SQL基础篇

//IN  NOT IN
SELECT * FROM t_student WHERE age IN (21,23);
SELECT * FROM t_student WHERE age NOT IN (21,23);

//BETWEEN.. AND..
SELECT * FROM t_student WHERE age BETWEEN 21 AND 24;
SELECT * FROM t_student WHERE age NOT BETWEEN 21 AND 24;

//模糊查询
SELECT * FROM t_student WHERE stuName LIKE '张三';
SELECT * FROM t_student WHERE stuName LIKE '张三%';
SELECT * FROM t_student WHERE stuName LIKE '张三__'; //_标识一个字符
SELECT * FROM t_student WHERE stuName LIKE '%张三%';

//IS NULL  IS NOT NULL
SELECT * FROM t_student WHERE sex IS NULL;
SELECT * FROM t_student WHERE sex IS NOT NULL;

//AND(并且)   OR(或者)
SELECT * FROM t_student WHERE gradeName='一年级' AND age=23
SELECT * FROM t_student WHERE gradeName='一年级' OR age=23

//DISTINCT(去重复查询)
SELECT DISTINCT gradeName FROM t_student;

//排序:默认升序(ASC 升序)(DESC 降序)
//语法:SELECT 字段1,字段2.. FROM 表名  ORDER BY 属性名 [ASC|DESC]
SELECT * FROM t_student ORDER BY age ASC;
SELECT * FROM t_student ORDER BY age DESC;

//GROUP BY 分组查询(单独使用毫无意义)
SELECT * FROM t_student GROUP BY gradeName;

//和GROUP_CONCAT 一起使用,查询每个年级所有的学生姓名
SELECT gradeName,GROUP_CONCAT(stuName) FROM t_student GROUP BY gradeName;

//和聚合函数一起使用 COUNT
SELECT gradeName,COUNT(stuName) FROM t_student GROUP BY gradeName;

//和HAVING 一起使用,HAVING的作用就是对查询结果进行删选
//GROUP BY 属性名 [HAVING 条件表达式][WITH ROLLUP]
SELECT gradeName,COUNT(stuName) FROM t_student GROUP BY gradeName HAVING COUNT(stuName)>3;

//与WITH ROLLUP(在最后一行加入总和的计算,很少用)
SELECT gradeName,COUNT(stuName) FROM t_student GROUP BY gradeName WITH ROLLUP;
SELECT gradeName,GROUP_CONCAT(stuName) FROM t_student GROUP BY gradeName WITH ROLLUP;

//分页查询
//语法:SELECT 字段1,字段2.. FROM 表名 LIMIT 初始位置,记录数(每页大小);
SELECT * FROM t_student LIMIT 0,5;
SELECT * FROM t_student LIMIT 5,5;
SELECT * FROM t_student LIMIT 10,5;

//聚合函数一共有以下五种
//COUNT()函数用来统计记录的条数；与 GOUPE BY 关键字一起使用；
//SUM()函数是求和函数；与 GOUPE BY 关键字一起使用；
//AVG()函数是求平均值的函数；与 GOUPE BY 关键字一起使用；
//MAX()函数是求最大值的函数；与 GOUPE BY 关键字一起使用；
//MIN()函数是求最小值的函数；与 GOUPE BY 关键字一起使用；

//连接查询
//内连接:可以查询两个或者两个以上的表
SELECT * FROM t_book,t_bookType WHERE t_book.bookTypeId=t_bookType.id;
//外连接:
//语法:SELECT 属性名列表 FROM 表名1 LEFT|RIGHT  JOIN 表名2 ON 表名1属性名1=表名2属性名2;
//左连接:查询出表1的所有数据,而表2只能查询出匹配的记录
SELECT * FROM t_book LEFT JOIN t_bookType ON t_book.bookTypeId=t_bookType.id;
//右连接:查询出表2的所有数据,而表1的只能查询出匹配的记录
SELECT * FROM t_book RIGHT JOIN t_bookType ON t_book.bookTypeId=t_bookType.id;
//多条件连接查询
SELECT tb.bookName,tb.author,tby.bookTypeName FROM t_book tb,t_bookType tby WHERE tb.bookTypeId=tby.id AND tb.price>70;


//带 In 关键字的子查询:一个查询语句的条件可能落在另一个 SELECT 语句的查询结果中。
//带比较运算符的子查询:子查询可以使用比较运算符。
//带 Exists 关键字的子查询:假如子查询查询到记录，则进行外层查询，否则，不执行外层查询；
SELECT * FROM t_book WHERE EXISTS (SELECT * FROM t_booktype);
SELECT * FROM t_book WHERE NOT EXISTS (SELECT * FROM t_booktype);
//带 Any 关键字的子查询:ANY 关键字表示满足其中任一条件；
//假如说子查询查询出来的结果是3个,那么price只要大于其中一个就可以进行查询;
SELECT * FROM t_book WHERE price>= ANY (SELECT price FROM t_pricelevel);
//带 All 关键字的子查询:ALL 关键字表示满足所有条件;
//假如说子查询查询出来的结果是3个,那么price必须大于全部才能进行查询;
SELECT * FROM t_book WHERE price>= ALL (SELECT price FROM t_pricelevel);

//使用 UNION 关键字是，数据库系统会将所有的查询结果合并到一起，然后去除掉相同的记录；
SELECT id FROM t_book UNION SELECT id FROM t_booktype;
//使用 UNION ALL，不会去除掉系统的记录;
SELECT id FROM t_book UNION ALL SELECT id FROM t_booktype;

//1，给表的所有字段插入数据
格式：INSERT INTO 表名 VALUES(值 1，值 2，值 3，...，值 n)；
//2，给表的指定字段插入数据
格式：INSERT INTO 表名(属性 1，属性 2，...，属性 n) VALUES(值 1，值 2，值 3，...，值 n)；
//3，同时插入多条记录
INSERT INTO 表名 [(属性列表)] VALUES(取值列表 1)，(取值列表 2)...，(取值列表 n)；
//4，更新数据
UPDATE 表名 SET 属性名 1=取值 1，属性名 2=取值 2，...，属性名 n=取值 n WHERE 条件表达式；
//5，删除数据
DELETE FROM 表名 [WHERE 条件表达式]

索引

//索引
//索引定义：索引是由数据库表中一列或者多列组合而成，其作用是提高对表中数据的查询速度；
//类似于图书的目录，方便快速定位，寻找指定的内容；
//优点：提高查询数据的速度；
//缺点：创建和维护索引的时间增加了；
//索引的分类
//1，普通索引
//这类索引可以创建在任何数据类型中；
//2，唯一性索引
//使用 UNIQUE 参数可以设置，在创建唯一性索引时，限制该索引的值必须是唯一的；
//3，全文索引
//使用 FULLTEXT 参数可以设置，全文索引只能创建在 CHAR，VARCHAR，TEXT 类型的字段上。主要作用
//就是提高查询较大字符串类型的速度；只有 MyISAM 引擎支持该索引，Mysql 默认引擎不支持；
//4，单列索引
//在表中可以给单个字段创建索引，单列索引可以是普通索引，也可以是唯一性索引，还可以是全文索引；
//5，多列索引
//多列索引是在表的多个字段上创建一个索引；
//6，空间索引
//使用 SPATIAL 参数可以设置空间索引。空间索引只能建立在空间数据类型上，这样可以提高系统获取空间数
//据的效率；只有 MyISAM 引擎支持该索引，Mysql 默认引擎不支持；

//语法:
CREATE TABLE 表名 (属性名 数据类型 [完整性约束条件],
属性名 数据类型 [完整性约束条件],
.... 属性名 数据类型
[UNIQUE | FULLTEXT | SPATIAL ] INDEX| KEY
[别名] (属性名 1 [(长度)] [ASC | DESC])
);

//在已经存在的表上创建索引
CREATE [ UNIQUE | FULLTEXT | SPATIAL ] INDEX 索引名
ON 表名 (属性名 [(长度)] [ ASC | DESC])；
//用ALTER TABLE 来创建索引
ALTER TABLE 表名 ADD [ UNIQUE | FULLTEXT | SPATIAL ] INDEX
索引名 (属性名 [(长度)] [ ASC | DESC])；
//删除索引
DROP INDEX 索引名 ON 表名 ；

视图

//视图的作用
//1，使操作简便化；
//2，增加数据的安全性；
//3，提高表的逻辑独立性；

//创建视图
CREATE [ ALGORITHM ={ UNDEFIEND | MERGE | TEMPTABLE }]
VIEW 视图名 [ ( 属性清单) ]
AS SELECT 语句
[ WITH [ CASCADED | LOCAL ] CHECK OPTION ]；

//以下是单表视图
//取原有数据库的全部字段
CREATE VIEW v1 AS SELECT * FROM t_book;
//只取原有数据库的部分字段
CREATE VIEW v2 AS SELECT bookName,price FROM t_book;
//可以原有的数据库的字段名字做改动
CREATE VIEW v3(b,p) AS SELECT bookName,price FROM t_book;

//创建多表视图
CREATE VIEW v4 AS SELECT bookName,bookTypeName FROM t_book,t_booktype WHERE t_book.bookTypeId=t_booktype.id;

//查看视图
//DESCRIBE 语句查看视图基本信息
DESC v5;
//SHOW TABLE STATUS 语句查看视图基本信息
SHOW TABLE STATUS LIKE 'v5';
//SHOW CREATE VIEW 语句查看视图详细信息
SHOW CREATE VIEW v5;
//在 views 表中查看视图详细信息

//修改视图
//CREATE OR REPLACE VIEW 语句修改视图
CREATE OR REPLACE [ ALGORITHM ={ UNDEFINED | MERGE | TEMPTABLE }]
VIEW 视图名 [( 属性清单 )]
AS SELECT 语句
[ WITH [ CASCADED | LOCAL ] CHECK OPTION ]；
eg:CREATE OR REPLACE VIEW v1(bookName,price) AS SELECT bookName,price FROM t_book;

//ALTER 语句修改视图
ALTER [ ALGORITHM ={ UNDEFINED | MERGE | TEMPTABLE }]
VIEW 视图名 [( 属性清单 )]
AS SELECT 语句
[ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
eg:ALTER VIEW v1 AS SELECT * FROM t_book;

//更新视图
//更新视图是指通过视图来插入（INSERT）、更新（UPDATE）和删除（DELETE）表中的数据。因为视图是一个
//虚拟的表，其中没有数据。通过视图更新时，都是转换基本表来更新。更新视图时，只能更新权限范围内的
//数据。超出了范围，就不能更新。
INSERT INTO v1 VALUES(NULL,'java good',120,'feng',1);
UPDATE v1 SET bookName='java very good',price=200 WHERE id=5;
DELETE FROM v1 WHERE id=5;

//删除视图
//删除视图是指删除数据库中已存在的视图。删除视图时，只能删除视图的定义，不会删除数据；
//DROP VIEW [ IF EXISTS ] 视图名列表 [ RESTRICT | CASCADE ]
DROP VIEW IF EXISTS v4;

触发器

//触发器的执行顺序是先执行你创建的触发器,再执行你要执行的操作
//触发器的引入
//触发器（TRIGGER）是由事件来触发某个操作。这些事件包括 INSERT 语句、UPDATE 语句和 DELETE 语句。
//当数据库系统执行这些事件时，就会激活触发器执行相应的操作

//创建只有一个执行语句的触发器
CREATE TRIGGER 触发器名 BEFORE | AFTER 触发事件
ON 表名 FOR EACH ROW 执行语句

eg:CREATE TRIGGER trig_book AFTER INSERT 
     ON t_book FOR EACH ROW
        UPDATE t_bookType SET bookNum=bookNum+1 WHERE new.bookTypeId=t_booktype.id;

INSERT INTO t_book VALUES(NULL,'java好',100,'ke',1);

//new 是指刚才新插入的数据,是过度变量
//old 用于删除的时候

//创建有多个执行语句的触发器
CREATE TRIGGER 触发器名 BEFORE | AFTER 触发事件
ON 表名 FOR EACH ROW
BEGIN
执行语句列表
END

eg:DELIMITER |
CREATE TRIGGER trig_book2 AFTER DELETE 
    ON t_book FOR EACH ROW
    BEGIN
       UPDATE t_bookType SET bookNum=bookNum-1 WHERE old.bookTypeId=t_booktype.id;
       INSERT INTO t_log VALUES(NULL,NOW(),'在book表里删除了一条数据');
       DELETE FROM t_test WHERE old.bookTypeId=t_test.id;
    END 
|
DELIMITER ;

//DELIMITER 分隔符,以上代码是以| 标识的,可以随意定义,也可以用&&等..,保证BEGIN  END 中代码的完整执行性

DELETE FROM t_book WHERE id=5;

//查看触发器
//SHOW TRIGGERS 语句查看触发器信息
SHOW TRIGGERS;
//在系统表中的 triggers 表中查看触发器信息

//删除触发器
//DROP TRIGGER 触发器名；
DROP TRIGGER trig_book2 ; //删除的时候要价格空格,不然解析要出错

常用函数

第一节：日期和时间函数
1，CURDATE() 返回当前日期；
2，CURTIME() 返回当前时间；
3，MONTH(d) 返回日期 d 中的月份值，范围是 1~12
SELECT CURDATE(),CURTIME(),MONTH(birthday) AS m FROM t_t;

第二节：字符串函数
1，CHAR_LENGTH(s) 计算字符串 s 的字符数；
2，UPPER(s) 把所有字母变成大写字母；
3，LOWER(s) 把所有字母变成小写字母；
SELECT userName,CHAR_LENGTH(userName),UPPER(userName),LOWER(userName) FROM t_t;

第三节：数学函数
1，A BS(x) 求绝对值
2，SQRT(x) 求平方根
3，MOD(x,y) 求余
SELECT num,ABS(num) FROM t_t;
SELECT SQRT(4),MOD(9,4) FROM t_t;

第四节：加密函数
1，PASSWORD(str) 一般对用户的密码加密 不可逆
2，MD5(str) 普通加密 不可逆
3，ENCODE(str，pswd_str) 加密函数，结果是一个二进制数，必须使用 BLOB 类型的字段来保存它；
4，DECODE(crypt_str，pswd_str) 解密函数；
INSERT INTO t_t VALUES(NULL,'2013-1-1','a',1,PASSWORD('123456'));
INSERT INTO t_t VALUES(NULL,'2013-1-1','a',1,MD5('123456'));
INSERT INTO t_t VALUES(NULL,'2013-1-1','a',1,MD5('123456'),ENCODE('abcd','aa'));//abcd 是加密的值, aa是加密的钥匙
SELECT DECODE(pp,'aa') FROM t_t WHERE id=5; //pp是解密的字段,aa是解密的钥匙

存储过程

//存储过程和函数的引入
存储过程和函数是在数据库中定义一些 SQL 语句的集合，然后直接调用这些存储过程和函数来执行已经定义好
的 SQL 语句。存储过程和函数可以避免开发人员重复的编写相同的 SQL 语句。而且，存储过程和函数是在 MySQL服务器中存储和执行的，可以减少客户端和服务器端的数据传输；

//创建存储过程和函数
2.1 创建存储过程
CREATE PROCEDURE sp_name([proc_parameter[,...]])
[characteristic...] routine_body
sp_name 参数是存储过程的名称；
proc_parameter 表示存储过程的参数列表；
characteristic 参数指定存储过程的特性；
routine_body 参数是 SQL 代码的内容，可以用 BEGIN...END 来标志 SQL 代码的开始和结束。
proc_parameter 中的每个参数由 3 部分组成。这 3 部分分别是输入输出类型、参数名称和参数类型。
[ IN | OUT | INOUT ] param_name type
其中，IN 表示输入参数；OUT 表示输出参数；INOUT 表示既可以是输入，也可以是输出；param_name 参数是
存储过程的参数名称；type 参数指定存储过程的参数类型，该类型可以是 MySQL 数据库的任意数据类型；
Characteristic 参数有多个取值。其取值说明如下：
LANGUAGE SQL：说明 routine_body 部分是由 SQL 语言的语句组成，这也是数据库系统默认的语言。
[ NOT ] DETERMINISTIC ：指明存储过程的执行结果是否是确定的。DETERMINISTIC 表示结果是确定的。每
次执行存储过程时，相同的输入会得到相同的输出。NOT DETERMINISTIC 表示结果是非确定的，相同的输入
可能得到不同的输出。默认情况下，结果是非确定的。
{ CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA } ：指明子程序使用 SQL 语句的限制；
CONTAINS SQL 表示子程序包含 SQL 语句，但不包含读或写数据的语句；NO SQL 表示子程序中不包含 SQL
语句；READS SQL DATA 表示子程序中包含读数据的语句；MODIFIES SQL DATA 表示子程序中包含写数据的
语句。默认情况下，系统会指定为 CONTAINS SQL；
SQL SECURITY { DEFINER | INVOKER }；指明谁有权限来执行。DEFINER 表示只有定义者自己才能够执行；
INVOKER 表示调用者可以执行。默认情况下，系统指定的权限是 DEFINER。
COMMENT ‘string’ ：注释信息；

//创建存储过程
DELIMITER &&
CREATE PROCEDURE pro_book ( IN bT INT,OUT count_num INT)
   READS SQL DATA
   BEGIN 
     SELECT COUNT(*) FROM t_book WHERE bookTypeId=bT;
   END 
   &&
DELIMITER ;

CALL pro_book(1,@total); //调用存储过程



2.2 创建存储函数
CREATE FUNCTION sp_name ( [func_parameter[,...]] )
RETURNS type
[ characteristic... ] routine_body
sp_name 参数是存储函数的名称；func_parameter 表示存储函数的参数列表；RETURNS type 指定返回值的
类型；characteristic 参数指定存储过程的特性，该参数的取值与存储过程中的取值是一样的；routine_body 参数
是 SQL 代码的内容，可以用 BEGIN...END 来标志 SQL 代码的开始和结束；
func_parameter 可以由多个参数组成，其中每个参数由参数名称和参数类型组成，其形式如下：
param_name type 其中，param_name 参数是存储函数的参数名称；type 参数指定存储函数的参数类型，
该类型可以是 MySQL 数据库的任意数据类型；

//创建存储函数 (bookId INT)传入参数 RETURN直接返回
DELIMITER &&
CREATE FUNCTION func_book (bookId INT)
 RETURNS VARCHAR(20)
 BEGIN 
  RETURN ( SELECT bookName FROM t_book WHERE id=bookId ); 
 END 
    &&
DELIMITER ;

SELECT func_book(2); //调用存储函数

2.3 变量的使用
1.定义变量
DECLARE var_name [,...] type [ DEFAULT value ]
定义变量:必须要用DECLARE 来做声明
DELIMITER &&
CREATE PROCEDURE pro_user()
	BEGIN
	 DECLARE a,b VARCHAR(20) ;
	 INSERT INTO t_user VALUES(NULL,a,b);
	END 
&&
DELIMITER ;
CALL pro_user();

2.为变量赋值
SET var_name = expr [,var_name=expr] ...
    //为变量赋值,语法是SET
    DELIMITER &&
    CREATE PROCEDURE pro_user2()
	    BEGIN
	         DECLARE a,b VARCHAR(20) ;
	         SET a='java1234',b='123456';
	         INSERT INTO t_user VALUES(NULL,a,b);
	    END 
    &&
    DELIMITER ;

    CALL pro_user2();
   

SELECT col_name[,...] INTO var_name[,...]
FROM table_name WHERE condition
    //从其他表查询出字段然后给a,b变量赋值
    DELIMITER &&
    CREATE PROCEDURE pro_user3()
	    BEGIN
	     DECLARE a,b VARCHAR(20) ;
	     SELECT userName2,password2 INTO a,b FROM t_user2 WHERE id2=1;
	     INSERT INTO t_user VALUES(NULL,a,b);
	    END 
    &&
    DELIMITER ;

    CALL pro_user3();

2.4 游标的使用
查询语句可能查询出多条记录，在存储过程和函数中使用游标来逐条读取查询结果集中的记录。游标的使
用包括声明游标、打开游标、使用游标和关闭游标。游标必须声明在处理程序之前，并且声明在变量和条
件之后。

1.声明游标
DECLARE cursor_name CURSOR FOR select_statement ;
2.打开游标
OPEN cursor_name;
3.使用游标
FETCH cursor_name INTO var_name [,var_name ... ]；
4.关闭游标
CLOSE cursor_name；

//游标的使用
DELIMITER &&
CREATE PROCEDURE pro_user4()
	BEGIN
	 DECLARE a,b VARCHAR(20) ;
	 DECLARE cur_t_user2 CURSOR FOR SELECT userName2,password2 FROM t_user2;  //创建游标,游标名字cur_t_user2
	 OPEN cur_t_user2;  //打开游标
	 FETCH cur_t_user2 INTO a,b; //使用游标
	 INSERT INTO t_user VALUES(NULL,a,b);
	 CLOSE cur_t_user2;  //关闭游标
	END 
&&
DELIMITER ;

CALL  pro_user4();

2.5 流程控制的使用
存储过程和函数中可以使用流程控制来控制语句的执行。MySQL 中可以使用 IF 语句、CASE 语句、LOOP
语句、LEAVE 语句、ITERATE 语句、REPEAT 语句和 WHILE 语句来进行流程控制。

1.IF 语句
IF search_condition THEN statement_list
[ ELSEIF search_condition THEN statement_list ]...
[ ELSE statement_list ]
END IF

解释: @num临时变量 传入一个bookId值,如果有的话就更新表t_user,如果没有的话就对t_user插入一条数据  INTO @num 类似于AS @num
DELIMITER &&
CREATE PROCEDURE pro_user5(IN bookId INT)
	BEGIN
	 SELECT COUNT(*) INTO @num FROM t_user WHERE id=bookId;
	 IF @num>0 THEN UPDATE t_user SET userName='java12345' WHERE id=bookId;
	 ELSE
	   INSERT INTO t_user VALUES(NULL,'2312312','2321312');
	 END IF ;
	END 
&&
DELIMITER ;
CALL pro_user5(5);

2.CASE 语句
CASE case_value
WHEN when_value THEN statement_list
[WHEN when_value THEN statement_list]...
[ELSE statement_list ]
END CASE

//case 和java中的switch case 类似
DELIMITER &&
CREATE PROCEDURE pro_user6(IN bookId INT)
	BEGIN
	 SELECT COUNT(*) INTO @num FROM t_user WHERE id=bookId;
	 CASE @num
	  WHEN 1 THEN UPDATE t_user SET userName='java12345' WHERE id=bookId;
	  WHEN 2 THEN INSERT INTO t_user VALUES(NULL,'2312312','2321312');
	  ELSE INSERT INTO t_user VALUES(NULL,'231231221321312','2321312321312');
	 END CASE ;
	END 
&&
DELIMITER ;
CALL pro_user6(5);

3.LOOP,LEAVE 语句
LOOP 语句可以使某些特定的语句重复执行，实现一个简单的循环。但是 LOOP 语句本身没有停止循环
的语句，必须是遇到 LEAVE 语句等才能停止循环。LOOP 语句的语法的基本形式如下：
[begin_label：]LOOP
Statement_list
END LOOP [ end_label ]
LEAVE 语句主要用于跳出循环控制。语法形式如下：
LEAVE label

//以下代码就相当于java代码的传入一个参数,当这个参数为0的时候跳出循环,不为0就继续插入数据
//LEAVE 相当于java的break
DELIMITER &&
CREATE PROCEDURE pro_user7(IN totalNum INT)
	BEGIN
	  aaa:LOOP
	    SET totalNum=totalNum-1;
	    IF totalNum=0 THEN LEAVE aaa ;
	    ELSE INSERT INTO t_user VALUES(totalNum,'2312312','2321312');
	    END IF ;
	  END LOOP aaa ;
	END 
&&
DELIMITER ;
CALL pro_user7(11);

4.ITERATE 语句
ITERATE 语句也是用来跳出循环的语句。但是，ITERATE 语句是跳出本次循环，然后直接进入下一次
循环,相当于java的continue。基本语法：
ITERATE label ;

DELIMITER &&
CREATE PROCEDURE pro_user8(IN totalNum INT)
	BEGIN
	  aaa:LOOP
	    SET totalNum=totalNum-1;
	    IF totalNum=0 THEN LEAVE aaa ;
	    ELSEIF totalNum=3 THEN ITERATE aaa ;
	    END IF ;
	    INSERT INTO t_user VALUES(totalNum,'2312312','2321312');
	  END LOOP aaa ;
	END 
&&
DELIMITER ;
CALL pro_user8(11);

5.REPEAT 语句
REPEAT 语句是有条件控制的循环语句。当满足特定条件时，就会跳出循环语句。REPEAT 语句的基本
语法形式如下：
[ begin_label : ] REPEAT
Statement_list
UNTIL search_condition
END REPEAT [ end_label ]

//传入一个数字,当这个数字等于1的时候结束循环 UNTIL表示的是条件 totalNum=1就是具体的条件
DELIMITER &&
CREATE PROCEDURE pro_user9(IN totalNum INT)
	BEGIN
	  REPEAT
	     SET totalNum=totalNum-1;
	     INSERT INTO t_user VALUES(totalNum,'2312312','2321312');
	     UNTIL totalNum=1 
	  END REPEAT;
	END 
&&
DELIMITER ;

CALL pro_user9(11);

6.WHILE 语句
[ begin_label : ] WHILE search_condition DO
Statement_list
END WHILE [ end_label ]

//WHILE 就相当于java的while循环一样
DELIMITER &&
CREATE PROCEDURE pro_user10(IN totalNum INT)
	BEGIN
	 WHILE totalNum>0 DO
	  INSERT INTO t_user VALUES(totalNum,'2312312','2321312');
	  SET totalNum=totalNum-1;
	 END WHILE ;
	END 
&&
DELIMITER ;

CALL pro_user10();

3.调用存储过程和函数
3.1 调用存储过程
CALL sp_name( [parameter[,...]] )
3.2 调用存储函数
fun_name( [parameter[,...]] )

4.查看存储过程和函数
4.1 SHOW STATUS 语句查看存储过程和函数的状态
SHOW { PROCEDURE | FUNCTION } STATUS [ LIKE ‘pattern’ ] ;
SHOW PROCEDURE STATUS LIKE 'pro_book';

4.2 SHOW CREATE 语句查看存储过程的函数的定义
SHOW CREATE { PROCEDURE | FUNCTION } sp_name ;
SHOW CREATE PROCEDURE pro_book;
4.3 从系统表 information_schema.Routines 表中查看存储过程和函数的信息

5.修改存储过程和函数 -->鸡肋功能
ALTER { PROCEDURE | FUNCTION } sp_name [ characteristic ... ]
characteristic :
{ CONTAINS SQL } NO SQL | READS SQL DATA | MODIFIES SQL DATA }
| SQL SECURITY { DEFINER | INVOKER }
| COMMENT ‘string’ 其中，sp_name 参数表示存储过程或函数的名称；characteristic 参数指定函数的特性。CONTAINS SQL 表示子程
序包含 SQL 语句，但不包含读或写数据的语句；NO SQL 表示子程序中不包含 SQL 语句；READS SQL DATA
表 示 子 程 序 中 包 含 数 据 的 语 句 ； MODIFIES SQL DATA 表 示 子 程 序 中 包 含 写 数 据 的 语 句 。 SQL
SECURITY{ DEFINER | INVODER } 指明谁有权限来执行。DEFINER 表示只有定义者自己才能够执行；
INVODER 表示调用者可以执行。COMMENT ‘string’ 是注释信息。

ALTER PROCEDURE pro_book  COMMENT '我来测试一个COMMENT';

6.删除存储过程和函数
DROP {PROCEDURE | FUNCTION } sp_name ;
DROP PROCEDURE pro_user3;

数据库备份

备份数据可以保证数据库中数据的安全，数据库管理员需要定期的进行数据库备份；

1.1 使用 mysqldump 命令备份

mysqldump -u username -p dbname table1 table2 ... > BackupName.sql dbname 参数表示数据库的名称；table1 和 table2 参数表示表的名称，没有该参数时将备份整个数据库； BackupName.sql 参数表示备份文件的名称，文件名前面可以加上一个绝对路径。通常以 sql 作为后缀。

mysqldump -u root -p db_book > c:\db_book.sql

1.2 使用 sqlyog 图形工具备份

数据还原

2.2 使用 mysql 命令还原

Mysql -u root -p [dbname] < backup.sql dbname 参数表示数据库名称。该参数是可选参数，可以指定数据库名，也可以不指定。指定数据库名时，表 示还原该数据库下的表。不指定数据库名时，表示还原特定的一个数据库。而备份文件中有创建数据库的语句。

2.3 使用 sqlyog 图形工具还原

数据库备份和还原大部分时候都是用图形工具

存储过程Mybatis的调用

<select id="getUserCount" parameterMap="getUserCountMap" statementType="CALLABLE">

CALL mybatis.ges_user_count(?,?)       //mybatis.ges_user_count就是存储过程的名字

</select>