12.7 字符串函数和运算符

table12.11 字符串函数和运算符

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

如果结果的长度大于系统变量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 的二进制值的字符串 table 示形式，其中 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_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 *的长度，以字符为单位。多字节字符算作单个字符。这意味着对于包含五个 2 字节字符的字符串，LENGTH()返回10，而CHAR_LENGTH()返回5。

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'

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

CONCAT_WS()代 table 用分隔符连接，是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()返回字符串列 table 的* N 元素： str1 如果 N * = 1，* str2 如果 N * = 2，依此类推。如果* N *小于1或大于参数个数，则返回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]])

返回一个字符串，这样对于值* 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,...)

返回* str1 ， str2 ， str3 ，...列 table 中 str 的索引(位置)。如果未找到 str *，则返回0。

如果FIELD()的所有参数都是字符串，则将所有参数作为字符串进行比较。如果所有参数都是数字，则将它们作为数字进行比较。否则，将参数比较为 double。

如果* 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 在字符串列 table strlist 由 N 子字符串组成，则返回 1 到 N 范围内的值。字符串列 table 是由由,个字符分隔的子字符串组成的字符串。如果第一个参数是常量字符串，第二个参数是类型为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.16 节“ MySQL Server 语言环境支持”)。如果未指定语言环境，则默认值为'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 的十六进制字符串 table 示形式，其中 str *中每个字符的每个字节都转换为两个十六进制数字。 (因此，多字节字符变为两位以上.)此操作的相反操作是通过UNHEX()函数执行的。

对于数字参数* N ，HEX()返回 N *的值的十六进制字符串 table 示形式，该值 table 示为 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)

返回子字符串* substr 在字符串 str *中第一次出现的位置。这与LOCATE()的两个参数形式相同，除了参数的 Sequences 相反。

mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0

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

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。

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

Note

Length() OpenGIS 空间函数在 MySQL 中名为ST_Length()。

LOAD_FILE(file_name)

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

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

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

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。如果 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 *，其中所有字符均根据当前字符集 Map 更改为小写。默认值为latin1(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()。 (缺陷#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,...)

返回一个设置值(一个字符串，该字符串包含用,个字符分隔的子字符串)，该字符串由具有* 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 的字符串 table 示形式，其中 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

位置(substr IN str)

位置(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

为了进行比较，请参见第 9.1.1 节“字符串 Literals”和第 27.7.6.56 节，“ mysql_real_escape_string_quote()”中的 Literals 字符串以及 C API 中的引用规则。

REPEAT(str,count)

返回由字符串* str 重复 count 次组成的字符串。如果 count 小于 1，则返回一个空字符串。如果 str 或 count *是NULL，则返回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 *，字符 Sequences 颠倒。

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 范围以外的国际字母字符都被视为元音。

Important

使用SOUNDEX()时，应注意以下限制：

当前实现的此功能旨在与仅英语语言的字符串配合使用。其他语言的字符串可能不会产生可靠的结果。
- 不能保证此函数为使用多字节字符集(包括utf-8)的字符串提供一致的结果。有关更多信息，请参见 Bug#22638.

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

Note

此函数实现原始的 Soundex 算法，而不是更流行的增强版本(也由 D. Knuth 描述)。区别在于原始版本先丢弃元音，然后再复制，而增强版本先丢弃元音，然后再丢弃。

expr1 类似于 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 参数的 table 单从字符串 str 返回子字符串，从位置 pos 开始。带 len 参数的 table 单从子字符串 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'

此功能是多字节安全的。

如果* len *小于 1，则结果为空字符串。

SUBSTRING_INDEX(str,delim,count)

从* 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'

此功能是多字节安全的。

TO_BASE64(str)

将 string 参数转换为 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 个可打印字符的组。Importing 数据的每 3 个字节使用 4 个字符进行编码。如果最后一组不完整，则用'='个字符填充，长度为 4.
- 在编码输出的每 76 个字符之后添加一个换行符，以将长输出分成多行。
- 解码识别并忽略换行符，回车符，制 table 符和空格。

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)将参数中的每对字符解释为十六进制数字，并将其转换为该数字 table 示的字节。返回值是一个二进制字符串。

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()返回X'41'。相比之下，'41'作为'41\0'存储到BINARY(3)列中，并作为'41\0'检索(尾随焊盘0x00字节未剥离)。 '\0'不是合法的十六进制数字，因此列值的UNHEX()返回NULL。

对于数字参数* N *，UNHEX()不执行HEX(N)的逆运算。改用CONV(HEX(N),16,10)。参见HEX()的描述。

UPPER(str)

返回字符串* str *，其中所有字符均根据当前字符集 Map 更改为大写。默认值为latin1(cp1252 西欧)。

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

有关也适用于UPPER()的信息，请参见LOWER()的描述。其中包括有关如何执行这些功能无效的二进制字符串(BINARY，VARBINARY，BLOB)的字母大小写转换的信息，以及有关 Unicode 字符集的大小写折叠的信息。

此功能是多字节安全的。

在早期版本的 MySQL 中，存储视图定义时，视图中使用的UPPER()被重写为UCASE()。在 MySQL 5.7 中，在这种情况下永远不会重写UPPER()，但是在视图中使用的UCASE()会重写为UPPER()。 (缺陷#12844279)

WEIGHT_STRING(str [AS{CHAR|BINARY}(N)] [LEVEL 等级] [标志])

levels: N [ASC|DESC|REVERSE] [, N [ASC|DESC|REVERSE]] ...

此函数返回 Importing 字符串的权重字符串。返回值是一个二进制字符串，table 示该字符串的比较和排序值。它具有以下属性：

如果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 节“为字符集添加排序规则”。

该列 table 简要总结了参数。列 table 后面的讨论中提供了更多详细信息。

- str *：Importing 字符串 table 达式。
- AS子句：可选；将 Importing 字符串转换为给定的类型和长度。
- LEVEL子句：可选；指定返回值的重量级别。
- - flags *：可选；没用过。

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

Examples:

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子句以将 Importing 字符串转换为非二进制或二进制字符串，并将其强制为给定长度：

AS CHAR(N)将字符串强制转换为非二进制字符串，并在右侧用空格填充* N *个字符。 * N 必须至少为 1.如果 N 小于 Importing 字符串的长度，则字符串将被截断为 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子句以指定返回值应包含特定归类级别的权重。

LEVEL关键字后的* levels *指示符可以是一个或多个用逗号分隔的整数的列 table，也可以是用短划线分隔的两个整数的范围。标点符号周围的空格无关紧要。

Examples:

LEVEL 1
LEVEL 2, 3, 5
LEVEL 1-3

小于 1 的任何级别都被视为 1.大于 Importing 字符串归类的最大值的任何级别都被视为归类的最大值。每个排序规则的最大值有所不同，但永远不会大于 6.

在级别列 table 中，必须按升序排列级别。在级别范围内，如果第二个数字小于第一个数字，则将其视为第一个数字(例如 4-2 与 4-4 相同)。

如果省略LEVEL子句，则 MySQL 假定LEVEL 1 - max，其中* max *是排序规则的最大级别。

如果使用列 table 语法(而不是范围语法)指定了LEVEL，那么任何级别编号都可以跟随这些修饰符：

ASC：不做任何修改就返回重量。这是默认值。
- DESC：返回按位反转的权重(例如0x78f0 DESC = 0x870f)。
- REVERSE：以相反的 Sequences 返回权重(即，反向字符串的权重，第一个字符在后，最后一个在前)。

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

flags *子句当前未使用。

Name	MySql 中文文档
Version
Language
Badge
Last Updated	2021-07-03T12:24:35