前言
重新温习一下MySQL，将以前的知识系统的总结。
扩展
Liunx 全操作过程 【JDK1.8配置、MySQL、Docker、mariaDB、nginx、tomcat、redis、各种问题解决总结】
mysql基础语句
登录mysql
mysql -u root -p 敲回车，输入密码
初始密码查看：cat /var/log/mysqld.log
在root@localhost: 后面的就是初始密码
修改mysql登录密码
set global validate_password_policy=0;
set global validate_password_length=1;
set password=password('密码');
授予远程连接权限
//授权
grant all privileges on *.* to 'root' @'%' identified by '密码';
//刷新
flush privileges;
关闭Linux系统防火墙
systemctl stop firewalld.service
数据库的注释：
-
单行注释：-- 注释内容 #注释内容(mysql特有)
-
多行注释：/* 注释内容 */
SQL分类
DDL(Data Definition Language)数据定义语言
用来定义数据库对象：数据库，表，列等。关键字：create, drop,alter 等
DML(Data Manipulation Language)数据操作语言
用来对数据库中表的数据进行增删改。关键字：insert, delete, update 等
DQL(Data Query Language)数据查询语言
用来查询数据库中表的记录(数据)。关键字：select, where 等
DCL(Data Control Language)数据控制语言(了解)
用来定义数据库的访问权限和安全级别，及创建用户。关键字：GRANT， REVOKE 等
DDL-操作数据库
-- 查询所有数据库
SHOW DATEBASES;
-- 查询某个数据库的创建语句
SHOW CREATE DATABASE 数据库名称;
-- 查看mysql数据库的创建格式
SHOW CREATE DATABASE mysql;
-- 创建数据库
CREATE DATABASE 数据库名称;
-- 创建数据库（判断数据库是否存在，不存在则创建）
CREATE DATABASE IF NOT EXISTS 数据库名称;
-- 创建数据库、并指定字符集
CREATE DATABASE 数据库名称 CHARACTER SET 字符集名称;
-- 删除数据库
DROP DATABASE 数据库名称;
-- 删除数据库（判断数据库是否存在，如果存在则删除）
DROP DATABASE IF EXISTS 数据库名称;
-- 查询正在使用的数据库名称
SELECT DATABASE();
-- 使用数据库
USE 数据库名称;DDL-操作数据表
-- 查询数据库中所有的数据表
SHOW TABLES;
-- 查询表结构
DESC 表名;
-- 查询表字符集
SHOW TABLE STATUS FROM 数据库名 LIKE '表名';
-- 创建数据表
CREATE TABLE 表名(
列名1 数据类型1,
列名2 数据类型2,
...
列名n 数据类型n,
);
数据类型
1. int ：整数类型
eg ：age int -- 年龄
2. double ： 小数类型
eg : score double(5,2) -- 成绩
3. date : 日期，只能包含年月日 -- yyyy-MM-dd
4. datetime : 日期，包含年月日时分秒 -- yyyy-MM-dd HH:mm:ss
5. timestamp : 时间戳类型，包含年月日时分秒 -- yyyy-MM-dd HH:mm:ss
注意：时间戳类型可以为空，默认使用当前系统时间
6. varchar : 字符串
eg : name varchar(20)
-- 创建临时数据表(关闭数据库，临时表就不存在）
CREATE TEMPORARY TABLE 表名(
列名1 数据类型1,
列名2 数据类型2,
...
列名n 数据类型n,
);
-- 复制表
CREATE TABLE 表名 LIKE 被复制的表名;
-- 修改表名
ALTER TABLE 表名 RENAME TO 新表名;
-- 添加字段
ALTER TABLE 表名 ADD 列名 数据类型;
-- 修改数据类型
ALTER TABLE 表名 MODIFY 列名 新数据类型;
-- 修改列名和数据类型
ALTER TABLE 表名 CHANGE 列名 新列名 新数据类型;
-- 删除列
ALTER TABLE 表名 DROP 列名;
-- 删除数据表
DROP TABLE 表名;
-- 删除数据表（判断数据表是否存在，存在则删除）
DROP TABLE IF EXISTS 表名;DML-操作数据表数据
-- 增加数据（对应列名的数据）
INSERT INTO 表名(列名1,列名2,...) VALUES (值1,值2,...);
-- 增加所有的数据
INSERT INTO 表名 VALUES (值1,值2,...);
-- 批量增加数据
INSERT INTO 表名 VALUES (值1,值2,...),(值1,值2,...),(值1,值2,...);
-- 修改数据
UPDATE 表名 SET 列名1 = 值1, 列名2 = 值2, ... [where 条件];
-- 删除数据
DELETE FROM 表名 [where 条件];DQL-单表查询
-- 查询
select
字段列表
from
表名列表
where
条件列表
group by
分组字段
having
分组之后的条件
order by
排序
limit
分页限定
-- 查询全部
SELECT * FROM 表名;
-- 去除重复查询
SELECT DISTINCT 列名1,列名2,... FROM 表名;
-- 计算列的值(四则运算)
SELECT 列名1 运算符(+ - * /) 列名2 FROM 表名;
-- 查看商品名称，商品库存数量加10
eg : SELECT name,stock+10 FROM product;
-- 查看商品名称，商品库存数量加10，并进行非空判断
eg : SELECT name,IFNULL(stock,0)+10 FROM product;
-- 起别名
SELECT 列名1,列名2,... AS 别名 FROM 表名;条件查询
| 符号 | 功能 |
|---|---|
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
| = | 等于 |
| <> 或 != | 不等于 |
| BETWEEN ... AND ... | 在某个范围之内(都包含) |
| IN(...) | 多选一 |
| LIKE 占位符 | 模糊查询 _单个任意字符 %多个任意字符 |
| IS NULL | 是NULL |
| IS NOT NULL | 不是NULL |
| AND 或 && | 并且 |
| OR 或 || | 或者 |
| NOT 或 ! | 非，不是 |
例子：
-- 标准语法
SELECT 列名 FROM 表名 WHERE 条件;
-- 查询库存大于20的商品信息
SELECT * FROM product WHERE stock > 20;
-- 查询品牌为华为的商品信息
SELECT * FROM product WHERE brand='华为';
-- 查询金额在4000 ~ 6000之间的商品信息
SELECT * FROM product WHERE price >= 4000 AND price <= 6000;
SELECT * FROM product WHERE price BETWEEN 4000 AND 6000;
-- 查询库存为14、30、23的商品信息
SELECT * FROM product WHERE stock=14 OR stock=30 OR stock=23;
SELECT * FROM product WHERE stock IN(14,30,23);
-- 查询库存为null的商品信息
SELECT * FROM product WHERE stock IS NULL;
-- 查询库存不为null的商品信息
SELECT * FROM product WHERE stock IS NOT NULL;
-- 查询名称以小米为开头的商品信息
SELECT * FROM product WHERE NAME LIKE '小米%';
-- 查询名称第二个字是为的商品信息
SELECT * FROM product WHERE NAME LIKE '_为%';
-- 查询名称为四个字符的商品信息
SELECT * FROM product WHERE NAME LIKE '____';
-- 查询名称中包含电脑的商品信息
SELECT * FROM product WHERE NAME LIKE '%电脑%';聚合函数
- 将一列数据作为一个整体，进行纵向的计算
- 聚合函数分类
| 函数名 | 功能 |
|---|---|
| count(列名) | 统计数量(一般选用不为null的列) |
| max(列名) | 最大值 |
| min(列名) | 最小值 |
| sum(列名) | 求和 |
| avg(列名) | 平均值 |
-- 标准语法
SELECT 函数名(列名) FROM 表名 [WHERE 条件];
-- 计算product表中总记录条数
SELECT COUNT(*) FROM product;
-- 获取最高价格
SELECT MAX(price) FROM product;
-- 获取最高价格的商品名称
SELECT NAME,price FROM product WHERE price = (SELECT MAX(price) FROM product);
-- 获取最低库存
SELECT MIN(stock) FROM product;
-- 获取最低库存的商品名称
SELECT NAME,stock FROM product WHERE stock = (SELECT MIN(stock) FROM product);
-- 获取总库存数量
SELECT SUM(stock) FROM product;
-- 获取品牌为苹果的总库存数量
SELECT SUM(stock) FROM product WHERE brand='苹果';
-- 获取品牌为小米的平均商品价格
SELECT AVG(price) FROM product WHERE brand='小米';排序查询
注意：多个排序条件，当前边的条件值一样时，才会判断第二条件
-- 排序
SELECT 列名 FROM 表名 [WHERE 条件] ORDER BY 列名1 排序方式1,列名2 排序方式2;
-- 按照库存升序排序
SELECT * FROM product ORDER BY stock ASC;
-- 查询名称中包含手机的商品信息。按照金额降序排序
SELECT * FROM product WHERE NAME LIKE '%手机%' ORDER BY price DESC;
-- 按照金额升序排序，如果金额相同，按照库存降序排列
SELECT * FROM product ORDER BY price ASC,stock DESC;分组查询
-- 标准语法
SELECT 列名 FROM 表名 [WHERE 条件] GROUP BY 分组列名 [HAVING 分组后条件过滤] [ORDER BY 排序列名 排序方式];
-- 按照品牌分组，获取每组商品的总金额
SELECT brand,SUM(price) FROM product GROUP BY brand;
-- 对金额大于4000元的商品，按照品牌分组,获取每组商品的总金额
SELECT brand,SUM(price) FROM product WHERE price > 4000 GROUP BY brand;
-- 对金额大于4000元的商品，按照品牌分组，获取每组商品的总金额，只显示总金额大于7000元的
SELECT brand,SUM(price) AS getSum FROM product WHERE price > 4000 GROUP BY brand HAVING getSum > 7000;
-- 对金额大于4000元的商品，按照品牌分组，获取每组商品的总金额，只显示总金额大于7000元的、并按照总金额的降序排列
SELECT brand,SUM(price) AS getSum FROM product WHERE price > 4000 GROUP BY brand HAVING getSum > 7000 ORDER BY getSum DESC;分页查询
-- 标准语法
SELECT 列名 FROM 表名 [WHERE 条件] GROUP BY 分组列名 [HAVING 分组后条件过滤] [ORDER BY 排序列名 排序方式] LIMIT 开始索引,查询条数;
-- 公式：开始索引 = (当前页码-1) * 每页显示的条数
-- 每页显示2条数据
SELECT * FROM product LIMIT 0,2; -- 第一页 开始索引=(1-1) * 2
SELECT * FROM product LIMIT 2,2; -- 第二页 开始索引=(2-1) * 2
SELECT * FROM product LIMIT 4,2; -- 第三页 开始索引=(3-1) * 2
SELECT * FROM product LIMIT 6,2; -- 第四页 开始索引=(4-1) * 2外键
约束的概念
-
对表中的数据进行限定，保证数据的正确性、有效性、完整性！
约束的分类
| 约束 | 说明 |
|---|---|
| PRIMARY KEY | 主键约束 |
| PRIMARY KEY AUTO_INCREMENT | 主键、自动增长 |
| UNIQUE | 唯一约束 |
| NOT NULL | 非空约束 |
| FOREIGN KEY | 外键约束 |
| FOREIGN KEY ON UPDATE CASCADE | 外键级联更新 |
| FOREIGN KEY ON DELETE CASCADE | 外键级联删除 |
主键约束
-- 建表时添加主键约束
CREATE TABLE 表名(
列名 数据类型 PRIMARY KEY,
列名 数据类型,
...
);
-- 创建student表
CREATE TABLE student(
id INT PRIMARY KEY -- 给id添加主键约束
);
-- 添加数据
INSERT INTO student VALUES (1),(2);
-- 主键默认唯一，添加重复数据，会报错
INSERT INTO student VALUES (2);
-- 主键默认非空，不能添加null的数据
INSERT INTO student VALUES (NULL);
-- 删除主键
ALTER TABLE 表名 DROP PRIMARY KEY;
-- 建表后单独添加主键
ALTER TABLE 表名 MODIFY 列名 数据类型 PRIMARY KEY;主键自动增长约束
-- 建表时添加主键自增约束
CREATE TABLE 表名(
列名 数据类型 PRIMARY KEY AUTO_INCREMENT,
列名 数据类型,
...
);
-- 创建student2表
CREATE TABLE student2(
id INT PRIMARY KEY AUTO_INCREMENT -- 给id添加主键自增约束
);
-- 添加数据
INSERT INTO student2 VALUES (1),(2);
-- 添加null值，会自动增长
INSERT INTO student2 VALUES (NULL),(NULL);
-- 删除自动增长
ALTER TABLE 表名 MODIFY 列名 数据类型;
-- 建表后单独添加自动增长
ALTER TABLE 表名 MODIFY 列名 数据类型 AUTO_INCREMENT;唯一约束
-- 建表时添加唯一约束
CREATE TABLE 表名(
列名 数据类型 UNIQUE,
列名 数据类型,
...
);
-- 创建student3表
CREATE TABLE student3(
id INT PRIMARY KEY AUTO_INCREMENT,
tel VARCHAR(20) UNIQUE -- 给tel列添加唯一约束
);
-- 添加数据
INSERT INTO student3 VALUES (NULL,'18888888888'),(NULL,'18666666666');
-- 添加重复数据，会报错
INSERT INTO student3 VALUES (NULL,'18666666666');
-- 删除唯一约束
ALTER TABLE 表名 DROP INDEX 列名;
-- 建表后单独添加唯一约束
ALTER TABLE 表名 MODIFY 列名 数据类型 UNIQUE;非空约束
-- 建表时添加非空约束
CREATE TABLE 表名(
列名 数据类型 NOT NULL,
列名 数据类型,
...
);
-- 创建student4表
CREATE TABLE student4(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL -- 给name添加非空约束
);
-- 添加数据
INSERT INTO student4 VALUES (NULL,'张三'),(NULL,'李四');
-- 添加null值，会报错
INSERT INTO student4 VALUES (NULL,NULL);
-- 删除非空约束
ALTER TABLE 表名 MODIFY 列名 数据类型;
-- 建表后单独添加非空约束
ALTER TABLE 表名 MODIFY 列名 数据类型 NOT NULL;外键约束
-- 建表时添加外键约束
CONSTRAINT 外键名 FOREIGN KEY (本表外键列名) REFERENCES 主表名(主表主键列名)
CREATE TABLE USER(
id INT PRIMARY KEY AUTO_INCREMENT, -- id
NAME VARCHAR(20) NOT NULL -- 姓名
);
-- 添加用户数据
INSERT INTO USER VALUES (NULL,'张三'),(NULL,'李四'),(NULL,'王五');
-- 创建order订单表
CREATE TABLE order(
id INT PRIMARY KEY AUTO_INCREMENT, -- id
number VARCHAR(20) NOT NULL, -- 订单编号
uid INT, -- 订单所属用户
CONSTRAINT user_order FOREIGN KEY (uid) REFERENCES USER(id) -- 添加外键约束
);
-- 添加订单数据
INSERT INTO orderlist VALUES (NULL,'hm001',1),(NULL,'hm002',1);
-- 添加一个订单，但是没有所属用户。无法添加
INSERT INTO orderlist VALUES (NULL,'hm007',8);
-- 删除王五这个用户，但是订单表中王五还有很多个订单呢。无法删除
DELETE FROM USER WHERE NAME='王五';
-- 删除外键约束
ALTER TABLE 表名 DROP FOREIGN KEY 外键名;
-- 建表后添加外键约束
ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY (本表外键列名) REFERENCES 主表名(主键列名);外键的级联更新和级联删除
什么是级联更新和级联删除
-
当我想把user用户表中的某个用户删掉，我希望该用户所有的订单也随之被删除
-
当我想把user用户表中的某个用户id修改，我希望订单表中该用户所属的订单用户编号也随之修改
-- 添加外键约束，同时添加级联更新 标准语法
ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY (本表外键列名) REFERENCES 主表名(主键列名) ON UPDATE CASCADE;
-- 添加外键约束，同时添加级联删除 标准语法
ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY (本表外键列名) REFERENCES 主表名(主键列名) ON DELETE CASCADE;
-- 添加外键约束，同时添加级联更新和级联删除 标准语法
ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY (本表外键列名) REFERENCES 主表名(主键列名) ON UPDATE CASCADE ON DELETE CASCADE;
-- 删除外键约束
ALTER TABLE orderlist DROP FOREIGN KEY user_order;
-- 添加外键约束，同时添加级联更新和级联删除
ALTER TABLE orderlist ADD CONSTRAINT user_order FOREIGN KEY (uid) REFERENCES USER(id) ON UPDATE CASCADE ON DELETE CASCADE;
-- 将王五用户的id修改为5 订单表中的uid也随之被修改
UPDATE USER SET id=5 WHERE id=3;
-- 将王五用户删除 订单表中该用户所有订单也随之删除
DELETE FROM USER WHERE id=5;多表设计
一对一
业务
人和身份证。一个人只有一个身份证，一个身份证只能对应一个人！
实现原则
在任意一个表建立外键，去关联另外一个表的主键
示意图
增删改查的影响范围
增：数据可以不分先后顺序增加，也不需要必要的对应关系，一个人没有身份证的数据也是可以存在，一个无效身份证的数据也是可以存在。
在业务角度上讲，需要程序员严谨的增加一对一的数据，不然会产生脏数据。
删：数据可以任意删除，没有任何限制。
改：两张表的数据可以任意修改，将约束外键修改其他值，也没有任何限制。
当程序想要进行修改，那么一定不能直接操作外键约束，最好只操作对应的信息。
查：查询两张表的数据，当使用内连接时，可以查出一对一的关系，建议使用。
当使用左连接时，根据左侧表为主体，查询出左侧表的全部数据，右侧表中有对应关系的数据才会查出，反之全部null值显示。
当使用右连接时，与上面相反，以右侧表为主体。
当使用合并连接时，会将重复的数据排除掉。
当使用子查询时，可以查询出脏数据。
-- 创建db5数据库
CREATE DATABASE db5 CHARACTER SET utf8;
-- 使用db5数据库
USE db5;
-- 创建person表
CREATE TABLE person(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
)ENGINE = InnoDB DEFAULT CHARSET = utf8;
-- 添加数据
INSERT INTO person VALUES (NULL,'张三'),(NULL,'李四');
-- 创建card表
CREATE TABLE card(
id INT PRIMARY KEY AUTO_INCREMENT,
number VARCHAR(50),
pid INT UNIQUE,
CONSTRAINT cp_fk1 FOREIGN KEY (pid) REFERENCES person(id) -- 添加外键
)ENGINE = InnoDB DEFAULT CHARSET = utf8;
-- 添加数据
INSERT INTO card VALUES (NULL,'12345',1),(NULL,'56789',3);
-- 查询还没有身份证的公民
select * from person where id not in (select pid from card);
+----+------+
| id | NAME |
+----+------+
| 2 | 李四 |
+----+------+
1 row in set
-- 查询有身份证的公民
select * from person join card on person.id = card.pid;
+----+------+----+--------+-----+
| id | NAME | id | number | pid |
+----+------+----+--------+-----+
| 1 | 张三 | 1 | 12345 | 1 |
+----+------+----+--------+-----+
1 row in set一对多
业务
用户和订单。一个用户可以有多个订单！
实现原则
在多的一方，建立外键约束，来关联一的一方主键
示意图
增删改查的影响范围
增：增加两张表的数据，可以任意增加数据，但是不建议没有先创建主表数据，按照一对多原则，必须有一才能有多的关系。多则可以不用创建。
删：可以随便删除数据，但是不允许删除主表数据。
改：不可以修改两张表任意的外键约束，但是可以修改业务数据。
查：内连接和左连接都可以查询出一对多关联的数据，右连接会查询出没有一对多关联的数据，也会查询出一对多关联的数据。根据业务进行选择使用那种方式。
/*
用户和订单
*/
-- 创建user表
CREATE TABLE USER(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
)ENGINE = InnoDB DEFAULT CHARSET = utf8;
-- 添加数据
INSERT INTO USER VALUES (NULL,'张三'),(NULL,'李四');
-- 创建orderlist表
CREATE TABLE orderlist(
id INT PRIMARY KEY AUTO_INCREMENT,
number VARCHAR(20),
uid INT,
CONSTRAINT ou_fk1 FOREIGN KEY (uid) REFERENCES USER(id) -- 添加外键约束
)ENGINE = InnoDB DEFAULT CHARSET = utf8;
-- 添加数据
INSERT INTO orderlist VALUES (NULL,'hm001',1),(NULL,'hm002',1),(NULL,'hm003',2),(NULL,'hm004',2);
多对多
业务
学生和课程。一个学生可以选择多个课程，一个课程也可以被多个学生选择！
实现原则
需要借助第三张表中间表，中间表至少包含两个列，这两个列作为中间表的外键，分别关联两张表的主键
示意图
增删改查的影响范围
增：除了中间表建立联系，另外两张表可以任意增加数据，中间表也可以随便增加数据，但是在业务中不允许出现中间表，胡乱增加不存在的关系，增加脏数据的存在。
删：可以删除这三张表的所有数据，根据实际业务判断。
改：可以随意修改这三张表的数据，包括外键约束都可以修改，按照实际业务中，外键约束不能进行随意修改。
查：
-- 创建student表
CREATE TABLE student(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);
-- 添加数据
INSERT INTO student VALUES (NULL,'张三'),(NULL,'李四');
-- 创建course表
CREATE TABLE course(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(10)
);
-- 添加数据
INSERT INTO course VALUES (NULL,'语文'),(NULL,'数学');
-- 创建中间表
CREATE TABLE stu_course(
id INT PRIMARY KEY AUTO_INCREMENT,
sid INT, -- 用于和student表的id进行外键关联
cid INT, -- 用于和course表的id进行外键关联
CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id), -- 添加外键约束
CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id) -- 添加外键约束
);
-- 添加数据
INSERT INTO stu_course VALUES (NULL,1,1),(NULL,6,2),(NULL,2,1),(NULL,2,2);
-- 子查询
select * from (select * from student ) s ,(select * from stu_course) sc,(select * from course) c where s.id=sc.sid and c.id = sc.cid;
+----+------+----+-----+-----+----+------+
| id | NAME | id | sid | cid | id | NAME |
+----+------+----+-----+-----+----+------+
| 1 | 张三 | 1 | 1 | 1 | 1 | 语文 |
| 2 | 李四 | 3 | 2 | 1 | 1 | 语文 |
| 2 | 李四 | 4 | 2 | 2 | 2 | 数学 |
+----+------+----+-----+-----+----+------+
3 rows in set
-- 内连接
select * from student s join stu_course sc on sc.sid = s.id join course c on sc.cid = c.id;
+----+------+----+-----+-----+----+------+
| id | NAME | id | sid | cid | id | NAME |
+----+------+----+-----+-----+----+------+
| 1 | 张三 | 1 | 1 | 1 | 1 | 语文 |
| 2 | 李四 | 3 | 2 | 1 | 1 | 语文 |
| 2 | 李四 | 4 | 2 | 2 | 2 | 数学 |
+----+------+----+-----+-----+----+------+
3 rows in set
-- 左连接
select * from student s left join stu_course sc on sc.sid = s.id left
join course c on sc.cid = c.id;
+----+------+------+------+------+------+------+
| id | NAME | id | sid | cid | id | NAME |
+----+------+------+------+------+------+------+
| 1 | 张三 | 1 | 1 | 1 | 1 | 语文 |
| 2 | 李四 | 3 | 2 | 1 | 1 | 语文 |
| 2 | 李四 | 4 | 2 | 2 | 2 | 数学 |
| 3 | 王五 | NULL | NULL | NULL | NULL | NULL |
+----+------+------+------+------+------+------+
4 rows in set
-- 右连接
select * from student s right join
stu_course sc on sc.sid = s.id right join course c on sc.cid = c.id;
+------+------+------+------+------+----+------+
| id | NAME | id | sid | cid | id | NAME |
+------+------+------+------+------+----+------+
| 1 | 张三 | 1 | 1 | 1 | 1 | 语文 |
| 2 | 李四 | 3 | 2 | 1 | 1 | 语文 |
| NULL | NULL | 2 | 6 | 2 | 2 | 数学 |
| 2 | 李四 | 4 | 2 | 2 | 2 | 数学 |
| NULL | NULL | NULL | NULL | NULL | 3 | 英语 |
+------+------+------+------+------+----+------+
5 rows in set
多表查询
-- 笛卡尔积查询
SELECT 列名 FROM 表名1,表名2,...;
-- 内连接查询[内连接查询的是两张表有交集的部分数据(有主外键关联的数据)]
SELECT 列名 FROM 表名1 [INNER] JOIN 表名2 ON 条件;
-- 隐式内连接
SELECT 列名 FROM 表名1,表名2 WHERE 条件;
-- 外连接查询[查询左表的全部数据，和左右两张表有交集部分的数据]
SELECT 列名 FROM 表名1 LEFT [OUTER] JOIN 表名2 ON 条件;
-- 右外连接[查询右表的全部数据，和左右两张表有交集部分的数据]
SELECT 列名 FROM 表名1 RIGHT [OUTER] JOIN 表名2 ON 条件;
-- 子查询[查询语句中嵌套了查询语句。我们就将嵌套查询称为子查询！]
-- 子查询-结果是单行单列
SELECT 列名 FROM 表名 WHERE 列名=(SELECT 聚合函数(列名) FROM 表名 [WHERE 条件]);
-- 子查询-结果是多行单列
SELECT 列名 FROM 表名 WHERE 列名 [NOT] IN (SELECT 列名 FROM 表名 [WHERE 条件]);
-- 子查询-结果是多行多列
SELECT 列名 FROM 表名 [别名],(SELECT 列名 FROM 表名 [WHERE 条件]) [别名] [WHERE 条件];视图
1.视图的概念
-
视图是一种虚拟存在的数据表
-
这个虚拟的表并不在数据库中实际存在
-
作用是将一些比较复杂的查询语句的结果，封装到一个虚拟表中。后期再有相同复杂查询时，直接查询这张虚拟表即可
-
说白了，视图就是将一条SELECT查询语句的结果封装到了一个虚拟表中，所以我们在创建视图的时候，工作重心就要放在这条SELECT查询语句上
2.视图的好处
-
简单
-
对于使用视图的用户不需要关心表的结构、关联条件和筛选条件。因为这张虚拟表中保存的就是已经过滤好条件的结果集
-
-
安全
-
视图可以设置权限 , 致使访问视图的用户只能访问他们被允许查询的结果集
-
-
数据独立
-
一旦视图的结构确定了，可以屏蔽表结构变化对用户的影响，源表增加列对视图没有影响；源表修改列名，则可以通过修改视图来解决，不会造成对访问者的影响
-
-- 视图的创建
CREATE VIEW 视图名称 [(列名列表)] AS 查询语句;
-- 视图的查询
SELECT * FROM 视图名称;
-- 查询视图创建语法
SHOW CREATE VIEW 视图名称;
-- 修改视图表中的数据
UPDATE 视图名称 SET 列名=值 WHERE 条件;
-- 修改视图表结构
ALTER VIEW 视图名称 [(列名列表)] AS 查询语句;
-- 删除视图
DROP VIEW [IF EXISTS] 视图名称;MySQL存储过程和函数
1.存储过程和函数的概念
-
存储过程和函数是 事先经过编译并存储在数据库中的一段 SQL 语句的集合
2.存储过程和函数的好处
-
存储过程和函数可以重复使用，减轻开发人员的工作量。类似于java中方法可以多次调用
-
减少网络流量，存储过程和函数位于服务器上，调用的时候只需要传递名称和参数即可
-
减少数据在数据库和应用服务器之间的传输，可以提高数据处理的效率
-
将一些业务逻辑在数据库层面来实现，可以减少代码层面的业务处理
3.存储过程和函数的区别
-
函数必须有返回值
-
存储过程没有返回值
/*
该关键字用来声明sql语句的分隔符，告诉MySQL该段命令已经结束！
sql语句默认的分隔符是分号，但是有的时候我们需要一条功能sql语句中包含分号，但是并不作为结束标识。
这个时候就可以使用DELIMITER来指定分隔符了！
*/
-- 标准语法
DELIMITER 分隔符
-- 创建存储过程
CREATE PROCEDURE 存储过程名称(参数...)
BEGIN
sql语句;
END[分隔符]
-- 调用存储过程
CALL 存储过程名称(实际参数);
-- 删除存储过程
DROP PROCEDURE [IF EXISTS] 存储过程名称;
-- 查看存储过程
SHOW PROCEDURE STATUS LIKE '存储过程名称'; -- 状态
SHOW CREATE PROCEDURE 存储过程名称; -- 语句
-- 查询数据库中所有的存储过程 标准语法
SELECT * FROM mysql.proc WHERE db='数据库名称';存储过程语法
定义变量
-- 标准语法
DECLARE 变量名 数据类型 [DEFAULT 默认值];
-- 注意： DECLARE定义的是局部变量，只能用在BEGIN END范围之内
-- 定义一个int类型变量、并赋默认值为10
DELIMITER $
CREATE PROCEDURE pro_test1()
BEGIN
DECLARE num INT DEFAULT 10; -- 定义变量
SELECT num; -- 查询变量
END$
DELIMITER ;
-- 调用pro_test1存储过程
CALL pro_test1();
+-----+
| num |
+-----+
| 10 |
+-----+
1 row in set变量的赋值1
-- 标准语法
SET 变量名 = 变量值;
-- 定义字符串类型变量，并赋值
DELIMITER $
CREATE PROCEDURE pro_test2()
BEGIN
DECLARE NAME VARCHAR(10); -- 定义变量
SET NAME = '存储过程'; -- 为变量赋值
SELECT NAME; -- 查询变量
END$
DELIMITER ;
-- 调用pro_test2存储过程
CALL pro_test2();
+----------+
| NAME |
+----------+
| 存储过程 |
+----------+
1 row in set变量的赋值2
-- 标准语法
SELECT 列名 INTO 变量名 FROM 表名 [WHERE 条件];
-- 定义两个int变量，用于存储男女同学的总分数
DELIMITER $
CREATE PROCEDURE pro_test3()
BEGIN
DECLARE men,women INT; -- 定义变量
SELECT SUM(score) INTO men FROM student WHERE gender='男'; -- 计算男同学总分数赋值给men
SELECT SUM(score) INTO women FROM student WHERE gender='女'; -- 计算女同学总分数赋值给women
SELECT men,women; -- 查询变量
END$
DELIMITER ;
-- 调用pro_test3存储过程
CALL pro_test3();if语句的使用
-- 标准语法
IF 判断条件1 THEN 执行的sql语句1;
[ELSEIF 判断条件2 THEN 执行的sql语句2;]
...
[ELSE 执行的sql语句n;]
END IF;
/*
定义一个int变量，用于存储班级总成绩
定义一个varchar变量，用于存储分数描述
根据总成绩判断：
380分及以上 学习优秀
320 ~ 380 学习不错
320以下 学习一般
*/
DELIMITER $
CREATE PROCEDURE pro_test4()
BEGIN
-- 定义总分数变量
DECLARE total INT;
-- 定义分数描述变量
DECLARE description VARCHAR(10);
-- 为总分数变量赋值
SELECT SUM(score) INTO total FROM student;
-- 判断总分数
IF total >= 380 THEN
SET description = '学习优秀';
ELSEIF total >= 320 AND total < 380 THEN
SET description = '学习不错';
ELSE
SET description = '学习一般';
END IF;
-- 查询总成绩和描述信息
SELECT total,description;
END$
DELIMITER ;
-- 调用pro_test4存储过程
CALL pro_test4();参数的传递
DELIMITER $
-- 标准语法
CREATE PROCEDURE 存储过程名称([IN|OUT|INOUT] 参数名 数据类型)
BEGIN
执行的sql语句;
END$
/*
IN:代表输入参数，需要由调用者传递实际数据。默认的
OUT:代表输出参数，该参数可以作为返回值
INOUT:代表既可以作为输入参数，也可以作为输出参数
*/
DELIMITER ;输入参数
DELIMITER $
-- 标准语法
CREATE PROCEDURE 存储过程名称(IN 参数名 数据类型)
BEGIN
执行的sql语句;
END$
DELIMITER ;
DELIMITER $
CREATE PROCEDURE pro_test5(IN total INT)
BEGIN
-- 定义分数描述变量
DECLARE description VARCHAR(10);
-- 判断总分数
IF total >= 380 THEN
SET description = '学习优秀';
ELSEIF total >= 320 AND total < 380 THEN
SET description = '学习不错';
ELSE
SET description = '学习一般';
END IF;
-- 查询总成绩和描述信息
SELECT total,description;
END$
DELIMITER ;
-- 调用pro_test5存储过程
-- 直接输入变量，用这个total参数进行后续的判断
CALL pro_test5(390);
-- 通过查询值进行判断
CALL pro_test5((SELECT SUM(score) FROM student));
Query OK, 0 rows affected
+-------+-------------+
| total | description |
+-------+-------------+
| 390 | 学习优秀 |
+-------+-------------+
1 row in set
Query OK, 0 rows affected
+-------+-------------+
| total | description |
+-------+-------------+
| 383 | 学习优秀 |
+-------+-------------+
1 row in set
输出参数
DELIMITER $
-- 标准语法
CREATE PROCEDURE 存储过程名称(OUT 参数名 数据类型)
BEGIN
执行的sql语句;
END$
DELIMITER ;
/*
输入总成绩变量，代表学生总成绩
输出分数描述变量，代表学生总成绩的描述
根据总成绩判断：
380分及以上 学习优秀
320 ~ 380 学习不错
320以下 学习一般
*/
DELIMITER $
CREATE PROCEDURE pro_test6(IN total INT,OUT description VARCHAR(10))
BEGIN
-- 判断总分数
IF total >= 380 THEN
SET description = '学习优秀';
ELSEIF total >= 320 AND total < 380 THEN
SET description = '学习不错';
ELSE
SET description = '学习一般';
END IF;
END$
DELIMITER ;
-- 调用pro_test6存储过程
CALL pro_test6(310,@description);
-- 查询总成绩描述
SELECT @description;
+--------------+
| @description |
+--------------+
| 学习一般 |
+--------------+
1 row in set@变量名: 这种变量要在变量名称前面加上“@”符号，叫做用户会话变量，代表整个会话过程他都是有作用的，这个类似于全局变量一样。
@@变量名: 这种在变量前加上 "@@" 符号, 叫做系统变量
case语句的使用
-- 标准语法
CASE 表达式
WHEN 值1 THEN 执行sql语句1;
[WHEN 值2 THEN 执行sql语句2;]
...
[ELSE 执行sql语句n;]
END CASE;
-- 标准语法
CASE
WHEN 判断条件1 THEN 执行sql语句1;
[WHEN 判断条件2 THEN 执行sql语句2;]
...
[ELSE 执行sql语句n;]
END CASE;
/*
输入总成绩变量，代表学生总成绩
定义一个varchar变量，用于存储分数描述
根据总成绩判断：
380分及以上 学习优秀
320 ~ 380 学习不错
320以下 学习一般
*/
DELIMITER $
CREATE PROCEDURE pro_test7(IN total INT)
BEGIN
-- 定义变量
DECLARE description VARCHAR(10);
-- 使用case判断
CASE
WHEN total >= 380 THEN
SET description = '学习优秀';
WHEN total >= 320 AND total < 380 THEN
SET description = '学习不错';
ELSE
SET description = '学习一般';
END CASE;
-- 查询分数描述信息
SELECT description;
END$
DELIMITER ;
-- 调用pro_test7存储过程
CALL pro_test7(390);
CALL pro_test7((SELECT SUM(score) FROM student));while循环
-- 标准语法
初始化语句;
WHILE 条件判断语句 DO
循环体语句;
条件控制语句;
END WHILE;
/*
计算1~100之间的偶数和
*/
DELIMITER $
CREATE PROCEDURE pro_test8()
BEGIN
-- 定义求和变量
DECLARE result INT DEFAULT 0;
-- 定义初始化变量
DECLARE num INT DEFAULT 1;
-- while循环
WHILE num <= 100 DO
-- 偶数判断
IF num%2=0 THEN
SET result = result + num; -- 累加
END IF;
-- 让num+1
SET num = num + 1;
END WHILE;
-- 查询求和结果
SELECT result;
END$
DELIMITER ;
-- 调用pro_test8存储过程
CALL pro_test8();repeat循环
-- 标准语法
初始化语句;
REPEAT
循环体语句;
条件控制语句;
UNTIL 条件判断语句
END REPEAT;
-- 注意：repeat循环是条件满足则停止。while循环是条件满足则执行
/*
计算1~10之间的和
*/
DELIMITER $
CREATE PROCEDURE pro_test9()
BEGIN
-- 定义求和变量
DECLARE result INT DEFAULT 0;
-- 定义初始化变量
DECLARE num INT DEFAULT 1;
-- repeat循环
REPEAT
-- 累加
SET result = result + num;
-- 让num+1
SET num = num + 1;
-- 停止循环
UNTIL num>10
END REPEAT;
-- 查询求和结果
SELECT result;
END$
DELIMITER ;
-- 调用pro_test9存储过程
CALL pro_test9();
+--------+
| result |
+--------+
| 55 |
+--------+
1 row in setloop循环
-- 标准语法
初始化语句;
[循环名称:] LOOP
条件判断语句
[LEAVE 循环名称;]
循环体语句;
条件控制语句;
END LOOP 循环名称;
-- 注意：loop可以实现简单的循环，但是退出循环需要使用其他的语句来定义。我们可以使用leave语句完成！
-- 如果不加退出循环的语句，那么就变成了死循环。
/*
计算1~10之间的和
*/
DELIMITER $
CREATE PROCEDURE pro_test10()
BEGIN
-- 定义求和变量
DECLARE result INT DEFAULT 0;
-- 定义初始化变量
DECLARE num INT DEFAULT 1;
-- loop循环
l:LOOP
-- 条件成立，停止循环
IF num > 10 THEN
LEAVE l;
END IF;
-- 累加
SET result = result + num;
-- 让num+1
SET num = num + 1;
END LOOP l;
-- 查询求和结果
SELECT result;
END$
DELIMITER ;
-- 调用pro_test10存储过程
CALL pro_test10();游标
游标的概念
-
游标可以遍历返回的多行结果，每次拿到一整行数据
-
在存储过程和函数中可以使用游标对结果集进行循环的处理
-
简单来说游标就类似于集合的迭代器遍历
-
MySQL中的游标只能用在存储过程和函数中
-- 创建游标
DECLARE 游标名称 CURSOR FOR 查询sql语句;
-- 打开游标
OPEN 游标名称;
-- 使用游标获取数据
FETCH 游标名称 INTO 变量名1,变量名2,...;
-- 关闭游标
CLOSE 游标名称;
/*
当游标结束后，会触发游标结束事件。我们可以通过这一特性来完成循环操作
加标记思想：
1.定义一个变量，默认值为0(意味着有数据)
2.当游标结束后，将变量值改为1(意味着没有数据了)
*/
-- 1.定义一个变量，默认值为0(意味着有数据)
DECLARE flag INT DEFAULT 0;
-- 2.当游标结束后，将变量值改为1(意味着没有数据了)
DECLARE EXIT HANDLER FOR NOT FOUND SET flag = 1;
/*
将student表中所有的成绩保存到stu_score表中
*/
DELIMITER $
CREATE PROCEDURE pro_test12()
BEGIN
-- 定义成绩变量
DECLARE s_score INT;
-- 定义标记变量
DECLARE flag INT DEFAULT 0;
-- 创建游标，查询所有学生成绩数据
DECLARE stu_result CURSOR FOR SELECT score FROM student;
-- 游标结束后，将标记变量改为1
DECLARE EXIT HANDLER FOR NOT FOUND SET flag = 1;
-- 开启游标
OPEN stu_result;
-- 循环使用游标
REPEAT
-- 使用游标，遍历结果,拿到数据
FETCH stu_result INTO s_score;
-- 将数据保存到stu_score表中
INSERT INTO stu_score VALUES (NULL,s_score);
UNTIL flag=1
END REPEAT;
-- 关闭游标
CLOSE stu_result;
END$
DELIMITER ;
-- 调用pro_test12存储过程
CALL pro_test12();
-- 查询stu_score表
SELECT * FROM stu_score;存储函数
-
存储函数和存储过程是非常相似的。存储函数可以做的事情，存储过程也可以做到！
-
存储函数有返回值，存储过程没有返回值(参数的out其实也相当于是返回数据了)
-- 创建存储函数
DELIMITER $
-- 标准语法
CREATE FUNCTION 函数名称([参数 数据类型])
RETURNS 返回值类型
BEGIN
执行的sql语句;
RETURN 结果;
END$
DELIMITER ;
-- 调用存储函数
SELECT 函数名称(实际参数);
-- 删除存储函数
DROP FUNCTION 函数名称;
/*
定义存储函数，获取学生表中成绩大于95分的学生数量
*/
DELIMITER $
CREATE FUNCTION fun_test1()
RETURNS INT
BEGIN
-- 定义统计变量
DECLARE result INT;
-- 查询成绩大于95分的学生数量，给统计变量赋值
SELECT COUNT(*) INTO result FROM student WHERE score > 95;
-- 返回统计结果
RETURN result;
END$
DELIMITER ;
-- 调用fun_test1存储函数
SELECT fun_test1();MySQL触发器
1.触发器的概念
-
触发器是与表有关的数据库对象，可以在 insert/update/delete 之前或之后，触发并执行触发器中定义的SQL语句。触发器的这种特性可以协助应用在数据库端确保数据的完整性 、日志记录 、数据校验等操作 。
-
使用别名 NEW 和 OLD 来引用触发器中发生变化的记录内容，这与其他的数据库是相似的。现在触发器还只支持行级触发，不支持语句级触发。
| 触发器类型 | OLD的含义 | NEW的含义 |
|---|---|---|
| INSERT 型触发器 | 无 (因为插入前状态无数据) | NEW 表示将要或者已经新增的数据 |
| UPDATE 型触发器 | OLD 表示修改之前的数据 | NEW 表示将要或已经修改后的数据 |
| DELETE 型触发器 | OLD 表示将要或者已经删除的数据 | 无 (因为删除后状态无数据) |
-- 创建触发器
DELIMITER $
CREATE TRIGGER 触发器名称
BEFORE|AFTER INSERT|UPDATE|DELETE
ON 表名
[FOR EACH ROW] -- 行级触发器
BEGIN
触发器要执行的功能;
END$
DELIMITER ;
/*
*/
-- 创建db9数据库
CREATE DATABASE db9 character set utf8;
-- 使用db9数据库
USE db9;
-- 创建账户表account
CREATE TABLE account(
id INT PRIMARY KEY AUTO_INCREMENT, -- 账户id
NAME VARCHAR(20), -- 姓名
money DOUBLE -- 余额
);
-- 添加数据
INSERT INTO account VALUES (NULL,'张三',1000),(NULL,'李四',2000);
-- 创建日志表account_log
CREATE TABLE account_log(
id INT PRIMARY KEY AUTO_INCREMENT, -- 日志id
operation VARCHAR(20), -- 操作类型 (insert update delete)
operation_time DATETIME, -- 操作时间
operation_id INT, -- 操作表的id
operation_params VARCHAR(200) -- 操作参数
);创建INSERT触发器
-- 创建INSERT触发器
DELIMITER $
CREATE TRIGGER account_insert
AFTER INSERT
ON account
FOR EACH ROW
BEGIN
INSERT INTO account_log VALUES (NULL,'INSERT',NOW(),new.id,CONCAT('插入后{id=',new.id,',name=',new.name,',money=',new.money,'}'));
END$
DELIMITER ;
-- 向account表添加记录
INSERT INTO account VALUES (NULL,'王五',3000);
-- 查询account表
SELECT * FROM account;
-- 查询日志表
SELECT * FROM account_log;创建UPDATE触发器
-- 创建UPDATE触发器
DELIMITER $
CREATE TRIGGER account_update
AFTER UPDATE
ON account
FOR EACH ROW
BEGIN
INSERT INTO account_log VALUES (NULL,'UPDATE',NOW(),new.id,CONCAT('修改前{id=',old.id,',name=',old.name,',money=',old.money,'}','修改后{id=',new.id,',name=',new.name,',money=',new.money,'}'));
END$
DELIMITER ;
-- 修改account表
UPDATE account SET money=3500 WHERE id=3;
-- 查询account表
SELECT * FROM account;
-- 查询日志表
SELECT * FROM account_log;创建DELETE触发器
-- 创建DELETE触发器
DELIMITER $
CREATE TRIGGER account_delete
AFTER DELETE
ON account
FOR EACH ROW
BEGIN
INSERT INTO account_log VALUES (NULL,'DELETE',NOW(),old.id,CONCAT('删除前{id=',old.id,',name=',old.name,',money=',old.money,'}'));
END$
DELIMITER ;
-- 删除account表数据
DELETE FROM account WHERE id=3;
-- 查询account表
SELECT * FROM account;
-- 查询日志表
SELECT * FROM account_log;查看触发器
-- 标准语法
SHOW TRIGGERS;
-- 查看触发器
SHOW TRIGGERS;删除触发器
-- 标准语法
DROP TRIGGER 触发器名称;
-- 删除DELETE触发器
DROP TRIGGER account_delete;MySQL事务
-- 开启事务
START TRANSACTION;
-- 回滚事务
ROLLBACK;
-- 提交事务
COMMIT;
-- 查看事务提交方式
SELECT @@AUTOCOMMIT; -- 1代表自动提交 0代表手动提交
-- 修改事务提交方式
-- 标准语法
SET @@AUTOCOMMIT=数字;
-- 修改为手动提交
SET @@AUTOCOMMIT=0;
-- 查看事务提交方式
SELECT @@AUTOCOMMIT;
事务的四大特征(ACID)
-
原子性(atomicity)
-
原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响
-
-
一致性(consistency)
-
一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态
-
拿转账来说，假设张三和李四两者的钱加起来一共是2000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是2000，这就是事务的一致性
-
-
隔离性(isolcation)
-
隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离
-
-
持久性(durability)
-
持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作
-
事务的隔离级别
-
隔离级别的概念
-
多个客户端操作时 ,各个客户端的事务之间应该是隔离的，相互独立的 , 不受影响的。
-
而如果多个事务操作同一批数据时，则需要设置不同的隔离级别 , 否则就会产生问题 。
-
我们先来了解一下四种隔离级别的名称 , 再来看看可能出现的问题
-
-
四种隔离级别
| 1 | 读未提交 | read uncommitted |
|---|---|---|
| 2 | 读已提交 | read committed |
| 3 | 可重复读 | repeatable read |
| 4 | 串行化 | serializable |
-
可能引发的问题
| 问题 | 现象 |
|---|---|
| 脏读 | 是指在一个事务处理过程中读取了另一个未提交的事务中的数据 , 导致两次查询结果不一致 |
| 不可重复读 | 是指在一个事务处理过程中读取了另一个事务中修改并已提交的数据, 导致两次查询结果不一致 |
| 幻读 | select 某记录是否存在，不存在，准备插入此记录，但执行 insert 时发现此记录已存在，无法插入。或不存在执行delete删除，却发现删除成功 |
-- 查询数据库隔离级别
SELECT @@TX_ISOLATION;
-- 修改数据库隔离级别
SET GLOBAL TRANSACTION ISOLATION LEVEL 级别字符串;
-- 修改数据库隔离级别为read uncommitted
SET GLOBAL TRANSACTION ISOLATION LEVEL read uncommitted;
-- 查看隔离级别
SELECT @@TX_ISOLATION; -- 修改后需要断开连接重新开解决脏读
-- 设置隔离级别为read committed
set global transaction isolation level read committed;
-- 开启事务
start transaction;
-- 转账
update account set money = money - 500 where id = 1;
update account set money = money + 500 where id = 2;
-- 窗口2查看转账结果，并没有发生变化(脏读问题被解决了)
-- 执行提交事务。
commit;解决不可重复读
-- 设置隔离级别为repeatable read
set global transaction isolation level repeatable read;
-- 开启事务
start transaction;
-- 转账
update account set money = money - 500 where id = 1;
update account set money = money + 500 where id = 2;
-- 窗口2查看转账结果，并没有发生变化
-- 执行提交事务
commit;
-- 这个时候窗口2只要还在上次事务中，看到的结果都是相同的。只有窗口2结束事务，才能看到变化(不可重复读的问题被解决)解决幻读
/*
窗口1
*/
-- 设置隔离级别为serializable
set global transaction isolation level serializable;
-- 开启事务
start transaction;
-- 添加一条记录
INSERT INTO account VALUES (4,'赵六',1600);
-- 查询账户表，本窗口可以查看到id为4的结果
SELECT * FROM account;
-- 提交事务
COMMIT;隔离级别总结
| 隔离级别 | 名称 | 出现脏读 | 出现不可重复读 | 出现幻读 | 数据库默认隔离级别 | |
|---|---|---|---|---|---|---|
| 1 | read uncommitted | 读未提交 | 是 | 是 | 是 | |
| 2 | read committed | 读已提交 | 否 | 是 | 是 | Oracle / SQL Server |
| 3 | repeatable read | 可重复读 | 否 | 否 | 是 | MySQL |
| 4 | serializable | 串行化 | 否 | 否 | 否 |
MySQL存储引擎
| 特性 | MyISAM | InnoDB | MEMORY |
|---|---|---|---|
| 存储限制 | 有(平台对文件系统大小的限制) | 64TB | 有(平台的内存限制) |
| 事务安全 | 不支持 | 支持 | 不支持 |
| 锁机制 | 表锁 | 表锁/行锁 | 表锁 |
| B+Tree索引 | 支持 | 支持 | 支持 |
| 哈希索引 | 不支持 | 不支持 | 支持 |
| 全文索引 | 支持 | 支持 | 不支持 |
| 集群索引 | 不支持 | 支持 | 不支持 |
| 数据索引 | 不支持 | 支持 | 支持 |
| 数据缓存 | 不支持 | 支持 | N/A |
| 索引缓存 | 支持 | 支持 | N/A |
| 数据可压缩 | 支持 | 不支持 | 不支持 |
| 空间使用 | 低 | 高 | N/A |
| 内存使用 | 低 | 高 | 中等 |
| 批量插入速度 | 高 | 低 | 高 |
| 外键 | 不支持 | 支持 | 不支持 |
-- 查询数据库支持的引擎
SHOW ENGINES;
-- 表含义:
- support : 指服务器是否支持该存储引擎
- transactions : 指存储引擎是否支持事务
- XA : 指存储引擎是否支持分布式事务处理
- Savepoints : 指存储引擎是否支持保存点
-- 查询某个数据库中所有数据表的引擎
SHOW TABLE STATUS FROM 数据库名称;
-- 查询某个数据库中某个数据表的引擎
SHOW TABLE STATUS FROM 数据库名称 WHERE NAME = '数据表名称';
-- 创建数据表，指定存储引擎
CREATE TABLE 表名(
列名,数据类型,
...
)ENGINE = 引擎名称;
-- 修改表的存储引擎
ALTER TABLE 表名 ENGINE = 引擎名称;索引的分类
-
功能分类
-
普通索引： 最基本的索引，它没有任何限制。
-
唯一索引：索引列的值必须唯一，但允许有空值。如果是组合索引，则列值组合必须唯一。
-
主键索引：一种特殊的唯一索引，不允许有空值。一般在建表时同时创建主键索引。
-
组合索引：顾名思义，就是将单列索引进行组合。
-
外键索引：只有InnoDB引擎支持外键索引，用来保证数据的一致性、完整性和实现级联操作。
-
全文索引：快速匹配全部文档的方式。InnoDB引擎5.6版本后才支持全文索引。MEMORY引擎不支持。
-
-
结构分类
-
B+Tree索引 ：MySQL使用最频繁的一个索引数据结构，是InnoDB和MyISAM存储引擎默认的索引类型。
-
Hash索引 : MySQL中Memory存储引擎默认支持的索引类型。
-
-- 创建索引
CREATE [UNIQUE|FULLTEXT] INDEX 索引名称
[USING 索引类型] -- 默认是B+TREE
ON 表名(列名...);
-- 查看索引
SHOW INDEX FROM 表名;
-- 添加索引
-- 普通索引
ALTER TABLE 表名 ADD INDEX 索引名称(列名);
-- 组合索引
ALTER TABLE 表名 ADD INDEX 索引名称(列名1,列名2,...);
-- 主键索引
ALTER TABLE 表名 ADD PRIMARY KEY(主键列名);
-- 外键索引(添加外键约束，就是外键索引)
ALTER TABLE 表名 ADD CONSTRAINT 外键名 FOREIGN KEY (本表外键列名) REFERENCES 主表名(主键列名);
-- 唯一索引
ALTER TABLE 表名 ADD UNIQUE 索引名称(列名);
-- 全文索引(mysql只支持文本类型)
ALTER TABLE 表名 ADD FULLTEXT 索引名称(列名);
-- 删除索引
DROP INDEX 索引名称 ON 表名;
-- 删除student表中的idx_score索引
DROP INDEX idx_score ON student;创建索引时的原则
-
对查询频次较高，且数据量比较大的表建立索引。
-
使用唯一索引，区分度越高，使用索引的效率越高。
-
索引字段的选择，最佳候选列应当从where子句的条件中提取，如果where子句中的组合比较多，那么应当挑选最常用、过滤效果最好的列的组合。
-
使用短索引，索引创建之后也是使用硬盘来存储的，因此提升索引访问的I/O效率，也可以提升总体的访问效率。假如构成索引的字段总长度比较短，那么在给定大小的存储块内可以存储更多的索引值，相应的可以有效的提升MySQL访问索引的I/O效率。
-
索引可以有效的提升查询数据的效率，但索引数量不是多多益善，索引越多，维护索引的代价自然也就水涨船高。对于插入、更新、删除等DML操作比较频繁的表来说，索引过多，会引入相当高的维护代价，降低DML操作的效率，增加相应操作的时间消耗。另外索引过多的话，MySQL也会犯选择困难病，虽然最终仍然会找到一个可用的索引，但无疑提高了选择的代价。
MySQL锁
锁的分类
-
按操作分类：
-
共享锁：也叫读锁。针对同一份数据，多个事务读取操作可以同时加锁而不互相影响 ，但是不能修改数据记录。
-
排他锁：也叫写锁。当前的操作没有完成前,会阻断其他操作的读取和写入
-
-
按粒度分类：
-
表级锁：操作时，会锁定整个表。开销小，加锁快；不会出现死锁；锁定力度大，发生锁冲突概率高，并发度最低。偏向于MyISAM存储引擎！
-
行级锁：操作时，会锁定当前操作行。开销大，加锁慢；会出现死锁；锁定粒度小，发生锁冲突的概率低，并发度高。偏向于InnoDB存储引擎！
-
页级锁：锁的粒度、发生冲突的概率和加锁的开销介于表锁和行锁之间，会出现死锁，并发性能一般。
-
-
按使用方式分类：
-
悲观锁：每次查询数据时都认为别人会修改，很悲观，所以查询时加锁。
-
乐观锁：每次查询数据时都认为别人不会修改，很乐观，但是更新时会判断一下在此期间别人有没有去更新这个数据
-
-
不同存储引擎支持的锁
| 存储引擎 | 表级锁 | 行级锁 | 页级锁 |
|---|---|---|---|
| MyISAM | 支持 | 不支持 | 不支持 |
| InnoDB | 支持 | 支持 | 不支持 |
| MEMORY | 支持 | 不支持 | 不支持 |
| BDB | 支持 | 不支持 | 支持 |
-- 共享锁
SELECT语句 LOCK IN SHARE MODE;
-- 排他锁
SELECT语句 FOR UPDATE;
/*
MyISAM锁
*/
-- 读锁
-- 加锁
LOCK TABLE 表名 READ;
-- 解锁(将当前会话所有的表进行解锁)
UNLOCK TABLES;
-- 写锁
-- 加锁
LOCK TABLE 表名 WRITE;
-- 解锁(将当前会话所有的表进行解锁)
UNLOCK TABLES;