标签：png 可见 max operation 循环结构 匹配 选择 标识符 创建
存储例程是存储程序的一种类型，本质上也是封装了一些可执行的语句，只不过它的调用方式是：需要手动去调用！存储例程又可以分为存储函数和存储过程。
存储函数其实就是一种函数，只不过在这个函数里可以执行命令语句而已。函数它可以把处理某个问题的过程封装起来，之后直接调用函数就可以去解决同样的问题了。MySQL 中定义存储函数的语句如下：
CREATE FUNCTION 存储函数名称([参数列表])
RETURNS 返回值类型
BEGIN
函数体内容
END
从这里可以看出，定义一个存储函数需要指定函数名称、参数列表、返回值类型以及函数体内容，如果该函数不需要参数，那参数列表可以被省略，函数体内容可以包括一条或多条语句，每条语句都要以分号 ; 结尾。里边的制表符和换行仅仅是为了好看，完全可以用空格代替。
mysql> delimiter $
mysql> create function avg_score(s varchar(100))
-> returns double
-> begin
-> return (select avg(score) from student_score where subject = s);
-> end $
Query OK, 0 rows affected (0.01 sec)
定义了一个名叫 avg_score 的函数，它接收一个 varchar(100) 类型的参数，声明的返回值类型是 double，需要注意的是，在 return 语句后边写了一个 select 语句，表明这个函数的最后返回结果就是根据这个查询语句产生的，也就是返回了指定科目的平均成绩。
自定义的函数和系统内置函数的使用方式是一样的，都是在函数名后加小括号 () 表示函数调用，有参数的函数调用可以把参数写到小括号里边。函数调用可以作为查询对象或者搜索条件，或者和别的操作数一起组成更复杂的表达式
mysql> select avg_score(‘母猪的产后护理‘);
+------------------------------------+
| avg_score(‘母猪的产后护理‘) |
+------------------------------------+
| 73 |
+------------------------------------+
1 row in set (0.01 sec)
mysql> select avg_score(‘论萨达姆的战争准备‘);
+------------------------------------------+
| avg_score(‘论萨达姆的战争准备‘) |
+------------------------------------------+
| 73.25 |
+------------------------------------------+
1 row in set (0.00 sec)
这样调用函数就比直接写两个查询语句简单多了
如果想查看已经定义了多少个存储函数，可以使用下边这个语句：
SHOW FUNCTION STATUS [LIKE 需要匹配的函数名]
比如这样：
mysql> show create function avg_score \G
*************************** 1. row ***************************
Function: avg_score
sql_mode: STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION
Create Function: CREATE DEFINER=`root`@`localhost` FUNCTION `avg_score`(s varchar(100)) RETURNS double
begin
return (select avg(score) from student_score where subject = s);
end
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: utf8_general_ci
1 row in set (0.00 sec)
如果想删除某个存储函数，使用这个语句：
DROP FUNCTION 函数名
比如删掉 avg_score 这个函数：
mysql> DROP FUNCTION avg_score;
Query OK, 0 rows affected (0.00 sec)
在函数体中使用变量前必须先声明这个变量，声明方式如下：
DECLARE 变量名 数据类型 [DEFAULT 默认值];
需要特别留心的是，函数体中的变量名不允许加 @ 前缀，这一点和定义变量的方式是截然不同的，特别注意一下。在声明了这个变量之后，才可以使用它：
mysql> delimiter $;
mysql> CREATE FUNCTION var_demo()
-> RETURNS INT
-> BEGIN
-> DECLARE c INT;
-> SET c = 5;
-> RETURN c;
-> END $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
这里定义了一个名叫 var_demo 而且不需要参数的函数，在函数体中声明了一个名称为 c 的 INT 类型变量，之后调用 SET 语句为这个变量赋值了整数 5 ，并且把变量 c 当作函数结果返回，调用一下这个函数：
mysql> SELECT var_demo();
+------------+
| var_demo() |
+------------+
| 5 |
+------------+
1 row in set (0.00 sec)
如果不对声明的变量赋值的话，它的默认值就是 NULL，当然也可以通过 DEFAULT 子句来显式的指定变量的默认值，比如这样：
mysql> delimiter $
mysql> CREATE FUNCTION var_default_demo()
-> RETURNS INT
-> BEGIN
-> DECLARE c INT DEFAULT 1;
-> RETURN c;
-> END $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
在新创建的这个 var_default_demo 函数中，声明了一个变量 c，并且指定了它的默认值为 1，然后看一下函数的调用结果：
mysql> SELECT var_default_demo();
+--------------------+
| var_default_demo() |
+--------------------+
| 1 |
+--------------------+
1 row in set (0.00 sec)
得到的结果是 1，说明了指定的变量默认值生效了。另外，特别需要注意一下，可以将某个查询语句的结果赋值给变量的情况，比如改写一下前边的 avg_score 函数：
CREATE FUNCTION avg_score(s VARCHAR(100))
RETURNS DOUBLE
BEGIN
DECLARE a DOUBLE;
SET a = (SELECT AVG(score) FROM student_score WHERE subject = s);
return a;
END
先把一个查询语句的结果赋值给了变量 a，然后再返回了这个变量。
在定义函数的时候，可以指定多个参数，每个参数都要指定对应的数据类型，就像这样：
参数名 数据类型
比如上边编写的这个 avg_score 函数：
CREATE FUNCTION avg_score(s VARCHAR(100))
RETURNS DOUBLE
BEGIN
RETURN (SELECT AVG(score) FROM student_score WHERE subject = s);
END
这个函数只需要一个类型为 VARCHAR(100) 参数，这里给这个参数起的名称是 s，需要注意的是，参数名不要和函数体语句中其他的变量名、命令语句的标识符冲突，如果把这个变量名命名为 subject，它就与下边用到 WHERE 子句中的列名冲突了，导致列名失效。
另外，函数参数不可以指定默认值，在调用函数的时候，必须显式的指定所有的参数，并且参数类型也一定要匹配，比方说在调用函数 avg_score 时，必须指定要查询的课程名，不然会报错的：
mysql> select avg_score();
ERROR 1318 (42000): Incorrect number of arguments for FUNCTION test.avg_score; expected 1, got 0
像其他的编程语言一样，在 MySQL 的函数体里也可以使用判断的语句，语法格式如下：
IF 布尔表达式 THEN
处理语句
[ELSEIF 布尔表达式 THEN
处理语句]
[ELSE
处理语句]
END IF;
需要注意的是，这里的处理语句可以是由多条语句构成的复合语句。举个例子：
mysql> delimiter $
mysql> CREATE FUNCTION condition_demo(i INT)
-> RETURNS VARCHAR(10)
-> BEGIN
-> DECLARE result VARCHAR(10);
-> IF i = 1 THEN
-> SET result = ‘结果是1‘;
-> ELSEIF i = 2 THEN
-> SET result = ‘结果是2‘;
-> ELSEIF i = 3 THEN
-> SET result = ‘结果是3‘;
-> ELSE
-> SET result = ‘非法参数‘;
-> END IF;
-> RETURN result;
-> END $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
现在调用一下这个函数：
mysql> SELECT condition_demo(2);
+-------------------+
| condition_demo(2) |
+-------------------+
| 结果是2 |
+-------------------+
1 row in set (0.00 sec)
mysql> SELECT condition_demo(5);
+-------------------+
| condition_demo(5) |
+-------------------+
| 非法参数 |
+-------------------+
1 row in set (0.00 sec)
除了判断语句，MySQL 还支持循环语句的编写，不过有 3 种形式的循环语句：
WHILE 布尔表达式 DO
循环语句
END WHILE;
这个语句的意思是：如果满足给定的表达式，则执行循环语句，否则退出循环。比如想定义一个从 1 到 n 这 n 个数的和（假设 n 大于 0），可以这么写：
mysql> delimiter $
mysql> CREATE FUNCTION sum_all(n INT UNSIGNED)
-> RETURNS INT
-> BEGIN
-> DECLARE result INT DEFAULT 0;
-> DECLARE i INT DEFAULT 1;
-> WHILE i <= n DO
-> SET result = result + i;
-> SET i = i + 1;
-> END WHILE;
-> RETURN result;
-> END $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
在函数 sum_all 中，接收一个 INT UNSIGNED 类型的参数，声明了两个 INT 类型的变量 i 和 result 。先测试一下这个函数：
mysql> SELECT sum_all(3);
+------------+
| sum_all(3) |
+------------+
| 6 |
+------------+
1 row in set (0.00 sec)
REPEAT 循环和 WHILE 循环差不多，只是形式上变了一下：
REPEAT
循环语句
UNTIL 布尔表达式 END REPEAT;
先执行循环语句，再判断布尔表达式是否成立，如果成立继续执行循环语句，否则退出循环。与 WHILE 循环不同的一点是：WHILE 循环先判断布尔表达式的值，再执行循环语句，REPEAT 循环先执行循环语句，再判断布尔表达式的值，所以至少执行一次循环语句，所以如果 sum_all 函数用 REPEAT 循环改写，可以写成这样：
CREATE FUNCTION sum_all(n INT UNSIGNED)
RETURNS INT
BEGIN
DECLARE result INT DEFAULT 0;
DECLARE i INT DEFAULT 1;
REPEAT
SET result = result + i;
SET i = i + 1;
UNTIL i <= n END REPEAT;
RETURN result;
END
这只是另一种形式的循环语句：
循环标记:LOOP
循环语句
LEAVE 循环标记;
END LOOP 循环标记;
在 LOOP 循环语句中，比较特别的是需要设置 循环标记 来标识一个循环，在循环体内依靠 LEAVE 循环标记的形式来中断某个循环，比方说可以把 sum_all 函数改写成这样：
CREATE FUNCTION sum_all(n INT UNSIGNED)
RETURNS INT
BEGIN
DECLARE result INT DEFAULT 0;
DECLARE i INT DEFAULT 1;
flag:LOOP
IF i > n THEN
LEAVE flag;
END IF;
SET result = result + i;
SET i = i + 1;
END LOOP flag;
RETURN result;
END
其中的 flag 就是一个 循环标记 ，在循环体内判断 i > n 成立的时候就调用 LEAVE flag 来跳出这个循环。
不论什么时候，对语句添加注释都是一件好事儿！注释不仅仅是帮助别人理解写的语句是什么意思，对于自己来说，可能隔了几天之后再看自己写的语句就不知道是什么意思了。在函数体内以 -- 开头的语句都算作注释语句，MySQL 服务器在执行语句的时候会忽略掉这些注释语句。
-- 函数名：sum_all
-- 参数：n = 从1累加到的数字
CREATE FUNCTION sum_all(n INT UNSIGNED) COMMENT ‘求1到n这n个数的和‘
RETURNS INT
BEGIN
-- 当前累加的和
DECLARE result INT DEFAULT 0;
-- 当前累加的数字
DECLARE i INT DEFAULT 1;
-- 若当前累加的数字不大于指定数字，则继续执行循环
WHILE i <= n DO
SET result = result + i;
SET i = i + 1;
END WHILE;
-- 返回累加的和
RETURN result;
END
除了 -- 开头的语句表示注释，我们还可以在函数参数后写 COMMENT 注释语句说明这个函数的作用。
存储函数和存储过程都属于存储例程，都是对某些语句的一个封装。存储函数侧重于执行这些语句并返回一个值，而存储过程更侧重于单纯的去执行这些语句。先看一下存储过程的定义语句：
CREATE PROCEDURE 存储过程名称([参数列表])
BEGIN
需要执行的语句
END
与存储函数最直观的不同点就是，存储过程的定义不需要声明返回值类型。为了更直观的理解，先定义一个存储过程看看：
mysql> delimiter $
mysql> CREATE PROCEDURE t1_operation(
-> m1_value INT,
-> n1_value CHAR(1)
-> )
-> BEGIN
-> SELECT * FROM t1;
-> INSERT INTO t1(m1, n1) VALUES(m1_value, n1_value);
-> SELECT * FROM t1;
-> END $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
这里建立了一个名叫 t1_operation 的存储过程，它接收两个参数，一个是 INT 类型的，一个是 CHAR(1) 类型的。这个存储过程做了 3 件事儿，一件是查询一下 t1 表中的数据，第二件是根据接收的参数来向 t1 表中插入一条语句，第三件是再次查询一下 t1 表中的数据。
存储函数执行语句并返回一个值，所以常用在表达式中。存储过程偏向于调用那些语句，并不能用在表达式中，需要显式的使用 CALL 语句来调用一个存储过程：
CALL 存储过程([参数列表]);
比方说调用一下 t1_operation 存储过程可以这么写：
mysql> CALL t1_operation(4, ‘d‘);
+------+------+
| m1 | n1 |
+------+------+
| 1 | a |
| 2 | b |
| 3 | c |
+------+------+
3 rows in set (0.00 sec)
+------+------+
| m1 | n1 |
+------+------+
| 1 | a |
| 2 | b |
| 3 | c |
| 4 | d |
+------+------+
4 rows in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
从执行结果中可以看到，存储过程在执行中产生的所有结果集，全部将会被显示到客户端。
只有查询语句才会产生结果集，更新语句是不产生结果集的，所以那条
INSERT语句所产生的输出没有被显示出来。
与存储函数类似，存储过程也有相似的查看和删除语句，下边只列举一下相关语句，就不举例子了。
查看当前数据库中创建的存储过程都有哪些的语句：
SHOW PROCEDURE STATUS [LIKE 需要匹配的函数名]
查看某个存储过程定义的语句：
SHOW CREATE PROCEDURE 存储过程名称
删除存储过程的语句：
DROP PROCEDURE 存储过程名称
上边介绍了存储函数中使用到的各种语句，包括变量的使用、判断、循环结构、注释的使用都可以被用在存储过程中，这里就不再赘述了。
相比存储函数，存储过程在定义参数的时候可以选择参数类型（注意！不是数据类型），就像是这个样子：
参数类型 参数名 数据类型
这个所谓的参数类型有 3 种：
IN 参数类型
先定义一个类型参数是 IN 的存储过程 p_in ：
mysql> delimiter $
mysql> create procedure p_in (
-> in arg int
-> )
-> begin
-> -- 语句一：读取参数
-> select arg;
-> -- 语句二：为参数赋值
-> set arg = 123;
-> end $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
这个 p_in 存储过程只有一个参数 arg，它的参数类型是 IN，这个存储过程实际执行两个语句，第一个语句是用来读取参数的值，第二个语句是给参数赋值。调用一下 p_in：
mysql> SET @a = 1;
Query OK, 0 rows affected (0.00 sec)
mysql> CALL p_in(@a);
+------+
| arg |
+------+
| 1 |
+------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @a;
+------+
| @a |
+------+
| 1 |
+------+
1 row in set (0.00 sec)
这里在客户端定义了一个变量 a 并赋值 1，因为它是在客户端定义的，所以需要加 @ 前缀，然后把它当作参数传给 p_in 存储过程。从结果中可以看出，第一个读取语句被成功执行，虽然第二个语句没有报错，但是再存储过程执行完毕后，再次查看变量 a 的值并没有改变，这也就是说：IN 参数类型的变量只能用于读取，对类型的变量赋值是不会被调用者看到的。
另外，因为对于参数类型是 IN 的参数，我们只是想在存储函数执行中使用它，并不需要把执行结果存储到它里边，所以除了让变量作为函数参数，常量也是可以的，比如这样：
mysql> CALL p_in(1);
+------+
| arg |
+------+
| 1 |
+------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
OUT 参数类型
先定义一个类型参数是 OUT 的存储过程 p_out ：
mysql> delimiter $
mysql> CREATE PROCEDURE p_out (
-> OUT a INT
-> )
-> BEGIN
-> SELECT a;
-> SET a = 123;
-> END $
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
这个 p_out 存储过程只有一个参数 arg，它的参数类型是 OUT，p_out 存储过程也有两个语句，一个用于读取参数的值，另一个用于为参数赋值，调用一下 p_out：
mysql> SET @b = 2;
Query OK, 0 rows affected (0.00 sec)
mysql> CALL p_out(@b);
+------+
| a |
+------+
| NULL |
+------+
1 row in set (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @b;
+------+
| @b |
+------+
| 123 |
+------+
1 row in set (0.00 sec)
在客户端定义了一个变量 b 并赋值 2 ，然后把它当作参数传给 p_out 存储过程。从结果中可以看出，第一个读取语句并没有获取到参数的值，在存储过程执行完毕之后，再次读取变量 b 的值，发现它的值已经被设置成 123，说明在过程中对该变量的赋值对调用者是可见的！这也就是说：OUT 参数类型的变量只能用于赋值，对类型的变量赋值是会被调用者看到的。
另外，由于 OUT 参数类型的参数只是为了用于在过程中赋值后被调用者查看，那实际的参数就不允许是常量，常量还怎么赋值啊！
INOUT 参数类型
知道了 IN 和 OUT 参数类型的意思，INOUT 也就明白了，这种类型的参数既可以在存储过程中被读取，也可以被赋值后被调用者看到，所以要求实际的参数必须是一个变量，不然无法赋值！INOUT 参数类型就不具体举例子了
需要注意的是，如果不写明参数类型的话，该参数的类型默认是 IN ，之前一直没有注明参数类型，所以之前使用的参数类型都是 IN ！
由于可以传入多个 OUT 或者 INOUT 类型的参数，所以可以在一个存储过程中获得多个结果，比如这样：
mysql> delimiter $
mysql> CREATE PROCEDURE get_score_data(
-> OUT max_score DOUBLE,
-> OUT min_score DOUBLE,
-> OUT avg_score DOUBLE,
-> s VARCHAR(100)
-> )
-> BEGIN
-> SELECT MAX(score), MIN(score), AVG(score) FROM student_score WHERE subject = s INTO max_score, min_score, avg_score;
-> END $
Query OK, 0 rows affected (0.02 sec)
mysql> delimiter ;
定义的这个 get_score_data 存储过程接受 4 个参数，前三个参数都是 OUT 类型的参数，第四个参数没写参数类型，默认就是 IN 类型。存储过程的内容是将指定学科的最高分、最低分、平均分赋值给三个 OUT 类型的参数。在这个存储过程执行完之后，我们可以根据通过访问这几个 OUT 类型的参数来获得相应的最高分、最低分以及平均分：
mysql> CALL get_score_data(@a, @b, @c, ‘母猪的产后护理‘);
Query OK, 1 row affected (0.01 sec)
mysql> SELECT @a, @b, @c;
+------+------+------+
| @a | @b | @c |
+------+------+------+
| 100 | 55 | 73 |
+------+------+------+
1 row in set (0.00 sec)
这个例子说明了：可以在存储过程中向调用者返回多个值，而存储函数只能返回一个值。
存储过程和存储函数都是某些语句的一个封装，而且使用的语法格式都是一样的，下面着重说一下它们的不同点：
RETURNS 语句标明返回的数据类型，而且在函数体中必须使用 RETURN 语句来显式指定返回的值，存储过程不需要。IN ，而存储过程支持 IN、OUT、INOUT 三种参数类型。OUT 类型的参数来返回多个结果。CALL 语句来显式调用。标签：png 可见 max operation 循环结构 匹配 选择 标识符 创建
原文地址：https://www.cnblogs.com/qiuxirufeng/p/12632677.html
