MySQL笔记

NULL 不代表没有值，NULL 代表不确定值；
SQL命令：DDL(DATABASE define language)、DML(DATA MODIFY language)增删改、DQL(DATA QUERY LANGUAGE)查
MODIFY CHANGE 的区别：
modify修改字段的数据类型；
change修改字段名称；
7个查询命令：select(生成1个临时表)、 FROM(生成1个临时表)、 WHERE(生成1个临时表)、 GROUP BY(生成1/n个临时表)、
HAVING(生成0个临时表，销毁group by生成的临时表)、 ORDER BY(生成1个临时表)、 LIMIT(生成1个临时表)
执行优先级：from > WHERE > GROUP BY > HAVING > SELECT > ORDER BY > LIMIT
DQL的内聚函数：max()、 MIN()、 AVG()、 SUM()、 COUNT()
ORDER BY 后面可以使用字段名，也可以使用字段位置；字段位置从1开始
如：SELECT doc_no, use_work_hour FROM dispatch_list ORDER BY 2 desc;

WHERE HAVING 的区别：
WHERE 操作单位是行，会生成新的临时表，对from返回的临时表进行过滤；
HAVING 操作单位是临时表，不会生成新的临时表，对group by返回的临时表进行销毁；
通配符 _ % * :
_ 一个任意字符
% 任意长度的字符串
* 全部字段

多表查询：连接查询合并方案、联合查询合并方案
连接查询合并方案（水平连接） JOIN…on…
使用内连接过滤合法数据
SELECT * FROM dispatch_list JOIN man ON man.responsibility_man=dispatch_list.responsibility_man;
连接查询合并方案，使用外连接(确保“需要帮助表”的所有数据行都要进入到合法临时表)过滤合法数据
外连接：左外连接、右外连接；没有值的栏位用null显示 （例子：没有派工单的工号也显示出来）
左外连接： FROM 需要帮助表 LEFT JOIN 不需要帮助表 ON 条件
SELECT * FROM man LEFT JOIN dispatch_list ON man.responsibility_man=dispatch_list.responsibility_man;
右外连接： FROM 不需要帮助表 RIGHT JOIN 需要帮助表 ON 条件
SELECT * FROM dispatch_list RIGHT JOIN man ON man.responsibility_man=dispatch_list.responsibility_man;
=======================================================
联合查询合并方案（垂直合并）；两张临时表结构必须一致，生成临时表字段只能来自第一个临时表；
UNION ALL不会去重，UNION会去重；联合查询合并方案只用于行转列查询；
SELECT responsibility_man, responsibility_name FROM dispatch_list
UNION
SELECT responsibility_man, man_name FROM man;

子查询：独立子查询、依赖子查询（一般不使用）
例子：获取所用工时大于所有派工单平均工时的派工单；
SELECT doc_no, responsibility_man, use_work_hour, (SELECT AVG(use_work_hour) FROM dispatch_list) AS avg_hour
FROM dispatch_list WHERE use_work_hour>(SELECT AVG(use_work_hour) FROM dispatch_list);
独立子查询规则：（不需要帮助就可以执行）
1、独立子查询返回的结果相当于一个常量；
2、独立子查询在被帮助命令前执行一次；
3、在被帮助命令执行期间，独立子查询不会执行；
=======================================================
依赖子查询：必须得到被帮助命令提供服务才能正常执行；
例子：获取所用工时大于该人员平均工时的派工单；
SELECT t2.doc_no,t2.responsibility_man,t2.use_work_hour, (SELECT AVG(t1.use_work_hour) AS avg_hour FROM dispatch_list t1 WHERE t1.responsibility_man=t2.responsibility_man) AS avg_hour
FROM dispatch_list t2
WHERE t2.use_work_hour>(SELECT AVG(t1.use_work_hour) FROM dispatch_list t1 WHERE t1.responsibility_man=t2.responsibility_man)
ORDER BY t2.responsibility_man, avg_hour, use_work_hour DESC, doc_no;
依赖子查询规则：
1、依赖子查询根据接收参数不同，返回结果不同；
2、依赖子查询在被帮助的命令执行时被调用，会无限增加加载表文件的次数，严重影响效率；
3、在实际开发过程中禁止使用依赖子查询；可以使用连接查询、自关联查询替代；
用连接代替依赖子查询，效率更快；例子：
SELECT t1.doc_no, t1.responsibility_man, t1.use_work_hour, t2.avg_hour FROM dispatch_list t1 JOIN (
SELECT responsibility_man, AVG(use_work_hour) AS avg_hour FROM dispatch_list GROUP BY responsibility_man ) t2
ON t1.responsibility_man=t2.responsibility_man WHERE t1.use_work_hour>t2.avg_hour;
=======================================================
自关联查询：
1、是连接查询的一种特殊表现形式；
2、将同一张表分别加载到内存中两次，再进行合并；
3、从一张临时表读取数据，另一张临时表提供参考数据；
4、不是每张表都适合使用自关联查询；有隶属关系才适合；
例子：使用自关联查询获取所有责任人的审核人的所有派工单
SELECT t1.responsibility_man, t1.review_man, t2.responsibility_man, t2.doc_no, t2.assign_content FROM dispatch_list t1 JOIN dispatch_list t2
ON t1.review_man=t2.responsibility_man GROUP BY t2.doc_no, t2.responsibility_man ORDER BY t2.responsibility_man;

解释字段：对查询结果的解释分析（无解释，不查询）
在select执行之前，在临时表动态生成一个列；列中内容用于对临时表每一行数据进行解释分析；
解释数据来源：
1、来源于聚合函数
2、来源于独立子查询
3、来源于开发人员手动设置常量
4、来源于case…END语句

case…END 语句：目的是为临时表的每一行数据给出一个动态的分析结果；
1、case…END在select执行之前执行
2、case…END执行时遍历临时表的每一行数据，在遍历时为每一行数据提供一个动态解释内容；
3、case…END执行完毕时，生成解释数据作为一个独立的列出现在临时表
=======================================================
case…END 区间判断，类似于if() ELSE if() ELSE 格式
SELECT (case
when 区间判断 then ‘解释数据’
when 区间判断 then ‘解释数据’
ELSE … END) AS 列名 FROM TABLE
例子：
SELECT doc_no, use_work_hour, (SELECT AVG(use_work_hour) FROM dispatch_list) AS avg_hour, (case
when use_work_hour<(SELECT AVG(use_work_hour) FROM dispatch_list) then ‘小于平均工时’
when use_work_hour>(SELECT AVG(use_work_hour) FROM dispatch_list) then ‘大于平均工时’
ELSE ‘等于平均工时’ END ) AS 等级 FROM dispatch_list;
=======================================================
case…END 等值判断，类似于switch；格式：
SELECT (case 字段名称
when 值 then ‘解释数据’
when 值 then ‘解释数据’
ELSE … END) AS 列名 FROM TABLE
例子：
SELECT id, (case id
when 1 then ‘1’
when 2 then ‘2’
when 3 then ‘3’
ELSE ‘no’ END) AS mycase FROM man_work_list LIMIT 10;

行转列查询：同一行数据转换为同一列数据；使用联合合并方案【union】
原表：
SELECT t1.responsibility_name, t1.a_hour, t2.b_hour FROM
(SELECT responsibility_name, responsibility_man, SUM(use_hour) a_hour
FROM man_work_list WHERE doc_no=‘AA00261988’ GROUP BY responsibility_name) t1
JOIN (SELECT responsibility_name, responsibility_man, SUM(use_hour) b_hour
FROM man_work_list WHERE doc_no=‘AA00262267’ GROUP BY responsibility_name) t2
on t1.responsibility_man=t2.responsibility_man;
行转列查询后的结果：
SELECT responsibility_name, myno, a_hour ‘hour’ FROM (SELECT t1.responsibility_name, ‘a_hour’ AS myno, t1.a_hour FROM
(SELECT responsibility_name, responsibility_man, SUM(use_hour) a_hour
FROM man_work_list WHERE doc_no=‘AA00261988’ GROUP BY responsibility_name) t1
JOIN (SELECT responsibility_name, responsibility_man, SUM(use_hour) b_hour
FROM man_work_list WHERE doc_no=‘AA00262267’ GROUP BY responsibility_name) t2
on t1.responsibility_man=t2.responsibility_man) t11
UNION
SELECT responsibility_name, myno, b_hour ‘hour’ FROM (SELECT t1.responsibility_name, ‘b_hour’ AS myno, t2.b_hour FROM
(SELECT responsibility_name, responsibility_man, SUM(use_hour) a_hour
FROM man_work_list WHERE doc_no=‘AA00261988’ GROUP BY responsibility_name) t1
JOIN (SELECT responsibility_name, responsibility_man, SUM(use_hour) b_hour
FROM man_work_list WHERE doc_no=‘AA00262267’ GROUP BY responsibility_name) t2
on t1.responsibility_man=t2.responsibility_man) t22
ORDER BY responsibility_name;

列转行查询：同一列数据转换为同一行数据；
列转行必备条件：表里面的数据一定有隶属关系；
原表：
SELECT responsibility_name, doc_no, SUM(use_hour) AS myhour
FROM man_work_list
WHERE doc_no IN(‘AA00261988’, ‘AA00262267’)
GROUP BY doc_no, responsibility_name;
1、使用自关联查询，效率较低：从t1中取AA00261988的信息，从t2取AA00262267的信息
SELECT t1.responsibility_name, t1.myhour AS ‘AA00261988’, t2.myhour AS ‘AA00262267’ FROM (SELECT responsibility_name, doc_no, SUM(use_hour) AS myhour
FROM man_work_list
WHERE doc_no IN(‘AA00261988’, ‘AA00262267’)
GROUP BY doc_no, responsibility_name) t1 JOIN
(SELECT responsibility_name, doc_no, SUM(use_hour) AS myhour
FROM man_work_list
WHERE doc_no IN(‘AA00261988’, ‘AA00262267’)
GROUP BY doc_no, responsibility_name)t2
ON t1.responsibility_name!=t2.responsibility_name AND t1.doc_no=‘AA00261988’ AND t2.doc_no=‘AA00262267’;
=======================================================
2、分组之后通过case…end…实现，效率较高；MAX()的作用是防止获取到0的数据
SELECT responsibility_name,
MAX((case doc_no when ‘AA00261988’ then myhour ELSE 0 END)) AS ‘AA00261988’,
MAX((case doc_no when ‘AA00262267’ then myhour ELSE 0 END)) AS ‘AA00262267’
FROM ( SELECT responsibility_name, doc_no, SUM(use_hour) AS myhour
FROM man_work_list
WHERE doc_no IN(‘AA00261988’, ‘AA00262267’)
GROUP BY doc_no, responsibility_name ) t
GROUP BY responsibility_name;

MySQL 服务器管理规则
1、存储引擎：MySQL服务器提供表文件管理方案；
查看MySQL服务器存在的存储引擎：show ENGINES;
修改MySQL服务器默认的存储引擎：my.ini文件中设置default-STORAGE-engine=InnoDB的值；默认存储引擎为InnoDB；
查看表文件的存储引擎：show CREATE TABLE man_work_list;
修改表文件的存储引擎：alter TABLE 表名 engin=INNODB;
=======================================================
2、INNODB、MyISAM的区别：
MYISAM 使用3个文件存储信息：
xx.frm：存储字段信息
xx.myd：存储数据行信息
xx.myi：存储索引信息
主要作用：增加表文件的操作速度；但是不支持事务(即备份)管理；
事务在用户操作前会备份，允许用户撤销操作；
如果表文件操作以查询为主，建议采用MYISAM
=======================================================
INNODB 使用frm文件存储信息（字段、数据行、索引）
主要作用：增加表文件数据安全性，可以支持事务管理；
如果表文件操作以修改为主，建议采用INNODB

约束管理方案：确保字段内容符合实际要求；
1、非空约束not null：要求管理字段下不允许存储null值；
2、唯一性约束unique：要求当前字段内容不能出现重复值，但是允许出现多个null；
3、主键约束primary key：管理主键字段，确保主键字段内容不能出现重复值，也不能出现null；
4、外键约束foreign key：管理外键字段，要求外键字段值必须来自与一方表主键字段中已经存在的值；同时允许外键字段存在多个null
5、自定义约束

视图：
视图是MySQL服务器提供的一个内置管理对象；
视图对象内部采用键值对的形式存储；
视图中key存放一个查询语句，value存放查询语句对应的字段管理权（使用权）；
视图作用：
提高查询语句的复用性；
分配开发人员对表文件字段的使用权；

索引index，用于sql优化
1、索引是存在于硬盘的数组；存放索引字段的数据与对应行号；
2、数组有序的存放表文件中某个字段下所有数据以及数据所在行数；
3、如果表文件采用INNODB引擎管理，索引存储在frm文件；如果表文件采用MYISAM引擎管理，索引存储在myi文件；

索引作用：
减少遍历临时表中数据行次数，增加查询速度；如果where使用字段上设置了索引，此时mysql服务器使用btree算法对应索引中定位满足条件的数据行行数并返回给where；

索引操作：如果建表时字段添加了主键约束、外键约束、唯一性约束，mysql服务器会自动为该字段添加索引；
查看表文件已经存在的索引：show INDEX FROM 表名
创建索引：create INDEX 索引名 ON 表文件(字段)
删除索引：drop INDEX 索引名 FROM 表文件
索引可以增加查询速度，但同时增加、删除、修改的效率会降低；

执行计划：explain 查询语句
TYPE字段，指查询级别
ALL < INDEX < RANGE < ref < const
ALL:最慢查询速度，表示没有通过索引帮助定位数据行，实际上采用全表扫描来定位数据行；进行sql优化时避免出现all级别；
INDEX:进行sql优化时避免index级别；采用全表扫描来定位数据行，但是在select抓取数据时从索引中得到结果，对于查询速度有所帮助；帮助作用很小可以忽略不计；
RANGE:进行sql优化时达到的最低标准；采用索引提供数据行位置，同时一次性返回多个数据行；range级别并不稳定，如果通过索引返回行数达到总行数1/3，mysql服务器考虑到性能与消耗的关系，会放弃使用索引；
ref:进行sql优化时达到的最高标准，采用索引提供数据行位置，同时每次只能返回一行数据；
const:采用聚簇索引进行定位，是最快的查询级别；

聚簇索引：也是一个数组；每一个下标存放的数据不只是行号，还包含当前行的所有非主键字段的值；
非聚簇索引：当前索引所关联的字段是非主键字段；只返回行号，然后去临时表中获取信息；
聚簇索引：当前索引所关联的字段是主键字段；返回整行信息，无需去临时表获取信息，节省了IO流操作；

索引失效：
1、如果通过索引定位的行数达到了总行数1/3时，必然导致索引失效；
2、如果在索引字段进行数学运算，必然导致索引失效；
EXPLAIN SELECT * FROM man_work_list WHERE id=39492; type为const
EXPLAIN SELECT * FROM man_work_list WHERE id+10=39492; TYPE为all
3、如果在索引字段进行函数处理，必然导致索引失效；
4、前置模糊查询(‘aa%’)可以到达range级别，此时索引有效；但是后置模糊查询(‘%aa’)、包含模糊查询(‘%aa%’)一定会导致索引失效；
5、如果采用类型自动转换（如字符串转数字），必然导致索引失效；

事务：transaction
对于采用innodb管理的表文件，在进行数据修改（insert、delete、update）时，mysql服务器自动对当前表文件中数据进行一次备份，然后再进行操作；这个备份就是事务；
=======================================================
事务作用：在操作之后，如果需要反悔，可以通过事务覆盖表文件实现撤销操作，即回滚操作；增加数据安全性；
=======================================================
事务管理方式：
mysql服务器自动管理事务：如果当前DML命令无法正常执行，那么mysql服务器使用事务撤销本次操作；如果当前DML命令正常执行，mysql服务器销毁掉事务；（如果sql执行成功，无法回滚）
手动事务管理方式：要求mysql服务器将多个sql命令产生备份，交给同一个事务管理对象管理；操作完毕后由开发人员根据实际情况决定是否撤销；（如果sql执行成功，可以回滚）
事务格式：
START TRANSACTION;
SQL 1;
SQL 2;
…
ROLLBACK; 回滚、撤销
COMMIT; 提交，事务管理对象将本次所有备份销毁；提交后无法回滚；

事务使用原则（ACID）
A：原子性；只有来自同一个业务中sql命令才应该交给同一个管理对象进行管理；如撤销部门20，同时将部门20下的职员删除；
C：一致性：一个业务中只要有一个分支任务执行失败或反悔，此时就应该将事务中所有sql操作都视为无效；即定义何时使用回滚；
I：隔离性（即java多线程的可见性）：两个事务对于同一个表操作应该彼此相互影响；如事务1添加2行数据，事务2应该能感受到新数据；
D：持久性：在commit执行之后，无法通过rollback撤销操作；

java多线程的3大特征：
原子性：确保命令的执行步骤只有1步，保证线程安全；可以加锁保证线程安全
可见性：多线程操作同一个变量，如果变量改变需通知其他线程；可以使用volatile保证可见性；
顺序性：可以使用Synchronized保证顺序性；

数据类型：
CHAR VARCHAR 的区别：
CHAR:固定不可变字符串；查询字符串长度时字符串后面的空格自动删除掉，不计入数量；
固定：可以接收的字符个数是固定的，赋值时不能超过这个数量；
不可变：在磁盘中用于存储字符的空间是固定的；
VARCHAR:固定可变字符串；
固定：可以接收的字符个数是固定的，赋值时不能超过这个数量；
可变：根据实际接收字符个数来减少磁盘空间；

存储过程
存储过程是一组为了完成特定功能的sql语句集，经编译后存储在数据库中，用户通过指定存储过程名字并给定参数来调用它；
存储过程是一个可编程的函数，它在数据库中创建并保存。它可以由sql语句和一些特殊的控制结构组成。当希望在不同的应用程序或平台执行相同的函数，
或者封装特定功能时，存储过程是非常有用的。数据库的存储过程可以看做是对编程中面向对象方法的模拟，它允许控制数据的访问方式；

存储过程的优点：
1、存储过程增强了sql语言的功能和灵活性。存储过程可以用流程控制语句编写，有很强的灵活性，可以完成复杂的判断、运算；
2、存储过程允许标准组件是编程；存储过程被创建后，可以在程序中被多次调用，而不必重新编写该存储过程的sql语句。数据库专业人员可以随时对存储过程
进行修改，对应用程序源代码毫无影响；
3、存储过程能实现较快的执行速度。如果某一操作包含大量的sql代码或分别被多次运行，那么存储过程要比批处理的执行速度快很多。因为存储过程是预编译
的。在首次运行一个存储过程时查询，优化器对其进行分析优化，并且给出最终被存储在系统表中的执行计划。而批处理的sql语句在每次运行时都要进行编译
和优化，速度相对要慢一些。
4、存储过程能减少网络流量；针对同一个数据库对象的操作，如果这一操作所涉及的sql语句被组织成存储过程，那么当在客户计算机上调用该存储过程时，网
络中传送的只是该调用语句，降低了网络负载；
5、存储过程可被作为一种安全机制来充分利用。系统管理员通过执行某一存储过程的权限进行限制，能够实现相应的数据的访问权限的限制，避免了非授权用户
对数据的访问，保证了数据的安全。

存储过程格式
CREATE PROCEDURE 存储过程名 ([参数[, , , ]])
[特性…] 过程体
例子：
delimiter // – 指定存储过程结束符为//
CREATE PROCEDURE proc1(OUT s INT)
BEGIN
SELECT COUNT(*) INTO s FROM USER;-- 把查询结果赋值给out类型的参数s；通过out类型的参数把存储过程中的结果返回给调用环境；
END;
//
delimiter ; – 把sql语句结束分隔符还原成;

delimiter作用：
delimiter是分隔符的意思；因为MySQL默认以;为分隔符，如果我们没有声明分隔符，那么编译器会把存储过程当成sql语句进行处理，则存储过程的编译过程
会报错，所以要事先用delimiter关键字声明当前段分隔符，这样MySQL才会将;当做存储过程的代码，不会执行这些代码，用完了之后要把分隔符还原。
delimiter // 即把MySQL语句的结束分隔符改成了// 原来的分号就不起作用了；在结束语句的时候需要加上//才会执行；

MySQL存储过程参数有3种类型：
IN 输入参数，表示该参数的值必须在调用存储过程时指定，在存储过程中修改该参数的值不能被返回，为默认值；
OUT 输出参数，该值可在存储过程内部被改变，并可返回；
INOUT 输入输出参数，调用时指定，并且可被改变和返回；
例子1：
CREATE PROCEDURE proc2(P_IN INT) P_IN没有声明输入输出类型，则默认为in类型
BEGIN
SELECT P_IN; 查询P_IN值
SET P_IN = 1000; 重新设置P_IN值
SELECT P_IN;再次查询P_IN值
END;
调用存储过程：
SET @P_IN = 10;声明一个变量并赋值，声明变量是以@开头
CALL proc2(@P_IN);调用存储过程并传递参数
SELECT @P_IN;查询结果
=======================================================
例子2：
CREATE PROCEDURE proc3(OUT P_OUT INT) OUT和INOUT类型的参数必须要显示的声明
BEGIN
SELECT P_OUT; OUT类型不可把值带入过程，所以为null
SET P_OUT = 1000; 在存储过程中给out类型的参数重新赋值，通过out类型的参数把结果带回给调用环境；
SELECT P_OUT;再次查询P_OUT值
END;
SET @P_OUT = 10;
CALL proc3(@P_OUT);
SELECT @P_OUT;
=======================================================
例子3：
CREATE PROCEDURE proc4(INOUT P_IN_OUT INT) OUT INOUT 类型的参数必须要显示的声明
BEGIN
DECLARE a VARCHAR(50) DEFAULT “asd”; 在存储过程中使用变量；声明变量的语句必须写在begin END 之间
SELECT a; 查询变量值
SET a = “www”; 给变量重新赋值
SELECT a; 重新查询变量
SELECT P_IN_OUT; INOUT 类型的参数是可以把数据带入给过程的
SET P_IN_OUT = 1000; 在存储过程中给INOUT类型的参数重新赋值，通过INOUT类型的参数把结果带回给调用环境；
SELECT P_IN_OUT;再次查询P_OUT值
END;
SET @P_IN_OUT = 10;
CALL proc4(@P_IN_OUT);
SELECT @P_IN_OUT;

在客户端中使用用户变量：用户变量一般以@开头
方式1、
SELECT “bb” INTO @str;-- 定义用户变量str,并赋值为"bb"
SELECT @str;
=======================================================
方式2、
SET @str1=“cc”;
SELECT @str1;
=======================================================
方式3、
SET @str2=1+12;
SELECT @str2;

在存储过程中使用用户变量：
CREATE PROCEDURE proc5()
BEGIN
SELECT CONCAT(@mystr, “123”);
END;
调用存储过程
SET @mystr = “55”;
CALL proc5();

在存储过程中传递全局范围的用户变量：
CREATE PROCEDURE proc6()
BEGIN
SET @LAST_PROC = “proc6”;
END;
=======================================================
CREATE PROCEDURE proc7()
BEGIN
SELECT CONCAT(“LAST_PROC值是：”, @LAST_PROC);
END;
调用存储过程
CALL proc6();
CALL proc7();

管理存储过程：
查询数据库中的存储过程：SHOW PROCEDURE STATUS WHERE DB=“wf_work”;
查询存储过程的详细内容：SHOW CREATE PROCEDURE wf_work.proc7;
MySQL不提供对存储过程进行修改；如果要修改，必须先删除原存储过程，重新编写代码；或者创建一个新的存储过程；
删除存储过程：drop PROCEDURE if EXISTS proc7;

MySQL存储过程变量的范围：有效范围是在该存储过程之内；即begin END范围中
CREATE PROCEDURE proc8()
BEGIN
DECLARE x1 VARCHAR(20) DEFAULT “qq”; x1的有效范围是在该存储过程之内
BEGIN
DECLARE x1 VARCHAR(20) DEFAULT “zz”;
SELECT x1; zz 优先使用内部块的变量值
DECLARE x2 VARCHAR(20) DEFAULT “aa”;
END
SELECT x1; qq
SELECT x2; 无法访问x2的值，因为x2已经超出使用范围；
END;
CALL proc8();

在存储过程中使用流程控制语句
1、if… ELSE…
CREATE PROCEDURE proc9(IN P_IN INT)
BEGIN
DECLARE aa INT;
SET aa = P_IN+1;
if aa=100 then – 判断是否相等用=
INSERT INTO t1 VALUES(0);
END if;
if aa=1 then – 判断是否相等用=
INSERT INTO t1 VALUES(100);
else
INSERT INTO t1 VALUES(200);
END if;
END;
CALL proc9(0);
=======================================================
2、case语句
CREATE PROCEDURE proc10(IN P_IN INT)
BEGIN
DECLARE aa INT;
SET aa = P_IN+1;
case aa
when 1 then
INSERT INTO t1 VALUES(1);
when 2 then
INSERT INTO t1 VALUES(2);
ELSE
INSERT INTO t1 VALUES(3);
END case;
END;
CALL proc10(0);
=======================================================
3、while循环语句
CREATE PROCEDURE proc11()
BEGIN
DECLARE aa INT DEFAULT 0;
while aa<10 DO
INSERT INTO t1 VALUES(aa);
SET aa=aa+1;
END while;
END;
CALL proc11();
=======================================================
4、repeat… END repeat循环
CREATE PROCEDURE proc12()
BEGIN
DECLARE aa INT DEFAULT 0;
repeat
INSERT INTO t1 VALUES(aa);
SET aa=aa+1;
until aa>10 退出循环的语句，末尾没有分号
END repeat;
END;
CALL proc12();
=======================================================
5、loop…end loop 循环
CREATE PROCEDURE proc13()
BEGIN
DECLARE aa INT DEFAULT 0;
loop1:loop
INSERT INTO t1 VALUES(aa);
SET aa=aa+1;
if aa>10 then
LEVEL loop1; 退出循环
END if;
END loop;
END;
CALL proc13();