参考官方文档：

12.5 String Functions

如果结果的长度大于max_allowed_packet系统变量的值，则字符串值函数将返回NULL。 请参见第5.1.1节“配置服务器”。

对于在字符串位置上操作的函数，第一个位置编号为1。

对于具有长度参数的函数，非整数参数四舍五入到最接近的整数。

ASCII(str)

返回字符串str的最左边字符的数字值。 如果str是空字符串，则返回0。 如果str为NULL，则返回NULL。 ASCII（）适用于8位字符。

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,... [USINGcharset_name])

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(X'65')), CHARSET(CHAR(X'65' USING utf8));

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

| CHARSET(CHAR(X'65')) | CHARSET(CHAR(X'65' USING utf8)) |

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

| binary | utf8 |

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

如果给出USING并且给定字符集的结果字符串不合法，则会发出警告。 另外，如果启用严格的SQL模式，则CHAR（）的结果将变为NULL。

CHAR_LENGTH(str)

返回字符串str的长度，以字符度量。 多字节字符算作单个字符。 这意味着对于包含5个2字节字符的字符串，LENGTH（）返回10，而CHAR_LENGTH（）返回5。

CHARACTER_LENGTH(str)

CHARACTER_LENGTH（）是CHAR_LENGTH（）的同义词。

CONCAT(str1,str2,...)

返回连接参数所产生的字符串。 可能有一个或多个参数。 如果所有参数都是非二进制字符串，则结果是非二进制字符串。 如果参数包含任何二进制字符串，则结果是二进制字符串。 数字参数被转换为其等效的非二进制字符串形式。

如果任何参数为null,CONECT（）将返回NULL

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

-> 'MySQL'

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

-> NULL

mysql> SELECT CONCAT(14.3);

-> '14.3'

对于带引号的字符串，可以通过将字符串放在一起进行连接：

mysql> SELECT 'My' 'S' 'QL'; -> 'MySQL'

--这个只适用于均为常量字符串的情况，那为啥不直接写一起呢？

CONCAT_WS(separator,str1,str2,...)

CONCAT_WS（）表示Concatenate With Separator并且是CONCAT（）的一种特殊形式。 第一个参数是其余参数的分隔符。 分隔符被添加在要连接的字符串之间。 分隔符可以是一个字符串，其余的参数也一样。 如果分隔符为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'

--这个就允许NULL值连接，但是分隔符不能为NULL

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

ELT（）返回字符串列表的第N个元素：如果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]])

返回一个字符串，使得对于bit中设置的每个位，都会得到一个on字符串，并且对于该值中未设置的每个位，都会得到一个off字符串。 从右到左检查位（从低位到高位）。 字符串从左到右添加到结果中，由分隔符字符串分隔（缺省为逗号字符）。 检查的位数由number_of_bits给出，如果未指定，缺省值为64。 如果大于64，number_of_bits会自动剪切为64.它被视为无符号整数，所以-1的值与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'

--这是位值，011 二进制就是十进制的6

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

返回str1，str2，str3，...列表中str的索引（位置）。 如果未找到str，则返回0。

如果FIELD（）的所有参数都是字符串，则将所有参数作为字符串进行比较。 如果所有参数都是数字，则将其作为数字进行比较。 否则，参数将以double比较。

如果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范围内的值。 字符串列表是由由字符分隔的子字符串组成的字符串。 如果第一个参数是一个常量字符串，第二个参数是SET类型的一列，那么FIND_IN_SET（）函数会优化为使用位运算。 如果str不在strlist中，或者strlist是空字符串，则返回0。 如果任一参数为NULL，则返回NULL。 如果第一个参数包含逗号（，）字符，则此函数无法正常工作。

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

-> 2

FORMAT(X,D[,locale])

将数字X格式化为像'＃，###，###.##'这样的格式，四舍五入为D小数位，并将结果作为字符串返回。 如果D为0，结果没有小数点或小数部分。

可选的第三个参数可以指定区域设置用于结果数的小数点，千位分隔符和分隔符之间的分组。 允许的语言环境值与lc_time_names系统变量的合法值相同（请参见第10.15节“MySQL服务器语言环境支持”）。 如果未指定区域设置，则缺省值为'en_US'。

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'

mysql> SELECT FORMAT(12332.2,2,'de_DE');

-> '12.332,20'

FROM_BASE64(str)

采用由TO_BASE64（）使用的base-64编码规则编码的字符串，并将解码结果作为二进制字符串返回。 如果参数为NULL或不是有效的base-64字符串，则结果为NULL。 有关编码和解码规则的详细信息，请参阅TO_BASE64（）的说明。

mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));

-> 'JWJj', 'abc'

HEX(str), HEX(N)

对于字符串参数str，HEX（）返回str的十六进制字符串表示形式，其中str中每个字符的每个字节都被转换为两个十六进制数字。 （因此多字节字符变为两位以上）。此函数的反操作由UNHEX（）函数执行。

对于数值参数N，HEX（）返回N值的十六进制字符串表示形式，视为longlong（BIGINT）数字。 这相当于CONV（N，10,16）。 该操作的逆操作由CONV（HEX（N），16,10）执行。

mysql> SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));

-> 'abc', 616263, 'abc'

mysql> SELECT HEX(255), CONV(HEX(255),16,10);

-> 'FF', 255

INSERT(str,pos,len,newstr)

返回字符串str，其中子字符串从位置pos开始，len字符长度由字符串newstr替换。 如果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中第一次出现substr的字符串位置。 这与LOCATE（）的双参数形式相同，只是参数的顺序相反。

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

-> 4

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

-> 0

该函数是多字节安全的，并且仅在至少一个参数是二进制字符串时区分大小写

LCASE(str)

LCASE（）是LOWER（）的同义词。

在MySQL 5.7中，视图中使用的LCASE（）在存储视图的定义时被重写为LOWER（）。 （Bug＃12844279）

LEFT(str,len)

返回字符串str中最左端的len字符，如果任何参数为NULL，则返回NULL。

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

这个函数是多字节安全的。

LENGTH(str)

返回字符串str的长度，以字节为单位。 多字节字符计为多个字节。 这意味着对于包含5个2字节字符的字符串，LENGTH（）返回10，而CHAR_LENGTH（）返回5。

mysql> SELECT LENGTH('text');

-> 4

注意：

Length（）OpenGIS空间函数在MySQL中被命名为ST_Length（）。

LOAD_FILE(file_name)

读取文件并以字符串形式返回文件内容。 要使用此功能，文件必须位于服务器主机上，必须指定文件的完整路径名，并且必须具有FILE权限。 该文件必须全部可读，并且其大小小于max_allowed_packet字节。 如果secure_file_priv系统变量设置为非空目录名称，则要加载的文件必须位于该目录中。

如果由于上述条件之一不满足而导致文件不存在或无法读取，则函数返回NULL

character_set_filesystem系统变量控制对作为文字字符串给出的文件名的解释。

mysql> UPDATE t SET blob_col=LOAD_FILE('/tmp/picture') WHERE id=1;

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

第一个语法返回str中第一次出现substr的位置。 第二个语法返回从位置pos开始的字符串str中第一次出现substr的位置。 如果substr不在str中，则返回0。 如果substr或str为NULL，则返回NULL。

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

-> 4

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

-> 0

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

-> 7

该函数是多字节安全的，并且仅在至少一个参数是二进制字符串时区分大小写。

LOWER(str)

根据当前字符集映射返回字符串str，并将所有字符更改为小写。 默认值是latin1（ West European cp1252）。

mysql> SELECT LOWER('QUADRATICALLY');

-> 'quadratically'

LOWER（）（和UPPER（））在应用于二进制字符串（BINARY，VARBINARY，BLOB）时无效。 要执行大小写转换，请将字符串转换为非二进制字符串：

mysql> SET @str = BINARY 'New York';

mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING latin1));

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

| LOWER(@str) | LOWER(CONVERT(@str USING latin1)) |

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

| New York | new york |

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

对于Unicode字符集的排序规则，LOWER（）和UPPER（）根据排序规则名称中的Unicode排序算法（UCA）版本（如果有）以及UCA 4.0.0（如果未指定版本）进行工作。 例如，utf8_unicode_520_ci根据UCA 5.2.0工作，而utf8_unicode_ci根据UCA 4.0.0工作。 请参见第10.10.1节“Unicode字符集”。

这个函数是多字节安全的。

在之前的MySQL版本中，视图中使用的LOWER（）在存储视图的定义时被重写为LCASE（）。 在MySQL 5.7中，在这种情况下LOWER（）永远不会被重写，但视图中使用的LCASE（）被改写为LOWER（）。 （Bug＃12844279）

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,...)

返回一个设置值（一个字符串，其中包含由字符分隔的子字符串），由设置了位对应位的字符串组成。 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 * 256^2) ...

如果最左边的字符不是多字节字符，则ORD（）将返回与ASCII（）函数相同的值。

mysql> SELECT ORD('2');

-> 50

POSITION(substrINstr)

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重复计数次数组成的字符串。 如果count小于1，则返回一个空字符串。 如果str或count为NULL，则返回NULL。

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

-> 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str)

返回字符串str，并将所有出现的字符串from_str替换为字符串to_str。 搜索from_str时，REPLACE（）执行区分大小写的匹配。

mysql> SELECT REPLACE('MySQL', 'w', 'Ww');

-> 'WwW'

此函数多字节安全

REVERSE(str)

返回字符串str，其字符顺序颠倒。

mysql> SELECT REVERSE('abc');

-> 'cba'

此函数多字节安全

RIGHT(str,len)

返回字符串str中最右侧的len个字符，如果任何参数为NULL，则返回NULL。

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字符串是四个字符长，但SOUNDEX（）函数返回一个任意长的字符串。 您可以在结果上使用SUBSTRING（）来获得标准的soundex字符串。 str中的所有非字母字符都将被忽略。 A-Z范围之外的所有国际字母字符都视为元音。

SPACE(N)

返回由N个空格字符组成的字符串。

mysql> SELECT SPACE(6);

-> ' '

SUBSTR(str,pos), SUBSTR(strFROMpos), SUBSTR(str,pos,len), SUBSTR(strFROMposFORlen)

SUBSTR（）是SUBSTRING（）的同义词。

SUBSTRING(str,pos), SUBSTRING(str FROMpos), SUBSTRING(str,pos,len),SUBSTRING(strFROMposFORlen)

没有len参数的表单从位置pos开始的字符串str返回一个子字符串。 带有len参数的表单从位置pos开始，从字符串str返回长度为len的子字符串。 使用FROM的表单是标准的SQL语法。 也可以对pos使用负值。 在这种情况下，子字符串的开头是字符串末尾的pos字符，而不是开头。 在这个函数的任何形式中pos可以使用负值。

对于所有形式的SUBSTRING（），要从中提取子串的字符串中第一个字符的位置被认为是1。

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，结果是空字符串。

SUBSTRING_INDEX(str,delim,count)

在计数分隔符定界符之前返回字符串str的子串。 如果count是正数，则返回最后一个分隔符左边的数字（从左数起）。 如果计数为负数，则返回最后一个分隔符右边的数字（从右数起）。 SUBSTRING_INDEX（）在搜索delim时执行区分大小写的匹配。

mysql> SELECT SUBSTRING_INDEX('MySQL', '.', 2);

-> ''

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

-> 'MySQL'

此函数多字节安全

TO_BASE64(str)

将字符串参数转换为base-64编码形式，并将结果作为字符串与连接字符集和归类一起返回。 如果参数不是字符串，则在转换发生之前将其转换为字符串。 如果参数为NULL，则结果为NULL。 使用FROM_BASE64（）函数可以解码Base-64编码的字符串。

mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));

-> 'JWJj', 'abc'

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

返回删除了所有remstr前缀或后缀的字符串str。 如果没有给出说明符BOTH，LEADING或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（）的同义词。

在MySQL 5.7中，视图中使用的UCASE（）在存储视图的定义时被重写为UPPER（）。 （Bug＃12844279）

UNHEX(str)

对于字符串参数str，UNHEX（str）将参数中的每对字符解释为十六进制数字，并将其转换为数字表示的字节。 返回值是一个二进制字符串。

mysql> SELECT UNHEX('4D7953514C');

-> 'MySQL'

mysql> SELECT X'4D7953514C';

-> 'MySQL'

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

-> 'string'

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

-> '1267'

参数字符串中的字符必须是合法的十六进制数字：'0'..'9'，'A'..'F'，'a'..'f'。 如果参数包含任何非十六进制数字，则结果为NULL：

mysql> SELECT UNHEX('GG');

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

| UNHEX('GG') |

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

| NULL |

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

如果UNHEX（）的参数是一个BINARY列，则会发生NULL结果，因为值在存储时用0x00字节填充，但这些字节在检索时不会被剥离。 例如，'41'作为'41'被存储到CHAR（3）列中，并被检索为'41'（随着尾部填充空间被剥离），所以列值的UNHEX（）返回'A'。 相比之下，'41'作为'41 \ 0'被存储到BINARY（3）列中，并被检索为'41\0'（尾随缓冲区0x00字节未被剥离）。 '\0'不是合法的十六进制数字，因此列值的UNHEX（）返回NULL。

UPPER(str)

根据当前字符集映射返回字符串str，并将所有字符更改为大写。 默认值是latin1（西欧cp1252）。

mysql> SELECT UPPER('Hej');

-> 'HEJ'

有关也适用于UPPER（）的信息，请参阅LOWER（）的说明。 其中包括有关如何执行这些函数无效的二进制字符串（BINARY，VARBINARY，BLOB）的字母转换的信息以及有关Unicode字符集的大小写折叠的信息。

在之前的MySQL版本中，视图中使用的UPPER（）在存储视图的定义时被重写为UCASE（）。 在MySQL 5.7中，在这种情况下，UPPER（）永远不会被重写，但视图中使用的UCASE（）被改写为UPPER（）。 （Bug＃12844279）

12.5.1 字符串比较函数

如果一个字符串函数被赋予一个二进制字符串作为参数，那么结果字符串也是一个二进制字符串。 转换为字符串的数字被视为二进制字符串。 这只影响比较。

通常，如果字符串比较中的任何表达式区分大小写，则会以区分大小写的方式执行比较。

exprLIKEpat[ESCAPE 'escape_char']

使用SQL模式进行模式匹配。 返回1（TRUE）或0（FALSE）。 如果expr或pat为NULL，则结果为NULL。

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

根据SQL标准，LIKE在每个字符的基础上执行匹配，因此它可以产生不同于=比较运算符的结果：

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;

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

| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |

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

| 0 |

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

mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;

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

| 'ä' = 'ae' COLLATE latin1_german2_ci |

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

| 1 |

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

特别是尾随空格是有意义的，对于使用=运算符执行的CHAR或VARCHAR比较来说并不是这样：

mysql> SELECT 'a' = 'a ', 'a' LIKE 'a ';

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

| 'a' = 'a ' | 'a' LIKE 'a ' |

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

| 1 | 0 |

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

1 row in set (0.00 sec)

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

转义序列应该是空的或一个字符长。 表达式必须在执行时作为常量进行计算。 如果启用NO_BACKSLASH_ESCAPES SQL模式，则序列不能为空。

以下两条语句说明除非其中一个操作数区分大小写（使用区分大小写的归类或二进制字符串），否则字符串比较不区分大小写：

mysql> SELECT 'abc' LIKE 'ABC';

-> 1

mysql> SELECT 'abc' LIKE _latin1 'ABC' COLLATE latin1_general_cs;

-> 0

mysql> SELECT 'abc' LIKE _latin1 'ABC' COLLATE latin1_bin;

-> 0

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

-> 0

作为标准SQL的扩展，MySQL允许在数字表达式上使用LIKE。

mysql> SELECT 10 LIKE '1%';

-> 1

注意：

因为MySQL在字符串中使用C转义语法（例如，\ n来表示换行符），所以您必须加倍使用LIKE字符串中的任何\。 例如，要搜索\n，请将其指定为\\ n。 要搜索\，请将其指定为\\\\; 这是因为反斜杠被解析器剥离了一次，并且当匹配模式匹配时，反斜杠被匹配。

例外：在模式字符串的末尾，反斜杠可以被指定为\\。 在字符串的末尾，反斜杠代表它自己，因为没有任何后续的转义。 假设一个表格包含以下值：

mysql> SELECT filename FROM t1;

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

| filename |

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

| C: |

| C:\ |

| C:\Programs |

| C:\Programs\ |

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

要测试以反斜杠结尾的值，可以使用以下任一模式匹配值：

mysql> SELECT filename, filename LIKE '%\\' FROM t1;

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

| filename | filename LIKE '%\\' |

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

| C: | 0 |

| C:\ | 1 |

| C:\Programs | 0 |

| C:\Programs\ | 1 |

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

mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;

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

| filename | filename LIKE '%\\\\' |

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

| C: | 0 |

| C:\ | 1 |

| C:\Programs | 0 |

| C:\Programs\ | 1 |

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

exprNOT LIKEpat[ESCAPE 'escape_char']

这与NOT（expr LIKE pat [ESCAPE'escape_char']）相同。

注意：

涉及NOT LIKE与包含NULL的列的比较聚合查询可能会产生意外的结果。 例如，请考虑下表和数据：

CREATE TABLE foo (bar VARCHAR(10));

INSERT INTO foo VALUES (NULL), (NULL);

查询SELECT COUNT（*）FROM foo WHERE bar LIKE'％baz％' 返回0; 你可能会认为SELECT COUNT（*）FROM foo WHERE bar NOT LIKE'％baz％'; 将返回2.但是，情况并非如此：第二个查询返回0.这是因为NULL NOT LIKE expr始终返回NULL，无论expr的值如何。 对于使用NOT RLIKE或NOT REGEXP的涉及NULL和比较的聚合查询也是如此。 在这种情况下，您必须使用OR（而不是AND）为NOT NULL显式测试，如下所示：

SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%' OR bar IS NULL;

STRCMP(expr1,expr2)

如果字符串相同，则STRCMP（）返回0;如果第一个参数根据当前排序顺序小于第二个参数，则返回-1，否则返回1。

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

-> -1

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

-> 1

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

-> 0

STRCMP（）使用参数的排序来执行比较。

mysql> SET @s1 = _latin1 'x' COLLATE latin1_general_ci;

mysql> SET @s2 = _latin1 'X' COLLATE latin1_general_ci;

mysql> SET @s3 = _latin1 'x' COLLATE latin1_general_cs;

mysql> SET @s4 = _latin1 'X' COLLATE latin1_general_cs;

mysql> SELECT STRCMP(@s1, @s2), STRCMP(@s3, @s4);

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

| STRCMP(@s1, @s2) | STRCMP(@s3, @s4) |

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

| 0 | 1 |

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

12.5.2 正则表达式

正则表达式是指定复杂搜索模式的有效方法。 本节讨论可用于正则表达式匹配的运算符，并举例说明一些可用于正则表达式操作的特殊字符和结构。 另见第3.3.4.7节“模式匹配”

MySQL使用Henry Spencer的正则表达式实现，这是为了符合POSIX 1003.2。 MySQL使用扩展版本来支持SQL语句中的正则表达式模式匹配操作。 本节不包含Henry Spencer的正则表达式（7）手册页中的所有详细信息。 该手册页包含在MySQL源代码发行版中，位于regex目录下的regex.7文件中。

正则表达式运算符

exprNOT REGEXPpat, exprNOT RLIKEpat

这与NOT（expr REGEXP pat）相同。

exprREGEXPpat, exprRLIKEpat

如果字符串expr匹配通过模式pat指定的表达式，则返回1.如果expr或pat是NULL，则返回值是NULL

RLIKE是REGEXP的同义词

该模式可以是扩展的正则表达式，正则表达式语法中讨论了其语法。 该模式不需要是文字字符串。 例如，它可以被指定为一个字符串表达式或表列。

注意：

由于MySQL在字符串中使用C转义语法（例如，\ n来表示换行符），因此您必须将您在REGEXP参数中使用的2个\。

正则表达式操作在决定字符类型并执行比较时使用字符集和字符串表达式和模式参数的排序规则。 如果参数具有不同的字符集或排序规则，则按第10.8.4节“表达式中的排序规则校验”中所述适用强制性规则。 如果任一参数是二进制字符串，则参数将以区分大小写的方式作为二进制字符串处理。

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

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

| 'Michael!' REGEXP '.*' |

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

| 1 |

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

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

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

| 'new*\n*line' REGEXP 'new\\*.\\*line' |

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

| 0 |

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

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

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

| 'a' REGEXP '^[a-d]' |

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

| 1 |

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

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

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

| 'a' REGEXP 'A' | 'a' REGEXP BINARY 'A' |

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

| 1 | 0 |

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

警告：

REGEXP和RLIKE操作符以字节方式工作，因此它们不是多字节安全的，并且可能会产生多字节字符集意想不到的结果。 另外，即使给定的排序规则将它们视为相等，这些运算符也会按字节值比较字符，而重音字符可能不会相等。

正则表达式语法

正则表达式描述了一组字符串。 最简单的正则表达式是没有特殊字符的正则表达式。 例如，正则表达式hello匹配hello，没有别的。

非平凡的正则表达式使用某些特殊的构造，以便它们可以匹配多个字符串。 例如，正则表达式hello | world包含| 交替运算符并匹配hello或world。

作为一个更复杂的例子，正则表达式B [an] * s匹配字符串Bananas，Baaaaas，Bs和任何其他以B开头，以s结尾，并在之间包含任意数量的a或n的字符 。

REGEXP运算符的正则表达式可以使用以下任何特殊字符和结构：

^

匹配字符串起始

mysql> SELECT 'fo\nfo' REGEXP '^fo$';

-> 0

mysql> SELECT 'fofo' REGEXP '^fo';

-> 1

$

匹配字符串结尾

mysql> SELECT 'fo\no' REGEXP '^fo\no$';

-> 1

mysql> SELECT 'fo\no' REGEXP '^fo$';

-> 0

.

匹配任何字符（包括回车符和换行符）。

mysql> SELECT 'fofo' REGEXP '^f.*$';

-> 1

mysql> SELECT 'fo\r\nfo' REGEXP '^f.*$';

-> 1

a*

匹配零个或多个字符的a 字符。

mysql> SELECT 'Ban' REGEXP '^Ba*n';

-> 1

mysql> SELECT 'Baaan' REGEXP '^Ba*n';

-> 1

mysql> SELECT 'Bn' REGEXP '^Ba*n';

-> 1

a+

匹配任何序列中的一个或多个a字符

mysql> SELECT 'Ban' REGEXP '^Ba+n';

-> 1

mysql> SELECT 'Bn' REGEXP '^Ba+n';

-> 0

a?

匹配零个或一个a字符。

mysql> SELECT 'Bn' REGEXP '^Ba?n';

-> 1

mysql> SELECT 'Ban' REGEXP '^Ba?n';

-> 1

mysql> SELECT 'Baan' REGEXP '^Ba?n';

-> 0

de|abc

匹配de或abc序列中的任一个。

mysql> SELECT 'pi' REGEXP 'pi|apa';

-> 1

mysql> SELECT 'axe' REGEXP 'pi|apa';

-> 0

mysql> SELECT 'apa' REGEXP 'pi|apa';

-> 1

mysql> SELECT 'apa' REGEXP '^(pi|apa)$';

-> 1

mysql> SELECT 'pi' REGEXP '^(pi|apa)$';

-> 1

mysql> SELECT 'pix' REGEXP '^(pi|apa)$';

-> 0

(abc)*

匹配序列abc中的0个或者多个实例

mysql> SELECT 'pi' REGEXP '^(pi)*$';

-> 1

mysql> SELECT 'pip' REGEXP '^(pi)*$';

-> 0

mysql> SELECT 'pipi' REGEXP '^(pi)*$';

-> 1

{1}, {2,3}

重复; {n}和{m，n}表示法提供了一种更通用的方式来编写正则表达式，该正则表达式匹配模式的以前原子（或“片段”）的多次出现。 m和n是整数。

a*

可以被写成 a{0,}

a+

可以被写成a{1,}

a?

可以被写成a{0,1}

更确切地说，a{n}恰好与a的n个实例匹配。 a{n，}匹配一个或多个a的实例。 a {m，n}通含a的n到m个实例。 如果给定m和n，则m必须小于或等于n。

m和n必须在0到RE_DUP_MAX（默认值为255）的范围内。

mysql> SELECT 'abcde' REGEXP 'a[bcd]{2}e';

-> 0

mysql> SELECT 'abcde' REGEXP 'a[bcd]{3}e';

-> 1

mysql> SELECT 'abcde' REGEXP 'a[bcd]{1,10}e';

-> 1

[a-dX], [^a-dX]

匹配任何（或不是，如果使用^）a，b，c，d或X的字符。A-两个其他字符之间的字符形成一个匹配从第一个字符到第二个字符的所有字符的范围。 例如，[0-9]匹配任何十进制数字。 要包含一个文字]字符，它必须紧跟在左括号[。 要包含一个-字符，它必须首先写入或最后写入。 任何在[]对中没有定义的特殊含义的字符只能匹配自身。

mysql> SELECT 'aXbc' REGEXP '[a-dXYZ]';

-> 1

mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]$';

-> 0

mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]+$';

-> 1

mysql> SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$';

-> 0

mysql> SELECT 'gheis' REGEXP '^[^a-dXYZ]+$';

-> 1

mysql> SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$';

-> 0

[.characters.]

在括号表达式中（写作使用[和]），匹配该整理元素的字符序列。 字符既可以是单个字符，也可以是像换行符这样的字符名称。 下表列出了允许的字符名称。

下表显示了允许的字符名称及其匹配的字符。 对于以数值形式给出的字符，值以八进制表示。

--表（略）

mysql> SELECT '~' REGEXP '[[.~.]]';

-> 1

mysql> SELECT '~' REGEXP '[[.tilde.]]';

-> 1

[=character_class=]

在括号表达式中（使用[和]），[= character_class =]表示等价类。 它匹配具有相同排序规则值的所有字符，包括自身。 例如，如果o和（+）是等价类的成员，[[= o =]]，[[=（+）=]]和[o（+）]都是同义词。 等价类不能用作范围的端点。

[:character_class:]

在括号表达式中（使用[和]），[：character_class：]表示匹配属于该类的所有字符的字符类。 下表列出了标准类名。 这些名称代表ctype（3）手册页中定义的字符类。 特定的语言环境可能会提供其他类名称。 字符类不能

mysql> SELECT 'justalnums' REGEXP '[[:alnum:]]+';

-> 1

mysql> SELECT '!!' REGEXP '[[:alnum:]]+';

-> 0

[[:<:]], [[:>:]]

这些标记代表单词边界。 它们分别匹配单词的开头和结尾。 单词是单词字符之前或之后没有的单词字符序列。 单词字符是alnum类的字母数字字符或下划线（_）。

mysql> SELECT 'a word a' REGEXP '[[:<:]]word[[:>:]]';

-> 1

mysql> SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]';

-> 0

要在正则表达式中使用特殊字符的文字实例，请在其前面加上两个反斜杠（\）字符。 MySQL解析器解释其中一个反斜杠，而正则表达式库解释另一个反斜杠。 例如，要匹配包含特殊+字符的字符串1 + 2，只有最后一个正则表达式是正确的：

mysql> SELECT '1+2' REGEXP '1+2';

-> 0

mysql> SELECT '1+2' REGEXP '1\+2';

-> 0

mysql> SELECT '1+2' REGEXP '1\\+2';

-> 1