玩转Mysql系列 - 第12篇：子查询（非常重要，高手必备）

打算提升sql技能的，可以加我微信itsoku，带你成为sql高手。

这是Mysql系列第12篇。

环境：mysql5.7.25，cmd命令中进行演示。

本章节非常重要。

子查询

出现在select语句中的select语句，称为子查询或内查询。

外部的select查询语句，称为主查询或外查询。

子查询分类

按结果集的行列数不同分为4种

  • 标量子查询（结果集只有一行一列）

  • 列子查询（结果集只有一列多行）

  • 行子查询（结果集有一行多列）

  • 表子查询（结果集一般为多行多列）

按子查询出现在主查询中的不同位置分

  • select后面：仅仅支持标量子查询。

  • from后面：支持表子查询。

  • where或having后面：支持标量子查询（单列单行）、列子查询（单列多行）、行子查询（多列多行）

  • exists后面（即相关子查询）：表子查询（多行、多列）

准备测试数据

测试数据比较多，放在我的个人博客上了。

浏览器中打开链接：http://www.itsoku.com/article/209

mysql中执行里面的javacode2018_employees库部分的脚本。

成功创建javacode2018_employees库及5张表，如下：

表名描述
departments部门表
employees员工信息表
jobs职位信息表
locations位置表（部门表中会用到）
job_grades薪资等级表

select后面的子查询

子查询位于select后面的，仅仅支持标量子查询。

示例1

查询每个部门员工个数

  1. SELECT
  2.   a.*,
  3.   (SELECT count(*)
  4.    FROM employees b
  5.    WHERE b.department_id = a.department_id) AS 员工个数
  6. FROM departments a;

示例2

查询员工号=102的部门名称

  1. SELECT (SELECT a.department_name
  2.         FROM departments a, employees b
  3.         WHERE a.department_id = b.department_id
  4.               AND b.employee_id = 102) AS 部门名;

from后面的子查询

将子查询的结果集充当一张表，要求必须起别名，否者这个表找不到。

然后将真实的表和子查询结果表进行连接查询。

示例1

查询每个部门平均工资的工资等级

  1. -- 查询每个部门平均工资
  2. SELECT
  3.   department_id,
  4.   avg(a.salary)
  5. FROM employees a
  6. GROUP BY a.department_id;
  7.  
  8. -- 薪资等级表
  9. SELECT *
  10. FROM job_grades;
  11.  
  12. -- 将上面2个结果连接查询，筛选条件:平均工资 between lowest_sal and highest_sal;
  13. SELECT
  14.   t1.department_id,
  15.   sa AS '平均工资',
  16.   t2.grade_level
  17. FROM (SELECT
  18.         department_id,
  19.         avg(a.salary) sa
  20.       FROM employees a
  21.       GROUP BY a.department_id) t1, job_grades t2
  22. WHERE
  23.   t1.sa BETWEEN t2.lowest_sal AND t2.highest_sal;

运行最后一条结果如下：

  1. mysql> SELECT
  2.           t1.department_id,
  3.           sa AS '平均工资',
  4.           t2.grade_level
  5.         FROM (SELECT
  6.                 department_id,
  7.                 avg(a.salary) sa
  8.               FROM employees a
  9.               GROUP BY a.department_id) t1, job_grades t2
  10.         WHERE
  11.           t1.sa BETWEEN t2.lowest_sal AND t2.highest_sal;
  12. +---------------+--------------+-------------+
  13. | department_id | 平均工资     | grade_level |
  14. +---------------+--------------+-------------+
  15. |          NULL |  7000.000000 | C           |
  16. |            10 |  4400.000000 | B           |
  17. |            20 |  9500.000000 | C           |
  18. |            30 |  4150.000000 | B           |
  19. |            40 |  6500.000000 | C           |
  20. |            50 |  3475.555556 | B           |
  21. |            60 |  5760.000000 | B           |
  22. |            70 | 10000.000000 | D           |
  23. |            80 |  8955.882353 | C           |
  24. |            90 | 19333.333333 | E           |
  25. |           100 |  8600.000000 | C           |
  26. |           110 | 10150.000000 | D           |
  27. +---------------+--------------+-------------+
  28. 12 rows in set (0.00 sec)

where和having后面的子查询

where或having后面，可以使用

  1. 标量子查询（单行单列行子查询）

  2. 列子查询（单列多行子查询）

  3. 行子查询（多行多列）

特点

  1. 子查询放在小括号内。

  2. 子查询一般放在条件的右侧。

  3. 标量子查询，一般搭配着单行操作符使用，多行操作符   >、<、>=、<=、=、<>、!=

  4. 列子查询，一般搭配着多行操作符使用

in(not in)：列表中的“任意一个”

any或者some：和子查询返回的“某一个值”比较，比如a>som(10,20,30)，a大于子查询中任意一个即可，a大于子查询中最小值即可，等同于a>min(10,20,30)。

all：和子查询返回的“所有值”比较，比如a>all(10,20,30)，a大于子查询中所有值，换句话说，a大于子查询中最大值即可满足查询条件，等同于a>max(10,20,30);

  1. 子查询的执行优先于主查询执行，因为主查询的条件用到了子查询的结果。

mysql中的in、any、some、all

in，any，some，all分别是子查询关键词之一。

in：in常用于where表达式中，其作用是查询某个范围内的数据

any和some一样： 可以与=、>、>=、<、<=、<>结合起来使用，分别表示等于、大于、大于等于、小于、小于等于、不等于其中的任何一个数据。

all：可以与=、>、>=、<、<=、<>结合是来使用，分别表示等于、大于、大于等于、小于、小于等于、不等于其中的其中的所有数据。

下文中会经常用到这些关键字。

标量子查询

一般标量子查询，示例

查询谁的工资比Abel的高？

  1. /*①查询abel的工资【改查询是标量子查询】*/
  2. SELECT salary
  3. FROM employees
  4. WHERE last_name = 'Abel';
  5.  
  6. /*②查询员工信息，满足salary>①的结果*/
  7. SELECT *
  8. FROM employees a
  9. WHERE a.salary > (SELECT salary
  10.                   FROM employees
  11.                   WHERE last_name = 'Abel');
多个标量子查询，示例

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

  1. /*返回job_id与141号员工相同，salary比143号员工多的员工、姓名、job_id和工资*/
  2. /*①查询141号员工的job_id*/
  3. SELECT job_id
  4. FROM employees
  5. WHERE employee_id = 141;
  6. /*②查询143好员工的salary*/
  7. SELECT salary
  8. FROM employees
  9. WHERE employee_id = 143;
  10. /*③查询员工的姓名、job_id、工资，要求job_id=① and salary>②*/
  11. SELECT
  12.   a.last_name 姓名,
  13.   a.job_id,
  14.   a.salary    工资
  15. FROM employees a
  16. WHERE a.job_id = (SELECT job_id
  17.                   FROM employees
  18.                   WHERE employee_id = 141)
  19.       AND
  20.       a.salary > (SELECT salary
  21.                   FROM employees
  22.                   WHERE employee_id = 143);
子查询+分组函数，示例

查询最低工资大于50号部门最低工资的部门id和其最低工资【having】

  1. /*查询最低工资大于50号部门最低工资的部门id和其最低工资【having】*/
  2. /*①查询50号部门的最低工资*/
  3. SELECT min(salary)
  4. FROM employees
  5. WHERE department_id = 50;
  6. /*②查询每个部门的最低工资*/
  7. SELECT
  8.   min(salary),
  9.   department_id
  10. FROM employees
  11. GROUP BY department_id;
  12. /*③在②的基础上筛选，满足min(salary)>①*/
  13. SELECT
  14.   min(a.salary) minsalary,
  15.   department_id
  16. FROM employees a
  17. GROUP BY a.department_id
  18. HAVING min(a.salary) > (SELECT min(salary)
  19.                         FROM employees
  20.                         WHERE department_id = 50);
错误的标量子查询，示例

将上面的示例③中子查询语句中的min(salary)改为salary，执行效果如下：

  1. mysql> SELECT
  2.           min(a.salary) minsalary,
  3.           department_id
  4.         FROM employees a
  5.         GROUP BY a.department_id
  6.         HAVING min(a.salary) > (SELECT salary
  7.                                 FROM employees
  8.                                 WHERE department_id = 500000);
  9. ERROR 1242 (21000): Subquery returns more than 1 row

错误提示：子查询返回的结果超过了1行记录。

说明：上面的子查询只支持最多一列一行记录。

列子查询

列子查询需要搭配多行操作符使用：in(not in)、any/some、all。

为了提升效率，最好去重一下distinct关键字。

示例1

返回location_id是1400或1700的部门中的所有员工姓名

  1. /*返回location_id是1400或1700的部门中的所有员工姓名*/
  2. /*方式1*/
  3. /*①查询location_id是1400或1700的部门编号*/
  4. SELECT DISTINCT department_id
  5. FROM departments
  6. WHERE location_id IN (1400, 1700);
  7.  
  8. /*②查询员工姓名，要求部门是①列表中的某一个*/
  9. SELECT a.last_name
  10. FROM employees a
  11. WHERE a.department_id IN (SELECT DISTINCT department_id
  12.                           FROM departments
  13.                           WHERE location_id IN (1400, 1700));
  14.  
  15. /*方式2：使用any实现*/
  16. SELECT a.last_name
  17. FROM employees a
  18. WHERE a.department_id = ANY (SELECT DISTINCT department_id
  19.                              FROM departments
  20.                              WHERE location_id IN (1400, 1700));
  21.  
  22. /*拓展，下面与not in等价*/
  23. SELECT a.last_name
  24. FROM employees a
  25. WHERE a.department_id <> ALL (SELECT DISTINCT department_id
  26.                              FROM departments
  27.                              WHERE location_id IN (1400, 1700));
示例2

返回其他工种中比job_id为'IT_PROG'工种任意工资低的员工的员工号、姓名、job_id、salary

  1. /*返回其他工种中比job_id为'IT_PROG'工种任一工资低的员工的员工号、姓名、job_id、salary*/
  2. /*①查询job_id为'IT_PROG'部门任-工资*/
  3. SELECT DISTINCT salary
  4. FROM employees
  5. WHERE job_id = 'IT_PROG';
  6.  
  7. /*②查询员工号、姓名、job_id、salary，slary<①的任意一个*/
  8. SELECT
  9.   last_name,
  10.   employee_id,
  11.   job_id,
  12.   salary
  13. FROM employees
  14. WHERE salary < ANY (SELECT DISTINCT salary
  15.                     FROM employees
  16.                     WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';
  17.  
  18. /*或者*/
  19. SELECT
  20.   last_name,
  21.   employee_id,
  22.   job_id,
  23.   salary
  24. FROM employees
  25. WHERE salary < (SELECT max(salary)
  26.                 FROM employees
  27.                 WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';
示例3

返回其他工种中比job_id为'IT_PROG'部门所有工资低的员工的员工号、姓名、job_id、salary

  1. /*返回其他工种中比job_id为'IT_PROG'部门所有工资低的员工的员工号、姓名、job_id、salary*/
  2. SELECT
  3.   last_name,
  4.   employee_id,
  5.   job_id,
  6.   salary
  7. FROM employees
  8. WHERE salary < ALL (SELECT DISTINCT salary
  9.                     FROM employees
  10.                     WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';
  11.  
  12. /*或者*/
  13. SELECT
  14.   last_name,
  15.   employee_id,
  16.   job_id,
  17.   salary
  18. FROM employees
  19. WHERE salary < (SELECT min(salary)
  20.                 FROM employees
  21.                 WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';

行子查询（结果集一行多列）

示例

查询员工编号最小并且工资最高的员工信息，3种方式。

  1. /*查询员工编号最小并且工资最高的员工信息*/
  2. /*①查询最小的员工编号*/
  3. SELECT min(employee_id)
  4. FROM employees;
  5. /*②查询最高工资*/
  6. SELECT max(salary)
  7. FROM employees;
  8. /*③方式1：查询员工信息*/
  9. SELECT *
  10. FROM employees a
  11. WHERE a.employee_id = (SELECT min(employee_id)
  12.                        FROM employees)
  13.       AND salary = (SELECT max(salary)
  14.                     FROM employees);
  15.  
  16. /*方式2*/
  17. SELECT *
  18. FROM employees a
  19. WHERE (a.employee_id, a.salary) = (SELECT
  20.                                      min(employee_id),
  21.                                      max(salary)
  22.                                    FROM employees);
  23. /*方式3*/
  24. SELECT *
  25. FROM employees a
  26. WHERE (a.employee_id, a.salary) in (SELECT
  27.                                      min(employee_id),
  28.                                      max(salary)
  29.                                    FROM employees);

方式1比较常见，方式2、3更简洁。

exists后面（也叫做相关子查询）

  1. 语法：exists(玩转的查询语句)。

  2. exists查询结果：1或0，exists查询的结果用来判断子查询的结果集中是否有值。

  3. 一般来说，能用exists的子查询，绝对都能用in代替，所以exists用的少。

  4. 和前面的查询不同，这先执行主查询，然后主查询查询的结果，在根据子查询进行过滤，子查询中涉及到主查询中用到的字段，所以叫相关子查询。

示例1

简单示例

  1. mysql> SELECT exists(SELECT employee_id
  2.               FROM employees
  3.               WHERE salary = 300000) AS 'exists返回1或者0';
  4. +----------------------+
  5. | exists返回1或者0     |
  6. +----------------------+
  7. |                    0 |
  8. +----------------------+
  9. 1 row in set (0.00 sec)
示例2

查询所有员工的部门名称

  1. /*exists入门案例*/
  2. SELECT exists(SELECT employee_id
  3.               FROM employees
  4.               WHERE salary = 300000) AS 'exists返回1或者0';
  5.  
  6. /*查询所有员工部门名*/
  7. SELECT department_name
  8. FROM departments a
  9. WHERE exists(SELECT 1
  10.              FROM employees b
  11.              WHERE a.department_id = b.department_id);
  12.  
  13. /*使用in实现*/
  14. SELECT department_name
  15. FROM departments a
  16. WHERE a.department_id IN (SELECT department_id
  17.                           FROM employees);
示例3

查询没有员工的部门

  1. /*查询没有员工的部门*/
  2. /*exists实现*/
  3. SELECT *
  4. FROM departments a
  5. WHERE NOT exists(SELECT 1
  6.                  FROM employees b
  7.                  WHERE a.department_id = b.department_id AND b.department_id IS NOT NULL);
  8. /*in的方式*/
  9. SELECT *
  10. FROM departments a
  11. WHERE a.department_id NOT IN (SELECT department_id
  12.                               FROM employees b
  13.                               WHERE b.department_id IS NOT NULL);

上面脚本中有b.department_id IS NOT NULL，为什么，有大坑，向下看。

NULL的大坑

示例1

使用in的方式查询没有员工的部门，如下：

  1. SELECT *
  2. FROM departments a
  3. WHERE a.department_id NOT IN (SELECT department_id
  4.                               FROM employees b);

运行结果：

  1. mysql> SELECT *
  2.     -> FROM departments a
  3.     -> WHERE a.department_id NOT IN (SELECT department_id
  4.     ->                               FROM employees b);
  5. Empty set (0.00 sec)

in的情况下，子查询中列的值为NULL的时候，外查询的结果为空。

建议：建表是，列不允许为空。

总结

  1. 本文中讲解了常见的子查询，请大家务必多练习

  2. 注意in、any、some、any的用法

  3. 字段为空的时候，in查询有大坑，这个要注意

  4. 建议创建表的时候，列不允许为空

Mysql系列目录

  1. 第1篇：mysql基础知识

  2. 第2篇：详解mysql数据类型（重点）

  3. 第3篇：管理员必备技能(必须掌握)

  4. 第4篇：DDL常见操作

  5. 第5篇：DML操作汇总（insert,update,delete）

  6. 第6篇：select查询基础篇

  7. 第7篇：玩转select条件查询，避免采坑

  8. 第8篇：详解排序和分页(order by & limit)

  9. 第9篇：分组查询详解（group by & having）

  10. 第10篇：常用的几十个函数详解

  11. 第11篇：深入了解连接查询及原理

mysql系列大概有20多篇，喜欢的请关注一下，欢迎大家加我微信itsoku或者留言交流mysql相关技术!

640?wx_fmt=jpeg

来源：https://itsoku.blog.csdn.net/article/details/101444328

posted @ 2022-04-23 22:06  程序员小明1024  阅读(835)  评论(0)  编辑  收藏  举报