MySQL基础（一）下

7种 SQL JOINS 的实现

代码实现

#中图：内连接 A∩B
SELECT employee_id,last_name,department_name
FROM employees e JOIN departments d
ON e.`department_id` = d.`department_id`;

#左上图：左外连接
SELECT employee_id,last_name,department_name
FROM employees e LEFT JOIN departments d
ON e.`department_id` = d.`department_id`;

#右上图：右外连接
SELECT employee_id,last_name,department_name
FROM employees e RIGHT JOIN departments d
ON e.`department_id` = d.`department_id`;

#右上图：右外连接
SELECT employee_id,last_name,department_name
FROM employees e RIGHT JOIN departments d
ON e.`department_id` = d.`department_id`;

#左中图：A - A∩B
SELECT employee_id,last_name,department_name
FROM employees e LEFT JOIN departments d
ON e.`department_id` = d.`department_id`
WHERE d.`department_id` IS NULL

#右中图：B-A∩B
SELECT employee_id,last_name,department_name
FROM employees e RIGHT JOIN departments d
ON e.`department_id` = d.`department_id`
WHERE e.`department_id` IS NULL

#左下图：满外连接
# 左中图 + 右上图  A∪B
SELECT employee_id,last_name,department_name
FROM employees e LEFT JOIN departments d
ON e.`department_id` = d.`department_id`
WHERE d.`department_id` IS NULL
UNION ALL  #没有去重操作，效率高
SELECT employee_id,last_name,department_name
FROM employees e RIGHT JOIN departments d
ON e.`department_id` = d.`department_id`;

#右下图
#左中图 + 右中图  A ∪B- A∩B 或者 (A -  A∩B) ∪ （B - A∩B）
SELECT employee_id,last_name,department_name
FROM employees e LEFT JOIN departments d
ON e.`department_id` = d.`department_id`
WHERE d.`department_id` IS NULL
UNION ALL
SELECT employee_id,last_name,department_name
FROM employees e RIGHT JOIN departments d
ON e.`department_id` = d.`department_id`
WHERE e.`department_id` IS NULL

语法格式小结

左中图

#实现A -  A∩B
select 字段列表
from A表 left join B表
on 关联条件
where 从表关联字段 is null and 等其他子句;

右中图

#实现B -  A∩B
select 字段列表
from A表 right join B表
on 关联条件
where 从表关联字段 is null and 等其他子句;

左下图

#实现查询结果是A∪B
#用左外的A，union 右外的B
select 字段列表
from A表 left join B表
on 关联条件
where 等其他子句
union 
select 字段列表
from A表 right join B表
on 关联条件
where 等其他子句;

右下图

#实现A∪B -  A∩B  或   (A -  A∩B) ∪ （B - A∩B）
#使用左外的 (A -  A∩B)  union 右外的（B - A∩B）
select 字段列表
from A表 left join B表
on 关联条件
where 从表关联字段 is null and 等其他子句
union
select 字段列表
from A表 right join B表
on 关联条件
where 从表关联字段 is null and 等其他子句

SQL99语法新特性

自然连接

SQL99 在 SQL92 的基础上提供了一些特殊语法，比如 NATURAL JOIN 用来表示自然连接。我们可以把自然连接理解为 SQL92 中的等值连接。它会帮你自动查询两张连接表中所有相同的字段，然后进行等值连接。

在SQL92标准中：

SELECT employee_id,last_name,department_name
FROM employees e JOIN departments d
ON e.`department_id` = d.`department_id`
AND e.`manager_id` = d.`manager_id`;

在 SQL99 中你可以写成：

SELECT employee_id,last_name,department_name
FROM employees e NATURAL JOIN departments d;

USING 连接

当我们进行连接的时候，SQL99还支持使用 USING 指定数据表里的同名字段进行等值连接。但是只能配合JOIN一起使用。比如：

SELECT employee_id,last_name,department_name
FROM employees e JOIN departments d
USING (department_id);

你能看出与自然连接 NATURAL JOIN 不同的是，USING 指定了具体的相同的字段名称，你需要在 USING 的括号 () 中填入要指定的同名字段。同时使用 JOIN...USING 可以简化 JOIN ON 的等值连接。它与下面的 SQL 查询结果是相同的：

SELECT employee_id,last_name,department_name
FROM employees e ,departments d
WHERE e.department_id = d.department_id;

章节小结

表连接的约束条件可以有三种方式：WHERE, ON, USING

WHERE：适用于所有关联查询

ON：只能和JOIN一起使用，只能写关联条件。虽然关联条件可以并到WHERE中和其他条件一起写，但分开写可读性更好。

USING：只能和JOIN一起使用，而且要求两个关联字段在关联表中名称一致，而且只能表示关联字段值相等

#关联条件
#把关联条件写在where后面
SELECT last_name,department_name 
FROM employees,departments 
WHERE employees.department_id = departments.department_id;
#把关联条件写在on后面，只能和JOIN一起使用
SELECT last_name,department_name 
FROM employees INNER JOIN departments 
ON employees.department_id = departments.department_id;
SELECT last_name,department_name 
FROM employees CROSS JOIN departments 
ON employees.department_id = departments.department_id;
SELECT last_name,department_name  
FROM employees JOIN departments 
ON employees.department_id = departments.department_id;
#把关联字段写在using()中，只能和JOIN一起使用
#而且两个表中的关联字段必须名称相同，而且只能表示=
#查询员工姓名与基本工资
SELECT last_name,job_title
FROM employees INNER JOIN jobs USING(job_id);
#n张表关联，需要n-1个关联条件
#查询员工姓名，基本工资，部门名称
SELECT last_name,job_title,department_name FROM employees,departments,jobs 
WHERE employees.department_id = departments.department_id 
AND employees.job_id = jobs.job_id;
SELECT last_name,job_title,department_name 
FROM employees INNER JOIN departments INNER JOIN jobs 
ON employees.department_id = departments.department_id 
AND employees.job_id = jobs.job_id;

注意：

我们要控制连接表的数量。多表连接就相当于嵌套 for 循环一样，非常消耗资源，会让 SQL 查询性能下降得很严重，因此不要连接不必要的表。在许多 DBMS 中，也都会有最大连接表的限制。

【强制】超过三个表禁止 join。需要 join 的字段，数据类型保持绝对一致；多表关联查询时，保证被关联的字段需要有索引。

说明：即使双表 join 也要注意表索引、SQL 性能。

来源：阿里巴巴《Java开发手册》

附录：常用的 SQL 标准有哪些

在正式开始讲连接表的种类时，我们首先需要知道 SQL 存在不同版本的标准规范，因为不同规范下的表连接操作是有区别的。

SQL 有两个主要的标准，分别是 SQL92 和 SQL99。92 和 99 代表了标准提出的时间，SQL92 就是 92 年提出的标准规范。当然除了 SQL92 和 SQL99 以外，还存在 SQL-86、SQL-89、SQL:2003、SQL:2008、SQL:2011 和 SQL:2016 等其他的标准。

这么多标准，到底该学习哪个呢？实际上最重要的 SQL 标准就是 SQL92 和 SQL99。一般来说 SQL92 的形式更简单，但是写的 SQL 语句会比较长，可读性较差。而 SQL99 相比于 SQL92 来说，语法更加复杂，但可读性更强。我们从这两个标准发布的页数也能看出，SQL92 的标准有 500 页，而 SQL99 标准超过了 1000 页。实际上从 SQL99 之后，很少有人能掌握所有内容，因为确实太多了。就好比我们使用 Windows、Linux 和 Office 的时候，很少有人能掌握全部内容一样。我们只需要掌握一些核心的功能，满足日常工作的需求即可。

**SQL92 和 SQL99 是经典的 SQL 标准，也分别叫做 SQL-2 和 SQL-3 标准。**也正是在这两个标准发布之后，SQL 影响力越来越大，甚至超越了数据库领域。现如今 SQL 已经不仅仅是数据库领域的主流语言，还是信息领域中信息处理的主流语言。在图形检索、图像检索以及语音检索中都能看到 SQL 语言的使用。

单行函数

函数的理解

什么是函数

函数在计算机语言的使用中贯穿始终，函数的作用是什么呢？它可以把我们经常使用的代码封装起来，需要的时候直接调用即可。这样既提高了代码效率，又提高了可维护性。在 SQL 中我们也可以使用函数对检索出来的数据进行函数操作。使用这些函数，可以极大地提高用户对数据库的管理效率。

从函数定义的角度出发，我们可以将函数分成内置函数和自定义函数。在 SQL 语言中，同样也包括了内置函数和自定义函数。内置函数是系统内置的通用函数，而自定义函数是我们根据自己的需要编写的，本章及下一章讲解的是 SQL 的内置函数。

不同DBMS函数的差异

我们在使用 SQL 语言的时候，不是直接和这门语言打交道，而是通过它使用不同的数据库软件，即 DBMS。DBMS 之间的差异性很大，远大于同一个语言不同版本之间的差异。实际上，只有很少的函数是被 DBMS 同时支持的。比如，大多数 DBMS 使用（||）或者（+）来做拼接符，而在 MySQL 中的字符串拼接函数为concat()。大部分 DBMS 会有自己特定的函数，这就意味着采用 SQL 函数的代码可移植性是很差的，因此在使用函数的时候需要特别注意。

MySQL的内置函数及分类

MySQL提供了丰富的内置函数，这些函数使得数据的维护与管理更加方便，能够更好地提供数据的分析与统计功能，在一定程度上提高了开发人员进行数据分析与统计的效率。

MySQL提供的内置函数从实现的功能角度可以分为数值函数、字符串函数、日期和时间函数、流程控制函数、加密与解密函数、获取MySQL信息函数、聚合函数等。这里，我将这些丰富的内置函数再分为两类：单行函数、聚合函数（或分组函数）。

两种SQL函数

单行函数

操作数据对象

接受参数返回一个结果

只对一行进行变换

每行返回一个结果

可以嵌套

参数可以是一列或一个值

数值函数

基本函数

举例：

SELECT ABS(-123),ABS(32),SIGN(-23),SIGN(43),PI(),CEIL(32.32),CEILING(-43.23),FLOOR(32.32),
FLOOR(-43.23),MOD(12,5)
FROM DUAL;

SELECT RAND(),RAND(),RAND(10),RAND(10),RAND(-1),RAND(-1)
FROM DUAL;

SELECT ROUND(12.33),ROUND(12.343,2),ROUND(12.324,-1),TRUNCATE(12.66,1),TRUNCATE(12.66,-1)
FROM DUAL;

角度与弧度互换函数

函数	用法
RADIANS(x)	将角度转化为弧度，其中，参数x为角度值
DEGREES(x)	将弧度转化为角度，其中，参数x为弧度值

SELECT RADIANS(30),RADIANS(60),RADIANS(90),DEGREES(2*PI()),DEGREES(RADIANS(90))
FROM DUAL;

三角函数

举例：

ATAN2(M,N)函数返回两个参数的反正切值。

与ATAN(X)函数相比，ATAN2(M,N)需要两个参数，例如有两个点point(x1,y1)和point(x2,y2)，使用ATAN(X)函数计算反正切值为ATAN((y2-y1)/(x2-x1))，使用ATAN2(M,N)计算反正切值则为ATAN2(y2-y1,x2-x1)。由使用方式可以看出，当x2-x1等于0时，ATAN(X)函数会报错，而ATAN2(M,N)函数则仍然可以计算。

ATAN2(M,N)函数的使用示例如下：

SELECT SIN(RADIANS(30)),DEGREES(ASIN(1)),TAN(RADIANS(45)),DEGREES(ATAN(1)),DEGREES(ATAN2(1,1))
FROM DUAL;

指数与对数

mysql> SELECT POW(2,5),POWER(2,4),EXP(2),LN(10),LOG10(10),LOG2(4)
    -> FROM DUAL;
+----------+------------+------------------+-------------------+-----------+---------+
| POW(2,5) | POWER(2,4) | EXP(2)           | LN(10)            | LOG10(10) | LOG2(4) |
+----------+------------+------------------+-------------------+-----------+---------+
|       32 |         16 | 7.38905609893065 | 2.302585092994046 |         1 |       2 |
+----------+------------+------------------+-------------------+-----------+---------+
1 row in set (0.00 sec)

进制间的转换

mysql> SELECT BIN(10),HEX(10),OCT(10),CONV(10,2,8)
    -> FROM DUAL;
+---------+---------+---------+--------------+
| BIN(10) | HEX(10) | OCT(10) | CONV(10,2,8) |
+---------+---------+---------+--------------+
| 1010    | A       | 12      | 2            |
+---------+---------+---------+--------------+
1 row in set (0.00 sec)

字符串函数

mysql> SELECT FIELD('mm','hello','msm','amma'),FIND_IN_SET('mm','hello,mm,amma')
    -> FROM DUAL;
+----------------------------------+-----------------------------------+
| FIELD('mm','hello','msm','amma') | FIND_IN_SET('mm','hello,mm,amma') |
+----------------------------------+-----------------------------------+
|                                0 |                                 2 |
+----------------------------------+-----------------------------------+
1 row in set (0.00 sec)

mysql> SELECT NULLIF('mysql','mysql'),NULLIF('mysql', '');
+-------------------------+---------------------+
| NULLIF('mysql','mysql') | NULLIF('mysql', '') |
+-------------------------+---------------------+
| NULL                    | mysql               |
+-------------------------+---------------------+
1 row in set (0.00 sec)

日期和时间函数

获取日期、时间

举例：

SELECT CURDATE(),CURTIME(),NOW(),SYSDATE()+0,UTC_DATE(),UTC_DATE()+0,UTC_TIME(),UTC_TIME()+0
FROM DUAL;

日期与时间戳的转换

举例：

mysql> SELECT UNIX_TIMESTAMP(now());
+-----------------------+
| UNIX_TIMESTAMP(now()) |
+-----------------------+
|            1576380910 |
+-----------------------+
1 row in set (0.01 sec)
mysql> SELECT UNIX_TIMESTAMP(CURDATE());
+---------------------------+
| UNIX_TIMESTAMP(CURDATE()) |
+---------------------------+
|                1576339200 |
+---------------------------+
1 row in set (0.00 sec)
mysql> SELECT UNIX_TIMESTAMP(CURTIME());
+---------------------------+
| UNIX_TIMESTAMP(CURTIME()) |
+---------------------------+
|                1576380969 |
+---------------------------+
1 row in set (0.00 sec)
mysql> SELECT UNIX_TIMESTAMP('2011-11-11 11:11:11')
+---------------------------------------+
| UNIX_TIMESTAMP('2011-11-11 11:11:11') |
+---------------------------------------+
|                            1320981071 |
+---------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT FROM_UNIXTIME(1576380910);
+---------------------------+
| FROM_UNIXTIME(1576380910) |
+---------------------------+
| 2019-12-15 11:35:10       |
+---------------------------+
1 row in set (0.00 sec)

获取月份、星期、星期数、天数等函数

举例：

SELECT YEAR(CURDATE()),MONTH(CURDATE()),DAY(CURDATE()),
HOUR(CURTIME()),MINUTE(NOW()),SECOND(SYSDATE())
FROM DUAL;

SELECT MONTHNAME('2021-10-26'),DAYNAME('2021-10-26'),WEEKDAY('2021-10-26'),
QUARTER(CURDATE()),WEEK(CURDATE()),DAYOFYEAR(NOW()),
DAYOFMONTH(NOW()),DAYOFWEEK(NOW())
FROM DUAL;

日期的操作函数

函数	用法
EXTRACT(type FROM date)	返回指定日期中特定的部分，type指定返回的值

EXTRACT(type FROM date)函数中type的取值与含义：

SELECT EXTRACT(MINUTE FROM NOW()),EXTRACT( WEEK FROM NOW()),

EXTRACT( QUARTER FROM NOW()),EXTRACT( MINUTE_SECOND FROM NOW())

FROM DUAL;

函数	用法
TIME_TO_SEC(time)	将 time 转化为秒并返回结果值。转化的公式为：`小时3600+分钟60+秒`
SEC_TO_TIME(seconds)	将 seconds 描述转化为包含小时、分钟和秒的时间

举例：

mysql> SELECT TIME_TO_SEC(NOW());
+--------------------+
| TIME_TO_SEC(NOW()) |
+--------------------+
|               78774 |
+--------------------+
1 row in set (0.00 sec)

mysql> SELECT SEC_TO_TIME(78774);
+--------------------+
| SEC_TO_TIME(78774) |
+--------------------+
| 21:52:54            |
+--------------------+
1 row in set (0.12 sec)

计算日期和时间的函数

第1组：

函数用法

DATE_ADD(datetime, INTERVAL expr type)，ADDDATE(date,INTERVAL expr type) 返回与给定日期时间相差INTERVAL时间段的日期时间

DATE_SUB(date,INTERVAL expr type)，SUBDATE(date,INTERVAL expr type) 返回与date相差INTERVAL时间间隔的日期

上述函数中type的取值：

举例：

SELECT DATE_ADD(NOW(), INTERVAL 1 DAY) AS col1,DATE_ADD('2021-10-21 23:32:12',INTERVAL 1 SECOND) AS col2,
ADDDATE('2021-10-21 23:32:12',INTERVAL 1 SECOND) AS col3,
DATE_ADD('2021-10-21 23:32:12',INTERVAL '1_1' MINUTE_SECOND) AS col4,
DATE_ADD(NOW(), INTERVAL -1 YEAR) AS col5, #可以是负数
DATE_ADD(NOW(), INTERVAL '1_1' YEAR_MONTH) AS col6 #需要单引号
FROM DUAL;

SELECT DATE_SUB('2021-01-21',INTERVAL 31 DAY) AS col1,
SUBDATE('2021-01-21',INTERVAL 31 DAY) AS col2,
DATE_SUB('2021-01-21 02:01:01',INTERVAL '1 1' DAY_HOUR) AS col3
FROM DUAL;

第2组：

举例：

SELECT ADDTIME(NOW(),20),SUBTIME(NOW(),30),SUBTIME(NOW(),'1:1:3'),DATEDIFF(NOW(),'2021-10-01'),
TIMEDIFF(NOW(),'2021-10-25 22:10:10'),FROM_DAYS(366),TO_DAYS('0000-12-25'),
LAST_DAY(NOW()),MAKEDATE(YEAR(NOW()),12),MAKETIME(10,21,23),PERIOD_ADD(20200101010101,10)
FROM DUAL;

mysql> SELECT ADDTIME(NOW(), 50);
+---------------------+
| ADDTIME(NOW(), 50)  |
+---------------------+
| 2019-12-15 22:17:47 |
+---------------------+
1 row in set (0.00 sec)
mysql> SELECT ADDTIME(NOW(), '1:1:1');
+-------------------------+
| ADDTIME(NOW(), '1:1:1') |
+-------------------------+
| 2019-12-15 23:18:46     |
+-------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBTIME(NOW(), '1:1:1');
+-------------------------+
| SUBTIME(NOW(), '1:1:1') |
+-------------------------+
| 2019-12-15 21:23:50     |
+-------------------------+
1 row in set (0.00 sec)
mysql> SELECT SUBTIME(NOW(), '-1:-1:-1'); 
+----------------------------+
| SUBTIME(NOW(), '-1:-1:-1') |
+----------------------------+
| 2019-12-15 22:25:11        |
+----------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SELECT FROM_DAYS(366);
+----------------+
| FROM_DAYS(366) |
+----------------+
| 0001-01-01     |
+----------------+
1 row in set (0.00 sec)

mysql> SELECT MAKEDATE(2020,1);
+------------------+
| MAKEDATE(2020,1) |
+------------------+
| 2020-01-01       |
+------------------+
1 row in set (0.00 sec)
mysql> SELECT MAKEDATE(2020,32);
+-------------------+
| MAKEDATE(2020,32) |
+-------------------+
| 2020-02-01        |
+-------------------+
1 row in set (0.00 sec)

mysql> SELECT MAKETIME(1,1,1);
+-----------------+
| MAKETIME(1,1,1) |
+-----------------+
| 01:01:01        |
+-----------------+
1 row in set (0.00 sec)

mysql> SELECT PERIOD_ADD(20200101010101,1);
+------------------------------+
| PERIOD_ADD(20200101010101,1) |
+------------------------------+
|               20200101010102 |
+------------------------------+
1 row in set (0.00 sec)

mysql> SELECT TO_DAYS(NOW());
+----------------+
| TO_DAYS(NOW()) |
+----------------+
|          737773 |
+----------------+
1 row in set (0.00 sec)

举例：查询 7 天内的新增用户数有多少？

SELECT COUNT(*) as num FROM new_user WHERE TO_DAYS(NOW())-TO_DAYS(regist_time)<=7
• 1

日期的格式化与解析

上述非GET_FORMAT函数中fmt参数常用的格式符：

GET_FORMAT函数中date_type和format_type参数取值如下：

举例：

mysql> SELECT DATE_FORMAT(NOW(), '%H:%i:%s');
+--------------------------------+
| DATE_FORMAT(NOW(), '%H:%i:%s') |
+--------------------------------+
| 22:57:34                        |
+--------------------------------+
1 row in set (0.00 sec)

SELECT STR_TO_DATE('09/01/2009','%m/%d/%Y')
FROM DUAL;
SELECT STR_TO_DATE('20140422154706','%Y%m%d%H%i%s')
FROM DUAL;
SELECT STR_TO_DATE('2014-04-22 15:47:06','%Y-%m-%d %H:%i:%s')
FROM DUAL;

mysql> SELECT GET_FORMAT(DATE, 'USA');
+-------------------------+
| GET_FORMAT(DATE, 'USA') |
+-------------------------+
| %m.%d.%Y                |
+-------------------------+
1 row in set (0.00 sec)
SELECT DATE_FORMAT(NOW(),GET_FORMAT(DATE,'USA')),
FROM DUAL;

mysql> SELECT STR_TO_DATE('2020-01-01 00:00:00','%Y-%m-%d'); 
+-----------------------------------------------+
| STR_TO_DATE('2020-01-01 00:00:00','%Y-%m-%d') |
+-----------------------------------------------+
| 2020-01-01                                    |
+-----------------------------------------------+
1 row in set, 1 warning (0.00 sec)

流程控制函数

流程处理函数可以根据不同的条件，执行不同的处理流程，可以在SQL语句中实现不同的条件选择。MySQL中的流程处理函数主要包括IF()、IFNULL()和CASE()函数。

SELECT IF(1 > 0,'正确','错误')    
->正确
1
2
SELECT IFNULL(null,'Hello Word')
->Hello Word
1
2
SELECT CASE 
  WHEN 1 > 0
  THEN '1 > 0'
  WHEN 2 > 0
  THEN '2 > 0'
  ELSE '3 > 0'
  END
->1 > 0
SELECT CASE 1 
  WHEN 1 THEN '我是1'
  WHEN 2 THEN '我是2'
ELSE '你是谁'
SELECT employee_id,salary, CASE WHEN salary>=15000 THEN '高薪' 
      WHEN salary>=10000 THEN '潜力股'  
      WHEN salary>=8000 THEN '屌丝' 
      ELSE '草根' END  "描述"
FROM employees; 
SELECT oid,`status`, CASE `status` WHEN 1 THEN '未付款' 
           WHEN 2 THEN '已付款' 
           WHEN 3 THEN '已发货'  
           WHEN 4 THEN '确认收货'  
           ELSE '无效订单' END 
FROM t_order;
mysql> SELECT CASE WHEN 1 > 0 THEN 'yes' WHEN 1 <= 0 THEN 'no' ELSE 'unknown' END;
+---------------------------------------------------------------------+
| CASE WHEN 1 > 0 THEN 'yes' WHEN 1 <= 0 THEN 'no' ELSE 'unknown' END |
+---------------------------------------------------------------------+
| yes                                                                  |
+---------------------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT CASE WHEN 1 < 0 THEN 'yes' WHEN 1 = 0 THEN 'no' ELSE 'unknown' END;  
+--------------------------------------------------------------------+
| CASE WHEN 1 < 0 THEN 'yes' WHEN 1 = 0 THEN 'no' ELSE 'unknown' END |
+--------------------------------------------------------------------+
| unknown                                                             |
+--------------------------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT CASE 1 WHEN 0 THEN 0 WHEN 1 THEN 1 ELSE -1 END;
+------------------------------------------------+
| CASE 1 WHEN 0 THEN 0 WHEN 1 THEN 1 ELSE -1 END |
+------------------------------------------------+
|                                               1 |
+------------------------------------------------+
1 row in set (0.00 sec)
mysql> SELECT CASE -1 WHEN 0 THEN 0 WHEN 1 THEN 1 ELSE -1 END;
+-------------------------------------------------+
| CASE -1 WHEN 0 THEN 0 WHEN 1 THEN 1 ELSE -1 END |
+-------------------------------------------------+
|                                               -1 |
+-------------------------------------------------+
1 row in set (0.00 sec)
SELECT employee_id,12 * salary * (1 + IFNULL(commission_pct,0))
FROM employees;
SELECT last_name, job_id, salary,
       CASE job_id WHEN 'IT_PROG'  THEN  1.10*salary
                   WHEN 'ST_CLERK' THEN  1.15*salary
                   WHEN 'SA_REP'   THEN  1.20*salary
             ELSE      salary END     "REVISED_SALARY"
FROM   employees;

练习：查询部门号为 10,20, 30 的员工信息, 若部门号为 10, 则打印其工资的 1.1 倍, 20 号部门, 则打印其工资的 1.2 倍, 30 号部门打印其工资的 1.3 倍数。

加密与解密函数

加密与解密函数主要用于对数据库中的数据进行加密和解密处理，以防止数据被他人窃取。这些函数在保证数据库安全时非常有用。

函数用法

PASSWORD(str) 返回字符串str的加密版本，41位长的字符串。加密结果不可逆，常用于用户的密码加密

MD5(str) 返回字符串str的md5加密后的值，也是一种加密方式。若参数为NULL，则会返回NULL

SHA(str) 从原明文密码str计算并返回加密后的密码字符串，当参数为NULL时，返回NULL。SHA加密算法比MD5更加安全。

ENCODE(value,password_seed) 返回使用password_seed作为加密密码加密value

DECODE(value,password_seed) 返回使用password_seed作为加密密码解密value

可以看到，ENCODE(value,password_seed)函数与DECODE(value,password_seed)函数互为反函数。

举例：

mysql> SELECT PASSWORD('mysql'), PASSWORD(NULL);

+-------------------------------------------+----------------+

| PASSWORD('mysql') | PASSWORD(NULL) |

+-------------------------------------------+----------------+

| *E74858DB86EBA20BC33D0AECAE8A8108C56B17FA | |

+-------------------------------------------+----------------+

1 row in set, 1 warning (0.00 sec)

SELECT md5('123')

->202cb962ac59075b964b07152d234b70

SELECT SHA('Tom123')

->c7c506980abc31cc390a2438c90861d0f1216d50

mysql> SELECT ENCODE('mysql', 'mysql');

+--------------------------+

| ENCODE('mysql', 'mysql') |

+--------------------------+

| íg　¼　ìÉ |

+--------------------------+

1 row in set, 1 warning (0.01 sec)

mysql> SELECT DECODE(ENCODE('mysql','mysql'),'mysql');

+-----------------------------------------+

| DECODE(ENCODE('mysql','mysql'),'mysql') |

+-----------------------------------------+

| mysql |

+-----------------------------------------+

1 row in set, 2 warnings (0.00 sec)

MySQL信息函数

MySQL中内置了一些可以查询MySQL信息的函数，这些函数主要用于帮助数据库开发或运维人员更好地对数据库进行维护工作。

函数用法

VERSION() 返回当前MySQL的版本号

CONNECTION_ID() 返回当前MySQL服务器的连接数

DATABASE()，SCHEMA() 返回MySQL命令行当前所在的数据库

USER()，CURRENT_USER()、SYSTEM_USER()，SESSION_USER() 返回当前连接MySQL的用户名，返回结果格式为“主机名@用户名”

CHARSET(value) 返回字符串value自变量的字符集

COLLATION(value) 返回字符串value的比较规则

举例：

mysql> SELECT DATABASE();
+------------+
| DATABASE() |
+------------+
| test       |
+------------+
1 row in set (0.00 sec)
mysql> SELECT DATABASE();
+------------+
| DATABASE() |
+------------+
| test       |
+------------+
1 row in set (0.00 sec)
mysql> SELECT USER(), CURRENT_USER(), SYSTEM_USER(),SESSION_USER();
+----------------+----------------+----------------+----------------+
| USER()         | CURRENT_USER() | SYSTEM_USER()  | SESSION_USER() |
+----------------+----------------+----------------+----------------+
| root@localhost | root@localhost | root@localhost | root@localhost |
+----------------+----------------+----------------+----------------+
mysql> SELECT CHARSET('ABC');
+----------------+
| CHARSET('ABC') |
+----------------+
| utf8mb4        |
+----------------+
1 row in set (0.00 sec)
mysql> SELECT COLLATION('ABC');
+--------------------+
| COLLATION('ABC')   |
+--------------------+
| utf8mb4_general_ci |
+--------------------+
1 row in set (0.00 sec)

其他函数

MySQL 中有些函数无法对其进行具体的分类，但是这些函数在 MySQL 的开发和运维过程中也是不容忽视的。

函数用法

FORMAT(value,n) 返回对数字value进行格式化后的结果数据。n表示四舍五入后保留到小数点后n位

CONV(value,from,to) 将value的值进行不同进制之间的转换

INET_ATON(ipvalue) 将以点分隔的IP地址转化为一个数字

INET_NTOA(value) 将数字形式的IP地址转化为以点分隔的IP地址

BENCHMARK(n,expr) 将表达式expr重复执行n次。用于测试MySQL处理expr表达式所耗费的时间

CONVERT(value USING char_code) 将value所使用的字符编码修改为char_code

举例：

# 如果n的值小于或者等于0，则只保留整数部分

mysql> SELECT FORMAT(123.123, 2), FORMAT(123.523, 0), FORMAT(123.123, -2); 
+--------------------+--------------------+---------------------+
| FORMAT(123.123, 2) | FORMAT(123.523, 0) | FORMAT(123.123, -2) |
+--------------------+--------------------+---------------------+
| 123.12             | 124                | 123                 |
+--------------------+--------------------+---------------------+
1 row in set (0.00 sec)
mysql> SELECT CONV(16, 10, 2), CONV(8888,10,16), CONV(NULL, 10, 2);
+-----------------+------------------+-------------------+
| CONV(16, 10, 2) | CONV(8888,10,16) | CONV(NULL, 10, 2) |
+-----------------+------------------+-------------------+
| 10000           | 22B8             | NULL              |
+-----------------+------------------+-------------------+
1 row in set (0.00 sec)
mysql> SELECT INET_ATON('192.168.1.100');
+----------------------------+
| INET_ATON('192.168.1.100') |
+----------------------------+
|                 3232235876 |
+----------------------------+
1 row in set (0.00 sec)
# 以“192.168.1.100”为例，计算方式为192乘以256的3次方，加上168乘以256的2次方，加上1乘以256，再加上100。
mysql> SELECT INET_NTOA(3232235876);
+-----------------------+
| INET_NTOA(3232235876) |
+-----------------------+
| 192.168.1.100         |
+-----------------------+
1 row in set (0.00 sec)
mysql> SELECT BENCHMARK(1, MD5('mysql'));
+----------------------------+
| BENCHMARK(1, MD5('mysql')) |
+----------------------------+
|                          0 |
+----------------------------+
1 row in set (0.00 sec)
mysql> SELECT BENCHMARK(1000000, MD5('mysql')); 
+----------------------------------+
| BENCHMARK(1000000, MD5('mysql')) |
+----------------------------------+
|                                0 |
+----------------------------------+
1 row in set (0.20 sec)
mysql> SELECT CHARSET('mysql'), CHARSET(CONVERT('mysql' USING 'utf8'));
+------------------+----------------------------------------+
| CHARSET('mysql') | CHARSET(CONVERT('mysql' USING 'utf8')) |
+------------------+----------------------------------------+
| utf8mb4          | utf8                                   |
+------------------+----------------------------------------+
1 row in set, 1 warning (0.00 sec)

聚合函数

上一章讲到了 SQL 单行函数。实际上 SQL 函数还有一类，叫做聚合（或聚集、分组）函数，它是对一组数据进行汇总的函数，输入的是一组数据的集合，输出的是单个值。

聚合函数介绍

什么是聚合函数

聚合函数作用于一组数据，并对一组数据返回一个值。

聚合函数类型

AVG()

SUM()

MAX()

MIN()

**COUNT() **

聚合函数语法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QqLz6Ucm-1639905602494)(F:\atguigu\尚硅谷\MySQL\01_课件\images\1554981029920.png)]

聚合函数不能嵌套调用。比如不能出现类似“AVG(SUM(字段名称))”形式的调用。

AVG和SUM函数

可以对数值型数据使用AVG 和 SUM 函数。

SELECT AVG(salary), MAX(salary),MIN(salary), SUM(salary)

FROM employees

WHERE job_id LIKE '%REP%';

MIN和MAX函数

可以对任意数据类型的数据使用 MIN 和 MAX 函数。

SELECT MIN(hire_date), MAX(hire_date)

FROM employees;

COUNT函数

COUNT(*)返回表中记录总数，适用于任意数据类型。

SELECT COUNT(*)

FROM employees

WHERE department_id = 50;

COUNT(expr) 返回expr不为空的记录总数。

SELECT COUNT(commission_pct)

FROM employees

WHERE department_id = 50;

问题：用count(*)，count(1)，count(列名)谁好呢?

其实，对于 MyISAM 引擎的表是没有区别的。这种引擎内部有一计数器在维护着行数。

Innodb 引擎的表用 count(*),count(1) 直接读行数，复杂度是O(n)，因为 innodb 真的要去数一遍。但好于具体的 count(列名)。

问题：能不能使用count(列名)替换count(*)?

不要使用 count(列名)来替代 count(*)，count(*)是 SQL92 定义的标准统计行数的语法，跟数据库无关，跟 NULL 和非 NULL 无关。

说明：count(*)会统计值为 NULL 的行，而 count(列名)不会统计此列为 NULL 值的行。

GROUP BY

基本使用

可以使用GROUP BY子句将表中的数据分成若干组

SELECT column, group_function(column)

FROM table

[WHERE condition]

[GROUP BY group_by_expression]

[ORDER BY column];

明确：WHERE一定放在FROM后面

在SELECT列表中所有未包含在组函数中的列都应该包含在 GROUP BY子句中

SELECT department_id, AVG(salary)

FROM employees

GROUP BY department_id ;

包含在 GROUP BY 子句中的列不必包含在SELECT 列表中

SELECT AVG(salary)

FROM employees

GROUP BY department_id ;

使用多个列分组

SELECT department_id dept_id, job_id, SUM(salary)

FROM employees

GROUP BY department_id, job_id ;

GROUP BY中使用WITH ROLLUP

使用WITH ROLLUP关键字之后，在所有查询出的分组记录之后增加一条记录，该记录计算查询出的所有记录的总和，即统计记录数量。

SELECT department_id,AVG(salary)

FROM employees

WHERE department_id > 80

GROUP BY department_id WITH ROLLUP;

注意：

当使用ROLLUP时，不能同时使用ORDER BY子句进行结果排序，即ROLLUP和ORDER BY是互相排斥的。

HAVING

基本使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8HPRPbEI-1639905602502)(F:\atguigu\尚硅谷\MySQL\01_课件\images\1554981656798.png)]

过滤分组：HAVING子句

行已经被分组。

使用了聚合函数。

满足HAVING 子句中条件的分组将被显示。

HAVING 不能单独使用，必须要跟 GROUP BY 一起使用。

SELECT department_id, MAX(salary)

FROM employees

GROUP BY department_id

HAVING MAX(salary)>10000 ;

**非法使用聚合函数：不能在 WHERE 子句中使用聚合函数。**如下：

SELECT department_id, AVG(salary)

FROM employees

WHERE AVG(salary) > 8000

GROUP BY department_id;

WHERE 和 HAVING 的对比

区别1：WHERE 可以直接使用表中的字段作为筛选条件，但不能使用分组中的计算函数作为筛选条件；HAVING 必须要与 GROUP BY 配合使用，可以把分组计算的函数和分组字段作为筛选条件。

这决定了，在需要对数据进行分组统计的时候，HAVING 可以完成 WHERE 不能完成的任务。这是因为，在查询语法结构中，WHERE 在 GROUP BY 之前，所以无法对分组结果进行筛选。HAVING 在 GROUP BY 之后，可以使用分组字段和分组中的计算函数，对分组的结果集进行筛选，这个功能是 WHERE 无法完成的。另外，WHERE排除的记录不再包括在分组中。

区别2：如果需要通过连接从关联表中获取需要的数据，WHERE 是先筛选后连接，而 HAVING 是先连接后筛选。这一点，就决定了在关联查询中，WHERE 比 HAVING 更高效。因为 WHERE 可以先筛选，用一个筛选后的较小数据集和关联表进行连接，这样占用的资源比较少，执行效率也比较高。HAVING 则需要先把结果集准备好，也就是用未被筛选的数据集进行关联，然后对这个大的数据集进行筛选，这样占用的资源就比较多，执行效率也较低。

小结如下：

优点缺点

WHERE 先筛选数据再关联，执行效率高不能使用分组中的计算函数进行筛选

HAVING 可以使用分组中的计算函数在最后的结果集中进行筛选，执行效率较低

开发中的选择：

WHERE 和 HAVING 也不是互相排斥的，我们可以在一个查询里面同时使用 WHERE 和 HAVING。包含分组统计函数的条件用 HAVING，普通条件用 WHERE。这样，我们就既利用了 WHERE 条件的高效快速，又发挥了 HAVING 可以使用包含分组统计函数的查询条件的优点。当数据量特别大的时候，运行效率会有很大的差别。

SELECT的执行过程

查询的结构

#方式1：

SELECT ...,....,...

FROM ...,...,....

WHERE 多表的连接条件

AND 不包含组函数的过滤条件

GROUP BY ...,...

HAVING 包含组函数的过滤条件

ORDER BY ... ASC/DESC

LIMIT ...,...

#方式2：

SELECT ...,....,...

FROM ... JOIN ...

ON 多表的连接条件

JOIN ...

ON ...

WHERE 不包含组函数的过滤条件

AND/OR 不包含组函数的过滤条件

GROUP BY ...,...

HAVING 包含组函数的过滤条件

ORDER BY ... ASC/DESC

LIMIT ...,...

#其中：

#（1）from：从哪些表中筛选

#（2）on：关联多表查询时，去除笛卡尔积

#（3）where：从表中筛选的条件

#（4）group by：分组依据

#（5）having：在统计结果中再次筛选

#（6）order by：排序

#（7）limit：分页

SELECT执行顺序

你需要记住 SELECT 查询时的两个顺序：

1. 关键字的顺序是不能颠倒的：

SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY ... LIMIT...

2.SELECT 语句的执行顺序（在 MySQL 和 Oracle 中，SELECT 执行顺序基本相同）：

FROM -> WHERE -> GROUP BY -> HAVING -> SELECT 的字段 -> DISTINCT -> ORDER BY -> LIMIT

比如你写了一个 SQL 语句，那么它的关键字顺序和执行顺序是下面这样的：

SELECT DISTINCT player_id, player_name, count(*) as num # 顺序 5

FROM player JOIN team ON player.team_id = team.team_id # 顺序 1

WHERE height > 1.80 # 顺序 2

GROUP BY player.team_id # 顺序 3

HAVING num > 2 # 顺序 4

ORDER BY num DESC # 顺序 6

LIMIT 2 # 顺序 7

在 SELECT 语句执行这些步骤的时候，每个步骤都会产生一个虚拟表，然后将这个虚拟表传入下一个步骤中作为输入。需要注意的是，这些步骤隐含在 SQL 的执行过程中，对于我们来说是不可见的。

SQL 的执行原理

SELECT 是先执行 FROM 这一步的。在这个阶段，如果是多张表联查，还会经历下面的几个步骤：

首先先通过 CROSS JOIN 求笛卡尔积，相当于得到虚拟表 vt（virtual table）1-1；

通过 ON 进行筛选，在虚拟表 vt1-1 的基础上进行筛选，得到虚拟表 vt1-2；

添加外部行。如果我们使用的是左连接、右链接或者全连接，就会涉及到外部行，也就是在虚拟表 vt1-2 的基础上增加外部行，得到虚拟表 vt1-3。

当然如果我们操作的是两张以上的表，还会重复上面的步骤，直到所有表都被处理完为止。这个过程得到是我们的原始数据。

当我们拿到了查询数据表的原始数据，也就是最终的虚拟表 vt1，就可以在此基础上再进行 WHERE 阶段。在这个阶段中，会根据 vt1 表的结果进行筛选过滤，得到虚拟表 vt2。

然后进入第三步和第四步，也就是 GROUP 和 HAVING 阶段。在这个阶段中，实际上是在虚拟表 vt2 的基础上进行分组和分组过滤，得到中间的虚拟表 vt3 和 vt4。

当我们完成了条件筛选部分之后，就可以筛选表中提取的字段，也就是进入到 SELECT 和 DISTINCT 阶段。

首先在 SELECT 阶段会提取想要的字段，然后在 DISTINCT 阶段过滤掉重复的行，分别得到中间的虚拟表 vt5-1 和 vt5-2。

当我们提取了想要的字段数据之后，就可以按照指定的字段进行排序，也就是 ORDER BY 阶段，得到虚拟表 vt6。

最后在 vt6 的基础上，取出指定行的记录，也就是 LIMIT 阶段，得到最终的结果，对应的是虚拟表 vt7。

当然我们在写 SELECT 语句的时候，不一定存在所有的关键字，相应的阶段就会省略。

同时因为 SQL 是一门类似英语的结构化查询语言，所以我们在写 SELECT 语句的时候，还要注意相应的关键字顺序，所谓底层运行的原理，就是我们刚才讲到的执行顺序。

子查询

子查询指一个查询语句嵌套在另一个查询语句内部的查询，这个特性从MySQL 4.1开始引入。

SQL 中子查询的使用大大增强了 SELECT 查询的能力，因为很多时候查询需要从结果集中获取数据，或者需要从同一个表中先计算得出一个数据结果，然后与这个数据结果（可能是某个标量，也可能是某个集合）进行比较。

需求分析与问题解决

实际问题

现有解决方式：

#方式一：

SELECT salary

FROM employees

WHERE last_name = 'Abel';

SELECT last_name,salary

FROM employees

WHERE salary > 11000;

#方式二：自连接

SELECT e2.last_name,e2.salary

FROM employees e1,employees e2

WHERE e1.last_name = 'Abel'

AND e1.`salary` < e2.`salary`

#方式三：子查询

SELECT last_name,salary

FROM employees

WHERE salary > (

SELECT salary

FROM employees

WHERE last_name = 'Abel'

);

子查询的基本使用

子查询的基本语法结构：

子查询（内查询）在主查询之前一次执行完成。

子查询的结果被主查询（外查询）使用。

注意事项

子查询要包含在括号内

将子查询放在比较条件的右侧

单行操作符对应单行子查询，多行操作符对应多行子查询

子查询的分类

分类方式1：

我们按内查询的结果返回一条还是多条记录，将子查询分为单行子查询、多行子查询。

单行子查询

多行子查询

分类方式2：

我们按内查询是否被执行多次，将子查询划分为相关(或关联)子查询和不相关(或非关联)子查询。

子查询从数据表中查询了数据结果，如果这个数据结果只执行一次，然后这个数据结果作为主查询的条件进行执行，那么这样的子查询叫做不相关子查询。

同样，如果子查询需要执行多次，即采用循环的方式，先从外部查询开始，每次都传入子查询进行查询，然后再将结果反馈给外部，这种嵌套的执行方式就称为相关子查询。

单行子查询

单行比较操作符

操作符含义

= equal to

> greater than

>= greater than or equal to

< less than

<= less than or equal to

<> not equal to

代码示例

题目：查询工资大于149号员工工资的员工的信息

题目：返回job_id与141号员工相同，salary比143号员工多的员工姓名，job_id和工资

SELECT last_name, job_id, salary
FROM   employees
WHERE  job_id =  
                (SELECT job_id
                 FROM   employees
                 WHERE  employee_id = 141)
AND    salary >
                (SELECT salary
                 FROM   employees
                 WHERE  employee_id = 143);
题目：返回公司工资最少的员工的last_name,job_id和salary
SELECT last_name, job_id, salary
FROM   employees
WHERE  salary = 
                (SELECT MIN(salary)
                 FROM   employees);
题目：查询与141号或174号员工的manager_id和department_id相同的其他员工的employee_id，manager_id，department_id
实现方式1：不成对比较
SELECT  employee_id, manager_id, department_id
FROM    employees
WHERE   manager_id IN
    (SELECT  manager_id
                   FROM    employees
                   WHERE   employee_id IN (174,141))
AND     department_id IN 
    (SELECT  department_id
                   FROM    employees
                   WHERE   employee_id IN (174,141))
AND employee_id NOT IN(174,141);
实现方式2：成对比较
SELECT  employee_id, manager_id, department_id
FROM  employees
WHERE  (manager_id, department_id) IN
                      (SELECT manager_id, department_id
                       FROM   employees
                       WHERE  employee_id IN (141,174))
AND employee_id NOT IN (141,174);
HAVING 中的子查询
首先执行子查询。
向主查询中的HAVING 子句返回结果。
题目：查询最低工资大于50号部门最低工资的部门id和其最低工资
SELECT   department_id, MIN(salary)
FROM     employees
GROUP BY department_id
HAVING   MIN(salary) >
                       (SELECT MIN(salary)
                        FROM   employees
                        WHERE  department_id = 50);
CASE中的子查询
在CASE表达式中使用单列子查询：
题目：显式员工的employee_id,last_name和location。其中，若员工department_id与location_id为1800的department_id相同，则location为’Canada’，其余则为’USA’。
SELECT employee_id, last_name,
       (CASE department_id
        WHEN
             (SELECT department_id FROM departments
       WHERE location_id = 1800)           
        THEN 'Canada' ELSE 'USA' END) location
FROM   employees;
子查询中的空值问题
SELECT last_name, job_id
FROM   employees
WHERE  job_id =
                (SELECT job_id
                 FROM   employees
                 WHERE  last_name = 'Haas');
子查询不返回任何行
非法使用子查询
SELECT employee_id, last_name
FROM   employees
WHERE  salary =
                (SELECT   MIN(salary)
                 FROM     employees
                 GROUP BY department_id);

多行子查询使用单行比较符

多行子查询

也称为集合比较子查询

内查询返回多行

使用多行比较操作符

多行比较操作符

操作符含义

IN 等于列表中的任意一个

ANY 需要和单行比较操作符一起使用，和子查询返回的某一个值比较

ALL 需要和单行比较操作符一起使用，和子查询返回的所有值比较

SOME 实际上是ANY的别名，作用相同，一般常使用ANY

体会 ANY 和 ALL 的区别

代码示例

题目：返回其它job_id中比job_id为‘IT_PROG’部门任一工资低的员工的员工号、姓名、job_id 以及salary

题目：返回其它job_id中比job_id为‘IT_PROG’部门所有工资都低的员工的员工号、姓名、job_id以及salary

题目：查询平均工资最低的部门id

#方式1：

SELECT department_id

FROM employees

GROUP BY department_id

HAVING AVG(salary) = (

SELECT MIN(avg_sal)

FROM (

SELECT AVG(salary) avg_sal

FROM employees

GROUP BY department_id

) dept_avg_sal

)

#方式2：

SELECT department_id

FROM employees

GROUP BY department_id

HAVING AVG(salary) <= ALL (

SELECT AVG(salary) avg_sal

FROM employees

GROUP BY department_id

)

空值问题

SELECT last_name

FROM employees

WHERE employee_id NOT IN (

SELECT manager_id

FROM employees

);

相关删除

DELETE FROM table1 alias1

WHERE column operator (SELECT expression

FROM table2 alias2

WHERE alias1.column = alias2.column);

使用相关子查询依据一个表中的数据删除另一个表的数据。

题目：删除表employees中，其与emp_history表皆有的数据

DELETE FROM employees e

WHERE employee_id in

(SELECT employee_id

FROM emp_history

WHERE employee_id = e.employee_id);

抛一个思考题

**问题：**谁的工资比Abel的高？

解答：

#方式1：自连接

SELECT e2.last_name,e2.salary

FROM employees e1,employees e2

WHERE e1.last_name = 'Abel'

AND e1.`salary` < e2.`salary`

#方式2：子查询

SELECT last_name,salary

FROM employees

WHERE salary > (

SELECT salary

FROM employees

WHERE last_name = 'Abel'

);

**问题：**以上两种方式有好坏之分吗？

**解答：**自连接方式好！

题目中可以使用子查询，也可以使用自连接。一般情况建议你使用自连接，因为在许多 DBMS 的处理过程中，对于自连接的处理速度要比子查询快得多。

可以这样理解：子查询实际上是通过未知表进行查询后的条件判断，而自连接是通过已知的自身数据表进行条件判断，因此在大部分 DBMS 中都对自连接处理进行了优化。

创建和管理表

基础知识

一条数据存储的过程

存储数据是处理数据的第一步。只有正确地把数据存储起来，我们才能进行有效的处理和分析。否则，只能是一团乱麻，无从下手。

那么，怎样才能把用户各种经营相关的、纷繁复杂的数据，有序、高效地存储起来呢？在 MySQL 中，一个完整的数据存储过程总共有 4 步，分别是创建数据库、确认字段、创建数据表、插入数据。

我们要先创建一个数据库，而不是直接创建数据表呢？

因为从系统架构的层次上看，MySQL 数据库系统从大到小依次是数据库服务器、数据库、数据表、数据表的行与列。

MySQL 数据库服务器之前已经安装。所以，我们就从创建数据库开始。

标识符命名规则

数据库名、表名不得超过30个字符，变量名限制为29个

必须只能包含 A–Z, a–z, 0–9, _共63个字符

数据库名、表名、字段名等对象名中间不要包含空格

同一个MySQL软件中，数据库不能同名；同一个库中，表不能重名；同一个表中，字段不能重名

必须保证你的字段没有和保留字、数据库系统或常用方法冲突。如果坚持使用，请在SQL语句中使用`（着重号）引起来

保持字段名和类型的一致性：在命名字段并为其指定数据类型的时候一定要保证一致性，假如数据类型在一个表里是整数，那在另一个表里可就别变成字符型了

MySQL中的数据类型

类型类型举例

整数类型 TINYINT、SMALLINT、MEDIUMINT、INT(或INTEGER)、BIGINT

浮点类型 FLOAT、DOUBLE

定点数类型 DECIMAL

位类型 BIT

日期时间类型 YEAR、TIME、DATE、DATETIME、TIMESTAMP

文本字符串类型 CHAR、VARCHAR、TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT

枚举类型 ENUM

集合类型 SET

二进制字符串类型 BINARY、VARBINARY、TINYBLOB、BLOB、MEDIUMBLOB、LONGBLOB

JSON类型 JSON对象、JSON数组

空间数据类型单值：GEOMETRY、POINT、LINESTRING、POLYGON；

集合：MULTIPOINT、MULTILINESTRING、MULTIPOLYGON、GEOMETRYCOLLECTION

其中，常用的几类类型介绍如下：

数据类型描述

INT 从-231到231-1的整型数据。存储大小为 4个字节

CHAR(size) 定长字符数据。若未指定，默认为1个字符，最大长度255

VARCHAR(size) 可变长字符数据，根据字符串实际长度保存，必须指定长度

FLOAT(M,D) 单精度，占用4个字节，M=整数位+小数位，D=小数位。 D<=M<=255,0<=D<=30，默认M+D<=6

DOUBLE(M,D) 双精度，占用8个字节，D<=M<=255,0<=D<=30，默认M+D<=15

DECIMAL(M,D) 高精度小数，占用M+2个字节，D<=M<=65，0<=D<=30，最大取值范围与DOUBLE相同。

DATE 日期型数据，格式’YYYY-MM-DD’

BLOB 二进制形式的长文本数据，最大可达4G

TEXT 长文本数据，最大可达4G

创建和管理数据库

创建数据库

方式1：创建数据库

CREATE DATABASE 数据库名;

方式2：创建数据库并指定字符集

CREATE DATABASE 数据库名 CHARACTER SET 字符集;

方式3：判断数据库是否已经存在，不存在则创建数据库（推荐）

CREATE DATABASE IF NOT EXISTS 数据库名;

如果MySQL中已经存在相关的数据库，则忽略创建语句，不再创建数据库。

注意：DATABASE 不能改名。一些可视化工具可以改名，它是建新库，把所有表复制到新库，再删旧库完成的。

使用数据库

查看当前所有的数据库

SHOW DATABASES; #有一个S，代表多个数据库

查看当前正在使用的数据库

SELECT DATABASE(); #使用的一个 mysql 中的全局函数

查看指定库下所有的表

SHOW TABLES FROM 数据库名;

查看数据库的创建信息

SHOW CREATE DATABASE 数据库名;

或者：

SHOW CREATE DATABASE 数据库名\G

使用/切换数据库

USE 数据库名;

注意：要操作表格和数据之前必须先说明是对哪个数据库进行操作，否则就要对所有对象加上“数据库名.”。

修改数据库

更改数据库字符集

ALTER DATABASE 数据库名 CHARACTER SET 字符集; #比如：gbk、utf8等

删除数据库

方式1：删除指定的数据库

DROP DATABASE 数据库名;

方式2：删除指定的数据库（推荐）

DROP DATABASE IF EXISTS 数据库名;

创建表

创建方式1

必须具备：

CREATE TABLE权限

存储空间

语法格式：

CREATE TABLE [IF NOT EXISTS] 表名(

字段1, 数据类型 [约束条件] [默认值],

字段2, 数据类型 [约束条件] [默认值],

字段3, 数据类型 [约束条件] [默认值],

……

[表约束条件]

);

加上了IF NOT EXISTS关键字，则表示：如果当前数据库中不存在要创建的数据表，则创建数据表；如果当前数据库中已经存在要创建的数据表，则忽略建表语句，不再创建数据表。

必须指定：

表名

列名(或字段名)，数据类型，长度

可选指定：

约束条件

默认值

创建表举例1：

-- 创建表

CREATE TABLE emp (

-- int类型

emp_id INT,

-- 最多保存20个中英文字符

emp_name VARCHAR(20),

-- 总位数不超过15位

salary DOUBLE,

-- 日期类型

birthday DATE

);

MySQL在执行建表语句时，将id字段的类型设置为int(11)，这里的11实际上是int类型指定的显示宽度，默认的显示宽度为11。也可以在创建数据表的时候指定数据的显示宽度。

创建表举例2：

CREATE TABLE dept(

-- int类型，自增

deptno INT(2) AUTO_INCREMENT,

dname VARCHAR(14),

loc VARCHAR(13),

-- 主键

PRIMARY KEY (deptno)

);

DESCRIBE dept;

在MySQL 8.x版本中，不再推荐为INT类型指定显示长度，并在未来的版本中可能去掉这样的语法。

创建方式2

使用 AS subquery 选项，将创建表和插入数据结合起来

指定的列和子查询中的列要一一对应

通过列名和默认值定义列

CREATE TABLE emp1 AS SELECT * FROM employees;

CREATE TABLE emp2 AS SELECT * FROM employees WHERE 1=2; -- 创建的emp2是空表

CREATE TABLE dept80

SELECT employee_id, last_name, salary*12 ANNSAL, hire_date

FROM employees

WHERE department_id = 80;

DESCRIBE dept80;

查看数据表结构

在MySQL中创建好数据表之后，可以查看数据表的结构。MySQL支持使用DESCRIBE/DESC语句查看数据表结构，也支持使用SHOW CREATE TABLE语句查看数据表结构。

语法格式如下：

SHOW CREATE TABLE 表名\G

使用SHOW CREATE TABLE语句不仅可以查看表创建时的详细语句，还可以查看存储引擎和字符编码。

修改表

修改表指的是修改数据库中已经存在的数据表的结构。

使用 ALTER TABLE 语句可以实现：

向已有的表中添加列

修改现有表中的列

删除现有表中的列

重命名现有表中的列

追加一个列

语法格式如下：

ALTER TABLE 表名 ADD 【COLUMN】字段名字段类型【FIRST|AFTER 字段名】;

举例：

ALTER TABLE dept80

ADD job_id varchar(15);

修改一个列

可以修改列的数据类型，长度、默认值和位置

修改字段数据类型、长度、默认值、位置的语法格式如下：

ALTER TABLE 表名 MODIFY 【COLUMN】字段名1 字段类型【DEFAULT 默认值】【FIRST|AFTER 字段名2】;

举例：

ALTER TABLE dept80

MODIFY last_name VARCHAR(30);

ALTER TABLE dept80

MODIFY salary double(9,2) default 1000;

对默认值的修改只影响今后对表的修改

此外，还可以通过此种方式修改列的约束。这里暂先不讲。

重命名一个列

使用 CHANGE old_column new_column dataType子句重命名列。语法格式如下：

ALTER TABLE 表名 CHANGE 【column】列名新列名新数据类型;

举例：

ALTER TABLE dept80

CHANGE department_name dept_name varchar(15);

删除一个列

删除表中某个字段的语法格式如下：

ALTER TABLE 表名 DROP 【COLUMN】字段名

举例：

ALTER TABLE dept80

DROP COLUMN job_id;

重命名表

方式一：使用RENAME

RENAME TABLE emp

TO myemp;

方式二：

ALTER table dept

RENAME [TO] detail_dept; -- [TO]可以省略

必须是对象的拥有者

删除表

在MySQL中，当一张数据表没有与其他任何数据表形成关联关系时，可以将当前数据表直接删除。

数据和结构都被删除

所有正在运行的相关事务被提交

所有相关索引被删除

语法格式：

DROP TABLE [IF EXISTS] 数据表1 [, 数据表2, …, 数据表n];

IF EXISTS的含义为：如果当前数据库中存在相应的数据表，则删除数据表；如果当前数据库中不存在相应的数据表，则忽略删除语句，不再执行删除数据表的操作。

举例：

DROP TABLE dept80;

DROP TABLE 语句不能回滚

清空表

TRUNCATE TABLE语句：

删除表中所有的数据

释放表的存储空间

举例：

TRUNCATE TABLE detail_dept;

TRUNCATE语句不能回滚，而使用 DELETE 语句删除数据，可以回滚

对比：

SET autocommit = FALSE;

DELETE FROM emp2;

#TRUNCATE TABLE emp2;

SELECT * FROM emp2;

ROLLBACK;

SELECT * FROM emp2;

阿里开发规范：

【参考】TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少，但 TRUNCATE 无事务且不触发 TRIGGER，有可能造成事故，故不建议在开发代码中使用此语句。

说明：TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同。

内容拓展

拓展1：阿里巴巴《Java 开发手册》之 MySQL 字段命名

【强制】表名、字段名必须使用小写字母或数字，禁止出现数字开头，禁止两个下划线中间只出现数字。数据库字段名的修改代价很大，因为无法进行预发布，所以字段名称需要慎重考虑。

正例：aliyun_admin，rdc_config，level3_name

反例：AliyunAdmin，rdcConfig，level_3_name

【强制】禁用保留字，如 desc、range、match、delayed 等，请参考 MySQL 官方保留字。

【强制】表必备三字段：id, gmt_create, gmt_modified。

说明：其中 id 必为主键，类型为BIGINT UNSIGNED、单表时自增、步长为 1。gmt_create, gmt_modified 的类型均为 DATETIME 类型，前者现在时表示主动式创建，后者过去分词表示被动式更新

【推荐】表的命名最好是遵循 “业务名称_表的作用”。

正例：alipay_task 、 force_project、 trade_config

【推荐】库名与应用名称尽量一致。

【参考】合适的字符存储长度，不但节约数据库表空间、节约索引存储，更重要的是提升检索速度。

正例：无符号值可以避免误存负数，且扩大了表示范围。

拓展2：如何理解清空表、删除表等操作需谨慎？！

表删除操作将把表的定义和表中的数据一起删除，并且MySQL在执行删除操作时，不会有任何的确认信息提示，因此执行删除操时应当慎重。在删除表前，最好对表中的数据进行备份，这样当操作失误时可以对数据进行恢复，以免造成无法挽回的后果。

同样的，在使用 ALTER TABLE 进行表的基本修改操作时，在执行操作过程之前，也应该确保对数据进行完整的备份，因为数据库的改变是无法撤销的，如果添加了一个不需要的字段，可以将其删除；相同的，如果删除了一个需要的列，该列下面的所有数据都将会丢失。

拓展3：MySQL8新特性—DDL的原子化

在MySQL 8.0版本中，InnoDB表的DDL支持事务完整性，即DDL操作要么成功要么回滚。DDL操作回滚日志写入到data dictionary数据字典表mysql.innodb_ddl_log（该表是隐藏的表，通过show tables无法看到）中，用于回滚操作。通过设置参数，可将DDL操作日志打印输出到MySQL错误日志中。

分别在MySQL 5.7版本和MySQL 8.0版本中创建数据库和数据表，结果如下：

CREATE DATABASE mytest;

USE mytest;

CREATE TABLE book1(

book_id INT ,

book_name VARCHAR(255)

);

SHOW TABLES;

（1）在MySQL 5.7版本中，测试步骤如下：

删除数据表book1和数据表book2，结果如下：

mysql> DROP TABLE book1,book2;

ERROR 1051 (42S02): Unknown table 'mytest.book2'

再次查询数据库中的数据表名称，结果如下：

mysql> SHOW TABLES;

Empty set (0.00 sec)

从结果可以看出，虽然删除操作时报错了，但是仍然删除了数据表book1。

（2）在MySQL 8.0版本中，测试步骤如下：

删除数据表book1和数据表book2，结果如下：

mysql> DROP TABLE book1,book2;

ERROR 1051 (42S02): Unknown table 'mytest.book2'

再次查询数据库中的数据表名称，结果如下：

mysql> show tables;

+------------------+

| Tables_in_mytest |

+------------------+

| book1 |

+------------------+

1 row in set (0.00 sec)

从结果可以看出，数据表book1并没有被删除。

数据处理之增删改

插入数据

实际问题

解决方式：使用 INSERT 语句向表中插入数据。

方式1：VALUES 的方式添加

使用这种语法一次只能向表中插入一条数据。

情况1：为表的所有字段按默认顺序插入数据

INSERT INTO 表名

VALUES (value1,value2,....);

值列表中需要为表的每一个字段指定值，并且值的顺序必须和数据表中字段定义时的顺序相同。

举例：

INSERT INTO departments

VALUES (70, 'Pub', 100, 1700);

INSERT INTO departments

VALUES (100, 'Finance', NULL, NULL);

情况2：为表的指定字段插入数据

INSERT INTO 表名(column1 [, column2, …, columnn])

VALUES (value1 [,value2, …, valuen]);

为表的指定字段插入数据，就是在INSERT语句中只向部分字段中插入值，而其他字段的值为表定义时的默认值。

在 INSERT 子句中随意列出列名，但是一旦列出，VALUES中要插入的value1,…valuen需要与column1,…columnn列一一对应。如果类型不同，将无法插入，并且MySQL会产生错误。

举例：

INSERT INTO departments(department_id, department_name)

VALUES (80, 'IT');

情况3：同时插入多条记录

INSERT语句可以同时向数据表中插入多条记录，插入时指定多个值列表，每个值列表之间用逗号分隔开，基本语法格式如下：

INSERT INTO table_name

VALUES

(value1 [,value2, …, valuen]),

……

(value1 [,value2, …, valuen]);

或者

INSERT INTO table_name(column1 [, column2, …, columnn])

VALUES

(value1 [,value2, …, valuen]),

……

(value1 [,value2, …, valuen]);

举例：

mysql> INSERT INTO emp(emp_id,emp_name)

-> VALUES (1001,'shkstart'),

-> (1002,'atguigu'),

-> (1003,'Tom');

Query OK, 3 rows affected (0.00 sec)

Records: 3 Duplicates: 0 Warnings: 0

使用INSERT同时插入多条记录时，MySQL会返回一些在执行单行插入时没有的额外信息，这些信息的含义如下：

●　Records：表明插入的记录条数。

●　Duplicates：表明插入时被忽略的记录，原因可能是这些记录包含了重复的主键值。

●　Warnings：表明有问题的数据值，例如发生数据类型转换。

一个同时插入多行记录的INSERT语句等同于多个单行插入的INSERT语句，但是多行的INSERT语句在处理过程中效率更高。因为MySQL执行单条INSERT语句插入多行数据比使用多条INSERT语句快，所以在插入多条记录时最好选择使用单条INSERT语句的方式插入。

小结：

VALUES也可以写成VALUE，但是VALUES是标准写法。

字符和日期型数据应包含在单引号中。

方式2：将查询结果插入到表中

INSERT还可以将SELECT语句查询的结果插入到表中，此时不需要把每一条记录的值一个一个输入，只需要使用一条INSERT语句和一条SELECT语句组成的组合语句即可快速地从一个或多个表中向一个表中插入多行。

基本语法格式如下：

INSERT INTO 目标表名

(tar_column1 [, tar_column2, …, tar_columnn])

SELECT

(src_column1 [, src_column2, …, src_columnn])

FROM 源表名

[WHERE condition]

在 INSERT 语句中加入子查询。

不必书写 VALUES 子句。

子查询中的值列表应与 INSERT 子句中的列名对应。

举例：

INSERT INTO emp2

SELECT *

FROM employees

WHERE department_id = 90;

INSERT INTO sales_reps(id, name, salary, commission_pct)

SELECT employee_id, last_name, salary, commission_pct

FROM employees

WHERE job_id LIKE '%REP%';

使用 UPDATE 语句更新数据。语法如下：

UPDATE table_name

SET column1=value1, column2=value2, … , column=valuen

[WHERE condition]

可以一次更新多条数据。

如果需要回滚数据，需要保证在DML前，进行设置：SET AUTOCOMMIT = FALSE;

使用 WHERE 子句指定需要更新的数据。

UPDATE employees

SET department_id = 70

WHERE employee_id = 113;

如果省略 WHERE 子句，则表中的所有数据都将被更新。

UPDATE copy_emp

SET department_id = 110;

更新中的数据完整性错误

UPDATE employees

SET department_id = 55

WHERE department_id = 110;

：不存在 55 号部门

删除数据

使用 DELETE 语句从表中删除数据

DELETE FROM table_name [WHERE <condition>];

table_name指定要执行删除操作的表；“[WHERE ]”为可选参数，指定删除条件，如果没有WHERE子句，DELETE语句将删除表中的所有记录。

使用 WHERE 子句删除指定的记录。

DELETE FROM departments

WHERE department_name = 'Finance';

如果省略 WHERE 子句，则表中的全部数据将被删除

DELETE FROM copy_emp;

删除中的数据完整性错误

DELETE FROM departments

WHERE department_id = 60;

说明：You cannot delete a row that contains a primary key that is used as a foreign key in another table.

MySQL8新特性：计算列

什么叫计算列呢？简单来说就是某一列的值是通过别的列计算得来的。例如，a列值为1、b列值为2，c列不需要手动插入，定义a+b的结果为c的值，那么c就是计算列，是通过别的列计算得来的。

在MySQL 8.0中，CREATE TABLE 和 ALTER TABLE 中都支持增加计算列。下面以CREATE TABLE为例进行讲解。

举例：定义数据表tb1，然后定义字段id、字段a、字段b和字段c，其中字段c为计算列，用于计算a+b的值。

首先创建测试表tb1，语句如下：

CREATE TABLE tb1(

id INT,

a INT,

b INT,

c INT GENERATED ALWAYS AS (a + b) VIRTUAL

);

插入演示数据，语句如下：

INSERT INTO tb1(a,b) VALUES (100,200);

查询数据表tb1中的数据，结果如下：

mysql> SELECT * FROM tb1;

+------+------+------+------+

| id | a | b | c |

+------+------+------+------+

| NULL | 100 | 200 | 300 |

+------+------+------+------+

1 row in set (0.00 sec)

更新数据中的数据，语句如下：

mysql> UPDATE tb1 SET a = 500;

Query OK, 0 rows affected (0.00 sec)

Rows matched: 1 Changed: 0 Warnings: 0

综合案例

# 1、创建数据库test01_library

# 2、创建表 books，表结构如下：

字段名字段说明数据类型

id 书编号 INT

name 书名 VARCHAR(50)

authors 作者 VARCHAR(100)

price 价格 FLOAT

pubdate 出版日期 YEAR

note 说明 VARCHAR(100)

num 库存 INT

# 3、向books表中插入记录

# 1）不指定字段名称，插入第一条记录

# 2）指定所有字段名称，插入第二记录

# 3）同时插入多条记录（剩下的所有记录）

id name authors price pubdate note num

1 Tal of AAA Dickes 23 1995 novel 11

2 EmmaT Jane lura 35 1993 joke 22

3 Story of Jane Jane Tim 40 2001 novel 0

4 Lovey Day George Byron 20 2005 novel 30

5 Old land Honore Blade 30 2010 law 0

6 The Battle Upton Sara 30 1999 medicine 40

7 Rose Hood Richard haggard 28 2008 cartoon 28

# 4、将小说类型(novel)的书的价格都增加5。

# 5、将名称为EmmaT的书的价格改为40，并将说明改为drama。

# 6、删除库存为0的记录。

# 7、统计书名中包含a字母的书

# 8、统计书名中包含a字母的书的数量和库存总量

# 9、找出“novel”类型的书，按照价格降序排列

# 10、查询图书信息，按照库存量降序排列，如果库存量相同的按照note升序排列

# 11、按照note分类统计书的数量

# 12、按照note分类统计书的库存量，显示库存量超过30本的

# 13、查询所有图书，每页显示5本，显示第二页

# 14、按照note分类统计书的库存量，显示库存量最多的

# 15、查询书名达到10个字符的书，不包括里面的空格

# 16、查询书名和类型，其中note值为novel显示小说，law显示法律，medicine显示医药，cartoon显示卡通，joke显示笑话

# 17、查询书名、库存，其中num值超过30本的，显示滞销，大于0并低于10的，显示畅销，为0的显示需要无货

# 18、统计每一种note的库存量，并合计总量

# 19、统计每一种note的数量，并合计总量

# 20、统计库存量前三名的图书

# 21、找出最早出版的一本书

# 22、找出novel中价格最高的一本书

# 23、找出书名中字数最多的一本书，不含空格

答案：

#1、创建数据库test01_library

CREATE DATABASE IF NOT EXISTS test01_library CHARACTER SET 'utf8';

# 指定使用哪个数据库

USE test01_library;

# 2、创建表 books

CREATE TABLE books(

id INT, name VARCHAR(50),

`authors` VARCHAR(100) ,

price FLOAT,

pubdate YEAR ,

note VARCHAR(100),

num INT

);

# 3、向books表中插入记录

# 1）不指定字段名称，插入第一条记录

INSERT INTO books VALUES(1,'Tal of AAA','Dickes',23,1995,'novel',11);

# 2）指定所有字段名称，插入第二记录

INSERT INTO books (id,name,`authors`,price,pubdate,note,num)VALUES(2,'EmmaT','Jane lura',35,1993,'Joke',22);

# 3）同时插入多条记录（剩下的所有记录）

INSERT INTO books (id,name,`authors`,price,pubdate,note,num)

VALUES(3,'Story of Jane','Jane Tim',40,2001,'novel',0),

(4,'Lovey Day','George Byron',20,2005,'novel',30),

(5,'Old land','Honore Blade',30,2010,'Law',0),

(6,'The Battle','Upton Sara',30,1999,'medicine',40),

(7,'Rose Hood','Richard haggard',28,2008,'cartoon',28);

# 4、将小说类型(novel)的书的价格都增加5。

UPDATE books SET price=price+5 WHERE note = 'novel';

# 5、将名称为EmmaT的书的价格改为40，并将说明改为drama。

UPDATE books SET price=40,note='drama' WHERE name='EmmaT';

# 6、删除库存为0的记录。

DELETE FROM books WHERE num=0;

# 7、统计书名中包含a字母的书

SELECT * FROM books WHERE name LIKE '%a%';

# 8、统计书名中包含a字母的书的数量和库存总量

SELECT COUNT(*),SUM(num) FROM books WHERE name LIKE '%a%';

# 9、找出“novel”类型的书，按照价格降序排列

SELECT * FROM books WHERE note = 'novel' ORDER BY price DESC;

# 10、查询图书信息，按照库存量降序排列，如果库存量相同的按照note升序排列

SELECT * FROM books ORDER BY num DESC,note ASC;

# 11、按照note分类统计书的数量

SELECT note,COUNT(*) FROM books GROUP BY note;

# 12、按照note分类统计书的库存量，显示库存量超过30本的

SELECT note,SUM(num) FROM books GROUP BY note HAVING SUM(num)>30;

# 13、查询所有图书，每页显示5本，显示第二页

SELECT * FROM books LIMIT 5,5;

# 14、按照note分类统计书的库存量，显示库存量最多的

SELECT note,SUM(num) sum_num FROM books GROUP BY note ORDER BY sum_num DESC LIMIT 0,1;

# 15、查询书名达到10个字符的书，不包括里面的空格

SELECT * FROM books WHERE CHAR_LENGTH(REPLACE(name,' ',''))>=10;

16、查询书名和类型，

其中note值为 novel显示小说，law显示法律，medicine显示医药，cartoon显示卡通，joke显示笑话

SELECT name AS "书名" ,note, CASE note

WHEN 'novel' THEN '小说'

WHEN 'law' THEN '法律'

WHEN 'medicine' THEN '医药'

WHEN 'cartoon' THEN '卡通'

WHEN 'joke' THEN '笑话'

END AS "类型"

FROM books;

# 17、查询书名、库存，其中num值超过30本的，显示滞销，大于0并低于10的，显示畅销，为0的显示需要无货

SELECT name,num,CASE

WHEN num>30 THEN '滞销'

WHEN num>0 AND num<10 THEN '畅销'

WHEN num=0 THEN '无货'

ELSE '正常'

END AS "库存状态"

FROM books;

# 18、统计每一种note的库存量，并合计总量

SELECT IFNULL(note,'合计总库存量') AS note,SUM(num) FROM books GROUP BY note WITH ROLLUP;

# 19、统计每一种note的数量，并合计总量

SELECT IFNULL(note,'合计总数') AS note,COUNT(*) FROM books GROUP BY note WITH ROLLUP;

# 20、统计库存量前三名的图书

SELECT * FROM books ORDER BY num DESC LIMIT 0,3;

# 21、找出最早出版的一本书

SELECT * FROM books ORDER BY pubdate ASC LIMIT 0,1;

# 22、找出novel中价格最高的一本书

SELECT * FROM books WHERE note = 'novel' ORDER BY price DESC LIMIT 0,1;

# 23、找出书名中字数最多的一本书，不含空格

SELECT * FROM books ORDER BY CHAR_LENGTH(REPLACE(name,' ','')) DESC LIMIT 0,1;

MySQL数据类型精讲

MySQL中的数据类型

类型类型举例

整数类型 TINYINT、SMALLINT、MEDIUMINT、INT(或INTEGER)、BIGINT

浮点类型 FLOAT、DOUBLE

定点数类型 DECIMAL

位类型 BIT

日期时间类型 YEAR、TIME、DATE、DATETIME、TIMESTAMP

文本字符串类型 CHAR、VARCHAR、TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT

枚举类型 ENUM

集合类型 SET

二进制字符串类型 BINARY、VARBINARY、TINYBLOB、BLOB、MEDIUMBLOB、LONGBLOB

JSON类型 JSON对象、JSON数组

空间数据类型单值类型：GEOMETRY、POINT、LINESTRING、POLYGON；

集合类型：MULTIPOINT、MULTILINESTRING、MULTIPOLYGON、GEOMETRYCOLLECTION

常见数据类型的属性，如下：

MySQL关键字含义

NULL 数据列可包含NULL值

NOT NULL 数据列不允许包含NULL值

DEFAULT 默认值

PRIMARY KEY 主键

AUTO_INCREMENT 自动递增，适用于整数类型

UNSIGNED 无符号

CHARACTER SET name 指定一个字符集

整数类型

类型介绍

整数类型一共有 5 种，包括 TINYINT、SMALLINT、MEDIUMINT、INT（INTEGER）和 BIGINT。

它们的区别如下表所示：

整数类型字节有符号数取值范围无符号数取值范围

TINYINT 1 -128~127 0~255

SMALLINT 2 -32768~32767 0~65535

MEDIUMINT 3 -8388608~8388607 0~16777215

INT、INTEGER 4 -2147483648~2147483647 0~4294967295

BIGINT 8 -9223372036854775808~9223372036854775807 0~18446744073709551615

可选属性

整数类型的可选属性有三个：

M: 表示显示宽度，M的取值范围是(0, 255)。例如，int(5)：当数据宽度小于5位的时候在数字前面需要用字符填满宽度。该项功能需要配合“ZEROFILL”使用，表示用“0”填满宽度，否则指定显示宽度无效。

如果设置了显示宽度，那么插入的数据宽度超过显示宽度限制，会不会截断或插入失败？

答案：不会对插入的数据有任何影响，还是按照类型的实际宽度进行保存，即显示宽度与类型可以存储的值范围无关。从MySQL 8.0.17开始，整数数据类型不推荐使用显示宽度属性。

整型数据类型可以在定义表结构时指定所需要的显示宽度，如果不指定，则系统为每一种类型指定默认的宽度值。

举例：

CREATE TABLE test_int1 ( x TINYINT,　y SMALLINT,　z MEDIUMINT,　m INT,　n BIGINT );

查看表结构（MySQL5.7中显式如下，MySQL8中不再显式范围）

mysql> desc test_int1;

+-------+--------------+------+-----+---------+-------+

+-------+--------------+------+-----+---------+-------+

| x | tinyint(4) | YES | | NULL | |

| y | smallint(6) | YES | | NULL | |

| z | mediumint(9) | YES | | NULL | |

| m | int(11) | YES | | NULL | |

| n | bigint(20) | YES | | NULL | |

+-------+--------------+------+-----+---------+-------+

5 rows in set (0.00 sec)

TINYINT有符号数和无符号数的取值范围分别为-128127和0255，由于负号占了一个数字位，因此TINYINT默认的显示宽度为4。同理，其他整数类型的默认显示宽度与其有符号数的最小值的宽度相同。

举例：

CREATE TABLE test_int2(

f1 INT,

f2 INT(5),

f3 INT(5) ZEROFILL

)

DESC test_int2;

INSERT INTO test_int2(f1,f2,f3)

VALUES(1,123,123);

INSERT INTO test_int2(f1,f2)

VALUES(123456,123456);

INSERT INTO test_int2(f1,f2,f3)

VALUES(123456,123456,123456);

mysql> SELECT * FROM test_int2;

+--------+--------+--------+

| f1 | f2 | f3 |

+--------+--------+--------+

| 1 | 123 | 00123 |

| 123456 | 123456 | NULL |

| 123456 | 123456 | 123456 |

+--------+--------+--------+

3 rows in set (0.00 sec)

UNSIGNED

UNSIGNED: 无符号类型（非负），所有的整数类型都有一个可选的属性UNSIGNED（无符号属性），无符号整数类型的最小取值为0。所以，如果需要在MySQL数据库中保存非负整数值时，可以将整数类型设置为无符号类型。

int类型默认显示宽度为int(11)，无符号int类型默认显示宽度为int(10)。

CREATE TABLE test_int3(

f1 INT UNSIGNED

);

mysql> desc test_int3;

+-------+------------------+------+-----+---------+-------+

+-------+------------------+------+-----+---------+-------+

| f1 | int(10) unsigned | YES | | NULL | |

+-------+------------------+------+-----+---------+-------+

1 row in set (0.00 sec)

ZEROFILL

ZEROFILL: 0填充,（如果某列是ZEROFILL，那么MySQL会自动为当前列添加UNSIGNED属性），如果指定了ZEROFILL只是表示不够M位时，用0在左边填充，如果超过M位，只要不超过数据存储范围即可。

原来，在 int(M) 中，M 的值跟 int(M) 所占多少存储空间并无任何关系。 int(3)、int(4)、int(8) 在磁盘上都是占用 4 bytes 的存储空间。也就是说，**int(M)，必须和UNSIGNED ZEROFILL一起使用才有意义。**如果整数值超过M位，就按照实际位数存储。只是无须再用字符 0 进行填充。

适用场景

TINYINT：一般用于枚举数据，比如系统设定取值范围很小且固定的场景。

SMALLINT：可以用于较小范围的统计数据，比如统计工厂的固定资产库存数量等。

MEDIUMINT：用于较大整数的计算，比如车站每日的客流量等。

INT、INTEGER：取值范围足够大，一般情况下不用考虑超限问题，用得最多。比如商品编号。

BIGINT：只有当你处理特别巨大的整数时才会用到。比如双十一的交易量、大型门户网站点击量、证券公司衍生产品持仓等。

如何选择？

在评估用哪种整数类型的时候，你需要考虑存储空间和可靠性的平衡问题：一方面，用占用字节数少的整数类型可以节省存储空间；另一方面，要是为了节省存储空间，使用的整数类型取值范围太小，一旦遇到超出取值范围的情况，就可能引起系统错误，影响可靠性。

举个例子，商品编号采用的数据类型是 INT。原因就在于，客户门店中流通的商品种类较多，而且，每天都有旧商品下架，新商品上架，这样不断迭代，日积月累。

如果使用 SMALLINT 类型，虽然占用字节数比 INT 类型的整数少，但是却不能保证数据不会超出范围 65535。相反，使用 INT，就能确保有足够大的取值范围，不用担心数据超出范围影响可靠性的问题。

你要注意的是，在实际工作中，系统故障产生的成本远远超过增加几个字段存储空间所产生的成本。因此，我建议你首先确保数据不会超过取值范围，在这个前提之下，再去考虑如何节省存储空间。

浮点类型

类型介绍

浮点数和定点数类型的特点是可以处理小数，你可以把整数看成小数的一个特例。因此，浮点数和定点数的使用场景，比整数大多了。 MySQL支持的浮点数类型，分别是 FLOAT、DOUBLE、REAL。

FLOAT 表示单精度浮点数；

DOUBLE 表示双精度浮点数；

REAL默认就是 DOUBLE。如果你把 SQL 模式设定为启用“REAL_AS_FLOAT”，那么，MySQL 就认为 REAL 是 FLOAT。如果要启用“REAL_AS_FLOAT”，可以通过以下 SQL 语句实现：

SET sql_mode = “REAL_AS_FLOAT”;

**问题1：**FLOAT 和 DOUBLE 这两种数据类型的区别是啥呢？

FLOAT 占用字节数少，取值范围小；DOUBLE 占用字节数多，取值范围也大。

**问题2：**为什么浮点数类型的无符号数取值范围，只相当于有符号数取值范围的一半，也就是只相当于有符号数取值范围大于等于零的部分呢？

MySQL 存储浮点数的格式为：符号(S)、尾数(M)和阶码(E)。因此，无论有没有符号，MySQL 的浮点数都会存储表示符号的部分。因此，所谓的无符号数取值范围，其实就是有符号数取值范围大于等于零的部分。

数据精度说明

对于浮点类型，在MySQL中单精度值使用4个字节，双精度值使用8个字节。

MySQL允许使用非标准语法（其他数据库未必支持，因此如果涉及到数据迁移，则最好不要这么用）：FLOAT(M,D)或DOUBLE(M,D)。这里，M称为精度，D称为标度。(M,D)中 M=整数位+小数位，D=小数位。 D<=M<=255，0<=D<=30。

例如，定义为FLOAT(5,2)的一个列可以显示为-999.99-999.99。如果超过这个范围会报错。

FLOAT和DOUBLE类型在不指定(M,D)时，默认会按照实际的精度（由实际的硬件和操作系统决定）来显示。

说明：浮点类型，也可以加UNSIGNED，但是不会改变数据范围，例如：FLOAT(3,2) UNSIGNED仍然只能表示0-9.99的范围。

不管是否显式设置了精度(M,D)，这里MySQL的处理方案如下：

如果存储时，整数部分超出了范围，MySQL就会报错，不允许存这样的值

如果存储时，小数点部分若超出范围，就分以下情况：

若四舍五入后，整数部分没有超出范围，则只警告，但能成功操作并四舍五入删除多余的小数位后保存。例如在FLOAT(5,2)列内插入999.009，近似结果是999.01。

若四舍五入后，整数部分超出范围，则MySQL报错，并拒绝处理。如FLOAT(5,2)列内插入999.995和-999.995都会报错。

从MySQL 8.0.17开始，FLOAT(M,D) 和DOUBLE(M,D)用法在官方文档中已经明确不推荐使用，将来可能被移除。另外，关于浮点型FLOAT和DOUBLE的UNSIGNED也不推荐使用了，将来也可能被移除。

举例

CREATE TABLE test_double1(

f1 FLOAT,

f2 FLOAT(5,2),

f3 DOUBLE,

f4 DOUBLE(5,2)

);

DESC test_double1;

INSERT INTO test_double1

VALUES(123.456,123.456,123.4567,123.45);

#Out of range value for column 'f2' at row 1

INSERT INTO test_double1

VALUES(123.456,1234.456,123.4567,123.45);

SELECT * FROM test_double1;

精度误差说明

浮点数类型有个缺陷，就是不精准。下面我来重点解释一下为什么 MySQL 的浮点数不够精准。比如，我们设计一个表，有f1这个字段，插入值分别为0.47,0.44,0.19，我们期待的运行结果是：0.47 + 0.44 + 0.19 = 1.1。而使用sum之后查询：

CREATE TABLE test_double2(

f1 DOUBLE

);

INSERT INTO test_double2

VALUES(0.47),(0.44),(0.19);

mysql> SELECT SUM(f1)

-> FROM test_double2;

+--------------------+

| SUM(f1) |

+--------------------+

| 1.0999999999999999 |

+--------------------+

1 row in set (0.00 sec)

mysql> SELECT SUM(f1) = 1.1,1.1 = 1.1

-> FROM test_double2;

+---------------+-----------+

| SUM(f1) = 1.1 | 1.1 = 1.1 |

+---------------+-----------+

| 0 | 1 |

+---------------+-----------+

1 row in set (0.00 sec)

查询结果是 1.0999999999999999。看到了吗？虽然误差很小，但确实有误差。你也可以尝试把数据类型改成 FLOAT，然后运行求和查询，得到的是， 1.0999999940395355。显然，误差更大了。

那么，为什么会存在这样的误差呢？问题还是出在 MySQL 对浮点类型数据的存储方式上。

MySQL 用 4 个字节存储 FLOAT 类型数据，用 8 个字节来存储 DOUBLE 类型数据。无论哪个，都是采用二进制的方式来进行存储的。比如 9.625，用二进制来表达，就是 1001.101，或者表达成 1.001101×2^3。如果尾数不是 0 或 5（比如 9.624），你就无法用一个二进制数来精确表达。进而，就只好在取值允许的范围内进行四舍五入。

在编程中，如果用到浮点数，要特别注意误差问题，**因为浮点数是不准确的，所以我们要避免使用“=”来判断两个数是否相等。**同时，在一些对精确度要求较高的项目中，千万不要使用浮点数，不然会导致结果错误，甚至是造成不可挽回的损失。那么，MySQL 有没有精准的数据类型呢？当然有，这就是定点数类型：DECIMAL。

定点数类型

类型介绍

MySQL中的定点数类型只有 DECIMAL 一种类型。

数据类型字节数含义

DECIMAL(M,D),DEC,NUMERIC M+2字节有效范围由M和D决定

使用 DECIMAL(M,D) 的方式表示高精度小数。其中，M被称为精度，D被称为标度。0<=M<=65，0<=D<=30，D<M。例如，定义DECIMAL（5,2）的类型，表示该列取值范围是-999.99~999.99。

DECIMAL(M,D)的最大取值范围与DOUBLE类型一样，但是有效的数据范围是由M和D决定的。DECIMAL 的存储空间并不是固定的，由精度值M决定，总共占用的存储空间为M+2个字节。也就是说，在一些对精度要求不高的场景下，比起占用同样字节长度的定点数，浮点数表达的数值范围可以更大一些。

定点数在MySQL内部是以字符串的形式进行存储，这就决定了它一定是精准的。

当DECIMAL类型不指定精度和标度时，其默认为DECIMAL(10,0)。当数据的精度超出了定点数类型的精度范围时，则MySQL同样会进行四舍五入处理。

浮点数 vs 定点数

浮点数相对于定点数的优点是在长度一定的情况下，浮点类型取值范围大，但是不精准，适用于需要取值范围大，又可以容忍微小误差的科学计算场景（比如计算化学、分子建模、流体动力学等）

定点数类型取值范围相对小，但是精准，没有误差，适合于对精度要求极高的场景（比如涉及金额计算的场景）

举例

CREATE TABLE test_decimal1(

f1 DECIMAL,

f2 DECIMAL(5,2)

);

DESC test_decimal1;

INSERT INTO test_decimal1(f1,f2)

VALUES(123.123,123.456);

#Out of range value for column 'f2' at row 1

INSERT INTO test_decimal1(f2)

VALUES(1234.34);

mysql> SELECT * FROM test_decimal1;

+------+--------+

| f1 | f2 |

+------+--------+

| 123 | 123.46 |

+------+--------+

1 row in set (0.00 sec)

举例

我们运行下面的语句，把test_double2表中字段“f1”的数据类型修改为 DECIMAL(5,2)：

ALTER TABLE test_double2

MODIFY f1 DECIMAL(5,2);

然后，我们再一次运行求和语句：

mysql> SELECT SUM(f1)

-> FROM test_double2;

+---------+

| SUM(f1) |

+---------+

| 1.10 |

+---------+

1 row in set (0.00 sec)

mysql> SELECT SUM(f1) = 1.1

-> FROM test_double2;

+---------------+

| SUM(f1) = 1.1 |

+---------------+

| 1 |

+---------------+

1 row in set (0.00 sec)

开发中经验

“由于 DECIMAL 数据类型的精准性，在我们的项目中，除了极少数（比如商品编号）用到整数类型外，其他的数值都用的是 DECIMAL，原因就是这个项目所处的零售行业，要求精准，一分钱也不能差。 ” ——来自某项目经理

位类型：BIT

BIT类型中存储的是二进制值，类似010110。

二进制字符串类型长度长度范围占用空间

BIT(M) M 1 <= M <= 64 约为(M + 7)/8个字节

BIT类型，如果没有指定(M)，默认是1位。这个1位，表示只能存1位的二进制值。这里(M)是表示二进制的位数，位数最小值为1，最大值为64。

CREATE TABLE test_bit1(

f1 BIT,

f2 BIT(5),

f3 BIT(64)

);

INSERT INTO test_bit1(f1)

VALUES(1);

#Data too long for column 'f1' at row 1

INSERT INTO test_bit1(f1)

VALUES(2);

INSERT INTO test_bit1(f2)

VALUES(23);

注意：在向BIT类型的字段中插入数据时，一定要确保插入的数据在BIT类型支持的范围内。

使用SELECT命令查询位字段时，可以用BIN()或HEX()函数进行读取。

mysql> SELECT * FROM test_bit1;

+------------+------------+------------+

| f1 | f2 | f3 |

+------------+------------+------------+

| 0x01 | NULL | NULL |

| NULL | 0x17 | NULL |

+------------+------------+------------+

2 rows in set (0.00 sec)

mysql> SELECT BIN(f2),HEX(f2)

-> FROM test_bit1;

+---------+---------+

| BIN(f2) | HEX(f2) |

+---------+---------+

| NULL | NULL |

| 10111 | 17 |

+---------+---------+

2 rows in set (0.00 sec)

mysql> SELECT f2 + 0

-> FROM test_bit1;

+--------+

| f2 + 0 |

+--------+

| NULL |

| 23 |

+--------+

2 rows in set (0.00 sec)

可以看到，使用b+0查询数据时，可以直接查询出存储的十进制数据的值。

日期与时间类型

日期与时间是重要的信息，在我们的系统中，几乎所有的数据表都用得到。原因是客户需要知道数据的时间标签，从而进行数据查询、统计和处理。

MySQL有多种表示日期和时间的数据类型，不同的版本可能有所差异，MySQL8.0版本支持的日期和时间类型主要有：YEAR类型、TIME类型、DATE类型、DATETIME类型和TIMESTAMP类型。

YEAR类型通常用来表示年

DATE类型通常用来表示年、月、日

TIME类型通常用来表示时、分、秒

DATETIME类型通常用来表示年、月、日、时、分、秒

TIMESTAMP类型通常用来表示带时区的年、月、日、时、分、秒

类型名称字节日期格式最小值最大值

YEAR 年 1 YYYY或YY 1901 2155

TIME 时间 3 HH:MM:SS -838:59:59 838:59:59

DATE 日期 3 YYYY-MM-DD 1000-01-01 9999-12-03

DATETIME 日期时间 8 YYYY-MM-DD HH:MM:SS 1000-01-01 00:00:00 9999-12-31 23:59:59

TIMESTAMP 日期时间 4 YYYY-MM-DD HH:MM:SS 1970-01-01 00:00:00 UTC 2038-01-19 03:14:07UTC

可以看到，不同数据类型表示的时间内容不同、取值范围不同，而且占用的字节数也不一样，你要根据实际需要灵活选取。

为什么时间类型 TIME 的取值范围不是 -23:59:59～23:59:59 呢？原因是 MySQL 设计的 TIME 类型，不光表示一天之内的时间，而且可以用来表示一个时间间隔，这个时间间隔可以超过 24 小时。

YEAR类型

YEAR类型用来表示年份，在所有的日期时间类型中所占用的存储空间最小，只需要1个字节的存储空间。

在MySQL中，YEAR有以下几种存储格式：

以4位字符串或数字格式表示YEAR类型，其格式为YYYY，最小值为1901，最大值为2155。

以2位字符串格式表示YEAR类型，最小值为00，最大值为99。

当取值为01到69时，表示2001到2069；

当取值为70到99时，表示1970到1999；

当取值整数的0或00添加的话，那么是0000年；

当取值是日期/字符串的’0’添加的话，是2000年。

从MySQL5.5.27开始，2位格式的YEAR已经不推荐使用。YEAR默认格式就是“YYYY”，没必要写成YEAR(4)，从MySQL 8.0.19开始，不推荐使用指定显示宽度的YEAR(4)数据类型。

CREATE TABLE test_year(

f1 YEAR,

f2 YEAR(4)

);

mysql> DESC test_year;

+-------+---------+------+-----+---------+-------+

+-------+---------+------+-----+---------+-------+

| f1 | year(4) | YES | | NULL | |

| f2 | year(4) | YES | | NULL | |

+-------+---------+------+-----+---------+-------+

2 rows in set (0.00 sec)

INSERT INTO test_year

VALUES('2020','2021');

mysql> SELECT * FROM test_year;

+------+------+

| f1 | f2 |

+------+------+

| 2020 | 2021 |

+------+------+

1 rows in set (0.00 sec)

INSERT INTO test_year

VALUES('45','71');

INSERT INTO test_year

VALUES(0,'0');

mysql> SELECT * FROM test_year;

+------+------+

| f1 | f2 |

+------+------+

| 2020 | 2021 |

| 2045 | 1971 |

| 0000 | 2000 |

+------+------+

3 rows in set (0.00 sec)

DATE类型

DATE类型表示日期，没有时间部分，格式为YYYY-MM-DD，其中，YYYY表示年份，MM表示月份，DD表示日期。需要3个字节的存储空间。在向DATE类型的字段插入数据时，同样需要满足一定的格式条件。

以YYYY-MM-DD格式或者YYYYMMDD格式表示的字符串日期，其最小取值为1000-01-01，最大取值为9999-12-03。YYYYMMDD格式会被转化为YYYY-MM-DD格式。

以YY-MM-DD格式或者YYMMDD格式表示的字符串日期，此格式中，年份为两位数值或字符串满足YEAR类型的格式条件为：当年份取值为00到69时，会被转化为2000到2069；当年份取值为70到99时，会被转化为1970到1999。

使用CURRENT_DATE()或者NOW()函数，会插入当前系统的日期。

举例：

创建数据表，表中只包含一个DATE类型的字段f1。

CREATE TABLE test_date1(

f1 DATE

);

Query OK, 0 rows affected (0.13 sec)

插入数据：

INSERT INTO test_date1

VALUES ('2020-10-01'), ('20201001'),(20201001);

INSERT INTO test_date1

VALUES ('00-01-01'), ('000101'), ('69-10-01'), ('691001'), ('70-01-01'), ('700101'), ('99-01-01'), ('990101');

INSERT INTO test_date1

VALUES (000301), (690301), (700301), (990301);

INSERT INTO test_date1

VALUES (CURRENT_DATE()), (NOW());

SELECT *

FROM test_date1;

TIME类型

TIME类型用来表示时间，不包含日期部分。在MySQL中，需要3个字节的存储空间来存储TIME类型的数据，可以使用“HH:MM:SS”格式来表示TIME类型，其中，HH表示小时，MM表示分钟，SS表示秒。

在MySQL中，向TIME类型的字段插入数据时，也可以使用几种不同的格式。

（1）可以使用带有冒号的字符串，比如’D HH:MM:SS'、’HH:MM:SS’、’HH:MM’、’D HH:MM’、’D HH‘或’SS‘格式，都能被正确地插入TIME类型的字段中。其中D表示天，其最小值为0，最大值为34。如果使用带有D格式的字符串插入TIME类型的字段时，D会被转化为小时，计算格式为D*24+HH。当使用带有冒号并且不带D的字符串表示时间时，表示当天的时间，比如12:10表示12:10:00，而不是00:12:10。

（2）可以使用不带有冒号的字符串或者数字，格式为’HHMMSS'或者HHMMSS。如果插入一个不合法的字符串或者数字，MySQL在存储数据时，会将其自动转化为00:00:00进行存储。比如1210，MySQL会将最右边的两位解析成秒，表示00:12:10，而不是12:10:00。

（3）使用CURRENT_TIME()或者NOW()，会插入当前系统的时间。

举例：

创建数据表，表中包含一个TIME类型的字段f1。

CREATE TABLE test_time1(

f1 TIME

);

Query OK, 0 rows affected (0.02 sec)

INSERT INTO test_time1

VALUES('2 12:30:29'), ('12:35:29'), ('12:40'), ('2 12:40'),('1 05'), ('45');

INSERT INTO test_time1

VALUES ('123520'), (124011),(1210);

INSERT INTO test_time1

VALUES (NOW()), (CURRENT_TIME());

SELECT * FROM test_time1;

DATETIME类型

DATETIME类型在所有的日期时间类型中占用的存储空间最大，总共需要8个字节的存储空间。在格式上为DATE类型和TIME类型的组合，可以表示为YYYY-MM-DD HH:MM:SS，其中YYYY表示年份，MM表示月份，DD表示日期，HH表示小时，MM表示分钟，SS表示秒。

在向DATETIME类型的字段插入数据时，同样需要满足一定的格式条件。

以YYYY-MM-DD HH:MM:SS格式或者YYYYMMDDHHMMSS格式的字符串插入DATETIME类型的字段时，最小值为1000-01-01 00:00:00，最大值为9999-12-03 23:59:59。

以YYYYMMDDHHMMSS格式的数字插入DATETIME类型的字段时，会被转化为YYYY-MM-DD HH:MM:SS格式。

以YY-MM-DD HH:MM:SS格式或者YYMMDDHHMMSS格式的字符串插入DATETIME类型的字段时，两位数的年份规则符合YEAR类型的规则，00到69表示2000到2069；70到99表示1970到1999。

使用函数CURRENT_TIMESTAMP()和NOW()，可以向DATETIME类型的字段插入系统的当前日期和时间。

举例：

创建数据表，表中包含一个DATETIME类型的字段dt。

CREATE TABLE test_datetime1(

dt DATETIME

);

Query OK, 0 rows affected (0.02 sec)

插入数据：

INSERT INTO test_datetime1

VALUES ('2021-01-01 06:50:30'), ('20210101065030');

INSERT INTO test_datetime1

VALUES ('99-01-01 00:00:00'), ('990101000000'), ('20-01-01 00:00:00'), ('200101000000');

INSERT INTO test_datetime1

VALUES (20200101000000), (200101000000), (19990101000000), (990101000000);

INSERT INTO test_datetime1

VALUES (CURRENT_TIMESTAMP()), (NOW());

TIMESTAMP类型

TIMESTAMP类型也可以表示日期时间，其显示格式与DATETIME类型相同，都是YYYY-MM-DD HH:MM:SS，需要4个字节的存储空间。但是TIMESTAMP存储的时间范围比DATETIME要小很多，只能存储“1970-01-01 00:00:01 UTC”到“2038-01-19 03:14:07 UTC”之间的时间。其中，UTC表示世界统一时间，也叫作世界标准时间。

存储数据的时候需要对当前时间所在的时区进行转换，查询数据的时候再将时间转换回当前的时区。因此，使用TIMESTAMP存储的同一个时间值，在不同的时区查询时会显示不同的时间。

向TIMESTAMP类型的字段插入数据时，当插入的数据格式满足YY-MM-DD HH:MM:SS和YYMMDDHHMMSS时，两位数值的年份同样符合YEAR类型的规则条件，只不过表示的时间范围要小很多。

如果向TIMESTAMP类型的字段插入的时间超出了TIMESTAMP类型的范围，则MySQL会抛出错误信息。

举例：

创建数据表，表中包含一个TIMESTAMP类型的字段ts。

CREATE TABLE test_timestamp1(

ts TIMESTAMP

);

插入数据：

INSERT INTO test_timestamp1

VALUES ('1999-01-01 03:04:50'), ('19990101030405'), ('99-01-01 03:04:05'), ('990101030405');

INSERT INTO test_timestamp1

VALUES ('2020@01@01@00@00@00'), ('20@01@01@00@00@00');

INSERT INTO test_timestamp1

VALUES (CURRENT_TIMESTAMP()), (NOW());

#Incorrect datetime value

INSERT INTO test_timestamp1

VALUES ('2038-01-20 03:14:07');

TIMESTAMP和DATETIME的区别：

TIMESTAMP存储空间比较小，表示的日期时间范围也比较小

底层存储方式不同，TIMESTAMP底层存储的是毫秒值，距离1970-1-1 0:0:0 0毫秒的毫秒值。

两个日期比较大小或日期计算时，TIMESTAMP更方便、更快。

TIMESTAMP和时区有关。TIMESTAMP会根据用户的时区不同，显示不同的结果。而DATETIME则只能反映出插入时当地的时区，其他时区的人查看数据必然会有误差的。

CREATE TABLE temp_time(

d1 DATETIME,

d2 TIMESTAMP

);

INSERT INTO temp_time VALUES('2021-9-2 14:45:52','2021-9-2 14:45:52');

INSERT INTO temp_time VALUES(NOW(),NOW());

mysql> SELECT * FROM temp_time;

+---------------------+---------------------+

| d1 | d2 |

+---------------------+---------------------+

| 2021-09-02 14:45:52 | 2021-09-02 14:45:52 |

| 2021-11-03 17:38:17 | 2021-11-03 17:38:17 |

+---------------------+---------------------+

2 rows in set (0.00 sec)

#修改当前的时区

SET time_zone = '+9:00';

mysql> SELECT * FROM temp_time;

+---------------------+---------------------+

| d1 | d2 |

+---------------------+---------------------+

| 2021-09-02 14:45:52 | 2021-09-02 15:45:52 |

| 2021-11-03 17:38:17 | 2021-11-03 18:38:17 |

+---------------------+---------------------+

2 rows in set (0.00 sec)

开发中经验

用得最多的日期时间类型，就是 DATETIME。虽然 MySQL 也支持 YEAR（年）、 TIME（时间）、DATE（日期），以及 TIMESTAMP 类型，但是在实际项目中，尽量用 DATETIME 类型。因为这个数据类型包括了完整的日期和时间信息，取值范围也最大，使用起来比较方便。毕竟，如果日期时间信息分散在好几个字段，很不容易记，而且查询的时候，SQL 语句也会更加复杂。

此外，一般存注册时间、商品发布时间等，不建议使用DATETIME存储，而是使用时间戳，因为DATETIME虽然直观，但不便于计算。

mysql> SELECT UNIX_TIMESTAMP();

+------------------+

| UNIX_TIMESTAMP() |

+------------------+

| 1635932762 |

+------------------+

1 row in set (0.00 sec)

文本字符串类型

在实际的项目中，我们还经常遇到一种数据，就是字符串数据。

MySQL中，文本字符串总体上分为CHAR、VARCHAR、TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT、ENUM、SET等类型。

CHAR与VARCHAR类型

CHAR和VARCHAR类型都可以存储比较短的字符串。

字符串(文本)类型特点长度长度范围占用的存储空间

CHAR(M) 固定长度 M 0 <= M <= 255 M个字节

VARCHAR(M) 可变长度 M 0 <= M <= 65535 (实际长度 + 1) 个字节

CHAR类型：

CHAR(M) 类型一般需要预先定义字符串长度。如果不指定(M)，则表示长度默认是1个字符。

如果保存时，数据的实际长度比CHAR类型声明的长度小，则会在右侧填充空格以达到指定的长度。当MySQL检索CHAR类型的数据时，CHAR类型的字段会去除尾部的空格。

定义CHAR类型字段时，声明的字段长度即为CHAR类型字段所占的存储空间的字节数。

CREATE TABLE test_char1(

c1 CHAR,

c2 CHAR(5)

);

DESC test_char1;

INSERT INTO test_char1

VALUES('a','Tom');

SELECT c1,CONCAT(c2,'***') FROM test_char1;

INSERT INTO test_char1(c2)

VALUES('a ');

SELECT CHAR_LENGTH(c2)

FROM test_char1;

VARCHAR类型：

VARCHAR(M) 定义时，必须指定长度M，否则报错。

MySQL4.0版本以下，varchar(20)：指的是20字节，如果存放UTF8汉字时，只能存6个（每个汉字3字节）；MySQL5.0版本以上，varchar(20)：指的是20字符。

检索VARCHAR类型的字段数据时，会保留数据尾部的空格。VARCHAR类型的字段所占用的存储空间为字符串实际长度加1个字节。

CREATE TABLE test_varchar1(

NAME VARCHAR #错误

);

#Column length too big for column 'NAME' (max = 21845);

CREATE TABLE test_varchar2(

NAME VARCHAR(65535) #错误

);

CREATE TABLE test_varchar3(

NAME VARCHAR(5)

);

INSERT INTO test_varchar3

VALUES('尚硅谷'),('尚硅谷教育');

#Data too long for column 'NAME' at row 1

INSERT INTO test_varchar3

VALUES('尚硅谷IT教育');

哪些情况使用 CHAR 或 VARCHAR 更好

类型特点空间上时间上适用场景

CHAR(M) 固定长度浪费存储空间效率高存储不大，速度要求高

VARCHAR(M) 可变长度节省存储空间效率低非CHAR的情况

情况1：存储很短的信息。比如门牌号码101，201……这样很短的信息应该用char，因为varchar还要占个byte用于存储信息长度，本来打算节约存储的，结果得不偿失。

情况2：固定长度的。比如使用uuid作为主键，那用char应该更合适。因为他固定长度，varchar动态根据长度的特性就消失了，而且还要占个长度信息。

情况3：十分频繁改变的column。因为varchar每次存储都要有额外的计算，得到长度等工作，如果一个非常频繁改变的，那就要有很多的精力用于计算，而这些对于char来说是不需要的。

情况4：具体存储引擎中的情况：

MyISAM 数据存储引擎和数据列：MyISAM数据表，最好使用固定长度(CHAR)的数据列代替可变长度(VARCHAR)的数据列。这样使得整个表静态化，从而使数据检索更快，用空间换时间。

MEMORY 存储引擎和数据列：MEMORY数据表目前都使用固定长度的数据行存储，因此无论使用CHAR或VARCHAR列都没有关系，两者都是作为CHAR类型处理的。

InnoDB存储引擎，建议使用VARCHAR类型。因为对于InnoDB数据表，内部的行存储格式并没有区分固定长度和可变长度列（所有数据行都使用指向数据列值的头指针），而且主要影响性能的因素是数据行使用的存储总量，由于char平均占用的空间多于varchar，所以除了简短并且固定长度的，其他考虑varchar。这样节省空间，对磁盘I/O和数据存储总量比较好。

TEXT类型

在MySQL中，TEXT用来保存文本类型的字符串，总共包含4种类型，分别为TINYTEXT、TEXT、MEDIUMTEXT 和 LONGTEXT 类型。

在向TEXT类型的字段保存和查询数据时，系统自动按照实际长度存储，不需要预先定义长度。这一点和 VARCHAR类型相同。

每种TEXT类型保存的数据长度和所占用的存储空间不同，如下：

文本字符串类型特点长度长度范围占用的存储空间

TINYTEXT 小文本、可变长度 L 0 <= L <= 255 L + 2 个字节

TEXT 文本、可变长度 L 0 <= L <= 65535 L + 2 个字节

MEDIUMTEXT 中等文本、可变长度 L 0 <= L <= 16777215 L + 3 个字节

LONGTEXT 大文本、可变长度 L 0 <= L<= 4294967295（相当于4GB） L + 4 个字节

由于实际存储的长度不确定，MySQL 不允许 TEXT 类型的字段做主键。遇到这种情况，你只能采用 CHAR(M)，或者 VARCHAR(M)。

举例：

创建数据表：

CREATE TABLE test_text(

tx TEXT

);

INSERT INTO test_text

VALUES('atguigu ');

SELECT CHAR_LENGTH(tx)

FROM test_text; #10

说明在保存和查询数据时，并没有删除TEXT类型的数据尾部的空格。

开发中经验：

TEXT文本类型，可以存比较大的文本段，搜索速度稍慢，因此如果不是特别大的内容，建议使用CHAR，VARCHAR来代替。还有TEXT类型不用加默认值，加了也没用。而且text和blob类型的数据删除后容易导致“空洞”，使得文件碎片比较多，所以频繁使用的表不建议包含TEXT类型字段，建议单独分出去，单独用一个表。

ENUM类型

ENUM类型也叫作枚举类型，ENUM类型的取值范围需要在定义字段时进行指定。设置字段值时，ENUM类型只允许从成员中选取单个值，不能一次选取多个值。

其所需要的存储空间由定义ENUM类型时指定的成员个数决定。

文本字符串类型长度长度范围占用的存储空间

ENUM L 1 <= L <= 65535 1或2个字节

当ENUM类型包含1～255个成员时，需要1个字节的存储空间；

当ENUM类型包含256～65535个成员时，需要2个字节的存储空间。

ENUM类型的成员个数的上限为65535个。

举例：

创建表如下：

CREATE TABLE test_enum(

season ENUM('春','夏','秋','冬','unknow')

);

添加数据：

INSERT INTO test_enum

VALUES('春'),('秋');

# 忽略大小写

INSERT INTO test_enum

VALUES('UNKNOW');

# 允许按照角标的方式获取指定索引位置的枚举值

INSERT INTO test_enum

VALUES('1'),(3);

# Data truncated for column 'season' at row 1

INSERT INTO test_enum

VALUES('ab');

# 当ENUM类型的字段没有声明为NOT NULL时，插入NULL也是有效的

INSERT INTO test_enum

VALUES(NULL);

SET类型

SET表示一个字符串对象，可以包含0个或多个成员，但成员个数的上限为64。设置字段值时，可以取取值范围内的 0 个或多个值。

当SET类型包含的成员个数不同时，其所占用的存储空间也是不同的，具体如下：

成员个数范围（L表示实际成员个数）占用的存储空间

1 <= L <= 8 1个字节

9 <= L <= 16 2个字节

17 <= L <= 24 3个字节

25 <= L <= 32 4个字节

33 <= L <= 64 8个字节

SET类型在存储数据时成员个数越多，其占用的存储空间越大。注意：SET类型在选取成员时，可以一次选择多个成员，这一点与ENUM类型不同。

举例：

创建表：

CREATE TABLE test_set(

s SET ('A', 'B', 'C')

);

向表中插入数据：

INSERT INTO test_set (s) VALUES ('A'), ('A,B');

#插入重复的SET类型成员时，MySQL会自动删除重复的成员

INSERT INTO test_set (s) VALUES ('A,B,C,A');

#向SET类型的字段插入SET成员中不存在的值时，MySQL会抛出错误。

INSERT INTO test_set (s) VALUES ('A,B,C,D');

SELECT *

FROM test_set;

举例：

CREATE TABLE temp_mul(

gender ENUM('男','女'),

hobby SET('吃饭','睡觉','打豆豆','写代码')

);

INSERT INTO temp_mul VALUES('男','睡觉,打豆豆'); #成功

# Data truncated for column 'gender' at row 1

INSERT INTO temp_mul VALUES('男,女','睡觉,写代码'); #失败

# Data truncated for column 'gender' at row 1

INSERT INTO temp_mul VALUES('妖','睡觉,写代码');#失败

INSERT INTO temp_mul VALUES('男','睡觉,写代码,吃饭'); #成功

二进制字符串类型

MySQL中的二进制字符串类型主要存储一些二进制数据，比如可以存储图片、音频和视频等二进制数据。

MySQL中支持的二进制字符串类型主要包括BINARY、VARBINARY、TINYBLOB、BLOB、MEDIUMBLOB 和 LONGBLOB类型。

BINARY与VARBINARY类型

BINARY和VARBINARY类似于CHAR和VARCHAR，只是它们存储的是二进制字符串。

BINARY (M)为固定长度的二进制字符串，M表示最多能存储的字节数，取值范围是0~255个字符。如果未指定(M)，表示只能存储1个字节。例如BINARY (8)，表示最多能存储8个字节，如果字段值不足(M)个字节，将在右边填充’\0’以补齐指定长度。

VARBINARY (M)为可变长度的二进制字符串，M表示最多能存储的字节数，总字节数不能超过行的字节长度限制65535，另外还要考虑额外字节开销，VARBINARY类型的数据除了存储数据本身外，还需要1或2个字节来存储数据的字节数。VARBINARY类型必须指定(M)，否则报错。

二进制字符串类型特点值的长度占用空间

BINARY(M) 固定长度 M （0 <= M <= 255） M个字节

VARBINARY(M) 可变长度 M（0 <= M <= 65535） M+1个字节

举例：

创建表：

CREATE TABLE test_binary1(

f1 BINARY,

f2 BINARY(3),

# f3 VARBINARY,

f4 VARBINARY(10)

);

添加数据：

INSERT INTO test_binary1(f1,f2)

VALUES('a','a');

INSERT INTO test_binary1(f1,f2)

VALUES('尚','尚');#失败

INSERT INTO test_binary1(f2,f4)

VALUES('ab','ab');

mysql> SELECT LENGTH(f2),LENGTH(f4)

-> FROM test_binary1;

+------------+------------+

| LENGTH(f2) | LENGTH(f4) |

+------------+------------+

| 3 | NULL |

| 3 | 2 |

+------------+------------+

2 rows in set (0.00 sec)

BLOB类型

BLOB是一个二进制大对象，可以容纳可变数量的数据。

MySQL中的BLOB类型包括TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB 4种类型，它们可容纳值的最大长度不同。可以存储一个二进制的大对象，比如图片、音频和视频等。

需要注意的是，在实际工作中，往往不会在MySQL数据库中使用BLOB类型存储大对象数据，通常会将图片、音频和视频文件存储到服务器的磁盘上，并将图片、音频和视频的访问路径存储到MySQL中。

二进制字符串类型值的长度长度范围占用空间

TINYBLOB L 0 <= L <= 255 L + 1 个字节

BLOB L 0 <= L <= 65535（相当于64KB） L + 2 个字节

MEDIUMBLOB L 0 <= L <= 16777215 （相当于16MB） L + 3 个字节

LONGBLOB L 0 <= L <= 4294967295（相当于4GB） L + 4 个字节

举例：

CREATE TABLE test_blob1(

id INT,

img MEDIUMBLOB

);

TEXT和BLOB的使用注意事项：

在使用text和blob字段类型时要注意以下几点，以便更好的发挥数据库的性能。

① BLOB和TEXT值也会引起自己的一些问题，特别是执行了大量的删除或更新操作的时候。删除这种值会在数据表中留下很大的"空洞"，以后填入这些"空洞"的记录可能长度不同。为了提高性能，建议定期使用 OPTIMIZE TABLE 功能对这类表进行碎片整理。

② 如果需要对大文本字段进行模糊查询，MySQL 提供了前缀索引。但是仍然要在不必要的时候避免检索大型的BLOB或TEXT值。例如，SELECT * 查询就不是很好的想法，除非你能够确定作为约束条件的WHERE子句只会找到所需要的数据行。否则，你可能毫无目的地在网络上传输大量的值。

③ 把BLOB或TEXT列分离到单独的表中。在某些环境中，如果把这些数据列移动到第二张数据表中，可以让你把原数据表中的数据列转换为固定长度的数据行格式，那么它就是有意义的。这会减少主表中的碎片，使你得到固定长度数据行的性能优势。它还使你在主数据表上运行 SELECT * 查询的时候不会通过网络传输大量的BLOB或TEXT值。

JSON 类型

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。它易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。JSON 可以将 JavaScript 对象中表示的一组数据转换为字符串，然后就可以在网络或者程序之间轻松地传递这个字符串，并在需要的时候将它还原为各编程语言所支持的数据格式。

在MySQL 5.7中，就已经支持JSON数据类型。在MySQL 8.x版本中，JSON类型提供了可以进行自动验证的JSON文档和优化的存储结构，使得在MySQL中存储和读取JSON类型的数据更加方便和高效。

创建数据表，表中包含一个JSON类型的字段 js 。

CREATE TABLE test_json(

js json

);

向表中插入JSON数据。

INSERT INTO test_json (js)

VALUES ('{"name":"songhk", "age":18, "address":{"province":"beijing", "city":"beijing"}}');

查询t19表中的数据。

mysql> SELECT *

-> FROM test_json;

当需要检索JSON类型的字段中数据的某个具体值时，可以使用“->”和“->>”符号。

mysql> SELECT js -> '$.name' AS NAME,js -> '$.age' AS age ,js -> '$.address.province' AS province, js -> '$.address.city' AS city

-> FROM test_json;

+----------+------+-----------+-----------+

+----------+------+-----------+-----------+

+----------+------+-----------+-----------+

1 row in set (0.00 sec)

通过“->”和“->>”符号，从JSON字段中正确查询出了指定的JSON数据的值。

空间类型

MySQL 空间类型扩展支持地理特征的生成、存储和分析。这里的地理特征表示世界上具有位置的任何东西，可以是一个实体，例如一座山；可以是空间，例如一座办公楼；也可以是一个可定义的位置，例如一个十字路口等等。MySQL中使用Geometry（几何）来表示所有地理特征。Geometry指一个点或点的集合，代表世界上任何具有位置的事物。

MySQL的空间数据类型（Spatial Data Type）对应于OpenGIS类，包括单值类型：GEOMETRY、POINT、LINESTRING、POLYGON以及集合类型：MULTIPOINT、MULTILINESTRING、MULTIPOLYGON、GEOMETRYCOLLECTION 。

Geometry是所有空间集合类型的基类，其他类型如POINT、LINESTRING、POLYGON都是Geometry的子类。

Point，顾名思义就是点，有一个坐标值。例如POINT(121.213342 31.234532)，POINT(30 10)，坐标值支持DECIMAL类型，经度（longitude）在前，维度（latitude）在后，用空格分隔。

LineString，线，由一系列点连接而成。如果线从头至尾没有交叉，那就是简单的（simple）；如果起点和终点重叠，那就是封闭的（closed）。例如LINESTRING(30 10,10 30,40 40)，点与点之间用逗号分隔，一个点中的经纬度用空格分隔，与POINT格式一致。

Polygon，多边形。可以是一个实心平面形，即没有内部边界，也可以有空洞，类似纽扣。最简单的就是只有一个外边界的情况，例如POLYGON((0 0,10 0,10 10, 0 10))。

下面展示几种常见的几何图形元素：

MultiPoint、MultiLineString、MultiPolygon、GeometryCollection 这4种类型都是集合类，是多个Point、LineString或Polygon组合而成。

下面展示的是多个同类或异类几何图形元素的组合：

小结及选择建议

在定义数据类型时，如果确定是整数，就用INT；如果是小数，一定用定点数类型 DECIMAL(M,D)；如果是日期与时间，就用 DATETIME。

这样做的好处是，首先确保你的系统不会因为数据类型定义出错。不过，凡事都是有两面的，可靠性好，并不意味着高效。比如，TEXT 虽然使用方便，但是效率不如 CHAR(M) 和 VARCHAR(M)。

关于字符串的选择，建议参考如下阿里巴巴的《Java开发手册》规范：

阿里巴巴《Java开发手册》之MySQL数据库：

任何字段如果为非负数，必须是 UNSIGNED

【强制】小数类型为 DECIMAL，禁止使用 FLOAT 和 DOUBLE。

说明：在存储的时候，FLOAT 和 DOUBLE 都存在精度损失的问题，很可能在比较值的时候，得到不正确的结果。如果存储的数据范围超过 DECIMAL 的范围，建议将数据拆成整数和小数并分开存储。

【强制】如果存储的字符串长度几乎相等，使用 CHAR 定长字符串类型。

【强制】VARCHAR 是可变长字符串，不预先分配存储空间，长度不要超过 5000。如果存储长度大于此值，定义字段类型为 TEXT，独立出来一张表，用主键来对应，避免影响其它字段索引效率。

约束

约束(constraint)概述

为什么需要约束

数据完整性（Data Integrity）是指数据的精确性（Accuracy）和可靠性（Reliability）。它是防止数据库中存在不符合语义规定的数据和防止因错误信息的输入输出造成无效操作或错误信息而提出的。

为了保证数据的完整性，SQL规范以约束的方式对表数据进行额外的条件限制。从以下四个方面考虑：

实体完整性（Entity Integrity）：例如，同一个表中，不能存在两条完全相同无法区分的记录

域完整性（Domain Integrity）：例如：年龄范围0-120，性别范围“男/女”

引用完整性（Referential Integrity）：例如：员工所在部门，在部门表中要能找到这个部门

用户自定义完整性（User-defined Integrity）：例如：用户名唯一、密码不能为空等，本部门经理的工资不得高于本部门职工的平均工资的5倍。

什么是约束

约束是表级的强制规定。

可以在创建表时规定约束（通过 CREATE TABLE 语句），或者在表创建之后通过 ALTER TABLE 语句规定约束。

约束的分类

**根据约束数据列的限制，**约束可分为：

单列约束：每个约束只约束一列

多列约束：每个约束可约束多列数据

根据约束的作用范围，约束可分为：

列级约束：只能作用在一个列上，跟在列的定义后面

表级约束：可以作用在多个列上，不与列一起，而是单独定义

位置支持的约束类型是否可以起约束名

列级约束列的后面语法都支持，但外键没有效果不可以

表级约束所有列的下面默认和非空不支持，其它支持可以（主键没有效果）

根据约束起的作用，约束可分为：

NOT NULL 非空约束，规定某个字段不能为空

UNIQUE 唯一约束，规定某个字段在整个表中是唯一的

PRIMARY KEY 主键(非空且唯一)约束

FOREIGN KEY 外键约束

CHECK 检查约束

DEFAULT 默认值约束

注意： MySQL不支持check约束，但可以使用check约束，而没有任何效果

查看某个表已有的约束

#information_schema数据库名（系统库）

#table_constraints表名称（专门存储各个表的约束）

SELECT * FROM information_schema.table_constraints

WHERE table_name = '表名称';

非空约束

作用

限定某个字段/某列的值不允许为空

关键字

NOT NULL

特点

默认，所有的类型的值都可以是NULL，包括INT、FLOAT等数据类型

非空约束只能出现在表对象的列上，只能某个列单独限定非空，不能组合非空

一个表可以有很多列都分别限定了非空

空字符串’'不等于NULL，0也不等于NULL

添加非空约束

（1）建表时

CREATE TABLE 表名称(

字段名数据类型,

字段名数据类型 NOT NULL,

字段名数据类型 NOT NULL

);

举例：

CREATE TABLE emp(

id INT(10) NOT NULL,

NAME VARCHAR(20) NOT NULL,

sex CHAR NULL

);

CREATE TABLE student(

sid int,

sname varchar(20) not null,

tel char(11) ,

cardid char(18) not null

);

insert into student values(1,'张三','13710011002','110222198912032545'); #成功

insert into student values(2,'李四','13710011002',null);#身份证号为空

ERROR 1048 (23000): Column 'cardid' cannot be null

insert into student values(2,'李四',null,'110222198912032546');#成功，tel允许为空

insert into student values(3,null,null,'110222198912032547');#失败

ERROR 1048 (23000): Column 'sname' cannot be null

（2）建表后

alter table 表名称 modify 字段名数据类型 not null;

举例：

ALTER TABLE emp

MODIFY sex VARCHAR(30) NOT NULL;

alter table student modify sname varchar(20) not null;

删除非空约束

alter table 表名称 modify 字段名数据类型 NULL;#去掉not null，相当于修改某个非注解字段，该字段允许为空

或

alter table 表名称 modify 字段名数据类型;#去掉not null，相当于修改某个非注解字段，该字段允许为空

举例：

ALTER TABLE emp

MODIFY sex VARCHAR(30) NULL;

ALTER TABLE emp

MODIFY NAME VARCHAR(15) DEFAULT 'abc' NULL;

唯一性约束

作用

用来限制某个字段/某列的值不能重复。

关键字

UNIQUE

特点

同一个表可以有多个唯一约束。

唯一约束可以是某一个列的值唯一，也可以多个列组合的值唯一。

唯一性约束允许列值为空。

在创建唯一约束的时候，如果不给唯一约束命名，就默认和列名相同。

MySQL会给唯一约束的列上默认创建一个唯一索引。

添加唯一约束

（1）建表时

create table 表名称(

字段名数据类型,

字段名数据类型 unique,

字段名数据类型 unique key,

字段名数据类型

);

create table 表名称(

字段名数据类型,

[constraint 约束名] unique key(字段名)

);

举例：

create table student(

sid int,

sname varchar(20),

tel char(11) unique,

cardid char(18) unique key

);

CREATE TABLE t_course(

cid INT UNIQUE,

cname VARCHAR(100) UNIQUE,

description VARCHAR(200)

);

CREATE TABLE USER(

id INT NOT NULL,

NAME VARCHAR(25),

PASSWORD VARCHAR(16),

-- 使用表级约束语法

CONSTRAINT uk_name_pwd UNIQUE(NAME,PASSWORD)

);

表示用户名和密码组合不能重复

insert into student values(1,'张三','13710011002','101223199012015623');

insert into student values(2,'李四','13710011003','101223199012015624');

mysql> select * from student;

+-----+-------+-------------+--------------------+

| sid | sname | tel | cardid |

+-----+-------+-------------+--------------------+

| 1 | 张三 | 13710011002 | 101223199012015623 |

| 2 | 李四 | 13710011003 | 101223199012015624 |

+-----+-------+-------------+--------------------+

2 rows in set (0.00 sec)

insert into student values(3,'王五','13710011004','101223199012015624'); #身份证号重复

ERROR 1062 (23000): Duplicate entry '101223199012015624' for key 'cardid'

insert into student values(3,'王五','13710011003','101223199012015625');

ERROR 1062 (23000): Duplicate entry '13710011003' for key 'tel'

（2）建表后指定唯一键约束

#字段列表中如果是一个字段，表示该列的值唯一。如果是两个或更多个字段，那么复合唯一，即多个字段的组合是唯一的

#方式1：

alter table 表名称 add unique key(字段列表);

#方式2：

alter table 表名称 modify 字段名字段类型 unique;

举例：

ALTER TABLE USER

ADD UNIQUE(NAME,PASSWORD);

ALTER TABLE USER

ADD CONSTRAINT uk_name_pwd UNIQUE(NAME,PASSWORD);

ALTER TABLE USER

MODIFY NAME VARCHAR(20) UNIQUE;

举例：

create table student(

sid int primary key,

sname varchar(20),

tel char(11) ,

cardid char(18)

);

alter table student add unique key(tel);

alter table student add unique key(cardid);

关于复合唯一约束

create table 表名称(

字段名数据类型,

unique key(字段列表) #字段列表中写的是多个字段名，多个字段名用逗号分隔，表示那么是复合唯一，即多个字段的组合是唯一的

);

#学生表

create table student(

sid int, #学号

sname varchar(20), #姓名

tel char(11) unique key, #电话

cardid char(18) unique key #身份证号

);

#课程表

create table course(

cid int, #课程编号

cname varchar(20) #课程名称

);

#选课表

create table student_course(

id int,

sid int,

cid int,

score int,

unique key(sid,cid) #复合唯一

);

insert into student values(1,'张三','13710011002','101223199012015623');#成功

insert into student values(2,'李四','13710011003','101223199012015624');#成功

insert into course values(1001,'Java'),(1002,'MySQL');#成功

mysql> select * from student;

+-----+-------+-------------+--------------------+

| sid | sname | tel | cardid |

+-----+-------+-------------+--------------------+

| 1 | 张三 | 13710011002 | 101223199012015623 |

| 2 | 李四 | 13710011003 | 101223199012015624 |

+-----+-------+-------------+--------------------+

2 rows in set (0.00 sec)

mysql> select * from course;

+------+-------+

| cid | cname |

+------+-------+

| 1001 | Java |

| 1002 | MySQL |

+------+-------+

2 rows in set (0.00 sec)

insert into student_course values

(1, 1, 1001, 89),

(2, 1, 1002, 90),

(3, 2, 1001, 88),

(4, 2, 1002, 56);#成功

mysql> select * from student_course;

+----+------+------+-------+

| id | sid | cid | score |

+----+------+------+-------+

| 1 | 1 | 1001 | 89 |

| 2 | 1 | 1002 | 90 |

| 3 | 2 | 1001 | 88 |

| 4 | 2 | 1002 | 56 |

+----+------+------+-------+

4 rows in set (0.00 sec)

insert into student_course values (5, 1, 1001, 88);#失败

#ERROR 1062 (23000): Duplicate entry '1-1001' for key 'sid' 违反sid-cid的复合唯一

删除唯一约束

添加唯一性约束的列上也会自动创建唯一索引。

删除唯一约束只能通过删除唯一索引的方式删除。

删除时需要指定唯一索引名，唯一索引名就和唯一约束名一样。

如果创建唯一约束时未指定名称，如果是单列，就默认和列名相同；如果是组合列，那么默认和()中排在第一个的列名相同。也可以自定义唯一性约束名。

# 查看都有哪些约束

SELECT * FROM information_schema.table_constraints WHERE table_name = '表名';

ALTER TABLE USER

DROP INDEX uk_name_pwd;

注意：可以通过 show index from 表名称;查看表的索引

PRIMARY KEY 约束

作用

用来唯一标识表中的一行记录。

关键字

primary key

特点

主键约束相当于唯一约束+非空约束的组合，主键约束列不允许重复，也不允许出现空值。

一个表最多只能有一个主键约束，建立主键约束可以在列级别创建，也可以在表级别上创建。

主键约束对应着表中的一列或者多列（复合主键）

如果是多列组合的复合主键约束，那么这些列都不允许为空值，并且组合的值不允许重复。

MySQL的主键名总是PRIMARY，就算自己命名了主键约束名也没用。

当创建主键约束时，系统默认会在所在的列或列组合上建立对应的主键索引（能够根据主键查询的，就根据主键查询，效率更高）。如果删除主键约束了，主键约束对应的索引就自动删除了。

需要注意的一点是，不要修改主键字段的值。因为主键是数据记录的唯一标识，如果修改了主键的值，就有可能会破坏数据的完整性。

添加主键约束

（1）建表时指定主键约束

create table 表名称(

字段名数据类型 primary key, #列级模式

字段名数据类型,

字段名数据类型

);

create table 表名称(

字段名数据类型,

[constraint 约束名] primary key(字段名) #表级模式

);

举例：

create table temp(

id int primary key,

name varchar(20)

);

mysql> desc temp;

+-------+-------------+------+-----+---------+-------+

+-------+-------------+------+-----+---------+-------+

| id | int(11) | NO | PRI | NULL | |

+-------+-------------+------+-----+---------+-------+

2 rows in set (0.00 sec)

insert into temp values(1,'张三');#成功

insert into temp values(2,'李四');#成功

mysql> select * from temp;

+----+------+

| id | name |

+----+------+

| 1 | 张三 |

| 2 | 李四 |

+----+------+

2 rows in set (0.00 sec)

insert into temp values(1,'张三');#失败

ERROR 1062 (23000): Duplicate（重复） entry（键入，输入） '1' for key 'PRIMARY'

insert into temp values(1,'王五');#失败

ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

insert into temp values(3,'张三');#成功

mysql> select * from temp;

+----+------+

| id | name |

+----+------+

| 1 | 张三 |

| 2 | 李四 |

| 3 | 张三 |

+----+------+

3 rows in set (0.00 sec)

insert into temp values(4,null);#成功

insert into temp values(null,'李琦');#失败

ERROR 1048 (23000): Column 'id' cannot be null

mysql> select * from temp;

+----+------+

| id | name |

+----+------+

| 1 | 张三 |

| 2 | 李四 |

| 3 | 张三 |

| 4 | NULL |

+----+------+

4 rows in set (0.00 sec)

#演示一个表建立两个主键约束

create table temp(

id int primary key,

name varchar(20) primary key

);

ERROR 1068 (42000): Multiple（多重的） primary key defined（定义）

再举例：

列级约束

CREATE TABLE emp4(

id INT PRIMARY KEY AUTO_INCREMENT ,

NAME VARCHAR(20)

);

表级约束

CREATE TABLE emp5(

id INT NOT NULL AUTO_INCREMENT,

NAME VARCHAR(20),

pwd VARCHAR(15),

CONSTRAINT emp5_id_pk PRIMARY KEY(id)

);

（2）建表后增加主键约束

ALTER TABLE 表名称 ADD PRIMARY KEY(字段列表); #字段列表可以是一个字段，也可以是多个字段，如果是多个字段的话，是复合主键

ALTER TABLE student ADD PRIMARY KEY (sid);

ALTER TABLE emp5 ADD PRIMARY KEY(NAME,pwd);

关于复合主键

create table 表名称(

字段名数据类型,

primary key(字段名1,字段名2) #表示字段1和字段2的组合是唯一的，也可以有更多个字段

);

#学生表

create table student(

sid int primary key, #学号

sname varchar(20) #学生姓名

);

#课程表

create table course(

cid int primary key, #课程编号

cname varchar(20) #课程名称

);

#选课表

create table student_course(

sid int,

cid int,

score int,

primary key(sid,cid) #复合主键

);

insert into student values(1,'张三'),(2,'李四');

insert into course values(1001,'Java'),(1002,'MySQL');

mysql> select * from student;

+-----+-------+

| sid | sname |

+-----+-------+

| 1 | 张三 |

| 2 | 李四 |

+-----+-------+

2 rows in set (0.00 sec)

mysql> select * from course;

+------+-------+

| cid | cname |

+------+-------+

| 1001 | Java |

| 1002 | MySQL |

+------+-------+

2 rows in set (0.00 sec)

insert into student_course values(1, 1001, 89),(1,1002,90),(2,1001,88),(2,1002,56);

mysql> select * from student_course;

+-----+------+-------+

| sid | cid | score |

+-----+------+-------+

| 1 | 1001 | 89 |

| 1 | 1002 | 90 |

| 2 | 1001 | 88 |

| 2 | 1002 | 56 |

+-----+------+-------+

4 rows in set (0.00 sec)

insert into student_course values(1, 1001, 100);

ERROR 1062 (23000): Duplicate entry '1-1001' for key 'PRIMARY'

mysql> desc student_course;

+-------+---------+------+-----+---------+-------+

+-------+---------+------+-----+---------+-------+

| sid | int(11) | NO | PRI | NULL | |

| cid | int(11) | NO | PRI | NULL | |

| score | int(11) | YES | | NULL | |

+-------+---------+------+-----+---------+-------+

3 rows in set (0.00 sec)

再举例

CREATE TABLE emp6(

id INT NOT NULL,

NAME VARCHAR(20),

pwd VARCHAR(15),

CONSTRAINT emp7_pk PRIMARY KEY(NAME,pwd)

);

删除主键约束

alter table 表名称 drop primary key;

举例：

ALTER TABLE student DROP PRIMARY KEY;

ALTER TABLE emp5 DROP PRIMARY KEY;

说明：删除主键约束，不需要指定主键名，因为一个表只有一个主键，删除主键约束后，非空还存在。

自增列：AUTO_INCREMENT

作用

某个字段的值自增

关键字

auto_increment

特点和要求

一个表最多只能有一个自增长列

当需要产生唯一标识符或顺序值时，可设置自增长

自增长列约束的列必须是键列（主键列，唯一键列）

自增约束的列的数据类型必须是整数类型

如果自增列指定了 0 和 null，会在当前最大值的基础上自增；如果自增列手动指定了具体值，直接赋值为具体值。

错误演示：

create table employee(

eid int auto_increment,

ename varchar(20)

);

# ERROR 1075 (42000): Incorrect table definition; there can be only one auto column and it must be defined as a key

create table employee(

eid int primary key,

ename varchar(20) unique key auto_increment

);

# ERROR 1063 (42000): Incorrect column specifier for column 'ename' 因为ename不是整数类型

如何指定自增约束

（1）建表时

create table 表名称(

字段名数据类型 primary key auto_increment,

字段名数据类型 unique key not null,

字段名数据类型 unique key,

字段名数据类型 not null default 默认值,

);

create table 表名称(

字段名数据类型 default 默认值 ,

字段名数据类型 unique key auto_increment,

字段名数据类型 not null default 默认值,,

primary key(字段名)

);

create table employee(

eid int primary key auto_increment,

ename varchar(20)

);

mysql> desc employee;

+-------+-------------+------+-----+---------+----------------+

+-------+-------------+------+-----+---------+----------------+

| eid | int(11) | NO | PRI | NULL | auto_increment |

+-------+-------------+------+-----+---------+----------------+

2 rows in set (0.00 sec)

（2）建表后

alter table 表名称 modify 字段名数据类型 auto_increment;

例如：

create table employee(

eid int primary key ,

ename varchar(20)

);

alter table employee modify eid int auto_increment;

mysql> desc employee;

+-------+-------------+------+-----+---------+----------------+

+-------+-------------+------+-----+---------+----------------+

| eid | int(11) | NO | PRI | NULL | auto_increment |

+-------+-------------+------+-----+---------+----------------+

2 rows in set (0.00 sec)

如何删除自增约束

#alter table 表名称 modify 字段名数据类型 auto_increment;#给这个字段增加自增约束

alter table 表名称 modify 字段名数据类型; #去掉auto_increment相当于删除

alter table employee modify eid int;

mysql> desc employee;

+-------+-------------+------+-----+---------+-------+

+-------+-------------+------+-----+---------+-------+

| eid | int(11) | NO | PRI | NULL | |

+-------+-------------+------+-----+---------+-------+

2 rows in set (0.00 sec)

MySQL 8.0 新特性—自增变量的持久化

在MySQL 8.0之前，自增主键AUTO_INCREMENT的值如果大于max(primary key)+1，在MySQL重启后，会重置AUTO_INCREMENT=max(primary key)+1，这种现象在某些情况下会导致业务主键冲突或者其他难以发现的问题。

下面通过案例来对比不同的版本中自增变量是否持久化。

在MySQL 5.7版本中，测试步骤如下：

创建的数据表中包含自增主键的id字段，语句如下：

CREATE TABLE test1(

id INT PRIMARY KEY AUTO_INCREMENT

);

插入4个空值，执行如下：

INSERT INTO test1

VALUES(0),(0),(0),(0);

查询数据表test1中的数据，结果如下：

mysql> SELECT * FROM test1;

+----+

| id |

+----+

| 1 |

| 2 |

| 3 |

| 4 |

+----+

4 rows in set (0.00 sec)

删除id为4的记录，语句如下：

DELETE FROM test1 WHERE id = 4;

再次插入一个空值，语句如下：

INSERT INTO test1 VALUES(0);

查询此时数据表test1中的数据，结果如下：

mysql> SELECT * FROM test1;

+----+

| id |

+----+

| 1 |

| 2 |

| 3 |

| 5 |

+----+

4 rows in set (0.00 sec)

从结果可以看出，虽然删除了id为4的记录，但是再次插入空值时，并没有重用被删除的4，而是分配了5。

删除id为5的记录，结果如下：

DELETE FROM test1 where id=5;

重启数据库，重新插入一个空值。

INSERT INTO test1 values(0);

再次查询数据表test1中的数据，结果如下：

mysql> SELECT * FROM test1;

+----+

| id |

+----+

| 1 |

| 2 |

| 3 |

| 4 |

+----+

4 rows in set (0.00 sec)

从结果可以看出，新插入的0值分配的是4，按照重启前的操作逻辑，此处应该分配6。出现上述结果的主要原因是自增主键没有持久化。

在MySQL 5.7系统中，对于自增主键的分配规则，是由InnoDB数据字典内部一个计数器来决定的，而该计数器只在内存中维护，并不会持久化到磁盘中。当数据库重启时，该计数器会被初始化。

在MySQL 8.0版本中，上述测试步骤最后一步的结果如下：

mysql> SELECT * FROM test1;

+----+

| id |

+----+

| 1 |

| 2 |

| 3 |

| 6 |

+----+

4 rows in set (0.00 sec)

从结果可以看出，自增变量已经持久化了。

MySQL 8.0将自增主键的计数器持久化到重做日志中。每次计数器发生改变，都会将其写入重做日志中。如果数据库重启，InnoDB会根据重做日志中的信息来初始化计数器的内存值。

FOREIGN KEY 约束

作用

限定某个表的某个字段的引用完整性。

比如：员工表的员工所在部门的选择，必须在部门表能找到对应的部分。

关键字

FOREIGN KEY

主表和从表/父表和子表

主表（父表）：被引用的表，被参考的表

从表（子表）：引用别人的表，参考别人的表

例如：员工表的员工所在部门这个字段的值要参考部门表：部门表是主表，员工表是从表。

例如：学生表、课程表、选课表：选课表的学生和课程要分别参考学生表和课程表，学生表和课程表是主表，选课表是从表。

特点

（1）从表的外键列，必须引用/参考主表的主键或唯一约束的列

为什么？因为被依赖/被参考的值必须是唯一的

（2）在创建外键约束时，如果不给外键约束命名，默认名不是列名，而是自动产生一个外键名（例如 student_ibfk_1;），也可以指定外键约束名。

（3）创建(CREATE)表时就指定外键约束的话，先创建主表，再创建从表

（4）删表时，先删从表（或先删除外键约束），再删除主表

（5）当主表的记录被从表参照时，主表的记录将不允许删除，如果要删除数据，需要先删除从表中依赖该记录的数据，然后才可以删除主表的数据

（6）在“从表”中指定外键约束，并且一个表可以建立多个外键约束

（7）从表的外键列与主表被参照的列名字可以不相同，但是数据类型必须一样，逻辑意义一致。如果类型不一样，创建子表时，就会出现错误“ERROR 1005 (HY000): Can’t create table’database.tablename’(errno: 150)”。

例如：都是表示部门编号，都是int类型。

（8）当创建外键约束时，系统默认会在所在的列上建立对应的普通索引。但是索引名是外键的约束名。（根据外键查询效率很高）

（9）删除外键约束后，必须手动删除对应的索引

添加外键约束

（1）建表时

create table 主表名称(

字段1 数据类型 primary key,

字段2 数据类型

);

create table 从表名称(

字段1 数据类型 primary key,

字段2 数据类型,

[CONSTRAINT <外键约束名称>] FOREIGN KEY（从表的某个字段) references 主表名(被参考字段)

);

#(从表的某个字段)的数据类型必须与主表名(被参考字段)的数据类型一致，逻辑意义也一样

#(从表的某个字段)的字段名可以与主表名(被参考字段)的字段名一样，也可以不一样

-- FOREIGN KEY: 在表级指定子表中的列

-- REFERENCES: 标示在父表中的列

create table dept( #主表

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(#从表

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int, #员工所在的部门

foreign key (deptid) references dept(did) #在从表中指定外键约束

#emp表的deptid和和dept表的did的数据类型一致，意义都是表示部门的编号

);

说明：

（1）主表dept必须先创建成功，然后才能创建emp表，指定外键成功。

（2）删除表时，先删除从表emp，再删除主表dept

（2）建表后

一般情况下，表与表的关联都是提前设计好了的，因此，会在创建表的时候就把外键约束定义好。不过，如果需要修改表的设计（比如添加新的字段，增加新的关联关系），但没有预先定义外键约束，那么，就要用修改表的方式来补充定义。

格式：

ALTER TABLE 从表名 ADD [CONSTRAINT 约束名] FOREIGN KEY (从表的字段) REFERENCES 主表名(被引用字段) [on update xx][on delete xx];

举例：

ALTER TABLE emp1

ADD [CONSTRAINT emp_dept_id_fk] FOREIGN KEY(dept_id) REFERENCES dept(dept_id);

举例：

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int #员工所在的部门

);

#这两个表创建时，没有指定外键的话，那么创建顺序是随意

alter table emp add foreign key (deptid) references dept(did);

演示问题

（1）失败：不是键列

create table dept(

did int , #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int, #员工所在的部门

foreign key (deptid) references dept(did)

);

#ERROR 1215 (HY000): Cannot add foreign key constraint 原因是dept的did不是键列

（2）失败：数据类型不一致

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid char, #员工所在的部门

foreign key (deptid) references dept(did)

);

#ERROR 1215 (HY000): Cannot add foreign key constraint 原因是从表的deptid字段和主表的did字段的数据类型不一致，并且要它俩的逻辑意义一致

（3）成功，两个表字段名一样

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

did int, #员工所在的部门

foreign key (did) references dept(did)

#emp表的deptid和和dept表的did的数据类型一致，意义都是表示部门的编号

#是否重名没问题，因为两个did在不同的表中

);

（4）添加、删除、修改问题

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int, #员工所在的部门

foreign key (deptid) references dept(did)

#emp表的deptid和和dept表的did的数据类型一致，意义都是表示部门的编号

);

insert into dept values(1001,'教学部');

insert into dept values(1003, '财务部');

insert into emp values(1,'张三',1001); #添加从表记录成功，在添加这条记录时，要求部门表有1001部门

insert into emp values(2,'李四',1005);#添加从表记录失败

ERROR 1452 (23000): Cannot add（添加） or update（修改） a child row: a foreign key constraint fails (`atguigudb`.`emp`, CONSTRAINT `emp_ibfk_1` FOREIGN KEY (`deptid`) REFERENCES `dept` (`did`)) 从表emp添加记录失败，因为主表dept没有1005部门

mysql> select * from dept;

+------+--------+

| did | dname |

+------+--------+

| 1001 | 教学部 |

| 1003 | 财务部 |

+------+--------+

2 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | 1001 |

+-----+-------+--------+

1 row in set (0.00 sec)

update emp set deptid = 1002 where eid = 1;#修改从表失败

ERROR 1452 (23000): Cannot add（添加） or update（修改） a child row（子表的记录）: a foreign key constraint fails（外键约束失败） (`atguigudb`.`emp`, CONSTRAINT `emp_ibfk_1` FOREIGN KEY (`deptid`) REFERENCES `dept` (`did`)) #部门表did字段现在没有1002的值，所以员工表中不能修改员工所在部门deptid为1002

update dept set did = 1002 where did = 1001;#修改主表失败

ERROR 1451 (23000): Cannot delete（删除） or update（修改） a parent row（父表的记录）: a foreign key constraint fails (`atguigudb`.`emp`, CONSTRAINT `emp_ibfk_1` FOREIGN KEY (`deptid`) REFERENCES `dept` (`did`)) #部门表did的1001字段已经被emp引用了，所以部门表的1001字段就不能修改了。

update dept set did = 1002 where did = 1003;#修改主表成功因为部门表的1003部门没有被emp表引用，所以可以修改

delete from dept where did=1001; #删除主表失败

ERROR 1451 (23000): Cannot delete（删除） or update（修改） a parent row（父表记录）: a foreign key constraint fails (`atguigudb`.`emp`, CONSTRAINT `emp_ibfk_1` FOREIGN KEY (`deptid`) REFERENCES `dept` (`did`)) #因为部门表did的1001字段已经被emp引用了，所以部门表的1001字段对应的记录就不能被删除

总结：约束关系是针对双方的

添加了外键约束后，主表的修改和删除数据受约束

添加了外键约束后，从表的添加和修改数据受约束

在从表上建立外键，要求主表必须存在

删除主表时，要求从表从表先删除，或将从表中外键引用该主表的关系先删除

约束等级

Cascade方式：在父表上update/delete记录时，同步update/delete掉子表的匹配记录

Set null方式：在父表上update/delete记录时，将子表上匹配记录的列设为null，但是要注意子表的外键列不能为not null

No action方式：如果子表中有匹配的记录，则不允许对父表对应候选键进行update/delete操作

Restrict方式：同no action，都是立即检查外键约束

Set default方式（在可视化工具SQLyog中可能显示空白）：父表有变更时，子表将外键列设置成一个默认的值，但Innodb不能识别

如果没有指定等级，就相当于Restrict方式。

对于外键约束，最好是采用: ON UPDATE CASCADE ON DELETE RESTRICT 的方式。

（1）演示1：on update cascade on delete set null

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int, #员工所在的部门

foreign key (deptid) references dept(did) on update cascade on delete set null

#把修改操作设置为级联修改等级，把删除操作设置为set null等级

);

insert into dept values(1001,'教学部');

insert into dept values(1002, '财务部');

insert into dept values(1003, '咨询部');

insert into emp values(1,'张三',1001); #在添加这条记录时，要求部门表有1001部门

insert into emp values(2,'李四',1001);

insert into emp values(3,'王五',1002);

mysql> select * from dept;

mysql> select * from emp;

#修改主表成功，从表也跟着修改，修改了主表被引用的字段1002为1004，从表的引用字段就跟着修改为1004了

mysql> update dept set did = 1004 where did = 1002;

Query OK, 1 row affected (0.00 sec)

Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from dept;

+------+--------+

| did | dname |

+------+--------+

| 1001 | 教学部 |

| 1003 | 咨询部 |

| 1004 | 财务部 | #原来是1002，修改为1004

+------+--------+

3 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | 1001 |

| 2 | 李四 | 1001 |

| 3 | 王五 | 1004 | #原来是1002，跟着修改为1004

+-----+-------+--------+

3 rows in set (0.00 sec)

#删除主表的记录成功，从表对应的字段的值被修改为null

mysql> delete from dept where did = 1001;

Query OK, 1 row affected (0.01 sec)

mysql> select * from dept;

+------+--------+

| did | dname | #记录1001部门被删除了

+------+--------+

| 1003 | 咨询部 |

| 1004 | 财务部 |

+------+--------+

2 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | NULL | #原来引用1001部门的员工，deptid字段变为null

| 2 | 李四 | NULL |

| 3 | 王五 | 1004 |

+-----+-------+--------+

3 rows in set (0.00 sec)

（2）演示2：on update set null on delete cascade

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int, #员工所在的部门

foreign key (deptid) references dept(did) on update set null on delete cascade

#把修改操作设置为set null等级，把删除操作设置为级联删除等级

);

insert into dept values(1001,'教学部');

insert into dept values(1002, '财务部');

insert into dept values(1003, '咨询部');

insert into emp values(1,'张三',1001); #在添加这条记录时，要求部门表有1001部门

insert into emp values(2,'李四',1001);

insert into emp values(3,'王五',1002);

mysql> select * from dept;

+------+--------+

| did | dname |

+------+--------+

| 1001 | 教学部 |

| 1002 | 财务部 |

| 1003 | 咨询部 |

+------+--------+

3 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | 1001 |

| 2 | 李四 | 1001 |

| 3 | 王五 | 1002 |

+-----+-------+--------+

3 rows in set (0.00 sec)

#修改主表，从表对应的字段设置为null

mysql> update dept set did = 1004 where did = 1002;

Query OK, 1 row affected (0.00 sec)

Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from dept;

+------+--------+

| did | dname |

+------+--------+

| 1001 | 教学部 |

| 1003 | 咨询部 |

| 1004 | 财务部 | #原来did是1002

+------+--------+

3 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | 1001 |

| 2 | 李四 | 1001 |

| 3 | 王五 | NULL | #原来deptid是1002，因为部门表1002被修改了，1002没有对应的了，就设置为null

+-----+-------+--------+

3 rows in set (0.00 sec)

#删除主表的记录成功，主表的1001行被删除了，从表相应的记录也被删除了

mysql> delete from dept where did=1001;

Query OK, 1 row affected (0.00 sec)

mysql> select * from dept;

+------+--------+

| did | dname | #部门表中1001部门被删除

+------+--------+

| 1003 | 咨询部 |

| 1004 | 财务部 |

+------+--------+

2 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |#原来1001部门的员工也被删除了

+-----+-------+--------+

| 3 | 王五 | NULL |

+-----+-------+--------+

1 row in set (0.00 sec)

（3）演示：on update cascade on delete cascade

create table dept(

did int primary key, #部门编号

dname varchar(50) #部门名称

);

create table emp(

eid int primary key, #员工编号

ename varchar(5), #员工姓名

deptid int, #员工所在的部门

foreign key (deptid) references dept(did) on update cascade on delete cascade

#把修改操作设置为级联修改等级，把删除操作也设置为级联删除等级

);

insert into dept values(1001,'教学部');

insert into dept values(1002, '财务部');

insert into dept values(1003, '咨询部');

insert into emp values(1,'张三',1001); #在添加这条记录时，要求部门表有1001部门

insert into emp values(2,'李四',1001);

insert into emp values(3,'王五',1002);

mysql> select * from dept;

+------+--------+

| did | dname |

+------+--------+

| 1001 | 教学部 |

| 1002 | 财务部 |

| 1003 | 咨询部 |

+------+--------+

3 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | 1001 |

| 2 | 李四 | 1001 |

| 3 | 王五 | 1002 |

+-----+-------+--------+

3 rows in set (0.00 sec)

#修改主表，从表对应的字段自动修改

mysql> update dept set did = 1004 where did = 1002;

Query OK, 1 row affected (0.00 sec)

Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from dept;

+------+--------+

| did | dname |

+------+--------+

| 1001 | 教学部 |

| 1003 | 咨询部 |

| 1004 | 财务部 | #部门1002修改为1004

+------+--------+

3 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid |

+-----+-------+--------+

| 1 | 张三 | 1001 |

| 2 | 李四 | 1001 |

| 3 | 王五 | 1004 | #级联修改

+-----+-------+--------+

3 rows in set (0.00 sec)

#删除主表的记录成功，主表的1001行被删除了，从表相应的记录也被删除了

mysql> delete from dept where did=1001;

Query OK, 1 row affected (0.00 sec)

mysql> select * from dept;

+------+--------+

| did | dname | #1001部门被删除了

+------+--------+

| 1003 | 咨询部 |

| 1004 | 财务部 |

+------+--------+

2 rows in set (0.00 sec)

mysql> select * from emp;

+-----+-------+--------+

| eid | ename | deptid | #1001部门的员工也被删除了

+-----+-------+--------+

| 3 | 王五 | 1004 |

+-----+-------+--------+

1 row in set (0.00 sec)

删除外键约束

流程如下：

(1)第一步先查看约束名和删除外键约束

SELECT * FROM information_schema.table_constraints WHERE table_name = '表名称';#查看某个表的约束名

ALTER TABLE 从表名 DROP FOREIGN KEY 外键约束名;

（2）第二步查看索引名和删除索引。（注意，只能手动删除）

SHOW INDEX FROM 表名称; #查看某个表的索引名

ALTER TABLE 从表名 DROP INDEX 索引名;

举例：

mysql> SELECT * FROM information_schema.table_constraints WHERE table_name = 'emp';

mysql> alter table emp drop foreign key emp_ibfk_1;

Query OK, 0 rows affected (0.02 sec)

Records: 0 Duplicates: 0 Warnings: 0

mysql> show index from emp;

mysql> alter table emp drop index deptid;

Query OK, 0 rows affected (0.01 sec)

Records: 0 Duplicates: 0 Warnings: 0

mysql> show index from emp;

开发场景

问题1：如果两个表之间有关系（一对一、一对多），比如：员工表和部门表（一对多），它们之间是否一定要建外键约束？

答：不是的

问题2：建和不建外键约束有什么区别？

答：建外键约束，你的操作（创建表、删除表、添加、修改、删除）会受到限制，从语法层面受到限制。例如：在员工表中不可能添加一个员工信息，它的部门的值在部门表中找不到。

不建外键约束，你的操作（创建表、删除表、添加、修改、删除）不受限制，要保证数据的引用完整性，只能依靠程序员的自觉，或者是在Java程序中进行限定。例如：在员工表中，可以添加一个员工的信息，它的部门指定为一个完全不存在的部门。

问题3：那么建和不建外键约束和查询有没有关系？

答：没有

在 MySQL 里，外键约束是有成本的，需要消耗系统资源。对于大并发的 SQL 操作，有可能会不适合。比如大型网站的中央数据库，可能会因为外键约束的系统开销而变得非常慢。所以， MySQL 允许你不使用系统自带的外键约束，在应用层面完成检查数据一致性的逻辑。也就是说，即使你不用外键约束，也要想办法通过应用层面的附加逻辑，来实现外键约束的功能，确保数据的一致性。

阿里开发规范

【强制】不得使用外键与级联，一切外键概念必须在应用层解决。

说明：（概念解释）学生表中的 student_id 是主键，那么成绩表中的 student_id 则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。外键与级联更新适用于单机低并发，不适合分布式、高并发集群；级联更新是强阻塞，存在数据库更新风暴的风险；外键影响数据库的插入速度。

CHECK 约束

作用

检查某个字段的值是否符号xx要求，一般指的是值的范围

关键字

CHECK

说明：MySQL 5.7 不支持

MySQL5.7 可以使用check约束，但check约束对数据验证没有任何作用。添加数据时，没有任何错误或警告

但是MySQL 8.0中可以使用check约束了。

create table employee(

eid int primary key,

ename varchar(5),

gender char check ('男' or '女')

);

insert into employee values(1,'张三','妖');

mysql> select * from employee;

+-----+-------+--------+

| eid | ename | gender |

+-----+-------+--------+

| 1 | 张三 | 妖 |

+-----+-------+--------+

1 row in set (0.00 sec)

再举例

CREATE TABLE temp(

id INT AUTO_INCREMENT,

NAME VARCHAR(20),

age INT CHECK(age > 20),

PRIMARY KEY(id)

);

再举例

age tinyint check(age >20) 或 sex char(2) check(sex in(‘男’,’女’))

再举例

CHECK(height>=0 AND height<3)

DEFAULT约束

作用

给某个字段/某列指定默认值，一旦设置默认值，在插入数据时，如果此字段没有显式赋值，则赋值为默认值。

关键字

DEFAULT

如何给字段加默认值

（1）建表时

create table 表名称(

字段名数据类型 primary key,

字段名数据类型 unique key not null,

字段名数据类型 unique key,

字段名数据类型 not null default 默认值,

);

create table 表名称(

字段名数据类型 default 默认值 ,

字段名数据类型 not null default 默认值,

primary key(字段名),

unique key(字段名)

);

说明：默认值约束一般不在唯一键和主键列上加

create table employee(

eid int primary key,

ename varchar(20) not null,

gender char default '男',

tel char(11) not null default '' #默认是空字符串

);

mysql> desc employee;

+--------+-------------+------+-----+---------+-------+

+--------+-------------+------+-----+---------+-------+

| eid | int(11) | NO | PRI | NULL | |

| gender | char(1) | YES | | 男 | |

| tel | char(11) | NO | | | |

+--------+-------------+------+-----+---------+-------+

4 rows in set (0.00 sec)

insert into employee values(1,'汪飞','男','13700102535'); #成功

mysql> select * from employee;

+-----+-------+--------+-------------+

| eid | ename | gender | tel |

+-----+-------+--------+-------------+

| 1 | 汪飞 | 男 | 13700102535 |

+-----+-------+--------+-------------+

1 row in set (0.00 sec)

insert into employee(eid,ename) values(2,'天琪'); #成功

mysql> select * from employee;

+-----+-------+--------+-------------+

| eid | ename | gender | tel |

+-----+-------+--------+-------------+

| 1 | 汪飞 | 男 | 13700102535 |

| 2 | 天琪 | 男 | |

+-----+-------+--------+-------------+

2 rows in set (0.00 sec)

insert into employee(eid,ename) values(3,'二虎');

#ERROR 1062 (23000): Duplicate entry '' for key 'tel'

#如果tel有唯一性约束的话会报错，如果tel没有唯一性约束，可以添加成功

再举例：

CREATE TABLE myemp(

id INT AUTO_INCREMENT PRIMARY KEY,

NAME VARCHAR(15),

salary DOUBLE(10,2) DEFAULT 2000

);

（2）建表后

alter table 表名称 modify 字段名数据类型 default 默认值;

#如果这个字段原来有非空约束，你还保留非空约束，那么在加默认值约束时，还得保留非空约束，否则非空约束就被删除了

#同理，在给某个字段加非空约束也一样，如果这个字段原来有默认值约束，你想保留，也要在modify语句中保留默认值约束，否则就删除了

alter table 表名称 modify 字段名数据类型 default 默认值 not null;

create table employee(

eid int primary key,

ename varchar(20),

gender char,

tel char(11) not null

);

mysql> desc employee;

+--------+-------------+------+-----+---------+-------+

+--------+-------------+------+-----+---------+-------+

| eid | int(11) | NO | PRI | NULL | |

| tel | char(11) | NO | | NULL | |

+--------+-------------+------+-----+---------+-------+

4 rows in set (0.00 sec)

alter table employee modify gender char default '男'; #给gender字段增加默认值约束

alter table employee modify tel char(11) default ''; #给tel字段增加默认值约束

mysql> desc employee;

+--------+-------------+------+-----+---------+-------+

+--------+-------------+------+-----+---------+-------+

| eid | int(11) | NO | PRI | NULL | |

| gender | char(1) | YES | | 男 | |

| tel | char(11) | YES | | | |

+--------+-------------+------+-----+---------+-------+

4 rows in set (0.00 sec)

alter table employee modify tel char(11) default '' not null;#给tel字段增加默认值约束，并保留非空约束

mysql> desc employee;

+--------+-------------+------+-----+---------+-------+

+--------+-------------+------+-----+---------+-------+

| eid | int(11) | NO | PRI | NULL | |

| gender | char(1) | YES | | 男 | |

| tel | char(11) | NO | | | |

+--------+-------------+------+-----+---------+-------+

4 rows in set (0.00 sec)

如何删除默认值约束

alter table 表名称 modify 字段名数据类型 ;#删除默认值约束，也不保留非空约束

alter table 表名称 modify 字段名数据类型 not null; #删除默认值约束，保留非空约束

alter table employee modify gender char; #删除gender字段默认值约束，如果有非空约束，也一并删除

alter table employee modify tel char(11) not null;#删除tel字段默认值约束，保留非空约束

mysql> desc employee;

+--------+-------------+------+-----+---------+-------+

+--------+-------------+------+-----+---------+-------+

| eid | int(11) | NO | PRI | NULL | |

| tel | char(11) | NO | | NULL | |

+--------+-------------+------+-----+---------+-------+

4 rows in set (0.00 sec)

面试

面试1、为什么建表时，加 not null default ‘’ 或 default 0

答：不想让表中出现null值。

面试2、为什么不想要 null 的值

答: （1）不好比较。null是一种特殊值，比较时只能用专门的is null 和 is not null来比较。碰到运算符，通常返回null。

（2）效率不高。影响提高索引效果。因此，我们往往在建表时 not null default ‘’ 或 default 0

面试3、带AUTO_INCREMENT约束的字段值是从1开始的吗？

答：在MySQL中，默认AUTO_INCREMENT的初始值是1，每新增一条记录，字段值自动加1。设置自增属性（AUTO_INCREMENT）的时候，还可以指定第一条插入记录的自增字段的值，这样新插入的记录的自增字段值从初始值开始递增，如在表中插入第一条记录，同时指定id值为5，则以后插入的记录的id值就会从6开始往上增加。添加主键约束时，往往需要设置字段自动增加属性。

面试4、并不是每个表都可以任意选择存储引擎？

答：外键约束（FOREIGN KEY）不能跨引擎使用。

MySQL支持多种存储引擎，每一个表都可以指定一个不同的存储引擎，需要注意的是：外键约束是用来保证数据的参照完整性的，如果表之间需要关联外键，却指定了不同的存储引擎，那么这些表之间是不能创建外键约束的。所以说，存储引擎的选择也不完全是随意的。

视图

常见的数据库对象

对象描述

表(TABLE) 表是存储数据的逻辑单元，以行和列的形式存在，列就是字段，行就是记录

数据字典就是系统表，存放数据库相关信息的表。系统表的数据通常由数据库系统维护，程序员通常不应该修改，只可查看

约束(CONSTRAINT) 执行数据校验的规则，用于保证数据完整性的规则

视图(VIEW) 一个或者多个数据表里的数据的逻辑显示，视图并不存储数据

索引(INDEX) 用于提高查询性能，相当于书的目录

存储过程(PROCEDURE) 用于完成一次完整的业务处理，没有返回值，但可通过传出参数将多个值传给调用环境

存储函数(FUNCTION) 用于完成一次特定的计算，具有一个返回值

触发器(TRIGGER) 相当于一个事件监听器，当数据库发生特定事件后，触发器被触发，完成相应的处理

视图概述

为什么使用视图？

视图一方面可以帮我们使用表的一部分而不是所有的表，另一方面也可以针对不同的用户制定不同的查询视图。比如，针对一个公司的销售人员，我们只想给他看部分数据，而某些特殊的数据，比如采购的价格，则不会提供给他。再比如，人员薪酬是个敏感的字段，那么只给某个级别以上的人员开放，其他人的查询视图中则不提供这个字段。

刚才讲的只是视图的一个使用场景，实际上视图还有很多作用。最后，我们总结视图的优点。

视图的理解

视图是一种虚拟表，本身是不具有数据的，占用很少的内存空间，它是 SQL 中的一个重要概念。

视图建立在已有表的基础上, 视图赖以建立的这些表称为基表。

视图的创建和删除只影响视图本身，不影响对应的基表。但是当对视图中的数据进行增加、删除和修改操作时，数据表中的数据会相应地发生变化，反之亦然。

向视图提供数据内容的语句为 SELECT 语句, 可以将视图理解为存储起来的 SELECT 语句

在数据库中，视图不会保存数据，数据真正保存在数据表中。当对视图中的数据进行增加、删除和修改操作时，数据表中的数据会相应地发生变化；反之亦然。

视图，是向用户提供基表数据的另一种表现形式。通常情况下，小型项目的数据库可以不使用视图，但是在大型项目中，以及数据表比较复杂的情况下，视图的价值就凸显出来了，它可以帮助我们把经常查询的结果集放到虚拟表中，提升使用效率。理解和使用起来都非常方便。

创建视图

在 CREATE VIEW 语句中嵌入子查询

CREATE [OR REPLACE]

[ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]

VIEW 视图名称 [(字段列表)]

AS 查询语句

[WITH [CASCADED|LOCAL] CHECK OPTION]

精简版

CREATE VIEW 视图名称

AS 查询语句

创建单表视图

举例：

CREATE VIEW empvu80

SELECT employee_id, last_name, salary

FROM employees

WHERE department_id = 80;

查询视图：

SELECT *

FROM salvu80;

举例：

CREATE VIEW emp_year_salary (ename,year_salary)

SELECT ename,salary*12*(1+IFNULL(commission_pct,0))

FROM t_employee;

举例：

CREATE VIEW salvu50

SELECT employee_id ID_NUMBER, last_name NAME,salary*12 ANN_SALARY

FROM employees

WHERE department_id = 50;

说明1：实际上就是我们在 SQL 查询语句的基础上封装了视图 VIEW，这样就会基于 SQL 语句的结果集形成一张虚拟表。

说明2：在创建视图时，没有在视图名后面指定字段列表，则视图中字段列表默认和SELECT语句中的字段列表一致。如果SELECT语句中给字段取了别名，那么视图中的字段名和别名相同。

创建多表联合视图

举例：

CREATE VIEW empview

SELECT employee_id emp_id,last_name NAME,department_name

FROM employees e,departments d

WHERE e.department_id = d.department_id;

CREATE VIEW emp_dept

SELECT ename,dname

FROM t_employee LEFT JOIN t_department

ON t_employee.did = t_department.did;

CREATE VIEW dept_sum_vu

(name, minsal, maxsal, avgsal)

SELECT d.department_name, MIN(e.salary), MAX(e.salary),AVG(e.salary)

FROM employees e, departments d

WHERE e.department_id = d.department_id

GROUP BY d.department_name;

利用视图对数据进行格式化

我们经常需要输出某个格式的内容，比如我们想输出员工姓名和对应的部门名，对应格式为 emp_name(department_name)，就可以使用视图来完成数据格式化的操作：

CREATE VIEW emp_depart

SELECT CONCAT(last_name,'(',department_name,')') AS emp_dept

FROM employees e JOIN departments d

WHERE e.department_id = d.department_id

基于视图创建视图

当我们创建好一张视图之后，还可以在它的基础上继续创建视图。

举例：联合“emp_dept”视图和“emp_year_salary”视图查询员工姓名、部门名称、年薪信息创建 “emp_dept_ysalary”视图。

CREATE VIEW emp_dept_ysalary

SELECT emp_dept.ename,dname,year_salary

FROM emp_dept INNER JOIN emp_year_salary

ON emp_dept.ename = emp_year_salary.ename;

查看视图

语法1：查看数据库的表对象、视图对象

SHOW TABLES;

语法2：查看视图的结构

DESC / DESCRIBE 视图名称;

语法3：查看视图的属性信息

# 查看视图信息（显示数据表的存储引擎、版本、数据行数和数据大小等）

SHOW TABLE STATUS LIKE '视图名称'\G

执行结果显示，注释Comment为VIEW，说明该表为视图，其他的信息为NULL，说明这是一个虚表。

语法4：查看视图的详细定义信息

SHOW CREATE VIEW 视图名称;

更新视图的数据

一般情况

MySQL支持使用INSERT、UPDATE和DELETE语句对视图中的数据进行插入、更新和删除操作。当视图中的数据发生变化时，数据表中的数据也会发生变化，反之亦然。

举例：UPDATE操作

mysql> SELECT ename,tel FROM emp_tel WHERE ename = '孙洪亮';
+---------+-------------+
| ename   | tel         |
+---------+-------------+
| 孙洪亮  | 13789098765 |
+---------+-------------+
1 row in set (0.01 sec)
mysql> UPDATE emp_tel SET tel = '13789091234' WHERE ename = '孙洪亮';
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> SELECT ename,tel FROM emp_tel WHERE ename = '孙洪亮';
+---------+-------------+
| ename   | tel         |
+---------+-------------+
|  孙洪亮 | 13789091234 |
+---------+-------------+
1 row in set (0.00 sec)
mysql> SELECT ename,tel FROM t_employee WHERE ename = '孙洪亮';
+---------+-------------+
| ename   | tel         |
+---------+-------------+
| 孙洪亮  | 13789091234 |
+---------+-------------+
1 row in set (0.00 sec)

举例：DELETE操作

mysql> SELECT ename,tel FROM emp_tel WHERE ename = '孙洪亮';
+---------+-------------+
| ename   | tel           |
+---------+-------------+
| 孙洪亮  | 13789091234 |
+---------+-------------+
1 row in set (0.00 sec)
mysql> DELETE FROM emp_tel  WHERE ename = '孙洪亮';
Query OK, 1 row affected (0.01 sec)
mysql> SELECT ename,tel FROM emp_tel WHERE ename = '孙洪亮';
Empty set (0.00 sec)
mysql> SELECT ename,tel FROM t_employee WHERE ename = '孙洪亮';
Empty set (0.00 sec)

不可更新的视图

要使视图可更新，视图中的行和底层基本表中的行之间必须存在一对一的关系。另外当视图定义出现如下情况时，视图不支持更新操作：

在定义视图的时候指定了“ALGORITHM = TEMPTABLE”，视图将不支持INSERT和DELETE操作；

视图中不包含基表中所有被定义为非空又未指定默认值的列，视图将不支持INSERT操作；

在定义视图的SELECT语句中使用了JOIN联合查询，视图将不支持INSERT和DELETE操作；

在定义视图的SELECT语句后的字段列表中使用了数学表达式或子查询，视图将不支持INSERT，也不支持UPDATE使用了数学表达式、子查询的字段值；

在定义视图的SELECT语句后的字段列表中使用DISTINCT、聚合函数、GROUP BY、HAVING、UNION等，视图将不支持INSERT、UPDATE、DELETE；

在定义视图的SELECT语句中包含了子查询，而子查询中引用了FROM后面的表，视图将不支持INSERT、UPDATE、DELETE；

视图定义基于一个不可更新视图；

常量视图。

举例：

mysql> CREATE OR REPLACE VIEW emp_dept
    -> (ename,salary,birthday,tel,email,hiredate,dname)
    -> AS SELECT ename,salary,birthday,tel,email,hiredate,dname
    -> FROM t_employee INNER JOIN t_department
    -> ON t_employee.did = t_department.did ;
Query OK, 0 rows affected (0.01 sec)

mysql> INSERT INTO emp_dept(ename,salary,birthday,tel,email,hiredate,dname)
    -> VALUES('张三',15000,'1995-01-08','18201587896',
    -> 'zs@atguigu.com','2022-02-14','新部门');
#ERROR 1393 (HY000): Can not modify more than one base table through a join view 'atguigu_chapter9.emp_dept'

从上面的SQL执行结果可以看出，在定义视图的SELECT语句中使用了JOIN联合查询，视图将不支持更新操作。

虽然可以更新视图数据，但总的来说，视图作为虚拟表，主要用于方便查询，不建议更新视图的数据。对视图数据的更改，都是通过对实际数据表里数据的操作来完成的。

修改、删除视图

修改视图

方式1：使用CREATE OR REPLACE VIEW 子句修改视图

CREATE OR REPLACE VIEW empvu80
(id_number, name, sal, department_id)
AS 
SELECT  employee_id, first_name || ' ' || last_name, salary, department_id
FROM employees
WHERE department_id = 80;

说明：CREATE VIEW 子句中各列的别名应和子查询中各列相对应。

方式2：ALTER VIEW

修改视图的语法是：

ALTER VIEW 视图名称

查询语句

删除视图

删除视图只是删除视图的定义，并不会删除基表的数据。

删除视图的语法是：

DROP VIEW IF EXISTS 视图名称;

DROP VIEW IF EXISTS 视图名称1,视图名称2,视图名称3,...;

举例：

DROP VIEW empvu80;

说明：基于视图a、b创建了新的视图c，如果将视图a或者视图b删除，会导致视图c的查询失败。这样的视图c需要手动删除或修改，否则影响使用。

总结

视图优点

1. 操作简单

将经常使用的查询操作定义为视图，可以使开发人员不需要关心视图对应的数据表的结构、表与表之间的关联关系，也不需要关心数据表之间的业务逻辑和查询条件，而只需要简单地操作视图即可，极大简化了开发人员对数据库的操作。

2. 减少数据冗余

视图跟实际数据表不一样，它存储的是查询语句。所以，在使用的时候，我们要通过定义视图的查询语句来获取结果集。而视图本身不存储数据，不占用数据存储的资源，减少了数据冗余。

3. 数据安全

MySQL将用户对数据的访问限制在某些数据的结果集上，而这些数据的结果集可以使用视图来实现。用户不必直接查询或操作数据表。这也可以理解为视图具有隔离性。视图相当于在用户和实际的数据表之间加了一层虚拟表。

同时，MySQL可以根据权限将用户对数据的访问限制在某些视图上，用户不需要查询数据表，可以直接通过视图获取数据表中的信息。这在一定程度上保障了数据表中数据的安全性。

4. 适应灵活多变的需求

当业务系统的需求发生变化后，如果需要改动数据表的结构，则工作量相对较大，可以使用视图来减少改动的工作量。这种方式在实际工作中使用得比较多。

5. 能够分解复杂的查询逻辑

数据库中如果存在复杂的查询逻辑，则可以将问题进行分解，创建多个视图获取数据，再将创建的多个视图结合起来，完成复杂的查询逻辑。

视图不足

如果我们在实际数据表的基础上创建了视图，那么，如果实际数据表的结构变更了，我们就需要及时对相关的视图进行相应的维护。特别是嵌套的视图（就是在视图的基础上创建视图），维护会变得比较复杂，可读性不好，容易变成系统的潜在隐患。因为创建视图的 SQL 查询可能会对字段重命名，也可能包含复杂的逻辑，这些都会增加维护的成本。

实际项目中，如果视图过多，会导致数据库维护成本的问题。

所以，在创建视图的时候，你要结合实际项目需求，综合考虑视图的优点和不足，这样才能正确使用视图，使系统整体达到最优。

MySQL基础（二）

MySQL基础（一）下

MySQL基础（一）下

7种 SQL JOINS 的实现

SQL99语法新特性

自然连接

角度与弧度互换函数

日期和时间函数

获取日期、时间

日期的操作函数

日期的格式化与解析

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像