SQL查询中，WHERE子句不仅可以完成简单的条件筛选，还可以配合子查询实现复杂的数据过滤。当查询条件涉及多个数据表、层级关系或动态计算结果时，多层嵌套查询能够将复杂业务逻辑拆分成多个查询层次，从而得到更加精准的结果。
不过，WHERE子句嵌套层数增加后，SQL的可读性、执行效率和维护成本也会随之上升。因此，掌握多层嵌套查询的写法，同时了解其优化方法，对于编写高质量SQL非常重要。
一、WHERE子句中的嵌套查询是什么
所谓WHERE子句嵌套查询，就是在一个SQL查询的WHERE条件中再次使用SELECT语句。例如，需要查询工资高于公司平均工资的员工，可以使用以下SQL：
SELECT *
FROM employee
WHERE salary > (
SELECT AVG(salary)
FROM employee
);外层查询负责获取员工信息，内层查询负责计算平均工资。内层SELECT的结果会作为外层WHERE条件的一部分参与判断。
这种结构可以继续向下嵌套。例如，先查询平均工资，再根据平均工资查询部门，再根据部门查询员工：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE manager_id IN (
SELECT employee_id
FROM employee
WHERE salary > 20000
)
);这里形成了两层子查询：
外层：查询员工
↓
第一层：查询符合条件的部门
↓
第二层：查询高薪员工SQL支持多层嵌套，但并不意味着嵌套层数越多越好。实际开发中应该根据数据关系和执行计划选择更加合理的写法。
二、单层WHERE子查询的基本用法
掌握多层嵌套之前，需要先理解常见的单层子查询。
1. 使用标量子查询
当子查询只返回一个值时，可以直接与比较运算符配合使用：
SELECT employee_id, employee_name, salary
FROM employee
WHERE salary > (
SELECT AVG(salary)
FROM employee
);常见的运算符包括：
=
>
<
>=
<=
<>例如查询工资等于最高工资的员工：
SELECT employee_id, employee_name, salary
FROM employee
WHERE salary = (
SELECT MAX(salary)
FROM employee
);需要注意的是，标量子查询必须返回单个值。如果子查询返回多行，可能产生类似“子查询返回多行”的错误。
2. 使用IN进行多值匹配
如果子查询可能返回多个值，应考虑使用IN：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE location = 'Tokyo'
);内层查询返回多个部门编号，外层查询再根据部门编号筛选员工。
3. 使用EXISTS判断记录是否存在
EXISTS尤其适合处理“是否存在相关记录”的业务条件：
SELECT e.employee_id, e.employee_name
FROM employee e
WHERE EXISTS (
SELECT 1
FROM employee_project p
WHERE p.employee_id = e.employee_id
);这条SQL用于查询参与过项目的员工。
EXISTS关注的是是否存在符合条件的记录，而不是具体返回哪些字段，因此通常写成：
SELECT 1即可。
三、WHERE子句多层嵌套查询实例
假设存在以下三张表：
employee
department
company其中：
employee.department_id
department.company_id分别表示员工所属部门以及部门所属公司。
现在需要查询“属于总部公司，并且工资高于总部员工平均工资的员工”。
可以先查询总部公司的部门：
SELECT department_id
FROM department
WHERE company_id = (
SELECT company_id
FROM company
WHERE company_name = '总部'
);然后继续查询员工：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id = (
SELECT company_id
FROM company
WHERE company_name = '总部'
)
);如果再加入平均工资条件：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id = (
SELECT company_id
FROM company
WHERE company_name = '总部'
)
)
AND salary > (
SELECT AVG(salary)
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id = (
SELECT company_id
FROM company
WHERE company_name = '总部'
)
)
);虽然这种方式逻辑上没有问题，但已经出现明显的重复嵌套。随着业务条件继续增加，SQL会越来越难以维护。
因此，多层嵌套查询真正需要关注的不只是“如何写出来”，还包括“如何写得清楚、写得高效”。
四、理解嵌套查询的执行逻辑
阅读多层嵌套SQL时，可以从最内层开始分析。
例如：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id IN (
SELECT company_id
FROM company
WHERE company_name = '总部'
)
);可以拆解为三个步骤。
第一步，查询目标公司：
SELECT company_id
FROM company
WHERE company_name = '总部';假设返回：
company_id
----------
10第二步，根据公司编号查询部门：
SELECT department_id
FROM department
WHERE company_id IN (10);假设得到：
101
102
103第三步，根据部门编号查询员工：
SELECT *
FROM employee
WHERE department_id IN (101, 102, 103);这种“由内向外”的分析方法非常适合排查复杂WHERE条件。
当SQL出现多层嵌套时，可以先分别运行最内层SELECT，确认每一层实际返回的数据，再逐层向外组合。
五、IN嵌套查询与EXISTS的选择
很多场景下，IN和EXISTS都可以实现相同业务逻辑，但两者的使用场景并不完全相同。
例如：
SELECT *
FROM employee e
WHERE e.department_id IN (
SELECT d.department_id
FROM department d
WHERE d.status = 1
);也可以写成：
SELECT *
FROM employee e
WHERE EXISTS (
SELECT 1
FROM department d
WHERE d.department_id = e.department_id
AND d.status = 1
);如果重点是判断外层记录是否存在对应的关联记录，EXISTS通常更加直观。
特别是在相关子查询中：
WHERE EXISTS (
SELECT 1
FROM order_detail od
WHERE od.order_id = o.order_id
);内层查询会引用外层查询的字段，这种写法就是典型的相关子查询。
具体性能不能简单地认为“EXISTS一定比IN快”或“IN一定更快”。现代数据库优化器可能会对两种写法进行改写，因此最终应该结合数据库类型、数据规模、索引以及执行计划进行判断。
六、避免NOT IN遇到NULL问题
多层WHERE查询中，一个容易被忽略的问题是NULL。
例如：
SELECT *
FROM employee
WHERE department_id NOT IN (
SELECT department_id
FROM department
);如果department表中的department_id存在NULL，NOT IN可能产生与预期不同的结果。
这是因为SQL中的NULL不是普通值，涉及NULL的比较结果可能为UNKNOWN。
对于排除关联记录的需求，通常可以考虑使用NOT EXISTS：
SELECT *
FROM employee e
WHERE NOT EXISTS (
SELECT 1
FROM department d
WHERE d.department_id = e.department_id
);这种方式通常更容易准确表达“没有对应记录”的业务含义。
七、多层嵌套查询中的相关子查询
相关子查询与普通子查询最大的区别，是内层查询引用了外层查询的数据。
例如查询工资高于所在部门平均工资的员工：
SELECT e.employee_id,
e.employee_name,
e.department_id,
e.salary
FROM employee e
WHERE e.salary > (
SELECT AVG(e2.salary)
FROM employee e2
WHERE e2.department_id = e.department_id
);这里：
e.department_id来自外层查询。
而：
e2.department_id = e.department_id建立了内外层查询之间的关联。
这种写法非常适合解决“每条记录与自己所属分组进行比较”的问题，例如：
工资高于部门平均值
销售额高于所在区域平均值
成绩高于班级平均分
价格高于同类商品平均价格
但相关子查询也可能带来较高的执行成本，尤其是在外层数据量很大的情况下。因此，当性能出现问题时，可以考虑改写为JOIN或窗口函数。
八、使用JOIN替代重复嵌套
如果多个子查询实际上是在进行表之间的关联，可以考虑使用JOIN简化SQL。
例如：
SELECT e.*
FROM employee e
WHERE e.department_id IN (
SELECT d.department_id
FROM department d
WHERE d.company_id IN (
SELECT c.company_id
FROM company c
WHERE c.company_name = '总部'
)
);可以改写为：
SELECT e.*
FROM employee e
JOIN department d
ON e.department_id = d.department_id
JOIN company c
ON d.company_id = c.company_id
WHERE c.company_name = '总部';JOIN版本通常具有更清晰的数据关系。
对于涉及多个表的关联查询，尤其是需要同时获取关联表字段时，JOIN往往比多层IN嵌套更加容易维护。
九、使用CTE降低复杂SQL的嵌套层级
对于复杂业务，可以使用公共表表达式，也就是CTE。
例如：
WITH target_company AS (
SELECT company_id
FROM company
WHERE company_name = '总部'
),
target_department AS (
SELECT department_id
FROM department
WHERE company_id IN (
SELECT company_id
FROM target_company
)
)
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM target_department
);这种方式将复杂逻辑拆成多个有名称的查询步骤。
如果数据库支持CTE，还可以进一步进行组合：
WITH target_company AS (
SELECT company_id
FROM company
WHERE company_name = '总部'
),
target_department AS (
SELECT d.department_id
FROM department d
JOIN target_company c
ON d.company_id = c.company_id
)
SELECT e.*
FROM employee e
JOIN target_department d
ON e.department_id = d.department_id;相比把所有条件塞进WHERE中的多层括号，CTE通常更容易阅读和调试。
十、使用窗口函数减少相关子查询
对于“与组内统计值进行比较”的场景，窗口函数通常是非常值得考虑的方案。
例如原始查询：
SELECT e.*
FROM employee e
WHERE e.salary > (
SELECT AVG(e2.salary)
FROM employee e2
WHERE e2.department_id = e.department_id
);可以使用窗口函数：
SELECT *
FROM (
SELECT e.*,
AVG(salary) OVER (
PARTITION BY department_id
) AS avg_salary
FROM employee e
) t
WHERE salary > avg_salary;这样可以直接计算每个部门的平均工资，再进行筛选。
对于排名、累计统计、分组平均值、分组最大值等需求，窗口函数往往比多层相关子查询更加适合。
十一、优化WHERE多层嵌套查询的索引
SQL优化不能只关注语法结构，还需要考虑索引。
例如：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id = 10
);可以重点考虑以下字段的索引：
department.company_id
department.department_id
employee.department_id如果经常根据公司查询部门，再根据部门查询员工，这些关联字段能够帮助数据库更快定位数据。
对于以下查询：
SELECT *
FROM employee
WHERE status = 1
AND department_id IN (
SELECT department_id
FROM department
WHERE company_id = 10
);还应该根据数据分布、查询频率以及数据库优化器的实际执行计划评估是否需要建立组合索引。
索引不是越多越好。过多索引会增加INSERT、UPDATE和DELETE操作的维护成本，因此应该根据实际SQL进行针对性设计。
十二、避免在WHERE条件中进行无意义的计算
以下写法可能影响索引使用：
WHERE YEAR(create_time) = 2026如果create_time存在索引，可以考虑改写为范围条件：
WHERE create_time >= '2026-01-01'
AND create_time < '2027-01-01'同样，对于多层嵌套查询，也应该尽量让过滤条件尽早生效。
例如：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id IN (
SELECT company_id
FROM company
WHERE status = 1
)
);如果业务允许，可以尽早利用status、状态类型、时间范围等条件减少参与后续运算的数据量。
十三、避免不必要的SELECT *
多层查询中，如果子查询只是为了判断条件，没有必要返回大量字段。
例如：
WHERE EXISTS (
SELECT *
FROM order_detail od
WHERE od.order_id = o.order_id
)可以写成：
WHERE EXISTS (
SELECT 1
FROM order_detail od
WHERE od.order_id = o.order_id
)对于EXISTS来说，数据库只需要判断是否存在符合条件的记录，SELECT 1可以更加明确地表达这一意图。
外层查询同样建议根据业务需要明确指定字段：
SELECT employee_id, employee_name, salary
FROM employee
WHERE ...而不是在生产业务代码中长期使用：
SELECT *
FROM employee
WHERE ...这样可以减少不必要的数据传输，也能降低表结构变化带来的影响。
十四、使用执行计划判断嵌套查询性能
当多层嵌套查询出现性能问题时，不应该只依靠SQL表面结构判断。
应该结合数据库提供的执行计划工具进行分析，例如：
EXPLAIN
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id = 10
);重点观察：
是否进行了全表扫描
是否正确使用索引
JOIN方式是否合理
实际扫描行数是否过大
子查询是否被重复执行
是否存在临时表
是否发生排序或额外的数据聚合
估算行数与实际行数是否存在明显偏差
对于MySQL、PostgreSQL、SQL Server、Oracle等不同数据库，执行计划的显示方式和优化器行为存在差异，因此应该结合具体数据库进行分析。
十五、多层嵌套查询的常见错误
1. 子查询返回多行却使用等号
错误示例：
WHERE department_id = (
SELECT department_id
FROM department
WHERE company_id = 10
);如果company_id=10对应多个部门，就可能出现子查询返回多行的问题。
可以改为：
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id = 10
);2. 子查询字段与外层字段混淆
复杂嵌套中最好使用表别名：
SELECT e.*
FROM employee e
WHERE EXISTS (
SELECT 1
FROM department d
WHERE d.department_id = e.department_id
);这样可以明显降低字段歧义。
3. 嵌套层数过多
如果SQL已经出现五层、六层甚至更多层嵌套，就应该重新审视查询设计。
可以考虑：
多层IN
↓
JOIN
重复子查询
↓
CTE
相关子查询
↓
窗口函数
复杂业务逻辑
↓
拆分查询或调整数据模型并不是所有嵌套都需要改写，但过度嵌套通常意味着SQL已经承担了过多职责。
十六、WHERE嵌套查询的实用优化原则
实际项目中，可以按照以下思路优化复杂SQL。
首先，确认每一个子查询到底解决什么问题。不要为了“把条件写进去”而不断增加SELECT。
其次，判断子查询返回的是单个值、多个值还是存在性结果，并分别选择：
单个值 → =、>、< 等
多个值 → IN
是否存在 → EXISTS
是否不存在 → NOT EXISTS再次，检查是否存在重复子查询。如果相同SELECT被多次复制，可以考虑JOIN、CTE或临时结果集。
然后检查索引情况。重点关注WHERE条件字段、JOIN关联字段以及高选择性过滤字段。
最后使用执行计划验证优化结果。SQL看起来更短，并不代表实际执行一定更快；同样，SQL写得更复杂，也不代表性能一定更差。
十七、一个完整的优化思路
假设最初的查询如下：
SELECT *
FROM employee
WHERE department_id IN (
SELECT department_id
FROM department
WHERE company_id IN (
SELECT company_id
FROM company
WHERE company_name = '总部'
)
)
AND salary > (
SELECT AVG(e2.salary)
FROM employee e2
WHERE e2.department_id = employee.department_id
);这条SQL虽然能够表达业务逻辑，但同时包含多层IN和相关子查询，维护成本较高。
可以考虑使用JOIN和窗口函数进行重构：
WITH employee_stat AS (
SELECT e.*,
AVG(e.salary) OVER (
PARTITION BY e.department_id
) AS avg_salary
FROM employee e
)
SELECT e.*
FROM employee_stat e
JOIN department d
ON e.department_id = d.department_id
JOIN company c
ON d.company_id = c.company_id
WHERE c.company_name = '总部'
AND e.salary > e.avg_salary;新的查询结构更加清晰：
employee
↓
计算部门平均工资
↓
JOIN department
↓
JOIN company
↓
筛选总部
↓