SQL HAVING 子句用法指南 – wiki基地

---

SQL HAVING 子句用法深度指南：过滤分组数据的利器

在 SQL 查询中，WHERE 子句是我们最熟悉的用于过滤数据的工具。它允许我们根据指定的条件筛选出满足条件的单个行。然而，在许多实际应用场景中，我们不仅需要过滤单个行，还需要对分组后的数据进行过滤，例如找出销量总额超过某个阈值的商品类别，或者找到客户数量超过某个数值的地区。这时，WHERE 子句就显得力不尽用了，因为它是在数据分组和聚合之前执行的。

SQL 提供了一个专门用于解决这类问题的子句：HAVING。HAVING 子句紧随 GROUP BY 子句之后，用于对由 GROUP BY 分组后的结果集进行过滤，其过滤条件通常涉及聚合函数（如 COUNT(), SUM(), AVG(), MIN(), MAX()）的结果。

本文将详细探讨 HAVING 子句的用法、它与 WHERE 子句的关键区别、常见应用场景、以及在使用时需要注意的细节和潜在问题。

1. 理解 SQL 查询的处理顺序：为何需要 HAVING？

要真正理解 HAVING 子句的必要性，首先需要了解 SQL 查询语句（尤其是包含 GROUP BY 和聚合函数的查询）在数据库系统中的大致处理顺序。一个典型的 SQL 查询语句包含多个子句，它们的执行顺序通常如下：

1. FROM 子句： 确定要从哪些表中检索数据。
2. JOIN 子句： 根据指定的连接条件将多个表连接起来，形成一个中间结果集。
3. WHERE 子句： 对 FROM 和 JOIN 生成的中间结果集的每一行进行过滤，只保留满足指定条件的行。这是行级过滤。
4. GROUP BY 子句： 将 WHERE 子句过滤后的结果集按照一个或多个列的值进行分组。相同列值（或列值组合）的行被归入同一个组。
5. 聚合函数 (COUNT(), SUM(), AVG(), etc.)： 在每个分组内执行聚合计算，为每个组生成一个汇总值。
6. HAVING 子句： 对 GROUP BY 分组后形成的每个分组进行过滤，只保留满足指定条件的组。其条件通常基于步骤 5 中聚合函数的结果。这是分组级过滤。
7. SELECT 子句： 确定最终结果集中要包含哪些列。通常包括 GROUP BY 列和聚合函数的结果。在这一步，可以使用列别名（如 AS 关键字）。
8. DISTINCT 子句： 如果指定，从 SELECT 子句的结果中移除重复的行。
9. ORDER BY 子句： 对最终的结果集进行排序。
10. LIMIT / TOP 子句： 限制返回的行数。

从这个顺序可以看出，WHERE 子句在 GROUP BY 和聚合函数之前执行。这意味着 WHERE 子句不能直接引用聚合函数的结果，因为它在执行时聚合结果还未计算出来。

而 HAVING 子句则在 GROUP BY 和聚合函数之后执行。它能够访问每个分组的聚合结果，因此可以用于对这些分组进行过滤。

简而言之：

• WHERE 过滤单个行，在分组/聚合之前。
• HAVING 过滤分组，在分组/聚合之后，且通常基于聚合结果。

2. HAVING 子句的基本语法

HAVING 子句的语法非常直观，它总是紧随 GROUP BY 子句之后：

sql
SELECT column1, column2, ..., aggregate_function(column)
FROM table_name
WHERE condition -- (可选) 行级过滤
GROUP BY column1, column2, ...
HAVING group_condition -- (可选) 分组级过滤
ORDER BY column -- (可选)

其中：
* aggregate_function(column) 是你要计算的聚合函数，例如 COUNT(*), SUM(Amount), AVG(Price) 等。
* GROUP BY column1, column2, ... 指定了用于分组的列。
* group_condition 是用于过滤分组的条件。这个条件可以包含聚合函数的结果、GROUP BY 列的值，以及常量。

重要规则：

1. HAVING 子句必须与 GROUP BY 子句一起使用（除非是针对整个结果集的聚合，但这种情况很少见且通常可以通过其他方式处理）。
2. HAVING 子句中的条件可以引用 GROUP BY 子句中指定的列。
3. HAVING 子句中的条件可以引用在 SELECT 列表中使用的聚合函数的结果。
4. HAVING 子句不能引用在 SELECT 列表中但未出现在 GROUP BY 子句中的非聚合列（因为在分组级别，这些列可能有多个不同的值）。

3. HAVING vs. WHERE：核心区别与示例

这是理解 HAVING 的关键。我们通过几个具体的例子来对比 WHERE 和 HAVING 的用法。

假设我们有一个 Orders 表，包含以下列：
* OrderID (订单 ID)
* CustomerID (客户 ID)
* OrderAmount (订单金额)
* OrderDate (订单日期)

示例 1：过滤单个行 vs. 过滤分组

需求 A： 找出所有订单金额大于 100 的订单。
这个需求是过滤单个行，应该使用 WHERE。

sql
SELECT OrderID, CustomerID, OrderAmount
FROM Orders
WHERE OrderAmount > 100;
WHERE 子句直接作用于 Orders 表中的每一行，检查 OrderAmount 是否大于 100。

需求 B： 找出总订单金额大于 5000 的客户。
这个需求是过滤分组（按客户 ID 分组），条件是每个分组的聚合结果（总订单金额）。这需要先按 CustomerID 分组，计算每个客户的 SUM(OrderAmount)，然后过滤出总金额大于 5000 的客户。这必须使用 HAVING。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
HAVING SUM(OrderAmount) > 5000;
这里，我们首先 GROUP BY CustomerID 将订单按客户分组。然后 SUM(OrderAmount) 计算每个客户的总订单金额。最后，HAVING SUM(OrderAmount) > 5000 对这些分组进行过滤，只保留总金额超过 5000 的分组（即客户）。

尝试使用 WHERE 来解决需求 B 是错误的：
sql
-- 错误用法！
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
WHERE SUM(OrderAmount) > 5000 -- WHERE 不能直接使用聚合函数！
GROUP BY CustomerID;
这条 SQL 语句会报错，因为 WHERE 子句在 SUM() 聚合函数执行之前就被评估。

示例 2：组合 WHERE 和 HAVING

假设需求更复杂：找出在 2023 年下达的订单中，总订单金额大于 1000 的客户。

这里既有行级过滤（订单必须是 2023 年的），也有分组级过滤（客户的总订单金额大于 1000）。我们可以同时使用 WHERE 和 HAVING。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
WHERE OrderDate >= '2023-01-01' AND OrderDate < '2024-01-01' -- 行级过滤：只考虑 2023 年的订单
GROUP BY CustomerID
HAVING SUM(OrderAmount) > 1000; -- 分组级过滤：只保留总金额 > 1000 的客户
执行顺序：
1. FROM Orders: 选择 Orders 表。
2. WHERE OrderDate >= '2023-01-01' AND OrderDate < '2024-01-01': 先过滤掉所有非 2023 年的订单。这张经过 WHERE 过滤的临时表会变小。
3. GROUP BY CustomerID: 对经过 WHERE 过滤后的剩余行按 CustomerID 分组。
4. SUM(OrderAmount): 计算每个分组（每个客户）的总订单金额。
5. HAVING SUM(OrderAmount) > 1000: 过滤这些分组，只保留总金额大于 1000 的客户分组。
6. SELECT CustomerID, SUM(OrderAmount) AS TotalAmount: 选择最终结果中要显示的列。

这个例子清楚地展示了 WHERE 和 HAVING 各司其职：WHERE 减少了待处理的行数（提高了效率，因为它发生在分组前），而 HAVING 过滤了最终的分组结果。

示例 3：基于非聚合列在 HAVING 中过滤

虽然 HAVING 主要用于过滤基于聚合结果的分组，但它也可以包含基于 GROUP BY 列的条件。

例如：找出总订单金额大于 1000 的客户，但只关心客户 ID 大于 100 的客户。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
HAVING CustomerID > 100 AND SUM(OrderAmount) > 1000;
这里，HAVING 子句同时使用了 GROUP BY 列 CustomerID 和聚合结果 SUM(OrderAmount) 进行过滤。

注意： 理论上，任何可以在 WHERE 子句中用于行级过滤的条件，如果涉及的列也在 GROUP BY 子句中，那么也可以放在 HAVING 子句中。然而，出于效率考虑，强烈建议将任何可以作为行级过滤的条件放在 WHERE 子句中，而不是 HAVING 子句中。将条件放在 WHERE 中可以在分组和聚合之前减少处理的数据量，从而提高查询性能。

将上面的例子改写成更推荐的形式：

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
WHERE CustomerID > 100 -- 优先在 WHERE 中过滤行
GROUP BY CustomerID
HAVING SUM(OrderAmount) > 1000; -- 只在 HAVING 中过滤分组
这个版本的查询通常效率更高，因为它在开始分组和聚合之前就排除了 CustomerID <= 100 的行。

4. HAVING 子句与聚合函数的结合应用

HAVING 子句最常见的用途就是结合聚合函数来过滤分组。它可以与所有的标准 SQL 聚合函数一起使用：

• COUNT(): 计数
• SUM(): 求和
• AVG(): 求平均值
• MIN(): 求最小值
• MAX(): 求最大值

下面是一些结合不同聚合函数的 HAVING 用法示例。

假设我们有一个 Products 表，包含 ProductID, CategoryID, Price, StockQuantity。

示例 4：使用 COUNT() 过滤分组

需求： 找出产品数量超过 50 个的类别。

sql
SELECT CategoryID, COUNT(ProductID) AS ProductCount
FROM Products
GROUP BY CategoryID
HAVING COUNT(ProductID) > 50;
这里 COUNT(ProductID) 计算每个类别中的产品数量，HAVING COUNT(ProductID) > 50 过滤掉产品数量少于或等于 50 的类别。

示例 5：使用 SUM() 过滤分组

需求： 找出库存总数量超过 1000 的类别。

sql
SELECT CategoryID, SUM(StockQuantity) AS TotalStock
FROM Products
GROUP BY CategoryID
HAVING SUM(StockQuantity) > 1000;
SUM(StockQuantity) 计算每个类别的总库存量，HAVING SUM(StockQuantity) > 1000 过滤掉总库存量不满足条件的类别。

示例 6：使用 AVG() 过滤分组

需求： 找出平均价格低于 100 的类别。

sql
SELECT CategoryID, AVG(Price) AS AveragePrice
FROM Products
GROUP BY CategoryID
HAVING AVG(Price) < 100;
AVG(Price) 计算每个类别的平均价格，HAVING AVG(Price) < 100 过滤掉平均价格大于或等于 100 的类别。

示例 7：使用 MIN() 和 MAX() 过滤分组

需求： 找出最高价格超过 500 且最低价格低于 50 的类别。

sql
SELECT CategoryID, MIN(Price) AS MinPrice, MAX(Price) AS MaxPrice
FROM Products
GROUP BY CategoryID
HAVING MAX(Price) > 500 AND MIN(Price) < 50;
这个示例展示了如何在 HAVING 子句中使用多个条件，这些条件可以是基于不同的聚合函数。

5. HAVING 子句中的复杂条件

HAVING 子句中的条件可以像 WHERE 子句一样复杂，可以使用逻辑运算符 (AND, OR, NOT)、比较运算符 (=, !=, >, <, >=, <=)、IN, BETWEEN, LIKE 等，只要这些条件能够基于 GROUP BY 列或聚合函数的结果来评估。

示例 8：使用 AND 和 OR 组合条件

需求： 找出总订单金额超过 10000 或者 订单数量超过 100 个的客户。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount, COUNT(OrderID) AS OrderCount
FROM Orders
GROUP BY CustomerID
HAVING SUM(OrderAmount) > 10000 OR COUNT(OrderID) > 100;

需求： 找出总订单金额在 5000 到 20000 之间（包含边界）的客户。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
HAVING SUM(OrderAmount) BETWEEN 5000 AND 20000; -- 或者使用 SUM(OrderAmount) >= 5000 AND SUM(OrderAmount) <= 20000

6. HAVING 子句与别名（Alias）的使用

在某些 SQL 实现中（并非所有），你可以在 HAVING 子句中直接使用 SELECT 列表中为聚合函数定义的别名。这可以使查询更具可读性。

例如，之前的示例 2：找出总订单金额大于 1000 的客户（假设只考虑 2023 年订单）。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount -- 定义别名 TotalAmount
FROM Orders
WHERE OrderDate >= '2023-01-01' AND OrderDate < '2024-01-01'
GROUP BY CustomerID
HAVING TotalAmount > 1000; -- 在 HAVING 中使用别名 (并非所有数据库都支持)
注意： 这是一个非标准的 SQL 特性，虽然在 MySQL, PostgreSQL 等许多数据库中被支持，但在 SQL Server 或 Oracle 的某些版本中可能不支持在 HAVING 中直接使用 SELECT 列表中的聚合函数别名。为了保证 SQL 语句的可移植性和符合标准，通常更推荐在 HAVING 子句中重复写出聚合表达式：

sql
-- 更具可移植性的写法
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
WHERE OrderDate >= '2023-01-01' AND OrderDate < '2024-01-01'
GROUP BY CustomerID
HAVING SUM(OrderAmount) > 1000; -- 重复聚合表达式
虽然重复写聚合表达式看起来不够简洁，但它是更标准的做法。如果你确定你的数据库系统支持在 HAVING 中使用别名，那么为了可读性可以使用别名。

7. HAVING 子句中的非聚合列：限制与最佳实践

前面提到，HAVING 子句可以引用 GROUP BY 子句中指定的列。

例如：找出总订单金额大于 1000 的客户，但只包括来自 ‘New York’ 州的客户。

假设 Orders 表连接到一个 Customers 表，Customers 表有 CustomerID 和 State 列。

sql
SELECT c.CustomerID, c.State, SUM(o.OrderAmount) AS TotalAmount
FROM Customers c
JOIN Orders o ON c.CustomerID = o.CustomerID
WHERE c.State = 'New York' -- 行级过滤：只考虑来自纽约的客户的订单
GROUP BY c.CustomerID, c.State -- 分组时包含 State
HAVING SUM(o.OrderAmount) > 1000; -- 分组级过滤：总金额大于 1000
在这个例子中，State 列被包含在 GROUP BY 子句中，因此它可以在 SELECT 列表和 HAVING 子句中被引用。

重要： 你不能在 HAVING 子句中引用一个既不在 GROUP BY 子句中，也不是聚合函数参数的列。这是因为 HAVING 是在分组级别操作的，对于一个给定的分组，一个非分组非聚合列可能有多个不同的值，数据库无法确定使用哪个值来评估条件。

例如，假设 Orders 表还有一个 ShippingCity 列。尝试这样做是错误的：

sql
-- 错误用法！ ShippingCity 既不在 GROUP BY 中，也不是聚合函数参数
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
HAVING SUM(OrderAmount) > 1000 AND ShippingCity = 'Los Angeles';
原因在于，一个客户（一个 CustomerID 分组）可能有多笔订单，这些订单可能发往不同的 ShippingCity。在评估 HAVING 条件时，数据库不知道应该用哪个 ShippingCity 的值来判断。

最佳实践： 如果你需要在 HAVING 子句中基于某个列进行过滤，这个列必须包含在 GROUP BY 子句中。或者，如果条件可以作为行级过滤，优先放在 WHERE 子句中。

8. 使用 HAVING 进行更复杂的分析

HAVING 子句结合子查询（Subquery）或公共表表达式（CTE – Common Table Expression）可以实现更复杂的过滤逻辑。

示例 9：结合子查询

需求： 找出那些客户总订单金额大于所有客户平均总订单金额的客户。

第一步：计算所有客户的平均总订单金额。这需要一个子查询或 CTE。
第二步：找出每个客户的总订单金额。
第三步：使用 HAVING 过滤出总订单金额大于第一步计算出的平均值的客户。

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
HAVING SUM(OrderAmount) > (SELECT AVG(TotalCustomerAmount)
FROM (SELECT SUM(OrderAmount) AS TotalCustomerAmount
FROM Orders
GROUP BY CustomerID) AS CustomerTotals);
这个查询有点复杂。内层子查询 (SELECT SUM(OrderAmount) AS TotalCustomerAmount FROM Orders GROUP BY CustomerID) 计算每个客户的总订单金额，并将其作为派生表 CustomerTotals。外层子查询 (SELECT AVG(TotalCustomerAmount) FROM CustomerTotals) 计算这些客户总金额的平均值。最后，主查询 HAVING SUM(OrderAmount) > ... 使用 HAVING 子句将每个客户自己的总金额与其进行比较。

示例 10：结合 CTE (通常更清晰)

使用 CTE 可以使上面的查询更易读：

sql
WITH CustomerTotals AS (
-- 计算每个客户的总订单金额
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
),
AvgCustomerTotal AS (
-- 计算所有客户总订单金额的平均值
SELECT AVG(TotalAmount) AS AvgTotalAmount
FROM CustomerTotals
)
-- 找出总订单金额大于平均值的客户
SELECT ct.CustomerID, ct.TotalAmount
FROM CustomerTotals ct
JOIN AvgCustomerTotal at ON ct.TotalAmount > at.AvgTotalAmount;
或者，如果数据库支持在 HAVING 子句中使用标量子查询（Scalar Subquery）：

sql
SELECT CustomerID, SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID
HAVING SUM(OrderAmount) > (SELECT AVG(TotalAmount) -- 标量子查询计算平均值
FROM (SELECT SUM(OrderAmount) AS TotalAmount
FROM Orders
GROUP BY CustomerID) AS CustomerTotals);
这两种方法都实现了相同的逻辑，但 CTE 版本通常被认为更易于理解和维护。这里的关键点在于 HAVING 子句能够与子查询或 CTE 返回的结果进行比较。

9. HAVING 子句的性能考虑

正如前面提到的，SQL 查询的执行顺序对性能有重要影响。WHERE 子句在分组和聚合之前执行，能够有效减少参与后续操作的行数。而 HAVING 子句在分组和聚合之后执行，它过滤的是分组，而不是原始行。

性能原则： 尽可能在 WHERE 子句中过滤掉不需要的行。只有当过滤条件必须基于聚合结果时，才使用 HAVING 子句。

• 如果一个条件可以同时放在 WHERE 和 HAVING 中（例如，基于 GROUP BY 列的条件），优先放在 WHERE 中。
• 如果条件涉及聚合函数，它必须放在 HAVING 中。

通过先在 WHERE 中减少行数，可以显著降低 GROUP BY 子句需要处理的数据量，以及聚合函数需要进行的计算量，从而提高整体查询性能。

10. 常见错误与排查

• 错误： 在 WHERE 子句中使用聚合函数。
  • 原因： WHERE 在聚合之前执行。
  • 解决： 将条件移到 HAVING 子句中。
• 错误： 在 HAVING 子句中使用非 GROUP BY 列且非聚合的列。
  • 原因： HAVING 在分组级别操作，无法确定非分组列的值。
  • 解决： 将该列添加到 GROUP BY 子句中（如果逻辑允许），或者尝试将过滤条件移到 WHERE 子句中（如果它适用于单行）。
• 错误： 在没有 GROUP BY 子句的情况下使用 HAVING。
  • 原因： HAVING 是为过滤分组而设计的，没有分组就无法使用。
  • 解决： 如果你需要对整个表进行聚合计算并在聚合结果上设置条件，一种方法是使用 GROUP BY null (某些数据库支持，表示整个表视为一个组) 或更常见的，将聚合和过滤逻辑组合在子查询/CTE中，然后在外部查询中过滤。不过，这种情况非常罕见，通常有更直接的方式，例如在一个子查询中计算聚合，然后在外部查询中用 WHERE 过滤子查询的结果。但最直接的用法还是与 GROUP BY 结合。
• 错误： 在 HAVING 子句中错误地使用聚合函数别名（在不支持别名的数据库中）。
  • 原因： 数据库不支持在 HAVING 中直接引用 SELECT 别名。
  • 解决： 在 HAVING 子句中重复写出完整的聚合函数表达式。

11. 总结

HAVING 子句是 SQL 中一个强大而重要的工具，它使我们能够对分组后的数据进行过滤，解决单靠 WHERE 子句无法完成的分析需求。

核心要点：

• HAVING 用于过滤分组，而 WHERE 用于过滤单个行。
• HAVING 在 GROUP BY 和聚合函数之后执行，因此可以引用聚合函数的结果。
• WHERE 在 GROUP BY 和聚合函数之前执行，不能直接引用聚合函数。
• HAVING 子句必须与 GROUP BY 子句一起使用（用于过滤分组）。
• HAVING 子句的条件通常基于聚合函数的结果，也可以基于 GROUP BY 列。
• 为了性能考虑，尽可能将行级过滤条件放在 WHERE 子句中。
• 理解 SQL 查询的处理顺序是掌握 HAVING 用法的关键。

通过熟练掌握 HAVING 子句，你可以编写出更灵活、更强大的 SQL 查询，对数据进行更深入的分析和洞察。在处理需要对汇总数据设置条件的场景时，记住 HAVING 子句是你不可或缺的工具。

---