Mysql详细学习指南（超详细）

╰+攻爆jí腚メ 2023-09-26 10:46 39阅读 0赞

#### 文章目录 ####

*  数据库MySQL
 *  一、数据库的概念
 *   *  1.1 现阶段数据存放方式
     *  1.2 现有方式的缺点
     *  1.3 新的文件类型
     *  1.4 分类
     *  1.5 数据库管理系统
 *  二、MySQL
 *   *  2.1 简介
     *  2.2 目录
     *  2.3 核心文件
 *  三、SQL语言
 *  四、MySQL操作
 *   *  4.1 连接数据库
     *  4.2 基本命令
     *   *  4.2.1 查看所有数据库
         *  4.2.2 创建数据库
         *  4.2.3 查看创建的数据库信息
         *  4.2.4 修改数据库
         *  4.2.5 查看当前所使用的数据库
         *  4.2.6 切换使用数据库
         *  4.2.7 删除数据库
 *  五、数据查询
 *   *  5.1 数据导入
     *  5.2 基本查询
     *  5.3 排序查询
     *  5.4 条件查询
     *   *  5.4.1 等值判断
         *  5.4.2 逻辑判断
         *  5.4.3 不等值判断
         *  5.4.4 区间判断
         *  5.4.5 空值判断
         *  5.4.6 枚举查询
         *  5.4.7 模糊查询
         *  5.4.8 分支查询
         *  5.4.9 时间函数
         *  5.4.10 字符串函数
     *  5.5 聚合函数
     *  5.6 分组查询
     *   *  5.6.1 分组基础查询
         *  5.6.2 分组过滤查询
     *  5.7 限定查询
     *  5.8 基础查询顺序总结
     *  5.9 子查询
     *   *  5.9.1 将查询结果当条件
         *  5.9.2 查询结果为多行单列（枚举）
         *  5.9.3 ALL和ANY用法
         *  5.9.4 将子查询作为条件再次查询
     *  5.10 合并查询
     *  5.11 连接查询
     *   *  5.11.1 交叉连接(了解)
         *  5.11.2 内连接
         *  5.11.3 外连接
     *  5.12 复杂查询
     *  5.13 行转列\[经典面试题\]
     *  5.14 查询某个列重复的行\[经典面试题\]
 *  六、DML操作
 *   *  6.1 新增
     *  6.2 修改
     *  6.3 删除和清空表
 *  七、MySQL字段数据类型
 *   *  7.1 数据类型概述
     *  7.2 数值类型
     *  7.3 日期类型
     *  7.4 字符串类型
 *  八、表结构操作
 *   *  8.1 表创建
     *  8.2 表修改
     *   *  8.2.1 添加列
         *  8.2.2 修改列
         *  8.2.3 修改列名
         *  8.2.4 删除列
         *  8.2.5 修改表名
     *  8.3 删除表
 *  九、表设计过程中的三范式
 *  十、约束
 *   *  10.1 实体完整性约束
     *   *  10.1.1 主键
         *  10.1.2 唯一键
         *  10.1.3 自动增长
     *  10.2 域完整性
     *  10.3 引用完整性
 *  十一、权限管理
 *   *  11.2 授权
     *  11.3 撤销权限
     *  11.4 删除用户
 *  十二、视图
 *  十三、SQL的分类
 *  十四、事务
 *   *  14.1 事务的场景
     *  14.2 事务的概念
     *  14.3 简单原理
     *  14.4 具体操作
     *  14.5 事务的四大特征
     *  14.6 事务的隔离性的理解
     *  14.7 事务的隔离级别
     *  14.8 脏读、不可重复读、幻读

## 数据库MySQL ##

## 一、数据库的概念 ##

### 1.1 现阶段数据存放方式 ###

> 瞬时状态：指数据存储到内存中
> 
> 持久化状态：使用文件存储（IO流、对象序列化）

### 1.2 现有方式的缺点 ###

>  *  数据类型
>  *  数据量级
>  *  安全机制
>  *  备份、恢复机制
>  *  查询搜索

### 1.3 新的文件类型 ###

> 能否使用excel之类的表格来存储？
> 
> 可以，但是excel表格能够清晰的描述数据的结构，却难以进行复杂的查询，而且excel用代码操作也极为不便利。

1.4 数据库

> 数据库是按照一定的数据结构来组织、存储、管理的仓库。

### 1.4 分类 ###

> 网状结构：
> 
> 层次结构：
> 
> 关系结构：以Table存储，多表之间建立关联关系，通过分类、合并、连接、选取等运算实现访问。是目前主流的数据库结构。
> 
>  *  Oracle：Oracle公司产品，企业级的专业性极强的大型数据库产品。服务收费。
>  *  DB2：IBM公司产品，企业级的专业性极强的大型数据库产品。服务收费。
>  *  MySQL：免费的数据库产品，目前仍旧是中小型企业和个人的首先数据库，也是个人学习的首选。
>  *  SQL Server：微软公司的产品，早期只能应用于windows系统。
> 
> 非关系结构：全称为Not only SQL，简写为no SQL，在处理高并发、高性能、海量数据时才使用，一般采用key-value方式存储。一般作为关系型数据库的补充。例如：MongoDB、Redis、ES等。

### 1.5 数据库管理系统 ###

> 操作和管理数据库的软件，用来建立、管理和维护数据库。
> 
> 用来对数据库的统一管理和控制。用户通过数据库管理系统来访问数据库中的数据。

## 二、MySQL ##

### 2.1 简介 ###

> 是一个关系型数据库。
> 
> RDBMS：relation database management system关系型数据库管理系统

### 2.2 目录 ###

> bin：可执行文件
> 
> data：系统数据库
> 
> include：头文件
> 
> lib：支持的库

### 2.3 核心文件 ###

> my.ini：对数据库的核心配置的设置。

port=3306 # 端口号
    default-character-set=utf8 # 默认字符集
    default-storage-engine=INNODB # 默认存储引擎
    max_connections=100 # 最大连接数

## 三、SQL语言 ##

> SQL：structured query language，结构化查询语言。
> 
> 用来对数据库进行操作。
> 
> 对数据的操作一般有增删改查。简称CRUD（create、read、update、delete）

## 四、MySQL操作 ##

### 4.1 连接数据库 ###

> 如果已经配置了环境变量：
> 
> 输入 mysql -u root -p回车
> 
> 输入root用户密码，然后回车，登录结束
> 
> 如果没有配置环境变量，windows系统中，可以在开始菜单找到mysql的客户端命令行工具。打开输入密码即可。

### 4.2 基本命令 ###

#### 4.2.1 查看所有数据库 ####

> show databases; 查看MySQL中有哪些数据库

#### 4.2.2 创建数据库 ####

> create database 数据库名称; 创建一个默认字符集的数据库。
> 
> create database 数据库名称 character set GBK; 创建一个字符集为GBK的数据库。
> 
> create database if not exists 数据库名称; 如果没有某个数据库就创建一个。
> 
> 注意：在创建数据库时一定要指定字符集。

create database java2106 character set utf8;

#### 4.2.3 查看创建的数据库信息 ####

> show create database 数据库名称;

#### 4.2.4 修改数据库 ####

> alter database 数据库名称 character set 字符集; 修改字符集

alter database java2106 character set gbk;

#### 4.2.5 查看当前所使用的数据库 ####

> select database(); 注意后面的括号，意味着此处是调用函数。

#### 4.2.6 切换使用数据库 ####

> use 数据库名称;

#### 4.2.7 删除数据库 ####

> drop database 数据库名称;

> 注意：
> 
> 数据库结构的创建、修改、删除、查看等，使用的命令是：create、alter、drop、show

## 五、数据查询 ##

> 数据库是由表构成，表又包含行和列。数据查询即对表的查询。查询结果以行和列的形式显示，可以看作为一张虚拟的表。

### 5.1 数据导入 ###

> show tables; 查看所有的表信息。
> 
> source sql文件地址; 导入一个sql文件。

create database companydb character set utf8; -- 创建数据库
    use companydb; -- 切换使用数据库
    source d:\companydb.sql; -- 导入一个sql文件内容到数据库。
    show tables; -- 查询所有的表名

### 5.2 基本查询 ###

> select 列名 from 表名; 查询一个表中的数据，只查询相应的列。

select * from t_employees; -- 查询所有的列，所有的行。
    select first_name, email from t_employees; -- 查询first_name, email两列。

> 对查询中的列进行运算：可以使用+、-、\*、/、运算，但是不能使用%，%在sql中不是求余运算。
> 
> 注意：\+不能做拼接字符串操作。

SELECT EMPLOYEE_ID, FIRST_NAME, SALARY * 12 FROM t_employees;

> 别名操作，可以给列起别名，语法结构是
> 
> select EMPLOYEE\_ID AS 编号 from t\_employees;
> 
> 注意： AS 关键字可以省略。别名加不加单引号没有区别。

SELECT EMPLOYEE_ID id, FIRST_NAME '名', SALARY * 12 as 年薪 FROM t_employees;

> distinct 对查询结果去重。
> 
> 注意：如果有多列，需要多列的内容都相同才能去重。

SELECT DISTINCT MANAGER_ID FROM t_employees;

### 5.3 排序查询 ###

> 将查询结果按照指定规则排序。
> 
> select 列名 from 表名 order by 排序列 排序规则;
> 
> 排序规则有两种：
> 
>  *  ASC 默认值，升序（由小到大）
>  *  DESC 降序（由大到小）

-- 按照单列排序
    SELECT EMPLOYEE_ID, FIRST_NAME, SALARY FROM t_employees ORDER BY SALARY DESC;

> 多列排序：
> 
> 先按照第一排序列的规则排序，如果有相同的列，则再按第二排序列的规则，以此类推。

SELECT EMPLOYEE_ID, FIRST_NAME, SALARY FROM t_employees ORDER BY SALARY DESC, EMPLOYEE_ID DESC;

> 注意：
> 
> 上面的案例是表示先按照员工薪资排序，如果薪资一样，则将员工比较大的排在前面。

### 5.4 条件查询 ###

> 语法：
> 
> select \* from 表名 where 条件;

#### 5.4.1 等值判断 ####

SELECT * FROM t_employees WHERE SALARY = 11000;
    SELECT * FROM t_employees WHERE FIRST_NAME = 'Steven';

> 注意：如果条件中比较的值是数字，可以不加单引号，也可以加，但是如果不是数字，是字符串或者时间等，必须加单引号。
> 
> 等值比较时只需要一个等号即可。

#### 5.4.2 逻辑判断 ####

> 当有多个条件时，可以使用AND、OR来进行逻辑处理，可以使用NOT来取反。

-- 条件并列
    SELECT * FROM t_employees WHERE SALARY = 11000 AND COMMISSION_PCT = 0.3;
    -- 条件或者
    SELECT * FROM t_employees WHERE FIRST_NAME = 'Steven' OR FIRST_NAME = 'Den';
    -- 条件取反
    SELECT * FROM t_employees WHERE NOT SALARY = 11000 ORDER BY SALARY DESC;

#### 5.4.3 不等值判断 ####

> 可以使用>、 < 、>=、 <=、 !=、 <>来进行不等值判断。
> 
> 注意： !=与<>效果一样。
> 
> 注意：字符串也可以使用不等值判断。先判断第一个字符，然后判断第二个。例如 ‘ac’ 大于’ab’
> 
> 注意： 日期也可以使用不等值判断。后面的日期大于前面的日期，如果使用字符串的方式表示，也可以按照字符串的方式判断。例如：date > '2021’表示得到2021年后所有的数据。

SELECT * FROM t_employees WHERE SALARY <> 11000 ORDER BY SALARY DESC;

#### 5.4.4 区间判断 ####

> 使用between…and来实现区间判断。
> 
> 相当于 列名 >= 较小值 AND 列名 <= 较大值

SELECT * FROM t_employees WHERE SALARY BETWEEN 11000 AND 12000;
    -- 相当于
    SELECT * FROM t_employees WHERE SALARY >= 11000 AND SALARY <= 12000;

> 注意：BETWEEN… AND区间必须先写小值，后面写大值，否则查询没有结果。

#### 5.4.5 空值判断 ####

> 列名 is NULL
> 
> 列名 is not NULL

SELECT * FROM t_employees WHERE COMMISSION_PCT IS NULL; -- 不能用 = NULL
    SELECT * FROM t_employees WHERE COMMISSION_PCT IS NOT NULL;

#### 5.4.6 枚举查询 ####

> 将要匹配的值列举出来，使用in关键字
> 
> 语法：列名 IN (值1，值2， 值3…)

SELECT * FROM t_employees WHERE SALARY IN (8000,10000,6000);
    -- 等同于
    SELECT * FROM t_employees WHERE SALARY = 8000 OR SALARY = 10000 OR SALARY = 6000;

#### 5.4.7 模糊查询 ####

> 当条件不明晰时，可以使用模糊查询。
> 
> 语法：列名 LIKE ‘A%’
> 
> 使用`%`和`_`作为通配符。`%`表示0到多个字符，`_`表示一个字符。
> 
> 注意： 列名 LIKE ‘%%’ 查询所有。

-- 表示名以Al开头，后面有3个字符的
    SELECT * FROM t_employees WHERE FIRST_NAME LIKE 'Al___' ORDER BY FIRST_NAME;
    -- 表示名以Al开头
    SELECT * FROM t_employees WHERE FIRST_NAME LIKE 'Al%' ORDER BY FIRST_NAME;
    -- 表示名包含Al
    SELECT * FROM t_employees WHERE FIRST_NAME LIKE '%Al%' ORDER BY FIRST_NAME;

> 注意：如果在LIKE后面的条件中没有通配符，等同于=

#### 5.4.8 分支查询 ####

> 一些sql的含义：

SELECT 1 FROM t_employees; -- 表里有多少条记录，就会显示多少行数字1
    SELECT `EMPLOYEE_ID` FROM t_employees; -- 表示查询EMPLOYEE_ID列的数据，`号一般用来区分关键字
    SELECT name, `DESC` from users; -- 区分关键字
    SELECT 'EMPLOYEE_ID' FROM t_employees; -- 表里有多少条记录，就会显示多少行字符串EMPLOYEE_ID

> 分支结构查询：
> 
> 语法：
> 
> CASE
> 
> WHEN 条件1 THEN 结果1
> 
> WHEN 条件2 THEN 结果2
> 
> WHEN 条件2 THEN 结果2
> 
> ELSE 结果4
> 
> END

-- 根据薪资查询级别
    SELECT EMPLOYEE_ID, FIRST_NAME, SALARY, 
    CASE
       WHEN SALARY >= 20000 THEN '高级'
       WHEN SALARY >= 10000 THEN '中级'
       WHEN SALARY >= 5000 THEN '初级'
       ELSE '见习'
    END 级别
     FROM t_employees ORDER BY SALARY DESC;

#### 5.4.9 时间函数 ####

> 在MySQL中的时间函数，可以单独使用，也可以用在其他SQL语句中。

SELECT SYSDATE(); -- 得到当前的日期时间
    SELECT CURDATE(); -- 得到当前的日期
    SELECT CURTIME(); -- 得到当前的时间
    SELECT NOW(); -- 得到当前的日期时间
    SELECT WEEK('2021-08-02'); -- 得到指定日期是当年的第几周
    SELECT WEEK(CURDATE()); -- 得到当前日期是当年的第几周（函数可以嵌套）
    -- 得到日期时间中的年月日时分秒
    SELECT YEAR(CURDATE());
    SELECT MONTH(CURDATE());
    SELECT DAY(CURDATE());
    SELECT HOUR(NOW());
    SELECT DATEDIFF('2021-06-03','2021-08-02'); -- 得到两个日期中间间隔的天数，结果是-60
    SELECT ADDDATE(CURDATE(),80); -- 得到今天的80天后是哪一天
    SELECT * FROM t_employees WHERE HIRE_DATE = ADDDATE(CURDATE(),-8200); -- 判断HIRE_DATE日期为今天的8200天前

#### 5.4.10 字符串函数 ####

> 在MySQL中的字符串函数，可以单独使用，也可以用在其他SQL语句中。

SELECT CONCAT(FIRST_NAME,',',LAST_NAME) 全名 FROM t_employees; -- 拼接字符串
    -- 第一个参数是要改变的字符串，第二个参数是从哪个位置开始（下标从1开始），第三个参数是长度，最后一个参数是替换的字符串
    SELECT INSERT(FIRST_NAME,3,3,'Hello')  FROM t_employees WHERE EMPLOYEE_ID = 100; -- 将字符串Steven变成StHellon
    SELECT LOWER(FIRST_NAME) FROM t_employees WHERE EMPLOYEE_ID = 100; -- 转小写
    SELECT UPPER(FIRST_NAME) FROM t_employees WHERE EMPLOYEE_ID = 100; -- 转大写
    SELECT SUBSTRING(FIRST_NAME,2) FROM t_employees WHERE EMPLOYEE_ID = 100; -- 截取字符串

### 5.5 聚合函数 ###

> 类似于Excel中的公式。
> 
> sum()：求和
> 
> avg()：求平均数
> 
> max()：求最大值
> 
> min()：求最小值
> 
> count()：计算行数

SELECT SUM(SALARY) FROM t_employees; -- 统计当月员工总工资和
    SELECT avg(SALARY) FROM t_employees; -- 计算平均薪资
    SELECT max(SALARY) FROM t_employees; -- 最高工资
    SELECT min(SALARY) FROM t_employees; -- 最低工资
    SELECT count(1) FROM t_employees; -- 查询行数，可以使用*或列名，使用数字1性能最好
    SELECT count(1) FROM t_employees WHERE SALARY > 10000; -- 查询薪资大于10000的人数

### 5.6 分组查询 ###

#### 5.6.1 分组基础查询 ####

> 分组查询是将数据按照指定列分成多组，然后按组进行数据统计。所以一般情况下，分组意味着需要聚合统计。
> 
> 语法：
> 
> Group by 分组列

> 注意： 如果语句中有分组，那么前面查询的列，必须是聚合函数或者与分组列有一一对应关系的列。否则只会显示第一行记录，是无意义记录。

SELECT DEPARTMENT_ID,COUNT(1),AVG(SALARY),MAX(SALARY), MIN(SALARY), SUM(SALARY) FROM t_employees GROUP BY DEPARTMENT_ID;

#### 5.6.2 分组过滤查询 ####

> 在分组后，如果还需要添加过滤条件，使用having关键字。

-- 先分组，再写条件使用having关键字
    SELECT DEPARTMENT_ID, COUNT(1), MAX(SALARY) FROM t_employees GROUP BY DEPARTMENT_ID HAVING DEPARTMENT_ID IN (30, 50, 80);

> 但是，上面的语句明显可以先写条件，再分组

-- 先写条件，再分组
    SELECT DEPARTMENT_ID, COUNT(1), MAX(SALARY) FROM t_employees WHERE DEPARTMENT_ID IN (30, 50, 80) GROUP BY DEPARTMENT_ID ;

> 在项目中，必须要用having关键字的场景应该是使用聚合函数当条件。
> 
> 查询平均薪资高于8000的部门。

-- 此时，将条件放到group by的前面，并使用where是不行的
    SELECT DEPARTMENT_ID, AVG(SALARY) FROM t_employees GROUP BY DEPARTMENT_ID HAVING AVG(SALARY) > 8000;

> 注意：having后面的聚合函数只能跟常量比较，不能写列名等，例如，下面的代码是错误的：

-- 查询部门大于平均薪资的人数，不能这么写
    SELECT DEPARTMENT_ID, COUNT(1) FROM t_employees GROUP BY DEPARTMENT_ID HAVING SALARY > AVG(SALARY);

### 5.7 限定查询 ###

> 显示一部分满足条件的结果。项目中通常用来进行分页显示。
> 
> 语法：limit 跳过条数, 显示条数

-- 跳过5条，显示5条，即显示第6-10条
    SELECT * FROM t_employees LIMIT 5, 5;
    -- 如果是跳过0条，显示5条
    SELECT * FROM t_employees LIMIT 0, 5;
    -- 可以简写为：
    SELECT * FROM t_employees LIMIT 5;

> 在项目中，如果有分页的业务，计算规则如下：

// page是页数
    // size是每页显示的条数
    public void findAll(int page, int size){
        
        int skip = (page - 1) * size;
        String sql = "select * from t1 limit " + skip + ", " + size;
    }

### 5.8 基础查询顺序总结 ###

> SELECT 列名
> 
> FROM 表名
> 
> WHERE 条件
> 
> GROUP BY 分组列
> 
> HAVING 分组后条件
> 
> ORDER BY 排序列 排序规则
> 
> LIMIT 跳过条数, 显示条数

### 5.9 子查询 ###

> 在查询语句中包含查询语句。

#### 5.9.1 将查询结果当条件 ####

> 例如：查询工资大于Bruce的员工信息。

-- 查询Bruce的工资信息，得到单行单列的数据（6000）
    SELECT SALARY FROM t_employees WHERE FIRST_NAME = 'Bruce';
    -- 查询工资大于6000的员工信息
    SELECT * FROM t_employees WHERE SALARY > 6000;
    -- 将两条语句组合，需要先查询的部分应该加上括号
    SELECT * FROM t_employees WHERE SALARY > (SELECT SALARY FROM t_employees WHERE FIRST_NAME = 'Bruce');

> 注意：需要结果能够作为查询条件。此处结果必须是单行单列。

#### 5.9.2 查询结果为多行单列（枚举） ####

> 查询与’King’同一个部门的员工信息。

-- 查询King对应的部门
    SELECT DEPARTMENT_ID FROM t_employees WHERE LAST_NAME = 'King';
    -- 结果有两个，不能直接用等号，需要使用in
    SELECT * FROM t_employees WHERE DEPARTMENT_ID in (80, 90) ;
    -- 将两条语句组合，需要先查询的部分应该加上括号
    SELECT * FROM t_employees WHERE DEPARTMENT_ID in (SELECT DEPARTMENT_ID FROM t_employees WHERE LAST_NAME = 'King') ;

#### 5.9.3 ALL和ANY用法 ####

> 查询大于60部门所有员工工资的员工信息。

-- 查询60部门的员工工资，结果是多行单列
    SELECT SALARY FROM t_employees WHERE DEPARTMENT_ID = 60;
    -- 如果要大于60部门所有员工工资，其实只需要大于最高工资即可
    SELECT * FROM t_employees WHERE SALARY >  (SELECT max(SALARY) FROM t_employees WHERE DEPARTMENT_ID = 60);
    -- 上面的写法可以实现结果，但是是人为分析的（算法），按照原始要求应该写为
    SELECT * FROM t_employees WHERE SALARY > ALL (SELECT SALARY FROM t_employees WHERE DEPARTMENT_ID = 60);

> 查询大于60部门任意员工工资的员工信息。

-- 查询60部门的员工工资，结果是多行单列
    SELECT SALARY FROM t_employees WHERE DEPARTMENT_ID = 60;
    -- 如果要大于60部门任意员工工资，其实只需要大于最低工资即可
    SELECT * FROM t_employees WHERE SALARY >  (SELECT min(SALARY) FROM t_employees WHERE DEPARTMENT_ID = 60);
    -- 上面的写法可以实现结果，但是是人为分析的（算法），按照原始要求应该写为
    SELECT * FROM t_employees WHERE SALARY > ANY (SELECT SALARY FROM t_employees WHERE DEPARTMENT_ID = 60);

> 注意：
> 
> ALL和ANY的区别：
> 
> ALL需要判断结果中多行是否全部满足条件，ANY只要结果中多行有一行满足条件即可。

#### 5.9.4 将子查询作为条件再次查询 ####

> 查询所有级别为高级的员工信息。（参考5.4.8）

> 先将员工级别使用分支查询的方式显示：

SELECT EMPLOYEE_ID, FIRST_NAME, SALARY, 
    CASE
       WHEN SALARY >= 20000 THEN '高级'
       WHEN SALARY >= 10000 THEN '中级'
       WHEN SALARY >= 5000 THEN '初级'
       ELSE '见习'
    END lv
     FROM t_employees

> 尝试直接在后面加条件 WHERE lv = ‘高级’，结果报错，原因是别名是在查询出结果后添加的，而条件是作为查询过程中使用的，但是此时结果还没出来，根本就没有别名。
> 
> 于是，需要将查询结果作为一个类似于虚拟表的方式再次查询。

SELECT * FROM
    (SELECT EMPLOYEE_ID, FIRST_NAME, SALARY, 
    CASE
       WHEN SALARY >= 20000 THEN '高级'
       WHEN SALARY >= 10000 THEN '中级'
       WHEN SALARY >= 5000 THEN '初级'
       ELSE '见习'
    END lv
     FROM t_employees) as t1 WHERE lv = '中级';

> 注意：将查询结果作为虚拟表查询时，一定要给查询结果起别名，否则会报错。

### 5.10 合并查询 ###

> 将两次查询结果合并，变成一个结果。

> 前面讲到in效率不高，应该使用其他办法。例如：
> 
> 查询部门号为90和60的，如果使用in，如下：

-- 使用in
    SELECT * FROM t_employees WHERE DEPARTMENT_ID IN (90, 60);

> 可以将90和60拆分查询，并将结果合并：

SELECT * FROM t_employees WHERE DEPARTMENT_ID = 90
    UNION ALL
    SELECT * FROM t_employees WHERE DEPARTMENT_ID = 60;
    -- 也可以使用
    SELECT * FROM t_employees WHERE DEPARTMENT_ID = 90
    UNION
    SELECT * FROM t_employees WHERE DEPARTMENT_ID = 60;

> 经典面试题：
> 
> UNION和UNION ALL的区别：
> 
> UNION会去掉重复的行。而UNION ALL会保留所有的行。
> 
> 注意：必须要查询的列数一致才能合并，必须要一行中所有的列内容与另一行完全一致才算重复。

### 5.11 连接查询 ###

#### 5.11.1 交叉连接(了解) ####

> 两张表完全交叉，形成笛卡尔集，即A表中如果有3条数据，B表中有5条数据，会形成15条记录的结果。

SELECT * FROM t_employees CROSS JOIN t_departments
    -- 也可以写作
    SELECT * FROM t_employees, t_departments

#### 5.11.2 内连接 ####

> 两张表根据某个关联条件进行连接。只有当有关联关系时才会有结果。

-- 查询所有的员工信息，表内有107条记录，但是有一个员工没有部门id
    SELECT * FROM t_employees; 
    -- 查询所有的部门信息，表内有32条记录
    SELECT * FROM t_departments;
    -- 关联查询部门和员工，共有106条记录，因为没有部门id的员工无法显示（没有关联）
    SELECT * FROM t_employees e, t_departments d WHERE e.DEPARTMENT_ID = d.DEPARTMENT_ID;
    -- 另一种使用内连接的写法
    SELECT * FROM t_employees e INNER JOIN t_departments d ON e.DEPARTMENT_ID = d.DEPARTMENT_ID;

> 注意：INNER JOIN在MySQL中是后面的版本才添加的写法，所以之前都是使用where加条件的写法。

#### 5.11.3 外连接 ####

> 两张表根据某个关联条件进行连接。以连接的方向对应的表为基准（会显示该表的所有记录）。

> 左外连接：以左边的表为基准。
> 
> 右外连接：以右边的表为基准。

-- left outer join 可以简写为 left join，以左边的表为准，会先显示内连接的所有106条记录，然后显示左边表中没有关联的数据1条，一共107条记录，没有关联的部门信息显示为null
    SELECT * FROM t_employees e left OUTER JOIN t_departments d ON e.DEPARTMENT_ID = d.DEPARTMENT_ID ORDER BY e.DEPARTMENT_ID;
    -- 右外连接，以右边的表为基准，先显示内连接所有的数据106条，然后显示没有与员工关联的部门信息，员工部分显示为null
    SELECT * FROM t_employees e right JOIN t_departments d ON e.DEPARTMENT_ID = d.DEPARTMENT_ID ORDER BY e.DEPARTMENT_ID;

### 5.12 复杂查询 ###

> – 查询每个部门大于平均薪资的人数

> 1、查询每个部门的平均薪资

SELECT DEPARTMENT_ID, AVG(SALARY) FROM t_employees GROUP BY DEPARTMENT_ID;

> 2、查询部门大于平均薪资的信息

SELECT * FROM t_employees e INNER JOIN 
    (SELECT DEPARTMENT_ID, AVG(SALARY) v FROM t_employees GROUP BY DEPARTMENT_ID) t1
    ON e.DEPARTMENT_ID = t1.DEPARTMENT_ID WHERE SALARY > v;

> 3、将上面的结果分组，求数量。

SELECT e.DEPARTMENT_ID, COUNT(1) FROM t_employees e INNER JOIN 
    (SELECT DEPARTMENT_ID, AVG(SALARY) v FROM t_employees GROUP BY DEPARTMENT_ID) t1
    ON e.DEPARTMENT_ID = t1.DEPARTMENT_ID WHERE SALARY > v
    GROUP BY e.DEPARTMENT_ID;

### 5.13 行转列\[经典面试题\] ###

> 默认的表数据显示方式如下：表名为：score1

<table> 
 <thead> 
  <tr> 
   <th>姓名stu_name</th> 
   <th>课程co_name</th> 
   <th>成绩score</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>张三</td> 
   <td>Java</td> 
   <td>90</td> 
  </tr> 
  <tr> 
   <td>张三</td> 
   <td>SQL</td> 
   <td>95</td> 
  </tr> 
  <tr> 
   <td>张三</td> 
   <td>HTML</td> 
   <td>88</td> 
  </tr> 
 </tbody> 
</table>

> 需要查询后显示为以列的形式：

> 1、先使用单表操作，创建一个单表，如上面的第一个表格样式。
> 
> 查询所有数据

SELECT * FROM score1;

> 2、由于需要使用多个新列（Java、HTML、SQL）来显示数据，所以使用case when的方式来条件显示。

SELECT *,
    CASE WHEN co_name = 'Java' THEN scores ELSE 0 END AS 'Java',
    CASE WHEN co_name = 'HTML' THEN scores ELSE 0 END AS 'HTML',
    CASE WHEN co_name = 'SQL' THEN scores ELSE 0 END AS 'SQL'
     FROM score1;

> 3、去掉其他多余的列

SELECT stu_name,
    CASE WHEN co_name = 'Java' THEN scores ELSE 0 END AS 'Java',
    CASE WHEN co_name = 'HTML' THEN scores ELSE 0 END AS 'HTML',
    CASE WHEN co_name = 'SQL' THEN scores ELSE 0 END AS 'SQL'
     FROM score1;

> 4、按照学生姓名分组显示

> 5、分组之后，与分组列不相关的列只会显示第一行数据，为了显示正确的数据，可以使用max函数来求当列的最大值。

SELECT stu_name,
    max(CASE WHEN co_name = 'Java' THEN scores ELSE 0 END) AS 'Java',
    max(CASE WHEN co_name = 'HTML' THEN scores ELSE 0 END) AS 'HTML',
    max(CASE WHEN co_name = 'SQL' THEN scores ELSE 0 END) AS 'SQL'
     FROM score1 GROUP BY stu_name;

> 练习题中数据进行行转列：
> 
> 1、先把数据以前面的表格1（score1）的形式显示出来。

(SELECT
    s.STU_NAME,
    sc.DEGREE,
    c.COU_NAME
    FROM
    student AS s
    INNER JOIN score AS sc ON s.STU_ID = sc.STU_ID
    INNER JOIN course AS c ON sc.COU_ID = c.COU_ID);

> 2、把上面的显示结果当作虚拟表t1，根据其进行查询显示行转列。

SELECT STU_NAME,
    MAX(CASE WHEN COU_NAME = '计算机导论' THEN DEGREE ELSE 0 END) AS '计算机导论',
    MAX(CASE WHEN COU_NAME = '操作系统' THEN DEGREE ELSE 0 END) AS '操作系统',
    MAX(CASE WHEN COU_NAME = '数字电路' THEN DEGREE ELSE 0 END) AS '数字电路'
     FROM
    (SELECT
    s.STU_NAME,
    sc.DEGREE,
    c.COU_NAME
    FROM
    student AS s
    INNER JOIN score AS sc ON s.STU_ID = sc.STU_ID
    INNER JOIN course AS c ON sc.COU_ID = c.COU_ID) t1 GROUP BY STU_NAME;

### 5.14 查询某个列重复的行\[经典面试题\] ###

> 去重的方式比较简单，使用distinct关键字即可。
> 
> 如果要查询某个列重复的行，先根据该列分组，求每组的数量，如果该组的数量大于1，说明该列是重复的。

SELECT
     sc.COU_ID
    FROM
    score AS sc
    GROUP BY COU_ID
    HAVING COUNT(1) > 1;

## 六、DML操作 ##

> 数据操作语言，对数据库中的数据进行增删改操作。

### 6.1 新增 ###

> 添加数据。
> 
> 语法：
> 
> 添加一行记录：
> 
> INSERT INTO 表名(列名1, 列名2, 列名3) VALUES (值1, 值2, 值3)
> 
> 当添加所有列对应的值时，也可以如下操作：
> 
> INSERT INTO 表名 VALUES (值1, 值2, 值3)
> 
> 一次添加多行记录：
> 
> INSERT INTO 表名(列名1, 列名2, 列名3) VALUES (值1, 值2, 值3), (值1, 值2, 值3), (值1, 值2, 值3), (值1, 值2, 值3);

-- 添加一行，指定部分列
    INSERT INTO t_jobs(JOB_ID, MIN_SALARY, MAX_SALARY) VALUES('AAA', 50000, 100000);
    -- 添加一行，不指定任何列，全列添加
    INSERT INTO t_jobs VALUES('BBB', 'BBBBBBB', 50000, 100000);
    -- 添加多行
    INSERT INTO t_jobs(JOB_ID, MIN_SALARY, MAX_SALARY) VALUES('AAAA', 50000, 100000), ('AAAAA', 50000, 100000), ('AAAAAA', 50000, 100000);

> 注意：值和列名要对应。

### 6.2 修改 ###

> 修改数据：
> 
> 语法：
> 
> UPDATE 表名 SET 列名1 = 值1, 列名2 = 值2, 列名3 = 值3 WHERE 条件;
> 
> 注意：修改时如果没有加条件，会修改所有的行。

UPDATE t_jobs SET JOB_TITLE = 'AAAAAAAAAA', MIN_SALARY = 2000 WHERE JOB_ID = 'AAA';

### 6.3 删除和清空表 ###

> 删除数据：
> 
> 语法：
> 
> DELETE FROM 表名 WHERE 条件;
> 
> 注意：如果没有加条件，会删除表中所有内容。

DELETE FROM t_jobs WHERE Job_id = 'AAA';

> 清空表：将整个表数据清空。
> 
> TRUNCATE TABLE 表名;

TRUNCATE TABLE t_locations;

> 经典面试题：
> 
> TRUNCATE 和 DELETE在删除所有数据时的区别？
> 
>  *  DELETE是逐条删除。而TRUNCATE直接删除表本身，然后重新建立一次。
>  *  DELETE删除表会保留自增数字，而TRUNCATE自增重新开始计算。

## 七、MySQL字段数据类型 ##

### 7.1 数据类型概述 ###

> 字段数据类型大体分为两类：
> 
>  *  不带单引号：数字
>  *  带单引号：
>     
>      *  日期时间，带单引号，但是格式必须按要求
>      *  字符串，带单引号，格式没有要求

### 7.2 数值类型 ###

> int：整数，也有类似于Java中的，此处叫tinyint，smallint，int，bigint
> 
> double：小数
> 
> decimal：小数
> 
> 注意：double和decimal也可以限制长度和小数位的长度，例如double(5,2)表示长度5位，小数位2位，范围-999.99~999.99

### 7.3 日期类型 ###

> date：日期，例如：2021-10-10
> 
> time：时间，例如：13:14:15
> 
> datetime：日期时间，例如：2021-10-10 13:14:15
> 
> timestamp：时间戳

### 7.4 字符串类型 ###

> char：定长字符串，例如：char(4)
> 
> varchar：变长字符串，例如：varchar(4)
> 
> blob：二进制
> 
> text：长文本时
> 
> 注意：在数据库中，char和varchar使用时一定要指定长度。添加数据时不能超过该长度，超过后会截断。
> 
> char和varchar区别在于，如果使用char，但是添加的内容没有达到长度，后面会自动使用空格填充，varchar则不会。例如上面的长度为4，如果添加内容tom，char类型时，显示tom空格，varchar类型时，显示tom
> 
> 所以在项目中，除非知道字段一定会长度固定，才会使用char（性别列），大多数都使用varchar

## 八、表结构操作 ##

### 8.1 表创建 ###

> 表创建的几个要素：
> 
> 1、表名
> 
> 2、每一个列的名称，类型
> 
> 3、规则（约束）

> 基本语法：
> 
> CREATE TABLE 表名(
> 
> 列名 类型 约束,
> 
> 列名 类型 约束,
> 
> 列名 类型 约束
> 
> ) 字符集;

CREATE TABLE product(
    	id INT NOT NULL,
      pro_name VARCHAR(20) NULL,
      create_time datetime
    ) charset=utf8;

### 8.2 表修改 ###

> 语法：
> 
> ALTER TABLE 表名 操作;

#### 8.2.1 添加列 ####

ALTER TABLE product ADD price INT NOT NULL;

#### 8.2.2 修改列 ####

ALTER TABLE product MODIFY price DOUBLE;

#### 8.2.3 修改列名 ####

ALTER TABLE product CHANGE price pro_price DOUBLE NOT NULL;

#### 8.2.4 删除列 ####

ALTER TABLE product DROP pro_price;

> 注意：对表的修改操作会受到数据的影响，可能修改不成功。
> 
> 例如：一个表中列类型为varchar(20),并且表中有一条记录’abc’，如果修改表，要把该列类型修改成int，会报错。
> 
> 建议：先导出表数据，再清空表，然后修改表，最后导入数据。

#### 8.2.5 修改表名 ####

ALTER TABLE product RENAME pro;

### 8.3 删除表 ###

> 删除表结构。
> 
> 语法：DROP TABLE 表名;

DROP TABLE pro;

## 九、表设计过程中的三范式 ##

> 范式：是指表设计的规则。
> 
> 在理论上来说，表设计可以有五范式，但是实际上达不到，所以一般设计表只需要满足三范式即可。

> 三范式：
> 
> 第一范式：域（字段）完整性。列应该是不可再分的。
> 
> 第二范式：实体完整性，主键约束。每一行所有的列应该完全依赖于主键。
> 
> 第三范式：引用完整性，（外键约束）。只能将另一个表的主键当作外键来引用。
> 
> 注意：所有的后面的范式是基于前面的范式的基础上，即第二范式必须先满足第一范式。

## 十、约束 ##

### 10.1 实体完整性约束 ###

#### 10.1.1 主键 ####

> 使用primary key，标识该列为主键，不能重复，不能为空。

CREATE TABLE product(
      id INT PRIMARY KEY,
      pro_name VARCHAR(20),
      create_time datetime
    );

CREATE TABLE product1(
      id INT ,
      pro_name VARCHAR(20),
      create_time datetime,
      PRIMARY KEY (id)
    );

> 当使用多个列同时一起做主键时，还是一个主键，但是必须多列一起做是否重复的判定。

-- 指定多列同时做主键
    CREATE TABLE score1(
      stu_id INT,
      cou_id INT,
      socre INT,
      PRIMARY KEY(stu_id, cou_id)
    );

#### 10.1.2 唯一键 ####

> 当一个表定义时，除了主键外，还有其他的列需要设置唯一性，可以使用关键字UNIQUE。
> 
> 注意：主键不仅需要唯一，而且不能为空，但是UNIQUE只管唯一，可以为空，而且可以多行为空，此时需要设置为NOT NULL。

CREATE TABLE product(
      id INT PRIMARY KEY,
      pro_name VARCHAR(20) UNIQUE NOT NULL,
      create_time datetime
    );

#### 10.1.3 自动增长 ####

> 在mysql中，int类型可以设置自增。而且需要与主键一起使用，不能单独使用，其他数据库与mysql使用方式不一样。

CREATE TABLE product(
      id INT PRIMARY KEY auto_increment,
      pro_name VARCHAR(20) UNIQUE NOT NULL,
      create_time datetime
    );

### 10.2 域完整性 ###

> 设置单元格的正确性。
> 
>  *  非空， NOT NULL
>  *  默认值，DEFAULT

CREATE TABLE product(
      id INT PRIMARY KEY auto_increment,
      pro_name VARCHAR(20) UNIQUE NOT NULL,
      create_time datetime,
    	price int DEFAULT 1
    );

> 注意：即使是int类型，在允许为空的前提下，如果没有设置值，会默认为null，当设置了默认值后，才会使用默认值。

### 10.3 引用完整性 ###

> 一个表中外键列必须要引用另一个表中的主键列。
> 
> 语法：
> 
> CONSTRAINT fk\_t FOREIGN KEY (type\_id) REFERENCES pro\_type(id)
> 
> type\_id是当前表中的外键列
> 
> pro\_type(id)是引用的表的名称和对应的主键列
> 
> fk\_t是当前表中外键的名称（随意取的，但是不同的表中名称不能重复）

CREATE TABLE product(
     id INT PRIMARY KEY auto_increment,
     pro_name VARCHAR(20) NOT NULL,
     type_id INT NOT NULL, 
     CONSTRAINT fk_t FOREIGN KEY (type_id) REFERENCES pro_type(id)
    );

> 注意：如果表中已经有数据，再想通过修改表的方式建立引用外键关系，可能会报错，建议先删除数据再建立。

## 十一、权限管理 ##

11.1 创建用户

> 语法：
> 
> CREATE USER 用户名 IDENTIFIED by 密码;

CREATE USER fenghua IDENTIFIED by '123456';

### 11.2 授权 ###

> 语法：GRANT 权限 ON 数据库名.表名 TO 用户名
> 
> SELECT\\DELETE\\UPDATE\\INSERT

-- 给与fenghua用户对于companydb数据库所有的表查询权限
    GRANT SELECT ON companydb.* TO fenghua;
    -- 给与fenghua用户对于所有库所有的表所有权限
    GRANT ALL ON *.* TO fenghua;

### 11.3 撤销权限 ###

> REVOKE 权限 ON 数据库名.表名 FROM 用户名;

-- 撤销给与的fenghua用户对于companydb数据库所有的表查询权限
    REVOKE SELECT ON companydb.* FROM fenghua;

### 11.4 删除用户 ###

> 语法：DROP USER 用户名;

DROP USER fenghua;

## 十二、视图 ##

> 视图可以理解为一个虚拟的表，实际上就是将一个复杂的查询语句当作一个变量来使用。

> 语法结构：
> 
> 创建视图：
> 
> 方式一：CREATE VIEW 视图名 AS 查询语句
> 
> 方式二：CREATE OR REPLACE VIEW 视图名 AS 查询语句，此方式的特点是如果该视图已经存在，则替换，如果不存在，则创建。

> 修改视图：
> 
> ALTER VIEW 视图名 AS 查询语句

> 删除视图：
> 
> DROP VIEW 视图名

> 注意：视图仅仅只是一个虚拟的变量（表），对视图的删除（DROP）和修改（ALTER）不影响视图所对应的表。

> 将5.12的复杂查询使用视图完成：

-- 查询每个部门大于平均薪资的人数,原来的写法如下
    SELECT e.DEPARTMENT_ID, COUNT(1) FROM t_employees e INNER JOIN 
    (SELECT DEPARTMENT_ID, AVG(SALARY) v FROM t_employees GROUP BY DEPARTMENT_ID) t1
    ON e.DEPARTMENT_ID = t1.DEPARTMENT_ID WHERE SALARY > v
    GROUP BY e.DEPARTMENT_ID;

-- 将代码中的子查询使用视图
    CREATE VIEW v1
    AS
    SELECT DEPARTMENT_ID, AVG(SALARY) v FROM t_employees GROUP BY DEPARTMENT_ID;

-- 修改原来的代码，使用视图替换
    SELECT e.DEPARTMENT_ID, COUNT(1) FROM t_employees e INNER JOIN 
    v1
    ON e.DEPARTMENT_ID = v1.DEPARTMENT_ID WHERE SALARY > v
    GROUP BY e.DEPARTMENT_ID;

> 将原来的行转列使用视图完成：

-- 原来的sql如下，参考5.13
    SELECT STU_NAME,
    MAX(CASE WHEN COU_NAME = '计算机导论' THEN DEGREE ELSE 0 END) AS '计算机导论',
    MAX(CASE WHEN COU_NAME = '操作系统' THEN DEGREE ELSE 0 END) AS '操作系统',
    MAX(CASE WHEN COU_NAME = '数字电路' THEN DEGREE ELSE 0 END) AS '数字电路'
     FROM
    (SELECT
    s.STU_NAME,
    sc.DEGREE,
    c.COU_NAME
    FROM
    student AS s
    INNER JOIN score AS sc ON s.STU_ID = sc.STU_ID
    INNER JOIN course AS c ON sc.COU_ID = c.COU_ID) t1 GROUP BY STU_NAME;

-- 将上面的3表关联查询创建为一个视图
    CREATE VIEW v2 AS
    SELECT
    s.STU_NAME,
    sc.DEGREE,
    c.COU_NAME
    FROM
    student AS s
    INNER JOIN score AS sc ON s.STU_ID = sc.STU_ID
    INNER JOIN course AS c ON sc.COU_ID = c.COU_ID;

-- 将上面的语句使用视图来完成
    SELECT STU_NAME,
    MAX(CASE WHEN COU_NAME = '计算机导论' THEN DEGREE ELSE 0 END) AS '计算机导论',
    MAX(CASE WHEN COU_NAME = '操作系统' THEN DEGREE ELSE 0 END) AS '操作系统',
    MAX(CASE WHEN COU_NAME = '数字电路' THEN DEGREE ELSE 0 END) AS '数字电路'
     FROM
    v2 GROUP BY STU_NAME;

> 注意：
> 
>  *  视图相当于一个临时的表（查询结果），但是使用时还是会将原来的查询语句代入运行，所以视图不会存储数据，原表的数据改变了，视图的结果也会改变。
>  *  对查询性能没有任何优化，仅仅是将查询语句变得简单
>  *  视图是可以update修改数据（修改视图数据等同于修改原表数据）的，但是，如果视图的创建语句包含下面的任意一种，则不能update数据：
>     
>      *  有聚合函数
>      *  使用了distinct
>      *  使用了group by
>      *  使用了having
>      *  使用了union或union all的

## 十三、SQL的分类 ##

> DDL：数据定义语言，创建表、数据库等 CREATE\\ALTER\\DROP
> 
> DCL：数据控制语言，权限，GRANT\\REVOKE
> 
> DML：数据操纵语言，增删改，INSERT\\UPDATE\\DELETE
> 
> DQL：数据查询语言，查询数据，SELECT\\GROUP BY\\ORDER BY\\HAVING
> 
> TPL(TCL)：事务处理语言，处理事务的，COMMIT\\ROLLBACK

## 十四、事务 ##

### 14.1 事务的场景 ###

> 转账。这在项目中应该是一个业务操作（方法）。
> 
> 实际上，该业务操作会在数据库中形成两个修改语句，即修改A账户减钱，修改B账户加钱。
> 
> 如果在修改A账户结束后，在修改B账户时出现了异常，没有成功，那么就形成了A账户减钱了，但是B账户没有加钱的局面，是不合理的。
> 
> 此时，需要使用到事务。

### 14.2 事务的概念 ###

> 事务是由一个或多个sql语句组成的一个原子操作。
> 
> 在一个事务中，只有所有的SQL都执行成功，才成功，如果有一个sql执行失败，则全部失败。

### 14.3 简单原理 ###

> 上面的案例在数据库中执行，如果使用了事务（即不自动提交），此时所有的修改操作都是在缓存中执行，如果全部执行成功，则会将结果写入到数据库（同步数据）（提交事务），如果有任何一个不能执行成功，则不写入到数据库，撤销操作（回顾事务）。

### 14.4 具体操作 ###

> 注意：在数据库中，默认是自动提交事务，即每一条sql语句都默认为是一个独立的事务，所以该sql执行成功后，会自动提交到数据库。
> 
> 所以，如果需要使用事务，首先应该关闭事务的自动提交，注意：事务执行完毕后需要还原自动提交的设置。

> 事务提交：
> 
> COMMIT，提交事务，将缓存数据同步（写入）到数据库。
> 
> 事务回顾：（撤销）
> 
> ROLLBACK，回滚事务，撤销之前的数据库操作。

> 设置自动提交参数：
> 
> SET AUTOCOMMIT = 0; 关闭自动提交
> 
> SET AUTOCOMMIT = 1; 开启自动提交

SELECT @@autocommit; -- 查看系统是否自动提交 1：自动提交 0：不自动提交

set autocommit=0; -- 修改为不自动提交
    -- 减钱
    UPDATE account SET money = money - 500 WHERE account = '1001';
    -- 加钱
    UPDATE account SET money = money + 500 WHERE account = '1002';
    COMMIT; -- 提交事务
    set autocommit=1; -- 还原设置，修改为自动提交

set autocommit=0; -- 修改为不自动提交
    -- 减钱
    UPDATE account SET money = money - 500 WHERE account = '1001';
    -- 加钱
    UPDATE account SET money = money + 500 WHERE account = '1002';
    ROLLBACK; -- 回滚事务
    set autocommit=1; -- 还原设置，修改为自动提交

### 14.5 事务的四大特征 ###

> A（原子性）：事务是一个整体，要么全部成功，要么全部失败。
> 
> C（一致性）：表示事务操作过程中，数据的状态必须是一致的。有一条语句失败，其他的全部回滚。
> 
> I（隔离性）：事务操作之间是相互隔离的，只能看到事务操作之前的状态或者之后的状态，不能看到事务操作过程中的状态。
> 
> D（持久性）：事务执行完成后，结果就持久的写入了数据库。

> 记忆的小技巧:一元九个。（一原久隔）

### 14.6 事务的隔离性的理解 ###

> 事务与事务之间应该相互隔离。
> 
> 安全和性能：如果涉及到同一个数据时，事务与事务之间安全和性能该如何取舍。

### 14.7 事务的隔离级别 ###

>  *  读未提交，一个事务能够读取另一个事务的未提交的数据。会引发脏读、虚读（不可重复读）、幻读问题
>  *  读已提交，一个事务能够读取另一个事务中的已提交的数据。会引发虚度、幻读问题
>  *  可重复读，只会出现幻读问题
>  *  可串行化，事务一个一个执行，性能会降到极低，安全性上升到极高

> 注意：上面的内容从上往下，性能越来越差，安全性越来越高，在项目中需要在性能和安全性上做一个取舍。所以基本不可能设置级别为读未提交或者可串行化。

> 在数据库中的事务的隔离级别的设置上：
> 
> 主流的数据库都默认设置为读已提交。但是唯独MySQL默认设置的可重复读。

### 14.8 脏读、不可重复读、幻读 ###

> 脏读：一个事务能读取另一个事务未提交的数据。脏读不会被任何数据提供方允许，所以出现脏读一般会认为是系统的BUG，需要改动。

> 不可重复读，也叫虚读。一个事务中，两次读取的数据不一致。此时，对于用户来说，可能会产生一些影响，但是对于数据提供方来说，安全没有影响。所以介于安全性和性能上的考虑，大多数主流数据库选择的就是此隔离级别。

> 幻读。一个事务中，两次读取的数据的条数不一致（增加或者减少）。此时，对于用户来说，可能会产生一些影响，但是对于数据提供方来说，安全没有影响。此隔离级别也可以选择，与上一种隔离级别不管是性能还是安全相差不大。