当前位置:首页 > sql > 正文内容

关于MySQL子查询

hxing6413个月前 (01-11)sql6852

子查询指一个查询语句嵌套在另一个查询语句内部的查询,这个特性从MySQL4.1开始引入。

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


1.需求分析与问题解决

1.1 实际问题

查询出employees表中,比Abel工资高的员工信息。

-- 方式1多表查询 自连接
SELECT
    e2.`last_name`,
    e2.`salary`
FROM
    employees e1,
    employees e2
WHERE e2.`salary` > e1.`salary`
    AND e1.`last_name` = 'Abel';-- 相当于自连接e1表(一张只有一行数据的employees表)
-- 方式2 子查询
SELECT
    last_name,
    salary
FROM
    employees
WHERE salary >
    (SELECT
        salary
    FROM
        employees
    WHERE last_name = 'Abel');


1.2 子查询的基本使用

子查询的基本语法结构。

SELECT select_list
FROM table_name
WHERE expr operator
(SELECT select_list FROM table_name);

子查询(内查询)在主查询之前一次执行完成。

子查询的结果被主查询(外查询)使用。

注意事项

  • 子查询要包含在括号内。

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

  • 单行操作符对于单行子查询,多行操作符对于多行子查询。

1.3 子查询的分类

分类方式1:

按照内查询的结果返回一条还是多条记录,将子查询分为 单行子查询,多行子查询。


分类方式2:

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

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

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


2.单行子查询

2.1 单行比较操作符

2883613-20240102224803754-1183185236.jpg


2.2 代码示例

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

mysql> SELECT last_name,employee_id,salary
    -> FROM employees
    -> WHERE salary > (
    ->                 SELECT salary FROM employees WHERE employee_id = 149
    ->                 );
+-----------+-------------+----------+
| last_name | employee_id | salary   |
+-----------+-------------+----------+
| King      |         100 | 24000.00 |
| Kochhar   |         101 | 17000.00 |
| De Haan   |         102 | 17000.00 |
...
| Hartstein |         201 | 13000.00 |
| Higgins   |         205 | 12000.00 |
+-----------+-------------+----------+
13 rows in set (0.00 sec)


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

mysql> SELECT last_name,job_id,salary
    -> FROM employees
    -> WHERE job_id = (SELECT job_id FROM employees WHERE employee_id = 149)
    -> AND salary > (SELECT salary FROM employees WHERE employee_id = 143);
+-----------+--------+----------+
| last_name | job_id | salary   |
+-----------+--------+----------+
| Russell   | SA_MAN | 14000.00 |
| Partners  | SA_MAN | 13500.00 |
| Errazuriz | SA_MAN | 12000.00 |
| Cambrault | SA_MAN | 11000.00 |
| Zlotkey   | SA_MAN | 10500.00 |
+-----------+--------+----------+
5 rows in set (0.00 sec)


题目 :返回公司工资最少的员工的last_name,job_id和salary

mysql> SELECT last_name,job_id,salary
    -> FROM employees
    -> WHERE salary = (SELECT MIN(salary) FROM employees);
+-----------+----------+---------+
| last_name | job_id   | salary  |
+-----------+----------+---------+
| Olson     | ST_CLERK | 2100.00 |
+-----------+----------+---------+
1 row in set (0.00 sec)


扩展,如何求出工资倒数第二的工资的员工的last_name,job_id和salary

mysql> SELECT last_name,job_id,salary
    -> FROM employees
    -> WHERE salary = (SELECT MIN(salary) FROM employees WHERE salary != (SELECT MIN(salary) FROM employees));
+------------+----------+---------+
| last_name  | job_id   | salary  |
+------------+----------+---------+
| Markle     | ST_CLERK | 2200.00 |
| Philtanker | ST_CLERK | 2200.00 |
+------------+----------+---------+
2 rows in set (0.00 sec)

来源,这是我再leetcode刷到过的sql的中等题目

思路解析,WHERE salary != (SELECT MIN(salary) FROM employees) 就是,过滤掉倒数第一的工资,排除倒数第一的工资的倒数第一的工资就是倒数第二,当时觉得这个思路,特别好,记忆比较深刻。


题目,查询与141号或174号员工的manager_id和department_id相同的其他员工的employee_id,manager_id,department_id

题目 其实是多行子查询(返回结果是多行的)

不成对比较

mysql> SELECT employee_id,manager_id,department_id
    -> FROM employees
    -> WHERE manager_id IN (SELECT manager_id FROM employees WHERE employee_id IN (141,174))
    -> AND department_id IN (SELECT department_id FROM employees WHERE employee_id IN (141,174))
    -> AND employee_id NOT IN(141,174);
+-------------+------------+---------------+
| employee_id | manager_id | department_id |
+-------------+------------+---------------+
|         142 |        124 |            50 |
|         143 |        124 |            50 |
|         144 |        124 |            50 |
|         196 |        124 |            50 |
|         197 |        124 |            50 |
|         198 |        124 |            50 |
|         199 |        124 |            50 |
|         175 |        149 |            80 |
|         176 |        149 |            80 |
|         177 |        149 |            80 |
|         179 |        149 |            80 |
+-------------+------------+---------------+
11 rows in set (0.00 sec)

成对比较(使用的条件很苛刻,用的很少)

mysql> 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);
+-------------+------------+---------------+
| employee_id | manager_id | department_id |
+-------------+------------+---------------+
|         142 |        124 |            50 |
|         143 |        124 |            50 |
|         144 |        124 |            50 |
|         196 |        124 |            50 |
|         197 |        124 |            50 |
|         198 |        124 |            50 |
|         199 |        124 |            50 |
|         175 |        149 |            80 |
|         176 |        149 |            80 |
|         177 |        149 |            80 |
|         179 |        149 |            80 |
+-------------+------------+---------------+
11 rows in set (0.00 sec)


2.3 HAVING中的子查询

  • 首先执行子查询

  • 向主查询中的HAVING子句返回结果

题目 查询最低工资大于50号部门最低工资的部门id和其最低工资

mysql> SELECT department_id,MIN(salary)
    -> FROM employees
    -> GROUP BY department_id
    -> HAVING MIN(salary) > (SELECT MIN(salary) FROM employees WHERE department_id = 50);
+---------------+-------------+
| department_id | MIN(salary) |
+---------------+-------------+
|          NULL |     7000.00 |
|            10 |     4400.00 |
|            20 |     6000.00 |
|            30 |     2500.00 |
|            40 |     6500.00 |
|            60 |     4200.00 |
|            70 |    10000.00 |
|            80 |     6100.00 |
|            90 |    17000.00 |
|           100 |     6900.00 |
|           110 |     8300.00 |
+---------------+-------------+
11 rows in set (0.00 sec)


2.4 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 'Canadad'
            ELSE 'USA'
        END
    ) AS 'location'
FROM
    employees


2.5 子查询中的空值现象

出现原因是,子查询中为查到数据,也可能是子查询中查到的数据中包含null(多行子查询中出现空值现象的原因)

mysql> SELECT last_name,salary,job_id
    -> FROM employees
    -> WHERE job_id = (SELECT job_id FROM employees WHERE last_name = 'wind');
Empty set (0.00 sec)


2.6 非法使用子查询

mysql> SELECT last_name,salary,job_id
    -> FROM employees
    -> WHERE salary = (SELECT MIN(salary) FROM employees GROUP BY department_id);
ERROR 1242 (21000): Subquery returns more than 1 row


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


3.多行子查询

  • 也称为集合比较子查询

  • 子查询返回多行

  • 使用多行比较操作符

3.1 多行比较操作符

2883613-20240102224848526-79914983.jpg


3.2 代码示例

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

mysql> SELECT employee_id,last_name,job_id,salary
    -> FROM employees
    -> WHERE salary < ANY (SELECT salary FROM employees
    -> WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';
+-------------+-------------+------------+---------+
| employee_id | last_name   | job_id     | salary  |
+-------------+-------------+------------+---------+
...
|         202 | Fay         | MK_REP     | 6000.00 |
|         203 | Mavris      | HR_REP     | 6500.00 |
|         206 | Gietz       | AC_ACCOUNT | 8300.00 |
+-------------+-------------+------------+---------+
76 rows in set (0.00 sec)
-- 上述sql语句也可以转化为下面这条sql语句,是因为比任一工资低的条件,可以转化为比最大值低即可
-- 这是因为比除最大值外的值低的条件,会隐形的包含在比最大值低的情况下
SELECT employee_id,last_name,job_id,salary
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees
WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';


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

mysql> SELECT employee_id,last_name,job_id,salary
    -> FROM employees
    -> WHERE salary < ALL (SELECT salary FROM employees
    -> WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';
+-------------+-------------+----------+---------+
| employee_id | last_name   | job_id   | salary  |
+-------------+-------------+----------+---------+
|         115 | Khoo        | PU_CLERK | 3100.00 |
|         116 | Baida       | PU_CLERK | 2900.00 |
|         117 | Tobias      | PU_CLERK | 2800.00 |
...
|         197 | Feeney      | SH_CLERK | 3000.00 |
|         198 | OConnell    | SH_CLERK | 2600.00 |
|         199 | Grant       | SH_CLERK | 2600.00 |
+-------------+-------------+----------+---------+
44 rows in set (0.00 sec)
-- 上述sql语句也可以转化成下面这条SQL语句,是因为比所有的工资都低的员工,可以转成比最小值低即可
-- 这是因为比除最小值的值低的条件,会隐形的包含在比最小值低的情况下
SELECT employee_id,last_name,job_id,salary
FROM employees
WHERE salary < (SELECT MIN(salary) FROM employees
WHERE job_id = 'IT_PROG') AND job_id != 'IT_PROG';


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

思路,按照部门id分类,查出各部门的平均工资,然后找出小于等于所有部门平均工资的平均工资对于的部门id。

mysql> SELECT
    ->     department_id
    -> FROM
    ->     employees
    -> GROUP BY department_id
    -> HAVING AVG(salary) <= ALL
    ->     (SELECT
    ->         AVG(salary)
    ->     FROM
    ->         employees
    ->     GROUP BY department_id);
+---------------+
| department_id |
+---------------+
|            50 |
+---------------+
1 row in set (0.00 sec)
-- 上述sql可以转化为下面SQL语句
-- 思路,找出最小的平均工资对应的部门
SELECT department_id
FROM employees
GROUP BY department_id
HAVING AVG(salary) = (
            SELECT MIN(avg_salary)
            FROM (
                SELECT AVG(salary) AS avg_salary
                FROM employees
                GROUP BY department_id
            ) t
        );

注意,在MYSQL中聚合函数不能嵌套使用。

mysql> SELECT
    ->         MIN(AVG(salary))
    ->     FROM
    ->         employees
    ->     GROUP BY department_id;
ERROR 1111 (HY000): Invalid use of group function


3.3 空值问题

mysql> SELECT employee_id
    -> FROM employees
    -> WHERE employee_id NOT IN(
    ->         SELECT manager_id
    ->         FROM employees
    ->         );
Empty set (0.00 sec)
-- sql分析,原本是想获取不在管理者中的员工信息,但是因为子查询中存在null值,导致整个查询为空
SELECT employee_id,last_name
FROM employees
WHERE employee_id NOT IN(
            SELECT manager_id
            FROM employees
            );
-- 获取不在管理者中的员工信息 正确的写法            
SELECT employee_id,last_name
FROM employees
WHERE employee_id NOT IN(
            SELECT manager_id
            FROM employees
                WHERE manager_id IS NOT NULL
            );


4.相关子查询

4.1 相关子查询执行流程

如果子查询的执行依赖于外部查询,通常情况下都是因为子查询中的表用到了外部的表,并进行了条件关联,因此每执行一次外部查询,子查询都要重新计算一次,这样的子查询就被称为关联子查询。

相关子查询按照一行一行的顺序执行,主查询的每一行都执行一次子查询。

2883613-20240102224928947-1462666561.jpg


-- 相关子查询语法 子查询中使用主查询中的列
SELECT column1,column2,...
FROM table1 outer
WHERE column1 operator 
(SELECT column1,column2 FROM table2 WHERE expr1 = outer.expr2);


4.2 代码示例

题目:查询员工中工资大于本部门平均工资的员工的last_name,salary和其department_id

方式一:相关子查询

mysql> SELECT last_name,salary,department_id
    -> FROM employees e
    -> WHERE salary > (
    ->             SELECT AVG(salary)
    ->             FROM employees
    ->             WHERE department_id = e.`department_id`
    ->             GROUP BY department_id
    ->             );
+-----------+----------+---------------+
| last_name | salary   | department_id |
+-----------+----------+---------------+
| King      | 24000.00 |            90 |
| Hunold    |  9000.00 |            60 |
| Ernst     |  6000.00 |            60 |
| Greenberg | 12000.00 |           100 |
...
| Everett   |  3900.00 |            50 |
| Hartstein | 13000.00 |            20 |
| Higgins   | 12000.00 |           110 |
+-----------+----------+---------------+
38 rows in set (0.00 sec)

方式二:FROM子句中使用子查询

mysql> SELECT last_name,salary,e1.department_id
    -> FROM employees e1,(SELECT AVG(salary) AS avg_sal,department_id FROM employees GROUP BY department_id) e2
    -> WHERE e1.`salary` > e2.avg_sal AND e1.`department_id` = e2.department_id;
+-----------+----------+---------------+
| last_name | salary   | department_id |
+-----------+----------+---------------+
| Hartstein | 13000.00 |            20 |
| Raphaely  | 11000.00 |            30 |
...
| Greenberg | 12000.00 |           100 |
| Faviet    |  9000.00 |           100 |
| Higgins   | 12000.00 |           110 |
+-----------+----------+---------------+
38 rows in set (0.00 sec)


FROM子句中使用子查询,子查询是作为FROM的一部分,子查询要用()引起来,并且要给这个子查询起别名,把它当作一张临时表使用。


在ORDER BY中使用子查询

题目:查询员工的id,salary,按照department_name 排序

SELECT employee_id,salary
FROM employees e
ORDER BY (
    SELECT department_name 
    FROM departments 
    WHERE department_id = e.`department_id`
    );


题目:若employees表中employee_id与job_history表中employee_id相同的数目不小于2,输出这些相同id的员工的employee_id,last_name和其job_id

SELECT employee_id,last_name,job_id
FROM employees e
WHERE 2 <= (
    SELECT COUNT(*)
    FROM job_history
    WHERE employee_id = e.`employee_id`
    );


4.3 EXISTS与NOT EXISTS关键字

关联子查询通常也会和EXISTS操作符一起来使用,用来检查在子查询中是否存在满足条件的行。

  • 如果在子查询中不存在满足条件的行

            条件返回false

            继续在子查询中查找

  • 如果在子查询中存在满足条件的行

        不在子查询中继续查找

        条件返回true

  • NOT EXISTS关键字表示如果不存在返回true,存在返回false

题目:查询公司管理者的employee_id,last_name,job_id,department_id信息

-- 方式1 相关子查询 + EXISTS关键字
SELECT employee_id,last_name,job_id,department_id
FROM employees e1
WHERE EXISTS (SELECT manager_id FROM employees e2 WHERE e2.manager_id = e1.`employee_id`);

-- 方式2 自连接
-- 加DISTINCT关键字的原因,因为满足e1.employee_id = e2.manager_id的条件有很多条,而显示的又是e1表的列数据,就会导致重复的数据
SELECT DISTINCT e1.employee_id,e1.last_name,e1.job_id,e1.department_id
FROM employees e1 JOIN employees e2
WHERE e1.employee_id = e2.manager_id;
-- 或者这样理解,因为显示的是管理者的列信息,而一个管理者下面会有很多员工,所以满足条件的管理者就会重复出现,所以需要加DISTINCT关键字
SELECT DISTINCT manager.employee_id,manager.last_name,manager.job_id,manager.department_id
FROM employees manager JOIN employees worker
WHERE manager.employee_id = worker.manager_id;

-- 方式3 
SELECT employee_id,last_name,job_id,department_id
FROM employees
WHERE employee_id IN (SELECT manager_id FROM employees);


题目:查询departments表中,不存在于employees表中的部门的department_id和department_name

SELECT department_id,department_name
FROM departments d
WHERE NOT EXISTS (SELECT 'X' FROM employees e WHERE e.`department_id` = d.`department_id`)


4.4 相关更新

语法

UPDATE table1 alias1
SET column = (SELECT expression FROM table2 alias2 WHERE alias1.column = alias2.column);

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


案例

题目:在employees中增加一个department_name字段,数据为员工对应的部门名称。

ALTER TABLE employees 
MODIFY department_name VARCHAR(30)
UPDATE employees e
SET e.department_name = (SELECT department_name FROM departments d WHERE d.`department_id` = e.`department_id`);


4.5 相关删除

语法

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 e.employee_id IN (
    SELECT employee_id 
    FROM emp_history e1
    WHERE e1.employee_id = e.employee_id
    );


5.思考题

谁的工资比Abel的高?

-- 方式1多表查询 自连接
SELECT
    e2.`last_name`,
    e2.`salary`
FROM
    employees e1,
    employees e2
WHERE e2.`salary` > e1.`salary`
    AND e1.`last_name` = 'Abel';-- 相当于自连接e1表(一张只有一行数据的employees表)
    
-- 方式2 子查询
SELECT
    last_name,
    salary
FROM
    employees
WHERE salary >
    (SELECT
        salary
    FROM
        employees
    WHERE last_name = 'Abel');


问题

自连接和子查询那种好?


答案

自连接更好!如果需求可以使用自连接,也可以使用子查询的情况下,建议使用自连接。原因,因为在许多DBMS的处理过程中,对于自连接的处理速度要比子查询快的多。

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

扫描二维码推送至手机访问。

版权声明:本文由星星博客发布,如需转载请注明出处。

本文链接:https://www.xingxinghan.cn/?id=510

分享给朋友:

“关于MySQL子查询” 的相关文章

MySQL数据库的基本操作

MySQL是一种广泛使用的关系型数据库管理系统,它的速度快、效率高且易于使用,被广大开发者用于各种应用,从小型个人项目到大型企业级应用。在本文中,我们将探讨MySQL数据库的基本操作,包括创建数据库、创建表、插入数据、查询数据和更新数据等。 在开始操...

HANA数据库用户表PASSWORD_CHANGE_NEEDED和PASSWORD_LIFETIME_CHECK的作用

因为hana数据库所在服务器主板出现问题,更换硬件设备重新安装导入数据后原来的账户提示连接失败,咨询服务商得知和这2个字段有关,于是记录备份下。在SAP HANA数据库中,有两个与用户密码相关的字段,它们分别是"PASSWORD_CHANGE_NEEDED"和"PASS...

MySQL修改用户名密码:详细步骤及代码演示

MySQL是一种非常流行的开源关系型数据库管理系统。在使用MySQL时,我们通常需要创建多个用户并设置相应的权限。当需要修改某个用户的用户名或密码时,该怎么办呢?本文将详细介绍MySQL修改用户名密码的步骤,并提供相关的代码演示。 一、连接到MySQ...

Mysql 开启外网访问

mysql -u root -puse mysql;select user,host from user;GRANT ALL PRIVILEGES ON *.* TO &...

mysql查询名称重复的数据

查询所有重复数据:SELECT * FROM your_table_name WHERE your_name IN (     SELECT your_name   ...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。