存储过程/游标/mysql 函数

存储过程和函数（存储在 mysql数据库中的 proc表，所以检查有没有这个表）
存储过程是一种存储程序（如正规语言里的子程序一样）,mysql支持有两种：存储过程，在其他SQL语句中可以返回值的函数（使用起来和 mysql预装载的函数一样,如 pi()）
一个存储过程包括名字，参数列表，以及可以包括很多SQL语句的SQL语句集。
as:(复合语句块)
CREATE PROCEDURE producedure1  /*name存储过程名*/
(in parameter1 interger)       /*parameters参数*/
BEGIN                          /*start of block 语句块头*/
  DECLARE varialbe1 CHAR(10);  /* variables 变量声明*/
  IF parameter1 = 100 THEN     /*start of IF if条件*/
     SET variable1 = 'birds';  /*assignment 赋值*/
  ELSE
     SET variable1 = 'beasts'; /*assignment 赋值*/
  END IF;                      /*end of if if结束*/
  INSERT INTO table1 values(variable1); /*statement SQL语句*/
  ......
END;                           /*end of block 语句块结束*/

DELIMITER // /*设置分隔符，默认为 ;*/
CREATE PROCEDURE p1 () select * from t; //
DELIMITER ; /*还原原来的分隔符 ; */
CALL p1 ();

调用： CALL 存储过程名();
则 CALL p1(); 相当规模于执行了 select * from t;
合法的存储过程（curd, drop table, set, commit, rollback()）

删除存储过程：
DROP PROCEDURE 存储过程名;

Charayeristics Clauses 特征子句
CREATE PROCEDURE p2()
LANGUAGE SQL             -->不起作用，只是作说明以下的句子是用SQL写的,系统默认的，可以不用声明(为了兼容，最好声明)
NOT DETERMINISTIC  -->是传递给系统的信息。这里一个确定过程的定义就是那些每次输入一样输出也一样的程序。在这里，既然主体中SELECT语句，那返回肯定是未知的，因此称其为 NOT DETERMINISTIC
SQL SECURITY DEFINER -->此句可以定义为 SQL SECURITY INVOKER, 这是进入权限控制的领域了，SQL SECURITY DEFINER 意味着在调用时检查创建过程用户的权限，使用时告诉MYSQL服务器检查创建过程的用户就可以了，当过程已经被调用，就不检查执行调用过程的用户了，另一个 INVOKER 则是告诉服务器在这一步(即使用)仍然要检查调用者的权限
COMMENT 'A Procedure' -->一个可选的注释说明
SELECT * FROM t; //
所以以上相与下面的等价:
CREATE PROCEDURE p2()
SELECT * FROM t; //

特征子句也有默认值，如果省略，则相当于：
LANGUAGE SQL NOT DETERMINISTIC SQL SECURITY DEFINER COMMENT

CREATE PROCEDURE p4()
SELECT "hi"; //
CALL p4();
则显示了字段名为 hi,值也为 hi

Parameters 参数
CREATE PROCEDURE p5()
.....

CREATE PROCEDURE p5([IN] name data-type)
.....

CREATE PROCEDURE p5(OUT name data-type)
.......

CREATE PROCEDURE p5(INOUT name data-type)
.........

IN:表示输入参数，默认为 IN(input)
OUT：输出参数
INOUT:既能作为输入也可以作为输出

IN:
DELIMITER //
CREATE PROCEDURE pp(p INT)
SET @X=P; //
CALL pp(100);
SELECT @X;
表示把 p的值给变量X;即  @X = 100;

OUT:
DELIMITER //
CREATE PROCEDURE pp(OUT p int)
set p = -100; //
CALL pp(@y);
SELECT @y;
这次 p是输出参数

新SQL语句：
varaibles 变量
在复合语句中声明变量的指令是 DECLARE;
as:
DELIMITER //
CREATE PROCEDURE p8()
BEGIN
  DECLARE a INT;
  DECLARE b INT;
  SET a = 5;
  SET b = 10;
  INSERT INTO t VALUES(a);
  SELECT s1 FROM t WHERE s1 >= b;
END; //
being/end中,一定要声明变量名和其类型，不能用 @修饰

没有默认子句和设定语句的例子
DELIMITER //
CREATE PROCEDUER p9()
BEGIN
  DECLARE a INT; /*没有默认子句*/
  DECLARE b INT; /*没有默认子句*/
  SET a = 5; /*设定值*/
  SET b = 10; /*设定值*/
  INTER INTO t VALUES (a);
  SELECT s1 FROM t WHERE s1 >= b;
END; //
有很多初始化变量的方法，如果没有默认的子句，那么变量的初始值为 NULL,你可以在任何时候使用 set 语句给变量赋值

含有 DEFAULT子句：
DELIMITER //
CREATE PROCEDURE p10()
  BEGIN
  DECLARE a,b INT DEFAULT 5;
  INSERT INTO t VALUES (a);
  SELECT s1 FROM t WHERE s1 >= b;
END; //

这里使用了 DEFAULT 子句来设定初始值，这就不需要把 DECLARE 和 SET 语句的实现分开了

Scope作用域
DELIMITER //
CREATE PROCEDURE p11()
BEGIN
  DECLARE x1 CHAR(5) DEFAULT 'outer';
  BEGIN
    DECLARE x1 CHAR(5) DEFAULT 'inner';
    SELECT x1;
    END;
  SELECT x1;
END; //
CALL p11();
句中嵌套了 begin/end,是合法的,内部的优先权高，所以先执行内部的，随后内部的变量消失，然后是外部的，所以有两个结果，一个是 inner,一个是outer;

条件式和 if-then-else
DELIMITER //
CREATE PROCEDURE p12(IN parameter1 INT)
BEGIN
  DECLARE variable INT;
  SET variable1 = parameter1 + 1;
  IF variable1 = 0 THEN
     INSERT INTO t VALUES (100);
  END IF;
  IF parameter1 = 0 THEN
     UPDATE t SET s1 = s1+1;
  ELSE
     UPDATE t set s1 = s1+2;
  END IF;
END; //
用 = 表示值是否相等及赋值

CASE 指令
DELIMITER //
CREATE PROCEDURE p13(IN parameter1 INT)
BEGIN
  DECLARE variable1 INT;
  SET variable1 = parameter1 + 1;
  CASE variable1
     WHEN 0 THEN INSERT INTO t VALUES (555);
     WHEN 1 THEN INSERT INTO t VALUES (888);
     ELSE INSERT INTO t VALUES (199);
  END CASE;
END; //

循环语句
WHILE ... END WHILE
LOOP ... END LOOP
REPEAL ... END REPEAT
GOTO(尽量少用,和别的语言一样，结果混乱)

WHILE ... END WHILE
CREATE PROCEDURE p14()
BEGIN
  DECLARE v INT;
  SET v = 0;
  WHILE v < 5 DO
    INSERT INTO v VALUES (v);
    SET v = v+1;
  END WHILE;
END; //
以上只会返回 one row affected,因为只对最后一个 insert动作计数

REPEAT ... END REPEAT: UNTIL
DELIMITER //
CREATE PROCEDURE p15()
BEGIN
  DECLARE v INT;
  SET v = 0;
  REPEAT
    INSERT INTO t VALUES (v);
    SET v = v+1;
    UNTIL v >= 5   /*不能加分号，不然报错*/
  END REPEAT;
END; //
其实就是 do ...while

loop ... end loop
as:
DELIMITER //
CREATE PROCEDURE p16()
BEGIN
  DECLARE v INT;
  SET v = 0;
  label1: LOOP
    INSERT INTO t VALUES (v);
    SET v = v+1;
    IF v >= 5 THEN
       LEAVE label1;  -->离开循环
    END IF;
   END LOOP label1;
END; //

label标号
DELIMITER //
CREATE PROCEDURE p17()
label_1: BEGIN
  label_2:
    WHILE 0=1
      DO LEAVE label_2;
    END WHILE;
  label_3: REPEAT
             LEAVE label_3;
             UNTIL 0=0  -->不能有分号
           END REPEAT;
  label_4: LOOP
             LEAVE label_4;
           END LOOP;
END [label_1]; //   label_1可选

LEAVE and Labels 跳出和标号(LEAVE语句使程序跳出复合语句)
DELIMITER //
CREATE PROCEDURE p19(parameter1 CHAR)
label_1: BEGIN
  label_2: BEGIN
    label_3: BEGIN
      IF parameter1 IS NOT NULL THEN
         IF parameter1 = 'a' THEN
            LEAVE label_1;
         ELSE BEGIN
            IF parameter1 = 'b' THEN
               LEAVE label_2;
             ELSE
               LEAVE label_3;
               END IF;
            END;
         END IF;
       END IF;
            END;
     END;
END; //

ITERATE 迭代
如果目标是 ITERATE语句的话，就必须用到 LEAVE语句
iterate(迭代)语句和 LEAVE语句一样也是在循环内部的循环引用，有点像C语言的 "Continue",同样它可以出现在复合语句中，引用复合语句标号， ITERATE（）意思是重新开始复合语句
DELIMITER //
CREATE PROCEDURE p20()
BEGIN
  DECLARE v INT;
  SET v = 0;
  loop_label: LOOP  /*循环标号*/
    IF v = 3 THEN
       SET v = v+1;
       ITERATE loop_label;  /*开始迭代,使循环又回到开始*/
    END IF;
    INSERT INTO t VALUES (v);
    SET v=v+1;
    IF v >= 5 THEN
       LEAVE loop_label; /*跳出循环,使指令跳到最后一步*/
    END IF;
   END LOOP;
END; //
CALL p20();
------------------
异常处理
CREATE TABLE t2(
  s1 int primary key
) engine = innodb;

CREATE TABLE t3(
  s1 int primary key references t2(s1)
) engine = innodb;
一个主键表，以及一个外键表
insert into t3 values(5);
如果系统提示：error 1216(2300) Cannot add or update a child row: a foreign key ..
是因为主表没有这个值
创建一个错误日志表：
create table error_log(error_message char(100));

DELIMITER //
CREATE PROCEDURE p22(parameter1 INT)
BEGIN
  DECLARE EXIT HANDLER FOR 1216 /*插入出错数字*/
  INSERT INTO error_log VALUES (contact('time:', current_date, 'xxx'));
  INSERT INTO t3 VALUES (parameter1);
END; //

DECLARE EXIT HANDLER 是用来处理异常的，如果错误1216发生了，则错误记录表中插入一行，exit意思是当动作成功提交后退出这个复合语句,此时 t3不会插入数据

声明异常处理的语法
DECLARE
{EXIT | CONTINUE}
HANDLER FOR
{error-number| {SQLSTATE error-string} | condition}
SQL statement
当程序出错后，自动触发代码，mysql允许两种处理，一是 exit处理，一种是 continue处理,它执行后，原主程序仍然继续运行,那国这个复合语句就没有了出口了
as:

DELIMITER //
CREATE PROCEDURE p23()
BEGIN  
  DECLARE CONTINUE HANDLER FOR SQLSTATE '23000' SET @x2 = 1; /*插入出错代码*/
  SET @x=1;
  INSERT INTO t VALUES (1);
  SET @x=2;
  INSERT INTO t VALUES (1);
  SET @x=3;
END; //
 开始执行时，插入为1；接着 set @x=2,此时再插入，因为 1已经存在，不能重复，所以会执行 declare语句，然后再执行 set @x=3
 所以执行
 select @x,@x2,则为 3,1值
 ----------------
 自定义名称
 CREATE PROCEDURE p24()
 BEGIN
   DECLARE `sql_1`
     CONDITION FOR SQLSTATE '23000';
   DECLARE EXIT HANDLER FOR
     `sql_2` ROLLBACK;
   START TRANSACTION;
   INSERT INTO t2 VALUES(1);
   INSERT INTO t2 VALUES(1);
   COMMIT;
END; //
可以给SQLSTATE或者错误代码其他的名字，这样可以在处理中使用自己定义的名字
-------------
cursors游标
as:
DECLARE cursor_name CURSOR FOR SELECT ...; /*声明游标*/
OPEN cursor-name;  /*打开游标*/
FETCH cursor-name INTO variable1[,variable2]; /*从游标中读取数据*/
CLOSE cursor-name; /*关闭游标*/
事务的基本流程：声明游标，打开游标，从游标中读取，关闭游标
as:
DELIMITER //
CREATE PROCEDURE p25(OUT return_val INT)
BEGIN
  DECLARE a,b INT;
  DECLARE cur_1 CURSOR FOR SELECT s1 FROM t;
  DECLARE CONTINUE HANDLER FOR NOT FOUND SET b = 1;
  OPEN cur_1;
  REPEAT
    FETCH cur_1 INTO a;
    UNTIL b=1
  END REPEAT;
  CLOSE cur_1;
  SET return_val = a;
END; //
CALL p25(@return_val);
SELECT @return_val;
结果是返回最后的一句数据值
这个过程开始声明了三个变量，声明的顺序十分重要，先进行变量声明，然后声明条件，随后声明游标，再才时声明错误处理，如果不按以上顺序，系统会提示错误

声明游标 cur_1，使用嵌入式的 SQL

执行语句 OPEN cur_1，它是与 SELECT s1 FROM t语句关联的，过程将执行 SELECT s1 FROM t,返回一个结果集

FETCH语句会获得一行从 select 产生的结果集中检索出来的值，然而 表 t中有多行，因此这个语句会被执行多次，这是在内部循环执行的

当 fetch没有获得行时， CONTINUE处理被触发，将变量 b赋值为 1

b=1时，循环结束，这里关闭游标，也可以由系统自动关闭，最后是手动加上关闭

为输出参数指派了一个局部变量，这样在过程结束后仍然可以使用
----------
游标的特征
READ ONLY 只读属性
NOT SCROLLABLE 顺序读取
ASENSITIVE 敏感
只可以从游标中取值，不能对其进行更新， 因为游标是只读的，但可以这样
FETCH cursor1 INTO variable1;
update t1 set column1='value1' where id=variable;

游标也是不可以滚动的，只允许逐一读取下一行，不能在结果集中前进和后退

同时也不允许在已打开游标进行操作的表上执行 update事务，因为游标是敏感的 (ASENSITIVE)

查看存储过程语句：show或者 select方法
show create procedure 过程名;
或者
show procedure status like '过程名';(更详细信息)

select * from mysql.proc where name='过程名';

查看有哪些例程
select * from information_schema.columns where table_name = 'routines';
可显示相关的例程字段

查询指定数据库中的所在例程数目：
select count(*) as cc from information_schema.routines where routine_schema = '数据库名';

查询定义的语句：
select routine_definition from information_schema.routines where routine_schema = '数据库名' and specific_name = '存储名'
------------------
FUNCTIONS 函数(没有存储过程强大),可直接作为函数在 sql语句中调用即可（同时也是保存到 mysql.proc表中）
as:
DELIMITER //
CREATE FUNCTION factorial(n decimal(3,0))
  returns decimal(20,0) /*不能加分号,表示返回值的类型*/
  DETERMINISTIC
BEGIN
  declare factorial decimal(20,0) default 1;
  declare counter decimal(3,0);
  set counter = n;
  factorial_loop: repeat
     set factorial = factorial * counter;
     set counter = counter -1;
  until counter = 1
  end repeat;
return factorial; /*返回值*/
end; //

引用函数
insert into t values (factorial(10));

删除函数
drop function factorial;