[MySQL] 事务和视图

[1. 什么是事务](#1. 什么是事务)

[2. 事务的四个特征](#2. 事务的四个特征)

[2.1 原子性](#2.1 原子性)

[2.2 一致性](#2.2 一致性)

[2.3 持久性](#2.3 持久性)

[2.4 隔离性](#2.4 隔离性)

[2.4.1 脏读问题](#2.4.1 脏读问题)

[2.4.2 不可重复读问题](#2.4.2 不可重复读问题)

[2.4.3 幻读问题](#2.4.3 幻读问题)

[2.5 事务的使用](#2.5 事务的使用)

[2.5.1 创建事务](#2.5.1 创建事务)

[2.5.2 保存点](#2.5.2 保存点)

[2.6 数据库的隔离级别](#2.6 数据库的隔离级别)

[2.6.1 修改隔离级别](#2.6.1 修改隔离级别)

[2.6.2 查看隔离级别](#2.6.2 查看隔离级别)

[2.5.3 读未提交（read uncommitted）](#2.5.3 读未提交（read uncommitted）)

[2.5.4 读已提交（read committed）](#2.5.4 读已提交（read committed）)

[2.5.5 可重复读（repeatable read）](#2.5.5 可重复读（repeatable read）)

[2.5.6 串行化（serializable）](#2.5.6 串行化（serializable）)

[3. 视图](#3. 视图)

[3.1 什么是视图](#3.1 什么是视图)

[3.2 创建视图](#3.2 创建视图)

[3.3 修改视图](#3.3 修改视图)

[3.3.1 修改表](#3.3.1 修改表)

[3.3.2 修改视图](#3.3.2 修改视图)

[3.3.3 视图不可修改](#3.3.3 视图不可修改)

[3.4 删除视图](#3.4 删除视图)

1. 什么是事务

事务就是把多条SQL语句打包成一个整体，里面的sql语句要么全部执行成功，要么都不执行，这里的都不执行，不是说真没执行，而是发生了回滚操作。

比如说有两个人A和B，A有 1000， B有1000，

语句一：A给B转账500，

语句二：B接收转过来的500。

这两个sql语句需要都执行，不能中断，要成功都成功。

如果执行完语句一后，没有执行语句二就会出现回滚现象，执行回滚的SQL语句，返回到语句一执行前的状态。

回滚：

就是事务中的SQL语句执行一部分，后面没执行，此时MySQL会执行回滚的sql语句将数据恢复到该事务执行之前的状态。

如果执行事务执行一般断电了，还会发生回滚吗？

当然会，因为MySQL在执行事务的时候，会记录一个日志，来记录当前事务执行到那步了，当恢复电后再进入MySQL，MySQL会根据日志对之前执行的操作进行回滚，回滚完成后删除该日志，如果事务成功执行完也会删除该日志。

引入事务可以很好的解决原子性问题。

2. 事务的四个特征

2.1 原子性

原子性就是说事务在执行SQL语句时候，要么全部执行，要么都不执行，不存在部分执行，部分没有执行的情况，如果存在会触发回滚操作。

2.2 一致性

一致性是说事务在执行前和执行后的数据都要符合该业务的规则和约束条件。

比如说：银行转账业务中，余额在执行完事务后不能是负数等。

事务在执行前是符合一致性的，在执行一部分后中断，发生回滚回到事务执行开始，也是符合一致性的。

有时候，事务回滚到中间某个SQL语句，此时也有可能遵循一致性。

2.3 持久性

持久性是说事务对数据做出的修改，应该持久的生效，那么就应该写入到硬盘中，加上数据库本身存储数据也是存储在硬盘上的。

硬盘也有坏的风险，我们需要对关键数据进行备份。

2.4 隔离性

隔离性主要是谈到事务在并发情况下出现的问题：

2.4.1 脏读问题

事务1 对某个数据进行了修改，但是该事务还没结束，如果事务1发生回滚，事务2 对该数据进行访问，访问的是修改后的数据，但实际数据是没有修改的，此时读到的这个数据就是脏数据。

如何解决脏读问题：

我们需要约束事务1执行完之后，才允许事务2读取到修改后的值。

此时如果事务1没有执行完，事务2读到的数据就是修改前的数据。

2.4.2 不可重复读问题

事务1中多次读取某个值的时候，每次读取同一个数据的值都不一样，就是不可重复读。

同一个事务多次读取一个数据，得到的结果相同就是可重复读。

图中的事务1就存在不可重复读问题。

如何解决不可重复读问题：

我们需要约束，一个事务在进行读操作的时候，对该数据进行加锁，其他事务不能对该数据进行读和修改的操作。当这个事务对该数据执行完后，开锁。

而SQL内部处理原理是：事务在执行前会创建一个"一致性读视图"（快照）(就是事务启动前的数据状态），该事务内部都会参照这个图去执行语句，不受外部其他事务对数据操作的影响。

2.4.3 幻读问题

同一个事务中，在针对某次查询时候，前后两个查询结果不同。

在执行事务1中第一次查询时，有3条数据，再执行事务2，在执行事务1的第二条查询，有4条数据，这就是幻读问题。

如何解决幻读问题：

我们就需要服务器进行串行化处理数据，也就是一个事务一个事务执行，可以解决幻读问题。

2.5 事务的使用

2.5.1 创建事务

sql 复制代码

#开始一个事务
start transaction;
或者
begin;

#结束一个事务
commit;

#回滚当前事务
bollback;

2.5.2 保存点

保存点是我们在创建事务的时候设置的，可以在回滚的时候，指定保存点进行回滚。使用

bollback to 保存点名字，回滚到保存点。

例如：

sql 复制代码

create table student(id int primary key, name varchar(20), balance double);
insert into student values(1,'张三',1000), (2,'李四',1500);

#开始事务
begin;

select * from student;

update student set balance = balance + 100 where name = '张三';
update student set balance = balance - 100 where name = '李四';

select * from student;

#设置保存点
savepoint tmp1;

update student set balance = balance + 100 where name = '张三';
update student set balance = balance - 100 where name = '李四';

select * from student;

#回滚到保存点
rollback to tmp1;

select * from student;

#结束事务
commit;

2.6 数据库的隔离级别

MySQL中规定了四种隔离级别：

read uncommitted，读未提交，此时包含脏读，不可重复读，幻读问题。

read committed，读已提交，此时包含不可重复读，幻读问题。

repeatable read，可重复读，这种是数据库默认的级别，此时包含幻读问题。

serializable，串行化，这种就解决了所有的隔离性问题。

2.6.1 修改隔离级别

方法一：

通过SQL语句进行修改：

sql 复制代码

set [global | session] transaction isolation level  隔离级别 | 访问模式;

#隔离级别
read uncommintted 
read committed
repeatable read
serializable

#访问模式
read write #事务对数据进行读写
read only  #事务对数据只进行读，不能读写。

global：是对当前的连接以及后续连接服务器的客户端都生效。

session：只对当前连接服务器的客户端生效。

这种使用SQL语句修改的方式只是临时修改，重启MySQL就失效了。

方法二：

通过配置文件修改：

我们可以找到自己电脑下载的MySQL所在的文件：

右键文件找到属性，里面有一串地址如下：

"C:\Program Files\MySQL\MySQL Server 8.0\bin\mysql.exe" "--defaults-file=C:\ProgramData\MySQL\MySQL Server 8.0\my.ini" "-uroot" "-p" "--default-character-set=utf8mb4"

C:\ProgramData\MySQL\MySQL Server 8.0\my.ini ，这个文件位置就是当前我电脑上的MySQL的配置文件，在里面可以修改隔离等级。

2.6.2 查看隔离级别

我们还可以通过SQL语句查看数据库的隔离级别：

查看全局会话隔离级别：

sql 复制代码

select @@global.transaction_isolation;

查看当前会话的隔离级别：

sql 复制代码

select @@global.transaction_isolation;

2.5.3 读未提交（read uncommitted）

这种级别包含脏读问题，不可重复包含问题和幻读问题。

脏读问题：

我们创建第一个连接，SQL语句为，这里包含第一个事务：

sql 复制代码

create table student(id int primary key, name varchar(20), balance double);
insert into student values(1,'张三',1000), (2,'李四',1500);
select * from student;

#修改当前会话的隔离等级为读未完成
set session transaction isolation level read uncommitted;

#查询当前会话的隔离等级
select @@session.transaction_isolation;

#事务1
begin;#1

update student set balance = 2000 where id = 1;#1

commit;

创建第二个连接，SQL语句包含第二个事务：

sql 复制代码

#修改当前会话的隔离等级为读未完成
set session transaction isolation level read uncommitted;

#查询当前会话的隔离等级
select @@session.transaction_isolation;

#事务2
begin; #2

select * from student where id = 1; #2

commit; #2

此时两个连接的隔离级别是 read uncommitted，此时事务1的SQL语句执行前两行，事务2的SQL语句全部执行，事务2查询的结果是2000。此时产生脏读问题。当我们设置隔离等级为read committed就能解决脏读问题。

我们修改隔离等级为read uncommitted后，再进行上面的步骤，查询结果是1000，此时就解决了脏读问题。

2.5.4 读已提交（read committed）

该隔离等级解决了脏读问题，包含不可重复读问题和幻读问题。

不可重复读问题：

第一个连接包含事务1：

sql 复制代码

#事务1
begin; #1

select * from student where id = 1; #3

select * from student where id = 1; #5

commit; #6

第二个连接包含事务2和事务3：

sql 复制代码

#事务2
begin; #2

update student set balance = 2000 where id = 1; #2

commit; #2


#事务3
begin; #4

update student set balance = 3000 where id = 1; #4

commit; #4

此时两个连接的隔离级别是read committed，此时按照上面注释的执行顺序，事务1中的第一次查询结果是2000，第二次查询结果是 3000，此时包含不可重复读问题。

我们可以修改隔离等级为repeatable read ，此时再按照上面顺序执行，事务1第一次查询结果是2000，第二次查询结果是2000，解决了不可重复读问题。

2.5.5 可重复读（repeatable read）

该隔离等级解决了脏读问题，不可重复读问题，还包含着幻读问题。

幻读问题：

第一个连接包含事务1：

sql 复制代码

#事务1
begin; #1

select * from student; #1

select * from student; #3

commit; #4

第二个连接包含事务2：

sql 复制代码

#事务2
begin; #2

insert into student values(3,'王五',2000); #2
select * from student; #2

commit; #2

此时的隔离等级是 repeatable read，事务1第一次查询没有王五，在执行完事务2后再次查询也没有王五。

为什么此时没有出现幻读问题呢？

可重复读问题是在一个事务中多次读取某个数据，而该数据受到其他事务的修改而导致结果不一致（这是针对已有的数据进行修改）。

幻读问题是在一个事务中多次相同条件的查询，而结果因为其他事务的插入或者删除操作发生了修改导致不一致（这是针对新数据的插入）。

而MySQL底层解决不可重复读问题是利用一致性读视图（快照）来解决的，而其他事务的插入和删除操作不会影响快照的内容，产生的结果一致。

下面是产生幻读问题的语句：

第一个连接包含事务1：

sql 复制代码

#事务1
begin; #1

select * from student; #1

insert into student values(3,'王五',2000); #3

commit; #4

第二个连接包含事务2：

sql 复制代码

#事务2
begin; #2

insert into student values(3,'王五',2000); #2
select * from student; #2

commit; #2

此时先执行事务1中的查询，没有王五，再执行事务2后，此时再执行事务一的查询没有王五，但是在执行插入操作时候，会报错说明王五数据已经插入其中，因为在插入前，MySQL会查询该表是否有此元素，此时就产生幻读错误。

下面是事务1报错信息，这里事务2已经执行，表中已有元素事务1执行就会报错：

此时我们可以修改隔离级别为serializable，此时在按照上面执行的话，就不会存在幻读问题了。此时事务之间一个一个执行。

下面是事务2的报错，这里事务2等到事务1执行完后才执行，此时执行事务2就会报错：

2.5.6 串行化（serializable）

该隔离级别是解决了脏读问题，不可重复读问题和幻读问题。

隔离级别越高，执行效率越低，并发性越低，数据准确性越高。

3. 视图

3.1 什么是视图

视图就是一个虚假的表，不存在于硬盘上，根据其他表或者视图的查询结果作为数据生成的一张"类似于表"的数据集。

3.2 创建视图

create view 视图名字 as 查询语句;

这里的查询语句是指从其他的表或者视图中查询的结果。

我们先创建一个学生表：

sql 复制代码

create table student(id int primary key, name varchar(20), sno varchar(20), age int, gender varchar(10), class_id int);
insert into student values(1,'张三','1001',20,'男',1), (2,'李四','1002',20,'男',1), (3,'王五','1003',20,'男',2),(4,'周六','1004',20,'男',2);

创建一个视图：

sql 复制代码

create view student_class_id as select * from student where class_id = 1;
select * from student_class_id;

该视图查询出来结果包含的就是class_id=1的学生的数据。

我们在创建视图的时候可以给列起指定的名字：

sql 复制代码

create view student_class_id1 (student_id,student_name) as select id,name from student where class_id = 1;
select * from student_class_id1;

查询视图结果为：

3.3 修改视图

3.3.1 修改表

修改真实的表的数据，根据这个表创建的视图的数据也会被修改。

sql 复制代码

update student set age = 50 where name = '张三';
select * from student_class_id;

查询创建的视图，张三的年龄也被修改成50。

3.3.2 修改视图

修改视图的数据也会影响到表中的数据。

sql 复制代码

update student_class_id set age = 100 where name = '李四';
select * from student;

查询表中李四的年龄变成了100。

3.3.3 视图不可修改

有些情况创建的视图不能够修改：

创建视图的时候使用了聚合函数的视图。比如sum,avg等。
创建视图的时候使用了distinct，对查询结果进行了去重，此时修改不知道修改的是表中的那行数据。
创建视图的时候使用了 group by 或者 having，对查询结果进行了分组，此时视图一行数据包含表中多条数据，修改视图不知道修改表的那条数据。
创建视图的时候使用了union或者union all，合并的查询来自不同的表时候，不能确定修改视图的行对应那个表的哪个行。
创建视图的时候使用了子查询，简单的子查询可以修改视图，但是复杂的子查询，子查询的查询语句中包含聚合函数group by之类的不能修改视图。
创建视图的时候查询条件是一个表跟一个不可修改的视图进行关联查询。

3.4 删除视图

sql 复制代码

drop view student_class_id1;