## 12.8 字符串函数和运算符

[12.8.1 字符串比较函数和运算符](string-comparison-functions.html)
[12.8.2 正则表达式](regexp.html)
[12.8.3 字符集和函数结果的整理](string-functions-charset.html)

[](<>)[](<>)[](<>)[](<>)

[](<>)

**表 12.12 字符串函数和运算符**

| 姓名 | 描述 |
| --- | --- |
| [`ASCII()`](string-functions.html#function_ascii) | 返回最左边字符的数值 |
| [`斌（）`](string-functions.html#function_bin) | 返回一个包含数字二进制表示的字符串 |
| [`BIT_LENGTH()`](string-functions.html#function_bit-length) | 返回参数的长度（以位为单位） |
| [`字符（）`](string-functions.html#function_char) | 返回传递的每个整数的字符 |
| [`CHAR_LENGTH()`](string-functions.html#function_char-length) | 返回参数中的字符数 |
| [`CHARACTER_LENGTH()`](string-functions.html#function_character-length) | CHAR 的同义词\_长度（） |
| [`连接（）`](string-functions.html#function_concat) | 返回连接的字符串 |
| [`CONCAT_WS()`](string-functions.html#function_concat-ws) | 返回与分隔符连接 |
| [`埃尔特（）`](string-functions.html#function_elt) | 返回索引号处的字符串 |
| [`EXPORT_SET()`](string-functions.html#function_export-set) | 返回一个字符串，这样对于值位中设置的每个位，您都会得到一个 on 字符串，对于每个未设置的位，您都会得到一个 off 字符串 |
| [`场地（）`](string-functions.html#function_field) | 后续参数中第一个参数的索引（位置） |
| [`FIND_IN_SET()`](string-functions.html#function_find-in-set) | 第二个参数中第一个参数的索引（位置） |
| [`格式（）`](string-functions.html#function_format) | 返回格式化为指定小数位数的数字 |
| [`FROM_BASE64()`](string-functions.html#function_from-base64) | 解码base64编码字符串并返回结果 |
| [`十六进制（）`](string-functions.html#function_hex) | 十进制或字符串值的十六进制表示 |
| [`插入（）`](string-functions.html#function_insert) | 在指定位置插入子字符串，最多指定字符数 |
| [`指令（）`](string-functions.html#function_instr) | 返回子字符串第一次出现的索引 |
| [`LCASE()`](string-functions.html#function_lcase) | LOWER() 的同义词 |
| [`剩下（）`](string-functions.html#function_left) | 返回指定的最左边的字符数 |
| [`长度（）`](string-functions.html#function_length) | 返回字符串的长度（以字节为单位） |
| [`喜欢`](string-comparison-functions.html#operator_like) | 简单的模式匹配 |
| [`加载文件（）`](string-functions.html#function_load-file) | 加载命名文件 |
| [`定位（）`](string-functions.html#function_locate) | 返回子字符串第一次出现的位置 |
| [`降低（）`](string-functions.html#function_lower) | 以小写形式返回参数 |
| [`LPAD()`](string-functions.html#function_lpad) | 返回字符串参数，左填充指定的字符串 |
| [`LTRIM()`](string-functions.html#function_ltrim) | 删除前导空格 |
| [`MAKE_SET()`](string-functions.html#function_make-set) | 返回一组逗号分隔的字符串，这些字符串在 bits 集中具有相应的位 |
| [`匹配（）`](fulltext-search.html#function_match) | 执行全文搜索 |
| [`中（）`](string-functions.html#function_mid) | 返回从指定位置开始的子字符串 |
| [`不喜欢`](string-comparison-functions.html#operator_not-like) | 简单模式匹配的否定 |
| [`不是正则表达式`](regexp.html#operator_not-regexp) | 否定正则表达式 |
| [`华侨城()`](string-functions.html#function_oct) | 返回包含数字的八进制表示的字符串 |
| [`OCTET_LENGTH()`](string-functions.html#function_octet-length) | LENGTH() 的同义词 |
| [`ORD()`](string-functions.html#function_ord) | 返回参数最左边字符的字符代码 |
| [`位置（）`](string-functions.html#function_position) | LOCATE() 的同义词 |
| [`引用（）`](string-functions.html#function_quote) | 转义参数以在 SQL 语句中使用 |
| [`正则表达式`](regexp.html#operator_regexp) | 字符串是否匹配正则表达式 |
| [`正则表达式_INSTR()`](regexp.html#function_regexp-instr) | 子串匹配正则表达式的起始索引 |
| [`正则表达式_LIKE()`](regexp.html#function_regexp-like) | 字符串是否匹配正则表达式 |
| [`正则表达式_REPLACE()`](regexp.html#function_regexp-replace) | 替换匹配正则表达式的子字符串 |
| [`REGEXP_SUBSTR()`](regexp.html#function_regexp-substr) | 返回匹配正则表达式的子字符串 |
| [`重复（）`](string-functions.html#function_repeat) | 重复一个字符串指定的次数 |
| [`代替（）`](string-functions.html#function_replace) | 替换指定字符串的出现 |
| [`逆转（）`](string-functions.html#function_reverse) | 反转字符串中的字符 |
| [`正确的（）`](string-functions.html#function_right) | 返回指定的最右边的字符数 |
| [`力克`](regexp.html#operator_regexp) | 字符串是否匹配正则表达式 |
| [`RPAD()`](string-functions.html#function_rpad) | 附加字符串指定次数 |
| [`RTRIM()`](string-functions.html#function_rtrim) | 删除尾随空格 |
| [`声音（）`](string-functions.html#function_soundex) | 返回一个 soundex 字符串 |
| [`听起来像`](string-functions.html#operator_sounds-like) | 比较声音 |
| [`空间（）`](string-functions.html#function_space) | 返回指定空格数的字符串 |
| [`STRCMP()`](string-comparison-functions.html#function_strcmp) | 比较两个字符串 |
| [`SUBSTR()`](string-functions.html#function_substr) | 返回指定的子字符串 |
| [`子串（）`](string-functions.html#function_substring) | 返回指定的子字符串 |
| [`SUBSTRING_INDEX()`](string-functions.html#function_substring-index) | 从指定出现次数的分隔符之前的字符串中返回子字符串 |
| [`TO_BASE64()`](string-functions.html#function_to-base64) | 返回转换为 base-64 字符串的参数 |
| [`修剪（）`](string-functions.html#function_trim) | 删除前导和尾随空格 |
| [`UCASE()`](string-functions.html#function_ucase) | UPPER() 的同义词 |
| [`十六进制（）`](string-functions.html#function_unhex) | 返回包含数字的十六进制表示的字符串 |
| [`上（）`](string-functions.html#function_upper) | 转换为大写 |
| [`重量字符串（）`](string-functions.html#function_weight-string) | 返回字符串的权重字符串 |

字符串值函数返回`空值`如果结果的长度大于[`max_allowed_pa​​cket`](server-system-variables.html#sysvar_max_allowed_packet)系统变量。看[第 5.1.1 节，“配置服务器”](server-configuration.html).

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

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

-   [](<>)

    [`ASCII(*`字符串`*)`](string-functions.html#function_ascii)

    [](<>)

    返回字符串最左边字符的数值*`字符串`*.退货`0`如果*`字符串`*是空字符串。退货`空值`如果*`字符串`*是`空值`.[`ASCII()`](string-functions.html#function_ascii)适用于 8 位字符。

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

    另见[`ORD()`](string-functions.html#function_ord)功能。

-   [](<>)

    [`斌（*`ñ`*)`](string-functions.html#function_bin)

    [](<>)

    返回二进制值的字符串表示形式*`ñ`*， 在哪里*`ñ`*是一个longlong ([`大整数`](integer-types.html)） 数字。这相当于[`转化率（*`ñ`*,10,2)`](mathematical-functions.html#function_conv).退货`空值`如果*`ñ`*是`空值`.

    ```
    mysql> SELECT BIN(12);
            -> '1100'
    ```

-   [](<>)

    [`BIT_LENGTH(*`字符串`*)`](string-functions.html#function_bit-length)

    [](<>)

    返回字符串的长度*`字符串`*位。

    ```
    mysql> SELECT BIT_LENGTH('text');
            -> 32
    ```

-   [](<>)

    [`字符（*`ñ`*，... [使用 *`字符集名称`*])`](string-functions.html#function_char)

    [](<>)

    [`字符（）`](string-functions.html#function_char)解释每个参数*`ñ`*作为整数并返回由这些整数的代码值给出的字符组成的字符串。`空值`值被跳过。

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

    [`字符（）`](string-functions.html#function_char)大于 255 的参数将转换为多个结果字节。例如，[`字符(256)`](string-functions.html#function_char)相当于[`字符(1,0)`](string-functions.html#function_char)， 和[`字符(256*256)`](string-functions.html#function_char)相当于[`字符（1,0,0）`](string-functions.html#function_char)：

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

    默认，[`字符（）`](string-functions.html#function_char)返回一个二进制字符串。要生成给定字符集中的字符串，请使用可选的`使用`条款：

    ```
    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 模式，则结果来自[`字符（）`](string-functions.html#function_char)变成`空值`.

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

-   [](<>)

    [`CHAR_LENGTH(*`字符串`*)`](string-functions.html#function_char-length)

    [](<>)

    返回字符串的长度*`字符串`*，以代码点测量。多字节字符计为单个代码点。这意味着，对于包含两个 3 字节字符的字符串，[`长度（）`](string-functions.html#function_length)返回`6`， 然而[`CHAR_LENGTH()`](string-functions.html#function_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(*`字符串`*)`](string-functions.html#function_character-length)

    [](<>)

    [`CHARACTER_LENGTH()`](string-functions.html#function_character-length)是同义词[`CHAR_LENGTH()`](string-functions.html#function_char-length).

-   [](<>)

    [`连接（*`str1`*,*`str2`*,...)`](string-functions.html#function_concat)

    [](<>)[](<>)[](<>)

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

    [`连接（）`](string-functions.html#function_concat)返回`空值`如果有任何论据`空值`.

    ```
    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'
    ```

    如果[`连接（）`](string-functions.html#function_concat)从内部调用[**mysql**](mysql.html)客户端，二进制字符串结果使用十六进制表示法显示，具体取决于[`--binary-as-hex`](mysql-command-options.html#option_mysql_binary-as-hex).有关该选项的更多信息，请参阅[第 4.5.1 节，“mysql - MySQL 命令行客户端”](mysql.html).

-   [](<>)

    [`CONCAT_WS(*`分隔器`*,*`str1`*,*`str2`*,...)`](string-functions.html#function_concat-ws)

    [](<>)

    [`CONCAT_WS()`](string-functions.html#function_concat-ws)代表 Concatenate With Separator 并且是一种特殊形式[`连接（）`](string-functions.html#function_concat).第一个参数是其余参数的分隔符。在要连接的字符串之间添加分隔符。分隔符可以是字符串，其余参数也可以。如果分隔符是`空值`，结果是`空值`.

    ```
    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()`](string-functions.html#function_concat-ws)不跳过空字符串。但是，它确实跳过了任何`空值`分隔符参数后的值。

-   [](<>)

    [`英语（*`ñ`*,*`str1`*,*`str2`*,*`str3`*,...)`](string-functions.html#function_elt)

    [](<>)

    [`埃尔特（）`](string-functions.html#function_elt)返回*`ñ`*字符串列表的第 th 个元素：*`str1`*如果*`ñ`*=`1`,*`str2`*如果*`ñ`*=`2`， 等等。退货`空值`如果*`ñ`*小于`1`或大于参数的数量。[`埃尔特（）`](string-functions.html#function_elt)是的补码[`场地（）`](string-functions.html#function_field).

    ```
    mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
            -> 'Aa'
    mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
            -> 'Dd'
    ```

-   [](<>)

    [`EXPORT_SET(*`位`*,*`在`*,*`关`*[,*`分离器`*[,*`位的数量`*]])`](string-functions.html#function_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`*,...)`](string-functions.html#function_field)

    [](<>)

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

    如果所有的论点[`字段（）`](string-functions.html#function_field)是字符串，所有参数都作为字符串进行比较。如果所有参数都是数字，则它们将作为数字进行比较。否则，两个参数会进行双重比较。

    如果*`str`*是`无效的`，返回值为`0`因为`无效的`无法与任何值进行相等比较。[`字段（）`](string-functions.html#function_field)是…的补充[`ELT（）`](string-functions.html#function_elt).

    ```
    mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
            -> 2
    mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
            -> 0
    ```

-   [](<>)

    [`在_集合中查找(*`str`*,*`斯特利斯特`*)`](string-functions.html#function_find-in-set)

    [](<>)

    返回一个介于1到1之间的值*`N`*如果绳子*`str`*在字符串列表中*`斯特利斯特`*包括*`N`*子字符串。字符串列表是由子字符串组成的字符串，子字符串之间用`,`角色。如果第一个参数是常量字符串，第二个参数是类型为[`设置`](set.html)这个[`在_集合（）中查找_`](string-functions.html#function_find-in-set)函数优化为使用位算法。退换商品`0`如果*`str`*不在*`斯特利斯特`*或者如果*`斯特利斯特`*是空字符串。退换商品`无效的`如果其中一个论点是`无效的`。如果第一个参数包含逗号，则此函数无法正常工作(`,`)性格。

    ```
    mysql> SELECT FIND_IN_SET('b','a,b,c,d');
            -> 2
    ```

-   [](<>)

    [`格式(*`十、`*,*`D`*[,*`场所`*])`](string-functions.html#function_format)

    [](<>)

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

    可选的第三个参数允许指定用于结果数字小数点、千位分隔符和分隔符之间分组的区域设置。允许的区域设置值与[`lc_时间_姓名`](server-system-variables.html#sysvar_lc_time_names)系统变量（参见[第10.16节，“MySQL服务器区域设置支持”](locale-support.html))。如果未指定区域设置，则默认为`“恩_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`*)`](string-functions.html#function_from-base64)

    [](<>)

    获取一个使用的base-64编码规则编码的字符串[`致_BASE64（）`](string-functions.html#function_to-base64)并将解码结果作为二进制字符串返回。结果是`无效的`如果论点是正确的`无效的`或者不是有效的base-64字符串。请参阅的描述[`致_BASE64（）`](string-functions.html#function_to-base64)有关编码和解码规则的详细信息。

    ```
    mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
            -> 'JWJj', 'abc'
    ```

    如果[`来自_BASE64（）`](string-functions.html#function_from-base64)从[**mysql**](mysql.html)客户端，二进制字符串使用十六进制表示法显示，具体取决于[`--二进制为十六进制`](mysql-command-options.html#option_mysql_binary-as-hex)。有关该选项的更多信息，请参阅[第4.5.1节，“mysql——mysql命令行客户端”](mysql.html).

-   [](<>)

    [`妖术(*`str`*)`](string-functions.html#function_hex), [`妖术(*`N`*)`](string-functions.html#function_hex)

    [](<>)

    对于字符串参数*`str`*, [`十六进制（）`](string-functions.html#function_hex)返回的十六进制字符串表示形式*`str`*其中每个字符的每个字节*`str`*转换为两个十六进制数字。（因此，多字节字符超过两位数。）此操作的逆操作由[`UNHEX（）`](string-functions.html#function_unhex)作用

    对于数字参数*`N`*, [`十六进制（）`](string-functions.html#function_hex)返回的值的十六进制字符串表示形式*`N`*被当作长龙对待([`比金`](integer-types.html))号码。这相当于[`康夫(*`N`*,10,16)`](mathematical-functions.html#function_conv).此操作的逆操作由[`CONV（十六进制）(*`N`*),16,10)`](mathematical-functions.html#function_conv).

    ```
    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`*`新闻记者`*)`](string-functions.html#function_insert)

    [](<>)

    返回字符串*`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`*)`](string-functions.html#function_instr)

    [](<>)

    返回子字符串第一次出现的位置*`substr`*串起*`str`*.这和[`定位（）`](string-functions.html#function_locate)，但参数的顺序是相反的。

    ```
    mysql> SELECT INSTR('foobarbar', 'bar');
            -> 4
    mysql> SELECT INSTR('xbar', 'foobar');
            -> 0
    ```

    此函数是多字节安全的，并且仅当至少一个参数是二进制字符串时才区分大小写。

-   [](<>)

    [`LCASE(*`str`*)`](string-functions.html#function_lcase)

    [](<>)

    [`LCASE（）`](string-functions.html#function_lcase)是的同义词[`下（）`](string-functions.html#function_lower).

    `LCASE（）`在视图中使用的被重写为`下（）`存储视图的定义时。（错误#12844279）

-   [](<>)

    [`左(*`str`*,*`伦恩`*)`](string-functions.html#function_left)

    [](<>)

    返回最左边的*`伦恩`*字符串中的字符*`str`*或`无效的`如果有任何论据`无效的`.

    ```
    mysql> SELECT LEFT('foobarbar', 5);
            -> 'fooba'
    ```

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

-   [](<>)

    [`长度(*`str`*)`](string-functions.html#function_length)

    [](<>)

    返回字符串的长度*`str`*，以字节为单位。多字节字符计为多个字节。这意味着对于包含五个2字节字符的字符串，[`长度（）`](string-functions.html#function_length)返回`10`鉴于[`字符长度（）`](string-functions.html#function_char-length)返回`5.`.

    ```
    mysql> SELECT LENGTH('text');
            -> 4
    ```

    笔记

    这个`长度（）`OpenGIS空间功能被命名为[`ST_Length（）`](gis-linestring-property-functions.html#function_st-length)在MySQL中。

-   [](<>)

    [`加载文件(*`文件名`*)`](string-functions.html#function_load-file)

    [](<>)[](<>)

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

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

    这个[`字符集文件系统`](server-system-variables.html#sysvar_character_set_filesystem)系统变量控制以文字字符串形式给出的文件名的解释。

    ```
    mysql> UPDATE t
                SET blob_col=LOAD_FILE('/tmp/picture')
                WHERE id=1;
    ```

-   [](<>)

    [`定位(*`substr`*,*`str`*)`](string-functions.html#function_locate), [`定位(*`substr`*,*`str`*,*`销售时点情报系统`*)`](string-functions.html#function_locate)

    [](<>)

    第一个语法返回子字符串第一次出现的位置*`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`*)`](string-functions.html#function_lower)

    [](<>)

    返回字符串*`str`*根据当前字符集映射将所有字符更改为小写。默认值是`utf8mb4`.

    ```
    mysql> SELECT LOWER('QUADRATICALLY');
            -> 'quadratically'
    ```

    [`下（）`](string-functions.html#function_lower)（及[`上（）`](string-functions.html#function_upper))应用于二进制字符串时无效([`二进制的`](binary-varbinary.html), [`VARBINARY`](binary-varbinary.html), [`斑点`](blob.html)).要执行二进制字符串的字母大小写转换，请首先使用适用于字符串中存储的数据的字符集将其转换为非二进制字符串：

    ```
    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字符集的排序，[`下（）`](string-functions.html#function_lower)和[`上（）`](string-functions.html#function_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工作。看见[第10.10.1节，“Unicode字符集”](charset-unicode-sets.html).

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

    `LCASE（）`在视图中使用的将重写为`下（）`.

-   [](<>)

    [`LPAD(*`str`*,*`伦恩`*,*`帕德斯特`*)`](string-functions.html#function_lpad)

    [](<>)

    返回字符串*`str`*，左边用绳子填充*`帕德斯特`*长达*`伦恩`*角色。如果*`str`*比*`伦恩`*，返回值缩短为*`伦恩`*角色。

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

-   [](<>)

    [`LTRIM(*`str`*)`](string-functions.html#function_ltrim)

    [](<>)

    返回字符串*`str`*删除前导空格字符。

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

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

-   [](<>)

    [`定做(*`位`*,*`str1`*,*`str2`*,...)`](string-functions.html#function_make-set)

    [](<>)

    返回一个集合值（一个包含由`,`字符）由字符串组成，字符串中有相应的位*`位`*设置*`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`*,*`销售时点情报系统`*,*`伦恩`*)`](string-functions.html#function_mid)

    [](<>)

    [`中段(*`str`*,*`销售时点情报系统`*,*`伦恩`*)`](string-functions.html#function_mid)是的同义词[`子串(*`str`*,*`销售时点情报系统`*,*`伦恩`*)`](string-functions.html#function_substring).

-   [](<>)

    [`十月(*`N`*)`](string-functions.html#function_oct)

    [](<>)

    返回的八进制值的字符串表示形式*`N`*哪里*`N`*这是一条很长的路([`比金`](integer-types.html))号码。这相当于[`康夫(*`N`*,10,8)`](mathematical-functions.html#function_conv).返回`无效的`如果*`N`*是`无效的`.

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

-   [](<>)

    [`八位组长度(*`str`*)`](string-functions.html#function_octet-length)

    [](<>)

    [`八位组长度（）`](string-functions.html#function_octet-length)是的同义词[`长度（）`](string-functions.html#function_length).

-   [](<>)

    [`奥德(*`str`*)`](string-functions.html#function_ord)

    [](<>)

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

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

    如果最左边的字符不是多字节字符，[`ORD（）`](string-functions.html#function_ord)返回与[`ASCII（）`](string-functions.html#function_ascii)作用

    ```
    mysql> SELECT ORD('2');
            -> 50
    ```

-   [](<>)

    [`位置(*`substr`*在*`str`*)`](string-functions.html#function_position)

    [](<>)

    [`位置(*`substr`*在*`str`*)`](string-functions.html#function_position)是的同义词[`定位(*`substr`*,*`str`*)`](string-functions.html#function_locate).

-   [](<>)

    [`引用(*`str`*)`](string-functions.html#function_quote)

    [](<>)

    引用字符串以生成一个结果，该结果可用作SQL语句中正确转义的数据值。返回的字符串用单引号括起来，并带有反斜杠的每个实例(`\`)，单引号(`'`)，ASCII码`努尔`，并在Control+Z前面加上反斜杠。如果论点是正确的`无效的`，返回值为单词“NULL”，不包含单引号。

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

    [](<>)

    要进行比较，请参阅中的C API中文字字符串和的引号规则[第9.1.1节“字符串文字”](string-literals.html)和[mysql\_真实的\_逃跑\_一串\_引用（）](https://dev.mysql.com/doc/c-api/8.0/en/mysql-real-escape-string-quote.html).

-   [](<>)

    [`重复(*`str`*,*`计数`*)`](string-functions.html#function_repeat)

    [](<>)

    返回由字符串组成的字符串*`str`*重复的*`计数`*时报。如果*`计数`*小于1，返回空字符串。退换商品`无效的`如果*`str`*或*`计数`*是`无效的`.

    ```
    mysql> SELECT REPEAT('MySQL', 3);
            -> 'MySQLMySQLMySQL'
    ```

-   [](<>)

    [`替换(*`str`*,*`来自\_街`*,*`到\_街`*)`](string-functions.html#function_replace)

    [](<>)

    返回字符串*`str`*所有出现的字符串*`来自_街`*替换为字符串*`到_街`*. [`替换（）`](string-functions.html#function_replace)搜索时执行区分大小写的匹配*`来自_街`*.

    ```
    mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
            -> 'WwWwWw.mysql.com'
    ```

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

-   [](<>)

    [`逆转(*`str`*)`](string-functions.html#function_reverse)

    [](<>)

    返回字符串*`str`*字符顺序颠倒。

    ```
    mysql> SELECT REVERSE('abc');
            -> 'cba'
    ```

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

-   [](<>)

    [`对(*`str`*,*`伦恩`*)`](string-functions.html#function_right)

    [](<>)

    返回最右边的*`伦恩`*字符串中的字符*`str`*或`无效的`如果有任何论据`无效的`.

    ```
    mysql> SELECT RIGHT('foobarbar', 4);
            -> 'rbar'
    ```

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

-   [](<>)

    [`RPAD(*`str`*,*`伦恩`*,*`帕德斯特`*)`](string-functions.html#function_rpad)

    [](<>)

    返回字符串*`str`*，右边用绳子填充*`帕德斯特`*长达*`伦恩`*角色。如果*`str`*比*`伦恩`*，返回值缩短为*`伦恩`*角色。

    ```
    mysql> SELECT RPAD('hi',5,'?');
            -> 'hi???'
    mysql> SELECT RPAD('hi',1,'?');
            -> 'h'
    ```

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

-   [](<>)

    [`RTRIM(*`str`*)`](string-functions.html#function_rtrim)

    [](<>)

    返回字符串*`str`*删除尾随空格字符。

    ```
    mysql> SELECT RTRIM('barbar   ');
            -> 'barbar'
    ```

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

-   [](<>)

    [`SOUNDEX(*`str`*)`](string-functions.html#function_soundex)

    [](<>)

    从中返回soundex字符串*`str`*.两个声音几乎相同的弦应该有相同的soundex弦。标准的soundex字符串有四个字符长，但[`SOUNDEX（）`](string-functions.html#function_soundex)函数返回任意长的字符串。你可以用[`子字符串（）`](string-functions.html#function_substring)根据结果获得标准soundex字符串。中的所有非阿尔卑斯字符*`str`*都被忽略了。A-Z范围之外的所有国际字母字符都被视为元音。

    重要的

    使用时[`SOUNDEX（）`](string-functions.html#function_soundex)，您应该注意以下限制：

    -   当前实现的此函数旨在处理仅使用英语的字符串。其他语言中的字符串可能无法产生可靠的结果。

    -   此函数不能保证为使用多字节字符集的字符串提供一致的结果，包括`utf-8`.有关更多信息，请参见Bug#22638。

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

    笔记

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

-   [](<>)

    [`*`expr1`*听起来像*`expr2`*`](string-functions.html#operator_sounds-like)

    [](<>)

    这和[`SOUNDEX(*`expr1`*)=SOUNDEX(*`expr2`*)`](string-functions.html#function_soundex).

-   [](<>)

    [`空间(*`N`*)`](string-functions.html#function_space)

    [](<>)

    返回由以下内容组成的字符串：*`N`*空格字符。

    ```
    mysql> SELECT SPACE(6);
            -> '      '
    ```

-   [](<>)

    [`SUBSTR(*`str`*,*`销售时点情报系统`*)`](string-functions.html#function_substr), [`SUBSTR(*`str`*来自*`销售时点情报系统`*)`](string-functions.html#function_substr), [`SUBSTR(*`str`*,*`销售时点情报系统`*,*`伦恩`*)`](string-functions.html#function_substr), [`SUBSTR(*`str`*来自*`销售时点情报系统`*因为*`伦恩`*)`](string-functions.html#function_substr)

    [](<>)

    [`SUBSTR（）`](string-functions.html#function_substr)是的同义词[`子字符串（）`](string-functions.html#function_substring).

-   [](<>)

    [`子串(*`str`*,*`销售时点情报系统`*)`](string-functions.html#function_substring), [`子串(*`str`*来自*`销售时点情报系统`*)`](string-functions.html#function_substring), [`子串(*`str`*,*`销售时点情报系统`*,*`伦恩`*)`](string-functions.html#function_substring), [`子串(*`str`*来自*`销售时点情报系统`*因为*`伦恩`*)`](string-functions.html#function_substring)

    [](<>)

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

    对于所有形式的[`子字符串（）`](string-functions.html#function_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'
    ```

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

    如果*`伦恩`*小于1，则结果为空字符串。

-   [](<>)

    [`子串索引(*`str`*,*`德利姆`*,*`计数`*)`](string-functions.html#function_substring-index)

    [](<>)

    从字符串返回子字符串*`str`*之前*`计数`*分隔符的出现*`德利姆`*如果*`计数`*如果为正，则返回最后定界符左侧的所有内容（从左侧开始计数）。如果*`计数`*如果为负数，则返回最后定界符右侧的所有内容（从右侧开始计数）。[`子字符串_索引（）`](string-functions.html#function_substring-index)搜索时执行区分大小写的匹配*`德利姆`*.

    ```
    mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
            -> 'www.mysql'
    mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
            -> 'mysql.com'
    ```

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

-   [](<>)

    [`去你的基地64(*`str`*)`](string-functions.html#function_to-base64)

    [](<>)

    将字符串参数转换为base-64编码形式，并将结果作为带有连接字符集和排序规则的字符串返回。如果参数不是字符串，则在转换之前将其转换为字符串。结果是`无效的`如果论点是正确的`无效的`.Base-64编码字符串可以使用[`来自_BASE64（）`](string-functions.html#function_from-base64)作用

    ```
    mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
            -> 'JWJj', 'abc'
    ```

    存在不同的base-64编码方案。这些是用户使用的编码和解码规则[`致_BASE64（）`](string-functions.html#function_to-base64)和[`来自_BASE64（）`](string-functions.html#function_from-base64):

    -   字母表值62的编码为`'+'`.

    -   字母表值63的编码为`'/'`.

    -   编码输出由4个可打印字符组成。输入数据的每3个字节使用4个字符进行编码。如果最后一组是不完整的，则用`'='`字符长度为4。

    -   在编码输出的每76个字符后添加一个换行符，将长输出分成多行。

    -   解码识别并忽略换行符、回车符、制表符和空格。

-   [](<>)

    [`修剪（[{两个|领先|落后}[*`雷姆斯特尔`*]来自]*`str`*)`](string-functions.html#function_trim), [`修剪([*`雷姆斯特尔`*来自]*`str`*)`](string-functions.html#function_trim)

    [](<>)

    返回字符串*`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`*)`](string-functions.html#function_ucase)

    [](<>)

    [`UCASE（）`](string-functions.html#function_ucase)是的同义词[`上（）`](string-functions.html#function_upper).

    `UCASE（）`在视图中使用的将重写为`上（）`.

-   [](<>)

    [`取消(*`str`*)`](string-functions.html#function_unhex)

    [](<>)

    对于字符串参数*`str`*, [`取消(*`str`*)`](string-functions.html#function_unhex)将参数中的每对字符解释为十六进制数，并将其转换为该数字表示的字节。返回值是一个二进制字符串。

    ```
    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（）`](string-functions.html#function_unhex)是一个[`二进制的`](binary-varbinary.html)列，因为值中填充了`0x00`存储时为字节，但检索时不剥离这些字节。例如`'41'`存储在`查尔（3）`列为`'41 '`并作为`'41'`（在去掉拖垫空间的情况下），所以[`UNHEX（）`](string-functions.html#function_unhex)对于返回的列值`X'41'`相比之下`'41'`存储在`二进制（3）`列为`'41\0'`并作为`'41\0'`（带拖垫）`0x00`字节（未剥离）。`'\0'`不是合法的十六进制数字，所以[`UNHEX（）`](string-functions.html#function_unhex)对于返回的列值`无效的`.

    对于数字参数*`N`*，与[`妖术(*`N`*)`](string-functions.html#function_hex)不是由[`UNHEX（）`](string-functions.html#function_unhex)使用[`CONV（十六进制）(*`N`*),16,10)`](mathematical-functions.html#function_conv)相反请参阅的描述[`十六进制（）`](string-functions.html#function_hex).

    如果[`UNHEX（）`](string-functions.html#function_unhex)从[**mysql**](mysql.html)客户端，二进制字符串使用十六进制表示法显示，具体取决于[`--二进制为十六进制`](mysql-command-options.html#option_mysql_binary-as-hex)。有关该选项的更多信息，请参阅[第4.5.1节，“mysql——mysql命令行客户端”](mysql.html).

-   [](<>)

    [`上层(*`str`*)`](string-functions.html#function_upper)

    [](<>)

    返回字符串*`str`*根据当前字符集映射将所有字符更改为大写。默认值是`utf8mb4`.

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

    请参阅的描述[`下（）`](string-functions.html#function_lower)获取同样适用于[`上（）`](string-functions.html#function_upper)。这包括有关如何执行二进制字符串的字母大小写转换的信息([`二进制的`](binary-varbinary.html), [`VARBINARY`](binary-varbinary.html), [`斑点`](blob.html))以及有关Unicode字符集大小写折叠的信息。

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

    `UCASE（）`在视图中使用的将重写为`上（）`.

-   [](<>)

    [`重量线(*`str`*[作为{CHAR | BINARY}(*`N`*)] [*`旗帜`*])`](string-functions.html#function_weight-string)

    [](<>)

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

    -   如果[`重量线(*`str1`*)`](string-functions.html#function_weight-string) = [`重量线(*`str2`*)`](string-functions.html#function_weight-string)然后`*`str1`* = *`str2`*` (*`str1`*和*`str2`*（被认为是平等的）

    -   如果[`重量线(*`str1`*)`](string-functions.html#function_weight-string) \\\< [`重量线(*`str2`*)`](string-functions.html#function_weight-string)然后`*`str1`* < *`str2`*` (*`str1`*排序之前*`str2`*)

    [`重量_字符串（）`](string-functions.html#function_weight-string)是一种供内部使用的调试功能。在不同的MySQL版本之间，它的行为可能会发生变化，恕不另行通知。它可以用于测试和调试排序规则，尤其是在添加新排序规则时。看见[第10.14节，“向字符集添加排序规则”](adding-collation.html).

    这个列表简要总结了这些论点。下面的讨论给出了更多细节。

    -   *`str`*：输入字符串表达式。

    -   `像`条款：可选；将输入字符串强制转换为给定的类型和长度。

    -   *`旗帜`*：可选；没用过。

        输入字符串，*`str`*，是一个字符串表达式。如果输入是非二进制（字符）字符串，例如[`烧焦`](char.html), [`瓦尔查尔`](char.html)或[`文本`](blob.html)值，返回值包含字符串的排序规则权重。如果输入是二进制（字节）字符串，例如[`二进制的`](binary-varbinary.html), [`VARBINARY`](binary-varbinary.html)或[`斑点`](blob.html)值，返回值与输入值相同（二进制字符串中每个字节的权重为字节值）。如果输入是`无效的`, [`重量_字符串（）`](string-functions.html#function_weight-string)返回`无效的`.

        例如：

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

    前面的例子使用[`十六进制（）`](string-functions.html#function_hex)显示[`重量_字符串（）`](string-functions.html#function_weight-string)后果因为结果是一个二进制值，[`十六进制（）`](string-functions.html#function_hex)当结果包含非打印值时，以可打印形式显示它尤其有用：

    ```
    mysql> SET @s = CONVERT(X'C39F' USING utf8) COLLATE utf8_czech_ci;
    mysql> SELECT HEX(WEIGHT_STRING(@s));
    +------------------------+
    | HEX(WEIGHT_STRING(@s)) |
    +------------------------+
    | 0FEA0FEA               |
    +------------------------+
    ```

    非-`无效的`返回值，该值的数据类型为[`VARBINARY`](binary-varbinary.html)如果其长度在[`VARBINARY`](binary-varbinary.html)，否则数据类型为[`斑点`](blob.html).

    这个`像`子句可以将输入字符串强制转换为非二进制或二进制字符串，并将其强制转换为给定长度：

    -   `作为字符(*`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                              |
    +---------------------------------------+
    ```

    这个*`旗帜`*子句当前未使用。

    如果[`重量_字符串（）`](string-functions.html#function_weight-string)从[**mysql**](mysql.html)客户端，二进制字符串使用十六进制表示法显示，具体取决于[`--二进制为十六进制`](mysql-command-options.html#option_mysql_binary-as-hex)。有关该选项的更多信息，请参阅[第4.5.1节，“mysql——mysql命令行客户端”](mysql.html).
