视图&&事务&&索引&&触发器&&流程控制

视图、事务、索引，触发器，流程控制。

视图：view

视图与真实表共享数据，视图和真实表的数据会相互映射，

视图的表结构只要存在真实表的数据只要存在，视图就可以使用。

数据依赖：单表emp

1）视图是存在内存中的临时表
2）视图的创建依赖select语句，所有就是select语句操作的结果形参的表
3）视图支持对数据的增删查改 ?
4）视图不允许对视图表的字段做修改
5）视图不仅支持创建，也支持更新与删除

语法:创建视图

mysql>: create view 视图名[(别名们)] as select 语句;
eg>: create view v1 as select dep, max(salary) from emp group by dep;

# 创建或替换视图
mysql>: create or replace 视图名[(别名们)] as select 语句;
mysql>: alter 视图名[(别名们)] as select 语句;
eg>: create or replace view v1(dep_name, max_salary) as select dep, max(salary) from emp group by dep;
eg>: alter view v1(name, salary) as select dep, max(salary) from emp group by dep;

# 删除视图
mysql>: drop view 视图名
eg>: drop view v1;

# 视图可以作为正常表完成连表查询
select name, dep_name, salary 
from emp join v1 
on emp.dep=v1.dep_name and emp.salary=v1.max_salary;

视图的增删改

# 前提：视图的增删改操作可以直接映射给真实表（本质就是对真实表进行操作）

# 视图可以完成增删改，增删改本质是直接对创建视图的真实表进行操作
create or replace view v2 as select id,name,age,salary from emp;
update v2 set salary=salary+1 where id=1;
delete from v2 where id=1;

create or replace view v3 as select * from emp;
insert into v3 values(1, 'yangsir', '男', 66, 1.11, '上海', '那噶的', '教职部');

# 总结：操作视图，会影响真实表，反之也会影响
update emp set salary=salary+1 where id=1;

事务

满足事物的四大特性就是事物。mysql语句自动启动事物，每一句都是事物的执行过程。

事务的四大特性
1.原子性：事务是一组不可分割的单位,要么同时成功,要么同时不成功
2.一致性：事物前后的数据完整性应该保持一致(数据库的完整性：如果数据库在某一时间点下，所有的数据都符合所有的约束，则称数据库为完整性的状态)
3.隔离性：事物的隔离性是指多个用户并发访问数据时，一个用户的事物不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离
4.持久性：持久性是指一个事物一旦被提交，它对数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

# 事务：通常一些业务需要多条sql参与，参与的sql会形参一个执行整体，该整体我们就称之为 事务
# 简而言之：事务 - 就是保护多条执行的sql语句
# 比如：转账就是一个事务：从一个用户将资金转出，再将资金转入到另一个用户

事务的使用：
start transaction; --开启事物,在这条语句之后的sql将处在同一事务,并不会立即修改数据库
commit;--提交事务,让这个事物中的sql立即执行数据的操作,
rollback;--回滚事务,取消这个事物,这个事物不会对数据库中的数据产生任何影响

事务的用户隔离级别:
数据库使用者可以控制数据库工作在哪个级别下,就可与防止不同的隔离性问题
read uncommitted --不做任何隔离,可能脏读,幻读
read committed --可以防止脏读,不能防止不可重复读,和幻读,
Repeatable read --可以防止脏读,不可重复读,不能防止幻读
Serializable --数据库运行在串行化实现,所有问题都没有,就是性能低

修改隔离级别:
select @@tx_isolation;--查询当前级别 
set[session|global] transaction isolation level ....;修改级别
实例:
set global transaction isolation level Repeatable read;
注：修改后重新连接服务器生效

what：事务是逻辑上的一组操作，要么都成功，要么都失败
why：很多时候一个数据操作，不是一个sql语句就完成的，可能有很多个sql语句，如果部分sql执行成功而部分sql执行失败将导致数据错乱
eg：转账 => 转入转出均成功，才能认为操作成功

# mysql中事务的执行
create table bank(
	id int,
    name varchar(16),
    money decimal(65, 2)
);
insert into bank values(1, 'Tom', 10), (2, "Bob", 10);

# 假设出现以下执行情况

# 没有事务支持情况下，Tom的钱就丢了
update bank set money=money-1 where name='Tom';
update bank set money=money+1 where name='ruakei';




# 将两条sql看做事务处理
# 开启事务
begin;
update bank set money=money-1 where name='Tom';
update bank set money=money+1 where name='ruakei';
# 确认无误，提交事务
commit;
# 确认有误，回滚
rollback;

索引

索引就是 键 - key

1）键 是添加给数据库表的 字段 的
2）给表创建 键 后，该表不仅会形参 表结构、表数据，还有 键的B+结构图
3）键的结构图是需要维护的，在数据完成增、删、改操作时，只要影响到有键的字段，结构图都要维护一次
所以创建键后一定会降低 增、删、改 的效率
4）键可以极大的加快查询速度(开发需求中，几乎业务都和查有关系)
5）建立键的方式：主键、外键、唯一键、index

import pymysql
from pymysql.cursors import DictCursor
conn = pymysql.connect(user='root', passwd='root', db='oldboy')
cursor = conn.cursor(DictCursor)

# 创建两张表
# sql1 = """create table a1(
#     id int primary key auto_increment,
#     x int,
#     y int
# )"""
# cursor.execute(sql1)
# sql2 = """create table a2(
#     id int primary key auto_increment,
#     x int,
#     y int,
#     index(x)###############索引，对x的索引，增加索引，提高查询率。
# )"""
# cursor.execute(sql2)

# 每个表插入5000条数据
# import random
# for i in range(1, 5001):
#     x = i
#     y = random.randint(1, 5000)
#     cursor.execute('insert into a1(x, y) values(%s, %s)', (x, y))
#     cursor.execute('insert into a2(x, y) values(%s, %s)', (x, y))
#
# conn.commit()

import time
# a1的x、a1的id、a2的x
b_time = time.time()
sql = 'select * from a1 where id=4975'
cursor.execute(sql)
e_time = time.time()
print(e_time - b_time)

b_time = time.time()
sql = 'select * from a1 where x=4975'
cursor.execute(sql)
e_time = time.time()
print(e_time - b_time)

b_time = time.time()
sql = 'select * from a2 where x=4975'
cursor.execute(sql)
e_time = time.time()
print(e_time - b_time)

触发器

what：在表发生数据更新时，会自动触发的功能称之为触发器
why：当一个表在发生数据更新时，需要去完成一些操作，可以为具体数据更新的方式添加触发器

'''


语法：
delimiter //
create trigger 触发器名 before|after insert|update|delete on 表名 for each row
begin 
    需要触发执行的sql代码们
end //
delimiter ;

# 触发器名: t1_before_insert_tri

注：delimiter是用来修改sql的语句结束标识符

删除触发器：drop trigger 触发器名;
'''

# cmd表
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代表执行失败
);
# 错误日志表
create table errlog (
    id int primary key auto_increment,
    err_cmd char(64),
    err_time datetime
);
# 创建触发器
delimiter //
create trigger trigger1 after insert on cmd for each row
begin
# new就是cmd当前插入的那条记录(对象)
if new.success = "no" then
	insert into errlog values(null, new.cmd, new.sub_time);
end if;
end //
delimiter ;

# 往表cmd中插入记录，触发触发器，根据IF的条件决定是否插入错误日志
insert into cmd(user, priv, cmd, sub_time, success) values
    ('egon', '0765', 'ls -l /etc', now(), 'yes'),
    ('jerry', '0852', 'cat /etc/passwd', now(), 'no'),
    ('kevin', '0867', 'useradd xxx', now(), 'no'),
    ('owen', '0912', 'ps aux', now(), 'yes');
# 查看cmd数据信息
select * from cmd;
# 查看错误日志表中的记录是否有自动插入
select * from errlog;

存储过程

what：用于完成指定功能的sql语句块，类似于Python中的函数
why：将能指定功能的sql语句块建立成存储过程，不仅将sql语句逻辑化了，更是功能化了，那我们要完成相同的事，只需要重复使用建立的存储过程，不就需要再重复书写sql语句了

总结: 存储过程可以让sql语句具有 复用性, 从而提高开发效率

变量的使用：
1.赋值变量：set @变量名 = 变量值
2.使用变量：@变量名 | select @变量名
3.删除变量：set @变量名 = null

三种开发方式：

1. 业务逻辑 + 存储过程：高执行与开发效率，低耦合 | 不易移植，人员成本高
2. 业务逻辑 + 原生sql：人员成本低 | 开发难度大
3. 业务逻辑 + ORM：高开发效率，对象化操作数据库，可移植 | 性能消耗加大，多表联查、复杂条件会复制化ORM

语法：
delimiter //
create procedure 存储过程名(
	输入输出类型1 参数名1 参数类型1(宽度), 
	... ,
	输入输出类型n 参数名n 参数类型n(宽度)
)
begin
sql语句块
end //
delimiter ;
注：
1.输入输出类型：in | out | inout
2.call 存储过程名(实参们)来调用存储过程

案例：
set @res = null; # 定义空值变量, 用来接收存储过程的执行结果
delimiter //
create procedure user_info(in b int, in l int, out res char(20))
begin
select * from emp limit b, l;
set res = 'success';
end //
delimiter ;
call user_info(2, 3, @res); # 调用存储过程, 传入相应的实参
select @res; # 查看存储过程的执行结果

存储过程的操作：
1.查看
select routine_name, routine_type from information_schema.routines where routine_schema='数据库名';

eg: select routine_name, routine_type from information_schema.routines where routine_schema='db2';

2.删除
drop procedure [if exists] 数据库名.存储过程名
'''

delimiter //
create procedure send_money( out p_return_code char(20) )
begin 
	# 异常处理
    declare exit handler for sqlexception 
    begin 
        # error 
        set p_return_code = '错误异常'; 
        rollback; 
    end; 
	# exit 也可以换成continue 表示发送异常时继续执行
    declare exit handler for sqlwarning 
    begin 
        # warning 
        set p_return_code = '警告异常'; 
        rollback; 
    end; 

    start transaction;
	update account set money = money - 1000 where id = 1;
	update account set money = moneys + 1000 where id = 2; # moneys字段导致异常
    commit; 

    # success 
    set p_return_code = '转账成功'; # 代表执行成功
end //
delimiter ;

# 在mysql中调用存储过程
set @res=null;
call send_money(@res);
select @res;

流程控制

• if语句的使用

第一种 if:
"""
if 条件 then
语句;
end if;
"""
第二种 if elseif
"""
if 条件  then
语句1;
elseif 条件 then
语句2;
else 语句3;
end if;
"""

案例:编写过程 实现 输入一个整数type 范围 1 - 2 输出 type=1 or type=2 or type=other;

delimiter //
create procedure showType(in type int,out result char(20))
begin
if type = 1 then 
set result = "type = 1";
elseif type = 2 then 
set result = "type = 2";
else 
set result = "type = other";
end if;
end //
delimiter ;

set @res=null;
call showType(100, @res);
select @res;

• CASE 语句

大体意思与Swtich一样的 你给我一个值 我对它进行选择 然后执行匹配上的语句
语法:

create procedure caseTest(in type int)
begin
CASE type 
when 1  then select "type = 1";
when 2  then select "type = 2";
else select "type = other";
end case;
end

• 定义变量

declare 变量名 类型 default 值;
例如: declare i int default 0;

• WHILE循环

循环输出10次hello mysql
create procedure showHello()
begin 
declare i int default 0;
while  i < 10 do
select "hello mysql";
set i  = i + 1;
end while;
end

• LOOP循环的

没有条件 需要自己定义结束语句
语法:

输出十次hello mysql;
create procedure showloop()
begin 
declare i int default 0;
aloop: LOOP
select "hello loop";
set i = i + 1;
if i > 9 then leave aloop;
end if;
end LOOP aloop;
end

• REPEAT循环

#类似do while
#输出10次hello repeat
create procedure showRepeat()
begin
declare i int default 0;
repeat
select "hello repeat";
set i = i + 1;
until i > 9
end repeat;
end

#输出0-100之间的奇数
create procedure showjishu()
begin
declare i int default 0;
aloop: loop
set i = i + 1;
if i >= 101 then leave aloop; end if;
if i % 2 = 0 then iterate aloop; end if;
select i;
end loop aloop;
end