day29 | 黑马程序员Java全程笔记 | 第二阶段MySQL高级事务-索引-视图-触发器-存储过程
目录
01.反馈
02.回顾
03.并发访问MySQL-问题概述
并发访问的问题
04.并发访问MySQL-问题演示
05.并发访问MySQL-read-committed解决脏读问题
06.并发访问MySQL-repeatable read解决不可重复读问题
07.并发访问MySQL-serializable解决所有问题
08.索引概述和作用
09.索引优劣势
优势
劣势
10.存储引擎和索引数据结构
11.索引结构-BTree结构
BTREE 结构
12.B+Tree结构
MySQL中的B+Tree
13.索引使用-创建-查看-删除索引
索引分类
索引语法
什么是索引？
单列索引分类和创建
语法总结
14.索引使用前后差别
索引比较
15.上午总结
16.索引使用原则
索引设计原则
17.视图-简单使用
18.触发器-概述
19.触发器-添加型触发器
20.触发器-修改型和删除型触器
21.查看和删除触发器
22.存储过程概述
23.存储过程-创建-调用-查询
创建存储过程
调用存储过程
查看存储过程
删除存储过程
24.存储过程语法-变量声明与赋值
25.if判断
26.传入传出参数格式
传递参数
27.case结构
28.多种循环
while循环
repeat结构
loop语句
leave语句
存储函数
存储过程练习
29.游标
课堂代码
作业
01.反馈
02.回顾
三范式:
范式: 创建数据库表时的规范,满足范式可以降低数据库数据冗余,保证数据的一致性和有效性
第一范式: 表字段不可再拆分,查询结果可以直接使用
第二范式: 一张表只描述一件事情,表中的数据都依赖主键字段(每张表都应该有一个主键)
第三范式: 从表外键字段必须引用主表的主键值
反三范式:
空间换时间,适当增加数据冗余,提高查询效率
约束:
主键约束: primary key
唯一约束: unique
非空约束: not null
默认值约束: default 值
外键约束: foreign key 外键字段 references 主表(主键名)
表与表关系:
一对一,一对多,多对多
多表查询:
连接查询:
内连接:
隐式内连接:
select * from 表1,表2 where 条件;
显示内连接:
select * from 表1 inner join 表2 on 关联条件 where 筛选条件;
外连接:
左外连接:
select * from 表1 left join 表2 on 关联条件 where 筛选条件;
右外连接:
select * from 表1 right join 表2 on 关联条件 where 筛选条件;
子查询:
一条sql的执行结果为另一条sql执行时的条件
单行单列: where后加条件
多行单列: in any all
多行多列: 作为临时表被查询
事务:
概述:
事务描述的就是一个完整的业务,组成这个业务的各个单元(sql)
要么同时成功,要么同时失败.
事务API:
自动事务: mysql的事务是自动的(默认)
select @@autocommit; // 查询事务自动提交状态
在mysql中事务是自动的,默认情况下一条sql就是一个事务,sql执行完毕后,
mysql会自动提交事务
关闭自动事务提交: set @@autocommit=0;
提交: commit
回滚: rollback
手动事务:
开启事务: begin; start transaction;
编写sql...
提交事务: commit
回滚事务: rollback
事务特征: 四大特性
A: 原子性,事务是一个独立的整体,不可再拆分
C: 一致性,组成事务的各个单元要么同时成功,要么同时失败
I: 隔离性,多个事务操作数据库时,事务之间相互隔离,互不干扰
D: 持久性,事务一旦提交,对数据库的影响是持久的
回滚点:
savepoint 名称
rollback 名称
03.并发访问MySQL-问题概述
在不考虑隔离性的前提下: 并发访问mysql
因为一张表可以同时有多个用户在访问，相互之间会有影响，会引发以下三种并发访问的问题
并发访问的问题
- 脏读
-
- 含义：读未提交。一个事务读取到另一个事务没有提交的数据
- 例子：张三转账给李四，但没有提交，李四那边却可以看见，然后张三rollback
- 不可重复读
-
- 含义：在一个事务中，执行同一条sql查询到的结果不同（其他事务对数据进行了修改）
- 幻读/虚读
-
- 含义：在一个事务中，执行同一条sql查询到的结果不同（其他事务对数据进行了添加或删除）
04.并发访问MySQL-问题演示
并发访问的问题可以通过数据库隔离级别来解决
隔离级别的特点：
- 级别1最低，级别4最高
- 隔离级别越高，性能越低，安全性越高
MySQL与隔离级别相关的命令
-- 查询事务隔离级别
select @@tx_isolation;
-- 设置全局事务隔离级别
set global transaction isolation level 四种级别名字;
05.并发访问MySQL-read-committed解决脏读问题
脏读演示
-- 1. 打开一个命令行Jack，设置全局的隔离级别为最低： set global transaction isolation level read uncommitted; -- 2. 选择数据库，开启事务 use db; start transaction; -- 3. 更新2个人的账户，未提交 update account set balance = balance - 500 where name = 'Jack'; update account set balance = balance + 500 where name = 'Rose'; -- 4. 打开另一个命令行Rose，选择数据库，开启事务 use db; start transaction; -- 5. 查询账户，发现钱已经到账，发货 select * from account; -- 6. 命令行Jack，回滚 rollback; -- 7. 命令行Rose，查询账户，钱没了 select * from account;
解决办法
-- 1. 打开命令行Jack，设置全局的隔离级别为 read committed set global transaction isolation level read committed; -- 2. 重复上面的操作：需要重新登录。命令行Jack在没有提交和回滚之前，Rose账户看到的金额不变 会发现命令行Jack在没有提交和回滚之前，命令行Rose看不到账户发生任何变化 -- 3. 命令行Jack。使用commit提交以后，Rose账户看到的金额变化 命令行Rose，可以看到账户发生了变化
06.并发访问MySQL-repeatable read解决不可重复读问题
不可重复读演示
-- 1.将数据进行恢复，并关闭窗口重新登录。 update account set balance=1000; -- 2.开启一个命令行Jack，确保当前的事务隔离是read committed select @@tx_isolation; -- 3.选择数据库，开启一个事务 use db; start transaction; -- 4.查询用户Jack的账户，查到是1000块 select * from account where name='Jack'; -- 5.开启另一个命令行Rose，选择数据库，开启一个事务 use db; start transaction; -- 6.更新Jack账户，减500元 update account set balance=balance-500 where name='Jack'; -- 7.提交事务 commit; -- 8.命令行Jack再次查询Jack的账户，查到是500块 select * from account where name='Jack'; -- 9.提交事务 commit;
两次查询输出的结果不同，到底哪次是对的？
解决办法
-- 1. 打开命令行Jack，设置全局的隔离级别为 repeatable read set global transaction isolation level repeatable read; -- 2. 重复上面的操作：需要重新登录 会发现命令行Rose事务提交后，命令行Jack依然读到1000，表示可以重复读
07.并发访问MySQL-serializable解决所有问题
幻读演示
-- 1.将数据恢复成1000，并关闭窗口重新登录。 update account set balance=1000; -- 2.开启一个命令行Jack，确保当前的事务隔离是repeatable read select @@tx_isolation; -- 3.选择数据库，开启一个事务 use db; start transaction; -- 4.查询id大于1的账户信息，查到1条记录 select * from account where id > 1; -- 5.开启另一个命令行Rose，选择数据库，开启事务 use db; start transaction -- 6.新增一条记录 insert into account values (null, 'Tom', 300); -- 7.提交事务 commit; -- 8.命令行Jack再次查询id大于1的账户信息，查到1条记录 select * from account where id > 1; -- 9.修改id大于1的账户金额为200，发现修改了2条记录 update account set balance = 200 where id > 1; -- 10.再次查询id大于1的账户信息，查到2条记录，出现幻觉 select * from account where id > 1;
查到2条记录，出现幻觉？
解决办法
-- 1. 打开命令行Jack，设置全局的隔离级别为 serializable set global transaction isolation level serializable; -- 2. 重复上面的操作：需要重新登录 会发现命令行Rose新增SQL提交后，没有立即执行，而是在等待Jack的事务结束 我们提交了Jack事务后，Rose新增SQL才执行完成，表示目前事务是串行化的
08.索引概述和作用
等同字典的目录
MySQL官方对索引的定义为：索引（index）是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护者满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据， 这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。
左边是数据表，一共有两列七条记录，最左边的是数据记录的物理地址（注意逻辑上相邻的记录在磁盘上也并不是一定物理相邻的）。为了加快Col2的查找，可以维护一个右边所示的二叉查找树，每个节点分别包含索引键值和一个指向对应数据记录物理地址的指针，这样就可以运用二叉查找快速获取到相应数据。
一般来说索引本身也很大，不可能全部存储在内存中，因此索引往往以索引文件的形式存储在磁盘上。索引是数据库中用来提高性能的最常用的工具。
09.索引优劣势
优势
1） 类似于书籍的目录索引，提高数据检索的效率，降低数据库的IO成本。
2） 通过索引列对数据进行排序，降低数据排序的成本，降低CPU的消耗。
劣势
1） 实际上索引也是一张表，该表中保存了主键与索引字段，并指向实体类的记录，所以索引列也是要占用空间的。
2） 虽然索引大大提高了查询效率，同时却也降低更新表的速度，如对表进行INSERT、UPDATE、DELETE。因为更新表时，MySQL 不仅要保存数据，还要保存一下索引文件每次更新添加了索引列的字段，都会调整因为更新所带来的键值变化后的索引信息。
10.存储引擎和索引数据结构
索引是在MySQL的存储引擎层中实现的，而不是在服务器层实现的。所以每种存储引擎的索引都不一定完全相同，也不是所有的存储引擎都支持所有的索引类型的。MySQL目前提供了以下4种索引：
- BTREE 索引 ：最常见的索引类型，大部分索引都支持 B 树索引。
- HASH 索引：只有Memory引擎支持 ， 使用场景简单 。
- R-tree 索引（空间索引）：空间索引是MyISAM引擎的一个特殊索引类型，主要用于地理空间数据类型，通常使用较少，不做特别介绍。
- Full-text （全文索引） ：全文索引也是MyISAM的一个特殊索引类型，主要用于全文索引，InnoDB从
Mysql5.6版本开始支持全文索引。
我们平常所说的索引，如果没有特别指明，都是指B+树（多路搜索树，并不一定是二叉的）结构组织的索引。其中聚集索引、复合索引、前缀索引、唯一索引默认都是使用 B+tree 索引，统称为 索引。
11.索引结构-BTree结构
BTREE 和二叉树相比，查询效率更高
BTREE 结构
BTree又叫多路平衡搜索树，一颗m叉的BTree特性如下： m=5
- 树中每个节点最多包含 m个孩子。 5
- 除根节点与叶子节点外，每个节点至少有 [ceil(m/2)]个孩子。3
- 若根节点不是叶子节点，则至少有两个孩子。
- 所有的叶子节点都在同一层。
- 每个非叶子节点由 n个key与n+1个指针组成，其中[ceil(m/2)-1] <= n <= m-1
以5叉BTree为例，key的数量：公式推导[ceil(m/2)-1] <= n <= m-1。所以 2 <= n <=4 。当n>4时，中间节点分裂到父节点，两边节点分裂。
每个节点上,key的数量: m=5 [ceil(m/2)-1] <= n <= m-1 2 <= n <= 4
插入 3 14 7 1 8 5 11 17 13 6 23 12 20 26 4 16 18 24 25 19 数据为例
演变过程如下：
1). 插入前4个数字 3 14 7 1
到此，该 BTREE树就已经构建完成了， BTREE树 和 二叉树 相比， 查询数据的效率更高， 因为对于相同的数据量来说，BTREE的层级结构比二叉树小，因此搜索速度快。
12.B+Tree结构
B+Tree为BTree的变种，B+Tree与BTree的区别为：
- n叉B+Tree最多含有n个key，而BTree最多含有n-1个key。
- B+Tree的叶子节点保存所有的key信息，依key大小顺序排列。
- 所有的非叶子节点都可以看作是key的索引部分。
由于 B+Tree只有叶子节点保存key信息，查询任何key都要从root走到叶子。所以B+Tree的查询效率更加稳定。
MySQL中的B+Tree
MySql索引数据结构对经典的B+Tree进行了优化。在原B+Tree的基础上，增加一个指向相邻叶子节点的链表指针，就形成了带有顺序指针的B+Tree，提高区间访问的性能。
MySQL中的 B+Tree 索引结构示意图:
13.索引使用-创建-查看-删除索引
索引分类
- 单值索引 ：即一个索引只包含单个列，一个表可以有多个单列索引
- 唯一索引 ：索引列的值必须唯一，但允许有空值
- 复合索引 ：即一个索引包含多个列
索引语法
索引在创建表的时候，可以同时创建， 也可以随时增加新的索引。
什么是索引？
索引是一张特殊的表，该表保存了主键与索引字段，并指向实体表的记录。
先假设有一张表student,表的数据有100万条数据,其中有一条数据是 name="xiaoming"，如果要拿这条数据的话需要写的sql是
select * from student where name='xiaoming'
一般情况下,在没有建立索引的时候，MySQL 需要扫描全表及扫描 100 万条数据找这条数据，这个效率实际上是非常慢的，那么有什么优化方法呢？答案就是索引。
如果我在name字段上建立索引，那么 MySQL 只需要扫描一行数据及为我们找到这条name='xiaoming'的数据,是不是感觉性能提升了好多咧....
单列索引分类和创建
我们使用最常见的是单列索引，分为主键索引、普通索引和唯一索引。
1.主键索引
主键索引一般在建表时创建，不允许有空值并且值唯一，最好是与表的其他字段不相关的列或者是业务不相关的列。一般会设为 int 而且是 AUTO_INCREMENT 自增类型的，例如一般表的 id 字段。
创建主键索引一般建表时使用 primary 关键字，例如如下语句:
CREATE TABLE `student` (
`ID` int(11) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
2.普通索引
普通索引实际上是我们最常见的，比如上述提到的例子，我们给name增加一个普通索引如下:
创建普通索引 CREATE INDEX name_index ON `student`(`name`); 或者是： ALTER TABLE student ADD INDEX name_index(`name`);
注意这里的 ` 不是单引号，而是键盘 1 数字左边的符；
3.唯一索引
唯一索引和主键索引类似，要求字段唯一，但是可以允许字段为空，创建语句如下:
创建唯一索引 CREATE UNIQUE INDEX name_index ON `student`(`name`);
CREATE UNIQUE INDEX name_index ON `student`(`name`);
唯一索引可以用来对数据进行强制性要求，可以禁止某表的某个字段出现重复数据。
语法总结
1.创建索引 创建普通索引 CREATE INDEX name_index ON `student`(`name`); ALTER TABLE student ADD INDEX name_index(`name`); 创建唯一索引 CREATE UNIQUE INDEX name_index ON `student`(`name`); 2.查看索引 show index from table_name; 3.删除索引 DROP INDEX index_name ON tbl_name;
14.索引使用前后差别
索引比较
create table user(
id int(11),
name varchar(20)
);
DELIMITER $
CREATE PROCEDURE pro12(n INT)
BEGIN
REPEAT
SET n = n - 1;
INSERT INTO `user` (id,NAME) VALUES(n,CONCAT("tom",n));
UNTIL n=0
END REPEAT;
END$
DELIMITER ;
CALL pro12(1000000);
create table user1(
id int(11) primary key auto_increment,
name varchar(20)
);
DELIMITER $
CREATE PROCEDURE pro15(n INT)
BEGIN
REPEAT
SET n = n - 1;
INSERT INTO `user1` (id,`name`) VALUES(NULL,CONCAT("tom",n));
UNTIL n=0
END REPEAT;
END$
DELIMITER ;
CALL pro15(1000000);
15.上午总结
多线程访问数据库表
存在的问题:
脏读: 一个事务读取到了另一个事务未提交的数据
不可重复读: 在一个事务中,运行相同的sql查询的结果不一致 (修改)
幻读(虚读):在一个事务中,运行相同的sql查询的结果不一致 (删除和添加)
事务的隔离级别:
1. Read uncommitted (读未提交)
级别最低，会同时出现三种问题
2. Read committed (读已提交)
可以解决脏读的问题 Oracle
3. Repeatable read (可重复读)：可以解决脏读和不可重复读的问题
mysql默认的
4. Serializable (串行化)： 所有的事务都是以串行的方式执行，没有并发执行的事务
查看和设置mysql的隔离级别
-- 查询事务隔离级别
select @@tx_isolation;
-- 设置全局事务隔离级别
set global transaction isolation level 四种级别名字;
set global transaction isolation level Repeatable read;
索引:
储存引擎: 将数据保存到硬盘上
存储结构: BTree B+Tree
作用:
有了索引,可以提高查询效率
增删改效率降低,更新数据时,也需要更新对应索引数据
16.索引使用原则
索引设计原则
索引的设计可以遵循一些已有的原则，创建索引的时候请尽量考虑符合这些原则，便于提升索引的使用效率，更高效的使用索引。
- 对查询频次较高，且数据量比较大的表建立索引。
- 索引字段的选择，最佳候选列应当从 where子句的条件中提取。
3.使用唯一索引，区分度越高，使用索引的效率越高。
- 索引可以有效的提升查询数据的效率，但索引数量不是多多益善，索引越多，维护索引的代价自然也就水涨船高。对于插入、更新、删除等DML操作比较频繁的表来说，索引过多，会引入相当高的维护代价，降低DML操作的效率，增加相应操作的时间消耗。另外索引过多的话，MySQL也会犯选择困难病，虽然最终仍然会找到一个可用的索引，但无疑提高了选择的代价。
- 使用短索引，索引创建之后也是使用硬盘来存储的，因此提升索引访问的 I/O效率，也可以提升总体的访问效率。假如构成索引的字段总长度比较短，那么在给定大小的存储块内可以存储更多的索引值，相应的可以有效的提升MySQL访问索引的I/O效率。
6.利用最左前缀， N个列组合而成的组合索引，那么相当于是创建了N个索引，如果查询时where子句中使用了组成该索引的前几个字段，那么这条查询SQL可以利用组合索引来提升查询效率。
1.针对查询频次高的字段建索引 2.使用唯一索引 3.使用索引时,并不是越多越好,需要考虑数据的变动频次 4.给占用空间小的字段建索引(索引也需要占用硬盘空间) 5.建议使用组合索引
创建复合索引 :
CREATE INDEX idx_name_email_status ON tb_seller(NAME,email,STATUS);
就相当于
对name 创建索引 ;
对name , email 创建了索引 ;
对name , email, status 创建了索引 ;
17.视图-简单使用
视图（view）：把临时表的数据储存起来了，视图就是一条SELECT语句执行后返回的结果集
创建视图
create view 视图名 as 查询的sql语句；
查看视图中的数据
select * from 视图名；
查询视图
show tables；
show views；
修改视图
alter view 视图名 as 查询的sql语句
删除视图
DROP VIEW 视图名 ;
18.触发器-概述
概述：日志记录的开关
| 触发器类型 |
NEW 和 OLD的使用 |
| INSERT 型触发器 |
NEW 表示将要或者已经新增的数据 |
| UPDATE 型触发器 |
OLD 表示修改之前的数据 , NEW 表示将要或已经修改后的数据 |
| DELETE 型触发器 |
OLD 表示将要或者已经删除的数据 |
19.触发器-添加型触发器
示例 需求: 通过触发器记录 emp 表的数据变更日志 , 包含增加, 修改 , 删除 ;
sql脚本: 创建一张日志表,存放日志信息
create table emp_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;
创建 insert 型触发器，完成插入数据时的日志记录 :
DELIMITER $ -- 设置分割符
CREATE TRIGGER emp_insert_trigger
AFTER INSERT
ON emp
FOR EACH ROW
BEGIN
INSERT INTO emp_logs (id,operation,operate_time,operate_id,operate_params) VALUES(
NULL,'insert',NOW(),new.id,
CONCAT('新增的数据为:',new.ename,'-',new.salary)
);
END $ -- sql结束
DELIMITER ;
其中new.id，new.ename的new意思是新添加的数据
20.触发器-修改型和删除型触器
创建 update 型触发器，完成更新数据时的日志记录 :
# 修改触发器
DELIMITER $ -- 设置分割符
CREATE TRIGGER emp_update_trigger
AFTER UPDATE
ON emp
FOR EACH ROW
BEGIN
INSERT INTO emp_logs (id,operation,operate_time,operate_id,operate_params) VALUES(
NULL,'update',NOW(),old.id,
CONCAT('修改前:',old.ename,'~',old.salary,'修改后:',new.ename,'-',new.salary)
);
END $ -- sql结束
DELIMITER ;
-- 执行修改语句
UPDATE emp SET ename='齐天大圣',salary=8 WHERE id = 1001;
创建delete 行的触发器 , 完成删除数据时的日志记录 :
# 删除型触发器
DELIMITER $ -- 设置分割符
CREATE TRIGGER emp_delete_trigger
AFTER DELETE
ON emp
FOR EACH ROW
BEGIN
INSERT INTO emp_logs (id,operation,operate_time,operate_id,operate_params) VALUES(
NULL,'delete',NOW(),old.id,
CONCAT('删除前的数据:',old.ename,'~',old.salary)
);
END $ -- sql结束
DELIMITER ;
-- 删除员工信息
DELETE FROM emp WHERE id = 1001;
测试:
-- 添加员工信息,查看日志表数据 insert into emp(id,name,age,salary) values(null, '光明左使',30,3500); insert into emp(id,name,age,salary) values(null, '光明右使',33,3200);
21.查看和删除触发器
创建触发器
create trigger 触发器名 before/after insert/update/delete on 表名 [ for each row ] -- 行级触发器,行数据发生改变时触发 begin trigger_stmt ;-- 触发器被触发后执行的sql语句 end;
查看触发器
show triggers ;
删除触发器
drop trigger trigger_name
22.存储过程概述
概述：跟函数差不多，实现了指定功能的代码片段
调用格式：
call 存储过程名（）；
函数: 相当于java中有返回值的方法 过程: 相当于java中没有返回值的方法
23.存储过程-创建-调用-查询
创建存储过程
CREATE PROCEDURE procedure_name ([proc_parameter[,...]])
begin
-- 编写SQL语句集
end ;
示例：
delimiter $ create procedure pro_test1() begin select 'Hello Mysql' ; end$ delimiter ;
知识小贴士
DELIMITER
该关键字用来声明SQL语句的分隔符 , 告诉 MySQL 解释器，该段命令是否已经结束了，mysql是否可以执行了。
默认情况下，delimiter是分号 ; 。在命令行客户端中，如果有一行命令以分号结束，那么回车后，mysql将会执行该命令。
调用存储过程
call procedure_name() ;
查看存储过程
-- 查询db_name数据库中的所有的存储过程 select name from mysql.proc where db='数据库名称'; -- 查询存储过程的状态信息 show procedure status; -- 查询某个存储过程的定义 show create procedure 数据库名.存储过程名称 \G;
删除存储过程
DROP PROCEDURE [IF EXISTS] 存储过程名称 ;
24.存储过程语法-变量声明与赋值
存储过程是可以编程的，意味着可以使用变量，表达式，控制结构 ， 来完成比较复杂的功能。
定义变量declare
在存储过程中我们可以去定义变量，格式如下：
declare 变量名称 变脸类型 default 默认值； 例如 ： declare num int(11) default 0;
delimiter $
create procedure pro02()
begin
declare num int(11) default 0;
select concat("num+10后的结果为："+(num+10)); -- 这里就相当于输出语句了
end $
delimiter ;
-- 调用存储过程
call pro02();
赋值set
直接赋值使用 SET，可以赋常量或者赋表达式
SET var_name = expr [, var_name = expr] ...
SELECT 查询结果 into 变量 form 表名;
eg: 直接给变量赋值
set 变量名称 = 值;
set num = 20;
eg1: 将查询结果赋值给一个变量
SELECT 查询结果 into 变量 form 表名;
select count(*) into num from city;
DELIMITER $
CREATE PROCEDURE pro03()
BEGIN
-- 变量声明
DECLARE num INT(11) DEFAULT 0;
SET num = 5;
SELECT CONCAT("num+10后的结果为: "+(num+10));
END $
DELIMITER ;
# 调用存储过程
CALL pro03();
也可以通过select ... into 方式进行赋值操作 :
```sql
DELIMITER $
CREATE PROCEDURE pro04()
BEGIN
-- 变量声明
DECLARE num INT(11) DEFAULT 0;
SELECT COUNT(*) INTO num FROM city;
SELECT CONCAT("city表数据总数为: "+num);
END $
DELIMITER ;
# 调用存储过程
CALL pro04();
25.if判断
/*
if判断:
格式:
if 条件 then -- 满足条件则执行then后面的sql语句
执行的sql;
elseif 条件 then -- 满足条件则执行then后面的sql语句
执行sql语句;
else -- 当不满足以上条件,则执行then后面的sql语句
执行sql语句;
end if; -- 结束if判断
根据定义的身高变量，判定当前身高的所属的身材类型
180 及以上 ----------> 身材高挑
170 - 180 ---------> 标准身材
170 以下 ----------> 一般身材
*/
DELIMITER $
CREATE PROCEDURE pro05()
BEGIN
-- 声明变量
DECLARE height INT(11) DEFAULT 175;
IF height>=180 THEN -- 满足条件则执行then后面的sql语句
SELECT "身材高挑";
ELSEIF height<180 AND height>=170 THEN -- 满足条件则执行then后面的sql语句
SELECT "标准身材";
ELSE -- 当不满足以上条件,则执行then后面的sql语句
SELECT "一般身材";
END IF; -- 结束if判断
END $
DELIMITER ;
# 调用存储过程
CALL pro05;
26.传入传出参数格式
传递参数
create procedure procedure_name([in/out/inout] 参数名 参数类型) ... IN : 该参数可以作为输入，也就是需要调用方传入值 , 默认 OUT: 该参数作为输出，也就是该参数可以作为返回值 INOUT: 既可以作为输入参数，也可以作为输出参数 用户会话变量: 调用有返回值的存储过程 call 存储过程的名称(输入参数,@输出参数名) 注释: @输出参数为用户会话变量 获取会话变量: @变量名称 eg: create procedure pro05(in height int) 执行相关判断操作即可
IN 输入
需求:
根据定义的身高变量，判定当前身高的所属的身材类型
delimiter $
create procedure pro_test7(in height int)
begin
declare description varchar(50) default '';
if height >= 180 then
set description='身材高挑';
elseif height >= 170 and height < 180 then
set description='标准身材';
else
set description='一般身材';
end if;
select concat('身高 ', height , '对应的身材类型为:',description);
end$
delimiter ;
OUT 输出
需求:
根据传入的身高变量，获取当前身高的所属的身材类型
sql语句:
delimiter $
create procedure pro_test8(in height int , out description varchar(100))
begin
if height >= 180 then
set description='身材高挑';
elseif height >= 170 and height < 180 then
set description='标准身材';
else
set description='一般身材';
end if;
end$
delimiter ;
知识小贴士
@变量名称 : 这种变量要在变量名称前面加上“@”符号，叫做用户会话变量，代表整个会话过程他都是有作用的，这个类似于全局变量一样。
@@global.sort_buffer_size : 这种在变量前加上 "@@" 符号, 叫做 系统变量
课堂代码
# ------------传入参数 in
DELIMITER $
CREATE PROCEDURE pro06(IN height INT(11))
BEGIN
IF height>=180 THEN -- 满足条件则执行then后面的sql语句
SELECT "身材高挑";
ELSEIF height<180 AND height>=170 THEN -- 满足条件则执行then后面的sql语句
SELECT "标准身材";
ELSE -- 当不满足以上条件,则执行then后面的sql语句
SELECT "一般身材";
END IF; -- 结束if判断
END $
DELIMITER ;
# 调用存储过程
CALL pro06(158);
# ---------传出参数 out
DELIMITER $
CREATE PROCEDURE pro07(IN height INT(11),OUT description VARCHAR(50))
BEGIN
IF height>=180 THEN -- 满足条件则执行then后面的sql语句
SET description = "身材高挑";
ELSEIF height<180 AND height>=170 THEN -- 满足条件则执行then后面的sql语句
SET description = "标准身材";
ELSE -- 当不满足以上条件,则执行then后面的sql语句
SET description = "一般身材";
END IF; -- 结束if判断
END $
DELIMITER ;
# 调用存储过程
/*
传出参数格式:
会话变量: 当前会话可以使用
@变量名
全局变量:
@@变量名
@@isolation
*/
CALL pro07(158,@des);
# ---------传入传出参数 inout
DELIMITER $
CREATE PROCEDURE pro08(INOUT str VARCHAR(20))
BEGIN
SELECT CONCAT("传进来的参数值为: ",str);
SET str = "哈哈哈哈哈哈";
END $
DELIMITER ;
# 调用存储过程,并传入参数(传入传出)
CALL pro08(@str);
SELECT @str;
27.case结构
方式一 :
CASE case_value
WHEN when_value THEN statement_list
[WHEN when_value THEN statement_list] ...
[ELSE statement_list]
END CASE;
eg:
case 1
when 1 then
执行的sql;
when 2 then
执行的sql;
when 3 then
执行的sql;
else
执行的sql;
end case;
方式二 :
CASE
WHEN search_condition THEN statement_list
[WHEN search_condition THEN statement_list] ...
[ELSE statement_list]
END CASE;
eg:
case
when 条件 then
执行的sql;
when 条件 then
执行的sql;
when 条件 then
执行的sql;
else
执行的sql;
end case;
需求:
给定一个月份 , 然后计算出所在的季度
sql
delimiter $
create procedure pro_test9(month int)
begin
declare result varchar(20);
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 = '第四季度';
end case;
select concat('您输入的月份为 :', month , ',该月份为 : ' , result) as content ;
end$
delimiter ;
课堂代码
# -------------case选择
/*
需求: 给定一个月份 , 然后计算出所在的季度
格式1:
case 1
when 1 then
执行的sql;
when 2 then
执行的sql;
when 3 then
执行的sql;
else
执行的sql;
end case;
格式2:
case
when 条件 then
执行的sql;
when 条件 then
执行的sql;
when 条件 then
执行的sql;
else
执行的sql;
end case;
*/
DELIMITER $
CREATE PROCEDURE pro09(IN mon INT(2))
BEGIN
CASE
WHEN mon>=1 AND mon<=3 THEN
SELECT "第一季度";
WHEN mon>=4 AND mon<=6 THEN
SELECT "第二季度";
WHEN mon>=7 AND mon<=9 THEN
SELECT "第三季度";
WHEN mon>=10 AND mon<=12 THEN
SELECT "第四季度";
ELSE
SELECT "输入无效!!";
END CASE;
END $
DELIMITER ;
# 调用存储过程
CALL pro09(16);
DELIMITER $
CREATE PROCEDURE pro10(IN n INT(2))
BEGIN
CASE n
WHEN 1 THEN
SELECT CONCAT('今晚: ',"吃鸡");
WHEN 2 THEN
SELECT CONCAT('今晚: ',"吃泡面");
WHEN 3 THEN
SELECT CONCAT('今晚: ',"捏脚");
WHEN 4 THEN
SELECT CONCAT('今晚: ',"大保健");
ELSE
SELECT "输入无效!!";
END CASE;
END $
DELIMITER ;
# 调用存储过程
CALL pro10(4);
28.多种循环
while循环
while search_condition do statement_list end while; eg: while 条件 do 执行sql; end while;
需求:
计算从 1加到n的值
sql
delimiter $
create procedure pro_test10(n int)
begin
declare total int default 0;
declare num int default 1;
while num<=n do
set total = total + num;
set num = num + 1;
end while;
select total;
end$
delimiter ;
repeat结构
有条件的循环控制语句, 当满足条件的时候退出循环 。while 是满足条件才执行，repeat 是满足条件就退出循环。
REPEAT
statement_list
UNTIL search_condition
END REPEAT;
eg: 当满足 until 关键字后面的条件时,退出循环
repeat
执行的sql语句;
until 条件;
end repeat;
需求:
计算从 1加到n的值
sql
delimiter $
create procedure pro_test11(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$
delimiter ;
loop语句
LOOP 实现简单的循环，退出循环的条件需要使用其他的语句定义，通常可以使用 LEAVE 语句实现
[begin_label:] LOOP
statement_list
END LOOP [end_label]
eg:
开始的标记:loop
执行的sql语句
end loop 结束标记
如果不在 statement_list 中增加退出循环的语句，那么 LOOP 语句可以用来实现简单的死循环。
leave语句
用来从标注的流程构造中退出，通常和 BEGIN ... END 或者循环一起使用。
需求: 使用loop和leave实现数字累加
sql:
delimiter $
CREATE PROCEDURE pro_test12(n int)
BEGIN
declare total int default 0;
ins: LOOP
IF n <= 0 then
leave ins;
END IF;
set total = total + n;
set n = n - 1;
END LOOP ins;
select total;
END$
delimiter ;
存储函数
CREATE FUNCTION function_name([param type ... ]) RETURNS type BEGIN ... END; eg:定义函数 create function 函数名称(参数名 参数类型) -- 定义函数 returns 数据类型 -- 声明返回值类型 begin sql语句集 return 变量名称; -- 返回值 end; 调用函数: select 函数名称(参数列表);
需求: 定义一个存储函数,根据传入的条件,计算满足条件的总记录数
delimiter $ create function count_city(countryId int) returns int begin declare cnum int ; select count(*) into cnum from city where country_id = countryId; return cnum; end$ delimiter ;
存储过程练习
需求:
将转账的业务,写入存储过程,调用存储过程实现转账的业务 ROW_COUNT() : 获取执行的sql对数据库的影响行数
sql
-- 创建表的sql
CREATE TABLE account(
id INT(11) PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20),
money FLOAT
);
INSERT INTO account VALUES(NULL,"tom",1000),(NULL,"rose",1000);
-- 存储过程sql
DELIMITER $
CREATE PROCEDURE pro_transfer(
IN fromSub VARCHAR(50),
IN toSub VARCHAR(50),
IN money_ FLOAT
)
BEGIN
DECLARE result INT(2) DEFAULT 0;
START TRANSACTION;
UPDATE account SET money=money-money_ WHERE `name`=fromSub;
IF ROW_COUNT() > 0 THEN
UPDATE account SET money=money+money_ WHERE `name`=toSub;
END IF;
IF ROW_COUNT() > 0 THEN
SET result = 1;
COMMIT;
ELSE
ROLLBACK;
END IF;
SELECT result;
END $
DELIMITER ;
29.游标
概述：是用来存储查询结果集的数据类型 , 在存储过程和函数中可以使用光标对结果集进行循环的处理。光标的使用包括光标的声明、OPEN、FETCH 和 CLOSE
将查询结果的一条记录存放到游标中，再从游标中获取数据信息。
DECLARE cursor_name CURSOR FOR select_statement ; -- 声明游标 OPEN cursor_name ; -- 打开游标 FETCH cursor_name INTO var_name [, var_name] ... ; -- 获取游标中的数据并赋给指定变量 CLOSE cursor_name ; -- 关闭游标 eg: declare 游标名称 cursor for 查询的sql; -- 将查询结果存放到游标中 declare 游标名称 cursor for select * from city; open 游标名称; -- 打开游标 fetch 游标名称 into 变量名称1,变量名称2,...; -- 获取游标中的数据并设置到指定的变量中 close 游标名称; -- 关闭游标
初始化脚本:
create table emp(
id int(11) not null auto_increment ,
name varchar(50) not null comment '姓名',
age int(11) comment '年龄',
salary int(11) comment '薪水',
primary key(`id`)
)engine=innodb default charset=utf8 ;
insert into emp(id,name,age,salary) values(null,'金毛狮王',55,3800),(null,'白眉鹰
王',60,4000),(null,'青翼蝠王',38,2800),(null,'紫衫龙王',42,1800);
方式1-实例sql:
delimiter $
create procedure pro_test13()
begin
declare e_id int(11);
declare e_name varchar(50);
declare e_age int(11);
declare e_salary int(11);
-- 创建游标
declare emp_result cursor for select * from emp;
open emp_result; -- 打开游标
fetch emp_result into e_id,e_name,e_age,e_salary;
select concat('id=',e_id , ', name=',e_name, ', age=', e_age, ', 薪资为:
',e_salary);
fetch emp_result into e_id,e_name,e_age,e_salary;
select concat('id=',e_id , ', name=',e_name, ', age=', e_age, ', 薪资为:
',e_salary);
fetch emp_result into e_id,e_name,e_age,e_salary;
select concat('id=',e_id , ', name=',e_name, ', age=', e_age, ', 薪资为:
',e_salary);
fetch emp_result into e_id,e_name,e_age,e_salary;
select concat('id=',e_id , ', name=',e_name, ', age=', e_age, ', 薪资为:
',e_salary);
close emp_result; -- 关闭游标
end$
delimiter ;
方式2-实例sql:
delimiter $
create procedure pro_test14()
begin
declare e_id int(11);
declare e_name varchar(50);
declare e_age int(11);
declare e_salary int(11);
declare has_data int default 1;
declare emp_result cursor for select * from emp; -- 创建游标
declare exit handler for not found set has_data = 0; -- 定义游标标记
open emp_result; -- 打开游标
repeat
fetch emp_result into e_id,e_name,e_age,e_salary;
select concat('id=',e_id , ', name=',e_name, ', age=', e_age, ', 薪资为: ',e_salary);
until has_data = 0
end repeat;
close emp_result; -- 关闭游标
end$
delimiter ;
课堂代码
/*
存储过程: 封装多条sql语句,当调用存储过程时,过程中封装的所有sql都会执行.
创建格式:
create procedure 存储过程名称
begin
sql语句集...
end;
调用格式:
call 存储过程名();
*/
DELIMITER $ -- 修改sql语句的分隔符
CREATE PROCEDURE pro01()
BEGIN
SELECT "hello 存储过程!";
END $
DELIMITER ; -- 设置回默认的分隔符
# 调用存储过程
CALL pro01;
CALL pro01();
-- 查询db_name数据库中的所有的存储过程
SELECT NAME FROM mysql.proc WHERE db='db5';
-- 查询存储过程的状态信息
SHOW PROCEDURE STATUS;
-- 查询某个存储过程的定义
SHOW CREATE PROCEDURE db5.pro01;
-- 删除存储过程
DROP PROCEDURE pro01;
-- ====================存储过程中的相关语法
/*
变量声明:
格式:
declare 变量名称 变量类型 default 默认值;
declare num int(11) default 0;
*/
DELIMITER $
CREATE PROCEDURE pro02()
BEGIN
-- 变量声明
DECLARE num INT(11) DEFAULT 0;
SELECT CONCAT("num+10后的结果为: "+(num+10));
END $
DELIMITER ;
# 调用存储过程
CALL pro02();
/*
改变变量的值:
eg: 直接给变量赋值
set 变量名称 = 值;
set num = 20;
eg1: 将查询结果赋值给一个变量
SELECT 查询结果 into 变量 form 表名;
select count(*) into num from city;
*/
DELIMITER $
CREATE PROCEDURE pro03()
BEGIN
-- 变量声明
DECLARE num INT(11) DEFAULT 0;
SET num = 5;
SELECT CONCAT("num+10后的结果为: "+(num+10));
END $
DELIMITER ;
# 调用存储过程
CALL pro03();
DELIMITER $
CREATE PROCEDURE pro04()
BEGIN
-- 变量声明
DECLARE num INT(11) DEFAULT 0;
SELECT COUNT(*) INTO num FROM city;
SELECT CONCAT("city表数据总数为: "+num);
END $
DELIMITER ;
# 调用存储过程
CALL pro04();
/*
if判断:
格式:
if 条件 then -- 满足条件则执行then后面的sql语句
执行的sql;
elseif 条件 then -- 满足条件则执行then后面的sql语句
执行sql语句;
else -- 当不满足以上条件,则执行then后面的sql语句
执行sql语句;
end if; -- 结束if判断
根据定义的身高变量，判定当前身高的所属的身材类型
180 及以上 ----------> 身材高挑
170 - 180 ---------> 标准身材
170 以下 ----------> 一般身材
*/
DELIMITER $
CREATE PROCEDURE pro05()
BEGIN
-- 声明变量
DECLARE height INT(11) DEFAULT 175;
IF height>=180 THEN -- 满足条件则执行then后面的sql语句
SELECT "身材高挑";
ELSEIF height<180 AND height>=170 THEN -- 满足条件则执行then后面的sql语句
SELECT "标准身材";
ELSE -- 当不满足以上条件,则执行then后面的sql语句
SELECT "一般身材";
END IF; -- 结束if判断
END $
DELIMITER ;
# 调用存储过程
CALL pro05;
# ------------传入参数 in
DELIMITER $
CREATE PROCEDURE pro06(IN height INT(11))
BEGIN
IF height>=180 THEN -- 满足条件则执行then后面的sql语句
SELECT "身材高挑";
ELSEIF height<180 AND height>=170 THEN -- 满足条件则执行then后面的sql语句
SELECT "标准身材";
ELSE -- 当不满足以上条件,则执行then后面的sql语句
SELECT "一般身材";
END IF; -- 结束if判断
END $
DELIMITER ;
# 调用存储过程
CALL pro06(158);
# ---------传出参数 out
DELIMITER $
CREATE PROCEDURE pro07(IN height INT(11),OUT description VARCHAR(50))
BEGIN
IF height>=180 THEN -- 满足条件则执行then后面的sql语句
SET description = "身材高挑";
ELSEIF height<180 AND height>=170 THEN -- 满足条件则执行then后面的sql语句
SET description = "标准身材";
ELSE -- 当不满足以上条件,则执行then后面的sql语句
SET description = "一般身材";
END IF; -- 结束if判断
END $
DELIMITER ;
# 调用存储过程
/*
传出参数格式:
会话变量: 当前会话可以使用
@变量名
全局变量:
@@变量名
@@isolation
*/
CALL pro07(158,@des);
# ---------传入传出参数 inout
DELIMITER $
CREATE PROCEDURE pro08(INOUT str VARCHAR(20))
BEGIN
SELECT CONCAT("传进来的参数值为: ",str);
SET str = "哈哈哈哈哈哈";
END $
DELIMITER ;
# 调用存储过程,并传入参数(传入传出)
CALL pro08(@str);
SELECT @str;
# -------------case选择
/*
需求: 给定一个月份 , 然后计算出所在的季度
格式1:
case 1
when 1 then
执行的sql;
when 2 then
执行的sql;
when 3 then
执行的sql;
else
执行的sql;
end case;
格式2:
case
when 条件 then
执行的sql;
when 条件 then
执行的sql;
when 条件 then
执行的sql;
else
执行的sql;
end case;
*/
DELIMITER $
CREATE PROCEDURE pro09(IN mon INT(2))
BEGIN
CASE
WHEN mon>=1 AND mon<=3 THEN
SELECT "第一季度";
WHEN mon>=4 AND mon<=6 THEN
SELECT "第二季度";
WHEN mon>=7 AND mon<=9 THEN
SELECT "第三季度";
WHEN mon>=10 AND mon<=12 THEN
SELECT "第四季度";
ELSE
SELECT "输入无效!!";
END CASE;
END $
DELIMITER ;
# 调用存储过程
CALL pro09(16);
DELIMITER $
CREATE PROCEDURE pro10(IN n INT(2))
BEGIN
CASE n
WHEN 1 THEN
SELECT CONCAT('今晚: ',"吃鸡");
WHEN 2 THEN
SELECT CONCAT('今晚: ',"吃泡面");
WHEN 3 THEN
SELECT CONCAT('今晚: ',"捏脚");
WHEN 4 THEN
SELECT CONCAT('今晚: ',"大保健");
ELSE
SELECT "输入无效!!";
END CASE;
END $
DELIMITER ;
# 调用存储过程
CALL pro10(4);
# ----------------循环-while
/*
需求: 计算从 1加到n的值
格式:
while 条件 do
要执行的sql
end while;
*/
DELIMITER $
CREATE PROCEDURE pro11(n INT(11))
BEGIN
DECLARE total INT(11) DEFAULT 0;
WHILE n>0 DO
SET total = total + n;
SET n = n - 1;
END WHILE;
SELECT CONCAT("计算结果为: ",total);
END $
DELIMITER ;
CALL pro11(100);
/*
eg: 当满足 until 关键字后面的条件时,退出循环
repeat
执行的sql语句;
until 条件;
end repeat;
*/
DELIMITER $
CREATE PROCEDURE pro12(n INT(11))
BEGIN
DECLARE total INT(11) DEFAULT 0;
REPEAT
SET total = total + n;
SET n = n - 1;
UNTIL n = 0
END REPEAT;
SELECT CONCAT("计算结果为: ",total);
END $
DELIMITER ;
CALL pro12(10000);
/*
eg:
循环标记:loop
执行的sql语句
leave 循环标记; -- 什么时候结束循环
end loop 循环标记
*/
DELIMITER $
CREATE PROCEDURE pro13(n INT(11))
BEGIN
DECLARE total INT(11) DEFAULT 0;
ints:LOOP
SET total = total + n;
SET n = n - 1;
IF n=0 THEN
LEAVE ints;
END IF;
END LOOP ints;
SELECT CONCAT("计算结果为: ",total);
END $
DELIMITER ;
CALL pro13(10000);
-- =====================游标
CREATE TABLE emp2(
id INT(11) NOT NULL AUTO_INCREMENT ,
NAME VARCHAR(50) NOT NULL COMMENT '姓名',
age INT(11) COMMENT '年龄',
salary INT(11) COMMENT '薪水',
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8 ;
INSERT INTO emp2(id,NAME,age,salary) VALUES(NULL,'金毛狮王',55,3800),(NULL,'白眉鹰
王',60,4000),(NULL,'青翼蝠王',38,2800),(NULL,'紫衫龙王',42,1800);
/*
作用:将查询结果的一条记录存放到游标中,再从游标中获取数据信息
格式:
declare 游标名称 cursor for 查询的sql; -- 将查询结果存放到游标中
declare 游标名称 cursor for select * from city;
open 游标名称; -- 打开游标
fetch 游标名称 into 变量名称1,变量名称2,...; -- 获取游标中的数据并设置到指定的变量中
close 游标名称; -- 关闭游标
*/
DELIMITER $
CREATE PROCEDURE pro14()
BEGIN
DECLARE id INT(11);
DECLARE `name` VARCHAR(30);
DECLARE age INT(11);
DECLARE salary INT(11);
-- 创建游标
DECLARE emp_cur CURSOR FOR SELECT * FROM emp2;
-- 打开游标
OPEN emp_cur;
FETCH emp_cur INTO id,`name`,age,salary;
SELECT CONCAT('id=',id ,',name=',`name`,',age=',age,',薪资为:',salary);
FETCH emp_cur INTO id,`name`,age,salary;
SELECT CONCAT('id=',id ,',name=',`name`,',age=',age,',薪资为:',salary);
FETCH emp_cur INTO id,`name`,age,salary;
SELECT CONCAT('id=',id ,',name=',`name`,',age=',age,',薪资为:',salary);
FETCH emp_cur INTO id,`name`,age,salary;
SELECT CONCAT('id=',id ,',name=',`name`,',age=',age,',薪资为:',salary);
CLOSE emp_cur;
END $
DELIMITER ;
CALL pro14();
DELIMITER $
CREATE PROCEDURE pro15()
BEGIN
DECLARE id INT(11);
DECLARE `name` VARCHAR(30);
DECLARE age INT(11);
DECLARE salary INT(11);
DECLARE total INT(11);
-- 创建游标
DECLARE emp_cur CURSOR FOR SELECT * FROM emp2;
-- 查询总条数,赋给total
SELECT COUNT(*) INTO total FROM emp2;
-- 打开游标
OPEN emp_cur;
REPEAT
FETCH emp_cur INTO id,`name`,age,salary;
SELECT CONCAT('id=',id ,',name=',`name`,',age=',age,',薪资为:',salary);
SET total = total - 1;
UNTIL total = 0
END REPEAT;
CLOSE emp_cur;
END $
DELIMITER ;
作业
练习课上所讲内容,理解事务,索引,视图,触发器的作用和应用场景