12.8 字符串函数和运算符_MySQL 5.7 参考手册

扩展 MySQL 8.0 / 第 6 章向 MySQL 添加函数 / 12.8 字符串函数和运算符

12.8 字符串函数和运算符

12.8.1 字符串比较函数和运算符
12.8.2 正则表达式
12.8.3 函数结果的字符集和整理

表 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()`	返回一组以逗号分隔的字符串，这些字符串具有相应的位 in bits set
`MATCH()`	执行全文搜索
`MID()`	返回从指定位置开始的子串
`NOT LIKE`	简单模式匹配的否定
`NOT REGEXP`	REGEXP 的否定
`OCT()`	返回包含数字的八进制表示的字符串
`OCTET_LENGTH()`	LENGTH() 的同义词
`ORD()`	返回参数最左边字符的字符代码
`POSITION()`	LOCATE() 的同义词
`QUOTE()`	转义参数以在 SQL 语句中使用
`REGEXP`	字符串是否匹配正则表达式
`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()`	返回字符串的权重字符串

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

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

对于采用长度参数的函数，非整数参数四舍五入为最接近的整数。

ASCII(str)
返回字符串最左边字符的数值str。0如果str是空字符串则返回。返回NULL如果 str是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)NULLNNULL
```
mysql> SELECT BIN(12);
        -> '1100'
```
BIT_LENGTH(str)
以位为单位返回字符串的长度 str。
```
mysql> SELECT BIT_LENGTH('text');
        -> 32
```

CHAR(N,... [USING charset_name])

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

mysql> SELECT CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
        -> 'MMM'

CHAR()大于 255 的参数被转换为多个结果字节。例如， 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()从mysql客户端中调用，则二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex. 有关该选项的更多信息，请参阅第 4.5.1 节，“mysql — MySQL 命令行客户端”。

CHAR_LENGTH(str)

返回 string 的长度 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)

CHARACTER_LENGTH(str)
CHARACTER_LENGTH()是的同义词CHAR_LENGTH()。
CONCAT(str1,str2,...)
返回由连接参数产生的字符串。可能有一个或多个参数。如果所有参数都是非二进制字符串，则结果是非二进制字符串。如果参数包含任何二进制字符串，则结果为二进制字符串。数字参数转换为其等效的非二进制字符串形式。
CONCAT()NULL如果任何参数是，则返回 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()从mysql客户端中调用，则二进制字符串结果使用十六进制表示法显示，具体取决于--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字符串列表的第 th 个元素： str1if N= 1、 str2if N=2等。NULL如果 N小于1 或大于参数数量，则返回。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]])
返回一个字符串，这样对于 value 中设置的每一位 bits，您都会得到一个 on字符串，而对于该值中未设置的每一位，您都会得到一个off 字符串。从右到左检查中的位bits（从低位到高位）。字符串从左到右添加到结果中，由separator字符串分隔（默认为逗号字符,）。检查的位数由给出 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,...)
返回, , ,列表str 中的索引（位置）。如果没有找到则返回。str1str2str3...0str
如果所有参数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)
N如果字符串在由子字符串组成的 str字符串列表中，则返回 1 到范围内的值。字符串列表是由字符分隔的子字符串组成的字符串。如果第一个参数是常量字符串，第二个是 type 的列，则函数优化为使用位算术。如果不在或如果是空字符串则返回。如果任一参数是，则返回。如果第一个参数包含逗号 (strlistN,SETFIND_IN_SET()0strstrliststrlistNULLNULL,）特点。
```
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2
```
FORMAT(X,D[,locale])
将数字X格式化为类似于的格式'#,###,###.##'，四舍五入到 D小数位，并将结果作为字符串返回。如果D是 0，则结果没有小数点或小数部分。
可选的第三个参数允许指定区域设置以用于结果数字的小数点、千位分隔符和分隔符之间的分组。lc_time_names允许的语言环境值与系统变量的合法值相同（请参阅第 10.16 节，“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)
获取使用 base-64 编码规则编码的字符串 TO_BASE64()，并将解码结果作为二进制字符串返回。结果是 NULL参数是否是 NULL有效的 base-64 字符串。详细的编解码规则见说明TO_BASE64()。
```
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'
```
如果FROM_BASE64()从mysql客户端中调用，则二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex. 有关该选项的更多信息，请参阅第 4.5.1 节，“mysql — MySQL 命令行客户端”。
HEX(str), HEX(N)
对于字符串参数str， HEX()返回十六进制字符串表示形式，str其中每个字符的每个字节都str 转换为两个十六进制数字。（多字节字符因此变得多于两位数。）此操作的逆运算由 UNHEX()函数执行。
对于数字参数N，返回被视为 longlong( ) 数字HEX()的值的十六进制字符串表示形式。这相当于 . 此操作的逆运算由执行。 NBIGINTCONV(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，子字符串从 position 开始pos ，len字符 long 被字符串替换newstr。pos如果不在字符串的长度内，则返回原始字符串。pos如果 len不在字符串其余部分的长度内，则从位置替换字符串的其余部分。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)
substr返回 substring在 string 中第一次出现的位置 str。这与的双参数形式相同LOCATE()，只是参数的顺序颠倒了。
```
mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0
```
此函数是多字节安全的，并且仅当至少一个参数是二进制字符串时才区分大小写。
LCASE(str)
LCASE()是的同义词 LOWER()。
LCASE()LOWER()在视图中使用的在存储视图的定义时被重写。（漏洞 #12844279）
LEFT(str,len)
返回字符串最左边len的字符str，或者 NULL如果任何参数是 NULL。
```
mysql> SELECT LEFT('foobarbar', 5);
        -> 'fooba'
```
这个函数是多字节安全的。
LENGTH(str)
返回 string 的长度 str，以字节为单位。多字节字符计为多个字节。这意味着对于包含五个 2 字节字符的字符串， LENGTH()返回 10，而 CHAR_LENGTH()返回 5.
```
mysql> SELECT LENGTH('text');
        -> 4
```
笔记

Length()OpenGIS 空间函数ST_Length()在 MySQL 中命名。
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)
第一个语法返回 substringsubstr在 string 中第一次出现的位置str。第二种语法返回 substrstring 中 substring 第一次出现的str位置，从 position 开始 pos。0 如果substr不在中则返回str。返回 NULLifsubstr 或stris NULL。
```
mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7
```
此函数是多字节安全的，并且仅当至少一个参数是二进制字符串时才区分大小写。
LOWER(str)
返回str根据当前字符集映射将所有字符更改为小写的字符串。默认值为 latin1(cp1252 西欧)。
```
mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'
```
LOWER()(and 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(). （漏洞 #12844279）
LPAD(str,len,padstr)
返回 string str，用 string 左填充到字符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，依此类推。 , ,中的NULL值不会附加到结果中。 str1str2...
```
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)NULLNNULL
```
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(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，则返回空字符串。返回NULLif str或 countare NULL。
```
mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
```
REPLACE(str,from_str,to_str)
返回str所有出现的字符串都from_str 替换为字符串的字符串to_str。 REPLACE()搜索时执行区分大小写的匹配 from_str。
```
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwWw.mysql.com'
```
这个函数是多字节安全的。
REVERSE(str)
返回str字符顺序颠倒的字符串。
```
mysql> SELECT REVERSE('abc');
        -> 'cba'
```
这个函数是多字节安全的。
RIGHT(str,len)
返回字符串中最右边len 的字符str，或者 NULL如果任何参数是 NULL。
```
mysql> SELECT RIGHT('foobarbar', 4);
        -> 'rbar'
```
这个函数是多字节安全的。
RPAD(str,len,padstr)
返回 string str，用 string 右填充到字符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)
从返回一个 soundex 字符串str。听起来几乎相同的两个字符串应该具有相同的 soundex 字符串。一个标准的 soundex 字符串是四个字符长，但该SOUNDEX() 函数返回一个任意长的字符串。您可以 SUBSTRING()在结果上使用以获得标准的 soundex 字符串。中的所有非字母字符 str都将被忽略。AZ 范围之外的所有国际字母字符都被视为元音。

重要的

使用时SOUNDEX()，您应该注意以下限制：
- 当前实现的此功能旨在很好地处理仅使用英语的字符串。其他语言的字符串可能不会产生可靠的结果。
- 此函数不保证为使用多字节字符集（包括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 空格字符组成的字符串。
```
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参数的形式从 stringstr 开始的 position返回一个子字符串pos。带有len参数的形式从 string 返回一个子串len字符 long str，从 position 开始 pos。使用的形式 FROM是标准的 SQL 语法。也可以使用负值 pos。在这种情况下，子字符串的开头是字符串pos末尾的字符，而不是开头。负值可用pos 于此函数的任何形式。值为 0 时 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之前的子字符串。如果为正数，则返回最终定界符左侧（从左侧开始计数）的所有内容。如果为负数，则返回最终定界符右侧（从右侧开始计数）的所有内容。搜索时执行区分大小写的匹配。 countdelimcountcountSUBSTRING_INDEX()delim
```
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'
```
这个函数是多字节安全的。
TO_BASE64(str)
将字符串参数转换为 base-64 编码形式，并将结果作为具有连接字符集和排序规则的字符串返回。如果参数不是字符串，则在转换发生之前将其转换为字符串。结果是NULL如果参数是 NULL。FROM_BASE64() 可以使用函数对 Base-64 编码的字符串进行解码。
```
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)
返回删除str了所有前缀或后缀的字符串。remstr如果没有给出任何说明符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()存储视图定义时。（漏洞 #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        |
+-------------+
```
如果NULLto 的参数 UNHEX()是一 BINARY列，则可能会出现结果，因为值在存储时会用字节填充，0x00但在检索时不会删除这些字节。例如， '41'存储到 CHAR(3)列中 '41 '并检索为 '41'（删除尾随填充空格），因此UNHEX()对于列值返回X'41'. 相比之下， '41'存储在 BINARY(3)列中 '41\0'并检索为 '41\0'（尾部填充 0x00字节未去除）。 '\0'不是合法的十六进制数字，所以 UNHEX()对于列值返回NULL。
对于数字参数N，的逆运算不由执行。改用。见说明。 HEX(N)UNHEX()CONV(HEX(N),16,10)HEX()
如果UNHEX()从mysql客户端中调用，则二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex. 有关该选项的更多信息，请参阅第 4.5.1 节，“mysql — MySQL 命令行客户端”。
UPPER(str)
返回str根据当前字符集映射将所有字符更改为大写的字符串。默认值为 latin1(cp1252 西欧)。
```
mysql> SELECT UPPER('Hej');
        -> 'HEJ'
```
LOWER() 有关也适用于的信息，请参阅的描述UPPER()。这包括有关如何对这些函数无效的二进制字符串 ( BINARY, VARBINARY, BLOB) 执行字母大小写转换的信息，以及有关 Unicode 字符集的大小写折叠的信息。
这个函数是多字节安全的。
在以前的 MySQL 版本中，UPPER()在视图中使用被重写为 UCASE()存储视图定义时。在 MySQL 5.7 中， UPPER()在这种情况下永远不会被重写，但是UCASE()在视图中使用被重写为UPPER(). （漏洞 #12844279）
WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [LEVEL levels] [flags])
levels: N [ASC|DESC|REVERSE] [, N [ASC|DESC|REVERSE]] ...
此函数返回输入字符串的权重字符串。返回值是一个二进制字符串，表示字符串的比较和排序值。它具有以下属性：
- 如果 = ，则 (和被认为是相等的) WEIGHT_STRING(str1)WEIGHT_STRING(str2)str1 = str2str1str2
- 如果 < ，则（排序在前） WEIGHT_STRING(str1)WEIGHT_STRING(str2)str1 < str2str1str2
WEIGHT_STRING()是供内部使用的调试函数。它的行为可以在 MySQL 版本之间更改，恕不另行通知。它可用于排序规则的测试和调试，尤其是在添加新排序规则时。请参阅第 10.14 节，“向字符集添加排序规则”。
此列表简要总结了这些论点。在列表后面的讨论中给出了更多细节。
- str：输入的字符串表达式。
- AS子句：可选；将输入字符串转换为给定的类型和长度。
- LEVEL子句：可选；指定返回值的权重级别。
- flags：可选的; 没用过。
输入字符串str是一个字符串表达式。如果输入是非二进制（字符）字符串，例如 a CHAR、 VARCHAR或 TEXTvalue，则返回值包含该字符串的归类权重。如果输入是二进制（字节）字符串，例如 a BINARY、 VARBINARY或 BLOBvalue，则返回值与输入相同（二进制字符串中每个字节的权重是字节值）。如果输入是 NULL，则WEIGHT_STRING()返回 NULL。
例子：
```
mysql> SET @s = _latin1 'AB' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 4142                   |
+------+---------+------------------------+
```
```
mysql> SET @s = _latin1 'ab' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 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   | 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 utf8) COLLATE utf8_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 'utf8';
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 0041004200200020                    |
+-------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));
+---------------------------------------+
| HEX(WEIGHT_STRING('ab' AS BINARY(4))) |
+---------------------------------------+
| 61620000                              |
+---------------------------------------+
```
LEVEL可以给出该子句以指定返回值应包含特定排序规则级别的权重。
The levels specifier following the LEVEL keyword may be given either as a list of one or more integers separated by commas, or as a range of two integers separated by a dash. Whitespace around the punctuation characters does not matter.
Examples:
```
LEVEL 1
LEVEL 2, 3, 5
LEVEL 1-3
```
Any level less than 1 is treated as 1. Any level greater than the maximum for the input string collation is treated as maximum for the collation. The maximum varies per collation, but is never greater than 6.
In a list of levels, levels must be given in increasing order. In a range of levels, if the second number is less than the first, it is treated as the first number (for example, 4-2 is the same as 4-4).
If the LEVEL clause is omitted, MySQL assumes LEVEL 1 - max, where max is the maximum level for the collation.
If LEVEL is specified using list syntax (not range syntax), any level number can be followed by these modifiers:
- ASC: Return the weights without modification. This is the default.
- DESC: Return bitwise-inverted weights (for example, 0x78f0 DESC = 0x870f).
- REVERSE: Return the weights in reverse order (that is,the weights for the reversed string, with the first character last and the last first).
Examples:
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1));
+--------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1)) |
+--------------------------------------+
| 007FFF                               |
+--------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC));
+-------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC)) |
+-------------------------------------------+
| FF8000                                    |
+-------------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 REVERSE));
+----------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 REVERSE)) |
+----------------------------------------------+
| FF7F00                                       |
+----------------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC REVERSE));
+---------------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC REVERSE)) |
+---------------------------------------------------+
| 0080FF                                            |
+---------------------------------------------------+
```
The flags clause currently is unused.
如果WEIGHT_STRING()从mysql客户端中调用，则二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex. 有关该选项的更多信息，请参阅第 4.5.1 节，“mysql — MySQL 命令行客户端”。