12.8 字符串函数和运算符

# 12.8 字符串函数和运算符

表 12.12 字符串函数和运算符

姓名	描述
`ASCII()`	返回最左边字符的数值
`斌（）`	返回一个包含数字二进制表示的字符串
`BIT_LENGTH()`	返回参数的长度（以位为单位）
`字符（）`	返回传递的每个整数的字符
`CHAR_LENGTH()`	返回参数中的字符数
`CHARACTER_LENGTH()`	CHAR 的同义词_长度（）
`连接（）`	返回连接的字符串
`CONCAT_WS()`	返回与分隔符连接
`埃尔特（）`	返回索引号处的字符串
`EXPORT_SET()`	返回一个字符串，这样对于值位中设置的每个位，您都会得到一个 on 字符串，对于每个未设置的位，您都会得到一个 off 字符串
`场地（）`	后续参数中第一个参数的索引（位置）
`FIND_IN_SET()`	第二个参数中第一个参数的索引（位置）
`格式（）`	返回格式化为指定小数位数的数字
`FROM_BASE64()`	解码base64编码字符串并返回结果
`十六进制（）`	十进制或字符串值的十六进制表示
`插入（）`	在指定位置插入子字符串，最多指定字符数
`指令（）`	返回子字符串第一次出现的索引
`LCASE()`	LOWER() 的同义词
`剩下（）`	返回指定的最左边的字符数
`长度（）`	返回字符串的长度（以字节为单位）
`喜欢`	简单的模式匹配
`加载文件（）`	加载命名文件
`定位（）`	返回子字符串第一次出现的位置
`降低（）`	以小写形式返回参数
`LPAD()`	返回字符串参数，左填充指定的字符串
`LTRIM()`	删除前导空格
`MAKE_SET()`	返回一组逗号分隔的字符串，这些字符串在 bits 集中具有相应的位
`匹配（）`	执行全文搜索
`中（）`	返回从指定位置开始的子字符串
`不喜欢`	简单模式匹配的否定
`不是正则表达式`	否定正则表达式
`华侨城()`	返回包含数字的八进制表示的字符串
`OCTET_LENGTH()`	LENGTH() 的同义词
`ORD()`	返回参数最左边字符的字符代码
`位置（）`	LOCATE() 的同义词
`引用（）`	转义参数以在 SQL 语句中使用
`正则表达式`	字符串是否匹配正则表达式
`正则表达式_INSTR()`	子串匹配正则表达式的起始索引
`正则表达式_LIKE()`	字符串是否匹配正则表达式
`正则表达式_REPLACE()`	替换匹配正则表达式的子字符串
`REGEXP_SUBSTR()`	返回匹配正则表达式的子字符串
`重复（）`	重复一个字符串指定的次数
`代替（）`	替换指定字符串的出现
`逆转（）`	反转字符串中的字符
`正确的（）`	返回指定的最右边的字符数
`力克`	字符串是否匹配正则表达式
`RPAD()`	附加字符串指定次数
`RTRIM()`	删除尾随空格
`声音（）`	返回一个 soundex 字符串
`听起来像`	比较声音
`空间（）`	返回指定空格数的字符串
`STRCMP()`	比较两个字符串
`SUBSTR()`	返回指定的子字符串
`子串（）`	返回指定的子字符串
`SUBSTRING_INDEX()`	从指定出现次数的分隔符之前的字符串中返回子字符串
`TO_BASE64()`	返回转换为 base-64 字符串的参数
`修剪（）`	删除前导和尾随空格
`UCASE()`	UPPER() 的同义词
`十六进制（）`	返回包含数字的十六进制表示的字符串
`上（）`	转换为大写
`重量字符串（）`	返回字符串的权重字符串

字符串值函数返回空值如果结果的长度大于max_allowed_packet系统变量。看第 5.1.1 节，“配置服务器”.

对于对字符串位置进行操作的函数，第一个位置编号为 1。

对于采用长度参数的函数，非整数参数四舍五入到最接近的整数。

ASCII(*字符串*)

返回字符串最左边字符的数值*字符串.退货0如果字符串是空字符串。退货空值如果字符串*是空值.ASCII()适用于 8 位字符。
```
mysql> SELECT ASCII('2');
        -> 50
mysql> SELECT ASCII(2);
        -> 50
mysql> SELECT ASCII('dx');
        -> 100
```
另见ORD()功能。
斌（*ñ*)

返回二进制值的字符串表示形式*ñ，在哪里ñ是一个longlong (大整数）数字。这相当于转化率（*ñ*,10,2).退货空值如果ñ*是空值.
```
mysql> SELECT BIN(12);
        -> '1100'
```
BIT_LENGTH(*字符串*)

返回字符串的长度*字符串*位。
```
mysql> SELECT BIT_LENGTH('text');
        -> 32
```

字符（*ñ*，... [使用 *字符集名称*])

字符（）解释每个参数*ñ*作为整数并返回由这些整数的代码值给出的字符组成的字符串。空值值被跳过。

mysql> SELECT CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
        -> 'MMM'

字符（）大于 255 的参数将转换为多个结果字节。例如，字符(256)相当于字符(1,0)，和字符(256*256)相当于字符（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             |
+------------------+--------------------+

默认，字符（）返回一个二进制字符串。要生成给定字符集中的字符串，请使用可选的使用条款：

mysql> SELECT CHARSET(CHAR(X'65')), CHARSET(CHAR(X'65' USING utf8));
+----------------------+---------------------------------+
| CHARSET(CHAR(X'65')) | CHARSET(CHAR(X'65' USING utf8)) |
+----------------------+---------------------------------+
| binary               | utf8                            |
+----------------------+---------------------------------+

如果使用给出并且结果字符串对于给定字符集是非法的，则发出警告。此外，如果启用了严格的 SQL 模式，则结果来自字符（）变成空值.

如果字符（）从内部调用mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex.有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”.

CHAR_LENGTH(*字符串*)

返回字符串的长度*字符串*，以代码点测量。多字节字符计为单个代码点。这意味着，对于包含两个 3 字节字符的字符串，长度（）返回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)

CHARACTER_LENGTH(*字符串*)

CHARACTER_LENGTH()是同义词CHAR_LENGTH().
连接（*str1*,*str2*,...)

返回由连接参数产生的字符串。可能有一个或多个参数。如果所有参数都是非二进制字符串，则结果是非二进制字符串。如果参数包含任何二进制字符串，则结果为二进制字符串。一个数字参数被转换成它的等价的非二进制字符串形式。

连接（）返回空值如果有任何论据空值.
```
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客户端，二进制字符串结果使用十六进制表示法显示，具体取决于--binary-as-hex.有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”.
CONCAT_WS(*分隔器*,*str1*,*str2*,...)

CONCAT_WS()代表 Concatenate With Separator 并且是一种特殊形式连接（）.第一个参数是其余参数的分隔符。在要连接的字符串之间添加分隔符。分隔符可以是字符串，其余参数也可以。如果分隔符是空值，结果是空值.
```
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()不跳过空字符串。但是，它确实跳过了任何空值分隔符参数后的值。
英语（*ñ*,*str1*,*str2*,*str3*,...)

埃尔特（）返回*ñ字符串列表的第 th 个元素：str1如果ñ=1,str2如果ñ=2，等等。退货空值如果ñ*小于1或大于参数的数量。埃尔特（）是的补码场地（）.
```
mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
        -> 'Aa'
mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
        -> 'Dd'
```
EXPORT_SET(*位*,*在*,*关*[,*分离器*[,*位的数量*]])

返回一个字符串，这样对于值中设置的每一位*位，你会得到一个在…上字符串，对于值中未设置的每一位，都会得到一个关一串点点滴滴位从右到左（从低阶位到高阶位）检查。字符串从左到右添加到结果中，由分离器字符串（默认为逗号字符）,).检查的位数由以下公式给出：位的数量，如果未指定，则默认值为64。位的数量*如果大于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'
```
场(*str*,*str1*,*str2*,*str3*,...)

返回的索引（位置）str在str1, str2, str3, ...列表退换商品0如果*str*找不到。

如果所有的论点字段（）是字符串，所有参数都作为字符串进行比较。如果所有参数都是数字，则它们将作为数字进行比较。否则，两个参数会进行双重比较。

如果*str*是无效的，返回值为0因为无效的无法与任何值进行相等比较。字段（）是…的补充ELT（）.
```
mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
        -> 2
mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
        -> 0
```
在_集合中查找(*str*,*斯特利斯特*)

返回一个介于1到1之间的值*N如果绳子str在字符串列表中斯特利斯特包括N子字符串。字符串列表是由子字符串组成的字符串，子字符串之间用,角色。如果第一个参数是常量字符串，第二个参数是类型为设置这个在_集合（）中查找_函数优化为使用位算法。退换商品0如果str不在斯特利斯特或者如果斯特利斯特*是空字符串。退换商品无效的如果其中一个论点是无效的。如果第一个参数包含逗号，则此函数无法正常工作(,)性格。
```
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2
```
格式(*十、*,*D*[,*场所*])

设置数字格式*十、以这样的形式'#,###,###.##'，四舍五入至D小数位数，并以字符串形式返回结果。如果D*是0，结果没有小数点或小数部分。

可选的第三个参数允许指定用于结果数字小数点、千位分隔符和分隔符之间分组的区域设置。允许的区域设置值与lc_时间_姓名系统变量（参见第10.16节，“MySQL服务器区域设置支持”)。如果未指定区域设置，则默认为“恩_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'
```
来自_BASE64(*str*)

获取一个使用的base-64编码规则编码的字符串致_BASE64（）并将解码结果作为二进制字符串返回。结果是无效的如果论点是正确的无效的或者不是有效的base-64字符串。请参阅的描述致_BASE64（）有关编码和解码规则的详细信息。
```
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'
```
如果来自_BASE64（）从mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--二进制为十六进制。有关该选项的更多信息，请参阅第4.5.1节，“mysql——mysql命令行客户端”.
妖术(*str*), 妖术(*N*)

对于字符串参数*str, 十六进制（）返回的十六进制字符串表示形式str其中每个字符的每个字节str*转换为两个十六进制数字。（因此，多字节字符超过两位数。）此操作的逆操作由UNHEX（）作用

对于数字参数*N, 十六进制（）返回的值的十六进制字符串表示形式N*被当作长龙对待(比金)号码。这相当于康夫(*N*,10,16).此操作的逆操作由CONV（十六进制）(*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
```
插入(*p*销售时点情报系统*n*新闻记者*)

返回字符串*p子字符串从位置开始销售时点情报系统和n长时间被字符串替换的字符新闻记者返回原始字符串，如果销售时点情报系统不在字符串长度内。从位置替换字符串的其余部分销售时点情报系统如果n*不在字符串其余部分的长度范围内。退换商品无效的如果有任何论据无效的.
```
mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
        -> 'QuWhattic'
mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
        -> 'Quadratic'
mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
        -> 'QuWhat'
```
这个函数是多字节安全的。
仪表(*p*,*substr*)

返回子字符串第一次出现的位置*substr串起str*.这和定位（），但参数的顺序是相反的。
```
mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0
```
此函数是多字节安全的，并且仅当至少一个参数是二进制字符串时才区分大小写。
LCASE(*str*)

LCASE（）是的同义词下（）.

LCASE（）在视图中使用的被重写为下（）存储视图的定义时。（错误#12844279）
左(*str*,*伦恩*)

返回最左边的*伦恩字符串中的字符str*或无效的如果有任何论据无效的.
```
mysql> SELECT LEFT('foobarbar', 5);
        -> 'fooba'
```
这个函数是多字节安全的。
长度(*str*)

返回字符串的长度*str*，以字节为单位。多字节字符计为多个字节。这意味着对于包含五个2字节字符的字符串，长度（）返回10鉴于字符长度（）返回5..
```
mysql> SELECT LENGTH('text');
        -> 4
```
笔记

这个长度（）OpenGIS空间功能被命名为ST_Length（）在MySQL中。
加载文件(*文件名*)

读取文件并以字符串形式返回文件内容。要使用此功能，文件必须位于服务器主机上，必须指定文件的完整路径名，并且必须具有文件特权服务器必须能够读取该文件，且其大小小于最大允许包数字节。如果安全文件如果系统变量设置为非空目录名，则要加载的文件必须位于该目录中。（在MySQL 8.0.17之前，文件必须是所有人都可以读取的，而不仅仅是服务器可以读取。）

如果文件不存在或由于不满足上述条件之一而无法读取，则函数返回无效的.

这个字符集文件系统系统变量控制以文字字符串形式给出的文件名的解释。
```
mysql> UPDATE t
            SET blob_col=LOAD_FILE('/tmp/picture')
            WHERE id=1;
```
定位(*substr*,*str*), 定位(*substr*,*str*,*销售时点情报系统*)

第一个语法返回子字符串第一次出现的位置*substr串起str.第二种语法返回子字符串第一次出现的位置substr串起str，从位置开始销售时点情报系统.返回0如果substr不在str*.返回无效的如果有任何论据无效的.
```
mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7
```
此函数是多字节安全的，并且仅当至少一个参数是二进制字符串时才区分大小写。
降低(*str*)

返回字符串*str*根据当前字符集映射将所有字符更改为小写。默认值是utf8mb4.
```
mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'
```
下（）（及上（）)应用于二进制字符串时无效(二进制的, VARBINARY, 斑点).要执行二进制字符串的字母大小写转换，请首先使用适用于字符串中存储的数据的字符集将其转换为非二进制字符串：
```
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字符集的排序，下（）和上（）根据排序规则名称中的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工作。看见第10.10.1节，“Unicode字符集”.

这个函数是多字节安全的。

LCASE（）在视图中使用的将重写为下（）.
LPAD(*str*,*伦恩*,*帕德斯特*)

返回字符串*str，左边用绳子填充帕德斯特长达伦恩角色。如果str比伦恩，返回值缩短为伦恩*角色。
```
mysql> SELECT LPAD('hi',4,'??');
        -> '??hi'
mysql> SELECT LPAD('hi',1,'??');
        -> 'h'
```
LTRIM(*str*)

返回字符串*str*删除前导空格字符。
```
mysql> SELECT LTRIM('  barbar');
        -> 'barbar'
```
这个函数是多字节安全的。

定做(*位*,*str1*,*str2*,...)

返回一个集合值（一个包含由,字符）由字符串组成，字符串中有相应的位*位设置str1对应于位0，str2到第1位，依此类推。无效的价值观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');
        -> ''

中段(*str*,*销售时点情报系统*,*伦恩*)

中段(*str*,*销售时点情报系统*,*伦恩*)是的同义词子串(*str*,*销售时点情报系统*,*伦恩*).
十月(*N*)

返回的八进制值的字符串表示形式*N哪里N这是一条很长的路(比金)号码。这相当于康夫(*N*,10,8).返回无效的如果N*是无效的.
```
mysql> SELECT OCT(12);
        -> '14'
```
八位组长度(*str*)

八位组长度（）是的同义词长度（）.
奥德(*str*)

如果字符串最左边的字符*str*是一个多字节字符，返回该字符的代码，使用以下公式从其组成字节的数值计算：
```
  (1st byte code)
+ (2nd byte code * 256)
+ (3rd byte code * 256^2) ...
```
如果最左边的字符不是多字节字符，ORD（）返回与ASCII（）作用
```
mysql> SELECT ORD('2');
        -> 50
```
位置(*substr*在*str*)

位置(*substr*在*str*)是的同义词定位(*substr*,*str*).
引用(*str*)

引用字符串以生成一个结果，该结果可用作SQL语句中正确转义的数据值。返回的字符串用单引号括起来，并带有反斜杠的每个实例(\)，单引号(')，ASCII码努尔，并在Control+Z前面加上反斜杠。如果论点是正确的无效的，返回值为单词“NULL”，不包含单引号。
```
mysql> SELECT QUOTE('Don\'t!');
        -> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
        -> NULL
```
要进行比较，请参阅中的C API中文字字符串和的引号规则第9.1.1节“字符串文字”和mysql_真实的_逃跑_一串_引用（） (opens new window).
重复(*str*,*计数*)

返回由字符串组成的字符串*str重复的计数时报。如果计数小于1，返回空字符串。退换商品无效的如果str或计数*是无效的.
```
mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
```
替换(*str*,*来自_街*,*到_街*)

返回字符串*str所有出现的字符串来自_街替换为字符串到_街. 替换（）搜索时执行区分大小写的匹配来自_街*.
```
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwWw.mysql.com'
```
这个函数是多字节安全的。
逆转(*str*)

返回字符串*str*字符顺序颠倒。
```
mysql> SELECT REVERSE('abc');
        -> 'cba'
```
这个函数是多字节安全的。
对(*str*,*伦恩*)

返回最右边的*伦恩字符串中的字符str*或无效的如果有任何论据无效的.
```
mysql> SELECT RIGHT('foobarbar', 4);
        -> 'rbar'
```
这个函数是多字节安全的。
RPAD(*str*,*伦恩*,*帕德斯特*)

返回字符串*str，右边用绳子填充帕德斯特长达伦恩角色。如果str比伦恩，返回值缩短为伦恩*角色。
```
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（）函数返回任意长的字符串。你可以用子字符串（）根据结果获得标准soundex字符串。中的所有非阿尔卑斯字符str*都被忽略了。A-Z范围之外的所有国际字母字符都被视为元音。

重要的

使用时SOUNDEX（），您应该注意以下限制：
- 当前实现的此函数旨在处理仅使用英语的字符串。其他语言中的字符串可能无法产生可靠的结果。
- 此函数不能保证为使用多字节字符集的字符串提供一致的结果，包括utf-8.有关更多信息，请参见Bug#22638。
```
mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'
```
笔记

该函数实现了原始的Soundex算法，而不是更流行的增强版（也由D.Knuth描述）。不同之处在于，原始版本先丢弃元音，然后再丢弃重复的元音，而增强版则先丢弃重复的元音，然后再丢弃元音。
*expr1*听起来像*expr2*

这和SOUNDEX(*expr1*)=SOUNDEX(*expr2*).
空间(*N*)

返回由以下内容组成的字符串：*N*空格字符。
```
mysql> SELECT SPACE(6);
        -> '      '
```
SUBSTR(*str*,*销售时点情报系统*), SUBSTR(*str*来自*销售时点情报系统*), SUBSTR(*str*,*销售时点情报系统*,*伦恩*), SUBSTR(*str*来自*销售时点情报系统*因为*伦恩*)

SUBSTR（）是的同义词子字符串（）.
子串(*str*,*销售时点情报系统*), 子串(*str*来自*销售时点情报系统*), 子串(*str*,*销售时点情报系统*,*伦恩*), 子串(*str*来自*销售时点情报系统*因为*伦恩*)

表格中没有*伦恩参数从字符串返回子字符串str从位置开始销售时点情报系统.带有伦恩参数返回一个子字符串伦恩字符串中的长字符str，从位置开始销售时点情报系统.使用从…起是标准的SQL语法。也可以将负值用于销售时点情报系统.在这种情况下，子字符串的开头是销售时点情报系统字符串末尾的字符，而不是开头的字符。负值可用于销售时点情报系统以这种功能的任何形式。值为0表示销售时点情报系统*返回一个空字符串。

对于所有形式的子字符串（），将从中提取子字符串的字符串中第一个字符的位置计算为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'
```
这个函数是多字节安全的。

如果*伦恩*小于1，则结果为空字符串。
子串索引(*str*,*德利姆*,*计数*)

从字符串返回子字符串*str之前计数分隔符的出现德利姆如果计数如果为正，则返回最后定界符左侧的所有内容（从左侧开始计数）。如果计数如果为负数，则返回最后定界符右侧的所有内容（从右侧开始计数）。子字符串_索引（）搜索时执行区分大小写的匹配德利姆*.
```
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'
```
这个函数是多字节安全的。
去你的基地64(*str*)

将字符串参数转换为base-64编码形式，并将结果作为带有连接字符集和排序规则的字符串返回。如果参数不是字符串，则在转换之前将其转换为字符串。结果是无效的如果论点是正确的无效的.Base-64编码字符串可以使用来自_BASE64（）作用
```
mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'
```
存在不同的base-64编码方案。这些是用户使用的编码和解码规则致_BASE64（）和来自_BASE64（）:
- 字母表值62的编码为'+'.
- 字母表值63的编码为'/'.
- 编码输出由4个可打印字符组成。输入数据的每3个字节使用4个字符进行编码。如果最后一组是不完整的，则用'='字符长度为4。
- 在编码输出的每76个字符后添加一个换行符，将长输出分成多行。
- 解码识别并忽略换行符、回车符、制表符和空格。
修剪（[{两个|领先|落后}[*雷姆斯特尔*]来自]*str*), 修剪([*雷姆斯特尔*来自]*str*)

返回字符串*str所有的雷姆斯特尔移除前缀或后缀。如果没有任何说明符二者都, 主要的或拖尾的被给予，二者都这是假定的。雷姆斯特尔*是可选的，如果未指定，则删除空格。
```
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'
```
这个函数是多字节安全的。
尤卡斯(*str*)

UCASE（）是的同义词上（）.

UCASE（）在视图中使用的将重写为上（）.
取消(*str*)

对于字符串参数*str*, 取消(*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”.如果参数包含任何非十六进制数字，则结果为无效的:
```
mysql> SELECT UNHEX('GG');
+-------------+
| UNHEX('GG') |
+-------------+
| NULL        |
+-------------+
```
A.无效的如果参数UNHEX（）是一个二进制的列，因为值中填充了0x00存储时为字节，但检索时不剥离这些字节。例如'41'存储在查尔（3）列为'41 '并作为'41'（在去掉拖垫空间的情况下），所以UNHEX（）对于返回的列值X'41'相比之下'41'存储在二进制（3）列为'41\0'并作为'41\0'（带拖垫）0x00字节（未剥离）。'\0'不是合法的十六进制数字，所以UNHEX（）对于返回的列值无效的.

对于数字参数*N*，与妖术(*N*)不是由UNHEX（）使用CONV（十六进制）(*N*),16,10)相反请参阅的描述十六进制（）.

如果UNHEX（）从mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--二进制为十六进制。有关该选项的更多信息，请参阅第4.5.1节，“mysql——mysql命令行客户端”.
上层(*str*)

返回字符串*str*根据当前字符集映射将所有字符更改为大写。默认值是utf8mb4.
```
mysql> SELECT UPPER('Hej');
        -> 'HEJ'
```
请参阅的描述下（）获取同样适用于上（）。这包括有关如何执行二进制字符串的字母大小写转换的信息(二进制的, VARBINARY, 斑点)以及有关Unicode字符集大小写折叠的信息。

这个函数是多字节安全的。

UCASE（）在视图中使用的将重写为上（）.
重量线(*str*[作为{CHAR | BINARY}(*N*)] [*旗帜*])

此函数用于返回输入字符串的权重字符串。返回值是一个二进制字符串，表示字符串的比较和排序值。它具有以下特性：
- 如果重量线(*str1*) = 重量线(*str2*)然后*str1* = *str2* (str1和str2（被认为是平等的）
- 如果重量线(*str1*) \< 重量线(*str2*)然后*str1* < *str2* (str1排序之前str2)
重量_字符串（）是一种供内部使用的调试功能。在不同的MySQL版本之间，它的行为可能会发生变化，恕不另行通知。它可以用于测试和调试排序规则，尤其是在添加新排序规则时。看见第10.14节，“向字符集添加排序规则”.

这个列表简要总结了这些论点。下面的讨论给出了更多细节。
- str：输入字符串表达式。
- 像条款：可选；将输入字符串强制转换为给定的类型和长度。
- 旗帜：可选；没用过。
  
  输入字符串，str，是一个字符串表达式。如果输入是非二进制（字符）字符串，例如烧焦, 瓦尔查尔或文本值，返回值包含字符串的排序规则权重。如果输入是二进制（字节）字符串，例如二进制的, VARBINARY或斑点值，返回值与输入值相同（二进制字符串中每个字节的权重为字节值）。如果输入是无效的, 重量_字符串（）返回无效的.
  
  例如：
```
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                   |
+------+---------+------------------------+
```
前面的例子使用十六进制（）显示重量_字符串（）后果因为结果是一个二进制值，十六进制（）当结果包含非打印值时，以可打印形式显示它尤其有用：
```
mysql> SET @s = CONVERT(X'C39F' USING utf8) COLLATE utf8_czech_ci;
mysql> SELECT HEX(WEIGHT_STRING(@s));
+------------------------+
| HEX(WEIGHT_STRING(@s)) |
+------------------------+
| 0FEA0FEA               |
+------------------------+
```
非-无效的返回值，该值的数据类型为VARBINARY如果其长度在VARBINARY，否则数据类型为斑点.

这个像子句可以将输入字符串强制转换为非二进制或二进制字符串，并将其强制转换为给定长度：
- 作为字符(*N*)将字符串强制转换为非二进制字符串，并在右侧填充长度为的空格*N角色。N必须至少为1。如果N小于输入字符串的长度时，字符串将被截断为N*角色。截断不会出现警告。
- 作为二进制(*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                              |
+---------------------------------------+
```
这个*旗帜*子句当前未使用。

如果重量_字符串（）从mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--二进制为十六进制。有关该选项的更多信息，请参阅第4.5.1节，“mysql——mysql命令行客户端”.

← 12.7 日期和时间函数 12.8.1 字符串比较函数和运算符 →