MySQL 5.1参考手册 :: 12. 函数和操作符(5)

12.9.1. 位函数

对于比特运算，MySQL 使用 BIGINT (64比特) 算法，因此这些操作符的最大范围是 64 比特。

• |

Bitwise OR:

mysql> SELECT 29 | 15;

        -> 31

其结果为一个64比特无符号整数。

• &

Bitwise AND:

mysql> SELECT 29 & 15;

        -> 13

其结果为一个64比特无符号整数。

• ^

Bitwise XOR:

mysql> SELECT 1 ^ 1;

        -> 0

mysql> SELECT 1 ^ 0;

        -> 1

mysql> SELECT 11 ^ 3;

        -> 8

结果为一个64比特无符号整数。

• <<

把一个longlong (BIGINT)数左移两位。

mysql> SELECT 1 << 2;

        -> 4

其结果为一个64比特无符号整数。

• >>

把一个longlong (BIGINT)数右移两位。

mysql> SELECT 4 >> 2;

        -> 1

其结果为一个64比特无符号整数。

• ~

反转所有比特。

mysql> SELECT 5 & ~1;

        -> 4

其结果为一个64比特无符号整数。

• BIT_COUNT(N)

返回参数N 中所设置的比特数

mysql> SELECT BIT_COUNT(29);

        -> 4

12.9.2. 加密函数

12.9.3. 信息函数

• BENCHMARK(count,expr)

BENCHMARK() 函数重复count 次执行表达式 expr 。 它可以被用于计算  MySQL 处理表达式的速度。结果值通常为 0。另一种用处来自 mysql客户端内部,能够报告问询执行的次数：

mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));

+----------------------------------------------+

| BENCHMARK(1000000,ENCODE('hello','goodbye')) |

+----------------------------------------------+

|                                            0 |

+----------------------------------------------+

1 row in set (4.74 sec)

此处报告的时间是客户端上的共用时间，而不是服务器端上的CPU时间。建议执行多遍BENCHMARK()，并解释与服务器机器负荷程度有关的结果。

·         CHARSET(str)

返回字符串自变量的字符集。

mysql> SELECT CHARSET('abc');

        -> 'latin1'

mysql> SELECT CHARSET(CONVERT('abc' USING utf8));

        -> 'utf8'

mysql> SELECT CHARSET(USER());

        -> 'utf8'

·         COERCIBILITY(str)

返回字符串自变量的整序可压缩性值。

mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);

        -> 0

mysql> SELECT COERCIBILITY(USER());

        -> 3

mysql> SELECT COERCIBILITY('abc');

        -> 4

返回值具有如下意义：

下方值得优先级较高。

• COLLATION(str)

返回惠字符串参数的排序方式。

mysql> SELECT COLLATION('abc');

        -> 'latin1_swedish_ci'

mysql> SELECT COLLATION(_utf8'abc');

        -> 'utf8_general_ci'

• CONNECTION_ID()

返回对于连接的连接ID (线程ID)。每个连接都有各自的唯一 ID。

mysql> SELECT CONNECTION_ID();

        -> 23786

• CURRENT_USER, CURRENT_USER()

返回当前话路被验证的用户名和主机名组合。这个值符合确定你的存取权限的MySQL 账户。在被指定SQL SECURITY DEFINER特征的存储程序内， CURRENT_USER() 返回程序的创建者。

 CURRENT_USER()的值可以和USER()的值有所不同。

mysql> SELECT USER();

        -> 'davida@localhost'

mysql> SELECT * FROM mysql.user;

ERROR 1044: Access denied for user ''@'localhost' to

database 'mysql'

mysql> SELECT CURRENT_USER();

        -> '@localhost'

这个例子解释了虽然客户端指定了一个 davida用户名 (正如USER()函数的值所指示的), 服务器却使用一个匿名的用户账户确认该客户端 (见CURRENT_USER()值得空用户名部分 )。这种情况发生的一个原因是 One 在向 davida的授权列表中没有足够的账户。 

 CURRENT_USER() 返回的字符串使用 utf8字符集。

• DATABASE()

返回使用 utf8 字符集的默认(当前)数据库名。在存储程序里，默认数据库是同该程序向关联的数据库，但并不一定与调用语境的默认数据库相同。 

mysql> SELECT DATABASE();

        -> 'test'

若没有默认数据库, DATABASE()返回 NULL。

• FOUND_ROWS()

A SELECT语句可能包括一个 LIMIT 子句，用来限制服务器返回客户端的行数。在有些情况下，需要不用再次运行该语句而得知在没有LIMIT 时到底该语句返回了多少行。为了知道这个行数, 包括在SELECT 语句中选择  SQL_CALC_FOUND_ROWS ，随后调用 FOUND_ROWS() ：

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name

    -> WHERE id > 100 LIMIT 10;

mysql> SELECT FOUND_ROWS();

第二个 SELECT返回一个数字，指示了在没有LIMIT子句的情况下，第一个SELECT返回了多少行 (若上述的 SELECT语句不包括 SQL_CALC_FOUND_ROWS 选项,则使用LIMIT 和不使用时，FOUND_ROWS() 可能会返回不同的结果）。

通过 FOUND_ROWS()的有效行数是瞬时的，并且不用于越过SELECT SQL_CALC_FOUND_ROWS语句后面的语句。若你需要稍候参阅这个值，那么将其保存：

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;

mysql> SET @rows = FOUND_ROWS();

假如你正在使用 SELECT SQL_CALC_FOUND_ROWS, MySQL 必须计算出在全部结果集合中有所少行。然而， 这比不用LIMIT而再次运行问询要快，原因是结果集合不需要被送至客户端。

SQL_CALC_FOUND_ROWS 和 FOUND_ROWS() 在当你希望限制一个问询返回的行数时很有用，同时还能不需要再次运行问询而确定全部结果集合中的行数。一个例子就是提供页式显示的Web脚本，该显示包含显示搜索结果其它部分的页的连接。使用FOUND_ROWS() 使你确定剩下的结果需要多少其它的页。 

SQL_CALC_FOUND_ROWS 和 FOUND_ROWS() 的应用对于UNION 问询比对于简单SELECT 语句更为复杂，原因是在UNION 中，LIMIT 可能会出现在多个位置。它可能适用于UNION中的个人 SELECT语句，或是总体上  到UNION 结果的全程。

SQL_CALC_FOUND_ROWS对于 UNION的意向是它应该不需要全程LIMIT而返回应返回的行数。SQL_CALC_FOUND_ROWS 和UNION 一同使用的条件是：

•  SQL_CALC_FOUND_ROWS 关键词必须出现在UNION的第一个 SELECT中。
•  FOUND_ROWS()的值只有在使用 UNION ALL时才是精确的。若使用不带ALL的UNION，则会发生两次删除， 而  FOUND_ROWS() 的指只需近似的。
• 假若UNION 中没有出现  LIMIT ，则SQL_CALC_FOUND_ROWS 被忽略，返回临时表中的创建的用来处理UNION的行数。
• LAST_INSERT_ID() LAST_INSERT_ID(expr)

自动返回最后一个INSERT或 UPDATE 问询为 AUTO_INCREMENT列设置的第一个 发生的值。

mysql> SELECT LAST_INSERT_ID();

        -> 195

产生的ID 每次连接后保存在服务器中。这意味着函数向一个给定客户端返回的值是该客户端产生对影响AUTO_INCREMENT列的最新语句第一个 AUTO_INCREMENT值的。这个值不能被其它客户端影响，即使它们产生它们自己的 AUTO_INCREMENT值。这个行为保证了你能够找回自己的 ID 而不用担心其它客户端的活动，而且不需要加锁或处理。

假如你使用一个非“magic”值来更新某一行的AUTO_INCREMENT 列，则LAST_INSERT_ID() 的值不会变化(换言之, 一个不是 NULL也不是 0的值)。

重点: 假如你使用单INSERT语句插入多个行，  LAST_INSERT_ID() 只返回插入的第一行产生的值。其原因是这使依靠其它服务器复制同样的 INSERT语句变得简单。

例如：

mysql> USE test;

Database changed

mysql> CREATE TABLE t (

    ->   id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,

    ->   name VARCHAR(10) NOT NULL

    -> );

Query OK, 0 rows affected (0.09 sec)

mysql> INSERT INTO t VALUES (NULL, 'Bob');

Query OK, 1 row affected (0.01 sec)

mysql> SELECT * FROM t;

+----+------+

| id | name |

+----+------+

|  1 | Bob  |

+----+------+

1 row in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();

+------------------+

| LAST_INSERT_ID() |

+------------------+

|                1 |

+------------------+

1 row in set (0.00 sec)

mysql> INSERT INTO t VALUES

    -> (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');

Query OK, 3 rows affected (0.00 sec)

Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM t;

+----+------+

| id | name |

+----+------+

|  1 | Bob  |

|  2 | Mary |

|  3 | Jane |

|  4 | Lisa |

+----+------+

4 rows in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();

+------------------+

| LAST_INSERT_ID() |

+------------------+

|                2 |

+------------------+

1 row in set (0.00 sec)

虽然第二个问询将3 个新行插入 t, 对这些行的第一行产生的 ID 为 2, 这也是 LAST_INSERT_ID()返回的值。

假如你使用 INSERT IGNORE而记录被忽略，则AUTO_INCREMENT 计数器不会增量，而 LAST_INSERT_ID() 返回0, 这反映出没有插入任何记录。

若给出作为到LAST_INSERT_ID()的参数expr ，则参数的值被函数返回，并作为被LAST_INSERT_ID()返回的下一个值而被记忆。这可用于模拟序列：

• 创建一个表，用来控制顺序计数器并使其初始化：

o                     mysql> CREATE TABLE sequence (id INT NOT NULL);

o                     mysql> INSERT INTO sequence VALUES (0);

• 使用该表产生这样的序列数 ：

o                     mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);

o                     mysql> SELECT LAST_INSERT_ID();

UPDATE 语句会增加顺序计数器并引发向LAST_INSERT_ID()  的下一次调用，用来返回升级后的值。 SELECT 语句会检索这个值。  mysql_insert_id() C API函数也可用于获取这个值。 见25.2.3.36节，“mysql_insert_id()”.

你可以不用调用LAST_INSERT_ID()而产生序列，但这样使用这个函数的效用在于 ID值被保存在服务器中，作为自动产生的值。它适用于多个用户，原因是多个用户均可使用 UPDATE语句并用SELECT语句(或mysql_insert_id()),得到他们自己的序列值，而不会影响其它产生他们自己的序列值的客户端或被其它产生他们自己的序列值的客户端所影响。

注意， mysql_insert_id() 仅会在INSERT 和UPDATE语句后面被升级， 因此你不能在执行了其它诸如SELECT或 SET 这样的SQL语句后使用 C API 函数来找回 LAST_INSERT_ID(expr) 对应的值。

• ROW_COUNT()

ROW_COUNT()返回被前面语句升级的、插入的或删除的行数。 这个行数和 mysql 客户端显示的行数及 mysql_affected_rows() C API 函数返回的值相同。

mysql> INSERT INTO t VALUES(1),(2),(3);

问询完成, 表中有3 行 (0.00秒)

记录: 3 重复: 0 警告: 0

mysql> SELECT ROW_COUNT();

+-------------+

| ROW_COUNT() |

+-------------+

|           3 |

+-------------+

表中有1行 (0.00 秒)

mysql> DELETE FROM t WHERE i IN(1,2);

问询完成, 找到2 行 (0.00 秒)

mysql> SELECT ROW_COUNT();

+-------------+

| ROW_COUNT() |

+-------------+

|           2 |

+-------------+

表中有1行 (0.00 秒)

• SCHEMA()

这个函数和 DATABASE()具有相同的意义。

• SESSION_USER()

SESSION_USER()和 USER()具有相同的意义。

• SYSTEM_USER()

SYSTEM_USER()合 USER()具有相同的意义。

• USER()

返回当前 MySQL用户名和机主名/

mysql> SELECT USER();

        -> 'davida@localhost'

这个值指示了你指定的连接服务器时的用户名,及你所连接的客户主机。这个值可以和CURRENT_USER() 的值不同。

你可以这样提取用户名部分：

mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);

        -> 'davida'

由于 USER() 返回一个utf8 字符集中的值，你也应确保'@' 字符串文字在该字符集中得到解释：

mysql> SELECT SUBSTRING_INDEX(USER(),_utf8'@',1);

        -> 'davida'

• VERSION()

返回指示 MySQL 服务器版本的字符串。这个字符串使用 utf8 字符集。

mysql> SELECT VERSION();

        -> '5.1.2-alpha-standard'

注意，假如你的版本字符串以-log结尾，这说明登录已被激活。 

12.9.4. 其他函数

• DEFAULT(col_name)

返回一个表列的默认值。若该列没有默认值则会产生错误。

mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;

• FORMAT(X,D)

将数字X 的格式写为'#,###,###.##',以四舍五入的方式保留小数点后 D 位， 并将结果以字符串的形式返回。若  D 为 0, 则返回结果不带有小数点，或不含小数部分。

mysql> SELECT FORMAT(12332.123456, 4);

        -> '12,332.1235'

mysql> SELECT FORMAT(12332.1,4);

        -> '12,332.1000'

mysql> SELECT FORMAT(12332.2,0);

        -> '12,332'

• GET_LOCK(str,timeout)

设法使用字符串str 给定的名字得到一个锁， 超时为timeout 秒。若成功得到锁，则返回 1，若操作超时则返回0  (例如,由于另一个客户端已提前封锁了这个名字 ),若发生错误则返回NULL (诸如缺乏记忆或线程mysqladmin kill 被断开 )。假如你有一个用GET_LOCK()得到的锁，当你执行RELEASE_LOCK()或你的连接断开(正常或非正常)时，这个锁就会解除。

这个函数可用于执行应用程序锁或模拟记录锁定。名称被锁定在服务器范围内。假如一个名字已经被一个客户端封锁， GET_LOCK() 会封锁来自另一个客户端申请封锁同一个名字的任何请求。这使对一个封锁名达成协议的客户端使用这个名字合作执行建议锁。然而要知道它也允许不在一组合作客户端中的一个客户端封锁名字，不论是服役的还是非故意的，这样阻止任何合作中的客户端封锁这个名字。一个减少这种情况发生的办法就是使用数据库特定的或应用程序特定的封锁名。例如，  使用db_name.str或 app_name.str 形式的封锁名。

mysql> SELECT GET_LOCK('lock1',10);

        -> 1

mysql> SELECT IS_FREE_LOCK('lock2');

        -> 1

mysql> SELECT GET_LOCK('lock2',10);

        -> 1

mysql> SELECT RELEASE_LOCK('lock2');

        -> 1

mysql> SELECT RELEASE_LOCK('lock1');

        -> NULL

注意，第二个 RELEASE_LOCK()调用返回 NULL ，原因是锁'lock1' 杯第二个GET_LOCK()调用解开。

• INET_ATON(expr)

给出一个作为字符串的网络地址的点地址表示，返回一个代表该地址数值的整数。地址可以是4或8比特地址。

mysql> SELECT INET_ATON('209.207.224.40');

        -> 3520061480

产生的数字总是按照网络字节顺序。如上面的例子，数字按照 209×2563 + 207×2562 + 224×256 + 40 进行计算。

INET_ATON() 也能理解短格式 IP 地址：

mysql> SELECT INET_ATON('127.0.0.1'), INET_ATON('127.1');

        -> 2130706433, 2130706433

注释： 在存储由INET_ATON() 产生的值时，推荐你使用 INT UNSIGNED 列。假如你使用 (带符号) INT列, 则相应的第一个八位组大于127的IP 地址值会被截至  2147483647 (即, INET_ATON('127.255.255.255') 所返回的值)。请参见11.2节，“数值类型”。

• INET_NTOA(expr)

给定一个数字网络地址 (4 或 8 比特),返回作为字符串的该地址的电地址表示。

mysql> SELECT INET_NTOA(3520061480);

        -> '209.207.224.40'

• IS_FREE_LOCK(str)

检查名为str的锁是否可以使用 (换言之,没有被封锁)。若锁可以使用，则返回  1  (没有人在用这个锁), 若这个锁正在被使用，则返回0 ，出现错误则返回 NULL  (诸如不正确的参数 )。

• IS_USED_LOCK(str)

检查名为str的锁是否正在被使用(换言之,被封锁)。若被封锁，则返回使用该锁的客户端的连接标识符。否则返回 NULL。

• MASTER_POS_WAIT(log_name,log_pos[,timeout])

该函数对于控制主从同步很有用处。它会持续封锁，直到从设备阅读和应用主机记录中所有补充资料到指定的位置。返回值是其为到达指定位置而必须等待的记录事件的数目。若从设备SQL线程没有被启动、从设备主机信息尚未初始化、参数不正确或出现任何错误，则该函数返回 NULL。若超时时间被超过，则返回-1。若在MASTER_POS_WAIT() 等待期间，从设备SQL线程中止，则该函数返回 NULL。若从设备由指定位置通过，则函数会立即返回结果。

假如已经指定了一个超时时间值，当 超时时间 秒数经过后MASTER_POS_WAIT()会停止等待。超时时间 必须大于 0；一个为零或为负值的 超时时间 表示没有超市时间。 

• NAME_CONST(name,value)

返回给定值。 当用来产生一个结果集合列时, NAME_CONST()促使该列使用给定名称。 

mysql> SELECT NAME_CONST('myname', 14);

+--------+

| myname |

+--------+

|     14 |

+--------+

这个函数被添加进 MySQL 5.0.12。它只做内部使用。 服务器在书写来自包含局部程序变量的存储程序的语句时会用到它，详见20.4节，“存储子程序和触发程序的二进制日志功能”。你可能会在mysqlbinlog 的书橱中看到这个函数。

• RELEASE_LOCK(str)

解开被GET_LOCK()获取的，用字符串str 所命名的锁。若锁被解开，则返回  1，若改线程尚未创建锁，则返回0 (此时锁没有被解开 ), 若命名的锁不存在，则返回 NULL。若该锁从未被对GET_LOCK()的调用获取，或锁已经被提前解开，则该锁不存在。

DO 语句和RELEASE_LOCK()同时使用很方便。请参见13.2.2节，“DO语法”。

• SLEEP(duration)

睡眠(暂停) 时间为duration 参数给定的秒数，然后返回 0。若 SLEEP() 被中断,它会返回 1。 duration 或许或包括一个给定的以微秒为单位的分数部分。

• UUID()

返回一个通用唯一标识符(UUID) ，其产生的根据是《DCE 1.1: 远程过程调用》 (附录A) CAE (公共应用软件环境) 的说明，该作品于1997年10月由 The Open Group 出版 (文件编号 C706, http://www.opengroup.org/public/pubs/catalog/c706.htm).

UUID被设计成一个在时间和空间上都独一无二的数字。2个对UUID() 的调用应产生2个不同的值，即使这些调用的执行是在两个互不相连的单独电脑上进行。

UUID 是一个由5位十六进制数的字符串表示的128比特数字 ，其格式为  aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee ：

• 前3个数字从一个时间戳产生。 
• 第4 个数字保持暂时唯一性，以防时间戳值失去单一性 (例如, 由于经济时)。
• 第5个数字是一个 IEEE 802 节点号，它提供空间唯一性。若后者不可用，则用一个随机数字替换。 (例如, 由于主机没有以太网卡，或我们不知道怎样在你的操作系统上找到界面的机器地址 )。假若这样，空间唯一性就不能得到保证。尽管如此，一个冲突的发生机率还是非常低的。

目前,一个界面的 MAC 地址尽被FreeBSD 和 Linux考虑到。在其它操作系统中, MySQL使用随机产生的 48比特数字。

mysql> SELECT UUID();

        -> '6ccd780c-baba-1026-9564-0040f4311e29'

注意， UUID() 不支持复制功能。

• VALUES(col_name)

在一个INSERT … ON DUPLICATE KEY UPDATE …语句中，你可以在UPDATE 子句中使用 VALUES(col_name)函数，用来访问来自该语句的INSERT 部分的列值。换言之，UPDATE 子句中的 VALUES(col_name) 访问需要被插入的col_name 的值,并不会发生重复键冲突。这个函数在多行插入中特别有用。  VALUES()函数只在INSERT ... UPDATE 语句中有意义，而在其它情况下只会返回 NULL。请参见13.2.4节，“INSERT语法”.

mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)

    -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);

12.10.1. GROUP BY（聚合）函数

12.10.2. GROUP BY修改程序

GROUP BY子句允许一个将额外行添加到简略输出端 WITH ROLLUP 修饰符。这些行代表高层(或高聚集)简略操作。ROLLUP 因而允许你在多层分析的角度回答有关问询的问题。例如，它可以用来向OLAP (联机分析处理) 操作提供支持。

设想一个名为sales 的表具有年份、国家、产品及记录销售利润的利润列：

CREATE TABLE sales

(

    year    INT NOT NULL,

    country VARCHAR(20) NOT NULL,

    product VARCHAR(32) NOT NULL,

    profit  INT

);

可以使用这样的简单GROUP BY，每年对表的内容做一次总结：

mysql> SELECT year, SUM(profit) FROM sales GROUP BY year;

+------+-------------+

| year | SUM(profit) |

+------+-------------+

| 2000 |        4525 |

| 2001 |        3010 |

+------+-------------+

这个输出结果显示了每年的总利润， 但如果你也想确定所有年份的总利润，你必须自己累加每年的单个值或运行一个加法询问。

或者你可以使用 ROLLUP, 它能用一个问询提供双层分析。将一个 WITH ROLLUP修饰符添加到GROUP BY 语句，使询问产生另一行结果，该行显示了所有年份的总价值：

mysql> SELECT year, SUM(profit) FROM sales GROUP BY year WITH ROLLUP;

+------+-------------+

| year | SUM(profit) |

+------+-------------+

| 2000 |        4525 |

| 2001 |        3010 |

| NULL |        7535 |

+------+-------------+

总计高聚集行被年份列中的NULL值标出。

当有多重 GROUP BY 列时，ROLLUP产生的效果更加复杂。这时，每次在除了最后一个分类列之外的任何列出现一个 “break” (值的改变) ，则问讯会产生一个高聚集累计行。

例如，在没有 ROLLUP的情况下，一个以年、国家和产品为基础的关于 sales 表的一览表可能如下所示：

mysql> SELECT year, country, product, SUM(profit)

    -> FROM sales

    -> GROUP BY year, country, product;

+------+---------+------------+-------------+

| year | country | product    | SUM(profit) |

+------+---------+------------+-------------+

| 2000 | Finland | Computer   |        1500 |

| 2000 | Finland | Phone      |         100 |

| 2000 | India   | Calculator |         150 |

| 2000 | India   | Computer   |        1200 |

| 2000 | USA     | Calculator |          75 |

| 2000 | USA     | Computer   |        1500 |

| 2001 | Finland | Phone      |          10 |

| 2001 | USA     | Calculator |          50 |

| 2001 | USA     | Computer   |        2700 |

| 2001 | USA     | TV         |         250 |

+------+---------+------------+-------------+

表示总值的输出结果仅位于年/国家/产品的分析级别。当添加了 ROLLUP后， 问询会产生一些额外的行：

mysql> SELECT year, country, product, SUM(profit)

    -> FROM sales

    -> GROUP BY year, country, product WITH ROLLUP;

+------+---------+------------+-------------+

| year | country | product    | SUM(profit) |

+------+---------+------------+-------------+

| 2000 | Finland | Computer   |        1500 |

| 2000 | Finland | Phone      |         100 |

| 2000 | Finland | NULL       |        1600 |

| 2000 | India   | Calculator |         150 |

| 2000 | India   | Computer   |        1200 |

| 2000 | India   | NULL       |        1350 |

| 2000 | USA     | Calculator |          75 |

| 2000 | USA     | Computer   |        1500 |

| 2000 | USA     | NULL       |        1575 |

| 2000 | NULL    | NULL       |        4525 |

| 2001 | Finland | Phone      |          10 |

| 2001 | Finland | NULL       |          10 |

| 2001 | USA     | Calculator |          50 |

| 2001 | USA     | Computer   |        2700 |

| 2001 | USA     | TV         |         250 |

| 2001 | USA     | NULL       |        3000 |

| 2001 | NULL    | NULL       |        3010 |

| NULL | NULL    | NULL       |        7535 |

+------+---------+------------+-------------+

对于这个问询， 添加ROLLUP 子句使村输出结果包含了四层分析的简略信息，而不只是一个下面是怎样解释  ROLLUP输出：

• 一组给定的年份和国家的每组产品行后面, 会产生一个额外的总计行， 显示所有产品的总值。这些行将产品列设置为 NULL。
• 一组给定年份的行后面，会产生一个额外的总计行，显示所有国家和产品的总值。这些行将国家和产品列设置为  NULL。
• 最后, 在所有其它行后面，会产生一个额外的总计列，显示所有年份、国家及产品的总值。 这一行将年份、国家和产品列设置为 NULL。

使用ROLLUP 时的其它注意事项

以下各项列出了一些MySQL执行ROLLUP的特殊状态： 

当你使用 ROLLUP时, 你不能同时使用 ORDER BY子句进行结果排序。换言之， ROLLUP 和ORDER BY 是互相排斥的。然而，你仍可以对排序进行一些控制。在 MySQL中， GROUP BY 可以对结果进行排序，而且你可以在GROUP BY列表指定的列中使用明确的 ASC和DESC关键词，从而对个别列进行排序。 (不论如何排序被ROLLUP添加的较高级别的总计行仍出现在它们被计算出的行后面）。

LIMIT可用来限制返回客户端的行数。LIMIT 用在 ROLLUP后面, 因此这个限制 会取消被ROLLUP添加的行。例如:

mysql> SELECT year, country, product, SUM(profit)

    -> FROM sales

    -> GROUP BY year, country, product WITH ROLLUP

    -> LIMIT 5;

+------+---------+------------+-------------+

| year | country | product    | SUM(profit) |

+------+---------+------------+-------------+

| 2000 | Finland | Computer   |        1500 |

| 2000 | Finland | Phone      |         100 |

| 2000 | Finland | NULL       |        1600 |

| 2000 | India   | Calculator |         150 |

| 2000 | India   | Computer   |        1200 |

+------+---------+------------+-------------+

将ROLLUP同 LIMIT一起使用可能会产生更加难以解释的结果，原因是对于理解高聚集行，你所掌握的上下文较少。

在每个高聚集行中的NULL 指示符会在该行被送至客户端时产生。服务器会查看最左边的改变值后面的GROUP BY子句指定的列。对于任何结果集合中的，有一个词匹配这些名字的列, 其值被设为 NULL。(若你使用列数字指定了分组列，则服务器会通过数字确定将哪个列设置为 NULL）。

由于在高聚集行中的 NULL值在问询处理阶段被放入结果集合中，你无法将它们在问询本身中作为NULL值检验。例如，你无法将 HAVING product IS NULL 添加到问询中，从而在输出结果中删去除了高聚集行以外的部分。 

另一方面, NULL值在客户端不以 NULL 的形式出现， 因而可以使用任何MySQL客户端编程接口进行检验。

12.10.3. 具有隐含字段的GROUP BY