MySQL(进阶篇2.0)

SQL优化

插入数据

insert

如果需要一次性往数据库表中插入多条记录，可以从以下三个方面进行优化

1、优化方案一

批量插入数据

insert into tb_test values(1, 'Tom'),(2,'Cat'),(3,'Jerry');

2、优化方案二

手动控制事务

start transaction;
insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry');
insert into tb_test values(4,'Tom'),(5,'Cat'),(6,'Jerry');
insert into tb_test values(7,'Tom'),(8,'Cat'),(9,'Jerry');
commit;

3、优化方案三

主键顺序插入，性能要高于乱序插入

原因：

1. 如果主键是顺序的，InnoDB会把每一次插入的记录存储在上一条记录的上面。当达到页的最大填充因子时，下一条记录会写入新的页中，一旦数据按照这种顺序的方式插入主键就会近似于被顺序的记录填满
2. 随机插入的情况，InnoDB无法简单的总是把新的记录插入到索引的最后，也就是说插入的位置很可能是现有数据的中间，这会导致性能恶化

• ​ 如果

大批量插入数据

如果一次性需要插入大批量数据（如：几百万的记录），使用insert语句插入性能较低，此时可以使用MySQL数据库提供的load指令进行插入。

可以执行如下指令，将数据脚本文件中的数据加载到表结构中：

-- 客户端连接服务器时，加上参数 --local-infile
mysql --local-infile -u root -p
-- 设置全局参数local_iinfile为1，开启从本地加载文件导入数据的开关
set global local_infile = 1;
-- 执行load指令将准备好的数据，加载到表结构中
load data local infile '/root/sql1.log' into table tb_user fields terminated by ',' lines terminated by '\n';

主键顺序插入性能高于乱序插入

示例：

1、创建表结构

CREATE TABLE `tb_user` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`username` VARCHAR(50) NOT NULL,
`password` VARCHAR(50) NOT NULL,
`name` VARCHAR(20) NOT NULL,
`birthday` DATE DEFAULT NULL,
`sex` CHAR(1) DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 ;

2、设置参数

-- 客户端连接服务器
mysql --local-infile -u root -p

-- 设置全局参数local_infile为1.开启从本地加载文件导入数据的开关
set global local_infile = 1;

3、load加载数据

load data local infile '/root/load_user_100w_sort.sql' into table tb_user fields terminated by ',' lines terminated by '\n';

在load时，主键顺序插入性能高于乱序插入

主键优化

主键顺序插入性能高于乱序插入原因：

数据组织方式

在InnoDB存储引擎中，表数据都是根据主键顺序组织存放的，这种存储方式的表成为索引组织表（index organized table IOT)

行数据，都是存储在聚集索引的叶子节点上的。

InnoDB的逻辑结构图：

在InnoDB引擎中，数据行是记录在逻辑结构Page页中的，而每一页的大小是固定的，默认是16k。那就意味着，一个页中所存储的行也是有限的，如果插入的数据行row在该页存储不小，将会存储到下一个页中，页与页之间通过指针连接

页分裂

页可以为空，也可以填充一半，也可以填充100%。每一页包含了2-N行数据（如果一行数据过大，会行溢出），根据主键排列

主键顺序插入效果

1、从磁盘中申请页，主键顺序插入

2、第一页没满，继续向第一页中插入

3、当第一个写满后，再写入第二页，也与也之间通过指针连接

4、当第二页写满了，再往第三页中写入

主键乱序插入效果

1、加入1#，2#页都已经写满，存放了如图所示的数据

2、此时再插入id为50的记录会怎么样？

此时索引结构的叶子节点是有顺序的。按照顺序，应该存储在47之后

但是47所在的页，已经写满了，存储不了50对应的数据，此时会开辟一个新的页3#

但是并不会直接将50存入3#页，而是会将1#页后的一半数据，移动到3#页，然后在3#页，插入50

移动数据，并插入id为50的数据之后，此时，这三个页之间的数据顺序是有问题的。1#的下一页应该是3#，3#的下一页是2#。所以此时需要重新 设置链表指针

上述的这种现象，称之为“页分裂”，是比较耗费性能的操作

页合并

目前表中已有数据的索引结构（叶子节点）如下：

当对已有数据进行删除时，具体的效果如下：
当删除一行记录时，实际上记录并没有被物理删除，只是记录被标记（flaged）为删除并且它的空间不允许被其他记录声明使用

继续删除2#的数据记录

当页中删除的记录达到MERGE_THRESHOLED（默认为页的50%），InnoDB会开始寻找最近的页（前或后）看看是否将两个页合并以优化空间使用

删除数据，并将页合并之后，再次插入新的数据21，则直接插入到3#页

这个里面发生的合并页的现象，就称为“页合并”

MERGE_THRESHOLD：合并页的阈值，可以自己设置，在创建表或和创建索引时指定

索引设计原则

• 满足业务需求的情况下，尽量降低主键的长度
• 插入数据时，尽量选择顺序插入，选择使用AUTO_INCREMENT自增主键
• 尽量不要使用UUID做主键或者是其他自然主键，如：身份证号
• 业务操作时，避免对主键的修改

Order by优化

MySQL的排序，有两种方式：
Using filesort：通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区sortbuffer中完成排序操作，所有不是通过索引直接返回排序结果的排序都叫FileSort排序

Using index：通过有序索引顺序扫描直接返回有序数据，这种情况即为using index，不需要额外排序，操作效率高

对于以上两种排序方式，Using index的性能高，而Using filesort的性能低，在优化排序操作时，尽量优化为Using index

测试：

数据准备

把之前测试时，为tb_user表所建立的部分索引直接删除掉

drop index idx_user_phone on tb_user;
drop index idx_user_phone_name on tb_user;
drop index idx_user_name on tb_user;

1、执行排序SQL

explain select id, age, phone from tb_user order by age;

explain select id,age,phone from tb_user order by age, phone;

由于age，phone都没有索引，所以此时再排序时，出现using filesort，排序性能较低

3、创建索引

create index idx_user_age_phone_aa on tb_user(age,phone);

4、创建索引后，根据age，phone进行升序排序

 explain select id,age,phone from tb_user order by age;

explain select id,age,phone from tb_user order by age,phone;

5、创建索引后，根据age，phone进行降序排序

explain select id,age,phone from tb_user order by age desc, phone desc;

注意：多个字段使用order by 时，按字段的顺序排优先级

也出现using index，但是此时Extra出现Backward index scan，这个代表反向扫描索引，因为在MySQL中创建的索引，默认索引的叶子节点是从小到大排序的，而此时查询排序时，是从大到小，所以，在扫描时就是反向扫描，就会出现Backward index scan。在MySQL8中支持降序索引，也可以创建降序索引

6、根据phone、age进行升序排序，phone在前，age在后

 explain select id,age,phone from tb_user order by phone,age;

排序时，也需要满足最左前缀法则，否则也会出现filesort。因为在创建索引时，age是第一个字段，phone是第二个字段，所以排序时，也应该按照这个顺序来，否则就会出现using filesort

7、根据age，phone进行一个升序，一个降序排序

explain select id,age,phone from tb_user order by age asc, phone desc;

因为创建索引时，如果未指定顺序，默认都是按照升序排序的，而查询时，一个升序，一个降序。此时就会出现using filesort

8、创建一个联合索引（age升序排序，phone降序排序）

create index idx_user_age_phone_ad on tb_user(age asc, phone desc);

9、再次执行如下SQL：

explain select id,age,phone from tb_user order by age asc, phone desc;

升序/降序联合索引结构图示：

由上述的测试，得出order by优化原则：

• 根据排序字段建立合适的索引，多字段排序时，也遵循最左前缀原则
• 尽量使用覆盖索引
• 多字段排序，一个升序一个降序，此时需要注意联合索引在创建时的规则（asc/desc)
• 如果不可避免地出现filesort，大数据量排序时，可以适当增大排序缓冲区大小sort_buffer_size(默认256k)

group by优化

先将tb_user表的索引全部删除

drop index idx_user_pro_age_sta on tb_user;
drop index idx_email_5 on tb_user;
drop index idx_user_age_phone_aa on tb_user;
drop index idx_user_age_phone_ad on tb_user;

执行如下sql

explain select profession , count(*) from tb_user group by profession;

然后，针对profession、age、status创建一个联合索引

create index idx_user_pro_age_sta on tb_user(profession,age,status);

再次执行上述相同的sql查看执行计划

explain select profession , count(*) from tb_user group by profession;

在执行如下的分组查询SQL，查看执行计划

explain select profession,count(*) from tb_user group by profession,age;

explain select age,count(*) from tb_user group by age;

如果仅仅根据age分组，就会出现Using tempory；而如果根据profession，age两个字段同时分组，则不会出现Using temporary，原因是对于分组操作，在联合索引中，也符合最左前缀法则

在分组操作中需要通过以下两点进行优化，提升性能：

• 在分组操作时，可以通过索引来提高效率
• 分组操作时，索引的使用也是满足最左前缀法则

limit优化

在数据量比较大时，如果进行limit分页查询，在查询时，越往后分页查询效率越低

因为当在进行分页查询时，如果执行limit 200000, 10，此时需要MySQL排序前2000010记录，仅仅返回200000-2000010的记录，其他记录丢弃，查询排序的代价非常大

explain select * from tb_user t, (select id from tb_user order by id limit 200000,10) a where t.id = a.id;

count优化

概述

在之前的测试中，如果数据量很大，在执行count操作时，是非常耗时的

• MyISAM引擎把一个表的总行数存在了磁盘上，因此执行count(*)的时候会直接返回这个数，效率很高，但是如果是待条件的count，MyISAM也慢
• InnoDB引擎的话，它执行count(*)的时候，需要把数据一行一行从引擎中读出来，然后累计

如果要大幅度提升InnoDB表的count效率，主要的优化思路：自己计数（可以借助于redis这样的数据库进行，但是如果是带条件的count有比较麻烦）

count用法

count()是一个聚合函数，对于返回的结果集，一行行的判断，如果count函数的参数不是null，累计值加1，否则不加，最后返回累计值

用法：count(*)、count(主键)、count(字段)、count(数字)

count用法	含义
count（主键）	InnoDB引擎会遍历整张表，把每一行的主键id都取出来，返回给服务层。服务层拿到主键后，直接按行进行累加（主键不可能为null）
count（字段）	没有not null约束：InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，服务层判断是否为null，不为null，计数累加。 有not null约束：InnoDB引擎会遍历整张表把每一行的字段都取出来，返回给服务层，直接按行进行累加
count（数字）	InnoDB引擎遍历整张表，但不取值。服务层对于返回的每一个行，放一个数字“1”进去，直接按行进行累加
count（*）	InnoDB引擎并不会把字段全部取出来，而是专门做了优化，不取值，服务层直接按行进行累加

按照效率排序的话，count(字段)

update优化

update语句执行时的注意事项

update course set name = 'javaEE' where id = 1;

当执行删除的SQL语句时，会锁定id为1这一行，然后事务提交色之后，行锁释放

当时当执行如下SQL：

update　counrse set name = 'springBoot' where name = 'php';

当开启多个事务，在执行上述的sql语句时，行锁升级成了表锁，导致该update语句的性能大大降低

InnoDB的行锁是针对索引加的锁，不是针对记录加的锁，并且该索引不能失效，否则会从行锁升级为表锁

存储/存储过程/触发器

视图

介绍

视图（view）是一种虚拟存在的表。视图中的数据并不在数据库中实际存在，行和列数据来自定义视图的查询中使用的表，并且是在使用视图时动态时动态生成

通俗的讲，视图只保存了查询的SQL逻辑，不保存查询结果。所以在创建视图的时候，主要的工作就是创建SQL查询语句上

语法

1、创建

CREATE [OR REPLACE] VIEW 视图名称[列名列表] AS SELECT语句 [WITH[CASCADE | LOCAL] CHECK OPTION]

2、查询

查看创建视图语句：SHOW CREATE VIEW 视图名称
查看视图数据：SELECT * FROM 视图名称 ……

3、修改

方式一：CREATE [OR REPLACE] VIEW 视图名称[列名列表] AS SELECT语句 [WITH | CASCADED | LOCAL] CHECK OPTION]
方式二：ALTER 视图名称[（列名列表）] AS SELECT语句 [with |CASCADED | LOCAL] CHECK OPTION]

4、删除

DROP VIEW [IF EXISTS] 视图名称 [, 视图名称]……

演示示例：

-- 创建视图
create or replace view stu_v_1 as select id, rolename from sys_role where id <= 10;
-- 查询视图
show create VIEW stu_v_1;
select * from stu_v_1;
select * from stu_v_1 where id < 3;
-- 修改视图
create or replace view stu_v_1 as select id,roleName,roleDesc from sys_role where id <= 10;
alter view stu_v_1 as SELECT id, roleName from sys_role where id <=3;
-- 删除视图
DROP view if EXISTS stu_v_1;

测试：

create or replace view stu_v_1 as select id,username from sys_user where id <= 5;
select * from stu_v_1;
insert into stu_v_1 values (4,'tom');
insert into stu_v_1 values(7,'jerry');

在执行上述sql语句时，id为4和7的数据可以成功插入，但是查询的时候，没有id为7的记录

这是因为在创建视图的时候，指定的条件为id<=5，id为17的数据是符合条件的，所以没有查询出来，但是这条数据已经插入到表中了。

检查选项

当使用WITH CHECK OPTION子句创建视图时，mysql会通过视图检查正在更改的每个行，如：插入、更新、删除，以使其符合视图的定义。MySQL允许基于另一个视图创建视图，他还会检查依赖视图中的规则以保持一致性。为了确定检查的范围，mysql提供了两个选项：CASCADED和LOCAL，默认值为CASCADED

1、CASCADED

级联

如：v2视图是基于v1视图的，如果在v2视图创建的时候指定了检查选项为cascaded，但是v1视图创建时未指定检查选项，则在执行检查的时候，不仅会检查v2，还会级联检查v2的关联视图v1.

2、LOCAL

本地

如：v2视图是基于v1的视图的，如果v2视图创建的时候指定了检查选项为local，但是v1视图的创建时未指定检查选项，则在执行检查时，只会检查v2，不会检查v2的关联视图v1

视图的更新

要是视图可更新，视图中的行与基础表中的行之间必须存在一对一的关系。如果视图包含以下任何一项，则该视图不可更新：

• 聚合函数或窗口函数（SUM()、MIN()、MAX()、COUNT()等）
• DISTINCT
• GROUOP BY
• HAVING
• UNION或者UNION ALL

示例：

create or replace view stu_v_count as select count(*) from sys_user;

上述的视图中，就只有一个单行单列的数据，如果对这个视图进行更新或插入的话，将会报错

insert into stu_v_count VALUES(10);

视图作用

1. 简单：

   视图不仅可以简化用户对数据的理解，也可以简化操作。那些经常使用的查询可以被定义为视图，从而使得用户不必为以后的操作每次指定全部的条件

2. 安全

   数据库可以授权，但不能授权到数据库特定行和特定列上。通过视图用户只能查询和修改他们所能见到的数据

3. 数据独立

   视图可以帮助用户屏蔽真实表结构变化带来的影响

案例

1、为了保证数据库的安全性，开发人员在操作tb_user表时，只能看到用户的基本字段，屏蔽手机号和邮箱两个字段

create view_tb_user_view as select id,name,profession,age,gender,status,createtime from tb_user;

2、查询每个学生所选修的课程（三张表联查），这个功能在很多业务中都有使用，为了简化操作，定义一个视图：

create view tb_stu_course_view as select s.name student_name , s.no student_no ,c.name course_name from student s, student_course sc , course c where s.id =sc.studentid and sc.courseid = c.id;

select * from tb_stu_course_view;

存储过程

介绍

存储过程是事先经过编译并存储在数据库中的一段SQL语句的集合，调用存储过程可以简化应用开发人员的很多工作，减少数据在数据库和应用服务器之间的传输，对于提高数据处理的效率是有好处的。存储过程思想上很简单，就是数据库SQL语言层面的代码封装与重用。

特点：

• 封装，复用：可以把某一业务SQL封装在存储过程中，需要用到的时候直接调用即可
• 可以接受参数，也可以返回数据：在存储过程中，可以传递参数，也可以接收返回值
• 减少网络交互，效率提升：如果涉及多条SQL，每执行一次都是一次网络传输。而如果封装在存储过程中，只需要网络交互一次可能就可以了

基本语法

1、创建

CREATE PROCEDURE 存储过程名称([参数列表])
BEGIN
	--SQL语句
END;

2、调用

CALL 名称 ([参数]);

3、查看

SELECT * FROM INFORMATION_SCHEMA.ROUTIMES WHERE ROUTINE_SCHEMA = 'xxx'; --查询指定数据库的存储过程及状态信息
SHOW CREATE PROCEDURE 存储过程名称; -- 查询某个存储过程的定义

4、删除

DROP PROCEDURE [ IF EXISTS ] 存储过程名称；

注意：

​ 在命令行中，执行创建存储过程的sql时，需要关键字delimiter指定sql语句的结束符

示例：

-- 存储过程基本语法
-- 创建
create procedure p1()
begin
    select count(*) from sys_user;
end;

-- 调用
call p1();

-- 查看
select * from information_schema.ROUTINES where routine_Schema = 'test';

show create PROCEDURE p1;

-- 删除
drop PROCEDURE if EXISTS p1;

变量

在MySQL中变量分为三种类型：系统变量、用户定义变量、局部变量

系统变量

系统变量是MySQL服务器提供的，不是用户定义的，属于服务器层面。分为全局变量(GLOBAL)、会话变量（SESSION）

1、查看系统变量

show [ session | global ] variables; -- 查看所有系统变量
show [ session | global ] variables like " "; -- 通过like模糊匹配方式查找变量
select @@[session | global ] 系统变量名; -- 查看指定变量的值

2、设置系统变量

set [session | global] 系统变量名 = 值;
set @@[session | global ]系统变量名 = 值;

注意：

​ 如果没有指定session/global，默认是session，会话变量

• mysql服务重新启动之后，所设置的全局参数会失效，要想不失效，可以在/etc/my.cnf中配置
  • 全局变量（global）：全局变量针对于所有的会话
  • 会话变量（session）：会话变量针对于单个会话，在另一个会话窗口就不生效了。

示例：

-- 查看系统变量
show session variables;

show session variables like 'auto%';
show global variables like 'auto%';

select @@global.autocommit;
select @@session.autocommit;

-- 设置系统变量
set session autocommit = 1;

insert into course(id, name) VALUES (6, 'ES');

set GLOBAL autocommit = 0;
select @@global.autocommit;

用户定义变量

用户定义变量是用户根据需求自己定义的变量，用户变量不用提前声明，在用的时候直接用"@变量名"使用就行，其作用域为当前连接

1、赋值

方式一：

set @va_name = expr [, @var_name = expr]....;
set @var_name := expr [, @var_name := expr] ...;

赋值的时候可以使用=，也可以使用:=.

方式二：

select @var_name := expr [, @var_name := expr] ...;
select 字段名 into @var_name from 表名;

2、使用

select @var_name；

注意：用户定义的变量无需对其进行声明或初始化，只不过获取到的值为null

示例：

-- 赋值
set @myname = 'demo';
set @myage := 10;
set @mygender := '男', @myhobby := 'java';
SELECT COUNT(*) into @mycount from tb_user;

-- 使用
SELECT @myname, @myage, @mygender, @myhobby;
select @mycolor, @mycount;
select @abc;

局部变量

局部变量是根据需要定义在局部生效的变量，访问之前，需要DECLARE声明。可用做存储过程内的局部变量和输入参数，局部变量的范围是在其内声明的BEGIN … END快。

1、声明

DECLARE 变量名 变量类型 [DEFAULT ...];

变量类型就是数据库字段类型：INT、BIGINT、CHAR、VARCHAR、DATE、TIME等

2、赋值

set 变量名 = 值;
set 变量名 := 值；
select 字段名 into 变量名 from 表名 ... ;

示例：

-- 声明局部变量 - declare
-- 赋值
create procedure p2()
begin
    declare stu_count int default 0;
    select count(*) into stu_count from student;
    select stu_count;
end;

call p2();

if

1、介绍

if用于条件判断，具体的语法结构为：

if 条件1 then
	……
elseif 条件2 then -- 可选
	……
else  		-- 可选
	……
end if；

在if条件判断的结构中，else if结构可以有多个，也可以没有。else结构可以有，也可以没有

2、示例

根据定义的分数score变量，判定当前分数对应的分数等级

• score >= 85分，等级为优秀
• score >= 60分 且 score < 85分，等级为及格
• score <= 60分，等级为不及格

create procedure p3()
begin
    declare score int default 58;
    declare result varchar(10);
    
    if score >= 85 then
        set result := '优秀';
    elseif score >= 60 then
        set result := '及格';
    else
        set result := '不及格';
    end if;
    select result;
end;

call p3();

参数

介绍

参数的类型，主要分为以下三种：in、out、inout.具体的含义如下：

类型	含义	备注
in	该类参数作为输入，也就是需要调用时传入值	默认
out	该类参数作为输出，也就是该参数可以作为返回值
inout	既可以作为输入参数，也可以作为输出参数

用法

create procedure 存储过程名称 ([in/out/inout 参数名 参数类型])
begin
	-- sql语句
end;

案例一

根据传入参数score，判定当前分数对应的分数等级，并返回。

• score>=85分，等级为优秀
• score>=60分，且score<85分，等级为及格
• score<60分，等级为不及格

create PROCEDURE p4(in score int, out result VARCHAR(10))
BEGIN
	IF score >= 85 THEN
			SET result := '优秀';
	ELSEIF score >= 60 THEN
			SET result := '及格';
	ELSE
			SET result := '不及格';
	end if;
END;

-- 定义用户变量 @result 来接收返回的数据，用户变量可以不用声明
call p4(19, @result);
select @result;

案例二

将传入的200分制的分数，进行换算，换算成百分制，然后返回

create procedure p5(INOUT score double)
BEGIN
	SET score := score * 0.5;
END;

SET @score := 198;
call p5(@score);
select @score;

case

介绍

case结构及作用，有两种语法格式：

语法1：

-- 含义：当case_value的值为when_value1时，执行statement_list1，当值为when_value2时，执行statement_list2，否则就执行statement_list
case case_value
	when when_value1 then statement_list1
	[when when_value2 then statement_list2]...
	[else statement_list]
end case;

语法2：

-- 含义：当条件search——condition1成立时，执行statement_list1，当条件search_condition2成立时，执行statement_list2，否则就执行statement_list
case
	when search_condition1 then statement_list1
	[when search_condition2 then statement_list2]...
	[else statement_list]
end case;

案例

根据传入的月份，判定月份所属的季节（要求采用case结构）

• 1-3月份，为第一季度
• 4-6月份，为第二季度
• 7-9月份，为第三季度
• 10-12月份，为第四季度

create procedure p6(in month int)
BEGIN
	declare result varchar(10);
	case
		when month >= 1 and month <= 3 THEN
				SET result := '第一季度';
		when month >= 4 and month <= 6 THEN
				SET result := '第二季度';
		when month >= 7 and month <= 9 THEN
				SET result := '第三季度';
		WHEN month >= 10 and month <= 12 THEN
				SET result := '第四季度';
		ELSE
				set result := '非法参数';
end case;

select concat('你输入的月份为：',month,'所属的季度为：',result);

END;

call p6(6);

注意：如果判定条件有多个，多个条件之间，可以使用and或or进行连接

while

介绍

while循环是有条件的循环控制语句。满足条件后，再执行循环体中的sql语句。具体语法为：

-- 先判定条件，如果条件为true，则执行逻辑，否则，不执行逻辑
while 条件 do
	sql逻辑...
end while;

案例

计算从1累加到n的值，n为传入的参数值

-- A.定义局部变量，记录累加之后的值
-- B.每循环一次，就会对n进行减1，如果n减到0，则退出循环
create procedure p7(in n int)
BEGIN
	declare total int DEFAULT 0;
	
	while n>0 DO
			SET total := total + n;
			set n := n - 1;
	END WHile;
	
	select total;
END;

call p7(100);

repeat

介绍

repeat是有条件的循环控制语句，当满足until声明的条件的时候，则退出循环。具体语法为：

-- 先执行一次逻辑，然后判断until条件是否满足，如果满足，则退出。如果不满足，则继续下一次循环
repeat
	SQL逻辑...
	until 条件
end repeat;

案例

计算从1累加到n的值，n为传入的参数值。（使用repeat实现）

-- A.定义局部变量，记录累加之后的值
-- B.每循环一次，就会对n进行-1，如果减到0，则退出循环
create procedure p8(in n int)
BEGIN
	declare total int DEFAULT 0;
	
	repeat
			set total := total + n;
			SET n := n - 1;
	UNTIL n <= 0
	end repeat;
	
	select total;
end;
call p8(10);
call p8(100);

loop

介绍

LOOP实现简单的循环，如果不在SQL逻辑中增加退出的循环条件，可以用其来实现简单的死循环

LOOP可以配合以下两个语句使用：

• LEAVE：配合循环使用，退出循环
• ITERATE：必须用在循环中，作用是跳过当前循环剩下的语句，直接进入下一次循环中

[begin_label:] loop
	sql逻辑...
end loop [end_label];

leave label;  -- 退出指定标记的循环体
iterate label; -- 直接进入下一次循环体

上述语法中出现的begin_label，end_label，label指的是自定义的标记

案例一

计算从1累加到n的值，n为传入的参数值

-- A.定义局部变量，记录累加之后的值
-- B.每循环一次，就会对n进行-1，如果n减到0，则退出循环 ---->leave xx
create procedure p9(in n int)
BEGIN
	declare total int DEFAULT 0;
	
	sum:loop
			IF n <= 0 THEN
					leave sum;
			end if;
			
			SET total := total + n;
			SET n := n - 1;
	end loop sum;
	
	select total;
end;

call p9(100);

案例二

计算从1到n之间的偶数累加的值，n为传入的参数值

-- A.定义局部变量，记录累加之后的值
-- B.每循环一次，就会对n进行-1，如果n减到0，则退出循环 ---> leave xx
-- C.如果每次累加的数据是奇数，则直接进入下一次循环---> iterate xx

create procedure p10(in n int)
BEGIN
	declare total int DEFAULT 0;
	
	sum:loop
			if n <= 0 THEN
					leave sum;
			end if;
			
			IF n%2 = 1 THEN
				SET n := n - 1;
				iterate sum;
			end if;
			
			SET total := total + n;
			SET n := n - 1;
			
	end loop sum;
	
	select total;
	
END;

call p10(100);

游标

介绍

游标（CURSOR）是用来存储查询结果集的数据类型，在存储过程和函数中可以使用游标对结果集进行循环的处理。游标的使用包括游标的声明、OPEN、FETCH和CLOSE，其语法分别如下：

1、声明游标

declare 游标名称 cursor for 查询语句;

2、打开游标

open 游标名称;

3、获取游标记录

fetch 游标名称 into 变量[, 变量];

4、关闭游标

close 游标名称;

案例

根据传入的参数uage，来查询用户表tb_user中，所有的用户年龄小于等于uage的用户姓名（name）和专业（profession），并将用户的姓名和专业插入到所创建的一张新表（id，name，profession）中。

tb_user表

-- 逻辑：
-- A.声明游标，存储查询结果集
-- B.准备：创建表结构
-- C.开启游标
-- D.获取游标中的记录
-- E.插入数据到新表中
-- F.关闭游标

create procedure p11(in uage int)
BEGIN 
		
		declare uname varchar(100);
		declare upro varchar(100);
		declare u_cursor cursor for select name,profession from tb_user where age <= uage;
		
		drop table if exists tb_user_pro;
		create table if not exists tb_user_pro(
				id int PRIMARY KEY auto_increment,
				name varchar(100),
				profession varchar(100)
		);
		
		open u_cursor;
		while true do 
				fetch u_cursor into uname, upro;
				insert into tb_user_pro values (null, uname, upro);
		end while;
		close u_cursor;
		
END;


call p11(40);

上述的存储过程，最终在调用的过程中，会报错，之所以报错是上面的while循环中，没有退出条件，当游标的数据集获取完毕之后，再次获取数据，就会报错，从而终止了程序的执行

tb_user_pro

条件处理程序

介绍

条件处理程序（Handler）可以用来定义在流程控制结构执行过程中遇到问题时相应的处理步骤。具体语法为：

declare handler_action handler for condition_value [, condition_value] ... statement;

注意：

• handler_action的取值：
  • continue：继续执行当前程序
  • exit：终止执行当前程序
• condition_value的取值：
  • sqlstate sqlstate_value：状态码，如 0200
  • sqlwarning：所有以01开头的sqlstate代码的简写
  • not found：所有以02开头的sqlstate代码的简写
  • sqlexception：所有没有被sqlwarning或not found捕获的sqlstate代码的简写

案例

根据传入的参数usage，来查询用户表tb_user中，所有用户年龄小于等于uage的用户姓名（name）和专业（profession），并将用户的姓名和专业插入到所创建的一张新表（id，name，profession）中。

1、通过sqlstate指定具体的状态码

-- 逻辑：
-- A.声明游标，存储查询结果集
-- B.准备：创建表结构
-- C.开启游标
-- D.获取游标中的记录
-- E.插入数据到新表中
-- F.关闭游标

create procedure p11(in uage int)
BEGIN 
		
		declare uname varchar(100);
		declare upro varchar(100);
		declare u_cursor cursor for select name,profession from tb_user where age <= uage;
		
		-- 声明条件处理程序，当sql语句执行抛出的状态码为02000时，将关闭游标u_cursor，并退出
		declare exit handler for sqlstate '02000' close u_cursor;
		
		drop table if exists tb_user_pro;
		create table if not exists tb_user_pro(
				id int PRIMARY KEY auto_increment,
				name varchar(100),
				profession varchar(100)
		);
		
		open u_cursor;
		while true do 
				fetch u_cursor into uname, upro;
				insert into tb_user_pro values (null, uname, upro);
		end while;
		close u_cursor;
		
END;


call p11(40);

2、通过sqlstate的代码简写方式not found

02开头的状态码，代码简写为not found

-- 逻辑：
-- A.声明游标，存储查询结果集
-- B.准备：创建表结构
-- C.开启游标
-- D.获取游标中的记录
-- E.插入数据到新表中
-- F.关闭游标

create procedure p11(in uage int)
BEGIN 
		
		declare uname varchar(100);
		declare upro varchar(100);
		declare u_cursor cursor for select name,profession from tb_user where age <= uage;
		
		-- 声明条件处理程序，当sql语句执行抛出的状态码为02开头时，将关闭游标u_cursor，并退出
		declare exit handler for not found close u_cursor;
		
		drop table if exists tb_user_pro;
		create table if not exists tb_user_pro(
				id int PRIMARY KEY auto_increment,
				name varchar(100),
				profession varchar(100)
		);
		
		open u_cursor;
		while true do 
				fetch u_cursor into uname, upro;
				insert into tb_user_pro values (null, uname, upro);
		end while;
		close u_cursor;
		
END;


call p11(40);

存储函数

介绍

存储函数是有返回值的存储过程，存储函数的参数只能是in类型的。具体语法如下：

create function 存储函数名称([参数列表])
returns type [characteristic ... ]
begin
	-- sql语句
	return ...;
end;

characteristic说明：

• deterministic：相同的输入参数总是产生相同的结果
• no sql：不包含sql语句
• read sql data：包含读取数据的语句，但不包含写入数据的语句

案例

计算从1累加到n的值，n为传入的参数值

create function fun1(n int)
returns INT DETERMINISTIC
BEGIN
		declare total int default 0;
		
		while n>0 DO
			set total := total + n;
			SET n:= n - 1;
		END while;
		
		return total;
end;

select fun1(5);

触发器

介绍

触发器是与表有关的数据库对象，指在insert/update/delete之前(before)或之后(after)，触发并执行触发器中定义的sql语句集合。触发器的这种特性可以协助应用在数据库端确保数据的完整性，日志记录，数据校验等操作

使用别名old和new来引用触发器中发生变化的记录内容，这与其它的数据库是相似的。现在触发器还只支持行级触发，不支持语句级触发

触发器类型	new和old
insert型触发器	new表示将要或者已经新增的数据
update型触发器	old表示修改之前的数据，new表示将要或已经修改后的数据
delete型触发器	old表示将要或者已经删除的数据

语法

创建

create trigger trigger_name
before/after insert/update/delete
on tb1_name for each row -- 行级触发器
begin
	trigger_stmt
end;

查看

show triggers;

删除

drop trigger [schema_name.]trigger_name; --如果没有指定schema_name，默认为当前数据库

案例

通过触发器记录tb_user表的数据变更日志，将变更日志插入到日志表user_log中，包含增加，删除，修改；

表结构准备

-- 准备工作：日志表user_logs
create table user_logs(
	id int(11) not null auto_increment,
	operation varchar(20) not null comment '操作类型,insert/update/delete',
	operate_time datetime not null comment '操作时间',
	operate_id int(11) not null comment '操作的id',
	operate_params varchar(500) comment '操作参数',
	primary key(id)
)engine=INNODB DEFAULT charset=utf8;

1、插入数据触发器

create trigger tb_user_insert_trigger
		after insert on tb_user for each ROW
BEGIN
	insert into user_logs(id, operation, operate_time, operate_id, operate_params)
		VALUES
			(null, 'insert', NOW(), new.id, concat('插入的数据内容为：id=',new.id, ',name=',new.name,
				', phone=', new.phone, ',email=', new.email, ', profession=', new.profession));
end;

测试

-- 查看
show triggers;

-- 插入数据到tb_user
insert into tb_user(id, name, phone, email, profession, age, gender, status,
createtime) VALUES (26,'三皇子','18809091212','[email protected]','软件工
程',23,'1','1',now());

2、修改数据触发器

create trigger tb_user_update_trigger
		after update on tb_user for each ROW
BEGIN
	insert into user_logs(id, operation, operate_time, operate_id, operate_params)
		VALUES
			(null, 'update', NOW(), new.id, concat('更新之前的内容为：id=',old.id, ',name=',old.name,
				', phone=', old.phone, ',email=', old.email, ', profession=', old.profession,'|更新之后的内容为：id=',new.id, ',name=',new.name,
				', phone=', new.phone, ',email=', new.email, ', profession=', new.profession));
end;

测试

-- 查看
show triggers;

-- 更新
update tb_user set profession = '会计' where id = 26;
update tb_user set profession = '会计' where id <= 5;

3、删除数据触发器

create trigger tb_user_delete_trigger
		after delete on tb_user for each ROW
BEGIN
	insert into user_logs(id, operation, operate_time, operate_id, operate_params)
		VALUES
			(null, 'delete', NOW(), old.id, concat('删除之前的内容为：id=',old.id, ',name=',old.name,
				', phone=', old.phone, ',email=', old.email, ', profession=', old.profession));
end;

-- 查看
show triggers;

-- 删除数据
delete from tb_user where id = 26;

​