如何避免 Nested Query

“Nested Query（嵌套查询 / 子查询）”本身不总是坏事，但在很多场景下（尤其是数据库查询、ORM 使用、API 设计、前端组件结构）过度或不当的嵌套会导致性能差、可读性低、维护困难。下面从数据库 SQL、ORM（如 Hibernate/MyBatis）、代码 / API 设计三个层面讲如何“避免或减少”嵌套查询。

一、SQL 中避免 Nested Query 的常见方法

1. 用 JOIN 替代子查询

不推荐（嵌套）

SELECT *
FROM orders
WHERE user_id IN (
  SELECT id FROM users WHERE age > 30
);

推荐（JOIN）

SELECT o.*
FROM orders o
JOIN users u ON o.user_id = u.id
WHERE u.age > 30;

✅ 优点：

• 执行计划更优
• 数据库更容易优化
• 可读性更好

2. 用 EXISTS 替代 IN + 子查询（大表场景）

SELECT *
FROM orders o
WHERE EXISTS (
  SELECT 1 FROM users u
  WHERE u.id = o.user_id AND u.age > 30
);

比 IN (子查询) 在大数据量下通常更稳定。

3. 用派生表 / CTE（公共表表达式）

如果必须用“中间结果”，优先用 CTE 而不是层层嵌套：

WITH active_users AS (
  SELECT id FROM users WHERE status = 'ACTIVE'
)
SELECT * FROM orders
WHERE user_id IN (SELECT id FROM active_users);

或：

WITH active_users AS (
  SELECT id FROM users WHERE status = 'ACTIVE'
)
SELECT o.*
FROM orders o
JOIN active_users a ON o.user_id = a.id;

4. 预聚合（减少运行时嵌套）

把复杂子查询变成：

• 视图（View）
• 物化视图（Materialized View）
• 汇总表（Summary Table）

二、ORM 中避免 Nested Query

1. 避免循环中的“隐式子查询”

❌ 错误示例（N + 1 问题）：

for (User user : users) {
    List<Order> orders = orderRepository.findByUserId(user.getId());
}

✅ 正确方式：

Map<Long, List<Order>> ordersMap =
    orderRepository.findByUserIdIn(userIds)
                  .stream()
                  .collect(groupingBy(Order::getUserId));

2. 使用 JOIN FETCH（Hibernate）

@Query("SELECT u FROM User u JOIN FETCH u.orders")
List<User> findAllWithOrders();

避免：

SELECT * FROM users;
-- 然后每条用户再查一次 orders

3. MyBatis 中用 ResultMap + 单条 SQL

而不是：

<select id="getUser">
  SELECT * FROM user WHERE id = #{id}
</select>
<!-- 再嵌套查 orders -->

而是一次性 JOIN + ResultMap。

三、代码 / API 层面的“嵌套查询”思维

1. 避免“逻辑嵌套”

❌

if (user != null) {
    if (user.isActive()) {
        if (user.getRole() != null) {
            ...
        }
    }
}

✅

if (user == null || !user.isActive()) return;
if (user.getRole() == null) return;

2. API 设计避免“嵌套请求”

❌

GET /users/{id}/orders/{orderId}/items

✅

GET /orders?userId=xxx
GET /order-items?orderId=xxx

四、什么时候“不必避免”嵌套查询？

✅ 可以保留的情况：

• 子查询返回极小结果集
• 逻辑非常清晰
• 数据库优化器能很好处理
• 临时分析 SQL，不追求性能

总结一句话

能用 JOIN 就别用子查询，能一次查就别多次查，能扁平就别嵌套。

如果你有具体场景（比如 MySQL / PostgreSQL / Hibernate / MyBatis / 前端组件），可以贴代码，我可以帮你具体改造。