### 第12章：函数和操作符
在SQL 语句中，表达式可用于一些诸如SELECT语句的ORDER BY 或HAVING子句、SELECT、 DELETE或 UPDATE语句的WHERE 子句或 SET语句之类的地方。使用文本值、column值、NULL值、函数、 操作符来书写表达式。 本章叙述了可用于书写MySQL表达式的函数和操作符。
除非在文档编制中对一个函数或操作符另有指定的情况外，一个包含NULL 的表达式通常产生一个NULL 值。
**注释**：在默认状态下, 在函数和紧随其后的括号之间不得存在空格。这能帮助 MySQL 分析程序区分一些同函数名相同的函数调用以及表或列。不过，函数自变量周围允许有空格出现。
可以通过选择--sql-mode=IGNORE_SPACE来打开MySQL服务器的方法使服务器接受函数名后的空格。 个人客户端程序可通过选择mysql_real_connect()的CLIENT_IGNORE_SPACE 实现这一状态。在以上两种情况中， 所有的函数名都成为保留字。请参见[5.3.2节，“SQL服务器模式”](# "5.3.2. The Server SQL Mode").
为节省时间，本章中对大多数例子使用简写形式展示了 **mysql**程序的输出结果。 对于以下格式的举例展示：
mysql> **SELECT MOD(29,9);**
+-----------+
| mod(29,9) |
+-----------+
| 2 |
+-----------+
1 rows in set (0.00 秒)
使用如下格式进行代替：
mysql> **SELECT MOD(29,9);**
-> 2
### 12.1. 操作符
[ 12.1.1. 操作符优先级](#)[ 12.1.2. 圆括号](#)[ 12.1.3. 比较函数和操作符](#)[ 12.1.4. 逻辑操作符](#)
### 12.1.1. 操作符优先级
以下列表显示了操作符优先级的由低到高的顺序。排列在同一行的操作符具有相同的优先级。
:=
||, OR, XOR
&&, AND
NOT
BETWEEN, CASE, WHEN, THEN, ELSE
=, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
|
&
<<, >>
-, +
*, /, DIV, %, MOD
^
- (一元减号), ~ (一元比特反转)
!
BINARY, COLLATE
**注释**：假如 HIGH_NOT_PRECEDENCE SQL 模式被激活，则 NOT 的优先级同 the ! 操作符相同。请参见[5.3.2节，“SQL服务器模式”](# "5.3.2. The Server SQL Mode")。
### 12.1.2. 圆括号
-
( ... )
使用括弧来规定表达式的运算顺序，例如：
mysql> SELECT 1+2*3;
-> 7
mysql> SELECT (1+2)*3;
-> 9
### 12.1.3. 比较函数和操作符
比较运算产生的结果为1(TRUE)、0 (FALSE)或 NULL。这些运算可用于数字和字符串。根据需要，字符串可自动转换为数字，而数字也可自动转换为字符串。
本章中的一些函数 (如LEAST()和GREATEST()) 的所得值不包括 1 (TRUE)、 0 (FALSE)和 NULL。然而，其所得值乃是基于按照下述规则运行的比较运算：
MySQL按照以下规则进行数值比较：
- 若有一个或两个参数为 NULL，除非NULL-safe <=> 等算符，则比较运算的结果为NULL。
- 若同一个比较运算中的两个参数都是字符串，则按照字符串进行比较。
- 若两个参数均为整数，则按照整数进行比较。
- 十六进制值在不需要作为数字进行比较时，则按照二进制字符串进行处理。
- 假如参数中的一个为 TIMESTAMP 或 DATETIME 列，而其它参数均为常数， 则在进行比较前将常数转为 timestamp。这样做的目的是为了使ODBC的进行更加顺利。注意，这不适合IN()中的参数!为了更加可靠，在进行对比时通常使用完整的 datetime/date/time字符串。
- 在其它情况下，参数作为浮点数进行比较。
在默认状态下，字符串比较不区分大小写，并使用现有字符集(默认为cp1252 Latin1，同时对英语也适合)。
为了进行比较，可使用CAST()函数将某个值转为另外一种类型。 使用CONVERT()将字符串值转为不同的字符集。请参见[12.8节，“Cast函数和操作符”](# "12.8. Cast Functions and Operators")。
以下例子说明了比较运算中将字符串转为数字的过程：
mysql> ** SELECT 1 > '6x';**
-> 0
mysql> ** SELECT 7 > '6x';**
-> 1
mysql> ** SELECT 0 > 'x6';**
-> 0
mysql> ** SELECT 0 = 'x6';**
-> 1
注意，在将一个字符串列同一个数字进行比较时， MySQL 不能使用列中的索引进行快速查找。假如_str_col_是一个编入索引的字符串列，则在以下语句中，索引不能执行查找功能：
SELECT * FROM _tbl_name_ WHERE _str_col_=1;
其原因是许多不同的字符串都可被转换为数值 1: '1'、 ' 1'、 '1a'、 ……
- =
等于：
mysql> ** SELECT 1 = 0;**
-> 0
mysql> ** SELECT '0' = 0;**
-> 1
mysql> ** SELECT '0.0' = 0;**
-> 1
mysql> ** SELECT '0.01' = 0;**
-> 0
mysql> ** SELECT '.01' = 0.01;**
-> 1
- <=>
NULL-safe equal.这个操作符和=操作符执行相同的比较操作，不过在两个操作码均为NULL时，其所得值为1而不为NULL，而当一个操作码为NULL时，其所得值为0而不为NULL。
mysql> ** SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;**
-> 1, 1, 0
mysql> ** SELECT 1 = 1, NULL = NULL, 1 = NULL;**
-> 1, NULL, NULL
- <> !=
不等于：
mysql> ** SELECT '.01' <> '0.01';**
-> 1
mysql> ** SELECT .01 <> '0.01';**
-> 0
mysql> ** SELECT 'zapp' <> 'zappp';**
-> 1
- <=
小于或等于：
mysql> ** SELECT 0.1 <= 2;**
-> 1
- <
小于：
mysql> ** SELECT 2 < 2;**
-> 0
- >=
大于或等于：
mysql> ** SELECT 2 >= 2;**
-> 1
- >
大于：
mysql> ** SELECT 2 > 2;**
-> 0
- IS _ boolean_value_ IS NOT _boolean_value_
根据一个布尔值来检验一个值，在这里，布尔值可以是TRUE、FALSE或UNKNOWN。
mysql> ** SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;**
-> 1, 1, 1
mysql> ** SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;**
-> 1, 1, 0
- IS NULL IS NOT NULL
检验一个值是否为 NULL。
mysql> ** SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;**
-> 0, 0, 1
mysql> ** SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;**
-> 1, 1, 0
为了能够顺利的使用ODBC 程序工作，在使用IS NULL时，MySQL支持一下额外特性：
- 在一个值产生后，立即运行一个以下格式的语句，从而找到最新AUTO_INCREMENT 值的所在行：
o SELECT * FROM _tbl_name_ WHERE _auto_col_ IS NULL
当设置SQL_AUTO_IS_NULL=0时，这项操作无法运行。请参见[13.5.3节，“SET语法”](# "13.5.3. SET Syntax")。
- 对于命名为NOT NULL 的DATE 和DATETIME列，可通过使用如下的 语句找到特定日期 '0000-00-00'：
o SELECT * FROM _tbl_name_ WHERE _date_column_ IS NULL
运行这一步需要使用一些 ODBC 应用软件，因为 ODBC本身不支持 一个 '0000-00-00'的时间值。
- _expr_ BETWEEN _min_ AND _max_
假如_expr大于或等于__min_且_expr_小于或等于_max_, 则BETWEEN 的返回值为1,或是0。若所有参数都是同一类型，则上述关系相当于表达式 (_min_ <= _expr_ AND _expr_ <= _max_)。其它类型的转换根据本章开篇所述规律进行，且适用于3种参数中任意一种。
mysql> ** SELECT 1 BETWEEN 2 AND 3;**
-> 0
mysql> ** SELECT 'b' BETWEEN 'a' AND 'c';**
-> 1
mysql> ** SELECT 2 BETWEEN 2 AND '3';**
-> 1
mysql> ** SELECT 2 BETWEEN 2 AND 'x-3';**
-> 0
- _expr_ NOT BETWEEN _min_ AND _max_
这相当于NOT(_expr_ BETWEEN _min_ AND _max_)。
· COALESCE(_value_,...)
返回值为列表当中的第一个非 NULL值，在没有非NULL 值得情况下返回值为 NULL 。
mysql> ** SELECT COALESCE(NULL,1);**
-> 1
mysql> ** SELECT COALESCE(NULL,NULL,NULL);**
-> NULL
· GREATEST(_value1_,_value2_,...)
当有2或多个参数时，返回值为最大(最大值的)参数。比较参数所依据的规律同LEAST()相同。
mysql> ** SELECT GREATEST(2,0);**
-> 2
mysql> ** SELECT GREATEST(34.0,3.0,5.0,767.0);**
-> 767.0
mysql> ** SELECT GREATEST('B','A','C');**
-> 'C'
在没有自变量为NULL的情况下，GREATEST()的返回值为NULL。
· _expr_ IN (_value_,...)
- 若_expr_为IN列表中的任意一个值，则其返回值为 1 , 否则返回值为0。假如所有的值都是常数，则其计算和分类根据 _expr_ 的类型进行。这时，使用二分搜索来搜索信息。如IN值列表全部由常数组成，则意味着IN 的速度非常之快。如_expr_是一个区分大小写的字符串表达式，则字符串比较也按照区分大小写的方式进行。
mysql> ** SELECT 2 IN (0,3,5,'wefwf');**
-> 0
mysql> ** SELECT 'wefwf' IN (0,3,5,'wefwf');**
-> 1
IN 列表中所列值的个数仅受限于 max_allowed_packet 值。
为了同SQL 标准相一致，在左侧表达式为NULL的情况下，或是表中找不到匹配项或是表中一个表达式为NULL 的情况下，IN的返回值均为NULL。
IN() 语构也可用书写某些类型的子查询。请参见[13.2.8.3节，“使用ANY、IN和SOME进行子查询”](# "13.2.8.3. Subqueries with ANY, IN, and SOME")。
· _expr_ NOT IN (_value_,...)
这与NOT (_expr_ IN (_value_,...))相同。
- ISNULL(_expr_)
如_expr_为NULL，那么ISNULL() 的返回值为 1，否则返回值为 0。
mysql> ** SELECT ISNULL(1+1);**
-> 0
mysql> ** SELECT ISNULL(1/0);**
-> 1
使用= 的NULL 值对比通常是错误的。
ISNULL() 函数同 IS NULL比较操作符具有一些相同的特性。请参见有关IS NULL 的说明。
· INTERVAL(_N_,_N1_,_N2_,_N3_,...)
假如_N_ < _N1__，_则返回值为0；假如_N_ < _N2_等等，则返回值为1；假如_N_为NULL，则返回值为 -1 。所有的参数均按照整数处理。为了这个函数的正确运行，必须满足 _N1_ < _N2_ < _N3_ < ……< _Nn_。其原因是使用了二分查找(极快速)。
mysql> ** SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);**
-> 3
mysql> ** SELECT INTERVAL(10, 1, 10, 100, 1000);**
-> 2
mysql> ** SELECT INTERVAL(22, 23, 30, 44, 200);**
-> 0
· LEAST(_value1_,_value2_,...)
在有两个或多个参数的情况下， 返回值为最小 (最小值)参数。用一下规则将自变量进行对比：
- 假如返回值被用在一个 INTEGER 语境中，或是所有参数均为整数值，则将其作为整数值进行比较。
- 假如返回值被用在一个 REAL语境中，或所有参数均为实值，则 将其作为实值进行比较。
- 假如任意一个参数是一个区分大小写的字符串，则将参数按照区分大小写的字符串进行比较。
- 在其它情况下，将参数作为区分大小写的字符串进行比较。
假如任意一个自变量为NULL，则 LEAST()的返回值为NULL 。
mysql> ** SELECT LEAST(2,0);**
-> 0
mysql> ** SELECT LEAST(34.0,3.0,5.0,767.0);**
-> 3.0
mysql> ** SELECT LEAST('B','A','C');**
-> 'A'
注意，上面的转换规则在一些边界情形中会产生一些奇特的结果：
mysql> ** SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);**
-> -9223372036854775808
发生这种情况的原因是MySQL在整数语境中读取9223372036854775808.0。整数表示法不利于保存数值，因此它包括一个带符号整数。
### 12.1.4. 逻辑操作符
在SQL中，所有逻辑 操作符的求值所得结果均为 TRUE、FALSE或 NULL (UNKNOWN)。在 MySQL中，它们体现为 1 (TRUE)、 0 (FALSE)和 NULL。其大多数都与不同的数据库SQL通用，然而一些服务器对TRUE的返回值可能是任意一个非零值。
- NOT !
逻辑 NOT。当操作数为0 时，所得值为 1 ；当操作数为非零值时，所得值为 0 ，而当操作数为NOT NULL时，所得的返回值为 NULL。
mysql> ** SELECT NOT 10;**
-> 0
mysql> ** SELECT NOT 0;**
-> 1
mysql> ** SELECT NOT NULL;**
-> NULL
mysql> ** SELECT ! (1+1);**
-> 0
mysql> ** SELECT ! 1+1;**
-> 1
最后一个例子产生的结果为 1，原因是表达式的计算方式和(!1)+1相同。
- AND &&
逻辑AND。当所有操作数均为非零值、并且不为NULL时，计算所得结果为 1 ，当一个或多个操作数为0 时，所得结果为 0 ，其余情况返回值为 NULL 。
mysql> ** SELECT 1 && 1;**
-> 1
mysql> ** SELECT 1 && 0;**
-> 0
mysql> ** SELECT 1 && NULL;**
-> NULL
mysql> ** SELECT 0 && NULL;**
-> 0
mysql> ** SELECT NULL && 0;**
-> 0
- OR ||
逻辑 OR。当两个操作数均为非 NULL值时，如有任意一个操作数为非零值，则结果为1，否则结果为0。当有一个操作数为NULL时，如另一个操作数为非零值，则结果为1，否则结果为 NULL 。假如两个操作数均为 NULL，则所得结果为 NULL。
mysql> ** SELECT 1 || 1;**
-> 1
mysql> ** SELECT 1 || 0;**
-> 1
mysql> ** SELECT 0 || 0;**
-> 0
mysql> ** SELECT 0 || NULL;**
-> NULL
mysql> ** SELECT 1 || NULL;**
-> 1
- XOR
逻辑XOR。当任意一个操作数为 NULL时，返回值为NULL。对于非 NULL 的操作数，假如一个奇数操作数为非零值，则计算所得结果为 1 ，否则为 0 。
mysql> ** SELECT 1 XOR 1;**
-> 0
mysql> ** SELECT 1 XOR 0;**
-> 1
mysql> ** SELECT 1 XOR NULL;**
-> NULL
mysql> ** SELECT 1 XOR 1 XOR 1;**
-> 1
a XOR b 的计算等同于 (a AND (NOT b)) OR ((NOT a)和 b)。
同样见 [ 12.1.1节，“操作符优先级”](# "12.1.1. Operator Precedence")。
### 12.2. 控制流程函数
- CASE _ value_ WHEN [_compare-value_] THEN _result_ [WHEN [_compare-value_] THEN _result_ ...] [ELSE _result_] END CASE WHEN [_condition_] THEN _result_ [WHEN [_condition_] THEN _result_ ...] [ELSE _result_] END
在第一个方案的返回结果中， _value_=_compare-value_。而第二个方案的返回结果是第一种情况的真实结果。如果没有匹配的结果值，则返回结果为ELSE后的结果，如果没有ELSE 部分，则返回值为 NULL。
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
一个CASE表达式的默认返回值类型是任何返回值的相容集合类型，但具体情况视其所在语境而定。如果用在字符串语境中，则返回结果味字符串。如果用在数字语境中，则返回结果为十进制值、实值或整数值。
- IF(_expr1_,_expr2_,_expr3_)
如果 _ expr1_是TRUE (_expr1_ <> 0 and _expr1_ <> NULL)，则 IF()的返回值为_expr2_; 否则返回值则为 _expr3_。IF() 的返回值为数字值或字符串值，具体情况视其所在语境而定。
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'
如果_expr2_或_expr3_中只有一个明确是 NULL，则IF() 函数的结果类型 为非NULL表达式的结果类型。
_expr1_ 作为一个整数值进行计算，就是说，假如你正在验证浮点值或字符串值， 那么应该使用比较运算进行检验。
mysql> ** SELECT IF(0.1,1,0);**
-> 0
mysql> ** SELECT IF(0.1<>0,1,0);**
-> 1
在所示的第一个例子中，IF(0.1)的返回值为0，原因是 0.1 被转化为整数值，从而引起一个对 IF(0)的检验。这或许不是你想要的情况。在第二个例子中，比较检验了原始浮点值，目的是为了了解是否其为非零值。比较结果使用整数。
IF() (这一点在其被储存到临时表时很重要 ) 的默认返回值类型按照以下方式计算：
<table border="1" cellpadding="0" id="table1"><tr><td> <p><b> <span>表达式</span></b></p></td> <td> <p><b> <span>返回值</span></b></p></td> </tr><tr><td> <p><i> <span> expr2</span></i><span> </span><span>或<i><span>expr3</span></i><span> </span>返回值为一个字符串。</span></p></td> <td> <p> <span>字符串</span></p></td> </tr><tr><td> <p><i> <span> expr2</span></i><span> </span><span>或<i><span>expr3</span></i><span> </span>返回值为一个浮点值。</span></p></td> <td> <p> <span>浮点</span></p></td> </tr><tr><td> <p><i> <span> expr2</span></i><span> </span><span>或 <i> <span>expr3</span></i><span> </span> 返回值为一个整数。<span> </span></span></p></td> <td> <p> <span>整数</span></p></td> </tr></table>
假如_expr2_和_expr3_ 都是字符串，且其中任何一个字符串区分大小写，则返回结果是区分大小写。
- IFNULL(_expr1_,_expr2_)
假如_expr1_不为 NULL，则 IFNULL() 的返回值为 _expr1_; 否则其返回值为 _expr2_。IFNULL()的返回值是数字或是字符串，具体情况取决于其所使用的语境。
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'
IFNULL(_expr1_,_expr2_)的默认结果值为两个表达式中更加“通用”的一个，顺序为STRING、 REAL或 INTEGER。假设一个基于表达式的表的情况， 或MySQL必须在内存储器中储存一个临时表中IFNULL()的返回值：
CREATE TABLE tmp SELECT IFNULL(1,'test') AS test；
在这个例子中，测试列的类型为 CHAR(4)。
- NULLIF(_expr1_,_expr2_)
如果_expr1_ = _expr2_ 成立，那么返回值为NULL，否则返回值为 _expr1_。这和CASE WHEN _expr1_ = _expr2_ THEN NULL ELSE _expr1_ END相同。
mysql> **SELECT NULLIF(1,1);**
-> NULL
mysql> **SELECT NULLIF(1,2);**
-> 1
注意，如果参数不相等，则 MySQL 两次求得的值为 expr1 。
### 12.3. 字符串函数
[ 12.3.1. 字符串比较函数](#)
假如结果的长度大于 max_allowed_packet 系统变量的最大值时，字符串值函数的返回值为NULL。请参见[7.5.2节，“调节服务器参数”](# "7.5.2. Tuning Server Parameters")。
对于在字符串位置操作的函数，第一个位置的编号为 1。
- ASCII(_str_)
返回值为字符串_str_的最左字符的数值。假如_str_为空字符串，则返回值为 0 。假如_str_为NULL，则返回值为 NULL。 ASCII()用于带有从 0到255的数值的字符。
mysql> **SELECT ASCII('2');**
-> 50
mysql> **SELECT ASCII(2);**
-> 50
mysql> **SELECT ASCII('dx');**
-> 100
见 ORD()函数。
- BIN(_N_)
返回值为_N_的二进制值的字符串表示，其中 _N_为一个longlong (BIGINT) 数字。这等同于 CONV(_N_,10,2)。假如_N_为NULL，则返回值为 NULL。
mysql> **SELECT BIN(12);**
-> '1100'
- BIT_LENGTH(_str_)
返回值为二进制的字符串_str _长度。
mysql> **SELECT BIT_LENGTH('text');**
-> 32
- CHAR(_N_,... [USING _charset_])
CHAR()将每个参数_N_理解为一个整数，其返回值为一个包含这些整数的代码值所给出的字符的字符串。NULL值被省略。
mysql> **SELECT CHAR(77,121,83,81,'76');**
-> 'MySQL'
mysql> **SELECT CHAR(77,77.3,'77.3');**
-> 'MMM'
大于 255的CHAR()参数被转换为多结果字符。 例如，CHAR(256) 相当于 CHAR(1,0), 而CHAR(256*256) 则相当于 CHAR(1,0,0)：
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 |
+------------------+--------------------+
CHAR()的返回值为一个二进制字符串。可选择使用USING语句产生一个给出的字符集中的字符串：
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 |
+---------------------+--------------------------------+
如果 USING已经产生，而结果字符串不符合给出的字符集，则会发出警告。 同样，如果严格的SQL模式被激活，则CHAR()的结果会成为 NULL。
- CHAR_LENGTH(_str_)
返回值为字符串_str_ 的长度，长度的单位为字符。一个多字节字符算作一个单字符。_对于一个_包含五个二字节字符集, LENGTH()返回值为 10, 而CHAR_LENGTH()的返回值为5。
- CHARACTER_LENGTH(_str_)
CHARACTER_LENGTH()是CHAR_LENGTH()的同义词。
- COMPRESS(_string_to_compress_)
压缩一个字符串。这个函数要求 MySQL已经用一个诸如zlib的压缩库压缩过。 否则，返回值始终是NULL。UNCOMPRESS() 可将压缩过的字符串进行解压缩。
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
压缩后的字符串的内容按照以下方式存储：
- 空字符串按照空字符串存储。
- 非空字符串未压缩字符串的四字节长度进行存储(首先为低字节),后面是压缩字符串。如果字符串以空格结尾，就会在后加一个"."号,以防止当结果值是存储在CHAR或VARCHAR类型的字段列时,出现自动把结尾空格去掉的现象。(不推荐使用 CHAR 或VARCHAR 来存储压缩字符串。最好使用一个 BLOB 列代替）。
- CONCAT(_str1_,_str2_,...)
返回结果为连接参数产生的字符串。如有任何一个参数为NULL ，则返回值为 NULL。或许有一个或多个参数。 如果所有参数均为非二进制字符串，则结果为非二进制字符串。 如果自变量中含有任一二进制字符串，则结果为一个二进制字符串。一个数字参数被转化为与之相等的二进制字符串格式；若要避免这种情况，可使用显式类型 cast, 例如： SELECT CONCAT(CAST(int_col AS CHAR), char_col)
mysql> **SELECT CONCAT('My', 'S', 'QL');**
-> 'MySQL'
mysql> **SELECT CONCAT('My', NULL, 'QL');**
-> NULL
mysql> **SELECT CONCAT(14.3);**
-> '14.3'
- CONCAT_WS(_separator_,_str1_,_str2_,...)
CONCAT_WS() 代表 CONCAT With Separator ，是CONCAT()的特殊形式。 第一个参数是其它参数的分隔符。分隔符的位置放在要连接的两个字符串之间。分隔符可以是一个字符串，也可以是其它参数。如果分隔符为 NULL，则结果为 NULL。函数会忽略任何分隔符参数后的 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'
CONCAT_WS()不会忽略任何空字符串。 (然而会忽略所有的 NULL）。
- 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'
mysql> **SELECT EXPORT_SET(6,'1','0',',',10);**
-> '0,1,1,0,0,0,0,0,0,0'
- 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节，“其他函数”](# "12.9.4. Miscellaneous Functions").
- 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'
该函数支持多字节字元。
### 12.3.1. 字符串比较函数
根据，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一起使用以下两种通配符：
<table border="1" cellpadding="0" id="table2"><tr><td> <p> <b> <span> 字符</span></b></p></td> <td> <p> <b> <span> 说明</span></b></p></td> </tr><tr><td> <p> <span> %</span></p></td> <td> <p> <span> 匹配任何数目的字符，甚至包括零字符<span> </span></span></p></td> </tr><tr><td> <p> <span> _</span></p></td> <td> <p> <span> 只能匹配一种字符 </span></p></td> </tr></table>
mysql> **SELECT 'David!' LIKE 'David_';**
-> 1
mysql> **SELECT 'David!' LIKE '%D%v%';**
-> 1
若要对通配符的文字实例进行检验, 可将转义字符放在该字符前面。如果没有指定 ESCAPE字符, 则假设为‘\’。
<table border="1" cellpadding="0" id="table3"><tr><td> <p> <b> <span> 字符串</span></b></p></td> <td width="103"> <p> <b> <span> 说明</span></b></p></td> </tr><tr><td> <p> <span> \%</span></p></td> <td colspan="2"> <p> <span> 匹配一个<span> </span>‘<span>%</span>’字符</span></p></td> </tr><tr><td> <p> <span> \_</span></p></td> <td colspan="2"> <p> <span> 匹配一个 ‘<span>_</span>’ 字符</span></p></td> </tr></table>
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正则表达式_](# "Appendix G. MySQL Regular Expressions")中有详细讨论。若_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() 使用当前字符集。这使得默认的比较区分大小写，当操作数中的一个或两个都是二进制字符串时除外。
### 12.4. 数值函数
[ 12.4.1. 算术操作符](#)[ 12.4.2. 数学函数](#)
### 12.4.1. 算术操作符
可使用常见的算术操作符。注意就 -、 +和 *而言, 若两个参数均为正数，则其计算结果的精确度为 BIGINT (64比特)，若其中一个参数为无符号整数， 而其它参数也是整数, 则结果为无符号整数。请参见[12.8节，“Cast函数和操作符”](# "12.8. Cast Functions and Operators")。
- +
加号:
mysql> **SELECT 3+5;**
-> 8
- -
减号:
mysql> **SELECT 3-5;**
-> -2
- -
一元减号。更换参数符号。
mysql> **SELECT - 2;**
-> -2
**注意**：若该 操作符同一个BIGINT同时使用，则返回值也是一个BIGINT。这意味着你应当尽量避免对可能产生–263的整数使用 –。
- *
乘号:
mysql> **SELECT 3*5;**
-> 15
mysql> **SELECT 18014398509481984*18014398509481984.0;**
-> 324518553658426726783156020576256.0
mysql> **SELECT 18014398509481984*18014398509481984;**
-> 0
最后一个表达式的结果是不正确的。原因是整数相乘的结果超过了BIGINT 计算的 64比特范围。 (见[11.2节，“数值类型”](# "11.2. Numeric Types").)
- /
除号:
mysql> **SELECT 3/5;**
-> 0.60
被零除的结果为 NULL：
mysql> **SELECT 102/(1-1);**
-> NULL
只有当执行的语境中，其结果要被转化为一个整数时 ，除法才会和 BIGINT 算法一起使用。
- DIV
整数除法。 类似于 FLOOR()，然而使用BIGINT 算法也是可靠的。
mysql> **SELECT 5 DIV 2;**
-> 2
### 12.4.2. 数学函数
若发生错误，所有数学函数会返回 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节，“其他函数”](# "12.9.4. Miscellaneous Functions")。
- 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章：](#)[_精度数学_](# "Chapter 24. Precision Math")。
- 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
mysql> **SELECT TRUNCATE(10.28*100,0);**
-> 1028
所有数字的舍入方向都接近于零。
### 12.5. 日期和时间函数
本章论述了一些可用于操作时间值的函数。关于每个时间和日期类型具有的值域及指定值的有效格式，请参见[11.3节，“日期和时间类型”](# "11.3. Date and Time Types")。
下面的例子使用了时间函数。以下询问选择了最近的 30天内所有带有date_col 值的记录：
mysql> **SELECT _something_ FROM _tbl_name_**
-> **WHERE DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= _date_col_;**
注意，这个询问也能选择将来的日期记录。
用于日期值的函数通常会接受时间日期值而忽略时间部分。而用于时间值的函数通常接受时间日期值而忽略日期部分。
返回各自当前日期或时间的函数在每次询问执行开始时计算一次。这意味着在一个单一询问中，对诸如NOW() 的函数多次访问总是会得到同样的结果(未达到我们的目的，单一询问也包括对存储程序或触发器和被该程序/触发器调用的所有子程序的调用 )。这项原则也适用于 CURDATE()、 CURTIME()、 UTC_DATE()、 UTC_TIME()、UTC_TIMESTAMP()，以及所有和它们意义相同的函数。
CURRENT_TIMESTAMP()、 CURRENT_TIME()、 CURRENT_DATE()以及FROM_UNIXTIME()函数返回连接当前时区内的值，这个值可用作time_zone系统变量的值。此外， UNIX_TIMESTAMP() 假设其参数为一个当前时区的时间日期值。请参见[5.10.8节，“MySQL服务器时区支持”](# "5.10.8. MySQL Server Time Zone Support")。
以下函数的论述中返回值的范围会请求完全日期。 若一个日期为“零” 值，或者是一个诸如'2001-11-00'之类的不完全日期， 提取部分日期值的函数可能会返回 0。 例如， DAYOFMONTH('2001-11-00') 会返回0。
- 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服务器时区支持”](# "5.10.8. MySQL Server Time Zone Support")。若自变量无效，则这个函数会返回 NULL。
在从若_from_tz_到UTC的转化过程中，该值超出 TIMESTAMP 类型的被支持范围，那么转化不会发生。关于 TIMESTAMP 范围的论述，请参见[11.1.2节，“日期和时间类型概述”](# "11.1.2. Overview of Date and Time Types")。
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服务器时区支持”](# "5.10.8. MySQL Server Time Zone Support")。
- 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_
- 前言
- 1. 一般信息
- 2. 安装MySQL
- 3. 教程
- 4. MySQL程序概述
- 5. 数据库管理
- 6. MySQL中的复制
- 7. 优化
- 8. 客户端和实用工具程序
- 9. 语言结构
- 10. 字符集支持
- 11. 列类型
- 12. 函数和操作符
- 13. SQL语句语法
- 14. 插件式存储引擎体系结构
- 15. 存储引擎和表类型
- 16. 编写自定义存储引擎
- 17. MySQL簇
- 18. 分区
- 19. MySQL中的空间扩展
- 20. 存储程序和函数
- 21. 触发程序
- 22. 视图
- 23. INFORMATION_SCHEMA信息数据库
- 24. 精度数学
- 25. API和库
- 26. 连接器
- 27. 扩展MySQL
- A. 问题和常见错误
- B. 错误代码和消息
- C. 感谢
- D. MySQL变更史
- E. 移植到其他系统
- F. 环境变量
- G. MySQL正则表达式
- H. MySQL中的限制
- I. 特性限制
- J. GNU通用公共许可
- K. MySQL FLOSS许可例外
- 索引