分类： Mysql/postgreSQL
2008-05-11 20:06:28
对于比特运算，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比特无符号整数。
返回参数N 中所设置的比特数
mysql> SELECT BIT_COUNT(29);
-> 4
本节介绍了加密和加密值。若你想要储存一些由可能包含任意字节值的加密函数返回的结果，使用BLOB列而不是 CHAR 或VARCHAR 列，从而避免由于结尾空格的删除而改变一些数据值的潜在问题。
这些函数允许使用官方AES进行加密和数据加密 (高级加密标准 ) 算法, 即以前人们所熟知的 “Rijndael”。 保密关键字的长度为128比特，不过你可以通过改变源而将其延长到 256 比特。我们选择了 128比特的原因是它的速度要快得多，且对于大多数用途而言这个保密程度已经够用。
输入参数可以为任何长度。若任何一个参数为NULL,则函数的结果也是NULL。
因为 AES 是块级算法，使用填充将不均衡长度字符串编码，这样结果字符串的长度的算法为 16 * (trunc(string_length / 16) + 1)。
若 AES_DECRYPT()检测到无效数据或不正确填充，它会返回 NULL。然而，若输入的资料或密码无效时， AES_DECRYPT()有可能返回一个非 NULL 值 (可能为无用信息 )。
你可以通过修改你的问询，从而使用AES函数以加密形式来存储数据：
INSERT INTO t VALUES (1,AES_ENCRYPT('text','password'));
AES_ENCRYPT()和AES_DECRYPT() 可以被看作MySQL中普遍通用的密码最安全的加密函数。
使用 pass_str 作为密码，解密加密字符串 crypt_str， crypt_str 应该是由ENCODE()返回的字符串。
使用pass_str 作为密码，解密 str 。 使用DECODE()解密结果。
结果是一个和str长度相同的二进制字符串。若你想要将其保留在一个列中，可使用 BLOB 列类型。
使用DES_ENCRYPT()加密一个字符串。若出现错误，这个函数会返回 NULL。
注意，这个函数只有当MySQL在SSL 的支持下配置完毕时才会运作。请参见5.8.7节，“使用安全连接”.
假如没有给定 key_str 参数， DES_DECRYPT() 会首先检查加密字符串的第一个字节， 从而确定用来加密原始字符串的DES密码关键字数字，之后从DES关键字文件中读取关键字从而解密信息。为使其运行，用户必须享有 SUPER 特权。可以选择--des-key-file服务器指定关键字文件。
假如你向这个函数传递一个key_str 参数，该字符串被用作解密信息的关键字。
若 crypt_str 参数看起来不是一个加密字符串， MySQL 会返回给定的 crypt_str。
用Triple-DES 算法给出的关键字加密字符串。若出现错误，这个函数会返回NULL。
注意，这个函数只有当MySQL 在SSL的支持下配置完毕后才会运行。请参见5.8.7节，“使用安全连接”.
使用的加密关键字的选择基于第二个到 DES_ENCRYPT()的参数，假如给定：
|
参数 |
说明 |
|
无参数 |
使用来自DES关键字文件的第一个关键字。 |
|
key_num |
使用DES 关键字文件给出的关键字数字(0-9)。 |
|
key_str |
使用给出的关键字字符串为 str 加密。 |
选择--des-key-file服务器指定关键字文件。
返回字符串是一个二进制字符串，其中第一个字符为 CHAR(128 | key_num)。
加上 128使得识别加密关键字更加容易。若你使用一个字符串关键字，则 key_num 为127。
结果的字符串长度为 new_len = orig_len + (8-(orig_len % 8))+1。
DES关键字文件中的每一行都具有如下格式：
key_num des_key_str
每个key_num 必须是一个从0到0范围内的数字。文件中行的排列顺序是任意的。 des_key_str 是用来加密信息的字符串。在数字和关键字之间应该至少有一个空格。若你未指定任何到DES_ENCRYPT()的关键字参数，则第一个关键字为默认的使用关键字。
使用FLUSH DES_KEY_FILE语句，你可以让 MySQL从关键字文件读取新的关键字值。这要求你享有 RELOAD特权。
拥有一套默认关键字的一个好处就是它向应用程序提供了一个检验加密列值的方式，而无须向最终用户提供解密这些值的权力。
mysql> SELECT customer_address FROM customer_table
> WHERE crypted_credit_card = DES_ENCRYPT('credit_card_number');
使用Unix crypt() 系统调用加密 str。 salt 参数应为一个至少包含2个字符的字符串。若没有给出 salt 参数，则使用任意值。
mysql> SELECT ENCRYPT('hello');
-> 'VxuFAJXVARROc'
至少在一些系统中，ENCRYPT()除了str的前八位字符之外会忽略所有内容。这个行为由下划线的crypt() 系统调用的执行所决定。
假如crypt()在你的系统中不可用(正如在 Windows系统), ENCRYPT() 则会始终返回NULL。鉴于这个原因，我们向你推荐使用 MD5() 或SHA1() 来代替,因为这两个函数适合所有的平台。
为字符串算出一个 MD5 128比特检查和。该值以32位十六进制数字的二进制字符串的形式返回, 若参数为 NULL 则会返回 NULL。例如，返回值可被用作散列关键字。
mysql> SELECT MD5('testing');
-> 'ae2b1fca515949e5d54fb22b8ed95575'
这是"RSA Data Security, Inc. MD5 Message-Digest Algorithm."
假如你想要将这个值转化为大写字母，参见12.8节，“Cast函数和操作符”中BINARY操作符项中给出的二进制字符串转换。
当PASSWORD()的执行变为改善安全性时，OLD_PASSWORD()会被添加到 MySQL。OLD_PASSWORD()返回从前的PASSWORD()执行值( 4.1之前)，同时允许你为任何4.1 之前的需要连接到你的5.1 版本MySQL服务器前客户端设置密码，从而不至于将它们切断。请参见5.7.9节，“MySQL 4.1中的密码哈希处理”。
从原文密码str 计算并返回密码字符串，当参数为 NULL 时返回 NULL。这个函数用于用户授权表的Password列中的加密MySQL密码存储
mysql> SELECT PASSWORD('badpwd');
-> '7f84554057dd964b'
PASSWORD() 加密是单向的 (不可逆 )。
PASSWORD() 执行密码加密与Unix 密码被加密的方式不同。请参见ENCRYPT()。
注释： PASSWORD()函数在MySQL服务器中的鉴定系统使用；你不应将它用在你个人的应用程序中。为达到同样目的，可使用 MD5()或SHA1() 代替。 更多关于在您的应用程序中处理密码及安全鉴定的信息见RFC 2195
为字符串算出一个 SHA1 160比特检查和，如RFC 3174 (安全散列算法 )中所述。该值被作为40位十六进制数字返回，而当参数为NULL 时则返回 NULL。这个函数的一个可能的用处就在于其作为散列关键字。你也可以将其作为存储密码的密码安全函数使用。
mysql> SELECT SHA1('abc');
-> 'a9993e364706816aba3e25717850c26c9cd0d89d'
SHA1()可以被视为一个密码更加安全的函数，相当于 MD5()。 SHA() 和SHA1()具有相同的意义。
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);
-> 0mysql> SELECT COERCIBILITY(USER());
-> 3mysql> SELECT COERCIBILITY('abc');
-> 4
返回值具有如下意义：
|
可压缩性 |
意义 |
举例 |
|
0 |
明确排序 |
带有COLLATE 子句的值 |
|
1 |
无排序 |
不同排序的字符串连接 |
|
2 |
明确排序 |
列值 |
|
3 |
系统常量 |
USER()返回值 |
|
4 |
可压缩 |
文字字符串 |
|
5 |
可忽略 |
NULL得来的NULL或一个表达式 |
下方值得优先级较高。
返回惠字符串参数的排序方式。
mysql> SELECT COLLATION('abc');
-> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc');
-> 'utf8_general_ci'
返回对于连接的连接ID (线程ID)。每个连接都有各自的唯一 ID。
mysql> SELECT CONNECTION_ID();
-> 23786
返回当前话路被验证的用户名和主机名组合。这个值符合确定你的存取权限的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字符集。
返回使用 utf8 字符集的默认(当前)数据库名。在存储程序里，默认数据库是同该程序向关联的数据库，但并不一定与调用语境的默认数据库相同。
mysql> SELECT DATABASE();
-> 'test'
若没有默认数据库, DATABASE()返回 NULL。
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 一同使用的条件是：
自动返回最后一个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 changedmysql> 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()返回被前面语句升级的、插入的或删除的行数。 这个行数和 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 秒)
这个函数和 DATABASE()具有相同的意义。
SESSION_USER()和 USER()具有相同的意义。
SYSTEM_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'
返回指示 MySQL 服务器版本的字符串。这个字符串使用 utf8 字符集。
mysql> SELECT VERSION();
-> '5.1.2-alpha-standard'
注意，假如你的版本字符串以-log结尾，这说明登录已被激活。
返回一个表列的默认值。若该列没有默认值则会产生错误。
mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
将数字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'
设法使用字符串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()调用解开。
给出一个作为字符串的网络地址的点地址表示，返回一个代表该地址数值的整数。地址可以是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节，“数值类型”。
给定一个数字网络地址 (4 或 8 比特),返回作为字符串的该地址的电地址表示。
mysql> SELECT INET_NTOA(3520061480);
-> '209.207.224.40'
检查名为str的锁是否可以使用 (换言之,没有被封锁)。若锁可以使用，则返回 1 (没有人在用这个锁), 若这个锁正在被使用，则返回0 ，出现错误则返回 NULL (诸如不正确的参数 )。
检查名为str的锁是否正在被使用(换言之,被封锁)。若被封锁，则返回使用该锁的客户端的连接标识符。否则返回 NULL。
该函数对于控制主从同步很有用处。它会持续封锁，直到从设备阅读和应用主机记录中所有补充资料到指定的位置。返回值是其为到达指定位置而必须等待的记录事件的数目。若从设备SQL线程没有被启动、从设备主机信息尚未初始化、参数不正确或出现任何错误，则该函数返回 NULL。若超时时间被超过，则返回-1。若在MASTER_POS_WAIT() 等待期间，从设备SQL线程中止，则该函数返回 NULL。若从设备由指定位置通过，则函数会立即返回结果。
假如已经指定了一个超时时间值，当 超时时间 秒数经过后MASTER_POS_WAIT()会停止等待。超时时间 必须大于 0；一个为零或为负值的 超时时间 表示没有超市时间。
返回给定值。 当用来产生一个结果集合列时, NAME_CONST()促使该列使用给定名称。
mysql> SELECT NAME_CONST('myname', 14);
+--------+
| myname |
+--------+
| 14 |
+--------+
这个函数被添加进 MySQL 5.0.12。它只做内部使用。 服务器在书写来自包含局部程序变量的存储程序的语句时会用到它，详见20.4节，“存储子程序和触发程序的二进制日志功能”。你可能会在mysqlbinlog 的书橱中看到这个函数。
解开被GET_LOCK()获取的，用字符串str 所命名的锁。若锁被解开，则返回 1，若改线程尚未创建锁，则返回0 (此时锁没有被解开 ), 若命名的锁不存在，则返回 NULL。若该锁从未被对GET_LOCK()的调用获取，或锁已经被提前解开，则该锁不存在。
DO 语句和RELEASE_LOCK()同时使用很方便。请参见13.2.2节，“DO语法”。
睡眠(暂停) 时间为duration 参数给定的秒数，然后返回 0。若 SLEEP() 被中断,它会返回 1。 duration 或许或包括一个给定的以微秒为单位的分数部分。
返回一个通用唯一标识符(UUID) ，其产生的根据是《DCE 1.1: 远程过程调用》 (附录A) CAE (公共应用软件环境) 的说明，该作品于1997年10月由 The Open Group 出版 (文件编号 C706, ).
UUID被设计成一个在时间和空间上都独一无二的数字。2个对UUID() 的调用应产生2个不同的值，即使这些调用的执行是在两个互不相连的单独电脑上进行。
UUID 是一个由5位十六进制数的字符串表示的128比特数字 ，其格式为 aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee ：
目前,一个界面的 MAC 地址尽被FreeBSD 和 Linux考虑到。在其它操作系统中, MySQL使用随机产生的 48比特数字。
mysql> SELECT UUID();
-> '6ccd780c-baba-1026-9564-0040f4311e29'
注意， UUID() 不支持复制功能。
在一个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);
本章论述了用于一组数值操作的 group (集合)函数。除非另作说明， group 函数会忽略 NULL 值。
假如你在一个不包含 ROUP BY子句的语句中使用一个 group函数 ，它相当于对所有行进行分组。
返回expr 的平均值。 DISTINCT 选项可用于返回 expr的不同值的平均值。
若找不到匹配的行，则AVG()返回 NULL 。
mysql> SELECT student_name, AVG(test_score)
-> FROM student
-> GROUP BY student_name;
返回expr中所有比特的 bitwise AND 。计算执行的精确度为64比特(BIGINT) 。
若找不到匹配的行，则这个函数返回 18446744073709551615 。(这是无符号 BIGINT 值，所有比特被设置为 1）。
返回expr 中所有比特的bitwise OR。计算执行的精确度为64比特(BIGINT) 。
若找不到匹配的行，则函数返回 0 。
返回expr 中所有比特的bitwise XOR。计算执行的精确度为64比特(BIGINT) 。
若找不到匹配的行，则函数返回 0 。
返回SELECT语句检索到的行中非NULL值的数目。
若找不到匹配的行，则COUNT() 返回 0 。
mysql> SELECT student.student_name,COUNT(*)
-> FROM student,course
-> WHERE student.student_id=course.student_id
-> GROUP BY student_name;
COUNT(*) 的稍微不同之处在于，它返回检索行的数目， 不论其是否包含 NULL值。
SELECT 从一个表中检索，而不检索其它的列，并且没有 WHERE子句时， COUNT(*)被优化到最快的返回速度。例如：
mysql> SELECT COUNT(*) FROM student;
这个优化仅适用于 MyISAM表, 原因是这些表类型会储存一个函数返回记录的精确数量，而且非常容易访问。对于事务型的存储引擎(InnoDB, BDB), 存储一个精确行数的问题比较多，原因是可能会发生多重事物处理, 而每个都可能会对行数产生影响。
返回不同的非NULL值数目。
若找不到匹配的项，则COUNT(DISTINCT)返回 0 。
mysql> SELECT COUNT(DISTINCT results) FROM student;
在MySQL中, 你通过给定一个表达式列表而获取不包含NULL 不同表达式组合的数目。在标准 SQL中,你将必须在COUNT(DISTINCT ...)中连接所有表达式。
该函数返回带有来自一个组的连接的非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;
Or:
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子句。若要按相反顺序排列，将 DESC (递减) 关键词添加到你要用ORDER BY 子句进行排序的列名称中。默认顺序为升序；可使用ASC将其明确指定。 SEPARATOR 后面跟随应该被插入结果的值中间的字符串值。默认为逗号 (‘,’)。通过指定SEPARATOR '' ，你可以删除所有分隔符。
使用group_concat_max_len系统变量，你可以设置允许的最大长度。 程序中进行这项操作的语法如下，其中 val 是一个无符号整数：
SET [SESSION | GLOBAL] group_concat_max_len = val;
若已经设置了最大长度， 则结果被截至这个最大长度。
返回expr 的最小值和最大值。 MIN() 和 MAX() 的取值可以是一个字符串参数；在这些情况下， 它们返回最小或最大字符串值。请参见7.4.5节，“MySQL如何使用索引”。 DISTINCT关键词可以被用来查找expr 的不同值的最小或最大值，然而，这产生的结果与省略DISTINCT 的结果相同。
若找不到匹配的行，MIN()和MAX()返回 NULL 。
mysql> SELECT student_name, MIN(test_score), MAX(test_score)
-> FROM student
-> GROUP BY student_name;
对于MIN()、 MAX()和其它集合函数， MySQL当前按照它们的字符串值而非字符串在集合中的相关位置比较 ENUM和 SET 列。这同ORDER BY比较二者的方式有所不同。这一点应该在MySQL的未来版本中得到改善。
返回expr 的总体标准偏差。这是标准 SQL 的延伸。这个函数的STDDEV() 形式用来提供和Oracle 的兼容性。可使用标准SQL函数 STDDEV_POP() 进行代替。
若找不到匹配的行，则这些函数返回 NULL 。
返回expr 的总体标准偏差(VAR_POP()的平方根)。你也可以使用 STD() 或STDDEV(), 它们具有相同的意义，然而不是标准的 SQL。
若找不到匹配的行，则STDDEV_POP()返回 NULL。
返回expr 的样本标准差 ( VAR_SAMP()的平方根)。
若找不到匹配的行，则STDDEV_SAMP() 返回 NULL 。
返回expr 的总数。 若返回集合中无任何行，则 SUM() 返回NULL。DISTINCT 关键词可用于 MySQL 5.1 中，求得expr 不同值的总和。
若找不到匹配的行，则SUM()返回 NULL。
返回expr 总体标准方差。它将行视为总体，而不是一个样本， 所以它将行数作为分母。你也可以使用 VARIANCE(),它具有相同的意义然而不是 标准的 SQL。
若找不到匹配的项，则VAR_POP()返回NULL。
返回expr 的样本方差。更确切的说，分母的数字是行数减去1。
若找不到匹配的行，则VAR_SAMP()返回NULL。
返回expr 的总体标准方差。这是标准SQL 的延伸。可使用标准SQL 函数 VAR_POP() 进行代替。
若找不到匹配的项，则VARIANCE()返回NULL。
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输出：
使用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客户端编程接口进行检验。
MySQL 扩展了 GROUP BY的用途，因此你可以使用SELECT 列表中不出现在GROUP BY语句中的列或运算。这代表 “对该组的任何可能值 ”。你可以通过避免排序和对不必要项分组的办法得到它更好的性能。例如，在下列问询中，你无须对customer.name 进行分组：
mysql> SELECT order.custid, customer.name, MAX(payments)
-> FROM order,customer
-> WHERE order.custid = customer.custid
-> GROUP BY order.custid;
在标准SQL中, 你必须将 customer.name添加到 GROUP BY子句中。在MySQL中, 假如你不在ANSI模式中运行，则这个名字就是多余的。
假如你从 GROUP BY 部分省略的列在该组中不是唯一的，那么不要使用这个功能! 你会得到非预测性结果。
在有些情况下,你可以使用MIN()和MAX() 获取一个特殊的列值，即使他不是唯一的。下面给出了来自包含排序列中最小值的列中的值：
SUBSTR(MIN(CONCAT(RPAD(sort,6,' '),column)),7)
注意，假如你正在尝试遵循标准 SQL, 你不能使用GROUP BY或 ORDER BY子句中的表达式。你可以通过使用表达式的别名绕过这一限制：
mysql> SELECT id,FLOOR(value/100) AS val
-> FROM tbl_name
-> GROUP BY id, val ORDER BY val;
然而, MySQL允许你使用GROUP BY 及 ORDER BY 子句中的表达式。例如：
mysql> SELECT id, FLOOR(value/100) FROM tbl_name ORDER BY RAND();这是MySQL参考手册的翻译版本，关于MySQL参考手册，请访问dev.mysql.com。 原始参考手册为英文版，与英文版参考手册相比，本翻译版可能不是最新的。