一、MySQL存储过程和函数

1.存储过程和函数的概念

  • 存储过程和函数是事先经过编译并存储在数据库中的一段 SQL 语句的集合。

2.存储过程和函数的好处

  • 存储过程和函数可以重复使用，减轻开发人员的工作量。类似于java中方法可以多次调用
  • 减少网络流量，存储过程和函数位于服务器上，调用的时候只需要传递名称和参数即可
  • 减少数据在数据库和应用服务器之间的传输，可以提高数据处理的效率
  • 将一些业务逻辑在数据库层面来实现，可以减少代码层面的业务处理

3.存储过程和函数的区别

  • 函数必须有返回
  • 存储过程没有返回值

4.创建存储过程

  • 数据准备 ```sql — 创建db3数据库 CREATE DATABASE db3;

— 使用db3数据库 USE db3;

— 创建学生表 CREATE TABLE student( id INT PRIMARY KEY AUTO_INCREMENT, — 学生id NAME VARCHAR(20), — 学生姓名 age INT, — 学生年龄 gender VARCHAR(5), — 学生性别 score INT — 学生成绩 ); — 添加数据 INSERT INTO student VALUES (NULL,’张三’,23,’男’,95),(NULL,’李四’,24,’男’,98), (NULL,’王五’,25,’女’,100),(NULL,’赵六’,26,’女’,90);

— 按照性别进行分组，查询每组学生的总成绩。按照总成绩的升序排序 SELECT gender,SUM(score) getSum FROM student GROUP BY gender ORDER BY getSum ASC;

  2. - DELIMITER 分隔符
  3.    - 该关键字用来声明SQL语句的分隔符，告诉MySql该段命令已经结束！
  4.    - SQL语句默认的分隔符是分号，但是有的时候我们需要一条功能SQL语句中包含分号，但是并不作为结束标识。这个时候就可以使用DELIMITER来指定分隔符了！
  6. ```plsql
  7. -- 标准语法
  8. DELIMITER 分隔符
  • 创建存储过程语法
  1. -- 修改分隔符为$
  2. DELIMITER $
  4. -- 标准语法
  5. CREATE PROCEDURE 存储过程名称(参数...)
  6. BEGIN
  7.     sql语句;
  8. END$
  10. -- 修改分隔符为分号
  11. DELIMITER ;
  • 创建存储过程练习
  1. -- 修改分隔符为$
  2. DELIMITER $
  4. -- 创建存储过程，封装分组查询学生总成绩的sql语句
  5. CREATE PROCEDURE stu_group()
  6. BEGIN
  7.     SELECT gender,SUM(score) getSum FROM student GROUP BY gender ORDER BY getSum ASC;
  9. END$
  11. -- 修改分隔符为分号
  12. DELIMITER ;

5.调用存储过程

  • 调用存储过程语法
  1. -- 标准语法
  2. CALL 存储过程名称(实际参数);
  4. -- 调用stu_group存储过程
  5. CALL stu_group();

6.查看存储过程

  • 查看存储过程语法
  1. -- 查询数据库中所有的存储过程 标准语法
  2. SELECT * FROM mysql.proc WHERE db='数据库名称';

7.删除存储过程

  • 删除存储过程语法
  1. -- 标准语法
  2. DROP PROCEDURE [IF EXISTS] 存储过程名称;
  4. -- 删除stu_group存储过程
  5. DROP PROCEDURE stu_group;

8.存储过程语法

8.1存储过程语法介绍
  • 存储过程是可以进行编程的。意味着可以使用变量、表达式、条件控制语句、循环语句等，来完成比较复杂的功能。

8.2变量的使用
  • 定义变量
    • 标准语法
      • DECLARE 变量名 数据类型 [DEFAULT 默认值];
    • 注意： DECLARE定义的是局部变量，只能用在BEGIN END范围之内
  1. -- 定义一个int类型变量、并赋默认值为10
  2. DELIMITER $
  4. CREATE PROCEDURE pro_test1()
  5. BEGIN
  6.     DECLARE num INT DEFAULT 10;   -- 定义变量
  7.     SELECT num;                   -- 查询变量
  8. END$
  10. DELIMITER ;
  12. -- 调用pro_test1存储过程
  13. CALL pro_test1();
  • 变量的赋值方式一：
    • 语法：SET 变量名 = 变量值;
  1. -- 定义字符串类型变量，并赋值
  2. DELIMITER $
  4. CREATE PROCEDURE pro_test2()
  5. BEGIN
  6.     DECLARE NAME VARCHAR(10);   -- 定义变量
  7.     SET NAME = '张三';          -- 为变量赋值
  8.     SELECT NAME;                -- 查询变量
  9. END$
  11. DELIMITER ;
  13. -- 调用pro_test2存储过程
  14. CALL pro_test2();
  • 变量的赋值方式二：
    • 语法：SELECT 列名 INTO 变量名 FROM 表名 [WHERE 条件];
  1. -- 定义两个int变量，用于存储男女同学的总分数
  2. DELIMITER $
  4. CREATE PROCEDURE pro_test3()
  5. BEGIN
  6.     DECLARE men,women INT;  -- 定义变量
  7.     SELECT SUM(score) INTO men FROM student WHERE gender='男';    -- 计算男同学总分数赋值给men
  8.     SELECT SUM(score) INTO women FROM student WHERE gender='女';  -- 计算女同学总分数赋值给women
  9.     SELECT men,women;           -- 查询变量
  10. END$
  12. DELIMITER ;
  14. -- 调用pro_test3存储过程
  15. CALL pro_test3();

8.3if语句的使用
  • 标准语法
  1. IF 判断条件1 THEN 执行的sql语句1;
  2. [ELSEIF 判断条件2 THEN 执行的sql语句2;]
  3. ...
  4. [ELSE 执行的sql语句n;]
  5. END IF;
  • 案例演示
  1. /*
  2.     定义一个int变量，用于存储班级总成绩
  3.     定义一个varchar变量，用于存储分数描述
  4.     根据总成绩判断：
  5.         380分及以上    学习优秀
  6.         320 ~ 380     学习不错
  7.         320以下       学习一般
  8. */
  9. DELIMITER $
  11. CREATE PROCEDURE pro_test4()
  12. BEGIN
  13.     -- 定义总分数变量
  14.     DECLARE total INT;
  15.     -- 定义分数描述变量
  16.     DECLARE description VARCHAR(10);
  17.     -- 为总分数变量赋值
  18.     SELECT SUM(score) INTO total FROM student;
  19.     -- 判断总分数
  20.     IF total >= 380 THEN 
  21.         SET description = '学习优秀';
  22.     ELSEIF total >= 320 AND total < 380 THEN 
  23.         SET description = '学习不错';
  24.     ELSE 
  25.         SET description = '学习一般';
  26.     END IF;
  28.     -- 查询总成绩和描述信息
  29.     SELECT total,description;
  30. END$
  32. DELIMITER ;
  34. -- 调用pro_test4存储过程
  35. CALL pro_test4();

8.4参数的传递
  • 参数传递的语法
  1. DELIMITER $
  2. -- 标准语法
  3. CREATE PROCEDURE 存储过程名称([IN|OUT|INOUT] 参数名 数据类型)
  4. BEGIN
  5.     执行的sql语句;
  6. END$
  7. /*
  8.     IN:代表输入参数，需要由调用者传递实际数据。默认的
  9.     OUT:代表输出参数，该参数可以作为返回值
  10.     INOUT:代表既可以作为输入参数，也可以作为输出参数
  11. */
  12. DELIMITER ;
  • 输入参数
    • 标准语法 ```plsql DELIMITER $

— 标准语法 CREATE PROCEDURE 存储过程名称(IN 参数名 数据类型) BEGIN 执行的sql语句; END$

DELIMITER ;

  2.    - 案例演示
  3. ```plsql
  4. /*
  5.     输入总成绩变量，代表学生总成绩
  6.     定义一个varchar变量，用于存储分数描述
  7.     根据总成绩判断：
  8.         380分及以上  学习优秀
  9.         320 ~ 380    学习不错
  10.         320以下      学习一般
  11. */
  12. DELIMITER $
  14. CREATE PROCEDURE pro_test5(IN total INT)
  15. BEGIN
  16.     -- 定义分数描述变量
  17.     DECLARE description VARCHAR(10);
  18.     -- 判断总分数
  19.     IF total >= 380 THEN 
  20.         SET description = '学习优秀';
  21.     ELSEIF total >= 320 AND total < 380 THEN 
  22.         SET description = '学习不错';
  23.     ELSE 
  24.         SET description = '学习一般';
  25.     END IF;
  27.     -- 查询总成绩和描述信息
  28.     SELECT total,description;
  29. END$
  31. DELIMITER ;
  33. -- 调用pro_test5存储过程
  34. CALL pro_test5(390);
  35. CALL pro_test5((SELECT SUM(score) FROM student));
  • 输出参数
    • 标准语法 ```plsql DELIMITER $

— 标准语法 CREATE PROCEDURE 存储过程名称(OUT 参数名 数据类型) BEGIN 执行的sql语句; END$

DELIMITER ;

  2.    - 案例演示
  3. ```plsql
  4. /*
  5.     输入总成绩变量，代表学生总成绩
  6.     输出分数描述变量，代表学生总成绩的描述
  7.     根据总成绩判断：
  8.         380分及以上  学习优秀
  9.         320 ~ 380    学习不错
  10.         320以下      学习一般
  11. */
  12. DELIMITER $
  14. CREATE PROCEDURE pro_test6(IN total INT,OUT description VARCHAR(10))
  15. BEGIN
  16.     -- 判断总分数
  17.     IF total >= 380 THEN 
  18.         SET description = '学习优秀';
  19.     ELSEIF total >= 320 AND total < 380 THEN 
  20.         SET description = '学习不错';
  21.     ELSE 
  22.         SET description = '学习一般';
  23.     END IF;
  24. END$
  26. DELIMITER ;
  28. -- 调用pro_test6存储过程
  29. CALL pro_test6(310,@description);
  31. -- 查询总成绩描述
  32. SELECT @description;
  • 小知识 ```plsql @变量名: 这种变量要在变量名称前面加上“@”符号，叫做用户会话变量，代表整个会话过程他都是有作用的，这个类似于全局变量一样。

@@变量名: 这种在变量前加上 “@@” 符号, 叫做系统变量。

  2. <a name="721fc285"></a>
  3. ##### 8.5case语句的使用
  5. - 标准语法1
  7. ```plsql
  8. -- 标准语法
  9. CASE 表达式
  10. WHEN 值1 THEN 执行sql语句1;
  11. [WHEN 值2 THEN 执行sql语句2;]
  12. ...
  13. [ELSE 执行sql语句n;]
  14. END CASE;
  • 标准语法2
  1. -- 标准语法
  2. CASE
  3. WHEN 判断条件1 THEN 执行sql语句1;
  4. [WHEN 判断条件2 THEN 执行sql语句2;]
  5. ...
  6. [ELSE 执行sql语句n;]
  7. END CASE;
  • 案例演示
  1. /*
  2.     输入总成绩变量，代表学生总成绩
  3.     定义一个varchar变量，用于存储分数描述
  4.     根据总成绩判断：
  5.         380分及以上  学习优秀
  6.         320 ~ 380    学习不错
  7.         320以下      学习一般
  8. */
  9. DELIMITER $
  11. CREATE PROCEDURE pro_test7(IN total INT)
  12. BEGIN
  13.     -- 定义变量
  14.     DECLARE description VARCHAR(10);
  15.     -- 使用case判断
  16.     CASE
  17.     WHEN total >= 380 THEN
  18.         SET description = '学习优秀';
  19.     WHEN total >= 320 AND total < 380 THEN
  20.         SET description = '学习不错';
  21.     ELSE 
  22.         SET description = '学习一般';
  23.     END CASE;
  25.     -- 查询分数描述信息
  26.     SELECT description;
  27. END$
  29. DELIMITER ;
  31. -- 调用pro_test7存储过程
  32. CALL pro_test7(390);
  33. CALL pro_test7((SELECT SUM(score) FROM student));

8.6while循环
  • 标准语法
  1. -- 标准语法
  2. 初始化语句;
  3. WHILE 条件判断语句 DO
  4.     循环体语句;
  5.     条件控制语句;
  6. END WHILE;
  • 案例演示
  1. /*
  2.     计算1~100之间的偶数和
  3. */
  4. DELIMITER $
  6. CREATE PROCEDURE pro_test8()
  7. BEGIN
  8.     -- 定义求和变量
  9.     DECLARE result INT DEFAULT 0;
  10.     -- 定义初始化变量
  11.     DECLARE num INT DEFAULT 1;
  12.     -- while循环
  13.     WHILE num <= 100 DO
  14.         -- 偶数判断
  15.         IF num%2=0 THEN
  16.             SET result = result + num; -- 累加
  17.         END IF;
  19.         -- 让num+1
  20.         SET num = num + 1;         
  21.     END WHILE;
  23.     -- 查询求和结果
  24.     SELECT result;
  25. END$
  27. DELIMITER ;
  29. -- 调用pro_test8存储过程
  30. CALL pro_test8();

8.7repeat循环
  • 标准语法
  1. -- 标准语法
  2. 初始化语句;
  3. REPEAT
  4.     循环体语句;
  5.     条件控制语句;
  6.     UNTIL 条件判断语句
  7. END REPEAT;
  9. -- 注意：repeat循环是条件满足则停止。while循环是条件满足则执行
  • 案例演示
  1. /*
  2.     计算1~10之间的和
  3. */
  4. DELIMITER $
  6. CREATE PROCEDURE pro_test9()
  7. BEGIN
  8.     -- 定义求和变量
  9.     DECLARE result INT DEFAULT 0;
  10.     -- 定义初始化变量
  11.     DECLARE num INT DEFAULT 1;
  12.     -- repeat循环
  13.     REPEAT
  14.         -- 累加
  15.         SET result = result + num;
  16.         -- 让num+1
  17.         SET num = num + 1;
  19.         -- 停止循环
  20.         UNTIL num>10
  21.     END REPEAT;
  23.     -- 查询求和结果
  24.     SELECT result;
  25. END$
  27. DELIMITER ;
  29. -- 调用pro_test9存储过程
  30. CALL pro_test9();

8.8loop循环
  • 标准语法
  1. -- 标准语法
  2. 初始化语句;
  3. [循环名称:] LOOP
  4.     条件判断语句
  5.         [LEAVE 循环名称;]
  6.     循环体语句;
  7.     条件控制语句;
  8. END LOOP 循环名称;
  10. -- 注意：loop可以实现简单的循环，但是退出循环需要使用其他的语句来定义。我们可以使用leave语句完成！
  11. --      如果不加退出循环的语句，那么就变成了死循环。
  • 案例演示
  1. /*
  2.     计算1~10之间的和
  3. */
  4. DELIMITER $
  6. CREATE PROCEDURE pro_test10()
  7. BEGIN
  8.     -- 定义求和变量
  9.     DECLARE result INT DEFAULT 0;
  10.     -- 定义初始化变量
  11.     DECLARE num INT DEFAULT 1;
  12.     -- loop循环
  13.     l:LOOP
  14.         -- 条件成立，停止循环
  15.         IF num > 10 THEN
  16.             LEAVE l;
  17.         END IF;
  19.         -- 累加
  20.         SET result = result + num;
  21.         -- 让num+1
  22.         SET num = num + 1;
  23.     END LOOP l;
  25.     -- 查询求和结果
  26.     SELECT result;
  27. END$
  29. DELIMITER ;
  31. -- 调用pro_test10存储过程
  32. CALL pro_test10();

9.存储过程的总结

  • 存储过程是 事先经过编译并存储在数据库中的一段 SQL 语句的集合。可以在数据库层面做一些业务处理
  • 说白了存储过程其实就是将sql语句封装为方法，然后可以调用方法执行sql语句而已
  • 存储过程的好处
    • 安全
    • 高效
    • 复用性强

10.存储函数

  • 存储函数和存储过程是非常相似的，区别在于存储函数必须有返回值。
  • 标准语法
    • 创建存储函数 ```plsql DELIMITER $

— 标准语法 CREATE FUNCTION 函数名称([参数 数据类型]) RETURNS 返回值类型 BEGIN 执行的sql语句; RETURN 结果; END$

DELIMITER ;

  2.    - 调用存储函数
  3. ```plsql
  4. -- 标准语法
  5. SELECT 函数名称(实际参数);
  • 删除存储函数
    1. -- 标准语法
    2. DROP FUNCTION 函数名称;
  • 案例演示
  1. /*
  2.     定义存储函数，获取学生表中成绩大于95分的学生数量
  3. */
  4. DELIMITER $
  6. CREATE FUNCTION fun_test1()
  7. RETURNS INT
  8. BEGIN
  9.     -- 定义统计变量
  10.     DECLARE result INT;
  11.     -- 查询成绩大于95分的学生数量，给统计变量赋值
  12.     SELECT COUNT(*) INTO result FROM student WHERE score > 95;
  13.     -- 返回统计结果
  14.     RETURN result;
  15. END$
  17. DELIMITER ;
  19. -- 调用fun_test1存储函数
  20. SELECT fun_test1();

二、MySQL触发器

1.触发器的概念

  • 触发器是与表有关的数据库对象，可以在 insert、update、delete 之前或之后触发并执行触发器中定义的 SQL 语句。
  • 这种特性可以协助应用系统在数据库端确保数据的完整性、日志记录、数据校验等操作。
  • 使用别名 NEW 和 OLD 来引用触发器中发生变化的内容记录。 | 触发器类型 | OLD的含义 | NEW的含义 | | —- | —- | —- | | INSERT 型触发器 | 无 (因为插入前状态无数据) | NEW 表示将要或者已经新增的数据 | | UPDATE 型触发器 | OLD 表示修改之前的数据 | NEW 表示将要或已经修改后的数据 | | DELETE 型触发器 | OLD 表示将要或者已经删除的数据 | 无 (因为删除后状态无数据) |

2.创建触发器

  • 标准语法
  1. DELIMITER $
  3. CREATE TRIGGER 触发器名称
  4. BEFORE|AFTER INSERT|UPDATE|DELETE
  5. ON 表名
  6. [FOR EACH ROW]  -- 行级触发器
  7. BEGIN
  8.     触发器要执行的功能;
  9. END$
  11. DELIMITER ;

  • 触发器演示。通过触发器记录账户表的数据变更日志。包含：增加、修改、删除

    • 创建账户表

      1. -- 创建账户表account
      2. CREATE TABLE account(
      3. id INT PRIMARY KEY AUTO_INCREMENT,    -- 账户id
      4. NAME VARCHAR(20),                    -- 姓名
      5. money DOUBLE                        -- 余额
      6. );
      7. -- 添加数据
      8. INSERT INTO account VALUES (NULL,'张三',1000),(NULL,'李四',2000);

    • 创建日志表

      1. -- 创建日志表account_log
      2. CREATE TABLE account_log(
      3. id INT PRIMARY KEY AUTO_INCREMENT,    -- 日志id
      4. operation VARCHAR(20),                -- 操作类型 (insert update delete)
      5. operation_time DATETIME,            -- 操作时间
      6. operation_id INT,                    -- 操作表的id
      7. operation_params VARCHAR(200)       -- 操作参数
      8. );

    • 创建INSERT触发器

    • ‘插入后{id=1’,new.id,’,name=’,new.name,’,money=’,new.money,’}’ ```plsql — 创建INSERT触发器 DELIMITER $

CREATE TRIGGER account_insert AFTER INSERT ON account FOR EACH ROW BEGIN INSERT INTO account_log VALUES (NULL,’INSERT’,NOW(),new.id,CONCAT(‘插入后{id=’,new.id,’,name=’,new.name,’,money=’,new.money,’}’)); END$

DELIMITER ;

— 向account表添加记录 INSERT INTO account VALUES (NULL,’王五’,3000);

— 查询account表 SELECT * FROM account;

— 查询日志表 SELECT * FROM account_log;

  2.    - 创建UPDATE触发器
  3. ```plsql
  4. -- 创建UPDATE触发器
  5. DELIMITER $
  7. CREATE TRIGGER account_update
  8. AFTER UPDATE
  9. ON account
  10. FOR EACH ROW
  11. BEGIN
  12.     INSERT INTO account_log VALUES (NULL,'UPDATE',NOW(),new.id,CONCAT('修改前{id=',old.id,',name=',old.name,',money=',old.money,'}','修改后{id=',new.id,',name=',new.name,',money=',new.money,'}'));
  13. END$
  15. DELIMITER ;
  17. -- 修改account表
  18. UPDATE account SET money=3500 WHERE id=3;
  20. -- 查询account表
  21. SELECT * FROM account;
  23. -- 查询日志表
  24. SELECT * FROM account_log;
  • 创建DELETE触发器 ```plsql — 创建DELETE触发器 DELIMITER $

CREATE TRIGGER account_delete AFTER DELETE ON account FOR EACH ROW BEGIN INSERT INTO account_log VALUES (NULL,’DELETE’,NOW(),old.id,CONCAT(‘删除前{id=’,old.id,’,name=’,old.name,’,money=’,old.money,’}’)); END$

DELIMITER ;

— 删除account表数据 DELETE FROM account WHERE id=3;

— 查询account表 SELECT * FROM account;

— 查询日志表 SELECT * FROM account_log;

  2. <a name="ad43e598"></a>
  3. #### 3.查看触发器
  5. ```plsql
  6. -- 标准语法
  7. SHOW TRIGGERS;
  9. -- 查看触发器
  10. SHOW TRIGGERS;

4.删除触发器

  1. -- 标准语法
  2. DROP TRIGGER 触发器名称;
  4. -- 删除DELETE触发器
  5. DROP TRIGGER account_delete;

5.触发器的总结

  • 触发器是与表有关的数据库对象
  • 可以在 insert/update/delete 之前或之后，触发并执行触发器中定义的SQL语句
  • 触发器的这种特性可以协助应用在数据库端确保数据的完整性 、日志记录 、数据校验等操作
  • 使用别名 NEW 和 OLD 来引用触发器中发生变化的记录内容

三、MySQL事务

1.事务的概念

  • 事务：一条或多条 SQL 语句组成一个执行单元，其特点是这个单元要么同时成功要么同时失败。
  • 单元中的每条 SQL 语句都相互依赖，形成一个整体。
  • 如果某条 SQL 语句执行失败或者出现错误，那么整个单元就会撤回到事务最初的状态。
  • 如果单元中所有的 SQL 语句都执行成功，则事务就顺利执行。

2.事务的数据准备

  1. -- 创建db4数据库
  2. CREATE DATABASE db4;
  4. -- 使用db4数据库
  5. USE db4;
  7. -- 创建账户表
  8. CREATE TABLE account(
  9.     id INT PRIMARY KEY AUTO_INCREMENT,    -- 账户id
  10.     NAME VARCHAR(20),            -- 账户名称
  11.     money DOUBLE                -- 账户余额
  12. );
  13. -- 添加数据
  14. INSERT INTO account VALUES (NULL,'张三',1000),(NULL,'李四',1000);

3.未管理事务演示

  1. -- 张三给李四转账500元
  2. -- 1.张三账户-500
  3. UPDATE account SET money=money-500 WHERE NAME='张三';
  4. -- 2.李四账户+500
  5. 出错了...
  6. UPDATE account SET money=money+500 WHERE NAME='李四';
  8. -- 该场景下，这两条sql语句要么同时成功，要么同时失败。就需要被事务所管理！

4.管理事务演示

  • 操作事务的三个步骤
    1. 开启事务：记录回滚点，并通知服务器，将要执行一组操作，要么同时成功、要么同时失败
    2. 执行sql语句：执行具体的一条或多条sql语句
    3. 结束事务(提交|回滚)
      • 提交：没出现问题，数据进行更新
      • 回滚：出现问题，数据恢复到开启事务时的状态
  • 开启事务
  1. -- 标准语法
  2. START TRANSACTION;
  • 回滚事务
  1. -- 标准语法
  2. ROLLBACK;
  • 提交事务
  1. -- 标准语法
  2. COMMIT;
  • 管理事务演示
  1. -- 开启事务
  3. START TRANSACTION;
  5. -- 张三给李四转账500元
  6. -- 1.张三账户-500
  7. UPDATE account SET money=money-500 WHERE NAME='张三';
  8. -- 2.李四账户+500
  9. -- 出错了...
  10. UPDATE account SET money=money+500 WHERE NAME='李四';
  12. -- 回滚事务(出现问题)
  13. ROLLBACK;
  15. -- 提交事务(没出现问题)
  16. COMMIT;

5.事务的提交方式

  • 提交方式
    • 自动提交(MySQL默认为自动提交)
    • 手动提交

  • 修改提交方式

    • 查看提交方式

      1. -- 标准语法
      2. SELECT @@AUTOCOMMIT;  -- 1代表自动提交    0代表手动提交

    • 修改提交方式 ```plsql — 标准语法 SET @@AUTOCOMMIT=数字;

— 修改为手动提交 SET @@AUTOCOMMIT=0;

— 查看提交方式 SELECT @@AUTOCOMMIT;

  2. <a name="b379cfd7"></a>
  3. #### 6.事务的四大特征(ACID)
  5. - 原子性(atomicity)
  6.    - 原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响
  7. - 一致性(consistency)
  8.    - 一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态
  9.    - 拿转账来说，假设张三和李四两者的钱加起来一共是2000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是2000，这就是事务的一致性
  10. - 隔离性(isolcation)
  11.    - 隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离
  12. - 持久性(durability)
  13.    - 持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作
  15. <a name="2196c35b"></a>
  16. #### 7.事务的隔离级别
  18. - 隔离级别的概念
  19.    - 多个客户端操作时 ,各个客户端的事务之间应该是隔离的，相互独立的 , 不受影响的。
  20.    - 而如果多个事务操作同一批数据时，则需要设置不同的隔离级别 , 否则就会产生问题 。
  21.    - 我们先来了解一下四种隔离级别的名称 , 再来看看可能出现的问题
  22. - 四种隔离级别
  23. | 序号 | 名称 | 隔离级别 | 可能引发问题 |
  24. | --- | --- | --- | --- |
  25. | 1 | **读未提交** | **read uncommitted** | 藏读、不可重复读、幻读 |
  26. | **2** | **读已提交** | **read committed** | 不可重复读、幻读 |
  27. | **3** | **可重复读** | **repeatable read** | 幻读 |
  28. | **4** | **串行化** | **serializable** | 无 |
  31. - 可能引发的问题
  32. | 问题 | 现象 |
  33. | --- | --- |
  34. | **脏读** | **是指在一个事务处理过程中读取了另一个未提交的事务中的数据 , 导致两次查询结果不一致** |
  35. | **不可重复读** | **是指在一个事务处理过程中读取了另一个事务中修改并已提交的数据, 导致两次查询结果不一致** |
  36. | **幻读** | **查询某记录是否存在，不存在，准备插入此记录，但执行 insert 时发现此记录已存在，无法插入。或不存在执行delete删除，却发现删除成功** |
  39. 事务A修改了数据，但是还没有提交，结果事务B确读到了事务A修改的数据。
  41. 事务A修改了数据，但是已经提交了，结果事务B确读到了事务A修改的数据。
  43. - 查询数据库隔离级别
  45. ```plsql
  46. -- 标准语法
  47. SELECT @@TX_ISOLATION;
  • 修改数据库隔离级别
  1. -- 标准语法
  2. SET GLOBAL TRANSACTION ISOLATION LEVEL 级别字符串;
  4. -- 修改数据库隔离级别为read uncommitted
  5. SET GLOBAL TRANSACTION ISOLATION LEVEL read uncommitted;
  7. -- 查看隔离级别
  8. SELECT @@TX_ISOLATION;   -- 修改后需要断开连接重新开

8.事务隔离级别演示

  • 脏读的问题
    • 窗口1 ```plsql — 查询账户表 select * from account;

— 设置隔离级别为read uncommitted set global transaction isolation level read uncommitted;

— 开启事务 start transaction;

— 转账 update account set money = money - 500 where id = 1; update account set money = money + 500 where id = 2;

— 窗口2查询转账结果 ,出现脏读(查询到其他事务未提交的数据)

— 窗口2查看转账结果后，执行回滚 rollback;

  2.    - 窗口2
  3. ```plsql
  4. -- 查询隔离级别
  5. select @@tx_isolation;
  7. -- 开启事务
  8. start transaction;
  10. -- 查询账户表
  11. select * from account;
  • 问题：事务的隔离级别定位为：read uncommitted。此时，读到了其他事物未提交的数据—藏读
    • 解决脏读的问题和演示不可重复读的问题
  • 窗口1 ```plsql — 设置隔离级别为read committed set global transaction isolation level read committed;

— 开启事务 start transaction;

— 转账 update account set money = money - 500 where id = 1; update account set money = money + 500 where id = 2;

— 窗口2查看转账结果，并没有发生变化(脏读问题被解决了)

— 执行提交事务。 commit;

— 窗口2查看转账结果，数据发生了变化(出现了不可重复读的问题，读取到其他事务已提交的数据)

  2.    - 窗口2
  3. ```plsql
  4. -- 查询隔离级别
  5. select @@tx_isolation;
  7. -- 开启事务
  8. start transaction;
  10. -- 查询账户表
  11. select * from account;
  • 解决藏读：事务的隔离级别定位为：read committed。
  • 问题：此时，读到了其他事物提交事务前的数据和未提交的数据。造成同一查询事务两次查询结果不一致—不可重复读
    • 解决不可重复读的问题
  • 窗口1 ```plsql — 设置隔离级别为repeatable read set global transaction isolation level repeatable read;

— 开启事务 start transaction;

— 转账 update account set money = money - 500 where id = 1; update account set money = money + 500 where id = 2;

— 窗口2查看转账结果，并没有发生变化

— 执行提交事务 commit;

— 这个时候窗口2只要还在上次事务中，看到的结果都是相同的。只有窗口2结束事务，才能看到变化(不可重复读的问题被解决)

  2.    - 窗口2
  3. ```plsql
  4. -- 查询隔离级别
  5. select @@tx_isolation;
  7. -- 开启事务
  8. start transaction;
  10. -- 查询账户表
  11. select * from account;
  13. -- 提交事务
  14. commit;
  16. -- 查询账户表
  17. select * from account;
  • 解决不可重复读：事务的隔离级别定位为：repeatable read。
  • 问题：查询某记录是否存在，不存在，准备插入此记录，但执行 insert 时发现此记录已存在，无法插入。或不存在执行delete删除，却发现删除成功—-幻读
    • 幻读的问题和解决
  • 窗口1 ```plsql — 设置隔离级别为repeatable read set global transaction isolation level repeatable read;

— 开启事务 start transaction;

— 添加一条记录 INSERT INTO account VALUES (3,’王五’,1500);

— 查询账户表，本窗口可以查看到id为3的结果 SELECT * FROM account;

— 提交事务 COMMIT;

  2.    - 窗口2
  3. ```plsql
  4. -- 查询隔离级别
  5. select @@tx_isolation;
  7. -- 开启事务
  8. start transaction;
  10. -- 查询账户表，查询不到新添加的id为3的记录
  11. select * from account;
  13. -- 添加id为3的一条数据，发现添加失败。出现了幻读
  14. INSERT INTO account VALUES (3,'王五',200);
  16. -- 提交事务
  17. COMMIT;
  19. -- 查询账户表，查询到了新添加的id为3的记录
  20. select * from account;
  • 解决幻读的问题 ```plsql / 窗口1 / — 设置隔离级别为serializable set global transaction isolation level serializable;

— 开启事务 start transaction;

— 添加一条记录 INSERT INTO account VALUES (4,’赵六’,1600);

— 查询账户表，本窗口可以查看到id为4的结果 SELECT * FROM account;

— 提交事务 COMMIT;

/ 窗口2 / — 查询隔离级别 select @@tx_isolation;

— 开启事务 start transaction;

— 查询账户表，发现查询语句无法执行，数据表被锁住！只有窗口1提交事务后，才可以继续操作 select * from account;

— 添加id为4的一条数据，发现已经存在了，就不会再添加了！幻读的问题被解决 INSERT INTO account VALUES (4,’测试’,200);

— 提交事务 COMMIT; ```

9.隔离级别总结

隔离级别 名称 出现脏读 出现不可重复读 出现幻读 数据库默认隔离级别
1 read uncommitted 读未提交 是 是 是
2 read committed 读已提交 否 是 是 Oracle / SQL Server
3 repeatable read 可重复读 否 否 是 MySQL
4 serializable 串行化 否 否 否

注意：隔离级别从小到大安全性越来越高，但是效率越来越低 , 所以不建议使用READ UNCOMMITTED 和 SERIALIZABLE 隔离级别.

10.事务的总结

  • 一条或多条 SQL 语句组成一个执行单元，其特点是这个单元要么同时成功要么同时失败。例如转账操作
  • 开启事务：start transaction;
  • 回滚事务：rollback;
  • 提交事务：commit;
  • 事务四大特征
    • 原子性
    • 持久性
    • 隔离性
    • 一致性
  • 事务的隔离级别
    • read uncommitted(读未提交)
    • read committed (读已提交)
    • repeatable read (可重复读)
    • serializable (串行化)