mysql5.5手册读书日记(2)

<?php



/* 

 *

 * MySQL_5.5中文参考手册 485开始

 * 

 * 





mysql> SELECT CASE 1 WHEN 1 THEN 'one'

-> WHEN 2 THEN 'two' ELSE 'more' END;

-> 'one'

mysql> SELECT CASE WHEN 1>0 THEN 'true' ELSE 'false' END;

-> 'true'

mysql> SELECT CASE BINARY 'B'

-> WHEN 'a' THEN 1 WHEN 'b' THEN 2 END;

-> NULL





mysql> SELECT IF(1>2,2,3);

-> 3

mysql> SELECT IF(1<2,'yes ','no');

-> 'yes'

mysql> SELECT IF(STRCMP('test','test1'),'no','yes');

-> 'no'





STRCMP比较字符串大小

mysql> SELECT STRCMP('Abc','abc'), STRCMP('abc','abc'), STRCMP('abc','Abc');

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

| STRCMP('Abc','abc') | STRCMP('abc','abc') | STRCMP('abc','Abc') |

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

|                   0 |                   0 |                   0 |

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



mysql> SELECT IFNULL(1,0);

-> 1

mysql> SELECT IFNULL(NULL,10);

-> 10

mysql> SELECT IFNULL(1/0,10);

-> 10

mysql> SELECT IFNULL(1/0,'yes');

-> 'yes'



mysql> SELECT NULLIF(1,1);

-> NULL

mysql> SELECT NULLIF(1,2);

-> 1



字符串函数



mysql> SELECT ASCII('2');

-> 50

mysql> SELECT ASCII(2);

-> 50

mysql> SELECT ASCII('dx');

-> 100



mysql> SELECT BIN(12);

-> '1100'





mysql> SELECT BIT_LENGTH('text');

-> 32



mysql> SELECT CHAR(77,121,83,81,'76');

-> 'MySQL'

mysql> SELECT CHAR(77,77.3,'77.3');

-> 'MMM'



mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));

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

| HEX(CHAR(1,0)) | HEX(CHAR(256)) |

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

| 0100 | 0100 |

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

mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));

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

| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |

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

| 010000 | 010000 |

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





mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));

mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));

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

| CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |

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

| binary | utf8 |

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







mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000)));

-> 21

mysql> SELECT LENGTH(COMPRESS(''));

-> 0

mysql> SELECT LENGTH(COMPRESS('a'));

-> 13

mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16)));

-> 15



COMPRESS压缩函数，压缩一个字符串。这个函数要求 MySQL已经用一个诸如zlib的压缩库压缩过。 

否则，返回值始终是NULL。UNCOMPRESS() 可将压缩过的字符串进行解压缩。 



mysql> select REPEAT('a',5);

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

| REPEAT('a',5) |

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

| aaaaa         |

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





mysql> SELECT CONCAT('My', 'S', 'QL');

-> 'MySQL'

mysql> SELECT CONCAT('My', NULL, 'QL');

-> NULL

mysql> SELECT CONCAT(14.3);

-> '14.3'



mysql> select length('ssssssssssssssssss');

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

| length('ssssssssssssssssss') |

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

|                           18 |

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



CONCAT_WS() 代表 CONCAT With Separator ，是CONCAT()的特殊形式。第一个参数是其它参数的分隔

符。分隔符的位置放在要连接的两个字符串之间。分隔符可以是一个字符串，也可以是其它参数。如果分隔符

为 NULL，则结果为 NULL。函数会忽略任何分隔符参数后的 NULL 值。

CONCAT_WS()不会忽略任何空字符串。 (然而会忽略所有的 NULL）。





mysql> SELECT CONCAT_WS(',','First name','Second name','Last Name');

-> 'First name,Second name,Last Name'

mysql> SELECT CONCAT_WS(',','First name',NULL,'Last Name');

-> 'First name,Last Name'





CONV(N,from_base,to_base)

不同数基间转换数字。返回值为数字的N字符串表示，由from_base基转化为to_base 基。如有任意一个参数

为NULL，则返回值为 NULL。自变量N 被理解为一个整数，但是可以被指定为一个整数或字符串。最小基数

为 2 ，而最大基数则为 36。 If to_base 是一个负数，则 N 被看作一个带符号数。否则， N 被看作无符号

数。 CONV() 的运行精确度为 64比特。

mysql> SELECT CONV('a',16,2);

-> '1010'

mysql> SELECT CONV('6E',18,8);

-> '172'

mysql> SELECT CONV(-17,10,-18);

-> '-H'

mysql> SELECT CONV(10+'10'+'10'+0xa,10,10);

-> '40'



ELT(N,str1,str2,str3,...)

若N = 1，则返回值为str1 ，若N = 2，则返回值为str2 ，以此类推。 若N 小于1或大于参数的数目，则返

回值为 NULL 。ELT() 是 FIELD()的补数。

mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');

-> 'ej'

mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');

-> 'foo'



EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

返回值为一个字符串，其中对于bits值中的每个位组，可以得到一个on 字符串，而对于每个清零比特位，可以

得到一个off 字符串。bits 中的比特值按照从右到左的顺序接受检验 (由低位比特到高位比特)。字符串被分隔

字符串分开(默认为逗号‘,’)，按照从左到右的顺序被添加到结果中。number_of_bits 会给出被检验的二进制位

数 (默认为 64)。

mysql> SELECT EXPORT_SET(5,'Y','N',',',4);

-> 'Y,N,Y,N'

5 101   0101 4位长度，比对是从右到左

        YNYN



mysql> SELECT EXPORT_SET(6,'1','0',',',10);

-> '0,1,1,0,0,0,0,0,0,0'





5是二进制101 ， 6是110，位数不足的在前面加0，比对是从右到左，0就是off值，1就是on的值













FIELD(str,str1,str2,str3,...)

返回值为str1, str2, str3,……列表中的str 指数。在找不到str 的情况下，返回值为 0 。

如果所有对于FIELD() 的参数均为字符串，则所有参数均按照字符串进行比较。如果所有的参数均为数字，则

按照数字进行比较。否则，参数按照双倍进行比较。



如果str 为NULL，则返回值为0 ，原因是NULL不能同任何值进行同等比较。FIELD() 是ELT()的补数。

mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');

-> 2

mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');

-> 0

FIND_IN_SET(str,strlist)

假如字符串str 在由N 子链组成的字符串列表strlist 中， 则返回值的范围在 1 到N 之间 。一个字符串列表就

是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type

SET列，则 FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或strlist 为空字符串，则返回值

为 0 。如任意一个参数为NULL，则返回值为 NULL。这个函数在第一个参数包含一个逗号(‘,’)时将无法正常运

行。

mysql> SELECT FIND_IN_SET('b','a,b,c,d');

-> 2

FORMAT(X,D)

将number X设置为格式 '#,###,###.##', 以四舍五入的方式保留到小数点后D位, 而返回结果为一个字符

串。详见12.9.4节，“其他函数”.

HEX(N_or_S)

如果N_OR_S 是一个数字，则返回一个 十六进制值 N 的字符串表示，在这里， N 是一个longlong

(BIGINT)数。这相当于 CONV(N,10,16)。

如果N_OR_S 是一个字符串，则返回值为一个N_OR_S的十六进制字符串表示， 其中每个N_OR_S 里的每个字

符被转化为两个十六进制数字。

mysql> SELECT HEX(255);

-> 'FF'

mysql> SELECT 0x616263;

-> 'abc'

mysql> SELECT HEX('abc');

-> 616263

INSERT(str,pos,len,newstr)

返回字符串str, 其子字符串起始于pos 位置和长期被字符串 newstr取代的len 字符。 如果pos 超过字符串长

度，则返回值为原始字符串。假如len的长度大于其它字符串的长度，则从位置pos开始替换。若任何一个参

数为null，则返回值为NULL。

mysql> SELECT INSERT('Quadratic', 3, 4, 'What');

-> 'QuWhattic'



mysql> SELECT INSERT('Quadratic', -1, 4, 'What');

-> 'Quadratic'

mysql> SELECT INSERT('Quadratic', 3, 100, 'What');

-> 'QuWhat'

这个函数支持多字节字元。

INSTR(str,substr)

返回字符串str 中子字符串的第一个出现位置。这和LOCATE()的双参数形式相同，除非参数的顺序被颠倒。

mysql> SELECT INSTR('foobarbar', 'bar');

-> 4

mysql> SELECT INSTR('xbar', 'foobar');

-> 0

这个函数支持多字节字元，并且只有当至少有一个参数是二进制字符串时区分大小写。

LCASE(str)

LCASE() 是 LOWER()的同义词。

LEFT(str,len)

返回从字符串str 开始的len 最左字符。

mysql> SELECT LEFT('foobarbar', 5);

-> 'fooba'

LENGTH(str)

返回值为字符串str 的长度，单位为字节。一个多字节字符算作多字节。这意味着 对于一个包含5个2字节字符

的字符串， LENGTH() 的返回值为10, 而 CHAR_LENGTH()的返回值则为5。

mysql> SELECT LENGTH('text');

-> 4

LOAD_FILE(file_name)

读取文件并将这一文件按照字符串的格式返回。文件的位置必须在服务器上,你必须为文件制定路径全名，而

且你还必须拥有FILE 特许权。文件必须可读取，文件容量必须小于 max_allowed_packet字节。

若文件不存在，或因不满足上述条件而不能被读取， 则函数返回值为 NULL。

mysql> UPDATE tbl_name

SET blob_column=LOAD_FILE('/tmp/picture')

WHERE id=1;



LOCATE(substr,str) , LOCATE(substr,str,pos)

第一个语法返回字符串str中子字符串substr的第一个出现位置。第二个语法返回字符串str中子字符

串substr的第一个出现位置, 起始位置在pos。如若substr 不在str中，则返回值为0。

mysql> SELECT LOCATE('bar', 'foobarbar');

-> 4

mysql> SELECT LOCATE('xbar', 'foobar');

-> 0

mysql> SELECT LOCATE('bar', 'foobarbar',5);

-> 7

这个函数支持多字节字元，并且只有当至少有一个参数是二进制字符串时区分大小写。

LOWER(str)

返回字符串str 以及所有根据最新的字符集映射表变为小写字母的字符 (默认为 cp1252 Latin1)。

mysql> SELECT LOWER('QUADRATICALLY');

-> 'quadratically'

这个函数支持多字节字元。

LPAD(str,len,padstr)

返回字符串str, 其左边由字符串padstr 填补到len 字符长度。假如str 的长度大于len, 则返回值被缩短至len 字

符。

mysql> SELECT LPAD('hi',4,'??');

-> '??hi'

mysql> SELECT LPAD('hi',1,'??');

-> 'h'

LTRIM(str)

返回字符串str ，其引导空格字符被删除。

mysql> SELECT LTRIM(' barbar');

-> 'barbar'

这个函数支持多字节字元。

MAKE_SET(bits,str1,str2,...)

返回一个设定值 (一个包含被‘,’号分开的字字符串的字符串) ，由在bits 组中具有相应的比特的字符串组

成。str1 对应比特 0, str2 对应比特1,以此类推。str1, str2, ...中的 NULL值不会被添加到结果中。

mysql> SELECT MAKE_SET(1,'a','b','c');



-> 'a'

mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');

-> 'hello,world'

mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');

-> 'hello'

mysql> SELECT MAKE_SET(0,'a','b','c');

-> ''

MID(str,pos,len)

MID(str,pos,len) 是 SUBSTRING(str,pos,len)的同义词。

OCT(N)

返回一个N的八进制值的字符串表示，其中N 是一个longlong (BIGINT)数。这等同于CONV(N,10,8)。若N 为

NULL ，则返回值为NULL。

mysql> SELECT OCT(12);

-> '14'

OCTET_LENGTH(str)

OCTET_LENGTH() 是 LENGTH()的同义词。

ORD(str)

若字符串str 的最左字符是一个多字节字符，则返回该字符的代码， 代码的计算通过使用以下公式计算其组成

字节的数值而得出:

(1st byte code)

+ (2nd byte code × 256)

+ (3rd byte code × 2562) ...

假如最左字符不是一个多字节字符，那么 ORD()和函数ASCII()返回相同的值。

mysql> SELECT ORD('2');

-> 50

POSITION(substr IN str)

POSITION(substr IN str)是 LOCATE(substr,str)同义词。

QUOTE(str)

引证一个字符串，由此产生一个在SQL语句中可用作完全转义数据值的结果。返回的字符串由单引号标注，

每例都带有单引号 (‘'’)、反斜线符号 (‘\’)、 ASCII NUL以及前面有反斜线符号的Control-Z 。如果自变量的值



为NULL, 则返回不带单引号的单词 “NULL”。

mysql> SELECT QUOTE('Don\'t!');

-> 'Don\'t!'

mysql> SELECT QUOTE(NULL);

-> NULL

REPEAT(str,count)

返回一个由重复的字符串str 组成的字符串，字符串str的数目等于count 。 若 count <= 0,则返回一个空字符

串。若str 或 count 为 NULL，则返回 NULL 。

mysql> SELECT REPEAT('MySQL', 3);

-> 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str)

返回字符串str 以及所有被字符串to_str替代的字符串from_str 。

mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');

-> 'WwWwWw.mysql.com'

这个函数支持多字节字元。

REVERSE(str)

返回字符串str ，顺序和字符顺序相反。

mysql> SELECT REVERSE('abc');

-> 'cba'

这个函数支持多字节字元。

RIGHT(str,len)

从字符串str 开始，返回最右len 字符。

mysql> SELECT RIGHT('foobarbar', 4);

-> 'rbar'

这个函数支持多字节字元。

RPAD(str,len,padstr)

返回字符串str, 其右边被字符串padstr填补至len 字符长度。假如字符串str 的长度大于 len,则返回值被缩短到

与len 字符相同长度。

mysql> SELECT RPAD('hi',5,'?');

-> 'hi???'



mysql> SELECT RPAD('hi',1,'?');

-> 'h'

这个函数支持多字节字元。

RTRIM(str)

返回字符串str ，结尾空格字符被删去。

mysql> SELECT RTRIM('barbar ');

-> 'barbar'

这个函数支持多字节字元。

SOUNDEX(str)

从str返回一个soundex字符串。两个具有几乎同样探测的字符串应该具有同样的 soundex 字符串。一个标准

的soundex 字符串的长度为4个字符，然而SOUNDEX() 函数会返回一个人以长度的字符串。可使用结果中

的SUBSTRING() 来得到一个标准 soundex 字符串。在str中，会忽略所有未按照字母顺序排列的字符。所有不

在A-Z范围之内的国际字母符号被视为元音字母。

mysql> SELECT SOUNDEX('Hello');

-> 'H400'

mysql> SELECT SOUNDEX('Quadratically');

-> 'Q36324'

注意：这个函数执行原始的Soundex算法，而非更加流行的加强版本(如D. Knuth所述)。其区别在于原始版本

首先会删去元音，其次是重复，而加强版则首先删去重复，而后删去元音。

expr1 SOUNDS LIKE expr2

这相当于SOUNDEX(expr1) = SOUNDEX(expr2)。

SPACE(N)

返回一个由N 间隔符号组成的字符串。

mysql> SELECT SPACE(6);

-> ' '

SUBSTRING(str,pos) , SUBSTRING(str FROM pos) SUBSTRING(str,pos,len) , SUBSTRING(str FROM

pos FOR len)

不带有len 参数的格式从字符串str返回一个子字符串，起始于位置pos。带有len参数的格式从字符串str返回一

个长度同len字符相同的子字符串，起始于位置pos。使用 FROM的格式为标准 SQL 语法。也可能对pos使用

一个负值。假若这样，则子字符串的位置起始于字符串结尾的pos 字符，而不是字符串的开头位置。在以下格

式的函数中可以对pos 使用一个负值。

mysql> SELECT SUBSTRING('Quadratically',5);

-> 'ratically'



mysql> SELECT SUBSTRING('foobarbar' FROM 4);

-> 'barbar'

mysql> SELECT SUBSTRING('Quadratically',5,6);

-> 'ratica'

mysql> SELECT SUBSTRING('Sakila', -3);

-> 'ila'

mysql> SELECT SUBSTRING('Sakila', -5, 3);

-> 'aki'

mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);

-> 'ki'

这个函数支持多字节字元。

注意，如果对len使用的是一个小于1的值，则结果始终为空字符串。

SUBSTR()是 SUBSTRING()的同义词。

SUBSTRING_INDEX(str,delim,count)

在定界符delim 以及count 出现前，从字符串str返回自字符串。若count为正值,则返回最终定界符(从左边开

始)左边的一切内容。若count为负值，则返回定界符（从右边开始）右边的一切内容。

mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);

-> 'www.mysql'

mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);

-> 'mysql.com'

这个函数支持多字节字元。

TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str) TRIM(remstr FROM] str)

返回字符串str ， 其中所有remstr 前缀和/或后缀都已被删除。若分类符BOTH、LEADIN或TRAILING中没有一

个是给定的,则假设为BOTH 。remstr 为可选项，在未指定情况下，可删除空格。

mysql> SELECT TRIM(' bar ');

-> 'bar'

mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');

-> 'barxxx'

mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');

-> 'bar'



mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');

-> 'barx'

这个函数支持多字节字元。

UCASE(str)

UCASE()是UPPER()的同义词。

UNCOMPRESS(string_to_uncompress)

对经COMPRESS()函数压缩后的字符串进行解压缩。若参数为压缩值，则结果为 NULL。这个函数要求 MySQL

已被诸如zlib 之类的压缩库编译过。否则, 返回值将始终是 NULL。

mysql> SELECT UNCOMPRESS(COMPRESS('any string'));

-> 'any string'

mysql> SELECT UNCOMPRESS('any string');

-> NULL

UNCOMPRESSED_LENGTH(compressed_string)

返回压缩字符串压缩前的长度。

mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));

-> 30

UNHEX(str)

执行从HEX(str)的反向操作。就是说，它将参数中的每一对十六进制数字理解为一个数字，并将其转化为该数

字代表的字符。结果字符以二进制字符串的形式返回。

mysql> SELECT UNHEX('4D7953514C');

-> 'MySQL'

mysql> SELECT 0x4D7953514C;

-> 'MySQL'

mysql> SELECT UNHEX(HEX('string'));

-> 'string'

mysql> SELECT HEX(UNHEX('1267'));

-> '1267'

UPPER(str)

返回字符串str， 以及根据最新字符集映射转化为大写字母的字符 (默认为cp1252 Latin1).

mysql> SELECT UPPER('Hej');

-> 'HEJ'

该函数支持多字节字元。



















字符串比较函数

根据，MySQL 会自动将数字转化为字符串，反之亦然。

mysql> SELECT 1+'1';

-> 2

mysql> SELECT CONCAT(2,' test');

-> '2 test'

若想要将数字明确地转化为字符串，可使用 CAST()或 CONCAT()函数：

mysql> SELECT 38.8, CAST(38.8 AS CHAR);

-> 38.8, '38.8'

mysql> SELECT 38.8, CONCAT(38.8);

-> 38.8, '38.8'

CAST() 比较可取。.

若已经对一个字符串函数给定一个二进制字符串作为参数， 则所得到的结果字符串也是一个二进制字符串。一

个转化为字符串的数字被作为二进制字符串对待。这仅会对比较结果产生影响。

一般而言, 若字符串比较中任意一个表达式是区分大小写的，则执行比较时也区分大小写。

expr LIKE pat [ESCAPE 'escape-char']

模式匹配，使用SQL简单正规表达式比较。返回1 (TRUE) 或 0 (FALSE)。若 expr 或 pat 中任何一个为

NULL,则结果为 NULL。

模式不需要为文字字符串。例如，可以被指定为一个字符串表达式或表列。

在模式中可以同LIKE一起使用以下两种通配符：

字符说明

% 匹配任何数目的字符，甚至包括零字符

_ 只能匹配一种字符

mysql> SELECT 'David!' LIKE 'David_';

-> 1

mysql> SELECT 'David!' LIKE '%D%v%';

-> 1

若要对通配符的文字实例进行检验, 可将转义字符放在该字符前面。如果没有指定 ESCAPE字符, 则假设为‘\’。



字符串说明

\% 匹配一个

‘%’字符

\_ 匹配一个 ‘_’

字符

mysql> SELECT 'David!' LIKE 'David\_';

-> 0

mysql> SELECT 'David_' LIKE 'David\_';

-> 1

要指定一个不同的转义字符,可使用ESCAPE语句：

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';

-> 1

转义序列可以为空，也可以是一个字符的长度。从 MySQL 5.1.2开始, 如若NO_BACKSLASH_ESCAPES SQL模

式被激活, 则该序列不能为空。

以下两个语句举例说明了字符串比较不区分大小写，除非其中一个操作数为二进制字符串：

mysql> SELECT 'abc' LIKE 'ABC';

-> 1

mysql> SELECT 'abc' LIKE BINARY 'ABC';

-> 0

在MySQL中, LIKE 允许出现在数字表达式中。 (这是标准SQL LIKE 的延伸）。

mysql> SELECT 10 LIKE '1%';

-> 1

注释： 由于 MySQL在字符串中使用 C转义语法(例如, 用‘\n’代表一个换行字符)，在LIKE字符串中，必须将用

到的‘\’双写。例如， 若要查找 ‘\n’, 必须将其写成 ‘\\n’。而若要查找 ‘\’, 则必须将其写成 it as ‘\\\\’;原因是反

斜线符号会被语法分析程序剥离一次，在进行模式匹配时，又会被剥离一次，最后会剩下一个反斜线符号接受

匹配。

expr NOT LIKE pat [ESCAPE 'escape-char']

这相当于 NOT (expr LIKE pat [ESCAPE 'escape-char'])。

expr NOT REGEXP pat expr NOT RLIKE pat

这相当于NOT (expr REGEXP pat)。

expr REGEXP pat expr RLIKE pat

执行字符串表达式expr 和模式pat 的模式匹配。该模式可以被延伸为正规表达式。正规表达式的语法在附



录G：MySQL正则表达式中有详细讨论。若expr 匹配 pat，则返回 1; 否则返回0。若expr 或 pat 任意一个为

NULL, 则结果为 NULL。 RLIKE 是REGEXP的同义词, 作用是为mSQL 提供兼容性。

模式不需要为文字字符串。例如,可以被指定为一个字符串表达式或表列。

注释：由于在字符串中， MySQL使用 C 转义语法 (例如, 用‘\n’来代表换行字符 ),在REGEXP字符串中必须将用

到的‘\’ 双写。

REGEXP 不区分大小写, 除非将其同二进制字符串同时使用。

mysql> SELECT 'Monty!' REGEXP 'm%y%%';

-> 0

mysql> SELECT 'Monty!' REGEXP '.*';

-> 1

mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';

-> 1

mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';

-> 1 0

mysql> SELECT 'a' REGEXP '^[a-d]';

-> 1

在确定字符类型时，REGEXP 和 RLIKE 使用当前字符集 (默认为cp1252 Latin1 )。警告：这些操作符不支持多

字节字元。

STRCMP(expr1,expr2)

若所有的字符串均相同，则返回STRCMP()，若根据当前分类次序，第一个参数小于第二个，则返回 -1，其它

情况返回 1 。

mysql> SELECT STRCMP('text', 'text2');

-> -1

mysql> SELECT STRCMP('text2', 'text');

-> 1

mysql> SELECT STRCMP('text', 'text');

-> 0

在执行比较时，STRCMP() 使用当前字符集。这使得默认的比较区分大小写，当操作数中的一个或两个都是二

进制字符串时除外



















数学函数

若发生错误，所有数学函数会返回 NULL 。

ABS(X)

返回X 的绝对值。

mysql> SELECT ABS(2);

-> 2

mysql> SELECT ABS(-32);

-> 32

该函数支持使用BIGINT值。

ACOS(X)

返回X 反余弦, 即, 余弦是X的值。若X 不在-1到 1的范围之内，则返回NULL 。

mysql> SELECT ACOS(1);

-> 0

mysql> SELECT ACOS(1.0001);

-> NULL

mysql> SELECT ACOS(0);

-> 1.5707963267949

ASIN(X)



返回X 的反正弦，即，正弦为X 的值。若X 若X 不在-1到 1的范围之内，则返回 NULL 。

mysql> SELECT ASIN(0.2);

-> 0.20135792079033

mysql> SELECT ASIN('foo');

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

| ASIN('foo') |

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

| 0 |

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

1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;

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

| Level | Code | Message |

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

| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |

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

ATAN(X)

返回X 的反正切，即，正切为X 的值。

mysql> SELECT ATAN(2);

-> 1.1071487177941

mysql> SELECT ATAN(-2);

-> -1.1071487177941

ATAN(Y,X) , ATAN2(Y,X)

返回两个变量X 及Y的反正切。它类似于 Y 或 X的反正切计算, 除非两个参数的符号均用于确定结果所在象

限。

mysql> SELECT ATAN(-2,2);

-> -0.78539816339745

mysql> SELECT ATAN2(PI(),0);

-> 1.5707963267949

CEILING(X) CEIL(X)

返回不小于X 的最小整数值。



mysql> SELECT CEILING(1.23);

-> 2

mysql> SELECT CEIL(-1.23);

-> -1

这两个函数的意义相同。注意返回值会被转化为一个BIGINT。

COS(X)

返回X 的余弦，其中X在弧度上已知。

mysql> SELECT COS(PI());

-> -1

COT(X)

返回X 的余切。

mysql> SELECT COT(12);

-> -1.5726734063977

mysql> SELECT COT(0);

-> NULL

CRC32(expr)

计算循环冗余码校验值并返回一个 32比特无符号值。若参数为NULL ，则结果为 NULL。该参数应为一个字符

串，而且在不是字符串的情况下会被作为字符串处理（若有可能）。

mysql> SELECT CRC32('MySQL');

-> 3259397556

mysql> SELECT CRC32('mysql');

-> 2501908538

DEGREES(X)

返回参数X, 该参数由弧度被转化为度。

mysql> SELECT DEGREES(PI());

-> 180

mysql> SELECT DEGREES(PI() / 2);

-> 90

EXP(X)



返回e的X乘方后的值(自然对数的底)。

mysql> SELECT EXP(2);

-> 7.3890560989307

mysql> SELECT EXP(-2);

-> 0.13533528323661

mysql> SELECT EXP(0);

-> 1

FLOOR(X)

返回不大于X的最大整数值。

mysql> SELECT FLOOR(1.23);

-> 1

mysql> SELECT FLOOR(-1.23);

-> -2

注意，返回值会被转化为一个 BIGINT。

FORMAT(X,D)

将数字X 的格式写成'#,###,###.##'格式, 即保留小数点后D位，而第D位的保留方式为四舍五入，然后将结

果以字符串的形式返回。详见12.9.4节，“其他函数”。

LN(X)

返回X 的自然对数,即, X 相对于基数e 的对数。

mysql> SELECT LN(2);

-> 0.69314718055995

mysql> SELECT LN(-2);

-> NULL

这个函数同LOG(X)具有相同意义。

LOG(X) LOG(B,X)

若用一个参数调用，这个函数就会返回X 的自然对数。

mysql> SELECT LOG(2);

-> 0.69314718055995

mysql> SELECT LOG(-2);

-> NULL



若用两个参数进行调用，这个函数会返回X 对于任意基数B 的对数。

mysql> SELECT LOG(2,65536);

-> 16

mysql> SELECT LOG(10,100);

-> 2

LOG(B,X) 就相当于 LOG(X) / LOG(B)。

LOG2(X)

返回X 的基数为2的对数。

mysql> SELECT LOG2(65536);

-> 16

mysql> SELECT LOG2(-100);

-> NULL

对于查出存储一个数字需要多少个比特，LOG2()非常有效。这个函数相当于表达式 LOG(X) / LOG(2)。

LOG10(X)

返回X的基数为10的对数。

mysql> SELECT LOG10(2);

-> 0.30102999566398

mysql> SELECT LOG10(100);

-> 2

mysql> SELECT LOG10(-100);

-> NULL

LOG10(X)相当于LOG(10,X)。

MOD(N,M) , N % M N MOD M

模操作。返回N 被 M除后的余数。

mysql> SELECT MOD(234, 10);

-> 4

mysql> SELECT 253 % 7;

-> 1

mysql> SELECT MOD(29,9);



-> 2

mysql> SELECT 29 MOD 9;

-> 2

这个函数支持使用BIGINT 值。

MOD() 对于带有小数部分的数值也起作用， 它返回除法运算后的精确余数：

mysql> SELECT MOD(34.5,3);

-> 1.5

PI()

返回ϖ (pi)的值。默认的显示小数位数是7位,然而 MySQL内部会使用完全双精度值。

mysql> SELECT PI();

-> 3.141593

mysql> SELECT PI()+0.000000000000000000;

-> 3.141592653589793116

POW(X,Y) , POWER(X,Y)

返回X 的Y乘方的结果值。

mysql> SELECT POW(2,2);

-> 4

mysql> SELECT POW(2,-2);

-> 0.25

RADIANS(X)

返回由度转化为弧度的参数X, (注意ϖ 弧度等于180度）。

mysql> SELECT RADIANS(90);

-> 1.5707963267949

RAND() RAND(N)

返回一个随机浮点值v ，范围在 0 到1 之间 (即, 其范围为 0 ≤ v ≤ 1.0)。若已指定一个整数参数N ，则它被

用作种子值，用来产生重复序列。

mysql> SELECT RAND();

-> 0.9233482386203

mysql> SELECT RAND(20);

-> 0.15888261251047



mysql> SELECT RAND(20);

-> 0.15888261251047

mysql> SELECT RAND();

-> 0.63553050033332

mysql> SELECT RAND();

-> 0.70100469486881

mysql> SELECT RAND(20);

-> 0.15888261251047

若要在i ≤ R ≤ j 这个范围得到一个随机整数R ，需要用到表达式 FLOOR(i + RAND() * (j – i + 1))。例如， 若

要在7 到 12 的范围（包括7和12）内得到一个随机整数, 可使用以下语句：

SELECT FLOOR(7 + (RAND() * 6));

在ORDER BY语句中，不能使用一个带有RAND()值的列，原因是 ORDER BY 会计算列的多重时间。然而，可

按照如下的随机顺序检索数据行：

mysql> SELECT * FROM tbl_name ORDER BY RAND();

ORDER BY RAND()同 LIMIT 的结合从一组列中选择随机样本很有用：

mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d

-> ORDER BY RAND() LIMIT 1000;

注意，在WHERE语句中，WHERE每执行一次， RAND()就会被再计算一次。

RAND()的作用不是作为一个精确的随机发生器，而是一种用来发生在同样的 MySQL版本的平台之间的可移

动ad hoc随机数的快速方式。

ROUND(X) ROUND(X,D)

返回参数X, 其值接近于最近似的整数。在有两个参数的情况下，返回X ，其值保留到小数点后D位，而第D位

的保留方式为四舍五入。若要接保留X值小数点左边的D 位，可将 D 设为负值。

mysql> SELECT ROUND(-1.23);

-> -1

mysql> SELECT ROUND(-1.58);

-> -2

mysql> SELECT ROUND(1.58);

-> 2

mysql> SELECT ROUND(1.298, 1);

-> 1.3



mysql> SELECT ROUND(1.298, 0);

-> 1

mysql> SELECT ROUND(23.298, -1);

-> 20

返回值的类型同第一个自变量相同(假设它是一个整数、双精度数或小数)。这意味着对于一个整数参数,结果

也是一个整数(无小数部分)。

当第一个参数是十进制常数时，对于准确值参数，ROUND() 使用精密数学题库：

对于准确值数字, ROUND() 使用“四舍五入” 或“舍入成最接近的数” 的规则:对于一个分数部分为

.5或大于 .5的值，正数则上舍入到邻近的整数值， 负数则下舍入临近的整数值。(换言之, 其舍入

的方向是数轴上远离零的方向）。对于一个分数部分小于.5 的值，正数则下舍入下一个整数值，负

数则下舍入邻近的整数值，而正数则上舍入邻近的整数值。

对于近似值数字，其结果根据C 库而定。在很多系统中，这意味着 ROUND()的使用遵循“舍入成最

接近的偶数”的规则： 一个带有任何小数部分的值会被舍入成最接近的偶数整数。

以下举例说明舍入法对于精确值和近似值的不同之处：

mysql> SELECT ROUND(2.5), ROUND(25E-1);

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

| ROUND(2.5) | ROUND(25E-1) |

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

| 3 | 2 |

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

详见第24章：精度数学。

SIGN(X)

返回参数作为-1、 0或1的符号，该符号取决于X 的值为负、零或正。

mysql> SELECT SIGN(-32);

-> -1

mysql> SELECT SIGN(0);

-> 0

mysql> SELECT SIGN(234);

-> 1

SIN(X)

返回X 正弦，其中 X 在弧度中被给定。

mysql> SELECT SIN(PI());



-> 1.2246063538224e-16

mysql> SELECT ROUND(SIN(PI()));

-> 0

SQRT(X)

返回非负数X 的二次方根。

mysql> SELECT SQRT(4);

-> 2

mysql> SELECT SQRT(20);

-> 4.4721359549996

mysql> SELECT SQRT(-16);

-> NULL

TAN(X)

返回X 的正切，其中X 在弧度中被给定。

mysql> SELECT TAN(PI());

-> -1.2246063538224e-16

mysql> SELECT TAN(PI()+1);

-> 1.5574077246549

TRUNCATE(X,D)

返回被舍去至小数点后D位的数字X。若D 的值为 0, 则结果不带有小数点或不带有小数部分。可以将D设为负

数,若要截去(归零) X小数点左起第D位开始后面所有低位的值.

mysql> SELECT TRUNCATE(1.223,1);

-> 1.2

mysql> SELECT TRUNCATE(1.999,1);

-> 1.9

mysql> SELECT TRUNCATE(1.999,0);

-> 1

mysql> SELECT TRUNCATE(-1.999,1);

-> -1.9

mysql> SELECT TRUNCATE(122,-2);

-> 100





-> 1028

所有数字的舍入方向都接近于零

















ADDDATE(date,INTERVAL expr type) ADDDATE(expr,days)

当被第二个参数的INTERVAL格式激活后， ADDDATE()就是DATE_ADD()的同义词。相关函数SUBDATE() 则

是DATE_SUB()的同义词。对于INTERVAL参数上的信息，请参见关于DATE_ADD()的论述。

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);

-> '1998-02-02'

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);

-> '1998-02-02'

若days 参数只是整数值，则 MySQL 5.1将其作为天数值添加至expr。

mysql> SELECT ADDDATE('1998-01-02', 31);

-> '1998-02-02'

ADDTIME(expr,expr2)



ADDTIME()将expr2添加至expr 然后返回结果。 expr 是一个时间或时间日期表达式，而expr2 是一个时间表

达式。

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999',

-> '1 1:1:1.000002');

-> '1998-01-02 01:01:01.000001'

mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');

-> '03:00:01.999997'

CONVERT_TZ(dt,from_tz,to_tz)

CONVERT_TZ() 将时间日期值dt 从from_tz 给出的时区转到to_tz给出的时区，然后返回结果值。关于可能指

定的时区的详细论述，请参见5.10.8节，“MySQL服务器时区支持”。若自变量无效，则这个函数会返回

NULL。

在从若from_tz 到UTC的转化过程中，该值超出 TIMESTAMP 类型的被支持范围，那么转化不会发生。关于

TIMESTAMP 范围的论述，请参见11.1.2节，“日期和时间类型概述”。

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');

-> '2004-01-01 13:00:00'

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');

-> '2004-01-01 22:00:00'

注释：若要使用诸如 'MET'或 'Europe/Moscow'之类的指定时间区，首先要设置正确的时区表。详细说明

见5.10.8节，“MySQL服务器时区支持”。

CURDATE()

将当前日期按照'YYYY-MM-DD' 或YYYYMMDD 格式的值返回，具体格式根据函数用在字符串或是数字语境中

而定。

mysql> SELECT CURDATE();

-> '1997-12-15'

mysql> SELECT CURDATE() + 0;

-> 19971215

CURRENT_DATE CURRENT_DATE()

CURRENT_DATE和CURRENT_DATE()是的同义词.

CURTIME()

将当前时间以'HH:MM:SS'或 HHMMSS 的格式返回， 具体格式根据函数用在字符串或是数字语境中而定。

mysql> SELECT CURTIME();

-> '23:50:26'



mysql> SELECT CURTIME() + 0;

-> 235026

CURRENT_TIME, CURRENT_TIME()

CURRENT_TIME 和CURRENT_TIME() 是CURTIME()的同义词。

CURRENT_TIMESTAMP, CURRENT_TIMESTAMP()

CURRENT_TIMESTAMP和 CURRENT_TIMESTAMP()是NOW()的同义词。

DATE(expr)

提取日期或时间日期表达式expr中的日期部分。

mysql> SELECT DATE('2003-12-31 01:02:03');

-> '2003-12-31'

DATEDIFF(expr,expr2)

DATEDIFF() 返回起始时间expr和结束时间expr2之间的天数。Expr和expr2 为日期或 date-and-time 表达式。

计算中只用到这些值的日期部分。

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');

-> 1

mysql> SELECT DATEDIFF('1997-11-30 23:59:59','1997-12-31');

-> -31

DATE_ADD(date,INTERVAL expr type) DATE_SUB(date,INTERVAL expr type)

这些函数执行日期运算。date 是一个 DATETIME 或DATE值，用来指定起始时间。expr 是一个表达式，用来

指定从起始日期添加或减去的时间间隔值。Expr是一个字符串;对于负值的时间间隔，它可以以一个 ‘-’开头。

type 为关键词，它指示了表达式被解释的方式。

关键词INTERVA及type 分类符均不区分大小写。

以下表显示了type 和expr 参数的关系：

type 值 预期的expr 格式

MICROSECOND MICROSECONDS

SECOND SECONDS

MINUTE MINUTES

HOUR HOURS

DAY DAYS

WEEK WEEKS

MONTH MONTHS

QUARTER QUARTERS

YEAR YEARS

SECOND_MICROSECOND 'SECONDS.MICROSECONDS'



MINUTE_MICROSECOND 'MINUTES.MICROSECONDS'

MINUTE_SECOND 'MINUTES:SECONDS'

HOUR_MICROSECOND 'HOURS.MICROSECONDS'

HOUR_SECOND 'HOURS:MINUTES:SECONDS'

HOUR_MINUTE 'HOURS:MINUTES'

DAY_MICROSECOND 'DAYS.MICROSECONDS'

DAY_SECOND 'DAYS HOURS:MINUTES:SECONDS'

DAY_MINUTE 'DAYS HOURS:MINUTES'

DAY_HOUR 'DAYS HOURS'

YEAR_MONTH 'YEARS-MONTHS'

MySQL 允许任何expr 格式中的标点分隔符。表中所显示的是建议的 分隔符。若 date 参数是一个 DATE 值，

而你的计算只会包括 YEAR、MONTH和DAY部分(即, 没有时间部分), 其结果是一个DATE 值。否则，结果将是

一个 DATETIME值。

若位于另一端的表达式是一个日期或日期时间值， 则INTERVAL expr type只允许在 + 操作符的两端。对于

–操作符， INTERVAL expr type 只允许在其右端，原因是从一个时间间隔中提取一个日期或日期时间值是毫

无意义的。 (见下面的例子）。

mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND;

-> '1998-01-01 00:00:00'

mysql> SELECT INTERVAL 1 DAY + '1997-12-31';

-> '1998-01-01'

mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND;

-> '1997-12-31 23:59:59'

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',

-> INTERVAL 1 SECOND);

-> '1998-01-01 00:00:00'

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',

-> INTERVAL 1 DAY);

-> '1998-01-01 23:59:59'

mysql> SELECT DATE_ADD('1997-12-31 23:59:59',

-> INTERVAL '1:1' MINUTE_SECOND);

-> '1998-01-01 00:01:00'

mysql> SELECT DATE_SUB('1998-01-01 00:00:00',

-> INTERVAL '1 1:1:1' DAY_SECOND);

-> '1997-12-30 22:58:59'



mysql> SELECT DATE_ADD('1998-01-01 00:00:00',

-> INTERVAL '-1 10' DAY_HOUR);

-> '1997-12-30 14:00:00'

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);

-> '1997-12-02'

mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',

-> INTERVAL '1.999999' SECOND_MICROSECOND);

-> '1993-01-01 00:00:01.000001'

若你指定了一个过于短的时间间隔值 (不包括type 关键词所预期的所有时间间隔部分), MySQL 假定你已经省

去了时间间隔值的最左部分。例如，你指定了一种类型的DAY_SECOND, expr 的值预期应当具有天、 小时、

分钟和秒部分。若你指定了一个类似 '1:10'的值, MySQL 假定天和小时部分不存在，那么这个值代表分和秒。

换言之, '1:10' DAY_SECOND 被解释为相当于 '1:10' MINUTE_SECOND。这相当于 MySQL将TIME 值解释为所

耗费的时间而不是日时的解释方式。

假如你对一个日期值添加或减去一些含有时间部分的内容，则结果自动转化为一个日期时间值：

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY);

-> '1999-01-02'

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);

-> '1999-01-01 01:00:00'

假如你使用了格式严重错误的日期,则结果为 NULL。假如你添加了 MONTH、YEAR_MONTH或YEAR ，而结果

日期中有一天的日期大于添加的月份的日期最大限度，则这个日期自动被调整为添加月份的最大日期：

mysql> SELECT DATE_ADD('1998-01-30', INTERVAL 1 MONTH);

-> '1998-02-28'

DATE_FORMAT(date,format)

根据format 字符串安排date 值的格式。

以下说明符可用在format 字符串中：

说明符说明

%a 工作日的缩写名称 (Sun..Sat)

%b 月份的缩写名称 (Jan..Dec)

%c 月份，数字形式(0..12)

%D 带有英语后缀的该月日期 (0th, 1st, 2nd, 3rd, ...)

%d 该月日期, 数字形式 (00..31)

%e 该月日期, 数字形式(0..31)

%f 微秒 (000000..999999)

%H 小时(00..23)



%h 小时(01..12)

%I 小时 (01..12)

%i 分钟,数字形式 (00..59)

%j 一年中的天数 (001..366)

%k 小时 (0..23)

%l 小时 (1..12)

%M 月份名称 (January..December)

%m 月份, 数字形式 (00..12)

%p 上午（AM）或下午（ PM）

%r 时间 , 12小时制 (小时hh:分钟mm:秒数ss 后加 AM或PM)

%S 秒 (00..59)

%s 秒 (00..59)

%T 时间 , 24小时制 (小时hh:分钟mm:秒数ss)

%U 周 (00..53), 其中周日为每周的第一天

%u 周 (00..53), 其中周一为每周的第一天

%V 周 (01..53), 其中周日为每周的第一天 ; 和%X同时使用

%v 周 (01..53), 其中周一为每周的第一天 ; 和%x同时使用

%W 工作日名称 (周日..周六)

%w 一周中的每日 (0=周日..6=周六)

%X 该周的年份，其中周日为每周的第一天, 数字形式,4位数;和%V同

时使用

%x 该周的年份，其中周一为每周的第一天, 数字形式,4位数;和%v同

时使用

%Y 年份, 数字形式,4位数

%y 年份, 数字形式 (2位数)

%% ‘%’文字字符

所有其它字符都被复制到结果中，无需作出解释。

注意， ‘%’字符要求在格式指定符之前。

月份和日期说明符的范围从零开始，原因是 MySQL允许存储诸如 '2004-00-00'的不完全日期.

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');

-> 'Saturday October 1997'

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');

-> '22:23:00'

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',

'%D %y %a %d %m %b %j');

-> '4th 97 Sat 04 10 Oct 277'

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',

'%H %k %I %r %T %S %w');

-> '22 22 10 10:23:00 PM 22:23:00 00 6'

mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');



-> '1998 52'

DAY(date)

DAY() 和DAYOFMONTH()的意义相同。

DAYNAME(date)

返回date 对应的工作日名称。

mysql> SELECT DAYNAME('1998-02-05');

-> '周四'

DAYOFMONTH(date)

返回date 对应的该月日期，范围是从 1到31。

mysql> SELECT DAYOFMONTH('1998-02-03');

-> 3

DAYOFWEEK(date)

返回date (1 = 周日, 2 = 周一, ..., 7 = 周六)对应的工作日索引。这些索引值符合 ODBC标准。

mysql> SELECT DAYOFWEEK('1998-02-03');

-> 3

DAYOFYEAR(date)

返回date 对应的一年中的天数，范围是从 1到366。

mysql> SELECT DAYOFYEAR('1998-02-03');

-> 34

EXTRACT(type FROM date)

EXTRACT()函数所使用的时间间隔类型说明符同 DATE_ADD()或DATE_SUB()的相同,但它从日期中提取其部

分，而不是执行日期运算。

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');

-> 1999

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');

-> 199907

mysql> SELECT EXTRACT(DAY_MINUTE FROM '1999-07-02 01:02:03');

-> 20102

mysql> SELECT EXTRACT(MICROSECOND

-> FROM '2003-01-02 10:30:00.00123');



-> 123

FROM_DAYS(N)

给定一个天数N, 返回一个DATE值。

mysql> SELECT FROM_DAYS(729669);

-> '1997-10-07'

使用 FROM_DAYS()处理古老日期时，务必谨慎。他不用于处理阳历出现前的日期(1582)。请参

见12.6节，“MySQL使用什么日历？”。

FROM_UNIXTIME(unix_timestamp) , FROM_UNIXTIME(unix_timestamp,format)

返回'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS 格式值的unix_timestamp参数表示，具体格式取决于该

函数是否用在字符串中或是数字语境中。

若format 已经给出，则结果的格式是根据format 字符串而定。 format 可以包含同DATE_FORMAT() 函数输入

项列表中相同的说明符。

mysql> SELECT FROM_UNIXTIME(875996580);

-> '1997-10-04 22:23:00'

mysql> SELECT FROM_UNIXTIME(875996580) + 0;

-> 19971004222300

mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),

-> '%Y %D %M %h:%i:%s %x');

-> '2003 6th August 06:22:58 2003'

GET_FORMAT(DATE|TIME|DATETIME, 'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL')

返回一个格式字符串。这个函数在同DATE_FORMAT() 及STR_TO_DATE()函数结合时很有用。

第一个参数的3个可能值和第二个参数的5个可能值产生 15 个可能格式字符串 (对于使用的说明符，请参

见DATE_FORMAT()函数说明表 )。

函数调用结果

GET_FORMAT(DATE,'USA') '%m.%d.%Y'

GET_FORMAT(DATE,'JIS') '%Y-%m-%d'

GET_FORMAT(DATE,'ISO') '%Y-%m-%d'

GET_FORMAT(DATE,'EUR') '%d.%m.%Y'

GET_FORMAT(DATE,'INTERNAL') '%Y%m%d'

GET_FORMAT(DATETIME,'USA') '%Y-%m-%d-%H.%i.%s'

GET_FORMAT(DATETIME,'JIS') '%Y-%m-%d %H:%i:%s'

GET_FORMAT(DATETIME,'ISO') '%Y-%m-%d %H:%i:%s'

GET_FORMAT(DATETIME,'EUR') '%Y-%m-%d-%H.%i.%s'

GET_FORMAT(DATETIME,'INTERNAL') '%Y%m%d%H%i%s'

GET_FORMAT(TIME,'USA') '%h:%i:%s %p'



GET_FORMAT(TIME,'JIS') '%H:%i:%s'

GET_FORMAT(TIME,'ISO') '%H:%i:%s'

GET_FORMAT(TIME,'EUR') '%H.%i.%S'

GET_FORMAT(TIME,'INTERNAL') '%H%i%s'

ISO 格式为ISO 9075, 而非ISO 8601.

也可以使用TIMESTAMP, 这时GET_FORMAT()的返回值和DATETIME相同。

mysql> SELECT DATE_FORMAT('2003-10-03',GET_FORMAT(DATE,'EUR'));

-> '03.10.2003'

mysql> SELECT STR_TO_DATE('10.31.2003',GET_FORMAT(DATE,'USA'));

-> '2003-10-31'

或见13.5.3节，“SET语法”。

HOUR(time)

返回time 对应的小时数。对于日时值的返回值范围是从 0 到 23 。

mysql> SELECT HOUR('10:05:03');

-> 10

然而, TIME 值的范围实际上非常大, 所以HOUR可以返回大于23的值。

mysql> SELECT HOUR('272:59:59');

-> 272

LAST_DAY(date)

获取一个日期或日期时间值，返回该月最后一天对应的值。若参数无效，则返回NULL。

mysql> SELECT LAST_DAY('2003-02-05');

-> '2003-02-28'

mysql> SELECT LAST_DAY('2004-02-05');

-> '2004-02-29'

mysql> SELECT LAST_DAY('2004-01-01 01:01:01');

-> '2004-01-31'

mysql> SELECT LAST_DAY('2003-03-32');

-> NULL

LOCALTIME, LOCALTIME()

LOCALTIME 及 LOCALTIME()和NOW()具有相同意义。



LOCALTIMESTAMP, LOCALTIMESTAMP()

LOCALTIMESTAMP和LOCALTIMESTAMP()和NOW()具有相同意义。

MAKEDATE(year,dayofyear)

给出年份值和一年中的天数值，返回一个日期。dayofyear 必须大于 0 ，否则结果为 NULL。

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);

-> '2001-01-31', '2001-02-01'

mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);

-> '2001-12-31', '2004-12-30'

mysql> SELECT MAKEDATE(2001,0);

-> NULL

MAKETIME(hour,minute,second)

返回由hour、minute和second 参数计算得出的时间值。

mysql> SELECT MAKETIME(12,15,30);

-> '12:15:30'

MICROSECOND(expr)

从时间或日期时间表达式expr返回微秒值，其数字范围从 0到 999999。

mysql> SELECT MICROSECOND('12:00:00.123456');

-> 123456

mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010');

-> 10

MINUTE(time)

返回 time 对应的分钟数,范围是从 0 到 59。

mysql> SELECT MINUTE('98-02-03 10:05:03');

-> 5

MONTH(date)

返回date 对应的月份，范围时从 1 到 12。

mysql> SELECT MONTH('1998-02-03');

-> 2

MONTHNAME(date)



返回date 对应月份的全名。

mysql> SELECT MONTHNAME('1998-02-05');

-> 'February '

NOW()

返回当前日期和时间值，其格式为 'YYYY-MM-DD HH:MM:SS' 或YYYYMMDDHHMMSS ， 具体格式取决于该函

数是否用在字符串中或数字语境中。

mysql> SELECT NOW();

-> '1997-12-15 23:50:26'

mysql> SELECT NOW() + 0;

-> 19971215235026

在一个存储程序或触发器内, NOW() 返回一个常数时间，该常数指示了该程序或触发语句开始执行的时间。这

同SYSDATE()的运行有所不同。

PERIOD_ADD(P,N)

添加N 个月至周期P (格式为YYMM 或YYYYMM)，返回值的格式为 YYYYMM。注意周期参数P 不是日期值。

mysql> SELECT PERIOD_ADD(9801,2);

-> 199803

PERIOD_DIFF(P1,P2)

返回周期P1和P2 之间的月份数。P1 和P2 的格式应该为YYMM或YYYYMM。注意周期参数P1和P2 不是日期

值。

mysql> SELECT PERIOD_DIFF(9802,199703);

-> 11

QUARTER(date)

返回date 对应的一年中的季度值，范围是从 1到 4。

mysql> SELECT QUARTER('98-04-01');

-> 2

SECOND(time)

返回time 对应的秒数, 范围是从 0到59。

mysql> SELECT SECOND('10:05:03');

-> 3

SEC_TO_TIME(seconds)

返回被转化为小时、分钟和秒数的seconds参数值, 其格式为 'HH:MM:SS' 或HHMMSS，具体格式根据该函数



是否用在字符串或数字语境中而定。

mysql> SELECT SEC_TO_TIME(2378);

-> '00:39:38'

mysql> SELECT SEC_TO_TIME(2378) + 0;

-> 3938

STR_TO_DATE(str,format)

这是DATE_FORMAT() 函数的倒转。它获取一个字符串str 和一个格式字符串format。若格式字符串包含日期

和时间部分，则 STR_TO_DATE()返回一个 DATETIME 值， 若该字符串只包含日期部分或时间部分，则返回

一个 DATE 或TIME值。

str所包含的日期、时间或日期时间值应该在format指示的格式中被给定。对于可用在format中的说明符，请参

见DATE_FORMAT() 函数说明表。所有其它的字符被逐字获取，因此不会被解释。若 str 包含一个非法日期、

时间或日期时间值，则 STR_TO_DATE()返回NULL。同时，一个非法值会引起警告。

对日期值部分的范围检查在11.3.1节，“DATETIME、DATE和TIMESTAMP类型”有详细说明。其意义是,例如, 只

要具体日期部分的范围时从 1到 31之间，则允许一个日期中的具体日期部分大于一个月中天数值。并且，允

许“零”日期或带有0值部分的日期。

mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');

-> '0000-00-00'

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');

-> '2004-04-31'

SUBDATE(date,INTERVAL expr type) SUBDATE(expr,days)

当被第二个参数的 INTERVAL型式调用时, SUBDATE()和DATE_SUB()的意义相同。对于有关INTERVAL参数的

信息， 见有关 DATE_ADD()的讨论。

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);

-> '1997-12-02'

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);

-> '1997-12-02'

第二个形式允许对days使用整数值。在这些情况下，它被算作由日期或日期时间表达式expr中提取的天数。

mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);

-> '1997-12-02 12:00:00'

注意不能使用格式 "%X%V" 来将一个 year-week 字符串转化为一个日期，原因是当一个星期跨越一个月份界

限时，一个年和星期的组合不能标示一个唯一的年和月份。若要将year-week转化为一个日期，则也应指定具

体工作日：

mysql> select str_to_date('200442 Monday', '%X%V %W');



-> 2004-10-18

SUBTIME(expr,expr2)

SUBTIME()从expr 中提取expr2 ，然后返回结果。expr 是一个时间或日期时间表达式，而xpr2 是一个时间表

达式。

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');

-> '1997-12-30 22:58:58.999997'

mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');

-> '-00:59:59.999999'

SYSDATE()

返回当前日期和时间值，格式为'YYYY-MM-DD HH:MM:SS' 或YYYYMMDDHHMMSS， 具体格式根据函数是否

用在字符串或数字语境而定。

在一个存储程序或触发器中, SYSDATE()返回其执行的时间, 而非存储成都或触发语句开始执行的时间。这

个NOW()的运作有所不同。

TIME(expr)

提取一个时间或日期时间表达式的时间部分，并将其以字符串形式返回。

mysql> SELECT TIME('2003-12-31 01:02:03');

-> '01:02:03'

mysql> SELECT TIME('2003-12-31 01:02:03.000123');

-> '01:02:03.000123'

TIMEDIFF(expr,expr2)

TIMEDIFF() 返回起始时间expr 和结束时间expr2 之间的时间。 expr 和expr2 为时间或 date-and-time 表达

式,两个的类型必须一样。

mysql> SELECT TIMEDIFF('2000:01:01 00:00:00',

-> '2000:01:01 00:00:00.000001');

-> '-00:00:00.000001'

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',

-> '1997-12-30 01:01:01.000002');

-> '46:58:57.999999'

TIMESTAMP(expr) , TIMESTAMP(expr,expr2)

对于一个单参数,该函数将日期或日期时间表达式expr 作为日期时间值返回.对于两个参数, 它将时间表达式

expr2 添加到日期或日期时间表达式 expr 中，将theresult作为日期时间值返回。

mysql> SELECT TIMESTAMP('2003-12-31');



-> '2003-12-31 00:00:00'

mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');

-> '2004-01-01 00:00:00'

TIMESTAMPADD(interval,int_expr,datetime_expr)

将整型表达式int_expr 添加到日期或日期时间表达式 datetime_expr中。int_expr 的单位被时间间隔参数给

定，该参数必须是以下值的其中一个： FRAC_SECOND、SECOND、 MINUTE、 HOUR、 DAY、 WEEK、

MONTH、 QUARTER或 YEAR。

可使用所显示的关键词指定Interval值，或使用SQL_TSI_前缀。例如, DAY或SQL_TSI_DAY 都是正确的。

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');

-> '2003-01-02 00:01:00'

mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');

-> '2003-01-09'

TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)

返回日期或日期时间表达式datetime_expr1 和datetime_expr2the 之间的整数差。其结果的单位由interval 参

数给出。interval 的法定值同TIMESTAMPADD()函数说明中所列出的相同。

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');

-> 3

mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');

-> -1

TIME_FORMAT(time,format)

其使用和 DATE_FORMAT()函数相同, 然而format 字符串可能仅会包含处理小时、分钟和秒的格式说明符。其

它说明符产生一个NULL值或0。

若time value包含一个大于23的小时部分，则 %H 和 %k 小时格式说明符会产生一个大于0..23的通常范围的

值。另一个小时格式说明符产生小时值模数12。

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');

-> '100 100 04 04 4'

TIME_TO_SEC(time)

返回已转化为秒的time参数。

mysql> SELECT TIME_TO_SEC('22:23:00');

-> 80580

mysql> SELECT TIME_TO_SEC('00:39:38');



-> 2378

TO_DAYS(date)

给定一个日期date, 返回一个天数(从年份0开始的天数 )。

mysql> SELECT TO_DAYS(950501);

-> 728779

mysql> SELECT TO_DAYS('1997-10-07');

-> 729669

TO_DAYS() 不用于阳历出现(1582)前的值，原因是当日历改变时，遗失的日期不会被考虑在内。请参

见12.6节，“MySQL使用什么日历？”。

请记住， MySQL使用11.3节，“日期和时间类型”中的规则将日期中的二位数年份值转化为四位。例如，

'1997-10-07'和 '97-10-07' 被视为同样的日期:

mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');

-> 729669, 729669

对于1582 年之前的日期(或许在其它地区为下一年 ), 该函数的结果实不可靠的。详见12.6节，“MySQL使用什

么日历？” 。

UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date)

若无参数调用，则返回一个Unix timestamp ('1970-01-01 00:00:00' GMT 之后的秒数) 作为无符号整数。若

用date 来调用UNIX_TIMESTAMP()，它会将参数值以'1970-01-01 00:00:00' GMT后的秒数的形式返回。date

可以是一个DATE 字符串、一个 DATETIME字符串、一个 TIMESTAMP或一个当地时间的YYMMDD

或YYYMMDD格式的数字。

mysql> SELECT UNIX_TIMESTAMP();

-> 882226357

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');

-> 875996580

当 UNIX_TIMESTAMP被用在 TIMESTAMP列时, 函数直接返回内部时戳值， 而不进行任何隐含的 “string-to-

Unix-timestamp”转化。假如你向UNIX_TIMESTAMP()传递一个溢出日期，它会返回 0,但请注意只有基本范围

检查会被履行 (年份从1970 到 2037， 月份从01到12,日期从 01 到31)。

假如你想要减去 UNIX_TIMESTAMP() 列, 你或许希望删去带符号整数的结果。请参见12.8节，“Cast函数和操

作符”。

UTC_DATE, UTC_DATE()

返回当前 UTC日期值，其格式为 'YYYY-MM-DD' 或 YYYYMMDD，具体格式取决于函数是否用在字符串或数字

语境中。

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;

-> '2003-08-14', 20030814



UTC_TIME, UTC_TIME()

返回当前 UTC 值，其格式为 'HH:MM:SS' 或HHMMSS，具体格式根据该函数是否用在字符串或数字语境而

定。

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;

-> '18:07:53', 180753

UTC_TIMESTAMP, UTC_TIMESTAMP()

返回当前UTC日期及时间值，格式为 'YYYY-MM-DD HH:MM:SS' 或YYYYMMDDHHMMSS，具体格式根据该函数

是否用在字符串或数字语境而定。

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;

-> '2003-08-14 18:08:04', 20030814180804

WEEK(date[,mode])

该函数返回date 对应的星期数。WEEK() 的双参数形式允许你指定该星期是否起始于周日或周一， 以及返回

值的范围是否为从0 到53 或从1 到53。若mode参数被省略，则使用default_week_format系统自变量的值。

请参见5.3.3节，“服务器系统变量”。

以下表说明了mode 参数的工作过程：d

第一天

Mode 工作日范围Week 1 为第一周 ...

0 周日0-53 本年度中有一个周日

1 周一0-53 本年度中有3天以上

2 周日1-53 本年度中有一个周日

3 周一1-53 本年度中有3天以上

4 周日0-53 本年度中有3天以上

5 周一0-53 本年度中有一个周一

6 周日1-53 本年度中有3天以上

7 周一1-53 本年度中有一个周一

mysql> SELECT WEEK('1998-02-20');

-> 7

mysql> SELECT WEEK('1998-02-20',0);

-> 7

mysql> SELECT WEEK('1998-02-20',1);

-> 8

mysql> SELECT WEEK('1998-12-31',1);

-> 53

注意，假如有一个日期位于前一年的最后一周， 若你不使用2、3、6或7作为mode 参数选择，则MySQL返回

0：

mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);

-> 2000, 0

有人或许会提出意见，认为 MySQL 对于WEEK() 函数应该返回 52 ，原因是给定的日期实际上发生在1999年

的第52周。我们决定返回0作为代替的原因是我们希望该函数能返回“给定年份的星期数”。这使得WEEK() 函数

在同其它从日期中抽取日期部分的函数结合时的使用更加可靠。

假如你更希望所计算的关于年份的结果包括给定日期所在周的第一天，则应使用 0、2、5或 7 作为mode参数

选择。

mysql> SELECT WEEK('2000-01-01',2);

-> 52

作为选择，可使用 YEARWEEK()函数:

mysql> SELECT YEARWEEK('2000-01-01');

-> 199952

mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);

-> '52'

WEEKDAY(date)

返回date (0 = 周一, 1 = 周二, ... 6 = 周日)对应的工作日索引 weekday index for

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');

-> 1

mysql> SELECT WEEKDAY('1997-11-05');

-> 2

WEEKOFYEAR(date)

将该日期的阳历周以数字形式返回，范围是从1到53。它是一个兼容度函数，相当于WEEK(date,3)。

mysql> SELECT WEEKOFYEAR('1998-02-20');

-> 8

YEAR(date)

返回date 对应的年份,范围是从1000到9999。

mysql> SELECT YEAR('98-02-03');

-> 1998

YEARWEEK(date), YEARWEEK(date,start)

返回一个日期对应的年或周。start参数的工作同start参数对 WEEK()的工作相同。结果中的年份可以和该年的



第一周和最后一周对应的日期参数有所不同。

mysql> SELECT YEARWEEK('1987-01-01');

-> 198653

注意，周数和WEEK()函数队可选参数0或 1可能会返回的(0) w有所不同，原因是此时 WEEK() 返回给定年份的

语境中的周。

-> '1997-10-07'

























其他函数

12.9.1. 位函数

12.9.2. 加密函数

12.9.3. 信息函数

12.9.4. 其他函数

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. 加密函数

本节介绍了加密和加密值。若你想要储存一些由可能包含任意字节值的加密函数返回的结果，使用BLOB列而

不是 CHAR 或VARCHAR 列，从而避免由于结尾空格的删除而改变一些数据值的潜在问题。

AES_ENCRYPT(str,key_str) , AES_DECRYPT(crypt_str,key_str)

这些函数允许使用官方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中普遍通用的密码最安全的加密函数。



DECODE(crypt_str,pass_str)

使用pass_str 作为密码，解密加密字符串 crypt_str， crypt_str 应该是由ENCODE()返回的字符串。

ENCODE(str,pass_str)

使用pass_str 作为密码，解密 str 。 使用DECODE()解密结果。

结果是一个和str长度相同的二进制字符串。若你想要将其保留在一个列中，可使用 BLOB 列类型。

DES_DECRYPT(crypt_str[,key_str])

使用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。

DES_ENCRYPT(str[,(key_num|key_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');

ENCRYPT(str[,salt])

使用Unix crypt() 系统调用加密str。salt 参数应为一个至少包含2个字符的字符串。若没有给出salt 参数，则

使用任意值。

mysql> SELECT ENCRYPT('hello');

-> 'VxuFAJXVARROc'

至少在一些系统中，ENCRYPT()除了str的前八位字符之外会忽略所有内容。这个行为由下划线的crypt() 系统

调用的执行所决定。

假如crypt()在你的系统中不可用(正如在 Windows系统), ENCRYPT() 则会始终返回NULL。鉴于这个原因，我

们向你推荐使用 MD5() 或SHA1() 来代替,因为这两个函数适合所有的平台。

MD5(str)

为字符串算出一个 MD5 128比特检查和。该值以32位十六进制数字的二进制字符串的形式返回, 若参数为

NULL 则会返回 NULL。例如，返回值可被用作散列关键字。

mysql> SELECT MD5('testing');

-> 'ae2b1fca515949e5d54fb22b8ed95575'

这是"RSA Data Security, Inc. MD5 Message-Digest Algorithm."

假如你想要将这个值转化为大写字母，参见12.8节，“Cast函数和操作符”中BINARY操作符项中给出的二进制字

符串转换。

OLD_PASSWORD(str)

当PASSWORD()的执行变为改善安全性时，OLD_PASSWORD()会被添加到 MySQL。OLD_PASSWORD()返回从

前的PASSWORD()执行值( 4.1之前)，同时允许你为任何4.1 之前的需要连接到你的5.1 版本MySQL服务器前客

户端设置密码，从而不至于将它们切断。请参见5.7.9节，“MySQL 4.1中的密码哈希处理”。

PASSWORD(str)

从原文密码str 计算并返回密码字符串，当参数为 NULL 时返回 NULL。这个函数用于用户授权表

的Password列中的加密MySQL密码存储

mysql> SELECT PASSWORD('badpwd');

-> '7f84554057dd964b'

PASSWORD() 加密是单向的 (不可逆 )。

PASSWORD() 执行密码加密与Unix 密码被加密的方式不同。请参见ENCRYPT()。



注释： PASSWORD()函数在MySQL服务器中的鉴定系统使用；你不应将它用在你个人的应用程序中。为达到

同样目的，可使用 MD5()或SHA1() 代替。更多关于在您的应用程序中处理密码及安全鉴定的信息见RFC

2195

SHA1(str) SHA(str)

为字符串算出一个 SHA1 160比特检查和，如RFC 3174 (安全散列算法 )中所述。该值被作为40位十六进制数

字返回，而当参数为NULL 时则返回 NULL。这个函数的一个可能的用处就在于其作为散列关键字。你也可以

将其作为存储密码的密码安全函数使用。

mysql> SELECT SHA1('abc');

-> 'a9993e364706816aba3e25717850c26c9cd0d89d'

SHA1()可以被视为一个密码更加安全的函数，相当于 MD5()。 SHA() 和SHA1()具有相同的意义。

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

返回值具有如下意义：

可压缩性意义举例

0 明确排序带有COLLATE 子句的值

1 无排序不同排序的字符串连接

2 明确排序列值

3 系统常量USER()返回值

4 可压缩文字字符串

5 可忽略NULL得来的NULL或一个表达式

下方值得优先级较高。

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-ddddeeeeeeeeeeee

：

前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);



 */