精通SQL HAVING子句：深入解析如何筛选分组数据
一旦你掌握了SQL的GROUP BY子句，你就可以执行很有用的聚合操作，比如按类别统计产品数量或按客户统计订单数量。但数据分析的真正乐趣才刚刚开始。你不可避免地会遇到这样的情况：希望基于这些聚合结果进行进一步筛选，提出像“谁是我们订单最多的顶级客户？”或“哪些热门类别的平均价格最高？”这样的问题。
解决这种“分组后筛选”问题的方案就是我们今天的主题：HAVING子句。当与GROUP BY一起使用时，HAVING能极大地提高数据分析的精度和深度。它正是你所需要的完美工具。
本文将从零开始，彻底讲解HAVING子句的作用和用法，重点关注它与WHERE子句的区别——这是许多SQL学习者容易混淆的地方。通过大量“复制-粘贴-运行”的示例（还附带一个在线SQL环境！），你将迎来“啊哈！”的顿悟时刻，并亲身体验它的工作原理，从而将你的数据聚合技能提升到一个新的水平！
准备工作：创建我们的示例订单数据
在深入理论之前，让我们先打下实践的基础。我们将使用一个模拟电子商务网站订单历史的orders表。它包含了客户ID、产品类别、价格和订单日期等实用数据。你可以复制下面的完整SQL语句，在自己的环境中运行，或者在稍后的“交互式演练场”部分使用它。
-- 如果表已存在，则删除（以便重复测试）
DROP TABLE IF EXISTS orders;
-- 创建 orders 表
CREATE TABLE orders (
order_id INTEGER PRIMARY KEY,
customer_id INTEGER NOT NULL,
product_category TEXT NOT NULL,
price INTEGER NOT NULL,
order_date DATE NOT NULL
);
-- 插入数据
INSERT INTO orders (order_id, customer_id, product_category, price, order_date) VALUES
(1, 101, 'PC外设', 15000, '2025-05-10'),
(2, 102, '书籍', 3200, '2025-05-11'),
(3, 101, 'PC外设', 250000, '2025-05-12'),
(4, 103, '家电', 88000, '2025-05-15'),
(5, 102, '书籍', 4500, '2025-05-20'),
(6, 101, '家电', 120000, '2025-06-01'),
(7, 104, 'PC外设', 8000, '2025-06-05'),
(8, 102, '服装', 7800, '2025-06-08'),
(9, 103, 'PC外设', 320000, '2025-06-10'),
(10, 105, '书籍', 2900, '2025-06-15'),
(11, 101, '书籍', 3500, '2025-06-20'),
(12, 103, '家电', 35000, '2025-06-22');
这些数据包含多次购买的客户（例如，客户ID 101, 102, 103）和被多个客户购买的类别（例如，PC外设, 书籍），非常适合用来观察GROUP BY和HAVING的行为。
核心概念：WHERE和HAVING的决定性区别
理解HAVING子句的最大关键是清楚地掌握它与WHERE子句的分工。虽然两者都用于“筛选”，但它们筛选的时机和对象完全不同。
让我们用一个餐厅厨房的比喻来说明这个区别。
SQL的执行顺序：一个餐厅的比喻
- 表连接 (FROM, JOIN): 首先，所有的食材（数据）都被收集到厨房里。
WHERE子句: 厨师登场。在开始烹饪之前，厨师会检查每一种食材，并丢弃那些不符合标准的，比如他会说：“今天的生鱼片不能用这条鱼。”GROUP BY子句: 厨师使用经过挑选的食材来制作各种菜肴（分组），例如沙拉、意大利面和主菜。HAVING子句: 美食评论家登场。当做好的菜肴（分组）摆在桌上后，评论家决定要品尝哪些，他会说：“我只品尝那些价格超过20美元的菜。”
正如这个比喻所示，最重要的两点是：
WHERE子句在数据被分组（烹饪）之前，筛选单个的记录（食材）。HAVING子句在数据被GROUP BY创建成分组（菜肴）之后，筛选整个分组。
因此，使用聚合函数（如COUNT()或SUM()）的条件只对分组有意义，所以它们只能用在HAVING子句中。你不能写像WHERE COUNT(*) > 10这样的语句。
实践：使用HAVING子句筛选聚合结果
现在，让我们通过实际代码来看看HAVING子句的威力。首先，我们使用GROUP BY来聚合“每个客户的订单数”。这将是我们应用HAVING子句之前的基础结果。
-- 首先，在不使用HAVING的情况下，统计每个客户的订单数
SELECT
customer_id,
COUNT(order_id) AS order_count
FROM
orders
GROUP BY
customer_id;结果:
customer_id | order_count
------------|-------------
101 | 4
102 | 3
103 | 3
104 | 1
105 | 1根据这个结果，假设我们想“只提取那些订单数大于等于3的顶级客户”。这时HAVING子句就派上用场了。我们对聚合结果`order_count`（也就是COUNT(order_id)）应用一个条件。
-- 【HAVING + COUNT】筛选订单数大于等于3的客户
SELECT
customer_id,
COUNT(order_id) AS order_count
FROM
orders
GROUP BY
customer_id
HAVING
COUNT(order_id) >= 3;结果:
customer_id | order_count
------------|-------------
101 | 4
102 | 3
103 | 3太棒了！只有订单数大于等于3的客户（HAVING COUNT(order_id) >= 3）被筛选了出来。这就是HAVING子句的基本用法。
高级示例：使用`SUM`和`AVG`设置条件
HAVING子句不仅限于COUNT。当然，它也可以与其他聚合函数如SUM（总和）和AVG（平均值）结合使用，这使得更复杂的数据分析成为可能。
【HAVING + SUM】筛选总销售额超过100,000的类别
为了找出“哪些类别对我们的收入贡献最大”，让我们计算每个类别的总销售额，然后只查看那些超过100,000的类别。
-- 【HAVING + SUM】筛选总销售额超过100,000的类别
SELECT
product_category,
SUM(price) AS total_sales
FROM
orders
GROUP BY
product_category
HAVING
SUM(price) > 100000;结果:
product_category | total_sales
------------------|-------------
PC外设 | 593000
家电 | 243000这个结果清楚地表明，“PC外设”和“家电”是主要的收入来源。
【HAVING + AVG】筛选平均价格超过50,000的类别
接下来，为了调查“哪些类别在销售高价商品”，让我们计算每个类别的平均价格，并只提取那些平均价格超过50,000的类别。
-- 【HAVING + AVG】筛选平均价格超过50,000的类别
SELECT
product_category,
AVG(price) AS average_price
FROM
orders
GROUP BY
product_category
HAVING
AVG(price) > 50000;结果:
product_category | average_price
------------------|---------------
PC外设 | 148250
家电 | 81000如你所见，我们可以从不同的角度评估类别，不仅是总销售额，还有平均价格。
终极组合：同时使用WHERE和HAVING
WHERE和HAVING不是对手，它们是合作伙伴，共同实现更复杂的筛选。在单个查询中同时使用这两者可以进行极其强大的分析。
我们的分析问题是：“只看2025年6月及以后的订单，哪些客户的总购买金额超过了100,000？”
如果我们分解这个需求，会发现有两个筛选步骤：
- 分组前筛选：将记录限制在2025年6月1日或之后的订单。→ 这是对单个记录的条件，所以是
WHERE子句的工作。 - 分组后筛选：将分组限制为那些聚合总购买金额大于100,000的客户。→ 这是对分组的条件，所以是
HAVING子句的工作。
相应的SQL如下：
-- 【WHERE + HAVING】筛选6月及以后总购买额超过10万的客户
SELECT
customer_id,
SUM(price) AS total_spent_in_june_onwards
FROM
orders
WHERE
order_date >= '2025-06-01'
GROUP BY
customer_id
HAVING
SUM(price) > 100000;结果:
customer_id | total_spent_in_june_onwards
------------|-----------------------------
101 | 123500
103 | 355000这个查询的处理流程与我们的餐厅比喻完全吻合：
- 首先，
WHERE order_date >= '2025-06-01'只选择了6月及以后的订单记录。 - 接着，这些选定的记录通过
GROUP BY customer_id按客户进行分组。 - 最后，
HAVING SUM(price) > 100000筛选这些分组，只保留那些总购买金额超过100,000的分组。
WHERE和HAVING之间的这种协作可以说是SQL在数据分析中最闪耀的亮点。
【交互式演练场】SQL Fiddle：在浏览器中尝试HAVING子句！
现在是时候把知识变成扎实的技能了！通过下面的“在线SQL环境”，你可以直接在浏览器中自由地实验SQL。本文中的orders表已经为你加载好了。
试试不同的条件吧。仅仅是改变数字，或者把>=换成<，就能让你看到结果如何变化，这将极大地加深你的理解。
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>SQL HAVING子句 在线演练场</title>
<style>
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; line-height: 1.7; color: #333; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
h1 { color: #2c3e50; }
textarea { width: 100%; height: 200px; font-family: "SF Mono", "Consolas", monospace; font-size: 16px; padding: 12px; border: 1px solid #ccc; border-radius: 6px; box-sizing: border-box; margin-bottom: 1rem; }
button { background-color: #8e44ad; color: white; border: none; padding: 12px 22px; font-size: 16px; border-radius: 6px; cursor: pointer; transition: background-color 0.2s; }
button:hover { background-color: #70368b; }
button:disabled { background-color: #bdc3c7; cursor: not-allowed; }
#result-container { margin-top: 2rem; border: 1px solid #ddd; padding: 1rem; border-radius: 6px; background: #fdfdfd; min-height: 50px; overflow-x: auto;}
#error-message { color: #e74c3c; font-weight: bold; }
table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
th, td { border: 1px solid #ddd; padding: 10px; text-align: left; white-space: nowrap; }
th { background-color: #f2f2f2; }
tr:nth-child(even) { background-color: #f9f9f9; }
</style>
<script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>
<h1>试一试SQL！</h1>
<p>在下面的文本框中输入你的SQL查询，然后点击“执行”按钮。请随意尝试文章中所有不同的查询！</p>
<textarea id="sql-input">-- 请随意实验!
-- 示例：筛选'PC外设'类别(WHERE)，
-- 然后计算每个客户的总支出(GROUP BY)，
-- 最后只显示支出超过200,000的客户(HAVING)。
SELECT
customer_id,
SUM(price) AS total_spent_on_pc
FROM
orders
WHERE
product_category = 'PC外设'
GROUP BY
customer_id
HAVING
SUM(price) > 200000;</textarea>
<button id="execute-btn">执行</button>
<div id="result-container">
<p id="error-message"></p>
<div id="result-output"></div>
</div>
<script>
const sqlInput = document.getElementById('sql-input');
const executeBtn = document.getElementById('execute-btn');
const errorMsg = document.getElementById('error-message');
const resultOutput = document.getElementById('result-output');
let db;
async function initDb() {
executeBtn.disabled = true;
executeBtn.textContent = '数据库初始化中...';
try {
const SQL = await initSqlJs({
locateFile: file => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${file}`
});
db = new SQL.Database();
const setupSql = `
DROP TABLE IF EXISTS orders;
CREATE TABLE orders (
order_id INTEGER PRIMARY KEY,
customer_id INTEGER NOT NULL,
product_category TEXT NOT NULL,
price INTEGER NOT NULL,
order_date DATE NOT NULL
);
INSERT INTO orders (order_id, customer_id, product_category, price, order_date) VALUES
(1, 101, 'PC外设', 15000, '2025-05-10'), (2, 102, '书籍', 3200, '2025-05-11'),
(3, 101, 'PC外设', 250000, '2025-05-12'), (4, 103, '家电', 88000, '2025-05-15'),
(5, 102, '书籍', 4500, '2025-05-20'), (6, 101, '家电', 120000, '2025-06-01'),
(7, 104, 'PC外设', 8000, '2025-06-05'), (8, 102, '服装', 7800, '2025-06-08'),
(9, 103, 'PC外设', 320000, '2025-06-10'), (10, 105, '书籍', 2900, '2025-06-15'),
(11, 101, '书籍', 3500, '2025-06-20'), (12, 103, '家电', 35000, '2025-06-22');
`;
db.run(setupSql);
executeBtn.disabled = false;
executeBtn.textContent = '执行';
resultOutput.innerHTML = '<p>准备就绪！请随意尝试您自己的SQL查询。</p>';
} catch (err) {
errorMsg.textContent = '数据库初始化失败: ' + err.message;
console.error(err);
}
}
function executeSql() {
if (!db) return;
const sql = sqlInput.value;
errorMsg.textContent = '';
resultOutput.innerHTML = '';
try {
const results = db.exec(sql);
if (results.length === 0) {
resultOutput.innerHTML = '<p>查询成功执行，但没有返回结果集（例如，用于INSERT, UPDATE等）。</p>';
return;
}
results.forEach(result => {
const table = document.createElement('table');
const thead = document.createElement('thead');
const tbody = document.createElement('tbody');
const headerRow = document.createElement('tr');
result.columns.forEach(colName => {
const th = document.createElement('th');
th.textContent = colName;
headerRow.appendChild(th);
});
thead.appendChild(headerRow);
result.values.forEach(row => {
const bodyRow = document.createElement('tr');
row.forEach(cellValue => {
const td = document.createElement('td');
td.textContent = cellValue === null ? 'NULL' : (typeof cellValue === 'number' ? cellValue.toLocaleString() : cellValue);
bodyRow.appendChild(td);
});
tbody.appendChild(bodyRow);
});
table.appendChild(thead);
table.appendChild(tbody);
resultOutput.appendChild(table);
});
} catch (err) {
errorMsg.textContent = 'SQL错误: ' + err.message;
console.error(err);
}
}
executeBtn.addEventListener('click', executeSql);
initDb();
</script>
</body>
</html>SQL引擎的内部工作：查询的逻辑执行顺序
为了进一步加深你对WHERE和HAVING之间区别的理解，了解SQL内部如何处理查询的“逻辑处理顺序”非常有帮助。我们编写代码的顺序（SELECT, FROM, WHERE...）与SQL解释和执行它的顺序是不同的。
SQL的逻辑执行顺序:
FROM: 首先，确定从哪个表中检索数据。WHERE: 接着，根据条件筛选单个行。GROUP BY: 将筛选后的行捆绑成分组。HAVING: 根据条件筛选分组后的结果。SELECT: 最后，决定要显示哪些列。ORDER BY: 按指定顺序对结果集进行排序。LIMIT: 限制要显示的行数。
查看这个顺序，你可以清楚地看到WHERE在GROUP BY之前，而HAVING紧随其后。这就是为什么聚合函数不能在WHERE中使用，但可以在HAVING中使用的核心原因。
这个顺序也解释了为什么你通常不能在WHERE或HAVING子句中使用在SELECT子句中定义的别名（例如，SUM(price) AS total_sales）（某些数据库除外）。这是因为SELECT子句是在之后才被求值的。（你通常可以在ORDER BY子句中使用别名，因为ORDER BY是在SELECT之后被求值的。）
总结：精通HAVING子句，让你的数据分析更上一层楼
在这次深入探讨中，我们探索了强大的HAVING子句，一个用于筛选GROUP BY聚合结果的工具。
让我们最后再回顾一下关键点：
HAVING的作用: 为由GROUP BY创建的分组指定条件并进行筛选。- 与
WHERE的区别:WHERE在分组前筛选单个行。它们在处理过程中的时机完全不同。 - 与聚合函数的关系: 只有
HAVING子句可以在其条件中使用像COUNT(),SUM(), 和AVG()这样的聚合函数。 - 终极组合: 使用
WHERE筛选原始数据，使用GROUP BY进行聚合，然后使用HAVING筛选这些聚合结果，这种协作方式非常强大。
乍一看，HAVING子句可能像是一个次要的功能。然而，你能否掌握它，将对你能从数据中提取的洞察的质量和深度产生天壤之别。它使你能够用SQL回答更尖锐、更具商业价值的问题，例如，“在我们最畅销的类别中，哪些是利润最高的？”或“在我们的活跃用户群中，高消费用户的画像是怎样的？”
请尽情地在本文的在线演练场中玩耍，并熟悉HAVING子句。我保证，你作为一名Web开发者的数据库利用能力将得到长足的进步。