12.24 杂项功能

# 12.24 杂项功能

表 12.29 其他功能

姓名	描述	介绍	已弃用
`ANY_VALUE()`	仅抑制_满的_团体_按值拒绝
`BIN_TO_UUID()`	将二进制 UUID 转换为字符串
`默认（）`	返回表列的默认值
`分组（）`	将超级聚合 ROLLUP 行与常规行区分开来
`INET_ATON()`	返回 IP 地址的数值
`INET_NTOA()`	从数值返回 IP 地址
`INET6_ATON()`	返回 IPv6 地址的数值
`INET6_NTOA()`	从数值返回 IPv6 地址
`IS_IPV4()`	参数是否为 IPv4 地址
`IS_IPV4_COMPAT()`	参数是否为 IPv4 兼容地址
`IS_IPV4_MAPPED()`	参数是否为 IPv4 映射地址
`IS_IPV6()`	参数是否为 IPv6 地址
`IS_UUID()`	参数是否是有效的 UUID
`MASTER_POS_WAIT()`	阻塞直到副本读取并应用所有更新到指定位置		8.0.26
`NAME_CONST()`	使列具有给定名称
`睡觉（）`	睡几秒钟
`SOURCE_POS_WAIT()`	阻塞直到副本读取并应用所有更新到指定位置	8.0.26
`UUID()`	返回通用唯一标识符 (UUID)
`UUID_SHORT()`	返回一个整数值的通用标识符
`UUID_TO_BIN()`	将字符串 UUID 转换为二进制
`值（）`	定义在 INSERT 期间要使用的值

ANY_VALUE(*参数*)

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

例如，如果姓名是非索引列，以下查询失败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()参考地址：
```
SELECT name, ANY_VALUE(address), MAX(age) FROM t GROUP BY name;
```
  在这种情况下，MySQL 忽略了地址每个内的值姓名组并接受查询。如果您根本不关心为每个组选择了非聚合列的哪个值，这可能很有用。ANY_VALUE()不是聚合函数，不像函数，例如和（）要么数数（）.它只是用来抑制对非确定性的测试。
- 禁用ONLY_FULL_GROUP_BY.这相当于使用ANY_VALUE()和ONLY_FULL_GROUP_BY启用，如上一项所述。
ANY_VALUE()如果列之间存在功能依赖但 MySQL 无法确定它，这也很有用。以下查询是有效的，因为年龄在功能上取决于分组列1 岁，但 MySQL 无法判断并拒绝查询ONLY_FULL_GROUP_BY启用：
```
SELECT age FROM t GROUP BY age-1;
```
要使 MySQL 接受查询，请使用ANY_VALUE()：
```
SELECT ANY_VALUE(age) FROM t GROUP BY age-1;
```
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()告诉 MySQL 接受查询：
```
SELECT ANY_VALUE(name), MAX(age) FROM t;
```
可能是由于给定数据集的某些属性，您知道选定的非聚合列在功能上实际上依赖于通过...分组柱子。例如，应用程序可以强制一列相对于另一列的唯一性。在这种情况下，使用ANY_VALUE()对于有效的功能依赖列可能是有意义的。

有关其他讨论，请参阅第 12.20.3 节，“MySQL 对 GROUP BY 的处理”.
BIN_TO_UUID(*binary_uuid*),BIN_TO_UUID(*binary_uuid*, *交换标志*)

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

BIN_TO_UUID()接受一两个参数：
- 单参数形式采用二进制 UUID 值。假设 UUID 值没有交换其时间低和时间高的部分。字符串结果与二进制参数的顺序相同。
- 两个参数形式采用二进制 UUID 值和交换标志值：
  - 如果*交换标志*为 0，二元形式等价于一元形式。字符串结果与二进制参数的顺序相同。
  - 如果*交换标志*为 1，假设 UUID 值的时间低和时间高部分交换。这些部分被交换回它们在结果值中的原始位置。
  有关时间部分交换的使用示例和信息，请参阅UUID_TO_BIN()功能说明。
默认（*col_name*)

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

指某东西的用途默认（*col_name*)为命名列指定默认值仅允许用于具有文字默认值的列，而不是用于具有表达式默认值的列。
```
mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;
```
格式（*X*,*D*)

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

分组（*表达式* [, *表达式*] ...)

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

分组（）允许在选择列表中，拥有子句和（从 MySQL 8.0.12 开始）订购方式条款。

每个论点分组（）必须是与通过...分组条款。表达式不能是位置说明符。对于每个表达式，分组（）如果当前行中的表达式值为 a空值表示超聚合值。否则，分组（）产生 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 |
+------+-------+----------+

区分空值超级聚合行中的值来自常规分组行中的值，使用分组（），仅对超聚合返回 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 |
+------+-------+----------+----------+----------+

常见用途分组（）：

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

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

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

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

以下查询显示了如何分组（）单个参数的结果组合用于多参数调用以生成位掩码值：

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

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

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

用于分组（）受以下限制：

不要使用子查询通过...分组表达式为分组（）参数，因为匹配可能会失败。例如，此查询的匹配失败：

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 中使用拥有子句作为分组（）论据。由于优化器评估时间之间的差异通过...分组和拥有, 匹配可能成功但是分组（）评估不会产生预期的结果。考虑这个查询：
```
SELECT a AS f1, 'w' AS f2
FROM t
GROUP BY f1, f2 WITH ROLLUP
HAVING GROUPING(f2) = 1;
```
分组（）对文字常量表达式的求值比对拥有子句作为一个整体并返回 0。要检查这样的查询是否受到影响，请使用解释并寻找不可能拥有在里面额外的柱子。

有关更多信息带汇总和分组（），看第 12.20.2 节，“GROUP BY 修饰符”.

INET_ATON(*表达式*)

给定 IPv4 网络地址作为字符串的点分四元组表示，返回一个整数，该整数表示网络字节顺序（大端）地址的数值。INET_ATON()返回空值如果它不理解它的论点。
```
mysql> SELECT INET_ATON('10.0.5.9');
        -> 167773449
```
对于本例，返回值计算为 10×256³ + 0×256²+ 5×256 + 9。

INET_ATON()可能会或可能不会返回非空值短格式 IP 地址的结果（例如'127.1'作为代表'127.0.0.1'）。因为这，INET_ATON()a 不应用于此类地址。

笔记

存储由INET_ATON(), 使用INT 无符号列而不是INT, 已签名。如果使用有符号列，则无法正确存储与第一个八位字节大于 127 的 IP 地址对应的值。看第 11.1.7 节，“超出范围和溢出处理”.
INET_NTOA(*表达式*)

给定一个按网络字节顺序排列的数字 IPv4 网络地址，以连接字符集中的字符串形式返回地址的点分四组字符串表示形式。INET_NTOA()返回空值如果它不理解它的论点。
```
mysql> SELECT INET_NTOA(167773449);
        -> '10.0.5.9'
```
INET6_ATON(*表达式*)

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

以下示例使用十六进制（）显示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以数字形式表示的 IPv6 地址的值变量值，使用这个表达式：
```
INET6_ATON(INET_NTOA(expr))
```
例如：
```
mysql> SELECT HEX(INET6_ATON(INET_NTOA(167773449)));
        -> '0A000509'
```
如果INET6_ATON()从内部调用mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex.有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”.
INET6_NTOA(*表达式*)

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

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()从内部调用mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--binary-as-hex.有关该选项的更多信息，请参阅第 4.5.1 节，“mysql - MySQL 命令行客户端”.
IS_IPV4(*表达式*)

如果参数是指定为字符串的有效 IPv4 地址，则返回 1，否则返回 0。
```
mysql> SELECT IS_IPV4('10.0.5.9'), IS_IPV4('10.0.5.256');
        -> 1, 0
```
对于给定的参数，如果IS_IPV4()返回 1，INET_ATON()（和INET6_ATON()) 返回非空值.相反的说法是不正确的：在某些情况下，INET_ATON()返回非空值什么时候IS_IPV4()返回 0。

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

此函数将以数字形式表示的 IPv6 地址作为二进制字符串，由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(*表达式*)

此函数将以数字形式表示的 IPv6 地址作为二进制字符串，由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(*表达式*)

如果参数是指定为字符串的有效 IPv6 地址，则返回 1，否则返回 0。此函数不认为 IPv4 地址是有效的 IPv6 地址。
```
mysql> SELECT IS_IPV6('10.0.5.9'), IS_IPV6('::1');
        -> 0, 1
```
对于给定的参数，如果IS_IPV6()返回 1，INET6_ATON()返回非空值.

IS_UUID(*string_uuid*)

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

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

aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee

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

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

值中字段的含义，请参见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(*日志名称*,*日志位置*[,*暂停*][,*渠道*])

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

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

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

在多线程副本上，该函数一直等到由设置的限制到期副本检查点组,slave_checkpoint_group,副本检查点周期要么slave_checkpoint_period系统变量，当调用检查点操作来更新副本的状态时。根据系统变量的设置，函数可能会在到达指定位置后返回一段时间。

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

如果一个*暂停指定值，MASTER_POS_WAIT()停止等待暂停秒过去了。暂停必须大于 0；零或负暂停*表示没有超时。

可选的*渠道*value 使您能够命名该函数适用于哪个复制通道。看第 17.2.2 节，“复制通道”了解更多信息。

此函数对于基于语句的复制是不安全的。如果您在以下情况下使用此功能，则会记录警告binlog_format被设定为陈述.
NAME_CONST(*姓名*,*价值*)

返回给定的值。当用于生成结果集列时，NAME_CONST()使列具有给定的名称。参数应该是常量。
```
mysql> SELECT NAME_CONST('myname', 14);
+--------+
| myname |
+--------+
|     14 |
+--------+
```
此功能仅供内部使用。服务器在从包含对本地程序变量的引用的存储程序中编写语句时使用它，如中所述第25.7节，“存储程序二进制记录”。您可能会在的输出中看到此函数mysqlbinlog.

对于您的应用程序，使用简单的别名可以获得与刚才所示示例完全相同的结果，如下所示：
```
mysql> SELECT 14 AS myname;
+--------+
| myname |
+--------+
|     14 |
+--------+
1 row in set (0.00 sec)
```
看见第13.2.10节“选择声明”，以获取有关列别名的详细信息。
睡觉(*期间*)

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

当睡眠恢复正常（无中断）时，它返回0：
```
mysql> SELECT SLEEP(1000);
+-------------+
| SLEEP(1000) |
+-------------+
|           0 |
+-------------+
```
什么时候睡眠（）是被中断的查询调用的唯一对象，它返回1，而查询本身不返回错误。无论查询被终止还是超时，都是如此：
- 此语句被使用中断终止查询来自另一个会议：
```
mysql> SELECT SLEEP(1000);
+-------------+
| SLEEP(1000) |
+-------------+
|           1 |
+-------------+
```
- 此语句因超时而中断：
```
mysql> SELECT /*+ MAX_EXECUTION_TIME(1) */ SLEEP(1000);
+-------------+
| SLEEP(1000) |
+-------------+
|           1 |
+-------------+
```
  什么时候睡眠（）只是被中断的查询的一部分，则查询返回错误：
- 此语句被使用中断终止查询来自另一个会议：
```
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_格式即将陈述.
来源_位置_等待(*日志名称*,*日志位置*[,*暂停*][,*频道*])

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

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

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

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

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

如果*暂停值被指定，SOURCE_POS_WAIT（）停止等待暂停几秒钟过去了。暂停必须大于0；零或负暂停*意味着没有超时。

可选的*频道*值使您能够命名该功能应用于哪个复制通道。看见第17.2.2节“复制通道”了解更多信息。

此函数对于基于语句的复制不安全。如果在以下情况下使用此功能，将记录警告：binlog_格式即将陈述.
UUID（）

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

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

警告

虽然UUID（）价值观是独一无二的，它们不一定是无用的或不可预测的。如果需要不可预测性，那么UUID值应该以其他方式生成。

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（）和BIN_TO_UUID（）功能。要检查字符串是否为有效的UUID值，请使用是_UUID（）作用

此函数对于基于语句的复制不安全。如果在以下情况下使用此功能，将记录警告：binlog_格式即将陈述.
UUID_SHORT（）

以64位无符号整数的形式返回“短”通用标识符。返回的值UUID_SHORT（）不同于UUID（）函数和具有不同的唯一性属性。价值UUID_SHORT（）如果满足以下条件，则保证是唯一的：
- 这个服务器id当前服务器的值介于0和255之间，并且在源服务器和副本服务器集中是唯一的
- 在这两个时间段之间，您不会为服务器主机设置系统时间mysqld重新开始
- 你调用UUID_SHORT（）平均每秒不到1600万次mysqld重新开始
  
  这个UUID_SHORT（）返回值的构造方式如下：
```
  (server_id & 255) << 56
+ (server_startup_time_in_seconds << 24)
+ incremented_variable++;
```
```
mysql> SELECT UUID_SHORT();
        -> 92395783831158784
```
笔记

UUID_SHORT（）不适用于基于语句的复制。
UUID_TO_BIN(*字符串_uuid*), UUID_TO_BIN(*字符串_uuid*, *交换旗*)

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

UUID_TO_BIN（）接受一个或两个参数：
- 单参数形式采用字符串UUID值。二进制结果的顺序与字符串参数的顺序相同。
- 双参数形式采用字符串UUID值和标志值：
  - 如果*交换旗*如果为0，则两个参数形式等同于一个参数形式。二进制结果的顺序与字符串参数的顺序相同。
  - 如果*交换旗*值为1时，返回值的格式不同：时间低位和时间高位部分（分别是第一组和第三组十六进制数字）被交换。这会将变化较快的部分向右移动，如果结果存储在索引列中，则可以提高索引效率。
  时间部分交换假定使用UUID版本1的值，例如UUID（）作用对于不遵循版本1格式的其他方式生成的UUID值，时间部分交换没有任何好处。有关版本1格式的详细信息，请参阅UUID（）功能描述。
  
  假设您有以下字符串UUID值：
```
mysql> SET @uuid = '6ccd780c-baba-1026-9564-5b8c656024db';
```
要将字符串UUID转换为二进制（带或不带时间部分交换），请使用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 |
+----------------------------------+
```
转换由返回的二进制UUIDUUID_TO_BIN（）要创建字符串UUID，请使用BIN_TO_UUID（）.如果通过调用UUID_TO_BIN（）如果第二个参数为1以交换时间部分，则还应将第二个参数1传递给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（）从mysql客户端，二进制字符串使用十六进制表示法显示，具体取决于--二进制为十六进制。有关该选项的更多信息，请参阅第4.5.1节，“mysql——mysql命令行客户端”.
价值观(*上校的名字*)

在一个插入关于重复密钥更新声明，你可以使用价值观(*上校的名字*)在使现代化子句中的列值插入声明的一部分。换句话说，价值观(*上校的名字*)在使现代化子句指的是*上校的名字*如果没有出现重复的密钥冲突，则将插入。此函数在多行插入中特别有用。这个价值观（）函数只有在关于重复密钥更新条款插入报表和报表无效的否则看见第13.2.6.2节，“在重复密钥更新声明中插入…”.
```
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节，“在重复密钥更新声明中插入…”，以获取更多信息和示例。

← 12.23 内部函数 12.25 精密数学 →