AVG([DISTINCT] expr) [over_clause]

返回 expr 的平均值。 DISTINCT 选项可用于返回 expr 的不同值的平均值。

如果没有匹配的行，AVG() 返回 NULL。如果 expr 为 NULL，该函数也返回 NULL。

如果存在 over_clause，则此函数将作为窗口函数执行。 over_clause 的描述如 第 14.20.2 节，“窗口函数的概念和语法” 中所述；它不能与 DISTINCT 一起使用。

mysql> SELECT student_name, AVG(test_score)
       FROM student
       GROUP BY student_name;

BIT_AND(expr) [over_clause]

返回 expr 中所有位的按位 AND。

结果类型取决于函数参数值是否被评估为二进制字符串或数字：

如果没有匹配的行，BIT_AND() 将返回一个中性值（所有位设置为 1），其长度与参数值相同。

NULL 值不影响结果，除非所有值都是 NULL。在这种情况下，结果是一个中性值，其长度与参数值相同。

有关参数计算和结果类型的更多讨论，请参阅 第 14.12 节，“位函数和运算符” 中的介绍性讨论。

如果 BIT_AND() 是从 mysql 客户端内部调用的，二进制字符串结果将使用十六进制表示法显示，具体取决于 --binary-as-hex 的值。有关该选项的更多信息，请参阅 第 6.5.1 节，“mysql — MySQL 命令行客户端”。

如果存在 over_clause，则此函数将作为窗口函数执行。 over_clause 的描述如 第 14.20.2 节，“窗口函数概念和语法” 中所述。

BIT_OR(expr) [over_clause]

返回 expr 中所有位的按位 OR。

结果类型取决于函数参数值是作为二进制字符串还是数字进行计算：

如果没有匹配的行，BIT_OR() 会返回一个与参数值长度相同的中性值（所有位都设置为 0）。

NULL 值不会影响结果，除非所有值都是 NULL。在这种情况下，结果是一个与参数值长度相同的中性值。

有关参数求值和结果类型的更多讨论，请参阅 第 14.12 节“位函数和运算符” 中的介绍性讨论。

如果从 mysql 客户端调用 BIT_OR()，二进制字符串结果将使用十六进制表示法显示，具体取决于 --binary-as-hex 的值。有关该选项的更多信息，请参阅 第 6.5.1 节“mysql — MySQL 命令行客户端”。

如果存在 over_clause，则此函数将作为窗口函数执行。 over_clause 的描述见 第 14.20.2 节“窗口函数概念和语法”。

BIT_XOR(expr) [over_clause]

返回 expr 中所有位的按位 XOR。

结果类型取决于函数参数值是作为二进制字符串还是数字进行求值：

如果没有匹配的行，BIT_XOR() 会返回一个中性值（所有位都设置为 0），其长度与参数值相同。

NULL 值不会影响结果，除非所有值都是 NULL。在这种情况下，结果是一个中性值，其长度与参数值相同。

有关参数计算和结果类型的更多信息，请参阅 第 14.12 节，“位函数和运算符” 中的介绍性讨论。

如果从 mysql 客户端调用 BIT_XOR()，则根据 --binary-as-hex 的值，二进制字符串结果将使用十六进制表示法显示。有关该选项的更多信息，请参阅 第 6.5.1 节，“mysql — MySQL 命令行客户端”。

如果存在 over_clause，则此函数将作为窗口函数执行。over_clause 的描述如 第 14.20.2 节，“窗口函数概念和语法” 中所述。

COUNT(expr) [over_clause]

返回由 SELECT 语句检索的行中 expr 的非 NULL 值的数量。结果是一个 BIGINT 值。

如果没有匹配的行，COUNT() 返回 0。COUNT(NULL) 返回 0。

如果存在 over_clause，则此函数将作为窗口函数执行。over_clause 的描述如 第 14.20.2 节，“窗口函数概念和语法” 中所述。

mysql> SELECT student.student_name,COUNT(*)
       FROM student,course
       WHERE student.student_id=course.student_id
       GROUP BY student_name;

COUNT(*) 的功能有所不同，它返回检索到的行数，无论它们是否包含 NULL 值。

对于像 InnoDB 这样的事务性存储引擎，存储准确的行数是有问题的。多个事务可能同时发生，每个事务都可能影响计数。

InnoDB 不会在表中保存内部行数，因为并发事务可能会在同一时间“看到”不同的行数。因此，SELECT COUNT(*) 语句只计算当前事务可见的行。

对于 InnoDB 表，如果没有额外的子句（例如 WHERE 或 GROUP BY），则 SELECT COUNT(*) FROM tbl_name 查询性能针对单线程工作负载进行了优化。

除非索引或优化器提示指示优化器使用不同的索引，否则 InnoDB 会通过遍历最小的可用二级索引来处理 SELECT COUNT(*) 语句。如果没有二级索引，InnoDB 会通过扫描聚簇索引来处理 SELECT COUNT(*) 语句。

如果索引记录没有完全在缓冲池中，则处理 SELECT COUNT(*) 语句需要一些时间。为了加快计数，请创建一个计数器表，并让您的应用程序根据它执行的插入和删除来更新它。但是，在数千个并发事务启动对同一个计数器表的更新的情况下，这种方法可能无法很好地扩展。如果近似行数足够，请使用 SHOW TABLE STATUS。

InnoDB 以相同的方式处理 SELECT COUNT(*) 和 SELECT COUNT(1) 操作。性能没有差异。

对于 MyISAM 表，如果 SELECT 从一个表中检索，没有检索其他列，并且没有 WHERE 子句，则 COUNT(*) 经过优化可以非常快速地返回。例如：

mysql> SELECT COUNT(*) FROM student;

此优化仅适用于 MyISAM 表，因为此存储引擎存储了确切的行数，并且可以非常快速地访问。 COUNT(1) 只有在第一列定义为 NOT NULL 时才受相同的优化约束。

COUNT(DISTINCT expr,[expr...])

返回具有不同非 NULL expr 值的行数。

如果没有匹配的行，COUNT(DISTINCT) 返回 0。

mysql> SELECT COUNT(DISTINCT results) FROM student;

在 MySQL 中，你可以通过提供一个表达式列表来获取不包含 NULL 的不同表达式组合的数量。在标准 SQL 中，你必须在 COUNT(DISTINCT ...) 中连接所有表达式。

GROUP_CONCAT(expr)

此函数返回一个字符串结果，其中包含来自组的连接的非 NULL 值。如果没有非 NULL 值，则返回 NULL。完整语法如下：

GROUP_CONCAT([DISTINCT] expr [,expr ...]
             [ORDER BY {unsigned_integer | col_name | expr}
                 [ASC | DESC] [,col_name ...]]
             [SEPARATOR str_val])

mysql> SELECT student_name,
         GROUP_CONCAT(test_score)
       FROM student
       GROUP BY student_name;

或者：

mysql> SELECT student_name,
         GROUP_CONCAT(DISTINCT test_score
                      ORDER BY test_score DESC SEPARATOR ' ')
       FROM student
       GROUP BY student_name;

在 MySQL 中，你可以获取表达式组合的连接值。要消除重复值，请使用 DISTINCT 子句。要对结果中的值进行排序，请使用 ORDER BY 子句。要按降序排序，请在 ORDER BY 子句中你要排序的列名称后面添加 DESC（降序）关键字。默认值为升序；这可以使用 ASC 关键字明确指定。组中值之间的默认分隔符是逗号（,）。要明确指定分隔符，请使用 SEPARATOR 后跟应插入组值之间的字符串文字值。要完全消除分隔符，请指定 SEPARATOR ''。

结果将被截断为 group_concat_max_len 系统变量给出的最大长度，该变量的默认值为 1024。该值可以设置得更高，尽管返回值的有效最大长度受 max_allowed_packet 值的限制。在运行时更改 group_concat_max_len 值的语法如下，其中 val 是一个无符号整数：

SET [GLOBAL | SESSION] group_concat_max_len = val;

返回值是一个非二进制或二进制字符串，具体取决于参数是非二进制还是二进制字符串。结果类型是 TEXT 或 BLOB，除非 group_concat_max_len 小于或等于 512，在这种情况下，结果类型是 VARCHAR 或 VARBINARY。

如果从mysql客户端内调用GROUP_CONCAT()，二进制字符串结果将使用十六进制表示法显示，具体取决于--binary-as-hex的值。有关该选项的更多信息，请参阅第 6.5.1 节，“mysql — MySQL 命令行客户端”。

另请参阅CONCAT()和CONCAT_WS()：第 14.8 节，“字符串函数和运算符”。

JSON_ARRAYAGG(col_or_expr) [over_clause]

将结果集聚合为单个JSON数组，其元素由行组成。此数组中元素的顺序未定义。该函数作用于一个列或一个计算结果为单个值的表达式。如果结果不包含任何行或发生错误，则返回NULL。如果col_or_expr为NULL，则该函数返回一个 JSON [null]元素数组。

如果存在over_clause，则此函数作为窗口函数执行。over_clause的说明如第 14.20.2 节，“窗口函数概念和语法”中所述。

mysql> SELECT o_id, attribute, value FROM t3;
+------+-----------+-------+
| o_id | attribute | value |
+------+-----------+-------+
|    2 | color     | red   |
|    2 | fabric    | silk  |
|    3 | color     | green |
|    3 | shape     | square|
+------+-----------+-------+
4 rows in set (0.00 sec)

mysql> SELECT o_id, JSON_ARRAYAGG(attribute) AS attributes
    -> FROM t3 GROUP BY o_id;
+------+---------------------+
| o_id | attributes          |
+------+---------------------+
|    2 | ["color", "fabric"] |
|    3 | ["color", "shape"]  |
+------+---------------------+
2 rows in set (0.00 sec)

JSON_OBJECTAGG(key, value) [over_clause]

接受两个列名或表达式作为参数，第一个用作键，第二个用作值，并返回包含键值对的 JSON 对象。如果结果不包含任何行或发生错误，则返回NULL。如果任何键名是NULL或参数数量不等于 2，则会发生错误。

如果存在over_clause，则此函数作为窗口函数执行。over_clause的说明如第 14.20.2 节，“窗口函数概念和语法”中所述。

mysql> SELECT o_id, attribute, value FROM t3;
+------+-----------+-------+
| o_id | attribute | value |
+------+-----------+-------+
|    2 | color     | red   |
|    2 | fabric    | silk  |
|    3 | color     | green |
|    3 | shape     | square|
+------+-----------+-------+
4 rows in set (0.00 sec)

mysql> SELECT o_id, JSON_OBJECTAGG(attribute, value)
    -> FROM t3 GROUP BY o_id;
+------+---------------------------------------+
| o_id | JSON_OBJECTAGG(attribute, value)      |
+------+---------------------------------------+
|    2 | {"color": "red", "fabric": "silk"}    |
|    3 | {"color": "green", "shape": "square"} |
+------+---------------------------------------+
2 rows in set (0.00 sec)

重复键处理。 当此函数的结果被规范化时，具有重复键的值将被丢弃。根据 MySQL JSON 数据类型规范，不允许重复键，在返回的对象中，只有最后遇到的值会与该键一起使用（““最后重复键胜出”）。这意味着，将此函数用于 SELECT 中的列的结果可能取决于返回行的顺序，而这是无法保证的。

当用作窗口函数时，如果在一个框架内存在重复的键，则结果中只存在该键的最后一个值。如果 ORDER BY 规范保证这些值具有特定的顺序，则该键在框架中最后一行中的值是确定性的。否则，该键的结果值是不确定的。

考虑以下情况：

mysql> CREATE TABLE t(c VARCHAR(10), i INT);
Query OK, 0 rows affected (0.33 sec)

mysql> INSERT INTO t VALUES ('key', 3), ('key', 4), ('key', 5);
Query OK, 3 rows affected (0.10 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT c, i FROM t;
+------+------+
| c    | i    |
+------+------+
| key  |    3 |
| key  |    4 |
| key  |    5 |
+------+------+
3 rows in set (0.00 sec)

mysql> SELECT JSON_OBJECTAGG(c, i) FROM t;
+----------------------+
| JSON_OBJECTAGG(c, i) |
+----------------------+
| {"key": 5}           |
+----------------------+
1 row in set (0.00 sec)

mysql> DELETE FROM t;
Query OK, 3 rows affected (0.08 sec)

mysql> INSERT INTO t VALUES ('key', 3), ('key', 5), ('key', 4);
Query OK, 3 rows affected (0.06 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT c, i FROM t;
+------+------+
| c    | i    |
+------+------+
| key  |    3 |
| key  |    5 |
| key  |    4 |
+------+------+
3 rows in set (0.00 sec)

mysql> SELECT JSON_OBJECTAGG(c, i) FROM t;
+----------------------+
| JSON_OBJECTAGG(c, i) |
+----------------------+
| {"key": 4}           |
+----------------------+
1 row in set (0.00 sec)

从最后一个查询中选择的键是不确定的。如果查询没有使用 GROUP BY（通常会强加它自己的排序规则），并且您希望使用特定的键排序，您可以通过包含 OVER 子句和 ORDER BY 规范来调用 JSON_OBJECTAGG() 作为窗口函数，以便对框架行强加特定的顺序。以下示例展示了在几种不同的框架规范中，使用和不使用 ORDER BY 会发生什么情况。

不使用 ORDER BY，框架是整个分区：

mysql> SELECT JSON_OBJECTAGG(c, i)
       OVER () AS json_object FROM t;
+-------------+
| json_object |
+-------------+
| {"key": 4}  |
| {"key": 4}  |
| {"key": 4}  |
+-------------+

使用 ORDER BY，其中框架是 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 的默认值（升序和降序）：

mysql> SELECT JSON_OBJECTAGG(c, i)
       OVER (ORDER BY i) AS json_object FROM t;
+-------------+
| json_object |
+-------------+
| {"key": 3}  |
| {"key": 4}  |
| {"key": 5}  |
+-------------+
mysql> SELECT JSON_OBJECTAGG(c, i)
       OVER (ORDER BY i DESC) AS json_object FROM t;
+-------------+
| json_object |
+-------------+
| {"key": 5}  |
| {"key": 4}  |
| {"key": 3}  |
+-------------+

使用 ORDER BY 和整个分区的显式框架：

mysql> SELECT JSON_OBJECTAGG(c, i)
       OVER (ORDER BY i
            ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
        AS json_object
       FROM t;
+-------------+
| json_object |
+-------------+
| {"key": 5}  |
| {"key": 5}  |
| {"key": 5}  |
+-------------+

要返回特定的键值（例如最小值或最大值），请在相应的查询中包含 LIMIT 子句。例如：

mysql> SELECT JSON_OBJECTAGG(c, i)
       OVER (ORDER BY i) AS json_object FROM t LIMIT 1;
+-------------+
| json_object |
+-------------+
| {"key": 3}  |
+-------------+
mysql> SELECT JSON_OBJECTAGG(c, i)
       OVER (ORDER BY i DESC) AS json_object FROM t LIMIT 1;
+-------------+
| json_object |
+-------------+
| {"key": 5}  |
+-------------+

有关更多信息和示例，请参阅 JSON 值的规范化、合并和自动包装。

MAX([DISTINCT] expr) [over_clause]

返回 expr 的最大值。MAX() 可以接受一个字符串参数；在这种情况下，它返回最大字符串值。请参阅 第 10.3.1 节，“MySQL 如何使用索引”。DISTINCT 关键字可用于查找 expr 的不同值的最大值，但是，这会产生与省略 DISTINCT 相同的结果。

如果没有匹配的行，或者 expr 是 NULL，则 MAX() 返回 NULL。

如果存在over_clause，则此函数将作为窗口函数执行。over_clause 的描述见章节 14.20.2，“窗口函数概念和语法”；它不能与 DISTINCT 一起使用。

mysql> SELECT student_name, MIN(test_score), MAX(test_score)
       FROM student
       GROUP BY student_name;

对于 MAX()，MySQL 目前通过字符串值而不是字符串在集合中的相对位置来比较 ENUM 和 SET 列。这与 ORDER BY 比较它们的方式不同。

MIN([DISTINCT] expr) [over_clause]

返回 expr 的最小值。MIN() 可以接受字符串参数；在这种情况下，它返回最小字符串值。参见章节 10.3.1，“MySQL 如何使用索引”。DISTINCT 关键字可用于查找 expr 的不同值的最小值，但这与省略 DISTINCT 产生的结果相同。

如果没有匹配的行，或者如果 expr 为 NULL，则 MIN() 返回 NULL。

如果存在over_clause，则此函数将作为窗口函数执行。over_clause 的描述见章节 14.20.2，“窗口函数概念和语法”；它不能与 DISTINCT 一起使用。

mysql> SELECT student_name, MIN(test_score), MAX(test_score)
       FROM student
       GROUP BY student_name;

对于 MIN()，MySQL 目前通过字符串值而不是字符串在集合中的相对位置来比较 ENUM 和 SET 列。这与 ORDER BY 比较它们的方式不同。

STD(expr) [over_clause]

返回 expr 的总体标准偏差。STD() 是标准 SQL 函数 STDDEV_POP() 的同义词，作为 MySQL 扩展提供。

如果没有匹配的行，或者如果 expr 为 NULL，则 STD() 返回 NULL。

如果存在 over_clause 子句，此函数将作为窗口函数执行。 over_clause 子句的描述如 第 14.20.2 节，“窗口函数概念和语法” 所示。

STDDEV(expr) [over_clause]

返回 expr 的总体标准偏差。 STDDEV() 是标准 SQL 函数 STDDEV_POP() 的同义词，用于与 Oracle 兼容。

如果没有匹配的行，或者 expr 为 NULL，则 STDDEV() 返回 NULL。

如果存在 over_clause 子句，此函数将作为窗口函数执行。 over_clause 子句的描述如 第 14.20.2 节，“窗口函数概念和语法” 所示。

STDDEV_POP(expr) [over_clause]

返回 expr 的总体标准偏差（VAR_POP() 的平方根）。您也可以使用 STD() 或 STDDEV()，它们是等效的，但不是标准 SQL。

如果没有匹配的行，或者 expr 为 NULL，则 STDDEV_POP() 返回 NULL。

如果存在 over_clause 子句，此函数将作为窗口函数执行。 over_clause 子句的描述如 第 14.20.2 节，“窗口函数概念和语法” 所示。

STDDEV_SAMP(expr) [over_clause]

返回 expr 的样本标准偏差（VAR_SAMP() 的平方根）。

如果没有匹配的行，或者 expr 为 NULL，则 STDDEV_SAMP() 返回 NULL。

如果存在 over_clause，则此函数作为窗口函数执行。 over_clause 的描述见 第 14.20.2 节，“窗口函数的概念和语法”。

SUM([DISTINCT] expr) [over_clause]

返回 expr 的总和。如果结果集没有行，SUM() 返回 NULL。可以使用 DISTINCT 关键字仅对 expr 的不同值求和。

如果没有匹配的行，或者 expr 为 NULL，SUM() 返回 NULL。

如果存在 over_clause，则此函数作为窗口函数执行。 over_clause 的描述见 第 14.20.2 节，“窗口函数的概念和语法”；它不能与 DISTINCT 一起使用。

VAR_POP(expr) [over_clause]

返回 expr 的总体标准方差。它将行视为整个总体，而不是样本，因此它以行数作为分母。你也可以使用 VARIANCE()，它等效但不是标准 SQL。

如果没有匹配的行，或者 expr 为 NULL，VAR_POP() 返回 NULL。

如果存在 over_clause，则此函数作为窗口函数执行。 over_clause 的描述见 第 14.20.2 节，“窗口函数的概念和语法”。

VAR_SAMP(expr) [over_clause]

返回 expr 的样本方差。也就是说，分母是行数减一。

如果没有匹配的行，或者 expr 为 NULL，VAR_SAMP() 返回 NULL。

如果存在 over_clause，则此函数将作为窗口函数执行。 over_clause 的描述详见 第 14.20.2 节，“窗口函数概念和语法”。

VARIANCE(expr) [over_clause]

返回 expr 的总体标准方差。 VARIANCE() 是标准 SQL 函数 VAR_POP() 的同义词，作为 MySQL 扩展提供。

如果没有匹配的行，或者 expr 为 NULL，则 VARIANCE() 返回 NULL。

如果存在 over_clause，则此函数将作为窗口函数执行。 over_clause 的描述详见 第 14.20.2 节，“窗口函数概念和语法”。