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 的值。有关该选项的更多信息，请参见 第 6.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 的值。有关该选项的更多信息，请参见 第 6.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]])

返回一个字符串，以便对于值 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 在 str1、str2、str3、... 列表中的索引（位置）。如果未找到 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 系统变量的合法值相同（请参见 第 12.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 来禁用此行为。有关该选项的更多信息，请参见 第 6.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 个字符的子字符串替换为字符串 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() 的双参数形式相同，只是参数的顺序相反。

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

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)

第一个语法返回子字符串 substr 在字符串 str 中第一次出现的位置。第二个语法返回子字符串 substr 在字符串 str 中从位置 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'

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

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 工作。请参阅 第 12.10.1 节“Unicode 字符集”。

此函数是多字节安全的。

视图中使用的 LCASE() 会被重写为 LOWER()。

LPAD(str,len,padstr)

返回字符串 str，在其左侧使用字符串 padstr 填充，使其长度达到 len 个字符。如果 str 的长度大于 len，则返回值将被截短为 len 个字符。

mysql> SELECT LPAD('hi',4,'??');
        -> '??hi'
mysql> SELECT LPAD('hi',1,'??');
        -> 'h'

如果它的任何参数为 NULL，则返回 NULL。

LTRIM(str)

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

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

此函数是多字节安全的。

MAKE_SET(bits,str1,str2,...)

返回一个集合值（一个包含由 , 字符分隔的子字符串的字符串），该值由在 bits 中设置了相应位的字符串组成。str1 对应于位 0，str2 对应于位 1，依此类推。str1、str2、... 中的 NULL 值不会附加到结果中。

mysql> SELECT MAKE_SET(1,'a','b','c');
        -> 'a'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
        -> 'hello,world'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
        -> 'hello'
mysql> SELECT MAKE_SET(0,'a','b','c');
        -> ''

MID(str,pos,len)

MID(str,pos,len) 是 SUBSTRING(str,pos,len) 的同义词。

OCT(N)

返回 N 的八进制值的字符串表示形式，其中 N 是一个 longlong（BIGINT）数字。这等效于 CONV(N,10,8)。如果 N 为 NULL，则返回 NULL。

mysql> SELECT OCT(12);
        -> '14'

OCTET_LENGTH(str)

OCTET_LENGTH() 是 LENGTH() 的同义词。

ORD(str)

如果字符串 str 最左边的字符是多字节字符，则返回该字符的代码，该代码使用以下公式根据其组成字节的数值计算得出

  (1st byte code)
+ (2nd byte code * 256)
+ (3rd byte code * 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 语句中用作正确转义数据值的结果。返回的字符串用单引号引起来，并且每个反斜杠 (\)、单引号 (')、ASCII NUL 和 Control+Z 字符前面都有一个反斜杠。如果参数为 NULL，则返回值是不带单引号的单词““NULL””。

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

有关比较，请参阅 第 11.1.1 节“字符串文字” 和 mysql_real_escape_string_quote() 中关于文字字符串和 C API 中的引用规则。

REPEAT(str,count)

返回一个字符串，该字符串由重复 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。REPLACE() 在搜索 from_str 时执行区分大小写的匹配。

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

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

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 参数的形式返回从字符串 str 的位置 pos 开始的子字符串。带有 len 参数的形式返回从字符串 str 的位置 pos 开始的长度为 len 个字符的子字符串。使用 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)

返回字符串 str 中在分隔符 delim 出现 count 次之前的子字符串。如果 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'

此函数是多字节安全的。

如果 SUBSTRING_INDEX() 的任何参数为 NULL，则返回 NULL。

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() 使用的编码和解码规则

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' 存储到 CHAR(3) 列中为 '41 '，并检索为 '41'（删除了尾随填充空格），因此列值的 UNHEX() 返回 X'41'。相反，'41' 存储到 BINARY(3) 列中为 '41\0'，并检索为 '41\0'（尾随填充 0x00 字节未删除）。'\0' 不是合法的十六进制数字，因此列值的 UNHEX() 返回 NULL。

对于数值参数 N，UNHEX() 不会执行 HEX(N) 的逆运算。请改用 CONV(HEX(N),16,10)。请参阅 HEX() 的说明。

如果从 mysql 客户端内部调用 UNHEX()，则二进制字符串将使用十六进制表示法显示，具体取决于 --binary-as-hex 的值。有关该选项的更多信息，请参阅 第 6.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() 是一个用于内部调试的函数。它的行为可能会在 MySQL 版本之间发生变化，恕不另行通知。它可用于测试和调试排序规则，尤其是在添加新排序规则时。请参阅 第 12.14 节“向字符集添加排序规则”。

此列表简要总结了参数。更多详细信息将在列表后面的讨论中给出。

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

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 子句当前未使用。

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