数据库了解及部分掌握

sql注入问题

sql注入原因是由于特殊符号的组合会产生特殊的效果，实际生活中，尤其是在注册用户名时，会明显提示很多特殊符号不能使用，原因一样，设计到敏感数据部分，不要自己拼接，交给现成的方法拼接即可。

利用一些语法的特性 书写一些特点的语句实现固定的语法
MySQL利用的是MySQL的注释语法
select * from user where name='jason' -- jhsadklsajdkla' and password=''

select * from user where name='xxx' or 1=1 -- sakjdkljakldjasl' and password=''

当在登录过程中用户名输入mysql中的注释语句时，也会显示登录成功，以下是会产生注入问题的代码。

import pymysql

conn = pymysql.connect(
    host='127.0.0.1',
    port=3306,
    user='root',
    password='root',
    db='yee',
    charset='utf8',
    autocommit=True
)

cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
username = input('>>>:').strip()
password = input('>>>:').strip()
sql = "select * from userinfo where username='%s' and password='%s'" % (username, password)
# 不要手动拼接数据 先用%s占位 之后将需要拼接的数据直接交给execute方法即可
res = cursor.execute(sql)  # 自动识别sql里面的%s用后面元组里面的数据替换
if res:
    print("登录成功")
    print(cursor.fetchall())
else:
    print("用户名或密码错误")

 

以下是解决注入问题的代码

import pymysql

conn = pymysql.connect(
    host='127.0.0.1',
    port=3306,
    user='root',
    password='root',
    db='yee',
    charset='utf8',
    autocommit=True   #这里默认autocommit=False 也就是自动提交，增删改需要二次确定提交，所以当不填写这个，或者为false就需要在增删改的后面加入conn.commit()
)
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

username = input('username:').strip()
password = input('password:').strip()

sql = "select * from userinfo where username = %s and password = %s "     #注意这里%s不能加引号，不然会报错
print(sql)
res =cursor.execute(sql,(username,password))      #这里以元组的形式传入进行匹配，因为execute里有正则表达式，解决了这个问题
data = cursor.fetchall()
if data:
    print('登录成功')
else:
    print('用户名或密码错误')

 

pymysql的补充

关于增删改查进数据库中

只有查可以输出结果，而删改查的操作设计到数据的修改，需要二次确认，查不需要。

插入数据（连接与上述都一致，以下只写关键部分）

插入单挑数据：

#插入单条数据写法一：
sql = "insert into userinfo(username,password) values (%s,%s)"
rows = cursor.execute(sql,('qxx',456))
print(rows)
#插入单条数据写法二：
sql = "insert into userinfo(username,password) values ('qxx',456)"
rows = cursor.execute(sql)
print(rows)

插入多条数据：

#写法一：
sql = "insert into userinfo(username,password) values (%s,%s)"
rows = cursor.executemany(sql,[('qxx',456),('qxx',456)])    #将execute改为executemany
print(rows)

#写法二：
sql = "insert into userinfo(username,password) values ('qxx',456),('qxx',456)"
rows = cursor.execute(sql)
print(rows)

删除数据：

sql = 'delete from userinfo where id = 1'
rows = cursor.execute(sql)
print(rows)

修改数据：

sql = 'update userinfo set username="yyqx" where id = 2'
rows = cursor.execute(sql)
print(rows)

 

 视图（了解）

视图就是通过查询得到一张虚拟表，保存下开，下次可以直接使用，视图也是表。

使用视图的原因是：如果频繁操作一张由拼表来建立虚拟表，就可以建立视图，方便后续使用。

固定语法：

创建视图：create view 表名/视图名 as 虚拟表的查询sql语句

删除视图：drop view 视图表名

ps：在硬盘中，视图只有表结构，没有表数据文件；视图通常只是用来查询，尽量不要去修改视图中的数据。

开发过程中是否会使用视图？

不会，视图是mysql的功能，如果项目里面大量使用视图，也就意味着后期想要扩张某个功能时，这个功能恰好又需要对视图修改，意味着需要现在mysql这边将视图修改，再去应用程序中修改对应的sql语句，这就涉及到跨部门的问题，所以通常不会使用视图，而是通过重新修改sql语句来扩展功能。

触发器（了解）

触发器是在满足对某张表数据的增删改的情况下自动触发的功能称之为触发器。

触发器专门针对我们对某一张表数据的insert、删delete、改update的运行，这类行为一旦执行，就会触发触发器的执行，即自动运行另一段sql代码

 创建触发器语法：

create trigger 触发器的名字 before/after insert/update/delete on 表名 for each row

begin 
　　sql 代码
end
create trigger tri_after_insert_t2 before insert on 表名 for each row
begin
　　sql 代码
end

 delimiter

修改MySQL默认的语句结束符 只作用于当前窗口 

delimiter $$     将默认的结束符号由；改为$$

dilimiter ;    结束后再将结束符号改回；

案例

创建cmd表

sql = '''CREATE TABLE cmd (id INT PRIMARY KEY auto_increment,
                            USER CHAR (32),priv CHAR (10),
                            cmd CHAR (64),
                            sub_time datetime, #提交时间
                            success enum ('yes', 'no') #0代表执行失败
)'''
rows = cursor.execute(sql)
print(rows)

创建err表

sql = '''CREATE TABLE err (id INT PRIMARY KEY auto_increment,
                            err_cmd char (64),
                            err_time datetime
)'''
rows = cursor.execute(sql)
print(rows)

需求：当cmd表中的succes字段是no时，就触发触发器去执行err表

delimiter $$
create trigger tri_after_insert_cmd after insert on cmd 
for each row
begin
    if NEW.success = 'no' then
        insert into errlog(err_cmd,err_time) values(NEW.cmd,NEW.sub_time);
    end if;
end $$
delimiter ;

4. 在cmd表插入数据
INSERT INTO cmd (
    USER,
    priv,
    cmd,
    sub_time,
    success
)
VALUES
    ('jason','0755','ls -l /etc',NOW(),'yes'),
    ('jason','0755','cat /etc/passwd',NOW(),'no'),
    ('jason','0755','useradd xxx',NOW(),'no'),
    ('jason','0755','ps aux',NOW(),'yes');

 删除触发器
drop trigger tri_after_insert_cmd;

 

事务（掌握）

开启一个事务可以包含多条sql语句，这些sql语句要么同时成功，要么一个都不成功，称之为事务的原子性

事务的作用：保证了对数据操作的安全性

例如："还钱的例子"
egon用银行卡给我的支付宝转账1000
1 将egon银行卡账户的数据减1000块
2 将jason支付宝账户的数据加1000块
万一减钱的时候断网了，这边加钱没有成功

在操作多条数据的时候可能会出现某几条操作不成功的情况

事务的四大特征

四大特征：ACID

A 原子性：“一个事务是一个不可分割的单位，事务中包含的诸多操作，要么同时成功，要么同时失败”

C一致性：“事务必须是使数据库从一个一致性的状态变到另一个一致性的状态”

一致性跟原子性密切相关

I 隔离性：一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用到的数据对并发的其他事务是隔离的，并发执行的事务之间也是互相不干扰的。

D--持久性
"也叫永久性"
"一个事务一旦提交成功执行成功 那么它对数据库中数据的修改应该是永久的"
"接下来的其他操作或者故障不应该对其有任何的影响"

如何使用事务

1、开启事务

1. 开启事务
start transaction;
2. 回滚(回到事务执行之前的状态)
rollback;
3. 确认(确认之后就无法回滚了)
commit;

案例

 

模拟转账功能
建表
create table user(
    id int primary key auto_increment,
    name char(16),
    balance int
);
插入数据
insert into user(name,balance) values
('jason',1000),
('egon',1000),
('tank',1000);

1. 先开启事务
start transaction;
2. 多条sql语句
update user set balance=900 where name='lin';
update user set balance=1010 where name='rui';
update user set balance=1090 where name='cai';
3. 
可以回滚
rollback;
若是已经确认了就回滚不了
commit;


总结：
"""
当你想让多条sql语句保持一致性 要么同时成功要么同时失败 
你就应该考虑使用事务
"""

 

 

存储过程（了解）

存储概念就类似于python中的自定义函数

它的内部包含了一系列可以执行的sql语句，存储过程存放MySQL服务端中，你可以直接通过调用存储过程触发内部sql语句执行。

基本语法

create procedure 存储过程的名字(形参1,形参2,...)
begin
    sql代码
end
# 调用
call 存储过程的名字();

三种开发模型（第一种基本不用，一般都是第三种，出现效率问题再动手写sql）

第一种

应用程序:程序员写代码开发
MySQL:提前编写好存储过程，供应用程序调用

好处:开发效率提升了 执行效率也上去了
缺点:考虑到认为元素、跨部门沟通的问题 后续的存储过程的扩展性差

第二种

应用程序:程序员写代码开发之外 设计到数据库操作也自己动手写
优点:扩展性很高
缺点:
开发效率降低
编写sql语句太过繁琐 而且后续还需要考虑sql优化的问题

第三种

应用程序:只写程序代码 不写sql语句 基于别人写好的操作MySQL的python框架直接调用操作即可 ORM框架
优点:开发效率比上面两种情况都要高
缺点:语句的扩展性差 可能会出现效率低下的问题

存储过程具体演示

delimiter $$ # 把结束符号；改为$$
create procedure p1(
    in m int,  # 只进不出  m不能返回出去
    in n int,  # 只进不出 n不能返回出去
    out res int  # 该形参可以返回出去
)
begin
    select tname from teacher where tid>m and tid<n;
    set res=666;  # 将res变量修改 用来标识当前的存储过程代码确实执行了
end $$
delimiter ; # 把结束符号$$改为；

# 针对形参res 不能直接传数据 应该传一个变量名
# 定义变量
set @ret = 10;
# 查看变量对应的值
select @ret;

pymysql模块中调用存储过程

import pymysql

conn = pymysql.connect(
    host = '127.0.0.1',
    port = 3306,
    user = 'root',
    passwd = '123456',
    db = 'day48',
    charset = 'utf8',
    autocommit = True
)
cursor = conn.cursor(pymysql.cursors.DictCursor)
# 调用存储过程 传参
cursor.callproc('p1',(1,5,10))
"""
@_p1_0=1
@_p1_1=5
@_p1_2=10
"""
print(cursor.fetchall())
# cursor.execute('select @_p1_2;')
print(cursor.fetchall())

 

函数(了解)

跟存储过程是有区别的，存储过程是自定义函数，函数就类似于是内置函数

 以下例子就是将时分秒的时间格式转换为年-月的形式，然后对年月进行分组（用到的MySQL的内置函数date_format()，能使用代码操作的尽量使用代码操作，不要过多的使用MySQL函数）

CREATE TABLE blog (
    id INT PRIMARY KEY auto_increment,
    NAME CHAR (32),
    sub_time datetime
);

INSERT INTO blog (NAME, sub_time)
VALUES
    ('第1篇','2015-03-01 11:31:21'),
    ('第2篇','2015-03-11 16:31:21'),
    ('第3篇','2016-07-01 10:21:31'),
    ('第4篇','2016-07-22 09:23:21'),
    ('第5篇','2016-07-23 10:11:11'),
    ('第6篇','2016-07-25 11:21:31'),
    ('第7篇','2017-03-01 15:33:21'),
    ('第8篇','2017-03-01 17:32:21'),
    ('第9篇','2017-03-01 18:31:21');

select date_format(sub_time,'%Y-%m'),count(id) from blog group by date_format(sub_time,'%Y-%m');

流程控制（了解）

# if判断
delimiter //
CREATE PROCEDURE proc_if ()
BEGIN
    declare i int default 0;
    if i = 1 THEN
        SELECT 1;
    ELSEIF i = 2 THEN
        SELECT 2;
    ELSE
        SELECT 7;
    END IF;
END //
delimiter ;


# while循环
delimiter //
CREATE PROCEDURE proc_while ()
BEGIN
    DECLARE num INT ;
    SET num = 0 ;
    WHILE num < 10 DO
        SELECT
            num ;
        SET num = num + 1 ;
    END WHILE ;

索引（了解）

数据都是存在与硬盘上的，查询数据不可避免的需要进行IO操作
索引:就是一种数据结构，类似于书的目录。意味着以后在查询数据的应该先找目录再找数据，而不是一页一页的翻书，从而提升查询速度降低IO操作.
索引在MySQL中也叫“键”,是存储引擎用于快速查找记录的一种数据结构
* primary key
* unique key
* index key

注意foreign key不是用来加速查询用的，不在我们的而研究范围之内
上面的三种key，前面两种除了可以增加查询速度之外各自还具有约束条件，而最后一种index key没有任何的约束条件，只是用来帮助你快速查询数据.

本质:
通过不断的缩小想要的数据范围筛选出最终的结果，同时将随机事件(一页一页的翻)
变成顺序事件(先找目录、找数据)
也就是说有了索引机制，我们可以总是用一种固定的方式查找数据
一张表中可以有多个索引(多个目录)
索引虽然能够帮助你加快查询速度但是也有缺点
"""
1 当表中有大量数据存在的前提下 创建索引速度会很慢
2 在索引创建完毕之后 对表的查询性能会大幅度的提升 但是写的性能也会大幅度的降低
"""
索引不要随意的创建！！！

b+树

只有叶子节点存放的是真实的数据，其他节点存放的是虚拟数据，仅仅用来指路的，书的层级越高查询数据所需要经历的步骤就越多（树有几层查询相互据就需要几步）

一个磁盘块存储是有限制的
为什么建议你将id字段作为索引
占得空间少 一个磁盘块能够存储的数据多
那么久降低了树的高度 从而减少查询次数

聚焦索引(primary key)

聚集索引指的就是主键
Innodb 只有两个文件 直接将主键存放在了idb表中
MyIsam 三个文件 单独将索引存在一个文件

辅助索引(unique,index)

辅助索引:查询数据的时候不可能都是用id作为筛选条件，也可能会用name，password等字段信息，那么这个时候就无法利用到聚集索引的加速查询效果。就需要给其他字段建立索引，这些索引就叫辅助索引

特点：叶子结点存放的是辅助索引字段对应的那条记录的主键的值(比如:按照name字段创建索引，那么叶子节点存放的是:{name对应的值:name所在的那条记录的主键值})

覆盖索引

在辅助索引的叶子节点就已经拿到了需要的数据
# 覆盖索引:只在辅助索引的叶子节点中就已经找到了所有我们想要的数据
select name from user where name='jason';
# 非覆盖索引,虽然查询的时候命中了索引字段name，但是要查的是age字段，所以还需要利用主键才去查找
select age from user where name='jason';

测试索引

准备

#1. 准备表
create table s1(
    id int,
    name varchar(20),
    gender char(6),
    email varchar(50)
);
select id,name from t1;

#2. 创建存储过程，实现批量插入记录
delimiter $$ #声明存储过程的结束符号为$$
create procedure auto_insert1()
BEGIN
    declare i int default 1;
    while(i<100000)do
        insert into s1 values(i,'jason','male',concat('jason',i,'@oldboy'));
        set i=i+1;
    end while;
END$$ #$$结束
delimiter ; #重新声明分号为结束符号

#3. 查看存储过程
show create procedure auto_insert1\G 

#4. 调用存储过程
call auto_insert1();

# 表没有任何索引的情况下
select * from s1 where id=1000;
# 避免打印带来的时间损耗
select count(id) from s1 where id = 1000000;
select count(id) from s1 where id = 1;

# 给id做一个主键
alter table s1 add primary key(id);  # 速度很慢

select count(id) from s1 where id = 1;  # 速度相较于未建索引之前两者差着数量级
select count(id) from s1 where name = 'jason'  # 速度仍然很慢

10000000
1000


select * from s1 limit 0,1000;
select * from s1 limit 1000,1000;
select * from s1 limit 2000,1000;

select * from s1 limit 9999000,1000; # 把100000万条数据都查一遍，然后把前99000条丢掉，要最后1000
"""
范围问题
"""
# 并不是加了索引，以后查询的时候按照这个字段速度就一定快   
select count(id) from s1 where id > 1;  # 速度相较于id = 1慢了很多
select count(id) from s1 where id >1 and id < 3;
select count(id) from s1 where id > 1 and id < 10000;
select count(id) from s1 where id != 3;

alter table s1 drop primary key;  # 删除主键 单独再来研究name字段
select count(id) from s1 where name = 'jason';  # 又慢了

create index idx_name on s1(name);  # 给s1表的name字段创建索引
select count(id) from s1 where name = 'jason'  # 仍然很慢！！！
"""
再来看b+树的原理，数据需要区分度比较高，而我们这张表全是jason，根本无法区分
那这个树其实就建成了“一根棍子”
"""
select count(id) from s1 where name = 'xxx';  
# 这个会很快，我就是一根棍，第一个不匹配直接不需要再往下走了
select count(id) from s1 where name like 'xxx';
select count(id) from s1 where name like 'xxx%';
select count(id) from s1 where name like '%xxx';  # 慢 最左匹配特性

# 区分度低的字段不能建索引
drop index idx_name on s1;

# 给id字段建普通的索引
create index idx_id on s1(id);
select count(id) from s1 where id = 3;  # 快了
select count(id) from s1 where id*12 = 3;  # 慢了  索引的字段一定不要参与计算

drop index idx_id on s1;
select count(id) from s1 where name='jason' and gender = 'male' and id = 3 and email = 'xxx';
# 针对上面这种连续多个and的操作，mysql会从左到右先找区分度比较高的索引字段，先将整体范围降下来再去比较其他条件
create index idx_name on s1(name);
select count(id) from s1 where name='jason' and gender = 'male' and id = 3 and email = 'xxx';  # 并没有加速

drop index idx_name on s1;
# 给name，gender这种区分度不高的字段加上索引并不难加快查询速度

create index idx_id on s1(id);
select count(id) from s1 where name='jason' and gender = 'male' and id = 3 and email = 'xxx';  # 快了  先通过id已经讲数据快速锁定成了一条了
select count(id) from s1 where name='jason' and gender = 'male' and id > 3 and email = 'xxx';  # 慢了  基于id查出来的数据仍然很多，然后还要去比较其他字段

drop index idx_id on s1

create index idx_email on s1(email);
select count(id) from s1 where name='jason' and gender = 'male' and id > 3 and email = 'xxx';  # 快 通过email字段一剑封喉 

联合索引

select count(id) from s1 where name='jason' and gender = 'male' and id > 3 and email = 'xxx';  
# 如果上述四个字段区分度都很高，那给谁建都能加速查询
# 给email加然而不用email字段
select count(id) from s1 where name='jason' and gender = 'male' and id > 3; 
# 给name加然而不用name字段
select count(id) from s1 where gender = 'male' and id > 3; 
# 给gender加然而不用gender字段
select count(id) from s1 where id > 3; 

where id=1;
where name='';
where name='jason' and age=18;
where name='jason' and age=18 and gender ='male';

"""最左匹配原则"""
KEY `index_1` (`name`,`gender`,`email`) # 联合索引
where name = '';
where name='' and gender ='';
where name = and gender = and email=;


KEY `index_1` (`name`) # 
KEY `index_1` (`name`,`gender`) 
KEY `index_1` (`name`,`gender`,`email`)

# 带来的问题是所有的字段都建了索引然而都没有用到，还需要花费四次建立的时间
create index idx_all on s1(email,name,gender,id);  # 最左匹配原则，区分度高的往左放
select count(id) from s1 where name='jason' and gender = 'male' and id > 3 and email = 'xxx';  # 速度变快