当前位置:   article > 正文

mysql 子查询总结_mysql子查询总结

mysql子查询总结

什么是子查询

子查询指一个查询语句嵌套在另一个查询语句内部的查询,这个特性从 MySQL 4.1 开始引入;
SQL 中子查询的使用大大增强了 SELECT 查询的能力,因为很多时候查询需要从结果集中获取数据,或者 需要从同一个表中先计算得出一个数据结果,然后与这个数据结果(可能是某个标量,也可能是某个集 合)进行比较。

一个实际场景

求员工表中工资比 Abel这个员工工资高的其他员工

现有解决方式

1、分步骤查询

  1. SELECT salary FROM employees WHERE last_name = 'Abel';
  2. SELECT last_name,salary FROM employees WHERE salary > 11000;

2、自连接

SELECT e2.last_name,e2.salary FROM employees e1,employees e2 WHERE e1.last_name = 'Abel' AND e1.`salary` < e2.`salary`

3、子查询

SELECT salary FROM employees WHERE salary > ( SELECT salary FROM employees WHERE last_name = 'Abel' );

子查询的基本使用

子查询的基本语法结构:

  • 子查询(内查询)在主查询之前一次执行完成;
  • 子查询的结果被主查询(外查询)使用 ;

注意事项

  • 子查询要包含在括号内 ;
  • 将子查询放在比较条件的右侧;
  • 单行操作符对应单行子查询,多行操作符对应多行子查询;

子查询的分类

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

 

2、多行子查询

 

 

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

  • 子查询从数据表中查询了数据结果,如果这个数据结果只执行一次,然后这个数据结果作为主查询的条 件进行执行,那么这样的子查询叫做不相关子查询;
  • 同样,如果子查询需要执行多次,即采用循环的方式,先从外部查询开始,每次都传入子查询进行查询,然后再将结果反馈给外部,这种嵌套的执行方式就称为相关子查询;

单行子查询

单行比较操作符

 

代码示例
查询工资大于 149 号员工工资的员工的信息

 

返回 job_id 141 号员工相同, salary 143 号员工多的员工姓名, job_id 和工资

 

返回公司工资最少的员工的 last_name,job_id salary

 

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

 

实现方式 1 :不成对比较
  1. SELECT employee_id, manager_id, department_id
  2. FROM employees
  3. WHERE manager_id IN
  4. (SELECT manager_id FROM employees WHERE employee_id IN (174,141))
  5. AND department_id IN
  6. (SELECT department_id FROM employees WHERE employee_id IN (174,141))
  7. AND employee_id NOT IN(174,141)
实现方式 2 :成对比较
  1. SELECT
  2. employee_id,
  3. manager_id,
  4. department_id
  5. FROM
  6. employees
  7. WHERE
  8. (manager_id, department_id) IN (
  9. SELECT
  10. manager_id,
  11. department_id
  12. FROM
  13. employees
  14. WHERE
  15. employee_id IN (141, 174)
  16. )
  17. AND employee_id NOT IN (141, 174);

查询最低工资大于 50 号部门最低工资的部门 id 和其最低工资
  1. SELECT
  2. department_id,
  3. MIN(salary)
  4. FROM
  5. employees
  6. GROUP BY
  7. department_id
  8. HAVING
  9. MIN(salary) > (
  10. SELECT
  11. MIN(salary)
  12. FROM
  13. employees
  14. WHERE
  15. department_id = 50
  16. );

CASE中的子查询

CASE表达式中使用单列子查询:

显式员工的 employee_id,last_name location 。其中,若员工 department_id location_id 1800 的department_id 相同,则 location ’Canada’ ,其余则为 ’USA’

  1. SELECT
  2. employee_id,
  3. last_name,
  4. (
  5. CASE department_id
  6. WHEN (
  7. SELECT
  8. department_id
  9. FROM
  10. departments
  11. WHERE
  12. location_id = 1800
  13. ) THEN
  14. 'Canada'
  15. ELSE
  16. 'USA'
  17. END
  18. ) location
  19. FROM
  20. employees;

多行子查询

  • 也称为集合比较子查询;
  • 内查询返回多行;
  • 使用多行比较操作符;

多行比较操作符

 

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

 

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

 

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

方式1:

  1. SELECT
  2. department_id
  3. FROM
  4. employees
  5. GROUP BY
  6. department_id
  7. HAVING
  8. AVG(salary) = (
  9. SELECT
  10. MIN(avg_sal)
  11. FROM
  12. (
  13. SELECT
  14. AVG(salary) avg_sal
  15. FROM
  16. employees
  17. GROUP BY
  18. department_id
  19. ) dept_avg_sal
  20. )

方式2:

  1. SELECT
  2. department_id
  3. FROM
  4. employees
  5. GROUP BY
  6. department_id
  7. HAVING
  8. AVG(salary) <= ALL (
  9. SELECT
  10. AVG(salary) avg_sal
  11. FROM
  12. employees
  13. GROUP BY
  14. department_id
  15. )

相关子查询

关联,因此每执行一次外部查询,子查询都要重新计算一次,这样的子查询就称之为 关联子查询 。 相关子查询按照一行接一行的顺序执行,主查询的每一行都执行一次子查询

 语法结构:

 

说明: 子查询中使用主查询中的列
查询员工中工资大于本部门平均工资的员工的 last_name,salary 和其 department_id

方式1:相关子查询

 

方式2:FROM 中使用子查询

  1. SELECT
  2. last_name,
  3. salary,
  4. e1.department_id
  5. FROM
  6. employees e1,
  7. (
  8. SELECT
  9. department_id,
  10. AVG(salary) dept_avg_sal
  11. FROM
  12. employees
  13. GROUP BY
  14. department_id
  15. ) e2
  16. WHERE
  17. e1.`department_id` = e2.department_id
  18. AND e2.dept_avg_sal < e1.`salary`;

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

  1. SELECT
  2. employee_id,
  3. salary
  4. FROM
  5. employees e
  6. ORDER BY
  7. (
  8. SELECT
  9. department_name
  10. FROM
  11. departments d
  12. WHERE
  13. e.`department_id` = d.`department_id`
  14. );

employees 表中 employee_id job_history 表中 employee_id 相同的数目不小于 2 ,输这些相同 id 的员工的 employee_id,last_name 和其 job_id
  1. SELECT
  2. e.employee_id,
  3. last_name,
  4. e.job_id
  5. FROM
  6. employees e
  7. WHERE
  8. 2 <= (
  9. SELECT
  10. COUNT(*)
  11. FROM
  12. job_history
  13. WHERE
  14. employee_id = e.employee_id
  15. );

EXISTS NOT EXISTS关键字

1、关联子查询通常也会和 EXISTS 操作符一起来使用,用来检查在子查询中是否存在满足条件的行;
2、 如果在子查询中不存在满足条件的行: 条件返回 FALSE,继续在子查询中查找;
3、 如果在子查询中存在满足条件的行: 不在子查询中继续查找 条件返回 TRUE;
4、 NOT EXISTS 关键字表示如果不存在某种条件,则返回 TRUE ,否则返回 FALSE;
查询公司管理者的 employee_id last_name job_id department_id 信息

方式1:

  1. SELECT
  2. employee_id,
  3. last_name,
  4. job_id,
  5. department_id
  6. FROM
  7. employees e1
  8. WHERE
  9. EXISTS (
  10. SELECT
  11. *
  12. FROM
  13. employees e2
  14. WHERE
  15. e2.manager_id = e1.employee_id
  16. );

方式2:自连接

  1. SELECT DISTINCT
  2. e1.employee_id,
  3. e1.last_name,
  4. e1.job_id,
  5. e1.department_id
  6. FROM
  7. employees e1
  8. JOIN employees e2
  9. WHERE
  10. e1.employee_id = e2.manager_id;

方式3:

  1. SELECT DISTINCT
  2. e1.employee_id,
  3. e1.last_name,
  4. e1.job_id,
  5. e1.department_id
  6. FROM
  7. employees e1
  8. WHERE
  9. e1.employee_id IN (
  10. SELECT DISTINCT
  11. manager_id
  12. FROM
  13. employees
  14. );

查询departments表中,不存在于employees表中的部门的department_iddepartment_name
  1. SELECT
  2. department_id,
  3. department_name
  4. FROM
  5. departments d
  6. WHERE
  7. NOT EXISTS (
  8. SELECT
  9. 'X'
  10. FROM
  11. employees
  12. WHERE
  13. department_id = d.department_id
  14. );

相关更新

  1. UPDATE table1 alias1
  2. SET COLUMN = (
  3. SELECT
  4. expression
  5. FROM
  6. table2 alias2
  7. WHERE
  8. alias1. COLUMN = alias2. COLUMN
  9. );

使用相关子查询依据一个表中的数据更新另一个表的数据
employees 中增加一个 department_name 字段,数据为员工对应的部门名称

方式1:

  1. ALTER TABLE employees ADD (
  2. department_name VARCHAR2 (14)
  3. );

方式2:

  1. UPDATE employees e
  2. SET department_name = (
  3. SELECT
  4. department_name
  5. FROM
  6. departments d
  7. WHERE
  8. e.department_id = d.department_id
  9. );

相关删除

  1. DELETE
  2. FROM
  3. table1 alias1
  4. WHERE
  5. COLUMN operator (
  6. SELECT
  7. expression
  8. FROM
  9. table2 alias2
  10. WHERE
  11. alias1. COLUMN = alias2. COLUMN
  12. );

使用相关子查询依据一个表中的数据删除另一个表的数据
删除表 employees 中,其与 emp_history 表皆有的数据
  1. DELETE
  2. FROM
  3. employees e
  4. WHERE
  5. employee_id IN (
  6. SELECT
  7. employee_id
  8. FROM
  9. emp_history
  10. WHERE
  11. employee_id = e.employee_id
  12. );
谁的工资比 Abel 的高?

方式1:自连接

  1. SELECT
  2. e2.last_name,
  3. e2.salary
  4. FROM
  5. employees e1,
  6. employees e2
  7. WHERE
  8. e1.last_name = 'Abel'
  9. AND e1.`salary` < e2.`salary`

方式2:子查询

  1. SELECT
  2. last_name,
  3. salary
  4. FROM
  5. employees
  6. WHERE
  7. salary > (
  8. SELECT
  9. salary
  10. FROM
  11. employees
  12. WHERE
  13. last_name = 'Abel'
  14. );

以上两种方式有好坏之分吗? 解答: 自连接方式好!

原因解释:

1、题目中可以使用子查询,也可以使用自连接。一般情况建议你使用自连接,因为在许多 DBMS 的处理过 程中,对于自连接的处理速度要比子查询快得多;
2、可以这样理解:子查询实际上是通过未知表进行查询后的条件判断,而自连接是通过已知的自身数据表 进行条件判断,因此在大部分 DBMS 中都对自连接处理进行了优化。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小丑西瓜9/article/detail/384812
推荐阅读
相关标签
  

闽ICP备14008679号