## 12.24 杂项功能

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

[](<>)

**表 12.29 其他功能**

| 姓名 | 描述 | 介绍 | 已弃用 |
| --- | --- | --- | --- |
| [`ANY_VALUE()`](miscellaneous-functions.html#function_any-value) | 仅抑制\_满的\_团体\_按值拒绝 |  |  |
| [`BIN_TO_UUID()`](miscellaneous-functions.html#function_bin-to-uuid) | 将二进制 UUID 转换为字符串 |  |  |
| [`默认（）`](miscellaneous-functions.html#function_default) | 返回表列的默认值 |  |  |
| [`分组（）`](miscellaneous-functions.html#function_grouping) | 将超级聚合 ROLLUP 行与常规行区分开来 |  |  |
| [`INET_ATON()`](miscellaneous-functions.html#function_inet-aton) | 返回 IP 地址的数值 |  |  |
| [`INET_NTOA()`](miscellaneous-functions.html#function_inet-ntoa) | 从数值返回 IP 地址 |  |  |
| [`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton) | 返回 IPv6 地址的数值 |  |  |
| [`INET6_NTOA()`](miscellaneous-functions.html#function_inet6-ntoa) | 从数值返回 IPv6 地址 |  |  |
| [`IS_IPV4()`](miscellaneous-functions.html#function_is-ipv4) | 参数是否为 IPv4 地址 |  |  |
| [`IS_IPV4_COMPAT()`](miscellaneous-functions.html#function_is-ipv4-compat) | 参数是否为 IPv4 兼容地址 |  |  |
| [`IS_IPV4_MAPPED()`](miscellaneous-functions.html#function_is-ipv4-mapped) | 参数是否为 IPv4 映射地址 |  |  |
| [`IS_IPV6()`](miscellaneous-functions.html#function_is-ipv6) | 参数是否为 IPv6 地址 |  |  |
| [`IS_UUID()`](miscellaneous-functions.html#function_is-uuid) | 参数是否是有效的 UUID |  |  |
| [`MASTER_POS_WAIT()`](miscellaneous-functions.html#function_master-pos-wait) | 阻塞直到副本读取并应用所有更新到指定位置 |  | 8.0.26 |
| [`NAME_CONST()`](miscellaneous-functions.html#function_name-const) | 使列具有给定名称 |  |  |
| [`睡觉（）`](miscellaneous-functions.html#function_sleep) | 睡几秒钟 |  |  |
| [`SOURCE_POS_WAIT()`](miscellaneous-functions.html#function_source-pos-wait) | 阻塞直到副本读取并应用所有更新到指定位置 | 8.0.26 |  |
| [`UUID()`](miscellaneous-functions.html#function_uuid) | 返回通用唯一标识符 (UUID) |  |  |
| [`UUID_SHORT()`](miscellaneous-functions.html#function_uuid-short) | 返回一个整数值的通用标识符 |  |  |
| [`UUID_TO_BIN()`](miscellaneous-functions.html#function_uuid-to-bin) | 将字符串 UUID 转换为二进制 |  |  |
| [`值（）`](miscellaneous-functions.html#function_values) | 定义在 INSERT 期间要使用的值 |  |  |

-   [](<>)

    [`ANY_VALUE(*`参数`*)`](miscellaneous-functions.html#function_any-value)

    [](<>)

    该功能适用​​于`通过...分组`查询时[`ONLY_FULL_GROUP_BY`](sql-mode.html#sqlmode_only_full_group_by)启用 SQL 模式，用于 MySQL 拒绝您知道有效的查询的情况，原因是 MySQL 无法确定。函数返回值和类型与其参数的返回值和类型相同，但不检查函数结果[`ONLY_FULL_GROUP_BY`](sql-mode.html#sqlmode_only_full_group_by)SQL 模式。

    例如，如果`姓名`是非索引列，以下查询失败[`ONLY_FULL_GROUP_BY`](sql-mode.html#sqlmode_only_full_group_by)启用：

    ```
    mysql> SELECT name, address, MAX(age) FROM t GROUP BY name;
    ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP
    BY clause and contains nonaggregated column 'mydb.t.address' which
    is not functionally dependent on columns in GROUP BY clause; this
    is incompatible with sql_mode=only_full_group_by
    ```

    发生故障是因为`地址`是一个未在其中命名的非聚合列`通过...分组`列在功能上也不依赖于它们。结果，`地址`每个内的行的值`姓名`组是不确定的。有多种方法可以使 MySQL 接受查询：

    -   更改表格以制作`姓名`主键或唯一`非空`柱子。这使 MySQL 能够确定`地址`在功能上取决于`姓名`;那是，`地址`唯一地由`姓名`.（此技术不适用，如果`空值`必须被允许作为有效的`姓名`价值。）

    -   采用[`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)参考`地址`：

        ```
        SELECT name, ANY_VALUE(address), MAX(age) FROM t GROUP BY name;
        ```

        在这种情况下，MySQL 忽略了`地址`每个内的值`姓名`组并接受查询。如果您根本不关心为每个组选择了非聚合列的哪个值，这可能很有用。[`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)不是聚合函数，不像函数，例如[`和（）`](aggregate-functions.html#function_sum)要么[`数数（）`](aggregate-functions.html#function_count).它只是用来抑制对非确定性的测试。

    -   禁用[`ONLY_FULL_GROUP_BY`](sql-mode.html#sqlmode_only_full_group_by).这相当于使用[`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)和[`ONLY_FULL_GROUP_BY`](sql-mode.html#sqlmode_only_full_group_by)启用，如上一项所述。

    [`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)如果列之间存在功能依赖但 MySQL 无法确定它，这也很有用。以下查询是有效的，因为`年龄`在功能上取决于分组列`1 岁`，但 MySQL 无法判断并拒绝查询[`ONLY_FULL_GROUP_BY`](sql-mode.html#sqlmode_only_full_group_by)启用：

    ```
    SELECT age FROM t GROUP BY age-1;
    ```

    要使 MySQL 接受查询，请使用[`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)：

    ```
    SELECT ANY_VALUE(age) FROM t GROUP BY age-1;
    ```

    [`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)可用于在没有 a 的情况下引用聚合函数的查询`通过...分组`条款：

    ```
    mysql> SELECT name, MAX(age) FROM t;
    ERROR 1140 (42000): In aggregated query without GROUP BY, expression
    #1 of SELECT list contains nonaggregated column 'mydb.t.name'; this
    is incompatible with sql_mode=only_full_group_by
    ```

    没有`通过...分组`，有一个组，它是不确定的`姓名`为组选择的值。[`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)告诉 MySQL 接受查询：

    ```
    SELECT ANY_VALUE(name), MAX(age) FROM t;
    ```

    可能是由于给定数据集的某些属性，您知道选定的非聚合列在功能上实际上依赖于`通过...分组`柱子。例如，应用程序可以强制一列相对于另一列的唯一性。在这种情况下，使用[`ANY_VALUE()`](miscellaneous-functions.html#function_any-value)对于有效的功能依赖列可能是有意义的。

    有关其他讨论，请参阅[第 12.20.3 节，“MySQL 对 GROUP BY 的处理”](group-by-handling.html).

-   [](<>)

    [`BIN_TO_UUID(*`binary_uuid`*)`](miscellaneous-functions.html#function_bin-to-uuid),[`BIN_TO_UUID(*`binary_uuid`*, *`交换标志`*)`](miscellaneous-functions.html#function_bin-to-uuid)

    [](<>)

    [`BIN_TO_UUID()`](miscellaneous-functions.html#function_bin-to-uuid)是的倒数[`UUID_TO_BIN()`](miscellaneous-functions.html#function_uuid-to-bin).它将二进制 UUID 转换为字符串 UUID 并返回结果。二进制值应该是一个 UUID 作为[`VARBINARY(16)`](binary-varbinary.html)价值。返回值为一个`utf8`由短划线分隔的五个十六进制数字组成的字符串。（有关此格式的详细信息，请参阅[`UUID()`](miscellaneous-functions.html#function_uuid)函数描述。）如果 UUID 参数是`空值`，返回值为`空值`.如果任何参数无效，则会发生错误。

    [`BIN_TO_UUID()`](miscellaneous-functions.html#function_bin-to-uuid)接受一两个参数：

    -   单参数形式采用二进制 UUID 值。假设 UUID 值没有交换其时间低和时间高的部分。字符串结果与二进制参数的顺序相同。

    -   两个参数形式采用二进制 UUID 值和交换标志值：

        -   如果*`交换标志`*为 0，二元形式等价于一元形式。字符串结果与二进制参数的顺序相同。

        -   如果*`交换标志`*为 1，假设 UUID 值的时间低和时间高部分交换。这些部分被交换回它们在结果值中的原始位置。

        有关时间部分交换的使用示例和信息，请参阅[`UUID_TO_BIN()`](miscellaneous-functions.html#function_uuid-to-bin)功能说明。

-   [](<>)

    [`默认（*`col_name`*)`](miscellaneous-functions.html#function_default)

    [](<>)

    返回表列的默认值。如果该列没有默认值，则会导致错误。

    指某东西的用途[`默认（*`col_name`*)`](miscellaneous-functions.html#function_default)为命名列指定默认值仅允许用于具有文字默认值的列，而不是用于具有表达式默认值的列。

    ```
    mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
    ```

-   [`格式（*`X`*,*`D`*)`](string-functions.html#function_format)

    格式化数字*`X`*像这样的格式`'#,###,###.##'`，四舍五入为*`D`*小数位，并将结果作为字符串返回。有关详细信息，请参阅[第 12.8 节，“字符串函数和运算符”](string-functions.html).

-   [](<>)

    [`分组（*`表达式`* [, *`表达式`*] ...)`](miscellaneous-functions.html#function_grouping)

    [](<>)

    为了`通过...分组`包含 a 的查询`带汇总`修饰符`卷起`操作产生超聚合输出行，其中`空值`表示所有值的集合。这[`分组（）`](miscellaneous-functions.html#function_grouping)功能使您能够区分`空值`超聚合行​​的值来自`空值`常规分组行中的值。

    [`分组（）`](miscellaneous-functions.html#function_grouping)允许在选择列表中，`拥有`子句和（从 MySQL 8.0.12 开始）`订购方式`条款。

    每个论点[`分组（）`](miscellaneous-functions.html#function_grouping)必须是与`通过...分组`条款。表达式不能是位置说明符。对于每个表达式，[`分组（）`](miscellaneous-functions.html#function_grouping)如果当前行中的表达式值为 a`空值`表示超聚合值。否则，[`分组（）`](miscellaneous-functions.html#function_grouping)产生 0，表示表达式值为 a`空值`对于常规结果行或不是`空值`.

    假设那张桌子`t1`包含这些行，其中`空值`表示“其他”或“未知”之类的东西：

    ```
    mysql> SELECT * FROM t1;
    +------+-------+----------+
    | name | size  | quantity |
    +------+-------+----------+
    | ball | small |       10 |
    | ball | large |       20 |
    | ball | NULL  |        5 |
    | hoop | small |       15 |
    | hoop | large |        5 |
    | hoop | NULL  |        3 |
    +------+-------+----------+
    ```

    无表汇总`带汇总`看起来像这样：

    ```
    mysql> SELECT name, size, SUM(quantity) AS quantity
           FROM t1
           GROUP BY name, size;
    +------+-------+----------+
    | name | size  | quantity |
    +------+-------+----------+
    | ball | small |       10 |
    | ball | large |       20 |
    | ball | NULL  |        5 |
    | hoop | small |       15 |
    | hoop | large |        5 |
    | hoop | NULL  |        3 |
    +------+-------+----------+
    ```

    结果包含`空值`值，但那些不代表超聚合行，因为查询不包括`带汇总`.

    添加`带汇总`生成包含附加的超聚合摘要行`空值`价值观。但是，如果不将此结果与上一个结果进行比较，则不容易看出哪个`空值`值出现在超聚合行中，并且出现在常规分组行中：

    ```
    mysql> SELECT name, size, SUM(quantity) AS quantity
           FROM t1
           GROUP BY name, size WITH ROLLUP;
    +------+-------+----------+
    | name | size  | quantity |
    +------+-------+----------+
    | ball | NULL  |        5 |
    | ball | large |       20 |
    | ball | small |       10 |
    | ball | NULL  |       35 |
    | hoop | NULL  |        3 |
    | hoop | large |        5 |
    | hoop | small |       15 |
    | hoop | NULL  |       23 |
    | NULL | NULL  |       58 |
    +------+-------+----------+
    ```

    区分`空值`超级聚合行中的值来自常规分组行中的值，使用[`分组（）`](miscellaneous-functions.html#function_grouping)，仅对超聚合返回 1`空值`价值观：

    ```
    mysql> SELECT
             name, size, SUM(quantity) AS quantity,
             GROUPING(name) AS grp_name,
             GROUPING(size) AS grp_size
           FROM t1
           GROUP BY name, size WITH ROLLUP;
    +------+-------+----------+----------+----------+
    | name | size  | quantity | grp_name | grp_size |
    +------+-------+----------+----------+----------+
    | ball | NULL  |        5 |        0 |        0 |
    | ball | large |       20 |        0 |        0 |
    | ball | small |       10 |        0 |        0 |
    | ball | NULL  |       35 |        0 |        1 |
    | hoop | NULL  |        3 |        0 |        0 |
    | hoop | large |        5 |        0 |        0 |
    | hoop | small |       15 |        0 |        0 |
    | hoop | NULL  |       23 |        0 |        1 |
    | NULL | NULL  |       58 |        1 |        1 |
    +------+-------+----------+----------+----------+
    ```

    常见用途[`分组（）`](miscellaneous-functions.html#function_grouping)：

    -   用标签替换超聚合`空值`价值观：

        ```
        mysql> SELECT
                 IF(GROUPING(name) = 1, 'All items', name) AS name,
                 IF(GROUPING(size) = 1, 'All sizes', size) AS size,
                 SUM(quantity) AS quantity
               FROM t1
               GROUP BY name, size WITH ROLLUP;
        +-----------+-----------+----------+
        | name      | size      | quantity |
        +-----------+-----------+----------+
        | ball      | NULL      |        5 |
        | ball      | large     |       20 |
        | ball      | small     |       10 |
        | ball      | All sizes |       35 |
        | hoop      | NULL      |        3 |
        | hoop      | large     |        5 |
        | hoop      | small     |       15 |
        | hoop      | All sizes |       23 |
        | All items | All sizes |       58 |
        +-----------+-----------+----------+
        ```

    -   通过过滤掉常规分组行仅返回超聚合行：

        ```
        mysql> SELECT name, size, SUM(quantity) AS quantity
               FROM t1
               GROUP BY name, size WITH ROLLUP
               HAVING GROUPING(name) = 1 OR GROUPING(size) = 1;
        +------+------+----------+
        | name | size | quantity |
        +------+------+----------+
        | ball | NULL |       35 |
        | hoop | NULL |       23 |
        | NULL | NULL |       58 |
        +------+------+----------+
        ```

    [`分组（）`](miscellaneous-functions.html#function_grouping)允许多个表达式参数。在这种情况下，[`分组（）`](miscellaneous-functions.html#function_grouping)返回值表示从每个表达式的结果组合的位掩码，其中最低位对应于最右边表达式的结果。例如，对于三个表达式参数，[`分组（*`expr1`*, *`expr2`*, *`expr3`*)`](miscellaneous-functions.html#function_grouping)评估如下：

    ```
      result for GROUPING(expr3)
    + result for GROUPING(expr2) << 1
    + result for GROUPING(expr1) << 2
    ```

    以下查询显示了如何[`分组（）`](miscellaneous-functions.html#function_grouping)单个参数的结果组合用于多参数调用以生成位掩码值：

    ```
    mysql> SELECT
             name, size, SUM(quantity) AS quantity,
             GROUPING(name) AS grp_name,
             GROUPING(size) AS grp_size,
           GROUPING(name, size) AS grp_all
           FROM t1
           GROUP BY name, size WITH ROLLUP;
    +------+-------+----------+----------+----------+---------+
    | name | size  | quantity | grp_name | grp_size | grp_all |
    +------+-------+----------+----------+----------+---------+
    | ball | NULL  |        5 |        0 |        0 |       0 |
    | ball | large |       20 |        0 |        0 |       0 |
    | ball | small |       10 |        0 |        0 |       0 |
    | ball | NULL  |       35 |        0 |        1 |       1 |
    | hoop | NULL  |        3 |        0 |        0 |       0 |
    | hoop | large |        5 |        0 |        0 |       0 |
    | hoop | small |       15 |        0 |        0 |       0 |
    | hoop | NULL  |       23 |        0 |        1 |       1 |
    | NULL | NULL  |       58 |        1 |        1 |       3 |
    +------+-------+----------+----------+----------+---------+
    ```

    使用多个表达式参数时，[`分组（）`](miscellaneous-functions.html#function_grouping)如果任何表达式表示超聚合值，则返回值非零。多参数[`分组（）`](miscellaneous-functions.html#function_grouping)因此，语法提供了一种更简单的方法来编写仅返回超聚合行的早期查询，方法是使用单个多参数[`分组（）`](miscellaneous-functions.html#function_grouping)调用而不是多个单参数调用：

    ```
    mysql> SELECT name, size, SUM(quantity) AS quantity
           FROM t1
           GROUP BY name, size WITH ROLLUP
           HAVING GROUPING(name, size) <> 0;
    +------+------+----------+
    | name | size | quantity |
    +------+------+----------+
    | ball | NULL |       35 |
    | hoop | NULL |       23 |
    | NULL | NULL |       58 |
    +------+------+----------+
    ```

    用于[`分组（）`](miscellaneous-functions.html#function_grouping)受以下限制：

    -   不要使用子查询`通过...分组`表达式为[`分组（）`](miscellaneous-functions.html#function_grouping)参数，因为匹配可能会失败。例如，此查询的匹配失败：

        ```
        mysql> SELECT GROUPING((SELECT MAX(name) FROM t1))
               FROM t1
               GROUP BY (SELECT MAX(name) FROM t1) WITH ROLLUP;
        ERROR 3580 (HY000): Argument #1 of GROUPING function is not in GROUP BY
        ```

    -   `通过...分组`文字表达式不应在 a 中使用`拥有`子句作为[`分组（）`](miscellaneous-functions.html#function_grouping)论据。由于优化器评估时间之间的差异`通过...分组`和`拥有`, 匹配可能成功但是[`分组（）`](miscellaneous-functions.html#function_grouping)评估不会产生预期的结果。考虑这个查询：

        ```
        SELECT a AS f1, 'w' AS f2
        FROM t
        GROUP BY f1, f2 WITH ROLLUP
        HAVING GROUPING(f2) = 1;
        ```

         [`分组（）`](miscellaneous-functions.html#function_grouping)对文字常量表达式的求值比对`拥有`子句作为一个整体并返回 0。要检查这样的查询是否受到影响，请使用[`解释`](explain.html)并寻找`不可能拥有`在里面`额外的`柱子。

        有关更多信息`带汇总`和[`分组（）`](miscellaneous-functions.html#function_grouping)， 看[第 12.20.2 节，“GROUP BY 修饰符”](group-by-modifiers.html).

-   [](<>)

    [`INET_ATON(*`表达式`*)`](miscellaneous-functions.html#function_inet-aton)

    [](<>)

    给定 IPv4 网络地址作为字符串的点分四元组表示，返回一个整数，该整数表示网络字节顺序（大端）地址的数值。[`INET_ATON()`](miscellaneous-functions.html#function_inet-aton)返回`空值`如果它不理解它的论点。

    ```
    mysql> SELECT INET_ATON('10.0.5.9');
            -> 167773449
    ```

    对于本例，返回值计算为 10×256<sup>3</sup> + 0×256<sup>2</sup>+ 5×256 + 9。

    [`INET_ATON()`](miscellaneous-functions.html#function_inet-aton)可能会或可能不会返回非`空值`短格式 IP 地址的结果（例如`'127.1'`作为代表`'127.0.0.1'`）。因为这，[`INET_ATON()`](miscellaneous-functions.html#function_inet-aton)a 不应用于此类地址。

    笔记

    存储由[`INET_ATON()`](miscellaneous-functions.html#function_inet-aton), 使用`INT 无符号`列而不是[`INT`](integer-types.html), 已签名。如果使用有符号列，则无法正确存储与第一个八位字节大于 127 的 IP 地址对应的值。看[第 11.1.7 节，“超出范围和溢出处理”](out-of-range-and-overflow.html).

-   [](<>)

    [`INET_NTOA(*`表达式`*)`](miscellaneous-functions.html#function_inet-ntoa)

    [](<>)

    给定一个按网络字节顺序排列的数字 IPv4 网络地址，以连接字符集中的字符串形式返回地址的点分四组字符串表示形式。[`INET_NTOA()`](miscellaneous-functions.html#function_inet-ntoa)返回`空值`如果它不理解它的论点。

    ```
    mysql> SELECT INET_NTOA(167773449);
            -> '10.0.5.9'
    ```

-   [](<>)

    [`INET6_ATON(*`表达式`*)`](miscellaneous-functions.html#function_inet6-aton)

    [](<>)

    给定 IPv6 或 IPv4 网络地址作为字符串，返回一个二进制字符串，该字符串表示网络字节顺序（大端）地址的数值。由于数字格式 IPv6 地址需要的字节数比最大整数类型多，因此此函数返回的表示形式为[`变量`](binary-varbinary.html)数据类型：[`VARBINARY(16)`](binary-varbinary.html)对于 IPv6 地址和[`VARBINARY(4)`](binary-varbinary.html)对于 IPv4 地址。如果参数不是有效地址，[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton)返回`空值`.

    以下示例使用[`十六进制（）`](string-functions.html#function_hex)显示[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton)产生可打印的形式：

    ```
    mysql> SELECT HEX(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
            -> 'FDFE0000000000005A55CAFFFEFA9089'
    mysql> SELECT HEX(INET6_ATON('10.0.5.9'));
            -> '0A000509'
    ```

    `INET6_ATON()`观察对有效参数的几个约束。以下列表中给出了这些内容以及示例。

    -   不允许使用尾随区域 ID，如`fe80::3%1`要么`fe80::3%eth0`.

    -   不允许使用尾随网络掩码，如`2001:45f:3:ba::/64`要么`198.51.100.0/24`.

    -   对于表示 IPv4 地址的值，仅支持无类别地址。有类地址，例如`198.51.1`被拒绝。不允许使用尾随端口号，如`198.51.100.2:8080`.地址组件中的十六进制数字是不允许的，如`198.0xa0.1.2`.不支持八进制数：`198.51.010.1`被视为`198.51.10.1`， 不是`198.51.8.1`.这些 IPv4 约束也适用于具有 IPv4 地址部分的 IPv6 地址，例如 IPv4 兼容地址或 IPv4 映射地址。

        转换 IPv4 地址*`表达式`*以数字形式表示为[`INT`](integer-types.html)以数字形式表示的 IPv6 地址的值[`变量`](binary-varbinary.html)值，使用这个表达式：

    ```
    INET6_ATON(INET_NTOA(expr))
    ```

    例如：

    ```
    mysql> SELECT HEX(INET6_ATON(INET_NTOA(167773449)));
            -> '0A000509'
    ```

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

-   [](<>)

    [`INET6_NTOA(*`表达式`*)`](miscellaneous-functions.html#function_inet6-ntoa)

    [](<>)

    给定以数字形式表示为二进制字符串的 IPv6 或 IPv4 网络地址，将地址的字符串表示形式作为连接字符集中的字符串返回。如果参数不是有效地址，[`INET6_NTOA()`](miscellaneous-functions.html#function_inet6-ntoa)返回`空值`.

    [`INET6_NTOA()`](miscellaneous-functions.html#function_inet6-ntoa)具有以下属性：

    -   它不使用操作系统函数来执行转换，因此输出字符串与平台无关。

    -   返回字符串的最大长度为 39 (4 x 8 + 7)。鉴于此声明：

        ```
        CREATE TABLE t AS SELECT INET6_NTOA(expr) AS c1;
        ```

        结果表将具有以下定义：

        ```
        CREATE TABLE t (c1 VARCHAR(39) CHARACTER SET utf8 DEFAULT NULL);
        ```

    -   返回字符串使用小写字母表示 IPv6 地址。

    ```
    mysql> SELECT INET6_NTOA(INET6_ATON('fdfe::5a55:caff:fefa:9089'));
            -> 'fdfe::5a55:caff:fefa:9089'
    mysql> SELECT INET6_NTOA(INET6_ATON('10.0.5.9'));
            -> '10.0.5.9'

    mysql> SELECT INET6_NTOA(UNHEX('FDFE0000000000005A55CAFFFEFA9089'));
            -> 'fdfe::5a55:caff:fefa:9089'
    mysql> SELECT INET6_NTOA(UNHEX('0A000509'));
            -> '10.0.5.9'
    ```

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

-   [](<>)

    [`IS_IPV4(*`表达式`*)`](miscellaneous-functions.html#function_is-ipv4)

    [](<>)

    如果参数是指定为字符串的有效 IPv4 地址，则返回 1，否则返回 0。

    ```
    mysql> SELECT IS_IPV4('10.0.5.9'), IS_IPV4('10.0.5.256');
            -> 1, 0
    ```

    对于给定的参数，如果[`IS_IPV4()`](miscellaneous-functions.html#function_is-ipv4)返回 1，[`INET_ATON()`](miscellaneous-functions.html#function_inet-aton)（和[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton)) 返回非`空值`.相反的说法是不正确的：在某些情况下，[`INET_ATON()`](miscellaneous-functions.html#function_inet-aton)返回非`空值`什么时候[`IS_IPV4()`](miscellaneous-functions.html#function_is-ipv4)返回 0。

    正如前面的评论所暗示的，[`IS_IPV4()`](miscellaneous-functions.html#function_is-ipv4)比更严格[`INET_ATON()`](miscellaneous-functions.html#function_inet-aton)关于什么构成有效的 IPv4 地址，因此它对于需要对无效值执行强检查的应用程序可能很有用。或者，使用[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton)将 IPv4 地址转换为内部形式并检查`空值`结果（表示地址无效）。[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton)同样强大[`IS_IPV4()`](miscellaneous-functions.html#function_is-ipv4)关于检查 IPv4 地址。

-   [](<>)

    [`IS_IPV4_COMPAT(*`表达式`*)`](miscellaneous-functions.html#function_is-ipv4-compat)

    [](<>)

    此函数将以数字形式表示的 IPv6 地址作为二进制字符串，由[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton).如果参数是有效的与 IPv4 兼容的 IPv6 地址，则返回 1，否则返回 0。IPv4 兼容地址具有以下形式`::*`ipv4_address`*`.

    ```
    mysql> SELECT IS_IPV4_COMPAT(INET6_ATON('::10.0.5.9'));
            -> 1
    mysql> SELECT IS_IPV4_COMPAT(INET6_ATON('::ffff:10.0.5.9'));
            -> 0
    ```

    IPv4 兼容地址的 IPv4 部分也可以使用十六进制表示法表示。例如，`198.51.100.1`有这个原始的十六进制值：

    ```
    mysql> SELECT HEX(INET6_ATON('198.51.100.1'));
            -> 'C6336401'
    ```

    以兼容 IPv4 的形式表示，`::198.51.100.1`相当于`::c0a8:0001`或（不带前导零）`::c0a8:1`

    ```
    mysql> SELECT
        ->   IS_IPV4_COMPAT(INET6_ATON('::198.51.100.1')),
        ->   IS_IPV4_COMPAT(INET6_ATON('::c0a8:0001')),
        ->   IS_IPV4_COMPAT(INET6_ATON('::c0a8:1'));
            -> 1, 1, 1
    ```

-   [](<>)

    [`IS_IPV4_MAPPED(*`表达式`*)`](miscellaneous-functions.html#function_is-ipv4-mapped)

    [](<>)

    此函数将以数字形式表示的 IPv6 地址作为二进制字符串，由[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton).如果参数是有效的 IPv4 映射的 IPv6 地址，则返回 1，否则返回 0。IPv4 映射地址具有以下形式`::ffff:*`ipv4_address`*`.

    ```
    mysql> SELECT IS_IPV4_MAPPED(INET6_ATON('::10.0.5.9'));
            -> 0
    mysql> SELECT IS_IPV4_MAPPED(INET6_ATON('::ffff:10.0.5.9'));
            -> 1
    ```

    与`IS_IPV4_COMPAT()`IPv4 映射地址的 IPv4 部分也可以使用十六进制表示法表示：

    ```
    mysql> SELECT
        ->   IS_IPV4_MAPPED(INET6_ATON('::ffff:198.51.100.1')),
        ->   IS_IPV4_MAPPED(INET6_ATON('::ffff:c0a8:0001')),
        ->   IS_IPV4_MAPPED(INET6_ATON('::ffff:c0a8:1'));
            -> 1, 1, 1
    ```

-   [](<>)

    [`IS_IPV6(*`表达式`*)`](miscellaneous-functions.html#function_is-ipv6)

    [](<>)

    如果参数是指定为字符串的有效 IPv6 地址，则返回 1，否则返回 0。此函数不认为 IPv4 地址是有效的 IPv6 地址。

    ```
    mysql> SELECT IS_IPV6('10.0.5.9'), IS_IPV6('::1');
            -> 0, 1
    ```

    对于给定的参数，如果[`IS_IPV6()`](miscellaneous-functions.html#function_is-ipv6)返回 1，[`INET6_ATON()`](miscellaneous-functions.html#function_inet6-aton)返回非`空值`.

-   [](<>)

    [`IS_UUID(*`string_uuid`*)`](miscellaneous-functions.html#function_is-uuid)

    [](<>)

    如果参数是有效的字符串格式 UUID，则返回 1，如果参数不是有效的 UUID，则返回 0，并且`空值`如果参数是`空值`.

    “有效”表示该值采用可解析的格式。也就是说，它具有正确的长度并且仅包含允许的字符（任何字母大小写的十六进制数字，以及可选的破折号和花括号）。这种格式最常见：

    ```
    aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
    ```

    这些其他格式也是允许的：

    ```
    aaaaaaaabbbbccccddddeeeeeeeeeeee
    {aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee}
    ```

    值中字段的含义，请参见[`UUID()`](miscellaneous-functions.html#function_uuid)功能说明。

    ```
    mysql> SELECT IS_UUID('6ccd780c-baba-1026-9564-5b8c656024db');
    +-------------------------------------------------+
    | IS_UUID('6ccd780c-baba-1026-9564-5b8c656024db') |
    +-------------------------------------------------+
    |                                               1 |
    +-------------------------------------------------+
    mysql> SELECT IS_UUID('6CCD780C-BABA-1026-9564-5B8C656024DB');
    +-------------------------------------------------+
    | IS_UUID('6CCD780C-BABA-1026-9564-5B8C656024DB') |
    +-------------------------------------------------+
    |                                               1 |
    +-------------------------------------------------+
    mysql> SELECT IS_UUID('6ccd780cbaba102695645b8c656024db');
    +---------------------------------------------+
    | IS_UUID('6ccd780cbaba102695645b8c656024db') |
    +---------------------------------------------+
    |                                           1 |
    +---------------------------------------------+
    mysql> SELECT IS_UUID('{6ccd780c-baba-1026-9564-5b8c656024db}');
    +---------------------------------------------------+
    | IS_UUID('{6ccd780c-baba-1026-9564-5b8c656024db}') |
    +---------------------------------------------------+
    |                                                 1 |
    +---------------------------------------------------+
    mysql> SELECT IS_UUID('6ccd780c-baba-1026-9564-5b8c6560');
    +---------------------------------------------+
    | IS_UUID('6ccd780c-baba-1026-9564-5b8c6560') |
    +---------------------------------------------+
    |                                           0 |
    +---------------------------------------------+
    mysql> SELECT IS_UUID(RAND());
    +-----------------+
    | IS_UUID(RAND()) |
    +-----------------+
    |               0 |
    +-----------------+
    ```

-   [](<>)

    [`MASTER_POS_WAIT(*`日志名称`*,*`日志位置`*[,*`暂停`*][,*`渠道`*])`](miscellaneous-functions.html#function_master-pos-wait)

    [](<>)

    此功能用于控制源/副本同步。它一直阻塞，直到副本读取并将所有更新应用到源二进制日志中的指定位置。从 MySQL 8.0.26 开始，[`MASTER_POS_WAIT()`](miscellaneous-functions.html#function_master-pos-wait)已弃用且别名[`SOURCE_POS_WAIT()`](miscellaneous-functions.html#function_source-pos-wait)应改为使用。在 MySQL 8.0.26 之前的版本中，使用[`MASTER_POS_WAIT()`](miscellaneous-functions.html#function_master-pos-wait).

    返回值是副本必须等待前进到指定位置的日志事件数。函数返回`空值`如果复制SQL线程没有启动，副本的源信息没有初始化，参数不正确，或者发生错误。它返回`-1`如果已超过超时。如果复制 SQL 线程在[`MASTER_POS_WAIT()`](miscellaneous-functions.html#function_master-pos-wait)正在等待，函数返回`空值`.如果副本超过指定位置，则函数立即返回。

    如果二进制日志文件位置已被标记为无效，则该函数将等待直到已知有效文件位置。二进制日志文件位置可以被标记为无效时[`将复制源更改为`](change-replication-source-to.html)选项`GTID_ONLY`为复制通道设置，并重新启动服务器或停止复制。在事务成功应用超过给定文件位置后，文件位置变为有效。如果应用程序没有到达规定的位置，该函数将等待直到超时。用一个[`显示副本状态`](show-replica-status.html)检查二进制日志文件位置是否已被标记为无效的语句。

    在多线程副本上，该函数一直等到由设置的限制到期[`副本检查点组`](replication-options-replica.html#sysvar_replica_checkpoint_group),[`slave_checkpoint_group`](replication-options-replica.html#sysvar_slave_checkpoint_group),[`副本检查点周期`](replication-options-replica.html#sysvar_replica_checkpoint_period)要么[`slave_checkpoint_period`](replication-options-replica.html#sysvar_slave_checkpoint_period)系统变量，当调用检查点操作来更新副本的状态时。根据系统变量的设置，函数可能会在到达指定位置后返回一段时间。

    如果正在使用二进制日志事务压缩并且指定位置的事务有效负载被压缩（作为`Transaction_payload_event`)，该函数一直等到整个交易被读取和应用，并且仓位已经更新。

    如果一个*`暂停`*指定值，[`MASTER_POS_WAIT()`](miscellaneous-functions.html#function_master-pos-wait)停止等待*`暂停`*秒过去了。*`暂停`*必须大于 0；零或负*`暂停`*表示没有超时。

    可选的*`渠道`*value 使您能够命名该函数适用于哪个复制通道。看[第 17.2.2 节，“复制通道”](replication-channels.html)了解更多信息。

    此函数对于基于语句的复制是不安全的。如果您在以下情况下使用此功能，则会记录警告[`binlog_format`](replication-options-binary-log.html#sysvar_binlog_format)被设定为`陈述`.

-   [](<>)

    [`NAME_CONST(*`姓名`*,*`价值`*)`](miscellaneous-functions.html#function_name-const)

    [](<>)

    返回给定的值。当用于生成结果集列时，[`NAME_CONST()`](miscellaneous-functions.html#function_name-const)使列具有给定的名称。参数应该是常量。

    ```
    mysql> SELECT NAME_CONST('myname', 14);
    +--------+
    | myname |
    +--------+
    |     14 |
    +--------+
    ```

    此功能仅供内部使用。服务器在从包含对本地程序变量的引用的存储程序中编写语句时使用它，如中所述[第25.7节，“存储程序二进制记录”](stored-programs-logging.html)。您可能会在的输出中看到此函数[**mysqlbinlog**](mysqlbinlog.html).

    对于您的应用程序，使用简单的别名可以获得与刚才所示示例完全相同的结果，如下所示：

    ```
    mysql> SELECT 14 AS myname;
    +--------+
    | myname |
    +--------+
    |     14 |
    +--------+
    1 row in set (0.00 sec)
    ```

    看见[第13.2.10节“选择声明”](select.html)，以获取有关列别名的详细信息。

-   [](<>)

    [`睡觉(*`期间`*)`](miscellaneous-functions.html#function_sleep)

    [](<>)

    睡眠（暂停）的秒数由*`期间`*参数，然后返回0。持续时间可以是小数部分。如果论点是正确的`无效的`或者是否定的，[`睡眠（）`](miscellaneous-functions.html#function_sleep)在严格SQL模式下生成警告或错误。

    当睡眠恢复正常（无中断）时，它返回0：

    ```
    mysql> SELECT SLEEP(1000);
    +-------------+
    | SLEEP(1000) |
    +-------------+
    |           0 |
    +-------------+
    ```

    什么时候[`睡眠（）`](miscellaneous-functions.html#function_sleep)是被中断的查询调用的唯一对象，它返回1，而查询本身不返回错误。无论查询被终止还是超时，都是如此：

    -   此语句被使用中断[`终止查询`](kill.html)来自另一个会议：

        ```
        mysql> SELECT SLEEP(1000);
        +-------------+
        | SLEEP(1000) |
        +-------------+
        |           1 |
        +-------------+
        ```

    -   此语句因超时而中断：

        ```
        mysql> SELECT /*+ MAX_EXECUTION_TIME(1) */ SLEEP(1000);
        +-------------+
        | SLEEP(1000) |
        +-------------+
        |           1 |
        +-------------+
        ```

        什么时候[`睡眠（）`](miscellaneous-functions.html#function_sleep)只是被中断的查询的一部分，则查询返回错误：

    -   此语句被使用中断[`终止查询`](kill.html)来自另一个会议：

        ```
        mysql> SELECT 1 FROM t1 WHERE SLEEP(1000);
        ERROR 1317 (70100): Query execution was interrupted
        ```

    -   此语句因超时而中断：

        ```
        mysql> SELECT /*+ MAX_EXECUTION_TIME(1000) */ 1 FROM t1 WHERE SLEEP(1000);
        ERROR 3024 (HY000): Query execution was interrupted, maximum statement
        execution time exceeded
        ```

        此函数对于基于语句的复制不安全。如果在以下情况下使用此功能，将记录警告：[`binlog_格式`](replication-options-binary-log.html#sysvar_binlog_format)即将`陈述`.

-   [](<>)

    [`来源_位置_等待(*`日志名称`*,*`日志位置`*[,*`暂停`*][,*`频道`*])`](miscellaneous-functions.html#function_source-pos-wait)

    [](<>)

    此功能用于控制源/副本同步。它会一直阻塞，直到复制副本读取并应用所有更新到源二进制日志中的指定位置为止。在MySQL 8.0.26中，使用[`SOURCE_POS_WAIT（）`](miscellaneous-functions.html#function_source-pos-wait)代替[`大师，等等`](miscellaneous-functions.html#function_master-pos-wait)，该版本已弃用。在MySQL 8.0.26之前的版本中，使用[`大师，等等`](miscellaneous-functions.html#function_master-pos-wait).

    返回值是复制副本必须等待才能前进到指定位置的日志事件数。函数返回`无效的`如果复制SQL线程未启动，则复制副本的源信息未初始化，参数不正确，或发生错误。它回来了`-1`如果超过了超时时间。如果复制SQL线程在[`SOURCE_POS_WAIT（）`](miscellaneous-functions.html#function_source-pos-wait)正在等待，函数返回`无效的`.如果复制副本超过指定位置，函数将立即返回。

    如果二进制日志文件位置被标记为无效，则函数将等待，直到知道有效的文件位置。当[`将复制源更改为`](change-replication-source-to.html)选项`仅限GTID_`为复制通道设置，服务器重新启动或复制停止。在事务成功应用于给定文件位置之后，文件位置将变为有效。如果应用程序没有到达指定的位置，函数将等待超时。使用[`显示副本状态`](show-replica-status.html)语句，以检查二进制日志文件位置是否已标记为无效。

    在多线程副本上，函数将等待，直到[`副本检查点组`](replication-options-replica.html#sysvar_replica_checkpoint_group)或[`副本\u检查点\u周期`](replication-options-replica.html#sysvar_replica_checkpoint_period)系统变量，当调用检查点操作以更新复制副本的状态时。因此，根据系统变量的设置，函数可能会在达到指定位置后的一段时间内返回。

    如果正在使用二进制日志事务压缩，并且压缩指定位置的事务有效负载（作为`事务负载事件`)，函数将等待整个事务被读取和应用，并且位置已更新。

    如果*`暂停`*值被指定，[`SOURCE_POS_WAIT（）`](miscellaneous-functions.html#function_source-pos-wait)停止等待*`暂停`*几秒钟过去了。*`暂停`*必须大于0；零或负*`暂停`*意味着没有超时。

    可选的*`频道`*值使您能够命名该功能应用于哪个复制通道。看见[第17.2.2节“复制通道”](replication-channels.html)了解更多信息。

    此函数对于基于语句的复制不安全。如果在以下情况下使用此功能，将记录警告：[`binlog_格式`](replication-options-binary-log.html#sysvar_binlog_format)即将`陈述`.

-   [](<>)

    [`UUID（）`](miscellaneous-functions.html#function_uuid)

    [](<>)

    返回根据RFC 4122“通用唯一标识符（UUID）URN命名空间”生成的通用唯一标识符（UUID）(<http://www.ietf.org/rfc/rfc4122.txt>).

    UUID被设计为在空间和时间上全局唯一的数字。打两个电话给[`UUID（）`](miscellaneous-functions.html#function_uuid)预计将生成两个不同的值，即使这些调用是在两个彼此未连接的单独设备上执行的。

    警告

    虽然[`UUID（）`](miscellaneous-functions.html#function_uuid)价值观是独一无二的，它们不一定是无用的或不可预测的。如果需要不可预测性，那么UUID值应该以其他方式生成。

    [`UUID（）`](miscellaneous-functions.html#function_uuid)返回符合RFC 4122中所述UUID版本1的值。该值是一个128位的数字，表示为`utf8`五个十六进制数组成的字符串`aaaaaaaa-bbbb-cccc-dddd-eeeeee`格式：

    -   前三个数字由时间戳的低、中、高部分生成。较高的部分还包括UUID版本号。

    -   第四个数字保留时间唯一性，以防时间戳值失去单调性（例如，由于夏令时）。

    -   第五个数字是提供空间唯一性的IEEE 802节点号。如果后者不可用（例如，因为主机设备没有以太网卡，或者不知道如何在主机操作系统上找到接口的硬件地址），则替换为随机数。在这种情况下，无法保证空间的唯一性。尽管如此，一场碰撞应该已经发生了*非常*概率很低。

        只有在FreeBSD、Linux和Windows上，才会考虑接口的MAC地址。在其他操作系统上，MySQL使用随机生成的48位数字。

    ```
    mysql> SELECT UUID();
            -> '6ccd780c-baba-1026-9564-5b8c656024db'
    ```

    要在字符串和二进制UUID值之间转换，请使用[`UUID_TO_BIN（）`](miscellaneous-functions.html#function_uuid-to-bin)和[`BIN_TO_UUID（）`](miscellaneous-functions.html#function_bin-to-uuid)功能。要检查字符串是否为有效的UUID值，请使用[`是_UUID（）`](miscellaneous-functions.html#function_is-uuid)作用

    此函数对于基于语句的复制不安全。如果在以下情况下使用此功能，将记录警告：[`binlog_格式`](replication-options-binary-log.html#sysvar_binlog_format)即将`陈述`.

-   [](<>)

    [`UUID_SHORT（）`](miscellaneous-functions.html#function_uuid-short)

    [](<>)

    以64位无符号整数的形式返回“短”通用标识符。返回的值[`UUID_SHORT（）`](miscellaneous-functions.html#function_uuid-short)不同于[`UUID（）`](miscellaneous-functions.html#function_uuid)函数和具有不同的唯一性属性。价值[`UUID_SHORT（）`](miscellaneous-functions.html#function_uuid-short)如果满足以下条件，则保证是唯一的：

    -   这个[`服务器id`](replication-options.html#sysvar_server_id)当前服务器的值介于0和255之间，并且在源服务器和副本服务器集中是唯一的

    -   在这两个时间段之间，您不会为服务器主机设置系统时间[**mysqld**](mysqld.html)重新开始

    -   你调用[`UUID_SHORT（）`](miscellaneous-functions.html#function_uuid-short)平均每秒不到1600万次[**mysqld**](mysqld.html)重新开始

        这个[`UUID_SHORT（）`](miscellaneous-functions.html#function_uuid-short)返回值的构造方式如下：

    ```
      (server_id & 255) << 56
    + (server_startup_time_in_seconds << 24)
    + incremented_variable++;
    ```

    ```
    mysql> SELECT UUID_SHORT();
            -> 92395783831158784
    ```

    笔记

    [`UUID_SHORT（）`](miscellaneous-functions.html#function_uuid-short)不适用于基于语句的复制。

-   [](<>)

    [`UUID_TO_BIN(*`字符串\_uuid`*)`](miscellaneous-functions.html#function_uuid-to-bin), [`UUID_TO_BIN(*`字符串\_uuid`*, *`交换旗`*)`](miscellaneous-functions.html#function_uuid-to-bin)

    [](<>)

    将字符串UUID转换为二进制UUID并返回结果。(小标题)[`是_UUID（）`](miscellaneous-functions.html#function_is-uuid)函数说明列出了允许的字符串UUID格式。）返回的二进制UUID是一个[`VARBINARY（16）`](binary-varbinary.html)价值如果UUID参数为`无效的`，返回值为`无效的`.如果任何参数无效，则会发生错误。

    [`UUID_TO_BIN（）`](miscellaneous-functions.html#function_uuid-to-bin)接受一个或两个参数：

    -   单参数形式采用字符串UUID值。二进制结果的顺序与字符串参数的顺序相同。

    -   双参数形式采用字符串UUID值和标志值：

        -   如果*`交换旗`*如果为0，则两个参数形式等同于一个参数形式。二进制结果的顺序与字符串参数的顺序相同。

        -   如果*`交换旗`*值为1时，返回值的格式不同：时间低位和时间高位部分（分别是第一组和第三组十六进制数字）被交换。这会将变化较快的部分向右移动，如果结果存储在索引列中，则可以提高索引效率。

        时间部分交换假定使用UUID版本1的值，例如[`UUID（）`](miscellaneous-functions.html#function_uuid)作用对于不遵循版本1格式的其他方式生成的UUID值，时间部分交换没有任何好处。有关版本1格式的详细信息，请参阅[`UUID（）`](miscellaneous-functions.html#function_uuid)功能描述。

        假设您有以下字符串UUID值：

    ```
    mysql> SET @uuid = '6ccd780c-baba-1026-9564-5b8c656024db';
    ```

    要将字符串UUID转换为二进制（带或不带时间部分交换），请使用[`UUID_TO_BIN（）`](miscellaneous-functions.html#function_uuid-to-bin):

    ```
    mysql> SELECT HEX(UUID_TO_BIN(@uuid));
    +----------------------------------+
    | HEX(UUID_TO_BIN(@uuid))          |
    +----------------------------------+
    | 6CCD780CBABA102695645B8C656024DB |
    +----------------------------------+
    mysql> SELECT HEX(UUID_TO_BIN(@uuid, 0));
    +----------------------------------+
    | HEX(UUID_TO_BIN(@uuid, 0))       |
    +----------------------------------+
    | 6CCD780CBABA102695645B8C656024DB |
    +----------------------------------+
    mysql> SELECT HEX(UUID_TO_BIN(@uuid, 1));
    +----------------------------------+
    | HEX(UUID_TO_BIN(@uuid, 1))       |
    +----------------------------------+
    | 1026BABA6CCD780C95645B8C656024DB |
    +----------------------------------+
    ```

    转换由返回的二进制UUID[`UUID_TO_BIN（）`](miscellaneous-functions.html#function_uuid-to-bin)要创建字符串UUID，请使用[`BIN_TO_UUID（）`](miscellaneous-functions.html#function_bin-to-uuid).如果通过调用[`UUID_TO_BIN（）`](miscellaneous-functions.html#function_uuid-to-bin)如果第二个参数为1以交换时间部分，则还应将第二个参数1传递给[`BIN_TO_UUID（）`](miscellaneous-functions.html#function_bin-to-uuid)要在将二进制UUID转换回字符串UUID时取消标记时间部分，请执行以下操作：

    ```
    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid));
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid))      |
    +--------------------------------------+
    | 6ccd780c-baba-1026-9564-5b8c656024db |
    +--------------------------------------+
    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,0),0);
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid,0),0)  |
    +--------------------------------------+
    | 6ccd780c-baba-1026-9564-5b8c656024db |
    +--------------------------------------+
    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,1),1);
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid,1),1)  |
    +--------------------------------------+
    | 6ccd780c-baba-1026-9564-5b8c656024db |
    +--------------------------------------+
    ```

    如果在两个方向的转换中使用的时间部分交换不同，则原始UUID无法正确恢复：

    ```
    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,0),1);
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid,0),1)  |
    +--------------------------------------+
    | baba1026-780c-6ccd-9564-5b8c656024db |
    +--------------------------------------+
    mysql> SELECT BIN_TO_UUID(UUID_TO_BIN(@uuid,1),0);
    +--------------------------------------+
    | BIN_TO_UUID(UUID_TO_BIN(@uuid,1),0)  |
    +--------------------------------------+
    | 1026baba-6ccd-780c-9564-5b8c656024db |
    +--------------------------------------+
    ```

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

-   [](<>)

    [`价值观(*`上校的名字`*)`](miscellaneous-functions.html#function_values)

    [](<>)

    在一个[`插入关于重复密钥更新`](insert-on-duplicate.html)声明，你可以使用`价值观(*`上校的名字`*)`在[`使现代化`](update.html)子句中的列值[`插入`](insert.html)声明的一部分。换句话说，`价值观(*`上校的名字`*)`在[`使现代化`](update.html)子句指的是*`上校的名字`*如果没有出现重复的密钥冲突，则将插入。此函数在多行插入中特别有用。这个[`价值观（）`](miscellaneous-functions.html#function_values)函数只有在`关于重复密钥更新`条款[`插入`](insert.html)报表和报表`无效的`否则看见[第13.2.6.2节，“在重复密钥更新声明中插入…”](insert-on-duplicate.html).

    ```
    mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
        -> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);
    ```

    重要的

    这种用法在MySQL 8.0.20中已被弃用，在MySQL的未来版本中可能会被删除。改用行别名或行和列别名。看见[第13.2.6.2节，“在重复密钥更新声明中插入…”](insert-on-duplicate.html)，以获取更多信息和示例。
