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 节，“位函数和运算符”中的介绍性讨论。

如果从mysql客户端调用BIT_AND()，则二进制字符串结果将使用十六进制表示法显示，具体取决于--binary-as-hex的值。有关该选项的更多信息，请参阅第 6.5.1 节，“mysql — The 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 — The 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 — The 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(*)语句仅计算当前事务可见的行。

如果不存在WHERE或GROUP BY之类的额外子句，则InnoDB表中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...])

返回具有不同非NULLexpr值的行的计数。

如果没有匹配的行，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 — The 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（这通常会强制执行自己的排序，无论如何），并且您希望使用特定键顺序，则可以通过包含带有 ORDER BY 规范的 OVER 子句来将 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 节，“窗口函数概念和语法”中所述。