# 聚合函数
表1聚合函数列表 
| 函数名                | 与MySQL的差异                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|
| AVG()           | - GaussDB中指定DISTINCT且SQL语句包含GROUP BY子句时，不对结果进行排序，MySQL会进行排序。  - GaussDB中当expr中的列为BIT、BOOL、整数类型，且所有行的和超过BIGINT的范围时，会发生溢出导致整数翻转。  - GaussDB中当expr中的类型为BIT类型，返回值类型为double，MySQL的返回值类型为decimal。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| BIT_AND()        | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| BIT_OR()       | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| BIT_XOR()       | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| COUNT()           | GaussDB中指定DISTINCT且SQL语句包含GROUP BY子句时，不对结果进行排序，MySQL会进行排序。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| GROUP_CONCAT() | - GaussDB中指定DISTINCT且SQL语句包含GROUP BY子句时，不对结果进行排序，MySQL会进行排序。  - GROUP_CONCAT返回类型为二进制类型时，只返回BLOB类型，其他情况返回TEXT类型。MySQL根据返回长度还会返回longtext/tinytext/longblob/tinyblob类型。  - GaussDB中当GROUP_CONCAT参数中同时有DISTINCT和ORDER BY语法时，所有ORDER BY后的表达式必须也在DISTINCT的表达式之中。    - GaussDB中GROUP_CONCAT(... ORDER BY 数字)不代表按照第几个参数的顺序，数字只是一个常量表达式，相当于不排序。  - GaussDB中使用参数group_concat_max_len限制GROUP_CONCAT最大返回长度，超长截断，目前能返回的最大长度是1073741823，小于MySQL。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| MAX()            | - GaussDB中指定DISTINCT且SQL语句包含GROUP BY子句时，不对结果进行排序，MySQL会进行排序。    - 当参数为非表字段时，MAX函数、MIN函数返回值类型和MySQL 5.7不一致。  - 当参数为float类型时，MAX函数、MIN函数的返回值结果与MySQL 5.7一致。MySQL5.7和MySQL8.0有行为差异，导致MAX函数、MIN函数嵌套CAST(expr AS FLOAT\[(p)\])时的返回结果与MySQL8.0有差异。 ``` -- GaussDB： m_db=# CREATE TABLE t1(c1 float); CREATE TABLE m_db=# INSERT INTO t1 VALUES(1.2); INSERT 0 1 m_db=# SELECT MAX(c1) FROM t1; max -------------------- 1.2000000476837158 (1 row) m_db=# SELECT MAX(CAST(1.2 AS FLOAT)); max -------------------- 1.2000000476837158 (1 row) m_db=# DROP TABLE t1; DROP TABLE -- MySQL 5.7： mysql> CREATE TABLE t1(c1 float); Query OK, 0 rows affected (0.02 sec) mysql> INSERT INTO t1 VALUES(1.2); Query OK, 1 row affected (0.00 sec) mysql> SELECT MAX(c1) FROM t1; +--------------------+ | MAX(c1)            | +--------------------+ | 1.2000000476837158 | +--------------------+ 1 row in set (0.00 sec) -- MySQL5.7不支持CAST(expr AS FLOAT[(p)])表达式 mysql> SELECT MAX(CAST(1.2 AS FLOAT)); ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'FLOAT))' at line 1 mysql> DROP TABLE t1; Query OK, 0 rows affected (0.01 sec) -- MySQL 8.0： mysql> CREATE TABLE t1(c1 float); Query OK, 0 rows affected (0.03 sec) mysql> INSERT INTO t1 VALUES(1.2); Query OK, 1 row affected (0.00 sec) mysql> SELECT MAX(c1) FROM t1; +---------+ | MAX(c1) | +---------+ |     1.2 | +---------+ 1 row in set (0.00 sec) mysql> SELECT MAX(CAST(1.2 AS FLOAT)); +-------------------------+ | MAX(CAST(1.2 AS FLOAT)) | +-------------------------+ |                     1.2 | +-------------------------+ 1 row in set (0.00 sec) mysql> DROP TABLE t1; Query OK, 0 rows affected (0.01 sec) ```    |
| MIN()              | - GaussDB中指定DISTINCT且SQL语句包含GROUP BY子句时，不对结果进行排序，MySQL会进行排序。    - 当参数为非表字段时，MAX函数、MIN函数返回值类型和MySQL 5.7不一致。  - 当参数为float类型时，MAX函数、MIN函数的返回值结果与MySQL 5.7一致。MySQL5.7和MySQL8.0有行为差异，导致MAX函数、MIN函数嵌套CAST(expr AS FLOAT\[(p)\])时的返回结果与MySQL8.0有差异。 ``` -- GaussDB： m_db=# CREATE TABLE t1(c1 float); CREATE TABLE m_db=# INSERT INTO t1 VALUES(1.2); INSERT 0 1 m_db=# SELECT MAX(c1) FROM t1; max -------------------- 1.2000000476837158 (1 row) m_db=# SELECT MAX(CAST(1.2 AS FLOAT)); max -------------------- 1.2000000476837158 (1 row) m_db=# DROP TABLE t1; DROP TABLE -- MySQL 5.7： mysql> CREATE TABLE t1(c1 float); Query OK, 0 rows affected (0.02 sec) mysql> INSERT INTO t1 VALUES(1.2); Query OK, 1 row affected (0.00 sec) mysql> SELECT MAX(c1) FROM t1; +--------------------+ | MAX(c1)            | +--------------------+ | 1.2000000476837158 | +--------------------+ 1 row in set (0.00 sec) -- MySQL5.7不支持CAST(expr AS FLOAT[(p)])表达式 mysql> SELECT MAX(CAST(1.2 AS FLOAT)); ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'FLOAT))' at line 1 mysql> DROP TABLE t1; Query OK, 0 rows affected (0.01 sec) -- MySQL 8.0： mysql> CREATE TABLE t1(c1 float); Query OK, 0 rows affected (0.03 sec) mysql> INSERT INTO t1 VALUES(1.2); Query OK, 1 row affected (0.00 sec) mysql> SELECT MAX(c1) FROM t1; +---------+ | MAX(c1) | +---------+ |     1.2 | +---------+ 1 row in set (0.00 sec) mysql> SELECT MAX(CAST(1.2 AS FLOAT)); +-------------------------+ | MAX(CAST(1.2 AS FLOAT)) | +-------------------------+ |                     1.2 | +-------------------------+ 1 row in set (0.00 sec) mysql> DROP TABLE t1; Query OK, 0 rows affected (0.01 sec) ```    |
| SUM()            | - GaussDB中指定DISTINCT且SQL语句包含GROUP BY子句时，不对结果进行排序，MySQL会进行排序。  - GaussDB中当expr中的列为BIT、BOOL、整数类型，且所有行的和超过BIGINT的范围时，会发生溢出导致整数翻转。  - GaussDB中当expr中的类型为BIT类型，返回值类型为double，MySQL的返回值类型为decimal。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |