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 — The MySQL Command-Line Client”。

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

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

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'

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

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 Server Locale Support”）。如果区域设置为 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 — The MySQL Command-Line Client”。

HEX(str)、HEX(N)

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

对于数值参数 N，HEX() 返回 N 的十六进制字符串表示形式，将 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()。（Bug #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'

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 运行。参见 第 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 节，“字符串文字” 中文字符串和 C API 中的引用规则，以及 mysql_real_escape_string_quote()。

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'

该函数是多字节安全的。如果任何参数为 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 字符串长 4 个字符， 但 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)

返回字符串 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'

该函数是多字节安全的。如果任何参数为 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        |
+-------------+

NULL 结果也可能发生在 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 的值。有关该选项的更多信息，请参阅 第 6.5.1 节，“mysql — The MySQL Command-Line Client”.

UPPER(str)

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

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

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

此函数是多字节安全的。

视图中使用的 UCASE() 将被重写为 UPPER()。

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

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

WEIGHT_STRING() 是一个调试函数，旨在供内部使用。其行为在不同版本的 MySQL 之间可能会发生变化。它可用于测试和调试排序规则，尤其是当您要添加新的排序规则时。请参阅 第 12.14 节，“Adding a Collation to a Character Set”.

此列表简要概述了参数。在列表后面的讨论中提供了更多详细信息。

输入字符串，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 命令行客户端”。