Mysql8【有与无】M12.字符串函数和运算符

12.8 字符串函数和运算符

表 12.12 字符串函数和运算符

名称	描述
ASCII()	返回最左边字符的数值
BIN()	返回一个包含数字二进制表示的字符串
BIT_LENGTH()	返回参数的长度（以位为单位）
CHAR()	返回传递的每个整数的字符
CHAR_LENGTH()	返回参数中的字符数
CHARACTER_LENGTH()	CHAR_LENGTH() 的同义词
CONCAT()	返回连接的字符串
CONCAT_WS()	返回与分隔符连接
ELT()	返回索引号处的字符串
EXPORT_SET()	返回一个字符串，这样对于值位中设置的每个位，您都会得到一个 on 字符串，对于每个未设置的位，您都会得到一个 off 字符串
FIELD()	后续参数中第一个参数的索引（位置）
FIND_IN_SET()	第二个参数中第一个参数的索引（位置）
FORMAT()	返回格式化为指定小数位数的数字
FROM_BASE64()	解码base64编码字符串并返回结果
HEX()	十进制或字符串值的十六进制表示
INSERT()	在指定位置插入子字符串，最多指定字符数
INSTR()	返回子字符串第一次出现的索引
LCASE()	LOWER() 的同义词
LEFT()	返回指定的最左边的字符数
LENGTH()	返回字符串的长度（以字节为单位）
LIKE	简单的模式匹配
LOAD_FILE()	加载命名文件
LOCATE()	返回子字符串第一次出现的位置
LOWER()	以小写形式返回参数
LPAD()	返回字符串参数，左填充指定的字符串
LTRIM()	删除前导空格
MAKE_SET()	返回一组逗号分隔的字符串，这些字符串在 bits 集中具有相应的位
MATCH()	执行全文搜索
MID()	返回从指定位置开始的子字符串
NOT LIKE	简单模式匹配的否定
NOT REGEXP	否定正则表达式
OCT()	返回包含数字的八进制表示的字符串
OCTET_LENGTH()	LENGTH() 的同义词
ORD()	返回参数最左边字符的字符代码
POSITION()	LOCATE() 的同义词
QUOTE()	转义参数以在 SQL 语句中使用
REGEXP	字符串是否匹配正则表达式
REGEXP_INSTR()	子串匹配正则表达式的起始索引
REGEXP_LIKE()	字符串是否匹配正则表达式
REGEXP_REPLACE()	替换匹配正则表达式的子字符串
REGEXP_SUBSTR()	返回匹配正则表达式的子字符串
REPEAT()	重复一个字符串指定的次数
REPLACE()	替换指定字符串的出现
REVERSE()	反转字符串中的字符
RIGHT()	返回指定的最右边的字符数
RLIKE	字符串是否匹配正则表达式
RPAD()	附加字符串指定次数
RTRIM()	删除尾随空格
SOUNDEX()	返回一个 soundex 字符串
SOUNDS LIKE	比较声音
SPACE()	返回指定空格数的字符串
STRCMP()	比较两个字符串
SUBSTR()	返回指定的子字符串
SUBSTRING()	返回指定的子字符串
SUBSTRING_INDEX()	从指定出现次数的分隔符之前的字符串中返回子字符串
TO_BASE64()	返回转换为 base-64 字符串的参数
TRIM()	删除前导和尾随空格
UCASE()	UPPER() 的同义词
UNHEX()	返回包含数字的十六进制表示的字符串
UPPER()	转换为大写
WEIGHT_STRING()	返回字符串的权重字符串

如果结果的长度大于 max_allowed_pa​​cket 系统变量的值，则字符串值函数返回 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 的长度（以位为单位）。如果 str 为 NULL，则返回 NULL。

mysql> SELECT BIT_LENGTH('text');
        -> 32

CHAR(N,… [USING charset_name])

CHAR() 将每个参数 N 解释为一个整数，并返回一个字符串，该字符串由这些整数的代码值给出的字符组成。 NULL 值被跳过。`在这里插入代码片

mysql> SELECT CHAR(77,121,83,81,'76');
+--------------------------------------------------+
| CHAR(77,121,83,81,'76')                          |
+--------------------------------------------------+
| 0x4D7953514C                                     |
+--------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CHAR(77,77.3,'77.3');
+--------------------------------------------+
| CHAR(77,77.3,'77.3')                       |
+--------------------------------------------+
| 0x4D4D4D                                   |
+--------------------------------------------+
1 row in set (0.00 sec)

默认情况下，CHAR() 返回一个二进制字符串。要生成给定字符集中的字符串，请使用可选的 USING 子句：

mysql> SELECT CHAR(77,121,83,81,'76' USING utf8mb4);
+---------------------------------------+
| CHAR(77,121,83,81,'76' USING utf8mb4) |
+---------------------------------------+
| MySQL                                 |
+---------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CHAR(77,77.3,'77.3' USING utf8mb4);
+------------------------------------+
| CHAR(77,77.3,'77.3' USING utf8mb4) |
+------------------------------------+
| MMM                                |
+------------------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;
+---------+------+-------------------------------------------+
| Level   | Code | Message                                   |
+---------+------+-------------------------------------------+
| Warning | 1292 | Truncated incorrect INTEGER value: '77.3' |
+---------+------+-------------------------------------------+
1 row in set (0.00 sec)

如果给出了 USING 并且结果字符串对于给定的字符集是非法的，则会发出警告。此外，如果启用了严格的 SQL 模式，则 CHAR() 的结果将变为 NULL。
如果从 mysql 客户端调用 CHAR()，则二进制字符串使用十六进制表示法显示，具体取决于 --binary-as-hex 的值。有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”。
大于 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           |
+----------------+----------------+
1 row in set (0.00 sec)

mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
+------------------+--------------------+
| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
+------------------+--------------------+
| 010000           | 010000             |
+------------------+--------------------+
1 row in set (0.00 sec)

CHAR_LENGTH(str)

返回字符串 str 的长度，以代码点为单位。多字节字符计为单个代码点。这意味着，对于包含两个 3 字节字符的字符串，LENGTH() 返回 6，而 CHAR_LENGTH() 返回 2，如下所示：

mysql> SET @dolphin:='海豚';
Query OK, 0 rows affected (0.01 sec)

mysql> SELECT LENGTH(@dolphin), CHAR_LENGTH(@dolphin);
+------------------+-----------------------+
| LENGTH(@dolphin) | CHAR_LENGTH(@dolphin) |
+------------------+-----------------------+
|                6 |                     2 |
+------------------+-----------------------+
1 row in set (0.00 sec)

如果 str 为 NULL，CHAR_LENGTH() 返回 NULL。

CHARACTER_LENGTH(str)

CHARACTER_LENGTH() 是 CHAR_LENGTH() 的同义词。

CONCAT(str1,str2,…)

返回由连接参数产生的字符串。可能有一个或多个参数。如果所有参数都是非二进制字符串，则结果是非二进制字符串。如果参数包含任何二进制字符串，则结果为二进制字符串。一个数字参数被转换成它的等价的非二进制字符串形式。
如果任何参数为 NULL，则 CONCAT() 返回 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

如果从 mysql 客户端调用 CONCAT()，则二进制字符串结果使用十六进制表示法显示，具体取决于 --binary-as-hex 的值。有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - 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'

CONCAT_WS() 不会跳过空字符串。但是，它会跳过分隔符参数之后的任何 NULL 值。

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

ELT() 返回字符串列表的第 N 个元素：如果 N = 1，则返回 str1，如果 N = 2，则返回 str2，依此类推。如果 N 小于 1、大于参数的数量或 NULL，则返回 NULL。 ELT() 是 FIELD() 的补码。

mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
        -> 'Aa'
mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
        -> 'Dd'

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

返回一个字符串，这样对于值位中设置的每个位，您都会获得一个 on 字符串，对于值中未设置的每个位，您都会获得一个 off 字符串。从右到左（从低位到高位）检查位中的位。字符串从左到右添加到结果中，由分隔符字符串分隔（默认为逗号字符，）。检查的位数由 number_of_bits 给出，如果未指定，则默认为 64。如果 number_of_bits 大于 64，则默认将其剪裁为 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'

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

返回 str1, str2, str3, … 列表中 str 的索引（位置）。如果未找到 str，则返回 0。
如果 FIELD() 的所有参数都是字符串，则所有参数都作为字符串进行比较。如果所有参数都是数字，则将它们作为数字进行比较。否则，参数将作为双精度进行比较。
如果 str 为 NULL，则返回值为 0，因为 NULL 无法与任何值进行相等比较。 FIELD() 是 ELT() 的补码。

mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
        -> 2
mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
        -> 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，则结​​果没有小数点或小数部分。如果 X 或 D 为 NULL，则函数返回 NULL。

可选的第三个参数允许指定区域设置以用于结果数字的小数点、千位分隔符和分隔符之间的分组。允许的区域设置值与 lc_time_names 系统变量的合法值相同（请参阅第 10.16 节，“MySQL 服务器区域设置支持”）。如果区域设置为 NULL 或未指定，则默认区域设置为“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'

如果从 mysql 客户端调用 FROM_BASE64()，则二进制字符串使用十六进制表示法显示。您可以通过在启动 mysql 客户端时将 --binary-as-hex 的值设置为 0 来禁用此行为。有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”。

HEX(str), HEX(N)

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

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

对于NULL参数，此函数返回 NULL.

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 字符 long 被字符串 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

此函数是多字节安全的，并且仅当至少一个参数是二进制字符串时才区分大小写。如果任一参数是NULL，此函数返回 NULL。

LCASE(str)

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

LCASE()视图中使用的内容被重写为 LOWER()存储视图定义时。（缺陷号 12844279）

LEFT(str,len)

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

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

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

LENGTH(str)

返回字符串 str 的长度，以字节为单位。一个多字节字符计为多个字节。这意味着对于包含五个 2 字节字符的字符串，LENGTH() 返回 10，而 CHAR_LENGTH() 返回 5。如果 str 为 NULL，则返回 NULL。

mysql> SELECT LENGTH('text');
        -> 4

笔记
Length() OpenGIS 空间函数在 MySQL 中被命名为 ST_Length()

LOAD_FILE(file_name)

读取文件并将文件内容作为字符串返回。要使用此功能，文件必须位于服务器主机上，您必须指定文件的完整路径名，并且您必须具有FILE权限。该文件必须可由服务器读取，并且其大小小于 max_allowed_packet字节。如果secure_file_priv系统变量设置为非空目录名，则要加载的文件必须位于该目录中。（在 MySQL 8.0.17 之前，该文件必须对所有人可读，而不仅仅是服务器可读。）

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

character_set_filesystem 系统变量控制以文字字符串形式给出的文件名的解释 。

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

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

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

mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7

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

LOWER(str)

返回根据当前字符集映射将所有字符更改为小写的字符串 str，如果 str 为 NULL，则返回 NULL。默认字符集是 utf8mb4。

mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'

LOWER()（和 UPPER()）在应用于二进制字符串（BINARY、VARBINARY、BLOB）时无效。要执行二进制字符串的字母大小写转换，首先使用适合存储在字符串中的数据的字符集将其转换为非二进制字符串：

mysql> SET @str = BINARY 'New York';
mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING utf8mb4));
+-------------+------------------------------------+
| LOWER(@str) | LOWER(CONVERT(@str USING utf8mb4)) |
+-------------+------------------------------------+
| New York    | new york                           |
+-------------+------------------------------------+

对于 Unicode 字符集的排序规则，LOWER() 和 UPPER() 根据排序规则名称中的 Unicode 排序算法 (UCA) 版本（如果有）工作，如果没有指定版本，则根据 UCA 4.0.0 工作。例如，utf8mb4_0900_ai_ci 和 utf8mb3_unicode_520_ci 分别根据 UCA 9.0.0 和 5.2.0 工作，而 utf8mb3_unicode_ci 根据 UCA 4.0.0 工作。请参阅第 10.10.1 节，“Unicode 字符集”。

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

LCASE()在视图中使用的被重写为 LOWER().

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

如果它的任何参数是 NULL, 则 返回NULL。

LTRIM(str)

返回str删除了前导空格字符的字符串。如果 str是NULL ，则返回NULL。

mysql> SELECT LTRIM('  barbar');
        -> 'barbar'

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

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()。如果 str是NULL，函数返回NULL。

mysql> SELECT ORD('2');
        -> 50

POSITION(substr IN str)

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

QUOTE(str)

引用字符串以生成可用作 SQL 语句中正确转义的数据值的结果。返回的字符串用单引号括起来，并且每个反斜杠 ( )、单引号 ( ')、ASCIINUL和 Control+Z 的实例都以反斜杠开头。如果参数是 NULL，则返回值是单词 “ NULL ”，不带单引号。

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

为了比较，请参阅第 9.1.1 节“字符串文字”和 mysql_real_escape_string_quote() 中的文字字符串和 C API 中的引用规则。

REPEAT(str,count)

返回由字符串 str 重复 count 次组成的字符串。如果 count 小于 1，则返回一个空字符串。如果 str 或 count 为 NULL，则返回 NULL。

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

这个函数是多字节安全的。如果它的任何参数是 NULL， 它就会返回 NULL。

REVERSE(str)

返回字符顺序颠倒的字符串 str，如果 str 为 NULL，则返回 NULL。

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 个字符。如果 str、padstr 或 len 为 NULL，则函数返回 NULL。

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

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

RTRIM(str)

返回删除了尾随空格字符的字符串 str。

mysql> SELECT RTRIM('barbar   ');
        -> 'barbar'

这个函数是多字节安全的，如果 str 为 NULL，则返回 NULL。

SOUNDEX(str)

从 str 返回 soundex 字符串，如果 str 为 NULL，则返回 NULL。听起来几乎相同的两个字符串应该具有相同的 soundex 字符串。一个标准的 soundex 字符串是四个字符长，但 SOUNDEX() 函数返回一个任意长的字符串。您可以在结果上使用 SUBSTRING() 来获得标准的 soundex 字符串。 str 中的所有非字母字符都将被忽略。 A-Z 范围之外的所有国际字母字符都被视为元音。

重要的
使用时SOUNDEX()，您应该注意以下限制：
1.当前实现的此功能旨在与仅使用英语的字符串很好地配合使用。其他语言的字符串可能不会产生可靠的结果。
2.此函数不保证提供与使用多字节字符集的字符串一致的结果，包括utf-8. 有关详细信息，请参阅错误 #22638。

mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'

笔记
这个函数实现了原始的 Soundex 算法，而不是更流行的增强版本（也由 D. Knuth 描述）。不同之处在于原始版本先丢弃元音，然后重复，而增强版先丢弃重复，然后再丢弃元音。

expr1 SOUNDS LIKE expr2

等价于SOUNDEX(expr1) = SOUNDEX(expr2).

SPACE(N)

返回由 N 个空格字符组成的字符串，如果 N 为 NULL，则返回 NULL。

mysql> SELECT SPACE(6);
        -> '      '

SUBSTR(str,pos), , , SUBSTR(str FROM pos)SUBSTR(str,pos,len)SUBSTR(str FROM pos FOR len)

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

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

没有 len 参数的表单从位置 pos 开始的字符串 str 返回一个子字符串。带有 len 参数的表单从字符串 str 返回一个子字符串 len 个字符，从位置 pos 开始。使用 FROM 的表单是标准 SQL 语法。也可以对 pos 使用负值。在这种情况下，子字符串的开头是字符串末尾的 pos 个字符，而不是开头。负值可用于此函数的任何形式的 pos。 pos 的值为 0 返回一个空字符串。
对于所有形式的 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'

这个函数是多字节安全的。如果其任何参数为 NULL，则返回 NULL。
如果 len 小于 1，则结果为空字符串。

SUBSTRING_INDEX(str,delim,count)

在计数出现分隔符 delim 之前从字符串 str 返回子字符串。如果 count 为正，则返回最终分隔符左侧的所有内容（从左侧开始计数）。如果 count 为负数，则返回最终分隔符右侧（从右侧开始计数）的所有内容。 SUBSTRING_INDEX() 在搜索 delim 时执行区分大小写的匹配。

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

这个函数是多字节安全的。
如果任何参数为 NULL，则 SUBSTRING_INDEX() 返回 NULL。

TO_BASE64(str)

将字符串参数转换为 base-64 编码形式，并将结果作为带有连接字符集和排序规则的字符串返回。如果参数不是字符串，则在转换之前将其转换为字符串。如果参数为 NULL，则结果为 NULL。 Base-64 编码字符串可以使用 FROM_BASE64() 函数进行解码。

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

存在不同的 base-64 编码方案。这些是 TO_BASE64() 和 FROM_BASE64() 使用的编码和解码规则：

• 字母值 62 的编码是 ‘+’.
• 字母值 63 的编码是 ‘/’.
• 编码输出由 4 个可打印字符组成。输入数据的每 3 个字节使用 4 个字符进行编码。如果最后一组不完整，则用’='字符填充，长度为 4。
• 在编码输出的每 76 个字符之后添加一个换行符，以将长输出分成多行。
• 解码识别并忽略换行符、回车符、制表符和空格。

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'

这个函数是多字节安全的。如果其任何参数为 NULL，则返回 NULL。

UCASE(str)

UCASE()是 的同义词 UPPER()。
UCASE()在视图中使用的被重写为 UPPER().

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，则结果为 NULL：

mysql> SELECT UNHEX('GG');
+-------------+
| UNHEX('GG') |
+-------------+
| NULL        |
+-------------+

mysql> SELECT UNHEX(NULL);
+-------------+
| UNHEX(NULL) |
+-------------+
| NULL        |
+-------------+

如果 UNHEX() 的参数是 BINARY 列，也可能出现 NULL 结果，因为值在存储时用 0x00 字节填充，但在检索时不会删除这些字节。例如，“41”作为“41”存储到 CHAR(3) 列中，检索为“41”（去除了尾随空格），因此列值的 UNHEX() 返回 X’41’。相比之下，“41”作为“41\0”存储到 BINARY(3) 列中，并作为“41\0”检索（没有去除尾随填充 0x00 字节）。 ‘\0’ 不是合法的十六进制数字，因此列值的 UNHEX() 返回 NULL。
对于数字参数 N，UNHEX() 不执行 HEX(N) 的逆运算。改用 CONV(HEX(N),16,10)。请参阅 HEX() 的描述。
如果从 mysql 客户端调用 UNHEX()，则二进制字符串使用十六进制表示法显示，具体取决于 --binary-as-hex 的值。有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”。

UPPER(str)

返回根据当前字符集映射将所有字符更改为大写的字符串 str，如果 str 为 NULL，则返回 NULL。默认字符集是 utf8mb4。

mysql> SELECT UPPER('Hej');
        -> 'HEJ'

有关也适用于 UPPER() 的信息，请参见 LOWER() 的描述。这包括有关如何对这些函数无效的二进制字符串（BINARY、VARBINARY、BLOB）执行字母大小写转换的信息，以及有关 Unicode 字符集的大小写折叠的信息。
这个函数是多字节安全的。
视图中使用的 UCASE() 被重写为 UPPER()。

WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [flags])

此函数返回输入字符串的权重字符串。返回值是一个二进制字符串，表示字符串的比较和排序值，如果参数为 NULL，则返回 NULL。它具有以下属性：

• 如果 WEIGHT_STRING(str1) = WEIGHT_STRING(str2)，则 str1 = str2（认为 str1 和 str2 相等）
• 如果 WEIGHT_STRING(str1) < WEIGHT_STRING(str2)，则 str1 < str2（str1 排在 str2 之前）

WEIGHT_STRING() 是一个供内部使用的调试函数。它的行为可以在 MySQL 版本之间更改，恕不另行通知。它可用于测试和调试排序规则，尤其是在添加新排序规则时。请参阅第 10.14 节，“向字符集添加排序规则”。

此列表简要总结了这些论点。更多细节在列表后面的讨论中给出。

• str: 输入字符串表达式。
• AS子句：可选；将输入字符串强制转换为给定的类型和长度。
• flags： 可选的; 没用过。

输入字符串 str 是一个字符串表达式。如果输入是非二进制（字符）字符串，例如 CHAR、VARCHAR 或 TEXT 值，则返回值包含字符串的排序规则权重。如果输入是二进制（字节）字符串，例如 BINARY、VARBINARY 或 BLOB 值，则返回值与输入相同（二进制字符串中每个字节的权重就是字节值）。如果输入为 NULL，则 WEIGHT_STRING() 返回 NULL。

例子：

mysql> SET @s = _utf8mb4 'AB' COLLATE utf8mb4_0900_ai_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 1C471C60               |
+------+---------+------------------------+

mysql> SET @s = _utf8mb4 'ab' COLLATE utf8mb4_0900_ai_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 1C471C60               |
+------+---------+------------------------+

mysql> SET @s = CAST('AB' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 4142                   |
+------+---------+------------------------+

mysql> SET @s = CAST('ab' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 6162                   |
+------+---------+------------------------+

前面的示例使用 HEX() 来显示 WEIGHT_STRING() 结果。因为结果是一个二进制值，所以当结果包含非打印值时，HEX() 尤其有用，可以以可打印的形式显示它：

mysql> SET @s = CONVERT(X'C39F' USING utf8mb4) COLLATE utf8mb4_czech_ci;
mysql> SELECT HEX(WEIGHT_STRING(@s));
+------------------------+
| HEX(WEIGHT_STRING(@s)) |
+------------------------+
| 0FEA0FEA               |
+------------------------+

对于非 NULL 返回值，如果其长度在 VARBINARY 的最大长度范围内，则该值的数据类型为 VARBINARY，否则数据类型为 BLOB。

可以使用 AS 子句将输入字符串强制转换为非二进制或二进制字符串，并将其强制为给定长度：

• AS CHAR(N) 将字符串转换为非二进制字符串，并在右侧用空格填充一个 N字符长度。 N必须至少为 1。如果 N小于输入字符串的长度，则将字符串截断为 N字符。不会出现截断警告。
• AS BINARY(N) 类似，但将字符串转换为二进制字符串， N以字节（不是字符）为单位，填充使用0x00 字节（不是空格）。

mysql> SET NAMES 'latin1';
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 41422020                            |
+-------------------------------------+
mysql> SET NAMES 'utf8mb4';
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 1C471C60                            |
+-------------------------------------+

mysql> SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));
+---------------------------------------+
| HEX(WEIGHT_STRING('ab' AS BINARY(4))) |
+---------------------------------------+
| 61620000                              |
+---------------------------------------+

该flags子句目前未使用。

如果WEIGHT_STRING()从mysql客户端中调用，则二进制字符串使用十六进制表示法显示，具体取决于–binary-as-hex. 有关该选项的更多信息，请参阅 第 4.5.1 节，“mysql - MySQL 命令行客户端”。

12.8.1 字符串比较函数和运算符

表 12.13 字符串比较函数和运算符

名称	描述
LIKE	简单的模式匹配
NOT LIKE	简单模式匹配的否定
STRCMP()	比较两个字符串

如果给字符串函数一个二进制字符串作为参数，则生成的字符串也是一个二进制字符串。转换为字符串的数字被视为二进制字符串。这仅影响比较。

通常，如果字符串比较中的任何表达式区分大小写，则以区分大小写的方式执行比较。
如果从 mysql客户端调用字符串函数，则二进制字符串使用十六进制表示法显示，具体取决于 --binary-as-hex. 有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”。

expr LIKE pat [ESCAPE ‘escape_char’]

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

模式不必是文字字符串。例如，它可以指定为字符串表达式或表格列。在后一种情况下，列必须定义为 MySQL 字符串类型之一（请参阅第 11.3 节，“字符串数据类型”）。

根据 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 和 TEXT 值）中的尾随空格的重要性取决于用于比较的排序规则的填充属性。有关更多信息，请参阅比较中的尾随空格处理。

使用 LIKE，您可以在模式中使用以下两个通配符：

• % 匹配任意数量的字符，甚至是零个字符。
• _ 只匹配一个字符。

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

要测试通配符的文字实例，请在其前面加上转义字符。如果未指定 ESCAPE 字符，则假定为 \，除非启用了 NO_BACKSLASH_ESCAPE SQL 模式。在这种情况下，不使用转义字符。

• % 匹配一个 % 字符。
• _ 匹配一个 _ 字符。

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 _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
        -> 0
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
        -> 0
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

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

mysql> SELECT 10 LIKE '1%';
        -> 1

笔记
MySQL 在字符串中使用 C 转义语法（例如，\n 表示换行符）。如果您希望 LIKE 字符串包含文字 \，则必须将其加倍。 （除非启用了 NO_BACKSLASH_ESCAPES SQL 模式，在这种情况下不使用转义字符。）例如，要搜索 \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 |
+--------------+-----------------------+

expr NOT LIKE pat [ESCAPE ‘escape_char’]

这与 NOT (expr LIKE pat [ESCAPE ‘escape_char’]) 相同。

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

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 的值。对于涉及 NULL 和使用 NOT RLIKE 或 NOT REGEXP 的比较的聚合查询也是如此。在这种情况下，您必须使用 OR（而不是 AND）显式测试 NOT NULL，如下所示：

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

STRCMP(expr1,expr2)

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

mysql> SELECT STRCMP('text', 'text2');
        -> -1
mysql> SELECT STRCMP('text2', 'text');
        -> 1
mysql> SELECT STRCMP('text', 'text');
        -> 0

STRCMP() 使用参数的排序规则执行比较。

mysql> SET @s1 = _utf8mb4 'x' COLLATE utf8mb4_0900_ai_ci;
mysql> SET @s2 = _utf8mb4 'X' COLLATE utf8mb4_0900_ai_ci;
mysql> SET @s3 = _utf8mb4 'x' COLLATE utf8mb4_0900_as_cs;
mysql> SET @s4 = _utf8mb4 'X' COLLATE utf8mb4_0900_as_cs;
mysql> SELECT STRCMP(@s1, @s2), STRCMP(@s3, @s4);
+------------------+------------------+
| STRCMP(@s1, @s2) | STRCMP(@s3, @s4) |
+------------------+------------------+
|                0 |               -1 |
+------------------+------------------+

如果排序规则不兼容，则必须将其中一个参数转换为与另一个兼容。请参阅第 10.8.4 节，“表达式中的排序规则强制性”。

mysql> SET @s1 = _utf8mb4 'x' COLLATE utf8mb4_0900_ai_ci;
mysql> SET @s2 = _utf8mb4 'X' COLLATE utf8mb4_0900_ai_ci;
mysql> SET @s3 = _utf8mb4 'x' COLLATE utf8mb4_0900_as_cs;
mysql> SET @s4 = _utf8mb4 'X' COLLATE utf8mb4_0900_as_cs;
-->
mysql> SELECT STRCMP(@s1, @s3);
ERROR 1267 (HY000): Illegal mix of collations (utf8mb4_0900_ai_ci,IMPLICIT)
and (utf8mb4_0900_as_cs,IMPLICIT) for operation 'strcmp'
mysql> SELECT STRCMP(@s1, @s3 COLLATE utf8mb4_0900_ai_ci);
+---------------------------------------------+
| STRCMP(@s1, @s3 COLLATE utf8mb4_0900_ai_ci) |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+

12.8.2 正则表达式

表 12.14 正则表达式函数和运算符

名称	描述
NOT REGEXP	否定正则表达式
REGEXP	字符串是否匹配正则表达式
REGEXP_INSTR()	子串匹配正则表达式的起始索引
REGEXP_LIKE()	字符串是否匹配正则表达式
REGEXP_REPLACE()	替换匹配正则表达式的子字符串
REGEXP_SUBSTR()	返回匹配正则表达式的子字符串
RLIKE	字符串是否匹配正则表达式

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

MySQL 使用 Unicode 国际组件 (ICU) 实现正则表达式支持，它提供完整的 Unicode 支持并且是多字节安全的。 （在 MySQL 8.0.4 之前，MySQL 使用 Henry Spencer 的正则表达式实现，它以字节方式运行并且不是多字节安全的。有关使用正则表达式的应用程序可能受实现更改影响的方式的信息，请参阅正则表达式兼容性注意事项。）

在 MySQL 8.0.22 之前，可以对这些函数使用二进制字符串参数，但它们会产生不一致的结果。在 MySQL 8.0.22 及更高版本中，使用任何 MySQL 正则表达式函数的二进制字符串都会被 ER_CHARACTER_SET_MISMATCH 拒绝。

• 正则表达式函数和运算符说明
• 正则表达式语法
• 正则表达式资源控制
• 正则表达式兼容性注意事项

1）正则表达式函数和运算符说明

expr NOT REGEXP pat, expr NOT RLIKE pat

这与 NOT (expr REGEXP pat) 相同。

expr REGEXP pat, expr RLIKE pat

如果字符串 expr 与模式 pat 指定的正则表达式匹配，则返回 1，否则返回 0。如果 expr 或 pat 为 NULL，则返回值为 NULL。

REGEXP 和 RLIKE 是 REGEXP_LIKE() 的同义词。

有关如何进行匹配的更多信息，请参阅 REGEXP_LIKE() 的说明。

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

REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])

返回与模式 pat 指定的正则表达式匹配的字符串 expr 的子字符串的起始索引，如果不匹配，则返回 0。如果 expr 或 pat 为 NULL，则返回值为 NULL。字符索引从 1 开始。

REGEXP_INSTR() 采用这些可选参数：

• pos: expr 中开始搜索的位置。如果省略，则默认值为 1。
• occurrence: 要搜索的匹配项。如果省略，则默认值为 1。
• return_option: 返回哪种类型的位置。如果此值为 0，则 REGEXP_INSTR() 返回匹配的子字符串的第一个字符的位置。如果此值为 1，则 REGEXP_INSTR() 返回匹配子字符串之后的位置。如果省略，则默认值为 0。
• match_type: 指定如何执行匹配的字符串。含义如 REGEXP_LIKE() 所述。

有关如何进行匹配的更多信息，请参阅 REGEXP_LIKE() 的说明。

mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog');
+------------------------------------+
| REGEXP_INSTR('dog cat dog', 'dog') |
+------------------------------------+
|                                  1 |
+------------------------------------+
mysql> SELECT REGEXP_INSTR('dog cat dog', 'dog', 2);
+---------------------------------------+
| REGEXP_INSTR('dog cat dog', 'dog', 2) |
+---------------------------------------+
|                                     9 |
+---------------------------------------+
mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{2}');
+-------------------------------------+
| REGEXP_INSTR('aa aaa aaaa', 'a{2}') |
+-------------------------------------+
|                                   1 |
+-------------------------------------+
mysql> SELECT REGEXP_INSTR('aa aaa aaaa', 'a{4}');
+-------------------------------------+
| REGEXP_INSTR('aa aaa aaaa', 'a{4}') |
+-------------------------------------+
|                                   8 |
+-------------------------------------+

REGEXP_LIKE(expr, pat[, match_type])

如果字符串 expr 与模式 pat 指定的正则表达式匹配，则返回 1，否则返回 0。如果 expr 或 pat 为 NULL，则返回值为 NULL。

模式可以是扩展的正则表达式，其语法在正则表达式语法中讨论。模式不必是文字字符串。例如，它可以指定为字符串表达式或表格列。

可选的 match_type 参数是一个字符串，它可能包含以下任何或所有指定如何执行匹配的字符：

• c: 区分大小写的匹配。
• i: 不区分大小写的匹配。
• m: 多线模式。识别字符串中的行终止符。默认行为是仅在字符串表达式的开头和结尾匹配行终止符。
• n: 这 . 字符匹配行终止符。默认为 . 匹配到在一行的末尾停止。
• u: 仅 Unix 的行尾。只有换行符被 .、 ^ 和 $ 匹配运算符识别为以行结尾的行。

如果在 match_type 中指定了指定矛盾选项的字符，则最右边的优先。

默认情况下，正则表达式操作在确定字符类型和执行比较时使用 expr 和 pat 参数的字符集和排序规则。如果参数具有不同的字符集或排序规则，则适用强制规则，如第 10.8.4 节“表达式中的排序规则强制”中所述。可以使用显式排序指示符指定参数以更改比较行为。

mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE');
+---------------------------------------+
| REGEXP_LIKE('CamelCase', 'CAMELCASE') |
+---------------------------------------+
|                                     1 |
+---------------------------------------+
mysql> SELECT REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs);
+------------------------------------------------------------------+
| REGEXP_LIKE('CamelCase', 'CAMELCASE' COLLATE utf8mb4_0900_as_cs) |
+------------------------------------------------------------------+
|                                                                0 |
+------------------------------------------------------------------+

match_type 可以用 c 或 i 字符指定以覆盖默认的区分大小写。例外：如果任一参数是二进制字符串，则参数以区分大小写的方式作为二进制字符串处理，即使 match_type 包含 i 字符。

笔记
MySQL 在字符串中使用 C 转义语法（例如，\n 表示换行符）。如果您希望 expr 或 pat 参数包含文字 \，则必须将其加倍。 （除非启用了 NO_BACKSLASH_ESCAPES SQL 模式，在这种情况下不使用转义字符。）

mysql> SELECT REGEXP_LIKE('Michael!', '.*');
+-------------------------------+
| REGEXP_LIKE('Michael!', '.*') |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT REGEXP_LIKE('new*\n*line', 'new\\*.\\*line');
+----------------------------------------------+
| REGEXP_LIKE('new*\n*line', 'new\\*.\\*line') |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
mysql> SELECT REGEXP_LIKE('a', '^[a-d]');
+----------------------------+
| REGEXP_LIKE('a', '^[a-d]') |
+----------------------------+
|                          1 |
+----------------------------+

mysql> SELECT REGEXP_LIKE('abc', 'ABC');
+---------------------------+
| REGEXP_LIKE('abc', 'ABC') |
+---------------------------+
|                         1 |
+---------------------------+
mysql> SELECT REGEXP_LIKE('abc', 'ABC', 'c');
+--------------------------------+
| REGEXP_LIKE('abc', 'ABC', 'c') |
+--------------------------------+
|                              0 |
+--------------------------------+

REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

用替换字符串 repl 替换字符串 expr 中匹配由模式 pat 指定的正则表达式的匹配项，并返回结果字符串。如果 expr、pat 或 repl 为 NULL，则返回值为 NULL。

REGEXP_REPLACE() 采用这些可选参数：

• pos: expr 中开始搜索的位置。如果省略，则默认值为 1。
• occurrence: 要替换哪个匹配项。如果省略，则默认值为 0（表示“替换所有匹配项”）。
• match_type: 指定如何执行匹配的字符串。含义如 REGEXP_LIKE() 所述。

在 MySQL 8.0.17 之前，该函数返回的结果使用 UTF-16 字符集；在 MySQL 8.0.17 及更高版本中，使用搜索匹配的表达式的字符集和排序规则。 （错误 #94203、错误 #29308212）

有关如何进行匹配的更多信息，请参阅 REGEXP_LIKE() 的说明。

mysql> SELECT REGEXP_REPLACE('a b c', 'b', 'X');
+-----------------------------------+
| REGEXP_REPLACE('a b c', 'b', 'X') |
+-----------------------------------+
| a X c                             |
+-----------------------------------+
mysql> SELECT REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3);
+----------------------------------------------------+
| REGEXP_REPLACE('abc def ghi', '[a-z]+', 'X', 1, 3) |
+----------------------------------------------------+
| abc def X                                          |
+----------------------------------------------------+

REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]])

返回与模式 pat 指定的正则表达式匹配的字符串 expr 的子字符串，如果没有匹配则返回 NULL。如果 expr 或 pat 为 NULL，则返回值为 NULL。

REGEXP_SUBSTR() 采用这些可选参数：

• pos: expr 中开始搜索的位置。如果省略，则默认值为 1。
• occurrence: 要搜索的匹配项。如果省略，则默认值为 1。
• match_type: 指定如何执行匹配的字符串。含义如 REGEXP_LIKE() 所述。

在 MySQL 8.0.17 之前，该函数返回的结果使用 UTF-16 字符集；在 MySQL 8.0.17 及更高版本中，使用搜索匹配的表达式的字符集和排序规则。 （错误 #94203、错误 #29308212）

有关如何进行匹配的更多信息，请参阅 REGEXP_LIKE() 的说明。

mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+');
+----------------------------------------+
| REGEXP_SUBSTR('abc def ghi', '[a-z]+') |
+----------------------------------------+
| abc                                    |
+----------------------------------------+
mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3);
+----------------------------------------------+
| REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3) |
+----------------------------------------------+
| ghi                                          |
+----------------------------------------------+

2）正则表达式语法

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

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

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

下面的列表涵盖了一些可以在正则表达式中使用的基本特殊字符和结构。有关用于实现正则表达式支持的 ICU 库支持的完整正则表达式语法的信息，请访问 International Components for Unicode 网站。

^ 匹配字符串的开头。

mysql> SELECT REGEXP_LIKE('fo\nfo', '^fo$');                   -> 0
mysql> SELECT REGEXP_LIKE('fofo', '^fo');                      -> 1

$ 匹配字符串的结尾。

mysql> SELECT REGEXP_LIKE('fo\no', '^fo\no$');                 -> 1
mysql> SELECT REGEXP_LIKE('fo\no', '^fo$');                    -> 0

. 匹配任何字符（包括回车和换行符，尽管要在字符串中间匹配这些字符，必须给出 m（多行）匹配控制字符或 (?m) 模式内修饰符）。

mysql> SELECT REGEXP_LIKE('fofo', '^f.*$');                    -> 1
mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$');                -> 0
mysql> SELECT REGEXP_LIKE('fo\r\nfo', '^f.*$', 'm');           -> 1
mysql> SELECT REGEXP_LIKE('fo\r\nfo', '(?m)^f.*$');           -> 1

a* 匹配任何零个或多个 a 字符的序列。

mysql> SELECT REGEXP_LIKE('Ban', '^Ba*n');                     -> 1
mysql> SELECT REGEXP_LIKE('Baaan', '^Ba*n');                   -> 1
mysql> SELECT REGEXP_LIKE('Bn', '^Ba*n');                      -> 1

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

mysql> SELECT REGEXP_LIKE('Ban', '^Ba+n');                     -> 1
mysql> SELECT REGEXP_LIKE('Bn', '^Ba+n');                      -> 0

a? 匹配零个或一个字符。

mysql> SELECT REGEXP_LIKE('Bn', '^Ba?n');                      -> 1
mysql> SELECT REGEXP_LIKE('Ban', '^Ba?n');                     -> 1
mysql> SELECT REGEXP_LIKE('Baan', '^Ba?n');                    -> 0

de|abc 交替;匹配序列 de 或 abc。

mysql> SELECT REGEXP_LIKE('pi', 'pi|apa');                     -> 1
mysql> SELECT REGEXP_LIKE('axe', 'pi|apa');                    -> 0
mysql> SELECT REGEXP_LIKE('apa', 'pi|apa');                    -> 1
mysql> SELECT REGEXP_LIKE('apa', '^(pi|apa)$');                -> 1
mysql> SELECT REGEXP_LIKE('pi', '^(pi|apa)$');                 -> 1
mysql> SELECT REGEXP_LIKE('pix', '^(pi|apa)$');                -> 0

(abc)* 匹配序列 abc 的零个或多个实例。

mysql> SELECT REGEXP_LIKE('pi', '^(pi)*$');                    -> 1
mysql> SELECT REGEXP_LIKE('pip', '^(pi)*$');                   -> 0
mysql> SELECT REGEXP_LIKE('pipi', '^(pi)*$');                  -> 1

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

• a* 可以写成{0,}。

• a+ 可以写成{1,}。

• a? 可以写成{0,1}。

  更准确地说，a{n} 恰好匹配 a 的 n 个实例。 a{n,} 匹配 a 的 n 个或更多实例。 a{m,n} 匹配 m 到 n 个 a 的实例，包括在内。如果同时给出 m 和 n，则 m 必须小于或等于 n。

mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{2}e');              -> 0
mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{3}e');              -> 1
mysql> SELECT REGEXP_LIKE('abcde', 'a[bcd]{1,10}e');           -> 1

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

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

mysql> SELECT REGEXP_LIKE('aXbc', '[a-dXYZ]');                 -> 1
mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]$');               -> 0
mysql> SELECT REGEXP_LIKE('aXbc', '^[a-dXYZ]+$');              -> 1
mysql> SELECT REGEXP_LIKE('aXbc', '^[^a-dXYZ]+$');             -> 0
mysql> SELECT REGEXP_LIKE('gheis', '^[^a-dXYZ]+$');            -> 1
mysql> SELECT REGEXP_LIKE('gheisa', '^[^a-dXYZ]+$');           -> 0

[=character_class=]

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

[:character_class:]

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

字符类	名称含义
alnum	字母数字字符
alpha	字母字符
blank	空白字符
cntrl	控制字符
digit	数字字符
graph	图形字符
lower	小写字母字符
print	图形或空格字符
punct	标点符号
space	空格、制表符、换行符和回车符
upper	大写字母字符
xdigit	十六进制数字字符

mysql> SELECT REGEXP_LIKE('justalnums', '[[:alnum:]]+');       -> 1
mysql> SELECT REGEXP_LIKE('!!', '[[:alnum:]]+');               -> 0

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

mysql> SELECT REGEXP_LIKE('1+2', '1+2');                       -> 0
mysql> SELECT REGEXP_LIKE('1+2', '1\+2');                      -> 0
mysql> SELECT REGEXP_LIKE('1+2', '1\\+2');                     -> 1

3）正则表达式资源控制

REGEXP_LIKE() 和类似的函数使用可以通过设置系统变量来控制的资源：

• 匹配引擎将内存用于其内部堆栈。要以字节为单位控制堆栈的最大可用内存，请设置 regexp_stack_limit 系统变量。
• 匹配引擎分步运行。要控制引擎执行的最大步骤数（从而间接控制执行时间），请设置 regexp_time_limit 系统变量。由于此限制以步数表示，因此它仅间接影响执行时间。通常，它是毫秒级的。

4）正则表达式兼容性注意事项

在 MySQL 8.0.4 之前，MySQL 使用 Henry Spencer 正则表达式库来支持正则表达式操作，而不是 International Components for Unicode (ICU)。以下讨论描述了 Spencer 和 ICU 库之间可能影响应用程序的差异：

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

ICU 具有完整的 Unicode 支持并且是多字节安全的。它的正则表达式函数将所有字符串视为 UTF-16。您应该记住，位置索引基于 16 位块而不是代码点。这意味着，当传递给此类函数时，使用多个块的字符可能会产生意想不到的结果，如下所示：

mysql> SELECT REGEXP_INSTR('🍣🍣b', 'b');
+--------------------------+
| REGEXP_INSTR('??b', 'b') |
+--------------------------+
|                        5 |
+--------------------------+
1 row in set (0.00 sec)

mysql> SELECT REGEXP_INSTR('🍣🍣bxxx', 'b', 4);
+--------------------------------+
| REGEXP_INSTR('??bxxx', 'b', 4) |
+--------------------------------+
|                              5 |
+--------------------------------+
1 row in set (0.00 sec)

Unicode 基本多语言平面中的字符（包括大多数现代语言使用的字符）在这方面是安全的：

mysql> SELECT REGEXP_INSTR('бжb', 'b');
+----------------------------+
| REGEXP_INSTR('бжb', 'b')   |
+----------------------------+
|                          3 |
+----------------------------+
1 row in set (0.00 sec)

mysql> SELECT REGEXP_INSTR('עבb', 'b');
+----------------------------+
| REGEXP_INSTR('עבb', 'b')   |
+----------------------------+
|                          3 |
+----------------------------+
1 row in set (0.00 sec)

mysql> SELECT REGEXP_INSTR('µå周çб', '周');
+------------------------------------+
| REGEXP_INSTR('µå周çб', '周')       |
+------------------------------------+
|                                  3 |
+------------------------------------+
1 row in set (0.00 sec)

表情符号，例如前两个示例中使用的🍣 (U+1F363)，不包含在基本多语言平面中，而是包含在 Unicode 的补充多语言平面中。当 REGEXP_SUBSTR() 或类似函数开始在字符中间搜索时，表情符号和其他 4 字节字符可能会出现另一个问题。以下示例中的两个语句中的每一个都从第一个参数中的第二个 2 字节位置开始。第一条语句适用于仅由 2 字节 (BMP) 字符组成的字符串。第二条语句包含 4 字节字符，这些字符在结果中被错误解释，因为前两个字节被剥离，因此剩余的字符数据未对齐。

mysql> SELECT REGEXP_SUBSTR('周周周周', '.*', 2);
+----------------------------------------+
| REGEXP_SUBSTR('周周周周', '.*', 2)     |
+----------------------------------------+
| 周周周                                 |
+----------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT REGEXP_SUBSTR('🍣🍣🍣🍣', '.*', 2);
+--------------------------------+
| REGEXP_SUBSTR('????', '.*', 2) |
+--------------------------------+
| ?㳟揘㳟揘㳟揘                  |
+--------------------------------+
1 row in set (0.00 sec)

• 为了 . 运算符，Spencer 库匹配字符串表达式中任何位置的行终止符（回车符、换行符），包括中间 . 要将字符串中间的行终止符字符与 ICU 匹配，请指定 m 匹配控制字符。
• Spencer 库支持词首和词尾边界标记（[[:<:]] 和 [[:>:]] 表示法）。 ICU没有 . 对于ICU，可以使用 \b 来匹配单词边界；双反斜杠，因为 MySQL 将其解释为字符串中的转义字符。
• Spencer 库支持整理元素括号表达式（[.characters.] 表示法）。 ICU没有。
• 对于重复计数（{n} 和 {m,n} 表示法），Spencer 库的最大值为 255。ICU 没有这样的限制，尽管可以通过设置 regexp_time_limit 系统变量来限制匹配引擎步骤的最大数量。
• ICU 将括号解释为元字符。要在正则表达式中指定文字左括号或右括号 (，必须对其进行转义：

mysql> SELECT REGEXP_LIKE('(', '(');
ERROR 3692 (HY000): Mismatched parenthesis in regular expression.
mysql> SELECT REGEXP_LIKE('(', '\\(');
+-------------------------+
| REGEXP_LIKE('(', '\\(') |
+-------------------------+
|                       1 |
+-------------------------+
mysql> SELECT REGEXP_LIKE(')', ')');
ERROR 3692 (HY000): Mismatched parenthesis in regular expression.
mysql> SELECT REGEXP_LIKE(')', '\\)');
+-------------------------+
| REGEXP_LIKE(')', '\\)') |
+-------------------------+
|                       1 |
+-------------------------+

ICU 也将方括号解释为元字符，但只有左方括号需要转义才能用作文字字符：

mysql> SELECT REGEXP_LIKE('[', '[');
ERROR 3696 (HY000): The regular expression contains an
unclosed bracket expression.
mysql> SELECT REGEXP_LIKE('[', '\\[');
+-------------------------+
| REGEXP_LIKE('[', '\\[') |
+-------------------------+
|                       1 |
+-------------------------+
mysql> SELECT REGEXP_LIKE(']', ']');
+-----------------------+
| REGEXP_LIKE(']', ']') |
+-----------------------+
|                     1 |
+-----------------------+

12.8.3.函数结果的字符集和排序

MySQL 有许多返回字符串的运算符和函数。本节回答问题：这样的字符串的字符集和排序规则是什么？

对于接受字符串输入并返回字符串结果作为输出的简单函数，输出的字符集和排序规则与主要输入值的相同。例如，UPPER(X) 返回与 X 具有相同字符串和排序规则的字符串。同样适用于 INSTR()、LCASE()、LOWER()、LTRIM()、MID()、REPEAT()、REPLACE( )、REVERSE()、RIGHT()、RPAD()、RTRIM()、SOUNDEX()、SUBSTRING()、TRIM()、UCASE() 和 UPPER()。

笔记
与所有其他函数不同，REPLACE() 函数始终忽略字符串输入的排序规则并执行区分大小写的比较。

如果字符串输入或函数结果是二进制字符串，则该字符串具有二进制字符集和排序规则。这可以通过使用 CHARSET() 和 COLLATION() 函数来检查，这两个函数都为二进制字符串参数返回二进制：

mysql> SELECT CHARSET(BINARY 'a'), COLLATION(BINARY 'a');
+---------------------+-----------------------+
| CHARSET(BINARY 'a') | COLLATION(BINARY 'a') |
+---------------------+-----------------------+
| binary              | binary                |
+---------------------+-----------------------+

对于组合多个字符串输入并返回单个字符串输出的操作，标准 SQL 的“聚合规则”适用于确定结果的排序规则：

• 如果出现显式 COLLATE Y，请使用 Y。
• 如果出现显式 COLLATE Y 和 COLLATE Z，则引发错误。
• 如果所有排序规则都是 Y，则使用 Y。
• 结果没有排序规则。

例如，使用 CASE … WHEN a THEN b WHEN b THEN c COLLATE X END，结果排序规则为 X。这同样适用于 UNION、||、CONCAT()、ELT()、GREATEST()、IF() , 和 LEAST()。

对于转换为字符数据的操作，操作产生的字符串的字符集和排序规则由确定默认连接字符集和排序规则的 character_set_connection 和 collat​​ion_connection 系统变量定义（请参阅第 10.4 节，“连接字符集和排序规则” ”）。这仅适用于 BIN_TO_UUID()、CAST()、CONV()、FORMAT()、HEX() 和 SPACE()。

对于虚拟生成列的表达式，上述原则有一个例外。在此类表达式中，表字符集用于 BIN_TO_UUID()、CONV() 或 HEX() 结果，而与连接字符集无关。

如果对字符串函数返回的结果的字符集或排序规则有任何疑问，请使用 CHARSET() 或 COLLATION() 函数找出：

mysql> SELECT USER(), CHARSET(USER()), COLLATION(USER());
+----------------+-----------------+--------------------+
| USER()         | CHARSET(USER()) | COLLATION(USER())  |
+----------------+-----------------+--------------------+
| test@localhost | utf8mb3         | utf8mb3_general_ci |
+----------------+-----------------+--------------------+
mysql> SELECT CHARSET(COMPRESS('abc')), COLLATION(COMPRESS('abc'));
+--------------------------+----------------------------+
| CHARSET(COMPRESS('abc')) | COLLATION(COMPRESS('abc')) |
+--------------------------+----------------------------+
| binary                   | binary                     |
+--------------------------+----------------------------+