ASCII(str)

返回字符串 str 的左most 字符的数字值。如果 str 是空字符串，则返回 0。如果 str 是 NULL，则返回 NULL。ASCII() 适用于 8 位字符。

mysql> SELECT ASCII('2');
        -> 50
mysql> SELECT ASCII(2);
        -> 50
mysql> SELECT ASCII('dx');
        -> 100

见 also ORD() 函数。

BIN(N)

返回长整数 N 的二进制字符串表示形式，相当于 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 命令行客户端”。

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 个元素：str1 如果 N = 1，str2 如果 N = 2，依此类推。返回 NULL 如果 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,...)

返回 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 在字符串列表 strlist 中，则返回一个介于 1 到 N 之间的值，否则返回 0。字符串列表是一个由逗号字符 , 分隔的子字符串组成的字符串。如果第一个参数是一个常量字符串，第二个参数是一个 SET 类型的列，则 FIND_IN_SET() 函数将使用位运算进行优化。返回 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)

使用 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，其中每个字符的每个字节都被转换为两个十六进制数字。（多字节字符因此变为多于两个数字。）该操作的逆操作由 UNHEX() 函数执行。

对于数字参数 N，HEX() 返回一个十六进制字符串表示 N 的值，作为长整数 (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）

左(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)

第一个语法返回字符串 str 中子串 substr 的首次出现的位置。第二个语法返回字符串 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 工作。参见 第 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，以此类推。NULL 值在 str1、str2、... 中不会被追加到结果中。

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 的八进制字符串表示形式，相当于 CONV(N,10,8)。如果 N 为 NULL，则返回 NULL。

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

OCTET_LENGTH(str)

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

ORD(str)

如果字符串 str 的左most 字符是一个多字节字符，则返回该字符的代码，从其组成字节的数字值计算得出，使用以下公式：

  (1st byte code)
+ (2nd byte code * 256)
+ (3rd byte code * 256^2) ...

如果左most字符不是多字节字符，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 和控制 Z 将被反斜杠前缀。如果参数是 NULL，则返回值是单词 “NULL”，不带单引号。

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

比较，请参阅文字字符串和 C API 中的引号规则：第 11.1.1 节，“字符串文字”，和 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字符串是四个字符长，但 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。Base-64 编码字符串可以使用 FROM_BASE64() 函数解码。

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

如果参数是 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 节，“添加字符集的排序”。

以下列表简要总结了参数。更多详细信息请参阅以下讨论。

输入字符串 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 子句未使用。

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