全网最详细MySQL教程，应付大学考试、考研复试、求职笔试应该说是完全足够的，
有兴趣的朋友可以看我的MySQL专栏，都是MySQL原理和底层一点的东西，可能比一般的面试文都深入。
本文篇幅较长，笔误之处在所难免，某些部分可能曾经写的不够详细（会陆续优化），如果觉得某节内容例子不够没有讲解好，欢迎在评论区提出，哪怕一点小修改，我后续也会进行补充或者修订，2023持续更新中...
--------------------------------------------------------------------------------------------------
最近修改：
4.1、4.2、4.3、4.4节（优化内容：给出容易理解的示例与实际运行结果——无需敲击一行代码，就能深入理解。包括特殊情景实例，均以代码片段形式展示，便于大家一键复制运行。）
PS: 说好的一周之内更新完4.4节的任务已完工！
后续会继续优化其他小节...
(如果文章突然消失个5分钟，可能是我修改了文章正在审核中)
目录
2.3 SQLyog（MySQL图形化开发工具，我个人用的Navicat）
4.5.7 MySQL索引原理图解、B+树应用场景大全、索引优化、索引成本计算等
第1章 数据库
1.1 数据库概述
什么是数据库
数据库是一个用于存储和管理数据的仓库。数据按照特定的格式存储，可以对数据库中的数据进行增加、修改、删除和查询操作。数据库的本质是一个文件系统，按照一定的逻辑结构组织数据，以方便高效地访问和维护。
什么是数据库管理系统
数据库管理系统（DataBase Management System，DBMS）是一个操作和管理数据库的软件。它用于建立、使用和维护数据库，对数据库进行统一管理和控制，以保证数据库的安全性和完整性。用户通过数据库管理系统访问数据库中表内的数据。
常见的数据库管理系统
MYSQL ：
- MySQL 不仅用于小型数据库，还可以扩展到大型企业级应用场景。它在许多高流量的网站和大型企业系统中得到了广泛应用。
- 虽然 Oracle 收购了 MySQL，但开源版本仍然存在且免费。MySQL 有多个版本（如社区版、企业版等），其中一些版本收费，但免费的社区版仍在维护和更新。
Oracle ：收费的大型关系数据库管理系统，主要用于大型企业级应用。
DB2 ：IBM 公司的收费关系数据库产品，国内几乎没有在用。
SQLServer：MicroSoft 公司收费的中型的数据库。SQL Server 不仅适用于 C# 和 .NET 语言，还可以与其他编程语言（如 Java、Python、PHP 等）一起使用。
SQLite : 嵌入式的小型数据库，SQLite 不仅应用于手机端，还可以应用于桌面应用程序和物联网（IoT）设备等。
PostgreSQL：PostgreSQL 是一种开源的关系数据库管理系统，功能强大且可扩展，适用于各种规模的应用场景。它在许多大型企业和开源项目中得到了广泛应用。
NoSQL：除了上述描述的关系数据库管理系统外，还有一类称为 NoSQL（Not Only SQL）数据库，它们使用非关系模型来存储和管理数据。这些数据库包括 MongoDB（文档存储）、Redis（键值存储）、Apache Cassandra（列存储）和 Neo4j（图数据库）等。这些数据库在大数据、分布式系统和实时应用场景中具有优势。
这里使用MySQL数据库。MySQL中可以有多个数据库，数据库是真正存储数据的地方。
数据库与数据库管理系统的关系
1.2 数据库表
数据库中以表为组织单位存储数据。
表类似我们的Java类，每个字段都有对应的数据类型。
那么用我们熟悉的java程序来与关系型数据对比，就会发现以下对应关系。
类----------表
类中属性----------表中字段
对象----------记录
1.3 表数据
根据表字段所规定的数据类型，我们可以向其中填入一条条的数据，而表中的每条数据类似类的实例对象。表中的一行一行的信息我们称之为记录。
表记录与java类对象的对应关系
第2章 MySql数据库
2.1 MySql安装
安装
自行百度
安装后，MySQL会以windows服务的方式为我们提供数据存储功能。开启和关闭服务的操作：右键点击我的电脑→管理→服务→可以找到MySQL服务开启或停止。
也可以在DOS窗口，通过命令完成MySQL服务的启动和停止（必须以管理运行cmd命令窗口）
2.2 登录MySQL数据库
MySQL是一个需要账户名密码登录的数据库，登陆后使用，它提供了一个默认的root账号，使用安装时设置的密码即可登录。
格式1：cmd> mysql –u用户名 –p密码
例如：mysql -uroot –proot
格式2：cmd> mysql --host=ip地址 --user=用户名 --password=密码
例如：mysql --host=127.0.0.1 --user=root --password=root
2.3 SQLyog（MySQL图形化开发工具，我个人用的Navicat）
安装：
提供的SQLyog软件为免安装版，可直接使用。【其实我建议使用Navicat，具体怎么破解得百度，公司都用的这个，学习阶段用SQLyog也没关系】
使用：
输入用户名、密码，点击连接按钮，进行访问MySQL数据库进行操作
在Query窗口中，输入SQL代码，选中要执行的SQL代码，按F8键运行，或按执行按钮运行。
2.4 MySQL配置文件
看到你的C:\ProgramData\MySQL\MySQL Server 8.0目录，注意ProgramData是隐藏目录，你需要设置查看隐藏文件才能看得到。
发现下面有个my.ini，这就是MySQL数据库的配置文件，比如字符集、端口号、目录地址等信息都可以在这里配置。
从大体上我们可以看到，my.ini里面有3个部分。
[client]和[mysql]是客户端配置信息，[mysqld]是数据库配置信息
提示：[mysql]中默认no-beep表示当数据库发生错误的时候，不要让主板发出蜂鸣器的声音
[mysqld]大致说明如下(已去掉默认注释，不然篇幅太长)
第3章 SQL语句
数据库是不认识JAVA语言的，但是我们同样要与数据库交互，这时需要使用到数据库认识的语言SQL语句，它是数据库的代码。
结构化查询语言(Structured Query Language)简称SQL，是一种数据库查询和程序设计语言，用于存取数据以及查询、更新和管理关系数据库系统。
创建数据库、创建数据表、向数据表中添加一条条数据信息均需要使用SQL语句。
3.1 SQL语句
SQL分类：
数据定义语言：简称DDL(Data Definition Language)，用来定义数据库对象：数据库，表，列等。关键字：create，alter，drop等
数据操作语言：简称DML(Data Manipulation Language)，用来对数据库中表的记录进行更新。关键字：insert，delete，update等
数据控制语言：简称DCL(Data Control Language)，用来定义数据库的访问权限和安全级别，及创建用户。
数据查询语言：简称DQL(Data Query Language)，用来查询数据库中表的记录。关键字：select，from，where等
3.2 SQL通用语法
1.SQL语句可以单行或多行书写，以分号结尾
2.可使用空格和缩进来增强语句的可读性
3.MySQL数据库的SQL语句不区分大小写，建议使用大写，例如：SELECT * FROM user。
4.同样可以使用/**/的方式完成注释
5.MySQL中的我们常使用的数据类型如下
详细的数据类型如下
| 分类 | 类型名称 | 说明 |
| 整数类型 | tinyInt | 很小的整数，1字节 |
| smallint | 小的整数，2字节 | |
| mediumint | 中等大小的整数，3字节 | |
| int(integer) | 普通大小的整数，4字节 | |
| bigint | 大整数，8字节 | |
| 小数类型 | float | 单精度浮点数，4字节 |
| double | 双精度浮点数，8字节 | |
| decimal（m,d） | 应该设置 m 和 d 的值。m 表示数字总位数，d 表示保留到小数点后 d 位。如果不设置 m 和 d，默认精度是 10,0，而不是整型 | |
| 日期类型 | year | 年份 YYYY 1901~2155，1字节 |
| time | 时间 HH:MM:SS -838:59:59~838:59:59，3字节 | |
| date | 日期 YYYY-MM-DD 1000-01-01~9999-12-3，3字节 | |
| datetime | 日期时间 YYYY-MM-DD HH:MM:SS 1000-01-01 00:00:00~ 9999-12-31 23:59:59，8字节 | |
| timestamp | 时间戳 YYYY-MM-DD HH:MM:SS 1970~01~01 00:00:01 UTC~2038-01-19 03:14:07UTC，4字节 | |
| 文本、二进制类型 | CHAR(M) | M为0~255之间的整数，固定长度为M，不足后面补全空格 |
| VARCHAR(M) | M为0~65535之间的整数 | |
| TINYBLOB | 允许长度0~255字节 | |
| BLOB | 允许长度0~65535字节 | |
| MEDIUMBLOB | 允许长度0~167772150字节 | |
| LONGBLOB | 允许长度0~4294967295字节 | |
| TINYTEXT | 允许长度0~255字节（0 ~ 2^8 - 1） | |
| TEXT | 允许长度0~65535字节（0 ~ 2^16 - 1） | |
| MEDIUMTEXT | 允许长度0~167772150字节（2^24 - 1） | |
| LONGTEXT | 允许长度0~4294967295字节（2^32 - 1） | |
| VARBINARY(M) | 允许长度0~M个字节的变长字节字符串 | |
| BINARY(M) | 允许长度0~M个字节的定长字节字符串 |
需要注意的是：
1. BOOLEAN在数据库保存的是tinyInt类型，false为0，true就是1
2. char是定长，varchar是变长，char存储时，如果字符数没有达到定义的位数，后面会用空格填充到指定长度，而varchar没达到定义位数则不会填充，按实际长度存储。比如一个 char(10) 类型的列它的长度是固定为 10 个字符。当我们插入一个长度为 5 的字符串时，MySQL 会在字符串的末尾添加 5 个空格，以填充到 10 个字符的长度。但是在查询结果中，这些空格会被省略，length()函数查不出区别，但是在储存中是有区别的。
3. char长度固定，尽管 char 类型存储速度可能略快于 varchar 类型，但这种差异通常可以忽略不计。实际上，在大多数情况下，数据存储空间和查询性能更为重要，实际开发中varchar远比char更常见。
4. timestamp 类型的值会随着时区的变化而变化。另外，timestamp 类型的默认值和更新行为与其他日期时间类型有所不同。timestamp 类型的列在插入或更新时，如果未显式设置值，会自动设置为当前的 UTC 日期时间。
5. year 类型用于表示年份，并支持两种显示格式：2 位数字表示（年份的后两位）和 4 位数字表示（完整年份）。它占用 1 字节的存储空间，值的范围是从 '1901' 到 '2155'。在 MySQL 中，如果使用 2 位数字表示年份，系统会根据一个范围（默认为 1970-2069）将其转换为 4 位数字表示的年份。对于 '00' 到 '69'，系统会将其转换为 '2000' 到 '2069'；对于 '70' 到 '99'，系统会将其转换为 '1970' 到 '1999'。
比如：
-- 插入为2022
INSERT INTO example (year_col) VALUES ('22');
-- 插入为1970
INSERT INTO example (year_col) VALUES ('70');
-- 如果要插入2070，还是要具体指明4位数
INSERT INTO example (year_col) VALUES ('2070');
3.3 数据库操作：database
创建数据库
格式:
create database 数据库名;
create database 数据库名 character set 字符集;
例如：
#创建数据库 数据库中数据的编码采用的是安装数据库时指定的默认编码 utf8
CREATE DATABASE day21_1;#创建数据库 并指定数据库中数据的编码
CREATE DATABASE day21_2 CHARACTER SET gbk; 
#如果创建之后 修改数据库编码
ALTER DATABASE day21_2 CHARACTER SET=utf8;查看数据库
查看数据库MySQL服务器中的所有的数据库:
show databases;查看某个数据库的定义的信息:
show create database 数据库名;
例如：
show create database day21_1;删除数据库
drop database 数据库名称;
例如：
drop database day21_2;其他的数据库操作命令
切换数据库：
格式：use 数据库名;
例如：
use day21_1;查看正在使用的数据库:
select database();图形化结果类似于下图
3.4 表结构相关语句
3.4.1 创建表
格式：
create table 表名(
字段名 类型(长度) 约束,
字段名 类型(长度) 约束
);
例如：
创建分类表
CREATE TABLE sort (
sid INT, #分类ID
sname VARCHAR(100) #分类名称
);
温馨提示：你创建了数据库（默认innodb引擎），就创建了一块逻辑空间，实际在磁盘上创建了一个文件夹，你创建了一个表，实际磁盘生成了一个.ibd文件，你可以在C:\ProgramData\MySQL\MySQL Server 8.0\Data目录下验证一下，路径中的ProgramData是隐藏文件夹。
在 Linux 系统上，MySQL 的数据文件通常位于 /var/lib/mysql 目录下
举个例子，你创建了test数据库，然后你执行建表语句如下
CREATE TABLE temp(/*实验精度丢失问题*/
id INT UNSIGNED PRIMARY KEY,
num DECIMAL(20, 10) /*数字总位数20，保留小数点后10位*/
)
实际在你的磁盘上是这样存储的
3.4.2 查看表
查看数据库中的所有表：
格式：
show tables;图形化结果类似于下图
这里的命名就告诉了你是 test 数据库里面的表
查看表结构：
有两种方式
方法一： desc 表名;
方法二： SHOW COLUMNS FROM 表名;
例如：
DESC student;
SHOW COLUMNS FROM student;
/* 这两种方式结果一模一样，第一种更常见，显然命令更短你也更愿意用 */图形化结果类似于下图
如果在建表初期比较粗心，某些字段可以忘记写了comment注释信息，导致后续安全合规不通过，如何快速查看呢？
show full columns from 表名 where comment = '';这样就可以很快筛选出没有comment的字段进行相应修改处理
3.4.3 删除表
格式：drop table 表名;
例如：
drop table sort;3.4.4 修改表结构格式（实际开发最常用）
alter table 表名 add 列名 类型(长度) 约束;
作用：修改表添加列.
例如：
#1，为分类表添加一个新的字段为 分类描述 varchar(20)
ALTER TABLE sort ADD sdesc VARCHAR(20);当然，想添加多个字段分类怎么做呢？
/*添加多个列方法一*/
ALTER TABLE student
ADD address VARCHAR(200) NOT NULL,
ADD home_tel CHAR(11) NOT NULL;
/*add语句之间用逗号分隔，最后用分号结束*/
/*添加多个列方法二*/
ALTER TABLE student
ADD (address VARCHAR(200) NOT NULL,home_tel CHAR(11) NOT NULL);值得注意的是：
如果表需要添加多列，而有一列字段home_tel之前已经添加过了，结果会显示Duplicate column name 'home_tel'，那么你本次添加的多列字段都是无效的，即全部添加失败
如果我想将这个字段添加到某个字段之后而不是末尾怎么办呢？
alter table 表名 add 列名 类型(长度) 约束 after 某个字段;
比如我想在age字段的后面加一个字段sex，而不是在最后一个字段末尾添加
alter table student add column sex char(1) not null comment '性别' after age;
新增列的时候，也可以同时新增索引，后续讲解索引的时候也会提到，比如
ALTER TABLE student
ADD address VARCHAR(200) NOT NULL,
ADD home_tel CHAR(11) NOT NULL AFTER address,
ADD INDEX idx_student_address (address),
ADD INDEX idx_student_phone (phone);alter table 表名 modify 列名 类型(长度) 约束;
作用：修改表修改列的类型长度及约束.
例如：
#2, 为分类表的分类名称字段进行修改，类型varchar(50) 添加约束 not null
ALTER TABLE sort MODIFY sname VARCHAR(50) NOT NULL; /* 添加约束NOT NULL */
ALTER TABLE student
MODIFY home_tel VARCHAR(20) NOT NULL; /*CHAR(11)修改为VARCHAR(200)*/同理，和add类似，需要修改多个列的类型长度及约束，那么modify语句之间用逗号分隔，最后一句的末尾用分号结束。
alter table 表名 change 旧列名 新列名 类型(长度) 约束;
作用：修改表修改列名.
例如：
#3, 为分类表的分类名称字段进行更换 更换为 snamesname varchar(30)
ALTER TABLE sort CHANGE sname snamename VARCHAR(30);同理，和add类似，需要修改多个列的字段名，那么change语句之间用逗号分隔，最后一句的末尾用分号结束。
直接来个例题：
假设有2个选项, 选择哪一个
A. ALTER TABLE cource CHANGE cname VARCHAR(30) NOT NULL FIRST;
B. ALTER TABLE cource MODIFY cname VARCHAR(30) NOT NULL FIRST;
请注意CHANGE和MODIFY的区别, MODIFY可以修改字段类型、字段属性，而CHANGE可修改字段名称，并且CHANGE需要旧列名和新列名，答案是B
注意：change和modify都可以修改表的定义，不同的是change后面需要写两次列名，不太方便，但是change的优点是可以修改列名称，modify则不行。
alter table 表名 drop 列名;
作用：修改表删除列.
例如：
#4, 删除分类表中snamename这列
ALTER TABLE sort DROP snamename;
ALTER TABLE student
DROP home_address,
DROP home_tel;同理，和add类似，需要删除多列，那么drop语句之间用逗号分隔，最后一句的末尾用分号结束。
来一道选择题，题目是：删除数据表中多余的列的语句是哪些，有同学上去就选了个B，认为删除就是DELETE，这里的答案是AC。
rename table 表名 to 新表名;
作用：修改表名
例如：
#5, 为分类表sort 改名成 category
RENAME TABLE sort TO category;alter table 表名 character set 字符集;
作用：修改表的字符集
例如：
#6, 为分类表 category 的编码表进行修改，修改成 gbk
ALTER TABLE category CHARACTER SET gbk;3.5 DOS操作数据乱码解决
我们在dos命令行操作中文时，会报错
insert into user(username,password) values(‘张三’,’123’);
ERROR 1366 (HY000): Incorrect string value: '\xD5\xC5\xC8\xFD' for column 'username' at row 1
原因:因为mysql的客户端编码的问题我们的是utf8,而系统的cmd窗口编码是gbk
解决方案（临时解决方案）:修改mysql客户端编码。
show variables like 'character%'; 查看所有mysql的编码
在图中与客户端有关的编码设置:
client connetion result 和客户端相关
database server system 和服务器端相关
将客户端编码修改为gbk.
set character_set_results=gbk; / set names gbk;
以上操作，只针对当前窗口有效果，如果关闭了服务器便失效。如果想要永久修改，通过以下方式:
在mysql安装目录下有my.ini文件
default-character-set=gbk 客户端编码设置
character-set-server=utf8 服务器端编码设置
注意:修改完成配置文件，重启服务
第4章 字段属性
主键, 唯一键和自增长.
4.1 主键
在创建表的过程中，我们可以设置一个或多个字段作为主键。主键是用来唯一标识表中的每一行记录的，主键字段的值不能重复，且不能为NULL。
一张表只能有最多一个主键, 主键请尽量使用整数类型而不是字符串类型
4.1.1 增加主键
SQL操作中有多种方式可以给表增加主键: 大体分为三种.
方案1: 在创建表的时候，直接在字段之后，跟primary key关键字(主键本身不允许为空)
创建表并设置主键：
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
age INT NOT NULL
);
使用DESC命令查看表结构：
DESC employees;+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| employee_id | int | NO | PRI | NULL | |
| first_name | varchar(50) | NO | | NULL | |
| last_name | varchar(50) | NO | | NULL | |
| age | int | NO | | NULL | |
+-------------+-------------+------+-----+---------+-------+可以看到employee_id列的Key字段值为PRI，表示该列为主键。
方案2: 在创建表的时候, 在所有的字段之后, 使用primary key(主键字段列表)来创建主键(如果有多个字段作为主键,可以是复合主键)
还是刚刚的例子，我们可以使用ALTER TABLE语句将first_name和last_name设置为复合主键：
ALTER TABLE employees
DROP PRIMARY KEY,
ADD PRIMARY KEY (employee_id, first_name);
先删除原来主键，再新增联合主键
现在查看表的结构：
mysql> DESC employees;
+-------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+--------------+------+-----+---------+-------+
| employee_id | int | NO | PRI | NULL | |
| first_name | varchar(50) | NO | PRI | NULL | |
| last_name | varchar(50) | NO | | NULL | |
| age | int | NO | | NULL | |
+-------------+--------------+------+-----+---------+-------+从上面的输出可以看出，employee_id和first_name现在都标记为PRI，表示他们现在是复合主键。
注意：需要保证employee_id和first_name组合是唯一的，因为主键要求其字段的值必须是唯一的。
假设这两个主键字段的数据是这样的。
+-------------+-----------+
| employee_id | first_name|
+-------------+-----------+
| 1 | a |
| 1 | b |
| 2 | a |
| 2 | b |
+-------------+-----------+
这里可以看到employee_id和first_name字段都有重复的值。然而查看employee_id和first_name的组合（也就是每一行），会发现每一行都是唯一的。这就是我们说的"组合必须是唯一的"。
如果我们试图插入一行数据，如(employee_id, first_name) = (1, a)，那么就会出现错误，因为这个组合在表中已经存在了，违反了主键的唯一性约束。
INSERT INTO orders (employee_id, first_name) VALUES (1, a);以上操作将会失败，因为它试图插入一个已经存在的复合主键值。
方案3: 当表已经创建好之后, 额外追加主键:
假如建表语句如下
CREATE TABLE employees (
employee_id INT,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
age INT NOT NULL
);
查看表结构：
mysql> DESC employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | YES | | NULL | |
| first_name | varchar(50) | NO | | NULL | |
| last_name | varchar(50) | NO | | NULL | |
| age | int | NO | | NULL | |
+--------------+-------------+------+-----+---------+-------+
我们想要额外追加一个主键。我们可以选择employee_id字段作为主键。这可以通过ALTER TABLE命令实现：
mysql> ALTER TABLE employees ADD PRIMARY KEY (employee_id);
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0查看表结构：
mysql> DESCRIBE employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | NO | PRI | NULL | |
| first_name | varchar(50) | NO | | NULL | |
| last_name | varchar(50) | NO | | NULL | |
| age | int | NO | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)可以看到employee_id字段的NULL属性现在显示为NO，主键字段不能为NULL，当一个字段被设置为主键时，系统会自动将这个字段的NULL属性设置为NO。
4.1.2 主键约束
创建约束的目的就是保证数据的完整性和一致性。
主键约束是用来确保表中主键字段的值是唯一的，且不能为NULL。在创建表时，可以使用 PRIMARY KEY 关键字为某个字段添加主键约束。以下是一个为 student_id 字段添加主键约束的例子：
CREATE TABLE students (
student_id INT NOT NULL,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
age INT NOT NULL,
PRIMARY KEY (student_id)
);
4.1.3 更新主键 & 删除主键
没有办法直接更新主键，需要先删除现有的主键，然后再添加新的主键。以下是一个删除主键并添加新主键的例子：
CREATE TABLE products (
product_id INT PRIMARY KEY,
product_name VARCHAR(50) NOT NULL,
price DECIMAL(10, 2) NOT NULL
);查看表结构：
DESC products;+--------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+--------------+------+-----+---------+-------+
| product_id | int | NO | PRI | NULL | |
| product_name | varchar(50) | NO | | NULL | |
| price | decimal(10,2)| NO | | NULL | |
+--------------+--------------+------+-----+---------+-------+删除现有的主键：
ALTER TABLE products DROP PRIMARY KEY;查看表结构：
DESC products;+--------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+--------------+------+-----+---------+-------+
| product_id | int | YES | | NULL | |
| product_name | varchar(50) | NO | | NULL | |
| price | decimal(10,2)| NO | | NULL | |
+--------------+--------------+------+-----+---------+-------+如果你删除这个主键，那么它的NULL属性会变回YES，表示可以接受NULL值
为product_name字段添加新的主键：
ALTER TABLE products ADD PRIMARY KEY (product_name);查看表结构：
DESC products;+--------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+--------------+------+-----+---------+-------+
| product_id | int | YES | | NULL | |
| product_name | varchar(50) | NO | PRI | NULL | |
| price | decimal(10,2)| NO | | NULL | |
+--------------+--------------+------+-----+---------+-------+ 现在可以看到product_name列的Key字段值为PRI，表示该列现在为主键，而product_id列的Key字段值为空，表示该列不再是主键。
4.1.4 主键分类
一般分为逻辑主键和业务主键
业务主键是具有实际业务含义的主键，它通常与业务逻辑紧密相关。业务主键用于在数据库表中唯一标识每一行记录，同时它的值与实际业务场景有关。使用业务主键时，需要确保这些主键在表中具有唯一性，同时它们可能需要满足特定的规则和格式。
以一个学生信息表为例，我们可以使用学号作为业务主键，因为学号在学生中具有唯一性且具有实际业务含义。表结构如下：
CREATE TABLE students (
student_id CHAR(10) PRIMARY KEY,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
birth_date DATE NOT NULL
); 在这个例子中，student_id就是一个业务主键。学号具有实际业务含义，它代表了每个学生在学校的唯一标识。当我们插入新的学生记录时，需要为每个学生分配一个唯一的学号。
与此相比，逻辑主键通常是一个自增的整数，它的值与业务逻辑无关，只是作为数据库表中记录的唯一标识符。例如，我们可以使用一个自增的整数作为订单表的逻辑主键：
CREATE TABLE orders (
order_id INT AUTO_INCREMENT PRIMARY KEY,
customer_id INT NOT NULL,
order_date DATE NOT NULL,
total_amount DECIMAL(10, 2) NOT NULL
); 在这个例子中，order_id就是一个逻辑主键。与业务主键不同，逻辑主键没有实际业务含义，只是用于标识每个订单记录。它会自动递增，确保每个订单在表中具有唯一的标识。
4.2 自动增长
自增长（Auto-increment）是数据库中的一种特性，通常用于为表中的主键字段自动生成唯一的整数值。当在表中插入新的记录时，自增长字段会自动分配一个比前一个记录更大的整数值，这样可以确保每条记录的主键值是唯一的。当自增长字段不给值，或者给NULL的时候，系统会自动为该字段分配一个唯一的整数值。这个值是根据当前字段中已有的最大值加1得到的。
4.2.1 新增自增长
假设我们有一个名为 students 的表：
CREATE TABLE students (
id INT AUTO_INCREMENT,
name VARCHAR(50),
age INT,
PRIMARY KEY (id)
);执行DESC students;查看表结构：
+-------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+----------------+
| id | int | NO | PRI | NULL | auto_increment |
| name | varchar(50) | YES | | NULL | |
| age | int | YES | | NULL | |
+-------+-------------+------+-----+---------+----------------+
在这个例子中，id 字段是自增长字段。
- 自增长字段必须是整数类型，并且通常设置为主键。在此示例中，
id是整数类型，并设置为主键。 - 每张表最多只能有一个自增长字段。在此示例中，
id是唯一的自增长字段。
关于自增长，需要注意的是：
1. 自增长字段必须是整数和浮点数类型，如果是其他类型，就报错
AUTO_INCREMENT属性只能被用在整型（integer）或者浮点数（floating point）类型的列上。这包括数据类型：TINYINT，SMALLINT，MEDIUMINT，INT，BIGINT，以及这些类型的有符号和无符号版本。对于浮点数，包括FLOAT 和 DOUBLE。
对于浮点数类型的字段，如果它被设置为AUTO_INCREMENT，那么它的增量将是1.0。也就是说，如果当前的值是1.0，那么下一个值将会是2.0，然后是3.0，依此类推。
即使设置浮点数的初始值为0.1，MySQL的AUTO_INCREMENT属性仍然会使其以整数的形式递增。也就是说，第一个插入的记录如果没有指定值，它的值将是1.0，而不是1.1。接下来的值将是2.0，3.0，等等。不会生成如1.1，2.1这样的值。这是因为MySQL的AUTO_INCREMENT属性会忽略初始设置值的小数部分，并始终以整数的方式递增。
尽管浮点数类型的字段可以被设置为AUTO_INCREMENT，但实际开发中没人这么干，开发中使用UNSIGNED BIGINT是比较常见的。使用浮点数作为自增字段可能引入一些不一致性和不精确性，这可能会导致数据的不准确。特别是当自增值非常大的时候，浮点数可能会开始丢失精度，这是因为浮点数只能存储有限数量的有效数字。因此更常见的做法是在整数类型的字段上使用AUTO_INCREMENT属性。
能被设置为AUTO_INCREMENT的前提是它已经被定义为主键或唯一索引。只有这样MySQL才能保证每行的自增值是唯一的。
2. 每张表最多只能有一个自增长字段。
3. 自增长字段通常用作唯一标识记录，例如 ID。
4. 如果插入数据时为自增长字段指定了值，该值会被插入，但不会影响后续自增长的计算。
5. 更改自增长字段的值时，只能设置大于当前最大值的数字，不能设置更小的值。
6. 默认情况下，自增长字段从1开始，每次递增1。但可以通过修改系统变量实现不同的起始值和递增步长，这些设置将影响整个数据库，而不仅仅是单张表，所以不建议手动更改自增长字段的值
4.2.2 自增长使用
现在，我们向 students 表插入一些数据：
INSERT INTO students (name, age) VALUES ('Alice', 20);
INSERT INTO students (name, age) VALUES ('Bob', 22);
INSERT INTO students (name, age) VALUES ('Charlie', 19);查看表中的数据：
SELECT * FROM students;+----+----------+-----+
| id | name | age |
+----+----------+-----+
| 1 | Alice | 20 |
| 2 | Bob | 22 |
| 3 | Charlie | 19 |
+----+----------+-----+注意 id 字段是如何自动递增的。
接下来，我们手动为自增长字段 id 插入一个值：
INSERT INTO students (id, name, age) VALUES (10, 'David', 23);查看表中的数据：
SELECT * FROM students;+----+----------+-----+
| id | name | age |
+----+----------+-----+
| 1 | Alice | 20 |
| 2 | Bob | 22 |
| 3 | Charlie | 19 |
| 10 | David | 23 |
+----+----------+-----+注意我们手动插入的值 10 成功地添加到了 id 字段。现在，我们再次插入一个没有指定 id 的记录：
INSERT INTO students (name, age) VALUES ('Eva', 21);查看表中的数据：
SELECT * FROM students;+----+----------+-----+
| id | name | age |
+----+----------+-----+
| 1 | Alice | 20 |
| 2 | Bob | 22 |
| 3 | Charlie | 19 |
| 10 | David | 23 |
| 11 | Eva | 21 |
+----+----------+-----+注意自增长字段 id 如何从最大值 10 自动递增到 11。
关于自增长字段的起始值和递增步长，可以通过修改数据库的系统变量进行设置。在 MySQL 中，可以使用以下语句设置起始值和递增步长：
SET @@auto_increment_increment=2;
SET @@auto_increment_offset=100;如何确定下一次是什么自增长呢?
查看表的创建信息：
SHOW CREATE TABLE students;输出结果：
CREATE TABLE `students` (
`id` int NOT NULL AUTO_INCREMENT,
`name` varchar(50) DEFAULT NULL,
`age` int DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci注意 AUTO_INCREMENT=12 部分，它表示下一个自增长值将是 12。
也可以查询 INFORMATION_SCHEMA.TABLES 表来获取下一个自增长值
假设数据库名为 my_database
首先，确保已选择正确的数据库：
USE my_database; 然后执行以下查询以获取 students 表的下一个自增长值：
SELECT AUTO_INCREMENT
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA = 'my_database' AND TABLE_NAME = 'students';执行结果将如下所示：
+----------------+
| AUTO_INCREMENT |
+----------------+
| 12 |
+----------------+4.2.3 修改自增长
自增长如果是涉及到字段改变: 必须先删除自增长，后增加(一张表只能有一个自增长)
首先我们在 MySQL 命令行客户端中创建 employees 表：
CREATE TABLE employees (
emp_id INT AUTO_INCREMENT,
emp_name VARCHAR(50),
emp_age INT,
PRIMARY KEY (emp_id)
);接下来我们插入一些记录：
INSERT INTO employees (emp_name, emp_age) VALUES ('Alice', 30);
INSERT INTO employees (emp_name, emp_age) VALUES ('Bob', 25);
INSERT INTO employees (emp_name, emp_age) VALUES ('Charlie', 35);此时表中有以下记录：
+--------+-----------+---------+
| emp_id | emp_name | emp_age |
+--------+-----------+---------+
| 1 | Alice | 30 |
| 2 | Bob | 25 |
| 3 | Charlie | 35 |
+--------+-----------+---------+注意：
1. 修改自增长只能比当前已有的自增长的最大值大，不能小（小不生效），向上修改可以。
现在我们将尝试修改自增长值。首先尝试将其更改为较小的值（例如 2）：
ALTER TABLE employees AUTO_INCREMENT = 2;查看表结构：
SHOW CREATE TABLE employees;执行结果：
CREATE TABLE `employees` (
`emp_id` int NOT NULL AUTO_INCREMENT,
`emp_name` varchar(50) DEFAULT NULL,
`emp_age` int DEFAULT NULL,
PRIMARY KEY (`emp_id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci从执行结果中可以看到，尽管我们尝试将其更改为较小的值，但它仍然保持在当前最大值 +1（即 4）。
现在让我们尝试将其更改为较大的值（例如 10）：
ALTER TABLE employees AUTO_INCREMENT = 10;再次查看表结构：
SHOW CREATE TABLE employees;执行结果
CREATE TABLE `employees` (
`emp_id` int NOT NULL AUTO_INCREMENT,
`emp_name` varchar(50) DEFAULT NULL,
`emp_age` int DEFAULT NULL,
PRIMARY KEY (`emp_id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci自增长值已成功更改为 10。
我们插入一些数据：
INSERT INTO employees (emp_name, emp_age) VALUES ('Tony', 18);
INSERT INTO employees (emp_name, emp_age) VALUES ('Jerry', 20);现在查询表中的数据：
SELECT * FROM employees;+--------+-----------+---------+
| emp_id | emp_name | emp_age |
+--------+-----------+---------+
| 1 | Alice | 30 |
| 2 | Bob | 25 |
| 3 | Charlie | 35 |
| 10 | Tony | 18 |
| 11 | Jerry | 20 |
+--------+-----------+---------+可以看到，在修改自增长值为10之后，新插入的数据的emp_id从10开始自增。已有的数据保持不变。
2. 修改自增长步长
要修改自增长步长，需要更改 MySQL 服务器的 auto_increment_increment 系统变量。以下命令将步长更改为 5：
SET @@SESSION.auto_increment_increment = 5;插入一些新记录：
INSERT INTO employees (emp_name, emp_age) VALUES ('David', 28);
INSERT INTO employees (emp_name, emp_age) VALUES ('Emma', 32);查看表中的记录：
+--------+-----------+---------+
| emp_id | emp_name | emp_age |
+--------+-----------+---------+
| 1 | Alice | 30 |
| 2 | Bob | 25 |
| 3 | Charlie | 35 |
| 10 | David | 28 |
| 15 | Emma | 32 |
+--------+-----------+---------+我们将自增长步长设置为 5，因此新插入的记录的 `emp_id` 分别为 10 和 15。
在当前会话中执行 SET @@SESSION.auto_increment_increment = 5; 时，将更改当前会话中数据库的所有表的自增长步长为 5，而不只是单张表。这意味着，在这个会话里，所有具有自增长列的表的自增长值都将按照步长为 5 的方式递增。需要注意的是，这个设置仅影响当前会话，不会影响其他会话，也不会永久更改数据库的配置。在会话结束时，这些修改将不再生效，恢复为默认值或全局设置值。
我们这里只修改了会话级别的 `auto_increment_increment` 变量，这意味着该更改仅对当前会话有效。要永久更改自增长步长，需要在 MySQL 服务器的配置文件（例如 my.cnf 或 my.ini）中设置 `auto_increment_increment` 变量，或者通过管理员权限执行以下命令：
SET GLOBAL auto_increment_increment = 5;这样所有新会话都将使用新的自增长步长。
4.2.4 删除自增长
首先，查看当前表结构：
DESC employees;输出结果：
+----------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+----------------+
| emp_id | int | NO | PRI | NULL | auto_increment |
| emp_name | varchar(50) | YES | | NULL | |
| emp_age | int | YES | | NULL | |
+----------+--------------+------+-----+---------+----------------+ 接下来删除 emp_id 列的自增长属性：
ALTER TABLE employees MODIFY emp_id INT;再次查看表结构：
DESC employees;输出结果：
+----------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+-------+
| emp_id | int | NO | PRI | NULL | |
| emp_name | varchar(50) | YES | | NULL | |
| emp_age | int | YES | | NULL | |
+----------+--------------+------+-----+---------+-------+
emp_id 列的 Extra 属性已经从 auto_increment 变为空，表示自增长属性已被删除。
4.3 唯一键
一张表往往有很多字段需要具有唯一性,数据不能重复: 但是一张表中只能有一个主键: 唯一键(unique key)就可以解决表中有多个字段需要唯一性约束的问题.
唯一键的本质与主键差不多: 唯一键默认的允许自动为空,而且可以多个为空(空字段不参与唯一性比较)
4.3.1 增加唯一键
方式1: 在创建表的时候，字段之后直接跟 UNIQUE 或 UNIQUE KEY：
CREATE TABLE employees (
employee_id INT,
first_name VARCHAR(50) UNIQUE,
last_name VARCHAR(50),
age INT NOT NULL
);查看表结构可以看到 first_name 字段已经被设置为唯一键。
mysql> DESCRIBE employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | YES | | NULL | |
| first_name | varchar(50) | YES | UNI | NULL | |
| last_name | varchar(50) | YES | | NULL | |
| age | int | NO | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)方式2: 在所有的字段之后增加 UNIQUE KEY(字段列表) 来创建唯一键或复合唯一键
CREATE TABLE employees (
employee_id INT,
first_name VARCHAR(50),
last_name VARCHAR(50),
age INT NOT NULL,
UNIQUE KEY (first_name, last_name)
);查看表结构：
mysql> DESC employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | YES | | NULL | |
| first_name | varchar(50) | YES | MUL | NULL | |
| last_name | varchar(50) | YES | | NULL | |
| age | int | NO | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec) 这里可以看到 first_name 字段的 Key 列的值为 MUL，注意，last_name 字段的 Key 列并没有标记为 MUL，但是 first_name 和 last_name 实际上是组合成一个复合唯一键的。
MUL在查看表结构中表示字段有一个非唯一索引。这可能是一个二级索引，也可能是复合索引的一部分。
对于复合索引，MUL只出现在第一个字段，因为这是复合索引的起点。复合索引是在多个字段上的索引，如果查询只使用了复合索引的第一个字段，那么索引仍然可以被使用。但是如果查询没有使用复合索引的第一个字段，那么索引可能就不能被使用了(索引的最左前缀原则)。这就是为什么MUL只出现在复合索引的第一个字段。
然后我们可以使用 SHOW INDEX 命令来查看这个复合唯一键的详情：
mysql> SHOW INDEX FROM employees;
+------------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+------------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| employees | 0 | first_name | 1 | first_name | A | 0 | NULL | NULL | YES | BTREE | | |
| employees | 0 | first_name | 2 | last_name | A | 0 | NULL | NULL | YES | BTREE | | |
+------------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
2 rows in set (0.00 sec)
first_name 和 last_name 都在同一个索引（即，复合唯一键）中，序号 Seq_in_index 分别为 1 和 2，表示在复合索引中的顺序。
注意：如果为一个表的字段设置了一个唯一键，并且这个表没有明确设置的主键，那么MySQL会选择一个唯一且非空的列作为主键。
创建一个没有设定主键的表：
CREATE TABLE employees (
employee_id VARCHAR(50) NOT NULL,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
age INT NOT NULL
);给非空字段employee_id添加唯一键：
ALTER TABLE employees ADD UNIQUE (employee_id);查看表结构：
mysql> DESC employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | varchar(50) | NO | PRI | NULL | |
| first_name | varchar(50) | NO | | NULL | |
| last_name | varchar(50) | NO | | NULL | |
| age | int | NO | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec) 在这个结果中可以看到employee_id列的Key属性被设置为PRI，表示它现在是表的主键。这是因为在没有明确设置主键的情况下，MySQL选择了一个唯一且非空的列作为主键。
这不是一个好的例子，只是为了演示给大家看，在设计数据库表时，应该明确选择一个适合作为主键的字段。如果一个字段被自动选为主键，但它不符合作为主键的要求（例如，它可能会有重复的值或者可能需要更新，也可能需要自增长，而这里是varchar，不符合自增长的要求），那么可能会在后续的使用中遇到问题。
方式3: 在创建表之后增加唯一键
mysql> CREATE TABLE employees (
-> employee_id INT,
-> first_name VARCHAR(50),
-> last_name VARCHAR(50),
-> age INT NOT NULL
-> );
Query OK, 0 rows affected (0.02 sec)
mysql> ALTER TABLE employees ADD UNIQUE (first_name);
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0查看表结构
mysql> DESC employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | YES | | NULL | |
| first_name | varchar(50) | YES | UNI | NULL | |
| last_name | varchar(50) | YES | | NULL | |
| age | int | NO | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)可以看到 first_name 字段已经被设置为唯一键。
4.3.2 唯一键约束
唯一键的主要作用是防止表中的数据在唯一键列中重复，唯一键可以有多个。
唯一键与主键本质相同，区别就是唯一键默认允许为空，而且是多个为空，如果唯一键也不允许为空，则与主键的约束作用是一致的.
首先，我们创建一个有主键和两个唯一键的表：
CREATE TABLE employees (
id INT AUTO_INCREMENT PRIMARY KEY,
employee_id INT,
email VARCHAR(255),
first_name VARCHAR(255),
last_name VARCHAR(255),
UNIQUE KEY (employee_id),
UNIQUE KEY (email)
);查看这个表的结构：
mysql> DESC employees;
+-------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+--------------+------+-----+---------+----------------+
| id | int | NO | PRI | NULL | auto_increment |
| employee_id | int | YES | UNI | NULL | |
| email | varchar(255) | YES | UNI | NULL | |
| first_name | varchar(255) | YES | | NULL | |
| last_name | varchar(255) | YES | | NULL | |
+-------------+--------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)首先插入一条数据，然后再次尝试插入相同的employee_id
mysql> INSERT INTO employees (employee_id, email, first_name, last_name) VALUES (1, 'test1@example.com', 'John', 'Doe');
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO employees (employee_id, email, first_name, last_name) VALUES (1, 'aa@example.com', 'Jane', 'Smith');
ERROR 1062 (23000): Duplicate entry '1' for key 'employees.employee_id'
这时我们得到一个错误，因为被设置为唯一键不能插入重复的值。
现在尝试插入2条employee_id和email都为NULL的数据：
mysql> INSERT INTO employees (employee_id, email, first_name, last_name) VALUES (NULL, NULL, 'Alice', 'Johnson');
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO employees (employee_id, email, first_name, last_name) VALUES (NULL, NULL, 'Bob', 'Williams');
Query OK, 1 row affected (0.01 sec)
插入成功，在SQL中，NULL值被视为未知的。因此多个NULL值并不被视为相等。这意味着如果一个唯一键的字段是NULL，仍然可以插入另一个NULL值到那个字段。
4.3.3 更新唯一键 & 删除唯一键
如果想更改唯一键的字段，需要先删除原来的唯一键，然后添加新的唯一键。
删除唯一键有两种方式：
-
使用
ALTER TABLE 表名 DROP UNIQUE key_name;删除唯一键，其中key_name是要删除的唯一键的名称。 -
使用
ALTER TABLE 表名 DROP INDEX index_name;删除唯一键，其中index_name是要删除的唯一键的名称。
假设表结构如下：
CREATE TABLE employees (
employee_id INT,
first_name VARCHAR(50) UNIQUE,
last_name VARCHAR(50),
age INT NOT NULL
);查看表结构：
mysql> DESCRIBE employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | YES | | NULL | |
| first_name | varchar(50) | YES | UNI | NULL | |
| last_name | varchar(50) | YES | | NULL | |
| age | int | YES | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)删除唯一键，首先删除first_name字段的唯一键：
mysql> ALTER TABLE employees DROP INDEX first_name;
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0
更新唯一键，添加新的唯一键到last_name字段：
mysql> ALTER TABLE employees ADD UNIQUE (last_name);
Query OK, 0 rows affected (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> DESC employees;
+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| employee_id | int | YES | | NULL | |
| first_name | varchar(50) | YES | | NULL | |
| last_name | varchar(50) | YES | UNI | NULL | |
| age | int | YES | | NULL | |
+--------------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)可以看到现在 last_name 字段的 Key 列显示 UNI，唯一键由first_name变成了last_name
4.4 外键
外键是一种数据库表的约束，它用于确保数据的一致性。在关系数据库中，一个表中的字段可以是另一个表的主键。这种字段被称为“外键”。
4.4.1 增加外键
注意：一张表可以有多个外键，外键是加在子表上的。
方式1：创建表的时候增加外键，在所有的表字段之后，使用foreign key(外键字段) references 外部表(主键字段)
首先创建一个主表：
CREATE TABLE departments (
dept_id INT NOT NULL,
dept_name VARCHAR(50),
PRIMARY KEY (dept_id)
);然后在创建员工表的时候，定义dept_id作为外键，引用departments表的dept_id字段：
CREATE TABLE employees (
emp_id INT NOT NULL,
emp_name VARCHAR(50),
dept_id INT,
PRIMARY KEY (emp_id),
FOREIGN KEY (dept_id) REFERENCES departments(dept_id)
);如何查看外键呢？DESC命令是看不到的
可以查看建表语句可以看到创建外键的语句
SHOW CREATE TABLE employees;结果如下
CREATE TABLE `employees` (
`employee_id` int NOT NULL,
`first_name` varchar(50) NOT NULL,
`last_name` varchar(50) NOT NULL,
`age` int NOT NULL,
`dept_id` int,
PRIMARY KEY (`employee_id`),
KEY `dept_id` (`dept_id`),
CONSTRAINT `employees_ibfk_1` FOREIGN KEY (`dept_id`) REFERENCES `departments` (`dept_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
在输出中，有一个 CONSTRAINT 子句，定义了 dept_id 作为外键，参考了 departments 表的 dept_id 列
查看外键的另一种方法
SELECT
TABLE_NAME,
COLUMN_NAME,
CONSTRAINT_NAME,
REFERENCED_TABLE_NAME,
REFERENCED_COLUMN_NAME
FROM
INFORMATION_SCHEMA.KEY_COLUMN_USAGE
WHERE
TABLE_SCHEMA = 'your_database_name' AND
TABLE_NAME = 'employees';将'your_database_name'替换为你实际的数据库名称。这个查询会返回所有在employees表中定义的外键。结果如下：
+-------------+-------------+-----------------+-----------------------+------------------------+
| TABLE_NAME | COLUMN_NAME | CONSTRAINT_NAME | REFERENCED_TABLE_NAME | REFERENCED_COLUMN_NAME |
+-------------+-------------+-----------------+-----------------------+------------------------+
| employees | dept_id | employees_ibfk_1| departments | dept_id |
+-------------+-------------+-----------------+-----------------------+------------------------+请注意表述：我们通常会说 "dept_id 是 employees 表的外键" 或 "dept_id 是指向 departments 表的外键"。我们不会说 "departments 的 dept_id 是外键"，因为在 departments 表中，dept_id 是主键，而不是外键。
方式2：在新增表之后增加外键
Alter table 表名 add [constraint 外键名字] foreign key(外键字段) references 父表(主键字段)
对于新增表之后增加外键，确实需要注意数据一致性的问题。这是因为如果原表中已经存在的数据在参照表中没有对应的记录，那么这个外键就无法添加成功。
首先创建两个表，departments 和 employees：
mysql> CREATE TABLE departments (
dept_id INT NOT NULL,
dept_name VARCHAR(50),
PRIMARY KEY (dept_id)
);
Query OK, 0 rows affected (0.04 sec)
mysql> CREATE TABLE employees (
emp_id INT NOT NULL,
emp_name VARCHAR(50),
dept_id INT,
PRIMARY KEY (emp_id)
);
Query OK, 0 rows affected (0.06 sec)在 employees 表中插入一些记录，这些记录的 dept_id 在 departments 表中并不存在：
mysql> INSERT INTO employees VALUES (1, 'John Doe', 100);
Query OK, 1 row affected (0.01 sec)现在如果尝试添加一个外键约束，将会失败，因为 departments 表中并不存在 dept_id 为100的记录：
mysql> ALTER TABLE employees
ADD FOREIGN KEY (dept_id) REFERENCES departments(dept_id);
ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`test`.`#sql-1c_27`, CONSTRAINT `#sql-1c_27_ibfk_1` FOREIGN KEY (`dept_id`) REFERENCES `departments` (`dept_id`))所以在添加外键之前，需要保证数据的一致性。我们可以通过在 departments 表中插入一条 dept_id 为100的记录来实现这一点：
mysql> INSERT INTO departments VALUES (100, 'Sales');
Query OK, 1 row affected (0.01 sec)现在，我们尝试添加外键
mysql> ALTER TABLE employees
ADD FOREIGN KEY (dept_id) REFERENCES departments(dept_id);
Query OK, 0 rows affected (0.03 sec)
Records: 0 Duplicates: 0 Warnings: 0查看表结构
mysql> DESC departments;
+----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| dept_id | int | NO | PRI | NULL | |
| dept_name| varchar(50) | YES | | NULL | |
+----------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)
mysql> DESCRIBE employees;
+----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| emp_id | int | NO | PRI | NULL | |
| emp_name | varchar(50) | YES | | NULL | |
| dept_id | int | YES | MUL | NULL | |
+----------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)
为什么外键字段这里会有一个MUL？MUL表示它是一个非唯一索引，接着看
使用 SHOW INDEX 命令来查看 departments 和 employees 表的索引信息的例子：
mysql> SHOW INDEX FROM departments;
+-------------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+-------------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| departments | 0 | PRIMARY | 1 | dept_id | A | 0 | NULL | NULL | | BTREE | | |
+-------------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
1 row in set (0.00 sec)
mysql> SHOW INDEX FROM employees;
+-----------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+-----------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| employees | 0 | PRIMARY | 1 | emp_id | A | 0 | NULL | NULL | | BTREE | | |
| employees | 1 | dept_id | 1 | dept_id | A | 0 | NULL | NULL | YES | BTREE | | |
+-----------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
2 rows in set (0.00 sec) 从 employees 表的索引信息中，我们可以看到 dept_id 列有一个索引。这是因为MySQL自动为外键创建索引，以便更快地执行连接操作和其他查询。
在Key_name列中，你会看到索引的名称，Seq_in_index列显示的是索引中的列的顺序。Column_name列是索引的列名，而Non_unique列表示索引是否唯一，如果Non_unique的值为1，那么这就是一个非唯一索引。
4.4.2 修改外键&删除外键
外键不可直接修改，只能先删除后新增.
删除外键语法
Alter table 表名 drop foreign key 外键名; -- 一张表中可以有多个外键,但是名字不能相同
我们需要创建两个表，分别为departments和employees。departments表具有一个主键dept_id，employees表则有一个外键dept_id，这个外键引用departments表中的dept_id字段。
创建departments表：
CREATE TABLE departments (
dept_id INT NOT NULL,
dept_name VARCHAR(50),
PRIMARY KEY (dept_id)
);查看表结构
DESC departments;+-----------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| dept_id | int | NO | PRI | NULL | |
| dept_name | varchar(50) | YES | | NULL | |
+-----------+-------------+------+-----+---------+-------+创建employees表：
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
first_name VARCHAR(50),
last_name VARCHAR(50),
dept_id INT,
FOREIGN KEY (dept_id) REFERENCES departments(dept_id)
);查看employees表结构：
mysql> DESC employees;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| employee_id | int | NO | PRI | NULL | |
| first_name | varchar(50) | YES | | NULL | |
| last_name | varchar(50) | YES | | NULL | |
| dept_id | int | YES | MUL | NULL | |
+-------------+-------------+------+-----+---------+-------+使用 SHOW CREATE TABLE 命令来查看 employees 表的外键
mysql> SHOW CREATE TABLE employees;
+-----------+--------------------------------------------------------+
| Table | Create Table |
+-----------+--------------------------------------------------------+
| employees | CREATE TABLE `employees` ( |
| | `employee_id` int NOT NULL, |
| | `first_name` varchar(50) DEFAULT NULL, |
| | `last_name` varchar(50) DEFAULT NULL, |
| | `dept_id` int DEFAULT NULL, |
| | PRIMARY KEY (`employee_id`), |
| | KEY `dept_id` (`dept_id`), |
| | CONSTRAINT `employees_ibfk_1` FOREIGN KEY (`dept_id`)|
| | REFERENCES `departments` (`dept_id`) |
| | ) ENGINE=InnoDB DEFAULT CHARSET=utf8 |
+-----------+--------------------------------------------------------+
1 row in set (0.00 sec)
看到外键约束已经被创建 CONSTRAINT `employees_ibfk_1` FOREIGN KEY (`dept_id`) REFERENCES`departments` (`dept_id`)
删除外键
ALTER TABLE employees DROP FOREIGN KEY employees_ibfk_1;查看表结构
mysql> DESC employees;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| employee_id | int | NO | PRI | NULL | |
| first_name | varchar(50) | YES | | NULL | |
| last_name | varchar(50) | YES | | NULL | |
| dept_id | int | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+其实从这里已经可以看出employees表的dept_id字段已经不是外键了，如果是外键的话，那么会自动为这个字段添加非唯一索引，Key这一列一定是MUL。
单看Key的值为MUL并不能说明这个字段是这张表的外键，但是不为MUL那一定不是外键字段。
你可以在SHOW CREATE TABLE employees;的输出中查看建表语句来判断是否有外键
mysql> SHOW CREATE TABLE employees;
+-----------+-------------------------------------------------------------------+
| Table | Create Table |
+-----------+-------------------------------------------------------------------+
| employees | CREATE TABLE `employees` ( |
| | `employee_id` int NOT NULL, |
| | `first_name` varchar(50) NOT NULL, |
| | `last_name` varchar(50) NOT NULL, |
| | `dept_id` int(11) DEFAULT NULL, |
| | PRIMARY KEY (`employee_id`) |
| |) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci |
+-----------+-------------------------------------------------------------------+
1 row in set (0.00 sec)
这里删除外键就讲完了，修改外键就是先删除后新增，新增外键见上面说过的方式2。
4.4.3 外键作用
外键的主要作用就是维护两个表之间的数据一致性。这就意味着在涉及这两个表的数据操作时，数据库将对数据进行一些额外的检查以确保数据一致性。
首先我们创建两个表：departments 和 employees。在 employees 表中，dept_id 是一个外键，它引用了 departments 表的 department_id 列。
CREATE TABLE departments (
department_id INT PRIMARY KEY,
department_name VARCHAR(50)
);
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
dept_id INT,
FOREIGN KEY (dept_id) REFERENCES departments(department_id)
);1. 对子表约束的例子：
INSERT INTO departments(department_id, department_name) VALUES (1, 'Sales');
-- 这将成功，因为departments表中存在department_id为1的记录
INSERT INTO employees(employee_id, first_name, last_name, dept_id) VALUES (1, 'John', 'Doe', 1);
-- 这将失败，因为departments表中不存在department_id为999的记录
INSERT INTO employees(employee_id, first_name, last_name, dept_id) VALUES (2, 'Jane', 'Doe', 999);当我们试图向employees表插入一行数据，其中dept_id在departments表中找不到对应的department_id时，操作会失败。
2. 对父表约束的例子：
-- 这将成功，因为employees表中没有任何记录的dept_id引用了department_id为2的记录
DELETE FROM departments WHERE department_id = 2;
-- 这将失败，因为employees表中有一行记录的dept_id引用了department_id为1的记录
DELETE FROM departments WHERE department_id = 1;
当我们试图删除departments表中的一行数据，如果该行数据的department_id在employees表中被引用，那么操作会失败。
正确删除有外键约束记录的方法：
可以先手动删除或修改引用该父表记录的所有子表记录，然后再删除父表记录。
-- 假设要删除的departments表记录的department_id为1
DELETE FROM employees WHERE dept_id = 1;
DELETE FROM departments WHERE department_id = 1;我们上面讲解的默认都是严格模式，在严格模式下，插入数据需要先从父表中开始，删除数据要先从子表开始，否则会报错。
我们后面会讲到，在置空(SET NULL)模式下，比如你的外键约束设置了ON DELETE SET NULL，那么你也可以直接删除父表中的记录，子表中的相关记录的外键字段会自动被设置为 NULL。
在级联(CASCADE)模式下，比如你的外键约束设置了ON DELETE CASCADE，那么你就可以直接删除父表中的记录，而无需先删除子表中的相关记录，因为子表中的相关记录会自动被删除。
4.4.4 外键条件
1.外键要存在，首先必须保证表的存储引擎是InnoDB：确实，只有InnoDB和其他一些支持事务的存储引擎才支持外键。MyISAM等其他一些不支持事务的存储引擎虽然可以创建含有外键的表，但是外键不会有任何效果。以下是一个例子：
CREATE TABLE myisam_table (
id INT PRIMARY KEY,
foreign_id INT,
FOREIGN KEY (foreign_id) REFERENCES other_table(id)
) ENGINE=MyISAM; 在这个例子中，虽然myisam_table表的定义包含了一个外键，但是因为表的存储引擎是MyISAM，所以这个外键不会有任何效果。
2.外键字段的字段类型必须与父表的主键类型完全一致：这是正确的，否则在定义外键时会出错。以下是一个例子：
CREATE TABLE parent_table (
id INT PRIMARY KEY
) ENGINE=InnoDB;
CREATE TABLE child_table (
id INT PRIMARY KEY,
foreign_id VARCHAR(10), -- 这里的类型和parent_table的id类型不一致
FOREIGN KEY (foreign_id) REFERENCES parent_table(id)
) ENGINE=InnoDB;在这个例子中，尝试将child_table的foreign_id字段（其类型为VARCHAR(10)）定义为一个引用parent_table的id字段（其类型为INT）的外键，这会出错，因为这两个字段的类型不一致。
3.一张表中的外键名字不能重复：这是正确的，否则在定义外键时会出错。以下是一个例子：
CREATE TABLE child_table (
id INT PRIMARY KEY,
foreign_id1 INT,
foreign_id2 INT,
FOREIGN KEY fk_name (foreign_id1) REFERENCES parent_table(id),
FOREIGN KEY fk_name (foreign_id2) REFERENCES another_table(id)
) ENGINE=InnoDB;
在这个例子中，尝试将child_table的foreign_id1和foreign_id2字段都定义为名为fk_name的外键，这会出错，因为这两个外键的名字相同。
4.增加外键的字段（数据已经存在），必须保证数据与父表主键要求对应：这是正确的，否则在定义外键时会出错。以下是一个例子：
CREATE TABLE parent_table (
id INT PRIMARY KEY
) ENGINE=InnoDB;
INSERT INTO parent_table (id) VALUES (1), (2), (3);
CREATE TABLE child_table (
id INT PRIMARY KEY,
foreign_id INT
) ENGINE=InnoDB;
INSERT INTO child_table (id, foreign_id) VALUES (1, 4); -- 这里的foreign_id值在parent_table表的id字段中找不到
ALTER TABLE child_table ADD FOREIGN KEY (foreign_id) REFERENCES parent_table(id);
在这个例子中，尝试将child_table的foreign_id字段定义为一个引用parent_table的id字段的外键，这会出错，因为child_table表中已经有一条记录的foreign_id字段的值在parent_table表的id字段中找不到。
如果父表有值而子表对应的外键列没有值（或者值为NULL），那么是可以成功添加外键的。在SQL中，NULL通常被认为是“未知”的或“不适用”的值。对于外键来说，如果子表的外键字段的值是NULL，那么这并不违反外键的约束。这是因为外键约束的作用是确保子表的外键字段的值必须在父表的主键字段中存在。如果子表的外键字段的值是NULL，那么这个值并不需要在父表的主键字段中存在，因为NULL并不代表任何实际的值。
这里不得不考虑到varchar类型default '' 的情况
假设父表（departments）和子表（employees）中的dept_name列都是VARCHAR类型，且子表的dept_name列被设为NOT NULL DEFAULT ''。在这种情况下，你不能将子表的dept_name列设置为外键，除非父表的dept_name列中有一个空字符串。如果没有，那么将会抛出一个错误，因为子表中的默认值（空字符串）在父表中找不到。
# 创建父表
CREATE TABLE departments (
dept_name VARCHAR(50) NOT NULL PRIMARY KEY
);
# 插入一条记录
INSERT INTO departments(dept_name) VALUES('HR');
# 创建子表，尝试设置外键
CREATE TABLE employees (
emp_id INT NOT NULL,
dept_name VARCHAR(50) NOT NULL DEFAULT '' REFERENCES departments(dept_name)
);
在运行上述CREATE TABLE employees语句时，将会看到一个错误，因为子表的默认值（空字符串）在父表中不存在。
如果希望这种情况下能成功添加外键，那么可以在父表的dept_name列中添加一个空字符串。或者可以将子表的DEFAULT ''更改为一个在父表的dept_name列中存在的值。
4.4.5 外键约束
MySQL字段约束有四种，主键约束，非空约束，唯一约束，外键约束。需要注意的是：外键约束是唯一不推荐的约束，开发中很少用
外键约束有三种约束模式: 都是针对父表的约束(子表约束父表)
级联模式（CASCADE）: 父表的删除或更新操作之后，对应子表关联的数据也跟着被删除或更新
置空模式（SET NULL）: 父表的删除或更新操作之后，子表对应的数据(外键字段)被置空
严格模式（NO ACTION 或 RESTRICT 或 不写）：父表不能删除或者更新一个已经被子表数据引用的记录
1.级联模式（CASCADE）
在级联模式下，如果父表的一条记录被删除或更新，那么所有与之相关联的子表记录也将被删除或更新。
现在我们创建两个表，一个父表 Parents，一个子表 Children，在子表上创建外键并设置删除和更新模式为级联模式（CASCADE）：
CREATE TABLE Parents (
id INT PRIMARY KEY,
name VARCHAR(20)
);
CREATE TABLE Children (
id INT PRIMARY KEY,
parent_id INT,
name VARCHAR(20),
FOREIGN KEY (parent_id) REFERENCES Parents(id) ON DELETE CASCADE ON UPDATE CASCADE
);
插入一些数据：
INSERT INTO Parents VALUES (1, 'Parent1');
INSERT INTO Children VALUES (1, 1, 'Child1');
我们已经在父表 Parents 和子表 Children 中插入了数据，现在我们分别查询一下这些数据：
SELECT * FROM Parents;
+----+--------+
| id | name |
+----+--------+
| 1 | Parent1|
+----+--------+
SELECT * FROM Children;
+----+-----------+--------+
| id | parent_id | name |
+----+-----------+--------+
| 1 | 1 | Child1 |
+----+-----------+--------+
接下来，我们删除父表 Parents 中的一条记录：
DELETE FROM Parents WHERE id = 1;
再次查询数据，会看到父表 Parents 和子表 Children 中的相关记录都被删除了，这就是级联模式的效果：
SELECT * FROM Parents;
SELECT * FROM Children;
Parents:
Empty set
Children:
Empty set
2.置空模式（SET NULL）
在置空模式下，如果父表的一条记录被删除或更新，那么所有与之相关联的子表记录的外键字段会被置为NULL。
首先我们创建一个新的父表 Teachers 和子表 Students，并在子表上创建外键，设置删除模式为置空模式（SET NULL）：
CREATE TABLE Teachers (
id INT PRIMARY KEY,
name VARCHAR(20)
);
CREATE TABLE Students (
id INT PRIMARY KEY,
teacher_id INT,
name VARCHAR(20),
FOREIGN KEY (teacher_id) REFERENCES Teachers(id) ON DELETE SET NULL
);
插入一些数据：
INSERT INTO Teachers VALUES (1, 'Teacher1');
INSERT INTO Students VALUES (1, 1, 'Student1');
现在我们查询一下这些数据：
SELECT * FROM Teachers;
+----+---------+
| id | name |
+----+---------+
| 1 | Teacher1|
+----+---------+
SELECT * FROM Students;
+----+------------+---------+
| id | teacher_id | name |
+----+------------+---------+
| 1 | 1 | Student1|
+----+------------+---------+我们删除父表 Teachers 中的一条记录：
DELETE FROM Teachers WHERE id = 1;
再次查询数据：
SELECT * FROM Teachers;
Empty set
SELECT * FROM Students;
+----+------------+---------+
| id | teacher_id | name |
+----+------------+---------+
| 1 | NULL | Student1|
+----+------------+---------+
子表 Students 中与被删除的父表记录相关联的记录的外键字段 teacher_id 被置为NULL，这就是置空模式的效果。
3.严格模式（NO ACTION 或者 RESTRICT）
在严格模式下，如果父表的一条记录被删除或更新，只要有子表的记录与之相关联，就会阻止这次删除或更新操作。
我们创建一个新的父表 Books 和子表 Orders，并在子表上创建外键，设置删除模式为严格模式。
注意：在MySQL中，ON DELETE NO ACTION、ON DELETE RESTRICT和完全不写的情况下，都将采用严格模式，我们在前面所讲的添加外键约束的方式默认都是严格模式
CREATE TABLE Books (
id INT PRIMARY KEY,
name VARCHAR(20)
);
-- 方式1
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id INT,
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id) ON DELETE NO ACTION
);
-- 方式2
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id INT,
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id) ON DELETE RESTRICT
);
-- 方式3
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id INT,
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id)
);
插入一些数据：
INSERT INTO Books VALUES (1, 'Book1');
INSERT INTO Orders VALUES (1, 1, 'Customer1');
现在我们查询一下这些数据：
SELECT * FROM Books;
+----+-------+
| id | name |
+----+-------+
| 1 | Book1 |
+----+-------+
SELECT * FROM Orders;
+----+--------+---------------+
| id | book_id| customer_name |
+----+--------+---------------+
| 1 | 1 | Customer1 |
+----+--------+---------------+
我们尝试删除父表 Books 中的一条记录：
DELETE FROM Books WHERE id = 1;
这个删除操作会被阻止，并返回一个错误信息，因为子表 Orders 中还有记录的 book_id 是1，这就是严格模式的效果。这种情况想要删除必须先删子表里面的记录。
总结：
-
当你尝试删除父表中的一条记录时，根据约束，会有以下影响：如果设置了
ON DELETE SET NULL，则子表中对应的外键字段将被置为NULL。如果设置了ON DELETE CASCADE，则子表中对应的记录将被删除。 -
当你尝试更新父表中的一条记录的主键时，根据约束，会有以下影响：如果设置了
ON UPDATE CASCADE，那么子表中对应的外键字段将被更新为新的值。如果设置了ON UPDATE SET NULL，那么子表中对应的外键字段将被置为NULL。
注意：如果你删除或更新子表的记录，父表中的记录不会受到影响。这种约束是父表（主表）中的记录影响子表（引用或依赖表）中的记录，别搞反了。
如果你希望在删除或更新子表的记录时父表的记录也随之改变，你可能需要编写触发器（trigger）来实现这个逻辑
触发器（trigger）是数据库中的一种对象，它与表关联，并在特定的数据库操作（如 INSERT、UPDATE 或 DELETE）执行时自动执行。使用触发器可以帮助我们在执行某个操作前后自动执行一些额外的任务，从而满足一些复杂的业务需求。
例如，你希望当子表的某个记录被删除时，父表中对应的记录也被删除，可以通过以下的触发器来实现：
CREATE TRIGGER after_orders_delete AFTER DELETE ON Orders FOR EACH ROW BEGIN DELETE FROM Books WHERE id = OLD.book_id; END;在这个例子中，我们创建了一个名为 after_orders_delete 的触发器。这个触发器会在 Orders 表（子表）中的记录被删除后自动执行。触发器的内容是删除 Books （父表）表中的记录，删除的条件是 Books 表的 id 字段值等于被删除的 Orders 表记录的 book_id 字段值。OLD 关键字用来引用被删除的记录。
需要注意的是，触发器会改变数据库的行为，可能会对性能和数据完整性产生影响。在使用触发器时，一定要充分考虑其可能带来的后果，并在应用上线前进行充分的测试。
来测试一下灵活运用
我们前面说了，置空就加SET NULL，级联就加CASCADE，那我们来看看如果外键约束后面加上ON DELETE SET NULL ON UPDATE CASCADE：
让我们创建一个具体的例子来说明这个约束的效果。首先创建父表 Persons 和子表 Orders：
CREATE TABLE Persons (
id INT PRIMARY KEY,
name VARCHAR(20)
);
CREATE TABLE Orders (
id INT PRIMARY KEY,
person_id INT,
product VARCHAR(20),
FOREIGN KEY (person_id) REFERENCES Persons(id) ON DELETE SET NULL ON UPDATE CASCADE
);
插入一些数据：
INSERT INTO Persons VALUES (1, 'Person1');
INSERT INTO Orders VALUES (1, 1, 'Product1');
查询插入的数据：
SELECT * FROM Persons;
+----+--------+
| id | name |
+----+--------+
| 1 | Person1|
+----+--------+
SELECT * FROM Orders;
+----+-----------+---------+
| id | person_id | product |
+----+-----------+---------+
| 1 | 1 | Product1|
+----+-----------+---------+
然后，我们再插入一条父表的记录，然后更新它的主键：
INSERT INTO Persons VALUES (2, 'Person2');
UPDATE Persons SET id = 3 WHERE id = 2;
由于没有子表的记录引用这条父表的记录，所以子表的数据不会有变化。但是如果在更新父表的记录之前有子表的记录引用它，那么这些子表的记录的外键将被更新为新的值，这就是 ON UPDATE CASCADE 的效果。
4.4.6 创建外键约束的要求
创建外键约束要求有以下几点：
1.父表和子表必须使用相同的存储引擎，且不能使用临时表。
首先，让我们创建两个使用不同存储引擎的表，尝试在其中建立外键约束。Books表使用InnoDB引擎，而Orders表试图使用MyISAM引擎：
CREATE TABLE Books (
id INT PRIMARY KEY,
title VARCHAR(100)
) ENGINE=InnoDB;
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id INT,
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id)
) ENGINE=MyISAM;
运行上述SQL语句，你会发现第二条CREATE TABLE语句失败，因为MyISAM不支持外键，InnoDB是唯一支持外键的MySQL存储引擎。
MySQL的临时表不支持外键约束，所以你不能在临时表中创建外键。例如尝试在临时表中创建外键的SQL语句：
CREATE TABLE Books (
id INT PRIMARY KEY,
title VARCHAR(100)
) ENGINE=InnoDB;
CREATE TEMPORARY TABLE Orders (
id INT PRIMARY KEY,
book_id INT,
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id)
) ENGINE=InnoDB;
在尝试执行上述代码时，你将收到一个错误，因为临时表Orders不能包含到Books表的外键约束。临时表是会话特定的，当会话结束时，它们会自动消失，而外键约束需要持久性和一致性，这就是为什么临时表不支持外键约束的原因。
2.外键列和参照列必须具有相似的数据类型。其中数字的长度或是否有符号位必须相同；而字符的长度则可以不同。
类型不匹配的情况：
假设我们有一个表Books，其中的id列为INT类型，然后我们试图在Orders表中创建一个VARCHAR类型的外键book_id。
CREATE TABLE Books (
id INT PRIMARY KEY,
title VARCHAR(100)
) ENGINE=InnoDB;
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id VARCHAR(20),
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id)
) ENGINE=InnoDB;
第二条CREATE TABLE语句将失败，因为外键列book_id（VARCHAR类型）和参照列id（INT类型）类型不匹配。
数字长度和符号位：
考虑两个表，Books表中的id字段是有符号的INT(11)，而Orders表中的book_id字段是无符号的INT(11)。
CREATE TABLE Books (
id INT(11) PRIMARY KEY,
title VARCHAR(100)
) ENGINE=InnoDB;
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id INT(11) UNSIGNED,
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id)
) ENGINE=InnoDB;
这将导致创建Orders表的语句失败，因为外键book_id（无符号）和参照列id（有符号）的符号位不同。
字符长度：
对于字符类型的列，外键列和参照列的长度可以不同。例如：
CREATE TABLE Books (
id VARCHAR(100) PRIMARY KEY,
title VARCHAR(100)
) ENGINE=InnoDB;
CREATE TABLE Orders (
id INT PRIMARY KEY,
book_id VARCHAR(20),
customer_name VARCHAR(20),
FOREIGN KEY (book_id) REFERENCES Books(id)
) ENGINE=InnoDB;
这个例子中，虽然外键book_id的长度（20）小于参照列id的长度（100），但CREATE TABLE语句仍然成功，因为字符类型的长度可以不同。
3.如果外键列不存在索引的话，MySQL将自动创建索引。如果参照列不存在索引的话，MySQL不会自动创建索引。
为了验证这一点，可以在创建表和插入一些数据后，运行SHOW INDEX FROM Orders;会看到MySQL自动为book_id列创建了一个索引，之前也讲过。
4.4.7 外键约束的闭环问题
比如说我们创建了2张表
/*先创建父表*/
CREATE TABLE t_dept(
deptno INT UNSIGNED PRIMARY KEY,
dname VARCHAR(20) NOT NULL UNIQUE,
tel CHAR(4) UNIQUE
)
/*再创建子表*/
CREATE TABLE t_emp(
empno INT UNSIGNED PRIMARY KEY,
ename VARCHAR(20) NOT NULL,
sex ENUM("男", "女") NOT NULL,
deptno INT UNSIGNED NOT NULL,
hiredate DATE NOT NULL,
FOREIGN KEY (deptno) REFERENCES t_dept(deptno)
);父表t_dept加一个数据如下：
子表t_emp加一个数据如下：
此时我想删除父表的数据，结果报错
结果发现有子表t_emp外键约束着父表，删除失败。必须先删除子表的约束数据才能删除父表的数据，那这样就失去了增减改查的灵活性了，并且更严重的是，
如果形成外键闭环，我们将无法删除任何一张表的数据记录。
如上图，父表约束子表，A约束B，B约束C......，这样每一个表都算作父表，所谓的先删除子表的数据就是不可能的。因为有外键闭环的存在，所以我们不推荐外键约束
4.5 索引
几乎所有的索引都是建立在字段之上.
索引: 系统根据某种算法, 将已有的数据(未来可能新增的数据),单独建立一个文件: 文件能够实现快速的匹配数据, 并且能够快速的找到对应表中的记录.
4.5.1 创建索引
建表的时候创建索引，也可以在已存在的表上添加索引。
CREATE TABLE 表名称(
......,
INDEX [索引名称] (字段),
......
);
CREATE TABLE t_message(
id INT UNSIGNED PRIMARY KEY,
content VARCHAR(200) NOT NULL,
type ENUM("公告", "通报", "个人通知") NOT NULL,
create_time TIMESTAMP NOT NULL,
INDEX idx_type (type)
);4.5.2 添加索引
向已存在的表中添加索引的方式如下
普通索引：
CREATE INDEX 索引名称 ON 表名(字段); /*添加索引方式1*/
ALTER TABLE 表名 ADD INDEX 索引名称(字段); /*添加索引方式2*/
唯一索引：
CREATE UNIQUE INDEX 索引名称 ON 表名(字段)
联合索引：
CREATE INDEX 索引名称 ON 表名(字段1，字段2...)
-- 普通索引：
CREATE INDEX idx_type ON t_message(type); /*添加索引方式1*/
ALTER TABLE t_message ADD INDEX idx_type(type);/*添加索引方式2*/
-- 唯一索引：
CREATE UNIQUE INDEX uidx_type ON t_message(type);
-- 联合索引
CREATE INDEX idx_type1_type2 ON t_message(type1, type2);经常被用来做检索条件的字段需要加上索引，原理是B+树，所以查询很快。如果是几千条数据，不必加索引，全表扫描也很快
前面提到过，新增列的时候，也可以同时新增索引，比如
ALTER TABLE student
ADD address VARCHAR(200) NOT NULL,
ADD home_tel CHAR(11) NOT NULL AFTER address,
ADD INDEX idx_student_address (address),
ADD INDEX idx_student_phone (phone);练习题：
已有新闻表(tb_news)，表中有type字段，下列选中项中能为该字段添加索引的是？
这个就是记忆题目，记住语法即可，答案是AC
4.5.3 查询索引
SHOW INDEX FROM 表名;
/*查看t_message表的索引*/
SHOW INDEX FROM t_message;查出来如下，有添加的普通索引和主键索引
4.5.4 删除索引
DROP INDEX 索引名称 ON 表名;
/* 在t_message表中删除idx_type索引 */
DROP INDEX idx_type ON t_message;4.5.5 索引的使用原则
1. 选择性高的列：对于具有大量唯一值或不重复值的列，索引能够极大地提高查询性能。这种情况下，索引可以帮助数据库快速定位所需数据
2. 经常用作过滤条件的列：对于经常用于 WHERE 子句、JOIN 条件或其他过滤条件的列，建立索引可以提高查询速度。
3. 排序和分组：如果某列经常用于 ORDER BY、GROUP BY 或其他排序和分组操作，为该列创建索引可以提高这些操作的性能。
4. 外键列：如果表之间有外键关系，在外键列上创建索引可以提高连接查询的性能。
5. 覆盖索引：尽量创建包含查询所需所有列的索引，这样查询可以直接在索引中获得所需数据，无需回表查询。这称为“覆盖索引”。
6. 索引维护成本：索引不仅会占用存储空间，还会在插入、更新和删除操作时产生额外的维护成本。因此，在创建索引时要权衡查询性能和维护成本。
7. 避免冗余索引：尽量避免创建重复或相似的索引。冗余索引不仅浪费存储空间，还会增加维护成本。可以定期审查索引并删除不必要的索引。
8. 低选择性列：对于具有较低选择性的列（即重复值较多的列），索引的效果可能不明显。在这种情况下，可以考虑使用其他查询优化方法。
9. 分析查询计划：分析查询计划，以确保数据库实际使用了预期的索引。如果没有使用预期索引，可以调整查询语句或调整索引策略。
10. 适时更新统计信息：统计信息对于数据库优化器选择正确索引至关重要。定期更新统计信息以确保数据库优化器作出正确的索引选择。
4.5.6 索引的意义
主要意义如下：
1. 提高查询速度：通过使用索引，数据库可以快速定位到需要的数据，而无需扫描整个表。这可以大大减少数据查询所需的时间和系统资源。
2. 优化排序和分组：索引可以帮助数据库在执行排序（ORDER BY）和分组（GROUP BY）操作时更高效地处理数据。
3. 加速连接操作：在具有外键关系的表之间进行连接查询时，索引可以显著提高查询性能。
4. 维护数据一致性：使用唯一索引可以确保表中的某列或某些列的唯一性，从而维护数据的完整性和一致性。
5. 改善查询计划：数据库查询优化器依赖于索引和统计信息来生成高效的查询计划。正确使用索引可以帮助查询优化器生成更好的查询计划，从而提高查询性能。
4.5.7 MySQL索引原理图解、B+树应用场景大全、索引优化、索引成本计算等
我这里会比你所有看到的一些原理文章讲的都细致，更深入，所以我另外开篇来讲。
比如：
图文并茂说MySQL索引——入门进阶必备https://blog.csdn.net/qq_34115899/article/details/118004118
https://blog.csdn.net/qq_34115899/article/details/118004118
MySQL中B+树索引的应用场景大全https://blog.csdn.net/qq_34115899/article/details/118308424https://blog.csdn.net/qq_34115899/article/details/118308424
更多文章请见专栏https://blog.csdn.net/qq_34115899/category_7832712.html
第5章 关系
将实体与实体的关系, 反应到最终数据库表的设计上来: 将关系分成三种: 一对一, 一对多(多对一)和多对多.
所有的关系都是指的表与表之间的关系.
5.1 一对一
一对一: 一张表的一条记录一定只能与另外一张表的一条记录进行对应; 反之亦然.
学生表: 姓名,性别,年龄,身高,体重,婚姻状况, 籍贯, 家庭住址,紧急联系人
| Id(P) | 姓名 | 性别 | 年龄 | 体重 | 身高 | 婚姻 | 籍贯 | 住址 | 联系人 |
表设计成以上这种形式: 符合要求. 其中姓名,性别,年龄,身高,体重属于常用数据; 但是婚姻,籍贯,住址和联系人属于不常用数据. 如果每次查询都是查询所有数据,不常用的数据就会影响效率, 实际又不用.
解决方案: 将常用的和不常用的信息分离存储,分成两张表
常用信息表
| Id(P) | 姓名 | 性别 | 年龄 | 体重 | 身高 |
| 1 | |||||
不常用信息表: 保证不常用信息与常用信息一定能够对应上: 找一个具有唯一性(确定记录)的字段来共同连接两张表
| Id(P) | 婚姻 | 籍贯 | 住址 | 联系人 |
| 2 | ||||
| 1 |
一个常用表中的一条记录: 永远只能在一张不常用表中匹配一条记录;反过来,一个不常用表中的一条记录在常用表中也只能匹配一条记录: 一对一的关系
5.2 一对多
一对多: 一张表中有一条记录可以对应另外一张表中的多条记录; 但是返回过, 另外一张表的一条记录只能对应第一张表的一条记录. 这种关系就是一对多或者多对一.
母亲与孩子的关系: 母亲,孩子两个实体
妈妈表
| ID(P) | 名字 | 年龄 | 性别 |
孩子表
| ID(P) | 名字 | 年龄 | 性别 |
以上关系: 一个妈妈可以在孩子表中找到多条记录(也有可能是一条); 但是一个孩子只能找到一个妈妈: 是一种典型的一对多的关系.
但是以上设计: 解决了实体的设计表问题, 但是没有解决关系问题: 孩子找不出妈,妈也找不到孩子.
解决方案: 在某一张表中增加一个字段,能够找到另外一张表的中记录: 应该在孩子表中增加一个字段指向妈妈表: 因为孩子表的记录只能匹配到一条妈妈表的记录.
妈妈表
| ID(P) | 名字 | 年龄 | 性别 |
孩子表
| ID(P) | 名字 | 年龄 | 性别 | 妈妈ID |
| 妈妈表主键 | ||||
5.3多对多
多对多: 一张表中(A)的一条记录能够对应另外一张表(B)中的多条记录; 同时B表中的一条记录也能对应A表中的多条记录: 多对多的关系
老师教学: 老师和学生
老师表
| T_ID(P) | 姓名 | 性别 |
| 1 | A | 男 |
| 2 | B | 女 |
学生表
| S_ID(P) | 姓名 | 性别 |
| 1 | 张三 | 男 |
| 2 | 小芳 | 女 |
以上设计方案: 实现了实体的设计, 但是没有维护实体的关系.
一个老师教过多个学生; 一个学生也被多个老师教过.
解决方案: 在学生表中增加老师字段: 不管在哪张表中增加字段, 都会出现一个问题: 该字段要保存多个数据, 而且是与其他表有关系的字段, 不符合表设计规范: 增加一张新表: 专门维护两张表之间的关系
老师表
| T_ID(P) | 姓名 | 性别 |
| 1 | A | 男 |
| 2 | B | 女 |
学生表
| S_ID(P) | 姓名 | 性别 |
| 1 | 张三 | 男 |
| 2 | 小芳 | 女 |
中间关系表: 老师与学生的关系
| ID | T_ID(老师) | S_ID(学生) |
| 1 | 1 | 1 |
| 2 | 1 | 2 |
| 3 | 2 | 1 |
| 4 |
增加中间表之后: 中间表与老师表形成了一对多的关系: 而且中间表是多表,维护了能够唯一找到一表的关系; 同样的,学生表与中间表也是一个一对多的关系: 一对多的关系可以匹配到关联表之间的数据.
学生找老师: 找出学生id -> 中间表寻找匹配记录(多条) -> 老师表匹配(一条)
老师找学生: 找出老师id -> 中间表寻找匹配记录(多条) -> 学生表匹配(一条)
第6章 范式
范式: Normal Format, 是一种离散数学中的知识, 是为了解决一种数据的存储与优化的问题: 保存数据的存储之后, 凡是能够通过关系寻找出来的数据,坚决不再重复存储: 终极目标是为了减少数据的冗余.
范式: 是一种分层结构的规范, 分为六层: 每一次层都比上一层更加严格: 若要满足下一层范式,前提是满足上一层范式.
六层范式: 1NF,2NF,3NF...6NF, 1NF是最底层,要求最低;6NF最高层,最严格.
Mysql属于关系型数据库: 有空间浪费: 也是致力于节省存储空间: 与范式所有解决的问题不谋而合: 在设计数据库的时候, 会利用到范式来指导设计.
但是数据库不单是要解决空间问题,要保证效率问题: 范式只为解决空间问题, 所以数据库的设计又不可能完全按照范式的要求实现: 一般情况下,只有前三种范式需要满足.
范式在数据库的设计当中是有指导意义: 但是不是强制规范.
6.1 1NF
第一范式: 在设计表存储数据的时候, 如果表中设计的字段存储的数据,在取出来使用之前还需要额外的处理(拆分),那么说表的设计不满足第一范式。
第一范式要求字段的数据具有原子性: 不可再分.
第一范式是数据库的基本要求，不满足第一范式就不是关系型数据库
让我们简单化这个问题：
1NF---原子性
eg1：
数据表的每一列都是不可分割的基本数据项，同一列中不能有多个值，也不能存在重复的属性。
eg2：
讲师代课表
| 讲师 | 性别 | 班级 | 教室 | 代课时间 | 代课时间（开始，结束） |
| 朱元璋 | Male | php0226 | D302 | 30天 | 2014-02-27,2014-05-05 |
| 朱元璋 | Male | php0320 | B206 | 30天 | 2014-03-21,2014-05-30 |
| 李世民 | Male | php0320 | B206 | 15天 | 2014-06-01,2014-06-20 |
上表设计不存在问题: 但是如果需求是将数据查出来之后,要求显示一个老师从什么时候开始上课,到什么时候节课: 需要将代课时间进行拆分: 不符合1NF, 数据不具有原子性, 可以再拆分.
解决方案: 将代课时间拆分成两个字段就解决问题.
6.2 2NF
第二范式: 在数据表设计的过程中,如果有复合主键(多字段主键), 且表中有字段并不是由整个主键来确定, 而是依赖主键中的某个字段(主键的部分): 存在字段依赖主键的部分的问题, 称之为部分依赖: 第二范式就是要解决表设计不允许出现部分依赖.
定义太绕了，简单点:
2NF---唯一性
数据表中的每条记录必须是唯一的。为了实现区分，通常要为表加上一个列来存储唯一标识，这个唯一属性列被称作主键列
eg1：
学号为230的学生在2018-07-15考试第一次58没及格，然后当天补考第二次还是58没及格，于是数据库就有了重复的数据。解决办法就是添加一个流水号，让数据变得唯一。
eg2：
讲师带课表
以上表中: 因为讲师没有办法作为独立主键, 需要结合班级才能作为主键(复合主键: 一个老师在一个班永远只带一个阶段的课): 代课时间,开始和结束字段都与当前的代课主键(讲师和班级): 但是性别并不依赖班级, 教室不依赖讲师: 性别只依赖讲师, 教室只依赖班级: 出现了性别和教室依赖主键中的一部分: 部分依赖.不符合第二范式.
解决方案1: 可以将性别与讲师单独成表, 班级与教室也单独成表.
解决方案2: 取消复合主键, 使用逻辑主键
ID = 讲师 + 班级(业务逻辑约束: 复合唯一键)
6.3 3NF
要满足第三范式,必须满足第二范式
第三范式: 理论上讲,应该一张表中的所有字段都应该直接依赖主键(逻辑主键: 代表的是业务主键), 如果表设计中存在一个字段, 并不直接依赖主键,而是通过某个非主键字段依赖,最终实现依赖主键: 把这种不是直接依赖主键,而是依赖非主键字段的依赖关系称之为传递依赖. 第三范式就是要解决传递依赖的问题.
定义很绕，我们简单点：
3NF---关联性
每列都与主键有直接关系，不存在传递依赖
eg1：
根据主键爸爸能关联儿子女儿，但是女儿的玩具、衣服都不是依赖爸爸的，而是依赖女儿的，这些东西不是与爸爸有直接关系，所以拆分两个表。
儿子女儿依赖于爸爸，女儿的玩具、衣服依赖于女儿。
满足第三范式后，检索、提取数据非常方便，如果不满足，虽然表也能建成功，但是检索就会花费很多时间，比如如果是第一个表，逻辑上要找女儿的衣服，去查找女儿是找不到的，此时女儿不是主键。数据表拆分之后，根据主键列女儿陈婷婷，可以很快的找到女儿的衣服校服。主键查找是很快的。
依照第三范式，数据可以拆分到不同的数据表，彼此保持关联
eg2：
讲师带课表
以上设计方案中: 性别依赖讲师存在, 讲师依赖主键; 教室依赖班级,班级依赖主键: 性别和教室都存在传递依赖.
解决方案: 将存在传递依赖的字段,以及依赖的字段本身单独取出,形成一个单独的表, 然后在需要对应的信息的时候, 使用对应的实体表的主键加进来.
讲师代课表
讲师表 班级表
讲师表: ID = 讲师 班级表中: ID = 班级
6.4 逆规范化
有时候, 在设计表的时候,如果一张表中有几个字段是需要从另外的表中去获取信息. 理论上讲, 的确可以获取到想要的数据, 但是就是效率低一点. 会刻意的在某些表中,不去保存另外表的主键(逻辑主键), 而是直接保存想要的数据信息: 这样一来,在查询数据的时候, 一张表可以直接提供数据, 而不需要多表查询(效率低), 但是会导致数据冗余增加.
如讲师代课信息表
逆规范化: 磁盘利用率与效率的对抗
第7章 数据高级操作
数据操作: 增删改查
7.1 新增数据
基本语法
Insert into 表名 [字段1,字段2,......] values (值1,值2,......); /*插入单条记录*/
Insert into 表名 [字段1,字段2,......] values (值1,值2,......), (值1,值2,......); /*插入多条记录*/
表名后面不写字段列表也可以插入数据，但是会影响速度。Mysql会进行词法分析，找到对应表结构，然后自动给你补上字段列表。所以表名后面不写字段列表，数据库难以高效的操作。
INSERT INTO t_dept(deptno, dname, loc)
VALUES(50, "技术部", "北京");
INSERT INTO t_dept(deptno, dname, loc)
VALUES(60, "后勤部", "北京"),(70,"保安部","北京"); 
eg：向技术部添加一条员工记录
分析：测验insert语句里面子查询的问题，并且这个子查询是单行子查询，不能是多行子查询，还必须是单行单列的。
INSERT INTO t_emp
(empno, ename, job, mgr, hiredate, sal, comm, deptno)
VALUES(8001, "刘娜", "SALESMAN", 8000, "1988-12-20", 2000, NULL,
(SELECT deptno FROM t_dept WHERE dname="技术部"));
练习题
答案选D，A错在scholarship字段没有数据去匹配，数据库会报错，可以填写NULL解决错误，或者删掉INSERT字段列表中的字段。B错在部门编号deptno却写成"食品工程系"，C错在人名"赵菲菲"没写成字符串形式，要加上影号。
INSERT语句方言
MySQL的INSERT语句还有一种方言语法
INSERT INTO 表名 SET 字段1=值1, 字段2=值2......
为什么称之为方言语法呢？就是因为这个语法只能在MySQL使用，不能在Oracle使用，当然你只用MySQL就可以使用这种方言语法，很简洁。
INSERT INTO t_emp
SET empno=8002,ename="JACK",job="SALESMAN",mgr=8000,
hiredate="1985-3-14",sal=2500,comm=NULL,deptno=50; 
在数据插入的时候, 假设主键对应的值已经存在: 插入一定会失败!
7.1.1 IGNORE关键字
IGNORE关键字只会插入数据库不存在的记录。比如主键冲突、唯一性冲突，数据库会报错，加上IGNORE之后数据库会忽略这条数据不会报错。
INSERT [IGNORE] INTO 表名 ......;
INSERT IGNORE INTO t_dept(deptno, dname, loc)
VALUES(70, "A", "北京"), (80, "B", "上海"); /*70部门已经存在*/ 
7.1.2 主键冲突
当主键存在冲突的时候(Duplicate key)，你可以添加ignore关键字选择忽略，数据库不会报错，但是确实非得添加这个记录怎么办呢？可以选择性的进行处理: 更新和替换
主键冲突：更新操作
Insert into 表名[(字段列表:包含主键)] values(值列表) on duplicate key update 字段 = 新值; (这个语法sql单独执行没问题，在mybatis会报错，找不到你想要的参数)
要想兼容mysql和mybatis两者，这里强烈建议不要用等号赋值
Insert into 表名[(字段列表:包含主键)] values(值列表) on duplicate key update 字段 = values(字段);
下图例子我忘记改了，应该改为...on duplicate key update room = values(room)，而不是room = 'B205'，记住不要用等号直接赋值，mybatis会报错。
主键冲突: 替换
Replace into 表名 [(字段列表:包含主键)] values(值列表);
7.1.3 蠕虫复制
蠕虫复制: 从已有的数据中去获取数据,然后将数据又进行新增操作: 数据成倍的增加.
表创建高级操作: 从已有表创建新表(复制表结构)
Create table 表名 like 数据库.表名;
蠕虫复制: 先查出数据, 然后将查出的数据新增一遍
Insert into 表名[(字段列表)] select 字段列表/* from 数据表名;
蠕虫复制的意义
从已有表拷贝数据到新表中
可以迅速的让表中的数据膨胀到一定的数量级: 测试表的压力以及效率
7.2 更新数据
基本语法
UPDATE [IGNORE] 表名 SET 字段1=值1, 字段2=值2, ......
[WHERE 条件1 ......]
[ORDER BY ......]
[LIMIT ......];
注意，如果这里有limit关键字，那么后面只能跟一个参数，即表示取前多少条数据，这里的limit不能有2个参数，ignore表示更新失败就直接忽略而不是报错。
eg1：把每个员工的编号和他上司的编号+1，用order by子句完成
UPDATE t_emp SET empno=empno+1, mgr=mgr+1
ORDER BY empno DESC;
eg2：把月收入前三名的员工底薪减100元，用LIMIT子句完成
UPDATE t_emp
SET sal=sal-100
ORDER BY sal+IFNULL(comm,0) DESC
LIMIT 3;
eg3：把10部门中，工龄达到20年的员工，底薪增加200元
UPDATE t_emp
SET sal=sal+200
WHERE deptno=10 AND DATEDIFF(NOW(),hiredate)/365 >= 20
eg：更新未排序的前3条数据，前3个出现的name为a的改为name为c
练习题
答案选A，因为B是升序排列，应该按照降序才取得到前3名，C项UPDATE子句就是错误的用法，D项LIMIT子句参数只能写一个，LIMIT子句在UPDATE中只能包含有一个参数，代表取前3条数据。
7.2.1 UPDATE语句中的内连接
因为相关子查询效率非常低，所以我们可以利用表连接的方式来改造UPDATE语句
UPDATE 表1 JOIN 表2 ON 条件
SET 字段1=值1, 字段2=值2, ......;
引申出另一种写法
UPDATE 表1 JOIN 表2
SET 字段1=值1, 字段2=值2, ......
WHERE 条件;
表连接的UPDATE语句可以修改多张表的记录
eg：把ALLEN调往RESEARCH部门，职务调整为ANALYST
/*表连接的几种写法*/
UPDATE t_emp e JOIN t_dept d ON e.ename="ALLEN" AND d.dname="RESEARCH"
SET e.deptno=d.deptno, e.job="ANALYST"
UPDATE t_emp e JOIN t_dept d
SET e.deptno=d.deptno, e.job="ANALYST"
WHERE e.ename="ALLEN" AND d.dname="RESEARCH"
UPDATE t_emp e,t_dept d
SET e.deptno=d.deptno, e.job="ANALYST"
WHERE e.ename="ALLEN" AND d.dname="RESEARCH" 
分析：其实利用的是笛卡尔积，笛卡尔积一般对于我们连接没什么用，恰恰这里就起了作用，这个例子可以好好推敲一下，表连接的条件直接将ALLEN这个人连接到RESEARCH部门，RESEARCH部门号是20，赋值给ALLEN的部门号就成功修改，接着修改职务即可。
eg：把底薪低于公司平均底薪的员工，底薪增加150元
sql语句如下
UPDATE t_emp e JOIN
(SELECT AVG(sal) avg FROM t_emp) t
ON e.sal<t.avg
SET e.sal=e.sal+150;执行结果就不演示了，从逻辑上也很好理解。
练习题
答案选B，和我们上面讲的例子一模一样，即学即用，A项错在标点符号，stu,deptno，这里不是逗号i而是点，C项错在where条件是and而不是or，D项错在update子句不用join的写法连接表，后面条件只能跟where而不是on。
7.2.2 UPDATE语句中的外连接
UPDATE语句的表连接既可以是内连接，又可以是外连接。
基本语法
UPDATE 表1 [LEFT | RIGHT] JOIN 表2 ON 条件
SET 字段1=值1, 字段2=值2, ......;
eg：把没有部门的员工，或者SALES部门低于2000元底薪的员工，都调往20部门
UPDATE t_emp e LEFT JOIN t_dept d ON e.deptno=d.deptno
SET e.deptno=20
WHERE e.deptno IS NULL OR (d.dname="SALES" AND e.sal<2000);
练习题
答案选C，根据题意，需要保留没有系别的学生，肯定是左连接，A错，B选项的左连接没有写on条件，B错，D选项筛选数据时是and最后会导致没有数据，应该是or。
7.3 删除数据
基本语法
DELETE [IGNORE] FROM 表名
[WHERE 条件1, 条件2, ...]
[ORDER BY ...]
[LIMIT ...];
子句执行顺序：FROM -> WHERE -> ORDER BY -> LIMIT -> DELETE
ignore表示删除失败就直接忽略而不是报错。
有了前面新增、更新数据的基础，下面的例子我就不展示数据表的变化了，基本语法比较容易理解。
eg1：删除10部门中，工龄超过20年的员工记录
DELETE from t_emp
WHERE deptno=10 AND DATEDIFF(NOW(),hiredate)/365 >20;eg2：删除20部门中工资最高的员工记录
DELETE FROM t_emp
WHERE deptno=20
ORDER BY sal+IFNULL(comm,0) DESC
LIMIT 1;提示：如果表中存在主键自增长,那么当删除之后, 自增长不会还原，下一条数据记录插入会在上一次计数的基础继续增加
练习题
答案选A，B错在这里的limit只能写一个参数，C错在删除了奖学金最低的人，应该desc降序排列才对，D错在没有限制条件limit。
7.3.1 DELETE语句中的内连接
因为相关子查询的效率非常低，所以我们可以利用表连接的方式来改造DELETE语句
DELETE 表1, ... FROM 表1 JOIN 表2 ON 条件
[WHERE 条件1, 条件2, ...]
[ORDER BY ...]
[LIMIT ...];
eg1：删除SALES部门该部门的全部员工记录
DELETE e,d
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno
WHERE d.dname="SALES";
eg2：删除每个低于部门平均底薪的员工记录
DELETE e
FROM t_emp e JOIN
(SELECT deptno, AVG(sal) avg FROM t_emp GROUP BY deptno) t
ON e.deptno=t.deptno AND e.sal<t.avg;
eg3：删除员工KING和他的下属的员工记录，用表连接实现
DELETE e
FROM t_emp e JOIN
(SELECT empno FROM t_emp WHERE ename="KING") t
ON e.mgr=t.empno OR e.empno=t.empno;注意，t 这个临时表是不能删除的，表连接出来的记录就是KING的员工下属和KING本身，删除e即可满足要求。数据表的图示操作就不演示了。
练习题
答案选C，即学即用，A错在没按照deptno条件连接，删除了太多无关记录，B错在delete语句中有表连接却没有指定删除的表名，D错在没有分组，查询出来的平均奖学金作为条件没有意义。
7.3.2 DELETE语句中的外连接
基本语法
DELETE 表1, ... FROM 表1 [LEFT | RIGHT] JOIN 表2 ON 条件
[WHERE 条件1, 条件2, ...]
[ORDER BY ...]
[LIMIT ...]
eg：删除SALES部门的员工，以及没有部门的员工
这里注意对比上一小节第一个例题，上一小节是删除SALES部门的员工，这里还要删除没有部门的员工，这就是内连接和外连接在这里使用的区别。
DELETE e
FROM t_emp e LEFT JOIN t_dept d ON e.deptno=d.deptno
WHERE d.dname="SALES" OR e.deptno IS NULL;
练习题
答案选B，即学即用，就是上面一个知识点。A错在判断为空是 IS NULL不是=NULL，C错在where条件dept.dept-no拼写错误，D错在删除的食品工程系和没有系别的学生应该是并集而不是交集的关系，所以是or而不是and。
7.3.3 快速删除数据表全部记录
DELETE语句是在事务机制下删除记录，删除记录之前，先把要删除的记录保存到日志文件里，然后再删除记录。
TRUNCATE语句在事务机制之外删除记录，速度远超过DELETE语句。
语法
TRUNCATE TABLE 表名;
注意：
1. drop（drop table 表名）是完全删除表，包括表结构，数据库就查不到这个表了
2. delete（delete from 表名）是删除表数据，保留表的结构，数据库中该表还存在，如果加where条件，可以只删除一行或者多行，下次插入id不会从1开始，而是从最后一次插入的id+1开始
3. truncate （truncate table 表名）只能删除全表数据，会保留表结构，数据库中该表还存在，下次插入id从1开始
如果要永久删除表，应该怎么做？
只能drop table 表名，用delete和truncate都不行。
7.4 查询数据
完整语法
Select [字段别名]/* from 数据源 [where条件子句] [group by子句] [having子句] [order by子句] [limit 子句];
7.4.1 Select语句
最基本的查询语句就是SELECT和FROM关键字组成，SELECT语句屏蔽了物理层的操作，用户不必关系数据的真实存储，交互由数据库高效的查询数据。
All或者*: 默认保留所有的结果
Distinct: 去重, 查出来的结果,将重复给去除(所有字段都相同)
7.4.2 去重查询
语法格式
SELECT DISTINCT 字段 FROM 表名;
假如我们查询员工职业，执行如下语句
SELECT job FROM t_emp;
我们发现有很多重复的记录，因为职业是有可能相同的。
此时我们加上distinct，继续执行
SELECT DISTINCT job FROM t_emp;
现在发现查询出来的职业信息就没有重复了。
注意点：
1.distinct关键字只能在select子句中使用一次
SELECT DISTINCT job, DISTINCT ename FROM t_emp;
写2个distinct直接报错
2.distinct关键字只能写在select子句的第一个字段前面，否则报错，若有多个字段，则只有多个字段的值都相同的情况才会被认为是重复记录，distinct才会生效
SELECT job, DISTINCT ename FROM t_emp;
/* distinct写在第二个字段前面 */ 
distinct没有写在第一个字段前面，结果直接报错
若有多个字段，distinct写在第一个字段前面，当全部字段都相同的时候，才会被当作重复记录。
SELECT DISTINCT job, ename FROM t_emp;
可以看到job有重复，因为针对了你的所有查询字段，只要有一个字段不同就算是不同。
7.4.3 字段别名
字段别名: 当数据进行查询出来的时候, 有时候名字并不一定就满足需求(多表查询的时候, 会有同名字段). 需要对字段名进行重命名: 别名
语法
字段名 [as] 别名;
再来一个图形化界面的例子
比如有一个数据表，你想查询员工编号和年收入，你执行结果如下：
SELECT empno, sal*12 FROM t_emp; 
查询的结果集出现了名称为sal*12这一列，语义不明确。添加别名之后
SELECT empno, sal*12 AS "income" FROM t_emp; 
这样就明确多了，这里只是查询的结果集修改了字段，并不会修改底层数据表的字段
小细节：查询语句的执行顺序是先词法分析与优化，读取SQL语句，然后FROM子句选择数据来源，最后SELECT子句选择输出内容
7.4.4 数据源
数据源: 数据的来源, 关系型数据库的来源都是数据表。本质上只要保证数据类似二维表，最终都可以作为数据源。
数据源分为多种: 单表数据源, 多表数据源, 查询语句
单表数据源: select * from 表名;
多表数据源: select* from 表名1,表名2...;
从一张表中取出一条记录，去另外一张表中匹配所有记录，而且全部保留(记录数和字段数)，将这种结果称为笛卡尔积(交叉连接)，笛卡尔积没什么用，所以应该尽量避免。只要没有条件，查询多表就会产生笛卡尔积。
子查询: 数据的来源是一条查询语句(查询语句的结果是二维表)
Select * from (select 语句) as 表名;
7.4.5 Where子句
Where子句: 用来判断数据,筛选数据.
Where子句返回结果: 0或者1, 0代表false,1代表true.
语法格式
SELECT ... FROM ... WHERE 条件 [AND | OR] 条件 ......;
判断条件:
比较运算符: >, <, >=, <= ,!= ,<>, =, like, between and, in/not in
逻辑运算符: &&(and), ||(or), !(not)
条件查询1: 要求找出学生id为1或者3或者5的学生
条件查询2: 查出区间落在180,190身高之间的学生:
Between本身是闭区间。between左边的值必须小于或者等于右边的值
图形化的例子如下：
eg1：查询部门编号为10或者20并且收入在2000及以上的记录示例：
SELECT deptno, empno, ename, sal
FROM t_emp
WHERE (deptno=10 OR deptno=20) AND sal >= 2000;
eg2：查询部门编号为10并且年收入大于15000并且工龄超过20年的职工的一些信息如下
SELECT deptno, empno, ename, sal, hiredate
FROM
t_emp
WHERE
deptno = 10
AND (
sal + IFNULL( comm, 0 ))* 12 >= 15000
AND DATEDIFF( NOW(), hiredate )/ 365 >= 20;其中IFNULL(comm, 0)表示如果佣金comm为null，则返回0，这里仅仅为了演示IFNULL才加进去的。
DATEDIFF(NOW()，hiredate)表示当前时间减去入职时间hiredate的天数。
eg3：查询包含在10，20，30里面的部门编号并且职位不是SALESMAN并且入职日期在1985-01-01以前的员工的一些信息
SELECT
empno, ename, sal, deptno, hiredate, job
FROM t_emp
WHERE deptno IN(10, 20, 30) AND job != 'SALESMAN'
AND hiredate < "1985-01-01";
例子太多了，下面可以不断变换各种比较运算符去举例，由于篇幅原因，这里不一一举例，只写一点需要注意的地方
例如判断某个字段是NULL就满足条件，是WHERE comm IS NULL而不是WHERE comm = NULL
如果不为空则满足条件，是WHERE comm IS NOT NULL而不是WHERE comm != NULL
比如名字我只记得后面是LACK，第一个字母忘了，WHERE ename like "_LACK"
我只记得是A开头的， WHERE ename LIKE "A%"
我只记得名字包含字母A，WHERE ename LIKE "%A%"
名字大部分人都是英文的，有个中文名但是我不记得了，WHERE ename REGEXP "^[\\u4e00-\\9fa5]{2, 4}$"
汉族人一般名字是2~4个字，汉字Unicode在\\u4e00-\\9fa5之间，^以...开头，$表示以...结尾。这是正则表达式，很强大，感兴趣的小伙伴可以自行下去搜索一下
来看几道练习题：
例子1
答案选择C，题目没有难度，主要熟悉语法
例子2
答案选择C，判断null是不能用等号的，而A是查询已经缴纳宿舍费用的学生姓名。
例子3
答案是AD，总学费是tuition和dorm_money两列之和。主要考察IFNULL和BETWEEN的运用。
例子4
答案是A，注意NOT IN的使用。
例子5
答案为B，可能有同学的疑问点在A和B两个选项中，A项中，只要名字以赵开头，条件就满足，不再往后继续判断，和C语言的短路语句一个道理。
where语句使用的注意事项：
WHERE子句中，条件执行的顺序是从左到右的。所以我们应该把索引条件或者筛选掉记录最多的条件写在最左侧。因为索引查询速度快，筛选记录最多的条件更容易触发短路语句的效果，这样就无须执行后续条件就能完成查询。
小提示：子句的执行顺序是FROM -> WHERE -> SELECT -> ORDER BY -> LIMIT，先选择数据来源，再进行条件筛选，根据筛选完的记录选择输出内容，接着进行排序，最后选择显示的限定条件
7.4.6 聚合函数
聚合函数在数据查询分析中，应用十分广泛。聚合函数可以对数据求和、求最大值和最小值、求平均值等等。
比如SQL提供了如下聚合函数
Count(): 统计分组后的记录数: 每一组有多少记录
Max(): 统计每组中非空的最大值
Min(): 统计非空的最小值
Avg(): 统计平均值
Sum(): 统计和
avg()函数：
eg：比如求公司员工平均月收入是多少？
SELECT AVG(sal + IFNULL(comm,0)) AS avg FROM t_emp;
这里sal是月收入，comm是佣金。avg()只用来统计数字，不要去统计别的东西
max()函数：
eg1：查询10和20部门中，月收入最高的员工？
SELECT MAX(sal+IFNULL(comm,0)) FROM t_emp
WHERE deptno IN(10,20)eg2：查询员工名字最长的是几个字符？
SELECT MAX(LENGTH(ename)) FROM t_emp;提示：LENGTH()可以统计字符个数
min()函数用法和max()一样
count()函数
count(*)用于获得包含空值的记录数，count(列名)用于获得包含非空值的记录数
SELECT COUNT(*), COUNT(comm) FROM t_emp;
执行结果如上图，表示数据表一共14条数据，而佣金comm不为空的有4条数据
来个容易混淆的题目
表结构如下：
CREATE TABLE `score` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`sno` int(11) NOT NULL,
`cno` tinyint(4) NOT NULL,
`score` tinyint(4) DEFAULT NULL,
PRIMARY KEY (`id`)
) ;
以下查询语句结果一定相等的是（）
①.SELECT sum(score) / count(*) FROM score WHERE cno = 2;
②.SELECT sum(score) / count(id) FROM score WHERE cno = 2;
③.SELECT sum(score) / count(sno) FROM score WHERE cno = 2;
④.SELECT sum(score) / count(score) FROM score WHERE cno = 2;
⑤.SELECT sum(score) / count(1) FROM score WHERE cno = 2;
⑥.SELECT avg(score) FROM score WHERE cno = 2;
A：①,⑤,⑥
B：①,④,⑥
C：①,②,③,④
D：④⑥
E：①,②,⑤,⑥
F：①,②,③,⑤
正确答案: D、F
针对这个表结构，我们来逐一分析这些查询语句：
①.SELECT sum(score) / count(*) FROM score WHERE cno = 2; 计算cno为2的记录中分数的总和，然后除以所有满足条件的记录总数（包括score为NULL的行）。
②.SELECT sum(score) / count(id) FROM score WHERE cno = 2; 计算cno为2的记录中分数的总和，然后除以所有满足条件的id的数量（包括score为NULL的行，因为id始终是NOT NULL的）。
③.SELECT sum(score) / count(sno) FROM score WHERE cno = 2; 计算cno为2的记录中分数的总和，然后除以所有满足条件的sno的数量（包括score为NULL的行，因为sno始终是NOT NULL的）。
④.SELECT sum(score) / count(score) FROM score WHERE cno = 2; 计算cno为2的记录中分数的总和，然后除以所有满足条件的非空分数的数量。
⑤.SELECT sum(score) / count(1) FROM score WHERE cno = 2; 计算cno为2的记录中分数的总和，然后除以所有满足条件的记录总数（包括score为NULL的行）。
⑥.SELECT avg(score) FROM score WHERE cno = 2; 直接使用SQL的内置函数，计算cno为2的记录中非空分数的平均值。
几乎所有的聚合函数都会忽略空值(null)，除了count(数字)、count(*)。
count(*)、count(1)包括了所有的列，相当于行数，在统计结果的时候，不会忽略列值为NULL。
count(列名)只包括列名那一列，在统计结果的时候，会忽略列值为空。
深入分析请见我另一篇博客：MySQL中count是怎样执行的？———count(1)，count(id)，count(非索引列)，count(二级索引列)的分析
eg1：查询10和20部门中，底薪超过2000元并且工龄超过15年的员工人数？
SELECT COUNT(*) FROM t_emp
WHERE deptno IN(10, 20) AND sal >= 2000
AND DATEDIFF(NOW(),hiredate)/365 >= 15;注意：聚合函数永远不可能出现在where子句里，一定会报错
练习题：
答案是D，tuition是学费，dorm_money是宿舍费。都是一些基本语法点的考察。
7.4.7 Group by子句
为什么要分组呢？因为默认情况下汇总函数是对全表范围内的数据做统计。
Group by:主要用来分组查询, 通过一定的规则将一个数据集划分为若干个小的区域，然后针对每个小区域分别进行数据汇总处理。也就是根据某个字段进行分组(相同的放一组,不同的分到不同的组)
基本语法: group by 字段名;
图形化例子：
eg：根据不同的部门号分组显示平均工资
SELECT deptno, ROUND(AVG(sal)) FROM t_emp GROUP BY deptno;/*round四舍五入为整数*/
逐级分组
数据库支持多列分组条件，执行的时候逐级分组
eg：查询每个部门里，每种职位的人员数量和平均底薪
SELECT deptno, job, COUNT(*), AVG(sal)
FROM t_emp
GROUP BY deptno, job
ORDER BY deptno;
这里千万千万要注意一个硬性要求！
如果查询语句中含有GROUP BY子句，那么SELECT子句中的内容必须遵守如下约定：
SELECT子句中可以包含聚合函数或者GROUP BY子句的分组列，其余列出现在SELECT子句中时就涉及到了SQL经典问题。
在MySQL中，如果在SELECT列表中包含GROUP BY子句中未指定的列，MySQL 的默认行为不会报错，但结果可能不确定，MySQL将使用默认值FIRST()来选择这些列的值。也就是说，刚刚的例子假如是GROUP BY deptno，没有job，虽然语法不报错，但是这个job列的值实际上是从符合GROUP BY条件的行中任意选择的，也就是说，deptno为10，查出来的job可能是CLERK、MANAGER、PRESIDENT中任何一个，MySQL会默认选择job列在分组集合中的第一个值作为代表值。
执行看看
SELECT deptno, job, COUNT(*), AVG(sal)
FROM t_emp
GROUP BY deptno /*相比上面的例子，这里没有job分组，但是select子句却出现了job*/
ORDER BY deptno;
/* select子句除了分组列字段deptno和聚合函数，还出现了job！ */ 
经过对比，部门为10的里面有3条记录，但是job都为MANAGER？？明显不对，看上面一个例子就知道了。为了确保查询结果正确性，建议在SELECT列表中仅包括GROUP BY子句中指定的列或聚合函数。
什么情况下查询除了group by以外的非聚合字段时有意义？
当非聚合字段与group by字段具有一对一关系的时候，这么写就有意义。在这个例子中group by deptno，但是一个deptno里面有很多个job，这么写没有业务意义。但是如果是一对一的关系，比如剧本是否点赞和剧本详细信息在2张表中，现在要查询点赞数最高的3个剧本详细信息，如下：
# drama_operation记录不同的人点赞的记录
# drama_info记录这个剧本的详细信息,剧本id都是唯一的
select
di.id,
di.title,
di.content,
COUNT(do.drama_id) AS num_likes
from
drama_info di
join drama_operation do on di.id = do.drama_id
where do.is_like = 1
group by
do.drama_id
order by
num_likes DESC
limit 3;
# 根据剧本id关联，虽然根据剧本id分组，查询了除了group by字段以外的非聚合字段，但是因为剧本id和这些非聚合字段是一对一的关系，所以这里在业务意义上也不会出错。对分组结果集再次做汇总计算(回溯统计)
这里就是WITH ROLLUP的使用
SELECT deptno, AVG(sal), SUM(sal), MAX(sal), MIN(sal), COUNT(*)
FROM t_emp
GROUP BY deptno WITH ROLLUP 
使用了WITH ROLLUP之后，你发现最底下还有一行，对应列再次做聚合计算，avg列再次做平均值计算，sum列对上面几个部门数据再次进行sum计算...
GROUP_CONCAT函数
这个函数可以把分组查询中的某个字段拼接成一个字符串
eg：查询每个部门内底薪超过2000元的人数和员工姓名
SELECT deptno, COUNT(*), GROUP_CONCAT(ename)
FROM t_emp
WHERE sal >= 2000
GROUP BY deptno;
看到ename都是逗号连接的字符串
练习题
答案选B，单看聚合函数就排除AC，根据含有GROUP BY子句SELECT子句会有硬性要求的问题，SELECT子句除了聚合函数以外的其他字段必须要出现在GROUP BY子句，所以排除D，答案选择B.
小提示：语句的执行顺序如下：
FROM -> WHERE -> GROUP BY -> SELECT -> ORDER BY -> LIMIT
FROM 选择数据来源，WHERE选择条件，符合条件的记录留下来，然后经过GROUP BY分组，分完组根据SELECT子句里面聚合函数做计算，然后ORDER BY对结果集排序，最后交给LIMIT挑选返回哪些分页的数据显示。
====下面几个控制台执行的例子是我之前写的，就不删了，大家也可以对照看一下====
分组会自动排序: 根据分组字段:默认升序
Group by 字段 [asc|desc]; -- 对分组的结果然后合并之后的整个结果进行排序
多字段分组: 先根据一个字段进行分组,然后对分组后的结果再次按照其他字段进行分组
有一个函数: 可以对分组的结果中的某个字段进行字符串连接(保留该组所有的某个字段): group_concat(字段)
这对于group by一个字段，而在select语句想查询除了group by字段以外的字段时，非常有用。
回溯统计: with rollup: 任何一个分组后都会有一个小组, 最后都需要向上级分组进行汇报统计: 根据当前分组的字段. 这就是回溯统计: 回溯统计的时候会将分组字段置空.
多字段回溯: 考虑第一层分组会有此回溯: 第二次分组要看第一次分组的组数, 组数是多少,回溯就是多少,然后加上第一层回溯即可.
7.4.8 Having子句
Having子句与where子句一样是进行条件判断的.
有同学会问了，和where子句功能一样，那还有什么用，多此一举？
eg1：查询部门平均底薪超过2000的员工数量，你是不是会这样写？
SELECT deptno, COUNT(*)
FROM t_emp
WHERE AVG(sal) >= 2000
GROUP BY deptno;
结果运行出错，我们前面也说了，WHERE子句不允许出现聚合函数。而且WHERE优先级高于GROUP BY，在条件筛选的时候不知道按照什么范围去筛选，是全部数据筛选还是分部门数据筛选呢？
解决方案来了，那就是HAVING子句，HAVING子句的出现主要是为了WHERE子句不能使用聚合函数的问题，HAVING子句不能独立存在，必须依赖于GROUP BY子句而存在，GROUP BY 执行完成就立即执行HAVING子句
SELECT deptno, COUNT(*)
FROM t_emp
GROUP BY deptno HAVING AVG(sal) >= 2000;
结果就出来了，部门号为20，底薪超过2000的有5人，部门号为10，底薪超过2000的有3人
eg2：查询每个部门中，查询每个部门中，1982年以后入职员工超过2个人的部门编号
SELECT deptno FROM t_emp
WHERE hiredate>="1982-01-01"
GROUP BY deptno HAVING COUNT(*) > 2
ORDER BY deptno; 
可以看到满足条件的有2个部门，10部门和20部门还是有老员工的。
要注意HAVING子句判断只能和具体数值判断大小，不能和字段以及聚合函数判断，比较要有数值。比如查询工资大于平均工资的人的数量就不能写HAVING sal > AVG(sal)，子句判断不是和数值在比较，直接报错。表连接能解决这个问题，后面再讲。
HAVING子句的特殊用法
如果按照数字1分组，MySQL会按照SELECT子句中的列进行分组，HAVING子句也可以正常使用
比如按照部门分组，查询各个部门总人数
SELECT deptno, COUNT(*) FROM t_emp GROUP BY 1;
HAVING的出现是不是可以完全替换WHERE？
那肯定是不行的，Where是针对磁盘数据进行判断，进入到内存之后会进行分组操作，分组结果就需要having来处理.
SELECT deptno, COUNT(*) FROM t_emp
GROUP BY 1
HAVING deptno IN(10, 30);/*效率低了*/
SELECT deptno, COUNT(*) FROM t_emp
WHERE deptno IN(10, 30)
GROUP BY 1;从功能上来说，上面两种写法没有什么区别，但是WHERE优先级在GROUP BY之前，是先把数据按条件筛选完了再分组好呢，还是分完组再去筛选好呢？肯定是前者。所以WHERE能完成的就用WHERE完成，不要放到HAVING中。大量的数据从磁盘读取到内容代价比较大，先筛选完了，再把符合条件的记录读取到内存中显然更好。
Having能做where能做的几乎所有事情, 但是where却不能做having能做的很多事情.
1.分组统计的结果或者说统计函数都只有having能够使用.
2.Having能够使用字段别名，where不能，where是从磁盘取数据，而名字只可能是字段名，别名是在字段进入到内存后才会产生.
练习题
答案选择A，基本语法的运用，看清表是student没有s。
7.4.9 Order by子句
Order by: 排序, 根据某个字段进行升序或者降序排序, 依赖校对集.
使用基本语法
单字段排序：
Order by 字段名 [asc|desc]; -- asc是升序(默认的),desc是降序
我们再图形化举例示范一下：
执行如下语句
SELECT empno, ename, sal, deptno FROM t_emp ORDER BY sal DESC;
按照sal降序就排好了。
来个练习题：
很简单，不用多说就知道答案，估摸着有人在BC里面纠结呢，这不一样吗，答案选B，select选择输出字段之间逗号隔开，细节问题。
多字段排序:
使用order by 规定首要条件和次要条件排序。数据库会先按照首要条件排序，遇到首要排序内容相同的记录，那么会启用次要条件再次排序。
使用图形化界面再举一个例子：
执行如下语句
SELECT empno, ename, sal, hiredate
FROM t_emp ORDER BY sal DESC, hiredate ASC;
可以看到当首要排序条件sal记录相同时，会按照hiredate进行升序排列
小提示：
1.order by 写在 limit前面
2.子句的执行顺序是FROM -> SELECT -> ORDER BY -> LIMIT，先选择数据来源，再选择输出内容，接着进行排序，最后选择显示的限定条件
来个练习题：
A排除，和表不对应，没有name字段，B排除，多字段之间排序用逗号隔开，D排除，升序是ASC或者不写，所以选C。
7.4.10 Limit子句
Limit子句是一种限制结果的语句，用来做数据分页的。
比如我们看朋友圈，只会加载少量的部分信息，不会一次性加载全部朋友圈，那样只会浪费CPU时间、内存、网络带宽。而结果集的记录可能很多，可以使用limit关键字限定结果集数量。
Limit有两种使用方式
方案1: 只用来限制长度(数据量): limit 数据量;
方案2: 限制起始位置,限制数量: limit 起始位置,长度;
Limit方案2主要用来实现数据的分页: 为用户节省时间,提交服务器的响应效率, 减少资源的浪费.
对于用户来讲: 可以点击的分页按钮: 1,2,3,4
对于服务器来讲: 根据用户选择的页码来获取不同的数据: limit offset,length;
Length: 每页显示的数据量: 基本不变
Offset: offset = (页码 - 1) * 每页显示量
小提示：子句的执行顺序 FROM -> SELECT -> LIMIT，先选择数据来源，再选择输出内容，最后选择显示的限定条件
7.4.11 select语句中各关键字的先后顺序
(1) from
(2) on
(3) join
(4) where （可以使用表的别名）
(5) group by(可以开始使用select中字段的别名（不是表的别名），后面的语句中都可以使用)
(6) having + 聚合函数
(7) select
(8) distinct
(9) order by
(10) limit
1~3是table部分——形成表
4~6是filter部分——过滤条件
7~10是show部分——展示
更多原理可以我写的见这篇文章
一条SQL如何被MySQL架构中的各个组件操作执行的？
https://liuchenyang0515.blog.csdn.net/article/details/130270929
第8章 连接查询
连接查询: 将多张表(可以大于2张)进行记录的连接(按照某个指定的条件进行数据拼接): 最终结果是: 记录数有可能变化, 字段数一定会增加(至少两张表的合并)
连接查询的意义: 在用户查看数据的时候,需要显示的数据来自多张表.
连接查询: join, 使用方式: 左表 join 右表
左表: 在join关键字左边的表
右表: 在join关键字右边的表
8.1 连接查询分类
SQL中将连接查询分成四类: 内连接,外连接,自然连接和交叉连接
8.2 交叉连接
交叉连接: cross join, 从一张表中循环取出每一条记录, 每条记录都去另外一张表的所有记录逐个进行匹配，并保留所有记录，最终形成的结果叫做笛卡尔积.
交叉连接也称为笛卡尔积连接，它返回两个表中所有可能的行组合。交叉连接通常在实际应用中很少使用，因为它会产生大量的结果，可能导致性能问题。然而，在某些特殊情况下，交叉连接可能是有用的。
基本语法: 左表 [cross] join 右表。其中cross可以省略，交叉连接是一个隐式的内连接，内连接没写条件就是交叉连接。
交叉连接存在的价值: 保证连接这种结构的完整性，生成所有可能组合，为查询提供基础数据。
8.3 内连接
内连接: [inner] join, 内连接是最常用的连接类型，它返回两个表中具有匹配值的行。如果某行在一个表中没有匹配值，那么结果集中将不包含这行。内连接可以使用INNER JOIN关键字或在WHERE子句中指定连接条件来实现。
SELECT ...
FROM table1
[INNER] JOIN table2 ON table1.column = table2.column
[WHERE] ...
SELECT ...是你要选择的列，可以使用table1.column或table2.column的形式，或使用*选择所有列。FROM table1是主表。INNER JOIN table2是要连接的表。内连接仅返回两个表中满足连接条件的匹配记录。ON table1.column = table2.column是连接条件，即用于比较两个表中的列以建立连接的条件。WHERE ...是筛选条件，如果你不需要筛选结果集，可以省略WHERE子句。
原理篇：
面试之前，MySQL表连接必须过关！——表连接的原理https://liuchenyang0515.blog.csdn.net/article/details/118633188
如下，某个条件左右表相同部分的交集
基本语法
SELECT ...... FROM 表1
[INNER] JOIN 表2 ON 条件
[INNER] JOIN 表3 ON 条件
......
内连接其实有多种语法形式，想用哪种看个人喜好，效率上没有区别。
SELECT ... FROM 表1 JOIN 表2 ON 连接条件;
SELECT ... FROM 表1 JOIN 表2 WHERE 连接条件;
SELECT ... FROM 表1, 表2 WHERE 连接条件;我们来做个例题，首先我们看到前提条件给出了3张表
1.员工表t_emp
2.部门表t_dept
3.薪资等级表t_salgrade
有人会问了，内连接语法看起来就是交叉连接多了一个ON条件，但是区别可大了，来直观感受一下
SELECT * FROM t_emp JOIN t_dept /*交叉连接*/ 
交叉连接产生笛卡尔积，保留所有结果，导致出现了56条记录
SELECT * FROM t_emp e JOIN t_dept d ON e.deptno = d.deptno; /*内连接*/ 
内连接就只针对符合条件的记录去连接，结果集少了很多条记录。
注意：在查询数据的时候，不同表有同名字段，这个时候需要加上表名才能区分，而表名太长，通常可以使用别名，这里两张表都有deptno，表名也缩短为了一个字母
再来看看具体例题
eg1：查询每个员工的工号、姓名、部门名称、底薪、职位、工资等级
分析：工号empno、姓名ename、底薪sal、职位job是在员工表t_emp，部门名称dname是在部门表t_dept，工资等级grade是在薪资等级表t_salgrade。现在就涉及到了3个表的操作，而员工表t_emp和部门表t_dept都有员工编号deptno字段，这个很容易作为筛选条件， 但是工资等级grade却没有相同字段去对应，那么这个就需要找到逻辑关系的对应，用底薪sal去判断薪资等级中的薪水范围即可
SELECT e.empno, e.ename, d.dname, e.sal, e.job, s.grade
FROM t_emp e JOIN t_dept d ON e.deptno = d.deptno
JOIN t_salgrade s ON e.sal BETWEEN s.losal AND s.hisal;
eg2：查询与SCOTT相同部门的员工
分析：还是那3张表，要查和某个人相同部门的员工，有人就开始这么做，上去就是一个sql
SELECT ename
FROM t_emp
WHERE deptno=(SELECT deptno FROM t_emp WHERE ename="SCOTT")
AND ename!="SCOTT";括号中的查询我们称为子表，子表中查询到deptno然后把结果集给父表继续查询，写完感觉自我良好，殊不知自己写了一个领导看到就想把你开除的sql。
FROM先执行，获取了数据表的每条记录，再去WHERE进行筛选，万一有上万条数据呢？WHERE会逐一判断上万条数据是否满足条件的时候都要去查询一个子表，相当于SELECT deptno FROM t_emp WHERE ename="SCOTT"被你执行了上万次，而子表也是上万条数据，每一次父表的条件判断又会执行上万次子表查询，数据量小的时候看不出差异，数据量大了就很明显了。
这里用表连接的效率远远高于子查询
SELECT e2.ename
FROM t_emp e1 JOIN t_emp e2 ON e1.deptno=e2.deptno
WHERE e1.ename="SCOTT" AND e2.ename!="SCOTT";先内连接减少数据源结果集的数量，然后进行筛选。能达到和子查询一样的效果，效率比子查询要高。
eg3：查询底薪超过公司平均底薪的员工信息
SELECT e.empno, e.ename, e.sal
FROM t_emp e JOIN
(SELECT AVG(sal) avg FROM t_emp) t
ON e.sal >= t.avg;
把平均底薪查询结果当作一个表再和员工表t_emp连接，返回FROM子句。之前说过，这个问题是WHERE解决不了的，WHERE里面不能出现聚合函数的，直接写WHERE sal >= AVG(sal)肯定报错，而HAVING子句又只能和数值比较，这里e.sal>=t.avg表达式两边都是变量，HAVING子句无法解决。
eg4：查询RESEARCH部门人数、最高底薪、最低底薪、平均底薪、平均工龄
SELECT COUNT(*), MAX(e.sal), MIN(e.sal), AVG(e.sal),
AVG(DATEDIFF(NOW(),e.hiredate)/365)
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno
WHERE d.dname="RESEARCH";
如果前面的题目都懂了，这题就是语法复习，表连接和聚合函数的使用。
eg5：查询每种职业的最高工资、最低工资、平均工资、最高工资等级和最低工资等级
分析：涉及到工资等级，需要薪资等级表t_salgrade，那么就是员工表和薪资等级表的连接，因为同一种职业不同人有不同的收入，所有根据收入等级排工资等级，逻辑要捋清楚。
SELECT
e.job,
MAX(e.sal + IFNULL(e.comm,0)),
MIN(e.sal + IFNULL(e.comm,0)),
AVG(e.sal + IFNULL(e.comm,0)),
MAX(s.grade),
MIN(s.grade)
FROM t_emp e JOIN t_salgrade s
ON (e.sal + IFNULL(e.comm,0)) BETWEEN s.losal AND s.hisal
GROUP BY e.job;
eg6：查询每个底薪超过部门平均底薪的员工信息
SELECT e.empno, e.ename, e.sal
FROM t_emp e JOIN
(SELECT deptno, AVG(sal) avg FROM t_emp GROUP BY deptno) t
ON e.deptno=t.deptno AND e.sal >= t.avg;
如果只运行子表查询，得到各个部门平均底薪，可以和上图对比一下
练习一下选择题
答案选B，都是语法细节，多一个少一个标点符号的问题。A错在别名问题，应该将子表别名写在括号外，C错在没有join，写了个逗号，D错在，select子句少了逗号，这个题目考察眼力哈哈哈。
答案选择A，考察表连接的另一种写法SELECT ... FROM 表1, 表2 WHERE 连接条件，排除D，因为两个表之间没有逗号，再排除C，因为只从一张表查不出那么多信息，最后排除B，因为NOW()后面没有逗号。
8.4 外连接
外连接分为两种：左(外)连接和右(外)连接。
左外连接就是保留左表所有记录，与右表做连接。如果右表有符合条件的记录就与左表连接。如果右表没有符合条件的记录，就用NULL与左表连接。右连接也是如此。
基本语法:
SELECT ...
FROM table1
LEFT JOIN table2 ON table1.column = table2.column
[WHERE] ...
或者
SELECT ...
FROM table1
RIGHT JOIN table2 ON table1.column = table2.column
[WHERE] ...
SELECT ...是你要选择的列，可以使用table1.column或table2.column的形式，或使用*选择所有列。FROM table1是主表。LEFT JOIN table2或RIGHT JOIN table2是要连接的表。左连接（Left Join）返回主表中的所有记录，即使在连接表中没有匹配的记录。右连接（Right Join）返回连接表中的所有记录，即使在主表中没有匹配的记录。ON table1.column = table2.column是连接条件，即用于比较两个表中的列以建立连接的条件。WHERE ...是筛选条件，如果你不需要筛选结果集，可以省略WHERE子句。。
为什么要有外连接？
我们还是以内连接中提到的3张数据表为例子。
如果有一名临时员工，没有固定的部门编号，那么我们查询每名员工和他的部门名称，用内连接就会漏掉临时员工，所以要引入外连接语法才能解决这个问题。外连接与内连接的区别在于，除了符合条件的记录之外，结果集中还会保留不符合条件的记录。
含有临时员工的员工表t_emp
部门表t_dept
薪资等级表t_salgrade
eg1：查询每名员工和他的部门名称
假设我们使用内连接，我们根本查不到临时员工信息，因为临时员工没有部门编号，如下：
SELECT e.empno, e.ename, d.dname
FROM t_emp e JOIN t_dept d
ON e.deptno=d.deptno;
当我们使用外连接时，就能够查到临时员工，如下：
/*左连接*/
SELECT e.empno, e.ename, d.dname
FROM t_emp e LEFT JOIN t_dept d
ON e.deptno=d.deptno;
/*右连接，换一下表的顺序，结果集一样*/
SELECT e.empno, e.ename, d.dname
FROM t_dept d RIGHT JOIN t_emp e
ON e.deptno=d.deptno;
左表是员工表，左连接保留所有记录，没有部门编号的临时员工信息也会保留，右表部门编号没有与之匹配，那就用NULL连接。
eg2：查询每个部门的名称和部门的人数
有人容易写出下面的错误sql语句
SELECT d.dname, COUNT(*)
FROM t_dept d LEFT JOIN t_emp e
ON d.deptno=e.deptno
GROUP BY d.deptno;/*按部门分组，所以有group by*/ 
这题很多细节，很多人会出错，40部门的部门名称为dname为OPERATIONS里没有员工，居然还是有一条记录，因为你在连接的时候左表记录全部保留，在右表中没有员工与OPERATIONS部门匹配，连接的是NULL，这也是一条记录，所以这里才会出现1。
但是你也不要写成COUNT(d.deptno)，因为左边部门表记录全保留，d.deptno有40部门，40部门的dname就是OPERATIONS，右表与之连接的都是NULL，道理和上面一样。
所以你得按照右边员工表计算，COUNT(e.deptno)，记录各个部门非空记录数。40部门没有员工，右表e.deptno没有40，NULL不会被COUNT(e.deptno)计算入内，所以是0，符合预期。
正确的sql语句如下：
SELECT d.dname, COUNT(e.deptno)
FROM t_dept d LEFT JOIN t_emp e
ON d.deptno=e.deptno
GROUP BY d.deptno;/*按部门分组，所以有group by*/
eg3：查询每个部门的名称和部门的人数，如果是没有部门的临时员工，部门名称用NULL代替
分析：我们上一个例子已经做到了查询部门名称和部门的人数，现在就差一个临时员工和他的部门的问题，临时员工还在等着被你统计呢。临时员工在t_emp表，所以你要保留这个表的所有内容再把eg2例子的查询语句一起联合查询
(SELECT d.dname, COUNT(e.deptno)
FROM t_dept d LEFT JOIN t_emp e
ON d.deptno=e.deptno
GROUP BY d.deptno) UNION
(SELECT d.dname, COUNT(*)
FROM t_dept d RIGHT JOIN t_emp e
ON d.deptno=e.deptno
GROUP BY d.deptno);
这个部门名称dname为NULL的就是那个临时员工。
eg4：查询每名员工的编号、姓名、部门名称、月薪、工资等级、工龄、上司编号、上司姓名、上司部门(这个题有点综合，没点基础做不出来)
分析：要查员工的编号、姓名、部门名称、工龄，涉及到员工表t_emp、部门表t_dept，查工资等级涉及到薪资等级表t_salgrade，有的员工是其他员工的上司，所以我们为员工表再做一次查询连接起来当作领导表，连接条件是员工的领导编号和领导的员工编号相等时，这个领导表查出来的员工，就是员工表里对应员工的领导。sql如下，你细品
SELECT
e.empno, e.ename, d.dname,
e.sal + IFNULL(e.comm,0), s.grade,
FLOOR(DATEDIFF(NOW(),e.hiredate)/365),
t.empno AS mgrno, t.ename AS mname, t.dname AS mdname
FROM t_emp e LEFT JOIN t_dept d ON e.deptno=d.deptno
LEFT JOIN t_salgrade s ON e.sal BETWEEN s.losal AND s.hisal
LEFT JOIN
(SELECT e1.empno, e1.ename, d1.dname
FROM t_emp e1 JOIN t_dept d1
ON e1.deptno=d1.deptno
) t ON e.mgr=t.empno;
外连接的注意事项：
内连接只保留符合条件的记录，所以查询条件写在ON子句和WHERE子句中的效果是相同的。但是外连接里，条件写在WHERE子句里，不符合条件的记录是会被过滤掉的，而不是保留下来。
我们来看看具体差别
SELECT e.ename, d.dname, d.deptno
FROM t_emp e
LEFT JOIN t_dept d ON e.deptno=d.deptno
AND e.deptno=10; /*这里是and不是where*/分析：左连接保留左表全部，按条件连接右表，不仅要部门编号相同，还要部门编号为10，不满足的用NULL连接，所以总记录条数就是左表的COUNT(*)数量
改为WHERE之后
SELECT e.ename, d.dname, d.deptno
FROM t_emp e
LEFT JOIN t_dept d ON e.deptno=d.deptno
WHERE e.deptno=10;分析：左连接保留左表全部，按照部门号进行对应连接，连接完再进行筛选员工部门号位10的记录，不满足的就过滤。一步步的执行过程如下图
外连接的扩展阅读：
一条SQL如何被MySQL架构中的各个组件操作执行的？https://liuchenyang0515.blog.csdn.net/article/details/130270929
8.5 自然连接
自然连接: natural join, 自然连接（NATURAL JOIN）是一种基于具有相同名称的列自动执行连接操作的方法。它有自然内连接（NATURAL INNER JOIN）和自然外连接（NATURAL OUTER JOIN）两种形式。
自然连接: 可以分为自然内连接和自然外连接.
假设我们有两个表：orders 和 customers
orders 表结构如下：
+--------+---------------+
| order_id | customer_id |
+--------+---------------+
| 1 | 1 |
| 2 | 2 |
| 3 | 1 |
+--------+---------------+
customers 表结构如下：
+---------+----------------+
| customer_id | name |
+---------+----------------+
| 1 | Alice |
| 2 | Bob |
+---------+----------------+
假设我们想要根据 customer_id 连接这两个表，可以使用自然连接：
SELECT * FROM orders NATURAL JOIN customers;
这将返回以下结果集：
+--------+---------+---------------+
| order_id | customer_id | name |
+--------+---------+---------------+
| 1 | 1 | Alice |
| 3 | 1 | Alice |
| 2 | 2 | Bob |
+--------+---------+---------------+
自然连接的问题在于，它完全依赖于列名和数据类型的匹配。如果两个表中具有相同名称和类型的列，并且它们的含义不同，那么自然连接可能会导致错误的结果。例如，如果 orders 表中的 customer_id 列表示客户的信用卡ID，而 customers 表中的 customer_id 列表示客户的ID，那么使用自然连接将产生错误的结果。
如果某个表的列名或数据类型发生更改，自然连接可能无法正确地连接这些表。例如，如果将 customers 表中的 customer_id 列名称更改为 cust_id，则自然连接将无法正确连接这两个表。
如果两个表中表示相同含义的字段名称不同，那么在这种情况下，自然连接不适用，需要使用显式的连接条件，如内连接或外连接来连接这些表。例如，如果orders表的customer_id字段表示客户ID，而customers表中表示相同含义的字段名称是cust_id，那么可以使用内连接（INNER JOIN）来连接这两个表
SELECT * FROM orders o
INNER JOIN customers c ON o.customer_id = c.cust_id;
这将返回与以前示例中相同的结果集。
在实际开发中，自然连接并不推荐使用，只推荐使用内连接和外连接。
8.6 子查询
子查询: sub query, 查询是在某个查询结果之上进行的.(一条select查询的sql语句内部包含了另外一条select查询的sql语句).
8.6.1 子查询分类
Where子查询: 子查询出现where条件中，where语句里不推荐使用子查询，每执行一次where条件筛选，就会进行一次子查询，效率低下。像这种反复子查询就属于相关子查询，where语句的子查询都属于相关子查询，我们要避免相关子查询的存在。
比如查询底薪超过公司平均底薪的员工信息
From子查询: 子查询跟在from之后，通常这种子查询的结果集作为一个临时表，from子查询只会执行一次，不是相关子查询，所以查询效率高。
SELECT子查询，子查询跟在SELECT之后，SELECT子查询也是相关子查询，不推荐
8.6.2 单行子查询和多行子查询
单行子查询的结果集只有一条记录，多行子查询结果集有多行记录
多行子查询只能出现在WHERE子句和FROM子句中
eg：如何用子查询查找FORD和MARTIN两个人的同事？
分析：同一个部门的都算作同事，而且题目限定了用子查询来做，所以不用表连接做。
SELECT ename FROM t_emp
WHERE deptno IN
(SELECT deptno FROM t_emp WHERE ename IN("FORD","MARTIN"))
AND ename NOT IN("FORD","MARTIN");
当然这个题目用表连接做时最好的，效率比WHERE里面子查询高的多，只不过这里题目要求用子查询，这里我们还是给出表连接的sql语句供大家参考
SELECT ename
FROM t_emp e
JOIN
(SELECT deptno FROM t_emp WHERE ename IN("FORD","MARTIN")) d
ON e.deptno=d.deptno
AND ename NOT IN("FORD","MARTIN");/*不需要用e.ename因为只有e表有ename*/8.6.3 WHERE子句中的多行子查询
WHERE子句中，可以用IN、ALL、ANY、EXISTS关键字来处理多行表达式结果集的条件判断。
eg：查询比FORD和MARTIN底薪都高的员工信息？
SELECT ename FROM t_emp
WHERE sal > ALL
(SELECT sal FROM t_emp
WHERE ename IN("FORD","MARTIN"));
这里是ALL，表示比FORD和MARTIN底薪都高，如果换成ANY，则表示比两者任意一个高就满足条件
8.6.4 子查询的EXISTS关键字
EXISTS关键字是把原来在子查询之外的条件判断，写到了子查询的里面。
SELECT ... FROM 表名 WHERE [NOT] EXISTS (子查询)
eg：查询工资等级是3级或者4级的员工信息
SELECT empno, ename, sal
FROM t_emp
WHERE EXISTS(
SELECT * /*这里选择其他字段也可以，比如grade*/
FROM t_salgrade
WHERE sal BETWEEN losal AND hisal
AND grade IN(3,4)
)只要子查询结果为不为空，那么EXISTS这个条件就是满足的，这条记录就满足条件不会被过滤。
这里只是演示WHERE多行子查询的EXISTS关键字，解决这个问题用表连接其实好的多。如下：
SELECT empno, ename, sal
FROM t_emp
JOIN t_salgrade
ON sal BETWEEN losal AND hisal AND grade IN(3,4)第9章 视图
视图: view, 是一种有结构(有行有列)但是没结果(结构中不真实存放数据)的虚拟表, 虚拟表的结构来源不是自己定义, 而是从对应的基表中产生(视图的数据来源).
9.1 创建视图
基本语法
Create view 视图名字 as select语句; -- select语句可以是普通查询;可以是连接查询; 可以是联合查询; 可以是子查询.
创建单表视图: 基表只有一个
创建多表视图: 基表来源至少两个
9.2 查看视图
查看视图: 查看视图的结构
视图是一张虚拟表: 表, 表的所有查看方式都适用于视图: show tables [like]/desc 视图名字/show create table 视图名;
视图比表还是有一个关键字的区别: view. 查看”表(视图)”的创建语句的时候可以使用view关键字
视图一旦创建: 系统会在视图对应的数据库文件夹下创建一个对应的结构文件: frm文件
9.3 使用视图
使用视图主要是为了查询: 将视图当做表一样查询即可.
视图的执行: 其实本质就是执行封装的select语句.
9.4 修改视图
视图本身不可修改, 但是视图的来源是可以修改的.
修改视图: 修改视图本身的来源语句(select语句)
Alter view 视图名字 as 新的select语句;
9.5 删除视图
Drop view 视图名字;
9.6 视图意义
1. 视图可以节省SQL语句: 将一条复杂的查询语句使用视图进行保存: 以后可以直接对视图进行操作
2. 数据安全: 视图操作是主要针对查询的, 如果对视图结构进行处理(删除), 不会影响基表数据(相对安全).
3. 视图往往是在大项目中使用, 而且是多系统使用: 可以对外提供有用的数据, 但是隐藏关键(无用)的数据: 数据安全
4. 视图可以对外提供友好型: 不同的视图提供不同的数据, 对外好像专门设计
5. 视图可以更好(容易)的进行权限控制
9.7 视图数据操作
视图是的确可以进行数据写操作的: 但是有很多限制
将数据直接在视图上进行操作.
9.7.1 新增数据
数据新增就是直接对视图进行数据新增.
1.多表视图不能新增数据
2.可以向单表视图插入数据: 但是视图中包含的字段必须有基表中所有不能为空(或者没有默认值)字段
3.视图是可以向基表插入数据的.
9.7.2 删除数据
多表视图不能删除数据
单表视图可以删除数据
9.7.3 更新数据
理论上不能单表视图还是多表示视图都可以更新数据.
更新限制: with check option, 如果对视图在新增的时候,限定了某个字段有限制: 那么在对视图进行数据更新操作时,系统会进行验证: 要保证更新之后,数据依然可以被实体查询出来,否则不让更新.
9.8 视图算法
视图算法: 系统对视图以及外部查询视图的Select语句的一种解析方式.
视图算法分为三种
Undefined: 未定义(默认的), 这不是一种实际使用算法, 是一种推卸责任的算法: 告诉系统,视图没有定义算法, 系统自己看着办
Temptable: 临时表算法: 系统应该先执行视图的select语句,后执行外部查询语句
Merge: 合并算法: 系统应该先将视图对应的select语句与外部查询视图的select语句进行合并,然后执行(效率高: 常态)
算法指定: 在创建视图的时候
Create algorithm = 指定算法 view 视图名字 as select语句;
视图算法选择: 如果视图的select语句中会包含一个查询子句(五子句), 而且很有可能顺序比外部的查询语句要靠后, 一定要使用算法temptable,其他情况可以不用指定(默认即可).
第10章 数据备份与还原
备份: 将当前已有的数据或者记录保留
还原: 将已经保留的数据恢复到对应的表中
为什么要做备份还原?
防止数据丢失: 被盗, 误操作
保护数据记录
数据备份还原的方式有很多种: 数据表备份, 单表数据备份, SQL备份, 增量备份.
10.1 数据表备份
不需要通过SQL来备份: 直接进入到数据库文件夹复制对应的表结构以及数据文件, 以后还原的时候,直接将备份的内容放进去即可.
数据表备份有前提条件: 根据不同的存储引擎有不同的区别.
存储引擎: mysql进行数据存储的方式: 主要是两种: innodb和myisam(免费)
对比myisam和innodb: 数据存储方式
Innodb: 只有表结构,数据全部存储到ibdata1文件中
Myisam: 表,数据和索引全部单独分开存储
这种文件备份通常适用于myisam存储引擎: 直接复制三个文件即可, 然后直接放到对应的数据库下即可以使用.
10.2 单表数据备份
每次只能备份一张表; 只能备份数据(表结构不能备份)
如果业务数据非常多，建议只导出表结构，然后用SELECT INTO OUTFILE把数据导出成文本文档，具体操作可以看10.5节图形化操作。
备份: 从表中选出一部分数据保存到外部的文件中(outfile)
Select */字段列表 into outfile 文件所在路径 from 数据源; -- 前提: 外部文件不存在
高级备份: 自己制定字段和行的处理方式
Select */字段列表 into outfile 文件所在路径 fields 字段处理 lines 行处理 from 数据源;
Fields: 字段处理
Enclosed by: 字段使用什么内容包裹, 默认是’’,空字符串
Terminated by: 字段以什么结束, 默认是”\t”, tab键
Escaped by: 特殊符号用什么方式处理,默认是’\\’, 使用反斜杠转义
Lines: 行处理
Starting by: 每行以什么开始, 默认是’’,空字符串
Terminated by: 每行以什么结束,默认是”\r\n”,换行符
数据还原: 将一个在外部保存的数据重新恢复到表中(如果表结构不存在,那么sorry)
Load data infile 文件所在路径 into table 表名[(字段列表)] fields字段处理 lines 行处理; -- 怎么备份的怎么还原
10.3 SQL备份与还原
备份的是SQL语句: 系统会对表结构以及数据进行处理,变成对应的SQL语句, 然后进行备份: 还原的时候只要执行SQL指令即可.(主要就是针对表结构)
备份: mysql没有提供备份指令: 需要利用mysql提供的软件: mysqldump.exe
Mysqldump.exe也是一种客户端,需要操作服务器: 必须连接认证
Mysqldump/mysqldump.exe -hPup 数据库名字 [数据表名字1[ 数据表名字2...]] > 外部文件目录(建议使用.sql)
mysqldump用来把业务数据导出成SQL文件，其中也包括了表结构
mysqldump -uroot -p [no-data] 逻辑库 > 路径
不写no-data表示既包含表结构，又包含数据
单表备份
图形化操作如下，选中数据表，点击右键
整库备份
Mysqldump/mysqldump.exe -hPup 数据库名字 > 外部文件目录
对应图形化操作如下，选中数据库选中右键
SQL还原数据: 两种方式还原
方案1: 使用mysql.exe客户端还原
Mysql.exe/mysql -hPup 数据库名字 < 备份文件目录
方案2: 使用SQL指令还原
1.use选择数据库； 2.Source 备份文件所在路径;
对应图形化操作如下
SQL备份优缺点
优点: 可以备份结构
缺点: 会浪费空间(额外的增加SQL指令)
练习题
答案选A，语法记忆，注意标点符号。
10.4 增量备份
不是针对数据或者SQL指令进行备份: 是针对mysql服务器的日志文件进行备份
增量备份: 指定时间段开始进行备份., 备份数据不会重复, 而且所有的操作都会备份(大项目都用增量备份)
练习题
答案选C，C错在数据导出，导出的纯粹是业务数据。
10.5 大文件备份和还原(图形化操作，推荐！)
业务数据比较多的时候，只导出表结构到sql文件，业务数据文件导出到txt文件，这样就跳过了sql词法分析和语法优化，哪怕导入几千万条数据，也可以在1分钟内导入完毕
1.导出表结构
2.导出表中业务数据
3.删除表，为导入做准备
4.导入表结构
5.刷新后看到表结构
6.导入业务数据文件
7.刷新表即可看到导入成功
第11章 事务安全
事务: transaction, 一系列要发生的连续的操作
事务安全: 一种保护连续操作同时满足(实现)的一种机制
事务安全的意义: 保证数据操作的完整性
如果SQL语句直接操作文件是很危险的，比如你要给员工涨工资，正在update操作的时候，系统断电了，你就不知道谁已经涨了谁还没涨。
我们应该利用日志来间接写入。
MySQL总共5种日志，其中只有redo日志和undo日志与事务有关
日志就相当于数据文件的一个副本，SQL语句操作什么样的记录，MySQL就会把这些记录拷贝到undo日志，然后增删改查的操作就会记录到redo日志，最后把redo日志和数据库文件进行同步就行了。即使同步过程中断电了，有了redo日志的存在，重启MySQL数据库之后继续同步数据，同步成功后我们修改的数据就真正同步到数据库里面了，有事务的数据库抵抗风险的能力变强了。
RDBMS=SQL语句+事务(ACID)
事务是一个或者多个SQL语句组成的整体，要么全部执行成功，要么全部失败。
11.1 事务操作
事务操作分为两种: 自动事务(默认的), 手动事务
默认情况下，MySQL执行每条SQL语句都会自动开启和提交事务。为了让多条SQL语句纳入到一个事物之下，可以手动管理事务。
START TRANSACTION;
SQL语句
[COMMIT | ROLLBACK];
START TRANSACTION;
DELETE FROM t_emp;
DELETE FROM t_dept;
SELECT * FROM t_emp;
SELECT * FROM t_dept;开启事务: 告诉系统以下所有的操作(写)不要直接写入到数据表, 先存放到redo日志。
删除员工表t_emp和部门表t_dept之后，SQL语句查询两表的的数据均为空
但是去看数据表的数据却仍然存在，这是为什么呢？
因为你开启了事务，你现在的操作还在redo日志里面，并没有同步到数据库文件里面，你只有COMMIT之后才会同步
继续执行
COMMIT;去数据表查看，2张数据表都被清空了。
当然你也可以直接回滚，执行ROLLBACK；
ROLLBACK;这样你的redo日志被清空，下次操作的时候重新往redo日志里面进行操作，就不会受到上一次操作的影响。
11.2 自动事务处理
在mysql中: 默认的都是自动事务处理, 用户操作完会立即同步到数据表中.
自动事务: 系统通过autocommit变量控制
Show variables like ‘autocommit’;
关闭自动提交: set autocommit = off/0;
再次直接写操作
自动关闭之后,需要手动来选择处理: commit提交, rollback回滚
注意: 通常都会使用自动事务
11.3 事务原理
事务操作原理: 事务开启之后, 所有的操作都会临时保存到事务日志, 事务日志只有在得到commit命令才会同步到数据表,其他任何情况都会清空(rollback, 断电, 断开连接)
11.4 回滚点
回滚点: 在某个成功的操作完成之后, 后续的操作有可能成功有可能失败, 但是不管成功还是失败,前面操作都已经成功: 可以在当前成功的位置, 设置一个点: 可以供后续失败操作返回到该位置, 而不是返回所有操作, 这个点称之为回滚点.
设置回滚点语法: savepoint 回滚点名字;
回到回滚点语法: rollback to 回滚点名字;
11.5 事务ACID属性
关于事务的详细内容，我新写了一篇，可以跳转查看MySQL读取的记录和我想象的不一致——事物隔离级别和MVCC
A: Atomic原子性，一个事物中的所有操作要么全部完成，要么全部失败。事物执行后，不允许停留在中间某个状态。
C: Consistency一致性，不管在任何给定的时间，并发事务有多少，事务必须保证运行结果的一致性。事务可以并发执行，但是最终MySQL却串行执行。
怎么保证一致性？
阻止事务之间相互读取临时数据
I: Isolation隔离性，每个事务只能看到事务内的相关数据，别的事务的临时数据在当前事务是看不到的。隔离性要求事务不受其他并发事务的影响，在给定时间内，该事务是数据库运行的唯一事务。
如果事务没有隔离性，按照不受控制的顺序并发读取和修改数据，想像一下会出现哪些问题？
一、脏读：一个事务读取了第二个事物未提交的数据，当第二个事务回滚了数据之后，第一个事务就读取到了无效的数据。
如下图，事务1查询course_id=59的平均分score为9.2，而事务2此时将其平均分修改为9.6，当事务1再次读取的时候，平均分就变成了9.6，此时事务2回滚，事务1就是读取的无效数据，简称脏读。
二、不可重复读：一个事物前后两次读取的同一数据不一致。
如下图，事务1查询course_id=59的平均分score为9.6，而事务2此时将其平均分修改为9.7，并将修改提交，当事务1再次读取的时候，平均分就变成了9.7，事务1就是读取的错误数据，注意，不可重复读和脏读的区别就是，脏读的数据会回滚，不可重复读会把数据提交，脏读的数据是无效的，而不可重复读因为事务2的提交，数据是有效的。
三、幻读：指一个事务两次查询的结果集记录数不一致
如下图，事务1查询到平均分在9.5到9.8之间的记录数是2条，经过事务2对course_id=43的平均分修改，导致事务1第二次查询的记录数为3条，这种情况就叫幻读，幻读的数据最终也是有效的数据。
innodb的事务隔离性保证了我们事务操作的安全，才让我们实际操作中并没有出现这么多问题。
怎么保证隔离性？
综上所述，我们简单总结下
脏读：事务 A 读取了事务 B 当前更新的数据，但是事务 B 出现了回滚或未提交修改，事务 A 读到的数据就被称为 “脏数据”。通常情况下，使用 “脏数据” 会造成系统数据不一致，出现错误
不可重复读：事务 A 在执行过程中多次读取同一数据，但是事务 B 在事务 A 的读取过程中对数据做了多次修改并提交，则会导致事务 A 多次读取的数据不一致，进而无法做出准确性判断
幻读：事务 A 在执行过程中读取了一些数据，但是事务 B 随即插入了一些数据，那么，事务 A 重新读取时，发现多了一些原本不存在的数据，就像是幻觉一样，称之为幻读
仔细品味，可以发现，不可重复读与幻读从概念上来说，是非常相似的。区分它们只要记住：不可重复读指的是对原来存在的数据做修改，而幻读指的是新增或者删除数据。
undo和redo日志中的数据都会被标记属于哪个事务的，所以事务执行过程中就只能读到自己的临时数据了。
D: Durability持久性，事务一旦提交，结果便是永久性的。即便发生宕机，仍然可依靠事务日志完成数据持久化。
锁机制: innodb默认是行锁, 但是如果在事务操作的过程中, 没有使用到索引,那么系统会自动全表检索数据, 自动升级为表锁
行锁: 只有当前行被锁住, 别的用户不能操作
表锁: 整张表被锁住, 别的用户都不能操作
11.6 事务的隔离级别
在某些特定场合，我们又想让事务之间读取到一些临时数据，这就需要修改事务的隔离级别
设置事务隔离级别的语法如下：
SET [PERSIST|GLOBAL|SESSION]
TRANSACTION ISOLATION LEVEL
{
READ UNCOMMITTED | READ COMMITTED
| REPEATABLE READ
| SERIALIZABLE
}
-- PERSIST:所有连接到mysql服务的新的连接都有效，并且mysql服务器重启后也不会丢失修改
-- GLOCAL: 所有连接到mysql服务的新的连接都有效，但是mysql服务器重启后会丢失这个修改
-- SESSION：开发最常用，只会影响到当前连接，当前连接断开，这个隔离级别的修改就会丢失
-- 开发中也可以用show variables like '%iso%'查看当前session的隔离级别
-- 因为有一个变量参数名为transaction_isolation11.6.1 read uncommitted
场景一：比如买票的场景，逢年过节都需要买票回家，假如A和B都在买同一辆车的车票，此时还剩最后一张票，A点击购买，但是还没付款提交，因为查看不到事务之间的临时数据，所以B查看时，也还剩一张票，于是B点击购买，立即付款提交，结果A就会购买失败。所以理想的情况应该是，当A点击购买去付款时，B应该看得到这个临时数据，显示没有票才对。这种场景会出现脏读、幻读、不可重复读情况，隔离性最低，并发性最高。
eg1：查看事务之间能否读取未提交的数据
START TRANSACTION;
UPDATE t_emp SET sal=1;此时开启事务1并进行更新操作，但是没有commit
再开启一个事务2
START TRANSACTION;
SELECT empno, ename, sal FROM t_emp;
COMMIT;注意：这里没有修改数据，仅仅只是select查询数据，redo日志没有改变，所以不会做同步到文件的操作，commit之后会清空对应的undo日志数据。
结果显示如下，前者在事务1中修改sal为1，事务2中却看不到。
如果修改事务2隔离级别，如下
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; /*代表可以读取其他事务未提交的数据*/
START TRANSACTION;
SELECT empno, ename, sal FROM t_emp;
COMMIT;
结果立马就变了，事务2能够读取事务1未提交的数据，但是要注意，因为前者并未commit，所以数据库表文件的数据还没有修改
11.6.2 read committed
场景二：银行转账的场景，A事务执行往Scott账户转账1000的操作，B事务执行扣除Scott账户100块的操作，如果A能读取到B事务未提交的数据，那么转账后就会修改为5900，而此时因为各种原因需要回滚支出100元的这个操作，此时账户就只有5900块了，凭空消失100块，所以只有A事务读取到B事务提交后的数据才能保证转账的正确性。这种场景就和买票的场景完全不同。这种场景是会出现幻读和不可重复读的。
还是eg1的例子，此时修改隔离级别的SQL语句即可
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;/*只能读取其他事务提交的数据*/
START TRANSACTION;
SELECT empno, ename, sal FROM t_emp;
COMMIT;
其他事物提交的数据都会同步到数据库表文件中，所以这里就是从数据库表文件中读取的数据。
11.6.3 repeatable read
场景三：你在淘宝或者京东等电商，点击购买，选好收货地址之类的之后，点击提交订单，就会让你输入支付密码支付，此时显示的价格是undo日志的价格，如果此时卖家涨价，你购买的还是涨价之前的价格，这种场景就是可重复读。可重复读不会出现脏读、不可重复读的情况，因为事务1读取不到事务2对数据的修改。对于幻读，只有靠锁或者serializable隔离级别下才能保证不出现幻读的问题。在应用中，你可以考虑使用Redis分布式锁在java层面杜绝幻读的可能。
新建一个查询，开启事务1
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;/*事务在执行中反复读取数据，得到的结果是一致的*/
START TRANSACTION;
SELECT empno, ename, sal FROM t_emp;这里一定要先执行一次select语句，保证undo日志拷贝过一次数据
再新建一个查询，开启事务2
START TRANSACTION;
UPDATE t_emp SET sal=1;此时数据库表文件的数据如下
此时在事务1执行SELECT empno, ename, sal FROM t_emp;
虽然数据库表文件的数据已经修改了，但是事务1处的事务隔离级别是可以反复读，每次都从undo日志里面读取，所以这里还是修改前的价格，直到提交commit，commit之后清空对应的undo日志记录，下次会重新从数据库文件里面拷贝数据，那个时候才是sal=1的数据。
注意：MySQL默认事务隔离级别就是REPEATABLE READ
11.6.4 serializable
由于事务并发执行所带来的各种问题，前三种隔离级别只适用于在某种业务场景中，凡事序列化的隔离性，让事务逐一执行，就不会产生上述问题了。但是序列化的隔离级别使用的特别少，它让事务的并发性大大降低。可重复读不会出现幻读、脏读、不可重复读的情况，因为事务1读取不到事务2对数据的修改。隔离性最高，并发性最低，其实就是没有并发，所有事务按照顺序执行。
开始事务1，sql语句如下
START TRANSACTION;
UPDATE t_emp SET sal=2;开始事务2，sql语句如下
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;/*事务序列化*/
START TRANSACTION;
SELECT empno, ename, sal FROM t_emp;但是这行sql之后并没有出结果
直到你的事务1执行commit之后，事务2就会立即执行查询结果。
针对这4种隔离级别与脏读幻读不可重复读的关系如下：
第12章 触发器
触发器: trigger, 事先为某张表绑定好一段代码 ,当表中的某些内容发生改变的时候(增删改)系统会自动触发代码,执行.
触发器: 事件类型, 触发时间, 触发对象
事件类型: 增删改, 三种类型insert,delete和update
触发时间: 前后: before和after
触发对象: 表中的每一条记录(行)
一张表中只能拥有一种触发时间的一种类型的触发器: 最多一张表能有6个触发器
12.1 创建触发器
在mysql高级结构中: 没有大括号, 都是用对应的字符符号代替
触发器基本语法
-- 临时修改语句结束符
Delimiter 自定义符号: 后续代码中只有碰到自定义符号才算结束
Create trigger 触发器名字 触发时间 事件类型 on 表名 for each row
Begin -- 代表左大括号: 开始
-- 里面就是触发器的内容: 每行内容都必须使用语句结束符: 分号
End -- 代表右带括号: 结束
-- 语句结束符
自定义符号
-- 将临时修改修正过来
Delimiter ;
12.2 查看触发器
查看所有触发器或者模糊匹配
Show triggers [like ‘pattern’];
\g 的作用是分号和在sql语句中写’;’是等效的
\G 的作用是将查到的结构旋转90度变成纵向
可以查看触发器创建语句
Show create trigger 触发器名字;
所有的触发器都会保存一张表中: Information_schema.triggers
12.3 使用触发器
触发器: 不需要手动调用, 而是当某种情况发生时会自动触发.(订单里面插入记录之后)
12.4 修改触发器&删除触发器
触发器不能修改,只能先删除,后新增.
Drop trigger 触发器名字;
12.5 触发器记录
触发器记录: 不管触发器是否触发了,只要当某种操作准备执行, 系统就会将当前要操作的记录的当前状态和即将执行之后新的状态给分别保留下来, 供触发器使用: 其中, 要操作的当前状态保存到old中, 操作之后的可能形态保存给new.
Old代表的是旧记录,new代表的是新记录
删除的时候是没有new的; 插入的时候是没有old
Old和new都是代表记录本身: 任何一条记录除了有数据, 还有字段名字.
使用方式: old.字段名 / new.字段名(new代表的是假设发生之后的结果)
查看触发器的效果
如果触发器内部只有一条要执行的SQL指令, 可以省略大括号(begin和end)
Create trigger 触发器名字 触发时间 事件类型 on 表名 for each row
一条SQL指令;
触发器: 可以很好的协调表内部的数据处理顺序和关系. 但是从JAVA角度出发, 触发器会增加数据库维护的难度, 所以较少使用触发器.
第13章 函数
13.1 数字函数
eg：求四舍五入
select round(4.6288*100)/100;
13.2 日期函数
13.2.1 获取系统时间函数
NOW()函数能获得系统日期和时间，格式yyyy-MM-dd hh:mm:ss，数据库的最小时间单位是秒s，而不是毫秒ms
CURDATE()函数能获得当前系统日期，格式yyyy-MM-dd
CURTIME()函数能获得当前系统时间，格式hh:mm:ss
SELECT NOW(), CURDATE(), CURTIME();
13.2.2 日期格式化函数
DATE_FORMAT(日期, 表达式)
该函数用于格式化日期，返回用户想要的日期格式
eg：比如查看员工入职的年份
SELECT ename, DATE_FORMAT(hiredate,"%Y") AS result FROM t_emp;占位符说明
eg：查询某个日期是星期几
SELECT DATE_FORMAT("2021-1-1","%w");
结果是星期5，如果是大写%W，那么就输出英文Friday
eg：利用日期函数，查询1981年上半年入职的员工有多少个
SELECT COUNT(*) FROM t_emp
WHERE DATE_FORMAT(hiredate,"%Y")=1981
AND DATE_FORMAT(hiredate,"%m")<=6;
练习题
答案选A，语法基础。
13.2.3 日期偏移计算
注意：MySQL数据库里面，两个日期不能直接加减，日期也不能与数字加减
比如 select hiredate+1 from t_emp;
其实hiredate是"1980-12-18"变成了19801218，然后+1，结果是19801219
DATE_ADD(日期, INTERVAL 偏移量 偏移的时间单位)
该函数可以实现日期的偏移计算，而且时间单位很灵活
举几个例子
/*100天之后是什么时间*/
SELECT DATE_ADD(NOW(), INTERVAL 100 DAY);
/*300分钟之前是什么时间*/
SELECT DATE_ADD(NOW(), INTERVAL -300 MINUTE);
/*6个月零3天之前是什么时间*/
SELECT DATE_ADD(DATE_ADD(NOW(),INTERVAL -6 MONTH),INTERVAL -3 DAY)把日期偏移函数和日期格式化函数混合用一下
eg：6个月零3天之前是什么时间，保留年月日即可
SELECT
DATE_FORMAT(DATE_ADD(DATE_ADD(NOW(),INTERVAL -6 MONTH), INTERVAL -3 DAY), "%Y/%m/%d"); 
13.2.4 计算日期之间相隔的天数
DATEDIFF(日期1, 日期2)
该函数用来计算两个日期之间相差的天数为日期1-日期2。
eg：比如计算现在和2019-1-1相差多少天
SELECT DATEDIFF(NOW(),"2019-1-1"); 
2019-1-1已经是707天之前了。
13.3 字符函数
eg：查询员工表中姓名小写、姓名大写、姓名包含的字符数、底薪末尾添加$，姓名包含有A
SELECT
LOWER(ename), UPPER(ename), LENGTH(ename),
CONCAT(sal,"$"),INSTR(ename,"A")
FROM t_emp;
这里对于汉字，LOWER和UPPER函数是没有转换作用的，对于LENGTH函数，因为这里的数据库编码是UTF8字符集，所以一个汉字占3个字节，长度为6，INSTR函数会返回首次出现A的位置，从1开始，如果没有包含A，则返回0。
INSERT例子
/*插入"先生"并替换从1开始的3个字符*/
SELECT INSERT("女士早上好", 1, 3, "先生"); 
REPLACE例子
SELECT REPLACE("女士早上好","女士","先生"); 
SUBSTR、SUBSTRING、LPAD、TRIM例子
SELECT SUBSTR("你好世界", 3, 4), SUBSTRING("你好世界", 3, 2),
LPAD(SUBSTRING("13312345678", 8, 4),11,"*"),
TRIM(" Hello World ");
说明：SUBSTR("你好世界", 3, 4)表示获取从1开始下标为[3,4]闭区间位置子串，SUBSTRING("13312345678", 8, 4)表示获取从下标8开始后面的4个字符，LPAD(SUBSTRING("13312345678", 8, 4),11,"*")表示子串将由"*"左填充到11个字符的长度，TRIM就是去除首尾空格。
练习题
答案选C，A项错在直接把最后4位也用*替代了，B错在substring下标从1开始，D错在是rpad而不是lpad。
13.4 条件函数
13.4.1 简单条件判断
SQL语句可以利用条件函数来实现编程语言里的条件判断
IFNULL(表达式, 值)
IF(表达式, 值1, 值2)
eg：SALES部门发放礼品A，其余部门发放礼品B，打印每名员工获得的礼品
SELECT
e.empno, e.ename, d.dname,
IF(d.dname="SALES","礼品A","礼品B")
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno;
练习题
答案选D，A错在as写成逗号，B错在函数用错，if也是3个参数，C错在入学日期和系号之间没有逗号分隔。
答案选A，B错在函数错用ifnull，并且ifnull也是2个参数而不是3个，C错在if函数里面的相框参数填写反了，D错在根们没有打印相框类型。
13.4.2 复杂条件判断
复杂的条件判断可以用条件语句来实现，比IF语句功能更强大
CASE
WHEN 表达式 THEN 值1
WHEN 表达式 THEN 值2
...
ELSE 值N
END
eg：公司集体旅游，每个部门目的地不同，SALES部门去P1地点，ACCOUNTING部门去P2地点，RESEARCH部门去P3地点，查询每名员工的旅行地点。
SELECT
e.empno, e.ename,
CASE
WHEN d.dname="SALES" THEN "p1"
WHEN d.dname="ACCOUNTING" THEN "p2"
WHEN d.dname="RESEARCH" THEN "P3"
END AS place
FROM t_emp e JOIN t_dept d ON e.deptno=d.deptno;
eg：公司调整员工基本工资，具体方案如下：
1.SALES部门中工龄超过20年，涨幅10%
2.SALES部门中工龄不满20年，涨幅5%
3.ACCOUNTING部门，涨幅300
4.RESEARCH部门里低于部门平均底薪，涨幅200
5.没有部门的员工，涨幅100
UPDATE t_emp e LEFT JOIN t_dept d ON e.deptno=d.deptno
LEFT JOIN (SELECT deptno, AVG(sal) avg FROM t_emp GROUP BY deptno) t
ON e.deptno=d.deptno
SET sal=(
CASE
WHEN d.dname="SALES" AND DATEDIFF(NOW(),e.hiredate)/365>=20
THEN e.sal*1.1
WHEN d.dname="SALES" AND DATEDIFF(NOW(),e.hiredate)/365<20
THEN e.sal*1.05
WHEN d.dname="ACCOUNTING" THEN e.sal+300
WHEN d.dname="RESEARCH" AND e.sal<t.avg THEN e.sal+200
WHEN e.deptno IS NULL THEN e.sal+100
ELSE e.sal
END
);
13.5 自定义函数
函数要素: 函数名, 参数列表(形参和实参), 返回值, 函数体(作用域)
13.5.1 创建函数
创建语法
Create function 函数名([形参列表]) returns 数据类型 -- 规定要返回的数据类型
Begin
-- 函数体
-- 返回值: return 类型(指定数据类型);
End
定义函数
自定义函数与系统函数的调用方式是一样: select 函数名([实参列表]);
13.5.2 查看函数
查看所有函数: show function status [like ‘pattern’];
查看函数的创建语句: show create function 函数名;
13.5.3 修改函数&删除函数
函数只能先删除后新增,不能修改.
Drop function 函数名;
13.5.4 函数参数
参数分为两种: 定义时的参数叫形参, 调用时的参数叫实参(实参可以是数值也可以是变量)
形参: 要求必须指定数据类型
Function 函数名(形参名字 字段类型) returns 数据类型
在函数内部使用@定义的变量在函数外部也可以访问
13.5.5 作用域
Mysql中的作用域与js中的作用域完全一样
全局变量可以在任何地方使用; 局部变量只能在函数内部使用.
全局变量: 使用set关键字定义, 使用@符号标志
局部变量: 使用declare关键字声明, 没有@符号: 所有的局部变量的声明,必须在函数体开始之前
第14章 存储过程
存储过程简称过程,procedure, 是一种用来处理数据的方式.
存储过程是一种没有返回值的函数.
14.1 创建过程
Create procedure 过程名字([参数列表])
Begin
-- 过程体
End
14.2 查看过程
函数的查看方式完全适用于过程: 关键字换成procedure
查看所有过程: show procedure status [like ‘pattern’];
查看过程创建语句: show create procedure 过程名;
14.3 调用过程
过程没有返回值: select是不能访问的.
过程有一个专门的调用关键字: call
14.4 修改过程&删除过程
过程只能先删除,后新增
Drop procedure 过程名;
/* 这是我某次模拟插入10W条数据的过程代码，仅供参考 */
create PROCEDURE p1()
BEGIN
DECLARE i int;
set i = 1;
WHILE i <= 100000 DO
INSERT INTO `demo_info`(key1, key2, key3, key_part1, key_part2, key_part3, common_field) VALUES ( 'a', i, 'a', '1可', 'b', 'a', '123是');
set i = i + 1;
END WHILE;
END;
DROP PROCEDURE p1;
start TRANSACTION;
CALL p1();
COMMIT;14.5 过程参数
函数的参数需要数据类型指定, 过程比函数更严格.
过程还有自己的类型限定: 三种类型
In: 数据只是从外部传入给内部使用(值传递): 可以是数值也可以是变量
Out: 只允许过程内部使用(不用外部数据), 给外部使用的.(引用传递: 外部的数据会被先清空才会进入到内部): 只能是变量
Inout: 外部可以在内部使用,内部修改也可以给外部使用: 典型的引用传递: 只能传变量
基本使用
Create procedure 过程名(in 形参名字 数据类型, out 形参名字 数据类型, inout 形参名字 数据类型)
调用: out和inout类型的参数必须传入变量,而不能是数值
正确调用: 传入变量
存储过程对于变量的操作(返回)是滞后的: 是在存储过程调用结束的时候,才会重新将内部修改的值赋值给外部传入的全局变量.
测试: 传入数据1,2,3: 说明局部变量与全局变量无关
最后: 在存储过程调用结束之后, 系统会将局部变量重复返回给全局变量(out和inout)
关注、留言，我们一起学习。
===============Talk is cheap, show me the code================
748
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
