sql中计算字段总和、平均值等聚合数据的核心是使用聚合函数，如sum()、avg()、count()、min()、max()等，它们对一组值进行计算并返回单个结果；2. 聚合函数通常与group by子句结合使用，以按指定列分组数据并在每组内进行独立计算，实现多维度分析；3. count()用于计数，其中count(*)统计所有行，count(列名)仅统计非null值，count(distinct 列名)可统计唯一值；4. sum()和avg()分别计算数值字段的总和与平均值，且自动忽略null值，适用于销售额、库存等数值型数据聚合；5. min()和max()可获取数值、日期或字符串类型的最小和最大值，适用于查找极值场景；6. group by通过指定列将数据分组，所有select中非聚合列必须出现在group by中，否则会导致逻辑错误；7. where在分组前过滤原始行，不能使用聚合函数，而having在分组后基于聚合结果过滤组，可引用聚合函数；8. 为提高性能，应优先使用where减少数据量，再用having进行组级别筛选；9. 聚合查询可与join结合，实现多表关联后的分组统计，如通过客户表与订单表联接计算每位客户的总消费；10. 子查询可用于复杂逻辑，如将聚合结果作为条件（例如筛选高于平均金额的订单），或作为派生表与其它表联接，提升查询灵活性。这些方法共同构成了sql中完整的聚合分析体系，能够满足从基础统计到复杂业务洞察的多样化需求。
SQL中计算字段的总和、平均值等聚合数据，核心在于使用聚合函数（Aggregate Functions），它们能对一组值执行计算，然后返回单个值。这通常结合
GROUP BY
子句来对数据进行分组，以便在每个分组内进行聚合计算。
解决方案
要计算SQL字段的总和、平均值等聚合数据，最直接的方法是利用内置的聚合函数。这些函数包括
SUM()
（求和）、
AVG()
（平均值）、
COUNT()
（计数）、
MIN()
（最小值）和
MAX()
（最大值）。
比如，你想计算一张名为
orders
的表里
amount
字段的总和：
SELECT SUM(amount) FROM orders;
如果想知道所有订单的平均金额：
SELECT AVG(amount) FROM orders;
想知道一共有多少条订单记录：
SELECT COUNT(*) FROM orders;
或者，如果只想计算
customer_id
不为空的订单数量：
SELECT COUNT(customer_id) FROM orders;
找出订单中的最小金额和最大金额：
SELECT MIN(amount), MAX(amount) FROM orders;
这些是最基础的用法，它们会对整个数据集进行聚合。但多数时候，我们希望按某个维度来分组计算，比如按客户计算每个客户的总消费。这时就需要
GROUP BY
子句了。
假设我们想计算每个
customer_id
的总消费：
SELECT customer_id, SUM(amount) AS total_spent FROM orders GROUP BY customer_id;
这个查询会先根据
customer_id
将订单分组，然后对每个分组内的
amount
求和。
SQL聚合函数家族：它们各自的本事是什么？
说起SQL里的聚合函数，它们就像是数据分析的瑞士军刀，每把刀都有其独特的用处。我个人觉得，理解它们的实际应用场景比死记硬背语法要重要得多。
COUNT()
：这个函数是用来计数的。
COUNT(*)
会统计所有行，包括那些包含
NULL
值的行。而
COUNT(column_name)
则只统计
column_name
字段值非
NULL
的行。有时我们需要统计不重复的值，比如有多少个不同的客户下了订单，这时
COUNT(DISTINCT customer_id)
就派上用场了。在我看来，
COUNT()
是最常用也最容易被误解的一个，尤其是
COUNT(*)
和
COUNT(column)
之间的细微差别，新手很容易搞混。
SUM()
：顾名思义，求和。它只适用于数值类型的数据。如果你试图对文本字段求和，数据库会报错，或者返回
NULL
，这很符合直觉。比如，计算某个销售区域的总销售额，或者某个产品类别的总库存量，
SUM()
都是不二之选。
AVG()
：计算平均值。同样只适用于数值类型。值得注意的是，
AVG()
在计算时会默认忽略
NULL
值。这意味着如果某个销售额记录是
NULL
，它不会被计入平均值，这和我们平时计算平均数的逻辑可能不太一样，需要注意。
MIN()
和
MAX()
：这两个函数分别用于找出数据集中的最小值和最大值。它们不仅可以用于数值类型，也可以用于日期时间类型（最早的日期、最晚的日期）和字符串类型（按字母顺序最小的字符串、最大的字符串）。这在查找最便宜的产品、最贵的订单、最早的注册日期或者按字母顺序排在最前的客户名时非常有用。
还有一些数据库特有的聚合函数，比如MySQL的
GROUP_CONCAT()
可以将一个分组内的字符串连接起来，PostgreSQL的
STRING_AGG()
也有类似功能，这些在生成报告或者列表时特别方便。这些“非主流”的聚合函数，虽然不那么通用，但在特定场景下能大大简化数据处理的逻辑。
怎么用GROUP BY把数据“分门别类”进行聚合？
GROUP BY
子句，在我看来，是SQL聚合查询的灵魂。没有它，聚合函数顶多只能给你整个表的一个总览。但数据往往需要从不同的维度去审视，比如按地区、按产品、按时间段来看销售情况。
GROUP BY
就是干这个的。
它的基本思想是：你指定一个或多个列，数据库会把这些列中值相同的行归为一组，然后对每个组独立地执行聚合函数。
举个例子，你有一个
sales
表，里面有
region
（地区）和
amount
（销售额）。如果你想知道每个地区的总销售额，你就需要按
region
来
GROUP BY
：
SELECT region, SUM(amount) AS total_region_sales FROM sales GROUP BY region;
这里，数据库会找到所有
region = 'East'
的行，把它们的
amount
加起来；再找所有
region = 'West'
的行，也把它们的
amount
加起来，以此类推。结果就是每个地区的总销售额。
如果你的数据更复杂，比如想看每个地区、每个产品类别的销售额，那就可以
GROUP BY
多个列：
SELECT region, product_category, SUM(amount) AS total_sales FROM sales GROUP BY region, product_category;
这里有个很重要的规则，也是很多人容易犯错的地方：
SELECT
语句中所有非聚合的列，都必须出现在
GROUP BY
子句中。比如，你不能
SELECT region, product_name, SUM(amount) FROM sales GROUP BY region;
。因为
product_name
没有被聚合（比如
COUNT(product_name)
），也没有在
GROUP BY
中，数据库就不知道在同一个
region
下，如果有很多不同的
product_name
，它应该显示哪一个。这就像你问“每个地区的总销售额是多少，顺便告诉我这个地区某个产品的名字”，但一个地区可能有很多产品，数据库就懵了。
有时，你可能会遇到一些数据清理的问题，比如
GROUP BY
的列中存在
NULL
值。
GROUP BY
会将所有
NULL
值视为一个单独的组。这一点在数据质量不高时，可能会导致一些意想不到的结果。所以，在进行分组聚合之前，对数据进行适当的清洗和预处理，总是一个好习惯。
WHERE和HAVING：聚合查询中的“双重过滤”艺术
在SQL的聚合查询里，
WHERE
和
HAVING
都是用来过滤数据的，但它们的工作时机和过滤对象完全不同。说实话，这俩是初学者最容易混淆的概念之一，但一旦理解了，你会发现它们能让你的查询逻辑变得异常清晰。
WHERE
子句：行级别的过滤
WHERE
是在数据被
GROUP BY
分组之前执行的。它针对的是表中的原始行。你可以把它想象成一个守门员，在数据还没进入聚合流程之前，就把不符合条件的个体（行）直接拦在外面了。
比如，你只想计算2023年的销售数据：
SELECT region, SUM(amount) AS total_sales FROM sales WHERE sale_date BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY region;
这里，
WHERE
子句会先筛选出所有2023年的销售记录，然后这些被筛选过的记录才会被送去按
region
分组，并计算总销售额。
WHERE
不能引用聚合函数的结果，因为它在聚合发生之前就执行了。你不能写
WHERE SUM(amount) > 1000
，那是
HAVING
的工作。
HAVING
子句：组级别的过滤
HAVING
则是在数据已经被
GROUP BY
分组并聚合之后执行的。它针对的是聚合后的组。你可以把它想象成一个评审团，在每个组的总销售额、平均值等聚合结果都计算出来之后，再根据这些聚合结果来决定哪些组应该被最终展示出来。
比如，你只想看那些总销售额超过10000的地区：
SELECT region, SUM(amount) AS total_sales FROM sales GROUP BY region HAVING SUM(amount) > 10000;
这个查询的执行顺序是：先从
sales
表获取数据，然后
GROUP BY region
对数据进行分组并计算每个
region
的
SUM(amount)
。最后，
HAVING
子句再检查每个组的
SUM(amount)
是否大于10000，只有满足条件的组才会被返回。
核心区别总结：
- 执行时机：
WHERE
在
GROUP BY
之前，
HAVING
在
GROUP BY
之后。
- 过滤对象：
WHERE
过滤原始行，
HAVING
过滤聚合后的组。
- 可引用内容：
WHERE
只能引用原始列，
HAVING
可以引用原始列和聚合函数的结果。
在实际工作中，我发现很多性能问题也和
WHERE
和
HAVING
的使用不当有关。通常，能用
WHERE
过滤的，就尽量用
WHERE
。因为
WHERE
会减少需要处理的行数，从而减轻
GROUP BY
和聚合函数的计算负担。而
HAVING
是在所有计算完成后再过滤，如果数据量很大，它可能会导致不必要的计算。所以，先用
WHERE
尽可能地缩小数据集，再用
HAVING
对聚合结果进行精细筛选，这通常是更高效的做法。
聚合查询与多表联接、子查询的结合
实际业务场景中，数据往往分散在多张表中，单表聚合是远远不够的。聚合函数与
JOIN
（联接）和子查询的结合使用，才是真正能解决复杂数据分析问题的利器。在我看来，这才是SQL聚合能力的真正体现，它能让你从不同维度、不同粒度去洞察数据。
聚合与JOIN：从多表获取聚合洞察
当我们想计算的数据分布在两张或更多张相关联的表里时，
JOIN
就成了必不可少的步骤。例如，我们想知道每个客户的总订单金额，但客户信息在
customers
表，订单信息在
orders
表。
SELECT c.customer_name, SUM(o.amount) AS total_order_amount FROM customers c JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.customer_name;
这个查询首先通过
customer_id
将
customers
表和
orders
表联接起来，形成一个包含客户姓名和订单金额的临时数据集。然后，在这个联接后的数据集上，我们再按
customer_name
进行分组，并计算每个客户的总订单金额。这里需要注意的是，如果一个客户没有订单，或者订单没有对应的客户，
JOIN
类型（
INNER JOIN
,
LEFT JOIN
,
RIGHT JOIN
,
FULL OUTER JOIN
）的选择会影响最终的聚合结果。例如，使用
LEFT JOIN
可以确保即使客户没有订单，他们的名字也会出现在结果中（
total_order_amount
为
NULL
）。
有时，我们可能需要对联接后的数据进行更复杂的过滤。比如，只计算活跃客户（比如过去一年内有订单的客户）的总消费。这可以在
JOIN
之前或之后，结合
WHERE
子句来完成。
聚合与子查询：解决更复杂的逻辑问题
子查询（Subquery）是嵌套在另一个SQL语句中的查询，它可以返回一个值、一行、一列或一个表。聚合函数经常在子查询中使用，以解决那些无法通过简单
JOIN
和
GROUP BY
直接解决的问题。
一种常见的场景是，我们需要将某个聚合结果与表中的每一行进行比较。例如，找出订单金额高于所有订单平均金额的订单：
SELECT order_id, amount FROM orders WHERE amount > (SELECT AVG(amount) FROM orders);
这里，
(SELECT AVG(amount) FROM orders)
是一个子查询，它首先计算出所有订单的平均金额，然后外部查询再用这个平均值来过滤订单。这种用法在“高于平均水平”、“低于特定阈值”等分析中非常实用。
另一种情况是，子查询作为
FROM
子句的一部分，创建一个临时表供外部查询使用，这通常被称为派生表（Derived Table）或内联视图。
SELECT t.customer_name, t.total_spent FROM (SELECT customer_id, SUM(amount) AS total_spent FROM orders GROUP BY customer_id) AS t JOIN customers c ON t.customer_id = c.customer_id WHERE t.total_spent > 5000;
这个例子中，我们首先在子查询中计算出每个客户的总消费（一个聚合结果），然后将这个结果作为一个临时表
t
，再与
customers
表联接，并筛选出总消费超过5000的客户。这种方式非常灵活，允许你先进行聚合，再将聚合结果与其他数据进行联接或进一步处理。
在我看来，掌握聚合函数、
JOIN
和子查询的组合使用，是SQL进阶的标志。它要求你对数据流向和SQL的执行顺序有清晰的理解，才能写出既准确又高效的查询。一开始可能会觉得有点绕，但多练习，多思考数据是如何一步步被转换和筛选的，就能逐渐体会到其中的精妙之处。
评论（已关闭）
评论已关闭