字符串函数和运算符

表字符串函数和运算符

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

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

对于在字符串位置上操作的函数，第一个位置编号为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_LENGTH(str)
返回字符串的长度str，以字符为单位。多字节字符算作单个字符。这意味着对于包含五个2字节字符的字符串，LENGTH()返回10，而CHAR_LENGTH()返回5。
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_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]])
返回一个字符串，这样对于值中设置的每个位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，...列表。0如果返回str找不到则。
如果所有参数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)
N如果字符串str在strlist由N子字符串组成的字符串列表中，则返回1到1之间的值。字符串列表是由由,字符分隔的子字符串组成的字符串。如果第一个参数是常量字符串，第二个参数是type的列SET，则该FIND_IN_SET()函数将优化为使用位算术。返回0如果str不是strlist，或者strlist是空字符串。NULL如果任一参数为，则返回NULL。如果第一个参数包含逗号（,）字符。
```
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
-> 2
```
FORMAT(X,D[,locale])
将数字X格式化为'#,###,###.##'，将其舍入为D小数位，然后将结果作为字符串返回。如果D为0，则结果没有小数点或小数部分。
可选的第三个参数允许指定语言环境，以用于结果数字的小数点，千位分隔符以及分隔符之间的分组。允许的语言环境值与lc_time_names系统变量的合法值相同（请参见“ 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'
```
HEX(str)，HEX(N)
对于string参数str，HEX()返回一个十六进制字符串表示形式，str其中每个字符的每个字节str都转换为两个十六进制数字。（因此，多字节字符变为两位以上。）此操作的反UNHEX()函数由功能执行。
对于数字参数N，HEX()返回将十六进制字符串表示N为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不在字符串的长度内，则返回原始字符串。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在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)
返回字符串的长度str，以字节为单位。多字节字符计为多个字节。这意味着对于包含五个2字节字符的字符串，LENGTH()返回10，而CHAR_LENGTH()返回5。
```
mysql> SELECT LENGTH('text');
-> 4
```
注意
在Length()开放GIS空间功能被命名为ST_Length()MySQL中。
LOAD_FILE(file_name)
读取文件并以字符串形式返回文件内容。要使用此功能，文件必须位于服务器主机上，必须指定文件的完整路径名，并且必须具有FILE特权。该文件必须可由服务器读取，并且其大小小于max_allowed_packet字节。如果secure_file_priv系统变量设置为非空目录名称，则要加载的文件必须位于该目录中。（在MySQL 8.0.17之前，该文件必须所有人都可读，而不仅仅是服务器可读。）
如果文件不存在或由于不满足前述条件之一而无法读取，则该函数返回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在string中第一次出现的位置str。第二种语法返回substrstring 中子字符串第一次出现的str位置，从position开始pos。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根据当前字符集映射将所有字符更改为小写的字符串。默认值为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并且utf8_unicode_520_ci根据分别UCA 9.0.0和5.2.0，工作，而utf8_unicode_ci作品根据UCA 4.0.0。请参见“ 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'
```
LTRIM(str)
返回已str删除前导空格字符的字符串。
```
mysql> SELECT LTRIM('  barbar');
-> 'barbar'
```
此功能是多字节安全的。
MAKE_SET(bits,str1,str2,...)
返回一个设置值（一个包含用,字符分隔的子字符串的字符串），该值由具有相应位的字符串组成bits。str1对应于位0，对应于位str21，依此类推。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，其中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语句中正确转义的数据值。返回的字符串用单引号引起来，并带有反斜杠（\），单引号（'），ASCII NUL和Control + Z的每个实例，并带有反斜杠。如果参数为NULL，则返回值是单词“ NULL ”，而不用单引号引起来。
```
mysql> SELECT QUOTE('Don\'t!');
-> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
-> NULL
```
为了进行比较，请参见“字符串文字”和“ mysql_real_escape_string_quote（）”中的文字字符串和C API中的引用规则。
REPEAT(str,count)
返回由str重复的字符串组成的字符串count。如果count小于1，则返回一个空字符串。返回NULL如果str还是count有NULL。
```
mysql> SELECT REPEAT('MySQL', 3);
-> 'MySQLMySQLMySQL'
```
REPLACE(str,from_str,to_str)
返回字符串，str其中所有出现的字符串均from_str替换为string 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)
返回字符串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)
从返回一个soundex字符串str。听起来几乎相同的两个弦应该具有相同的soundex弦。标准的soundex字符串长四个字符，但该SOUNDEX()函数返回任意长的字符串。您可以SUBSTRING()在结果上使用以获得标准的soundex字符串。中的所有非字母字符str都将被忽略。AZ范围以外的所有国际字母字符都被视为元音。
重要
使用时SOUNDEX()，您应注意以下限制：
- 当前实现的此功能旨在与仅英语语言的字符串配合使用。其他语言的字符串可能不会产生可靠的结果。
- 不能保证此功能为使用多字节字符集（包括）的字符串提供一致的结果utf-8。有关更多信息，请参见Bug＃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参数的形式从string中返回一个从str position开始的子字符串pos。带len参数的表单len从str位置开始，从字符串返回一个长的子字符串字符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)
将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个可打印字符的组。输入数据的每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()。
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：
```
mysql> SELECT UNHEX('GG');
+-------------	+
| UNHEX('GG') 	|
+-------------	+
| NULL        	|
+-------------	+
```
阿NULL可发生的结果，如果该参数UNHEX()是一BINARY，列，因为值是用0x00填充字节存储时，但这些字节不剥离上检索。例如，'41'将储存CHAR(3)为'41 '并以检索为'41'（除去尾随空格），因此UNHEX()列值将返回'A'。相比之下'41'，存储为BINARY(3)as 的列'41\0'并以as 检索'41\0'（0x00未删除尾随字节）。'\0'不是合法的十六进制数字，因此UNHEX()为列值返回NULL。
对于数字参数N，不执行的反函数。使用代替。请参阅的说明。HEX(N)UNHEX()CONV(HEX(N),16,10)HEX()
UPPER(str)
返回str根据当前字符集映射将所有字符都更改为大写的字符串。默认值为utf8mb4。
```
mysql> SELECT UPPER('Hej');
-> 'HEJ'
```
请参阅的说明，LOWER()以获取适用于的信息UPPER()。有关如何大小写二进制串的转换执行这包括信息（BINARY，VARBINARY，BLOB），用于这些功能是无效的，以及约壳体折叠的Unicode字符集的信息。
此功能是多字节安全的。
UCASE()视图中使用的重写为UPPER()。

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

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

如果= ，则（和视为相等）WEIGHT_STRING(str1)WEIGHT_STRING(str2)str1= str2str1str2
如果<，则（在之前排序）WEIGHT_STRING(str1)WEIGHT_STRING(str2)str1<str2str1str2

WEIGHT_STRING()是供内部使用的调试功能。在MySQL版本之间，其行为可能会更改，恕不另行通知。它可以用于测试和调试归类，尤其是在添加新归类时。请参见“向字符集添加校验规则”。

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

str：输入字符串表达式。
AS子句：可选；将输入字符串转换为给定的类型和长度。
flags：可选的；没用过。

输入字符串，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 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                              	|
+---------------------------------------	+

该flags子句当前未使用。