ANY_VALUE(arg)

This function is useful for GROUP BY queries when the ONLY_FULL_GROUP_BY SQL mode is enabled, for cases when MySQL rejects a query that you know is valid for reasons that MySQL cannot determine. 当启用了ONLY_FULL_GROUP_BYSQL模式时，此函数对于GROUP BY查询非常有用，当MySQL拒绝一个您知道是有效的查询时，它的原因MySQL无法确定。The function return value and type are the same as the return value and type of its argument, but the function result is not checked for the ONLY_FULL_GROUP_BY SQL mode.函数返回值和类型与其参数的返回值和类型相同，但对于ONLY_FULL_GROUP_BYSQL模式，不会检查函数结果。

For example, if name is a nonindexed column, the following query fails with ONLY_FULL_GROUP_BY enabled:例如，如果name是非索引列，并且启用了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

The failure occurs because address is a nonaggregated column that is neither named among GROUP BY columns nor functionally dependent on them. 失败的原因是address是一个未聚合的列，它既不在GROUP BY列中命名，也不在功能上依赖于GROUP BY列。As a result, the address value for rows within each name group is nondeterministic. 因此，每个name组中的行的地址值是不确定的。There are multiple ways to cause MySQL to accept the query:有多种方法可以使MySQL接受查询：

ANY_VALUE() is also useful if functional dependence exists between columns but MySQL cannot determine it. 如果列之间存在函数依赖关系，但MySQL无法确定它，则ANY_VALUE()也很有用。The following query is valid because age is functionally dependent on the grouping column age-1, but MySQL cannot tell that and rejects the query with ONLY_FULL_GROUP_BY enabled:下面的查询是有效的，因为age在功能上依赖于分组列age-1，但是MySQL无法判断这一点，并且拒绝启用了ONLY_FULL_GROUP_BY的查询：

SELECT age FROM t GROUP BY age-1;

To cause MySQL to accept the query, use ANY_VALUE():要使MySQL接受查询，请使用ANY_VALUE()：

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

ANY_VALUE() can be used for queries that refer to aggregate functions in the absence of a GROUP BY clause:在没有GROUP BY子句的情况下，ANY_VALUE()都可以用于引用聚合函数的查询：

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

Without GROUP BY, there is a single group and it is nondeterministic which name value to choose for the group. 没有GROUP BY，就只有一个组，为组选择哪个名称值是不确定的。ANY_VALUE() tells MySQL to accept the query:ANY_VALUE()告诉MySQL接受查询：

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

It may be that, due to some property of a given data set, you know that a selected nonaggregated column is effectively functionally dependent on a GROUP BY column. 可能是因为，由于给定数据集的某些属性，您知道选定的非聚集列在功能上实际上依赖于GROUP BY列。For example, an application may enforce uniqueness of one column with respect to another. 例如，应用程序可以强制一列相对于另一列的唯一性。In this case, using ANY_VALUE() for the effectively functionally dependent column may make sense.在这种情况下，对有效的函数依赖列使用ANY_VALUE()可能是有意义的。

For additional discussion, see Section 12.20.3, “MySQL Handling of GROUP BY”.有关更多讨论，请参阅第12.20.3节，“MySQL处理分组方式”。

BIN_TO_UUID(binary_uuid), BIN_TO_UUID(binary_uuid, swap_flag)

BIN_TO_UUID() is the inverse of UUID_TO_BIN(). BIN_TO_UUID()是UUID_TO_BIN()的倒数。It converts a binary UUID to a string UUID and returns the result. 它将二进制UUID转换为字符串UUID并返回结果。The binary value should be a UUID as a VARBINARY(16) value. 二进制值应该是一个UUID作为VARBINARY(16)值。The return value is a utf8 string of five hexadecimal numbers separated by dashes. 返回值是由五个十六进制数组成的utf8字符串，用破折号分隔。(For details about this format, see the UUID() function description.) （有关此格式的详细信息，请参阅UUID()函数说明。）If the UUID argument is NULL, the return value is NULL. 如果UUID参数为NULL，则返回值为NULL。If any argument is invalid, an error occurs.如果任何参数无效，则会发生错误。

BIN_TO_UUID() takes one or two arguments:BIN_TO_UUID()接受一个或两个参数：

For usage examples and information about time-part swapping, see the UUID_TO_BIN() function description.有关时间段交换的用法示例和信息，请参阅UUID_TO_BIN()函数说明。

DEFAULT(col_name)

Returns the default value for a table column. 返回表列的默认值。An error results if the column has no default value.如果列没有默认值，则会产生错误。

The use of DEFAULT(col_name) to specify the default value for a named column is permitted only for columns that have a literal default value, not for columns that have an expression default value.仅允许对具有文字默认值的列使用DEFAULT(col_name)来指定命名列的默认值，而不允许对具有表达式默认值的列使用它。

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

FORMAT(X,D)

Formats the number X to a format like '#,###,###.##', rounded to D decimal places, and returns the result as a string. 将数字X格式化为'#,###,###.##'等格式，四舍五入到D位小数，并以字符串形式返回结果。For details, see Section 12.8, “String Functions and Operators”.有关详细信息，请参阅第12.8节，“字符串函数和运算符”。

GROUPING(expr [, expr] ...)

For GROUP BY queries that include a WITH ROLLUP modifier, the ROLLUP operation produces super-aggregate output rows where NULL represents the set of all values. 对于包含WITH ROLLUP修饰符的GROUP BY查询，ROLLUP操作生成超级聚合输出行，其中NULL表示所有值的集合。The GROUPING() function enables you to distinguish NULL values for super-aggregate rows from NULL values in regular grouped rows.GROUPING()函数让你能够区分超级聚合行的NULL值和常规分组行的NULL值。

GROUPING() is permitted in the select list, HAVING clause, and (as of MySQL 8.0.12) ORDER BY clause.SELECT列表、HAVING子句和（从MySQL 8.0.12开始）ORDER BY子句中允许GROUPING()。

Each argument to GROUPING() must be an expression that exactly matches an expression in the GROUP BY clause. GROUPING()的每个参数必须是与GROUP BY子句中的表达式完全匹配的表达式。The expression cannot be a positional specifier. 表达式不能是位置说明符。For each expression, GROUPING() produces 1 if the expression value in the current row is a NULL representing a super-aggregate value. 对于每个表达式，如果当前行中的表达式值是表示超级聚合值的NULL，GROUPING()将生成1。Otherwise, GROUPING() produces 0, indicating that the expression value is a NULL for a regular result row or is not NULL.否则，GROUPING()将生成0，表示表达式值对于常规结果行为NULL或不为NULL。

Suppose that table t1 contains these rows, where NULL indicates something like “other” or “unknown”:假设表t1包含这些行，其中NULL表示类似“other”或“unknown”的内容：

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

A summary of the table without WITH ROLLUP looks like this:不带WITH ROLLUP的表的摘要如下所示：

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

The result contains NULL values, but those do not represent super-aggregate rows because the query does not include WITH ROLLUP.结果包含NULL值，但这些值不表示超级聚合行，因为查询不包含WITH ROLLUP。

Adding WITH ROLLUP produces super-aggregate summary rows containing additional NULL values. 添加WITH ROLLUP将生成包含其他NULL值的超级聚合摘要行。However, without comparing this result to the previous one, it is not easy to see which NULL values occur in super-aggregate rows and which occur in regular grouped rows:但是，如果不将此结果与前一个结果进行比较，就不容易看出哪些NULL值出现在超级聚合行中，哪些NULL值出现在常规分组行中：

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

To distinguish NULL values in super-aggregate rows from those in regular grouped rows, use GROUPING(), which returns 1 only for super-aggregate NULL values:要区分超级聚合行中的NULL值和常规分组行中的NULL值，请使用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 |
+------+-------+----------+----------+----------+

Common uses for GROUPING():GROUPING()的常见用法：

GROUPING() permits multiple expression arguments. GROUPING()允许多个表达式参数。In this case, the GROUPING() return value represents a bitmask combined from the results for each expression, where the lowest-order bit corresponds to the result for the rightmost expression. 在本例中，GROUPING()返回值表示从每个表达式的结果组合而来的位掩码，其中最低位对应于最右边表达式的结果。For example, with three expression arguments, GROUPING(expr1, expr2, expr3) is evaluated like this:例如，使用三个表达式参数GROUPING(expr1, expr2, expr3)等同于下面：

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

The following query shows how GROUPING() results for single arguments combine for a multiple-argument call to produce a bitmask value:以下查询显示如何将单个参数的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 |
+------+-------+----------+----------+----------+---------+

With multiple expression arguments, the GROUPING() return value is nonzero if any expression represents a super-aggregate value. 对于多个表达式参数，如果任何表达式表示超级聚合值，则GROUPING()返回值为非零。Multiple-argument GROUPING() syntax thus provides a simpler way to write the earlier query that returned only super-aggregate rows, by using a single multiple-argument GROUPING() call rather than multiple single-argument calls:因此，多参数的GROUPING()语法通过使用单个多参数的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 |
+------+------+----------+

Use of GROUPING() is subject to these limitations:GROUPING()的使用受以下限制：

For more information about WITH ROLLUP and GROUPING(), see Section 12.20.2, “GROUP BY Modifiers”.有关WITH ROLLUP和GROUPING()的详细信息，请参阅第12.20.2节，“按修饰符分组”。

INET_ATON(expr)

Given the dotted-quad representation of an IPv4 network address as a string, returns an integer that represents the numeric value of the address in network byte order (big endian). 给定IPv4网络地址的虚线四元表示为字符串，返回一个整数，该整数以网络字节顺序（大端）表示地址的数值。INET_ATON() returns NULL if it does not understand its argument.如果INET_ATON()不理解其参数，则返回NULL。

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

For this example, the return value is calculated as 10×256³ + 0×256² + 5×256 + 9.对于本例，返回值计算为10×256³ + 0×256² + 5×256 + 9。

INET_ATON() may or may not return a non-NULL result for short-form IP addresses (such as '127.1' as a representation of '127.0.0.1'). INET_ATON()可能返回也可能不返回短格式IP地址的非空结果（例如表示'127.0.0.1'的'127.1'）。Because of this, INET_ATON()a should not be used for such addresses.因此，INET_ATON()不应用于此类地址。

INET_NTOA(expr)

Given a numeric IPv4 network address in network byte order, returns the dotted-quad string representation of the address as a string in the connection character set. 给定按网络字节顺序排列的数字IPv4网络地址，以连接字符集中的字符串形式返回该地址的虚线四元字符串表示形式。INET_NTOA() returns NULL if it does not understand its argument.如果INET_NTOA()不理解其参数，则返回NULL。

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

INET6_ATON(expr)

Given an IPv6 or IPv4 network address as a string, returns a binary string that represents the numeric value of the address in network byte order (big endian). 给定一个IPv6或IPv4网络地址作为字符串，返回一个二进制字符串，该字符串以网络字节顺序（大端）表示地址的数值。Because numeric-format IPv6 addresses require more bytes than the largest integer type, the representation returned by this function has the VARBINARY data type: VARBINARY(16) for IPv6 addresses and VARBINARY(4) for IPv4 addresses. 由于数字格式IPv6地址需要的字节数比最大整数类型多，因此此函数返回的表示形式具有VARBINARY数据类型：VARBINARY(16)表示IPv6地址，VARBINARY(4)表示IPv4地址。If the argument is not a valid address, INET6_ATON() returns NULL.如果参数不是有效地址，INET6_ATON()将返回NULL。

The following examples use HEX() to display the INET6_ATON() result in printable form:以下示例使用HEX()以可打印形式显示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() observes several constraints on valid arguments. INET6_ATON()观察有效参数的几个约束。These are given in the following list along with examples.下面列出了这些示例。

To convert an IPv4 address expr represented in numeric form as an INT value to an IPv6 address represented in numeric form as a VARBINARY value, use this expression:要将以数值形式表示为INT值的IPv4地址expr转换为以数值形式表示为VARBINARY值的IPv6地址，请使用以下表达式：

INET6_ATON(INET_NTOA(expr))

For example:例如：

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

If INET6_ATON() is invoked from within the mysql client, binary strings display using hexadecimal notation, depending on the value of the --binary-as-hex. 如果从mysql客户机中调用INET6_ATON()，则二进制字符串将使用十六进制表示法显示，具体取决于--binary-as-hex的值。For more information about that option, see Section 4.5.1, “mysql — The MySQL Command-Line Client”.有关该选项的更多信息，请参阅第4.5.1节，“mysql-mysql命令行客户端”。

INET6_NTOA(expr)

Given an IPv6 or IPv4 network address represented in numeric form as a binary string, returns the string representation of the address as a string in the connection character set. 给定以数字形式表示为二进制字符串的IPv6或IPv4网络地址，将该地址的字符串表示形式作为连接字符集中的字符串返回。If the argument is not a valid address, INET6_NTOA() returns NULL.如果参数不是有效地址，INET6_NTOA()将返回NULL。

INET6_NTOA() has these properties:INET6_NTOA()具有以下属性：

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'

If INET6_NTOA() is invoked from within the mysql client, binary strings display using hexadecimal notation, depending on the value of the --binary-as-hex. 如果从mysql客户机中调用INET6_NTOA()，则二进制字符串将使用十六进制表示法显示，具体取决于--binary-as-hex的值。For more information about that option, see Section 4.5.1, “mysql — The MySQL Command-Line Client”.有关该选项的更多信息，请参阅第4.5.1节，“mysql-mysql命令行客户端”。

IS_IPV4(expr)

Returns 1 if the argument is a valid IPv4 address specified as a string, 0 otherwise.如果参数是指定为字符串的有效IPv4地址，则返回1，否则返回0。

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

For a given argument, if IS_IPV4() returns 1, INET_ATON() (and INET6_ATON()) returns non-NULL. 对于给定的参数，如果IS_IPV4()返回1，INET_ATON()（并且INET6_ATON()）返回非NULL。The converse statement is not true: In some cases, INET_ATON() returns non-NULL when IS_IPV4() returns 0.相反的语句不是真的：在某些情况下，当IS_IPV4()返回0时，INET_ATON()返回非NULL。

As implied by the preceding remarks, IS_IPV4() is more strict than INET_ATON() about what constitutes a valid IPv4 address, so it may be useful for applications that need to perform strong checks against invalid values. 正如前面的说明所暗示的，IS_IPV4()比INET_ATON()对于什么是有效的IPV4地址更严格，因此对于需要对无效值执行强检查的应用程序来说，它可能很有用。Alternatively, use INET6_ATON() to convert IPv4 addresses to internal form and check for a NULL result (which indicates an invalid address). 或者，使用INET6_ATON()将IPv4地址转换为内部格式，并检查空结果（表示地址无效）。INET6_ATON() is equally strong as IS_IPV4() about checking IPv4 addresses.INET6_ATON()和IPV4()在检查IPV4地址方面同样强大。

IS_IPV4_COMPAT(expr)

This function takes an IPv6 address represented in numeric form as a binary string, as returned by INET6_ATON(). 此函数采用由INET6_ATON()返回的以数字形式表示为二进制字符串的IPv6地址。It returns 1 if the argument is a valid IPv4-compatible IPv6 address, 0 otherwise. 如果参数是有效的IPv4兼容IPv6地址，则返回1，否则返回0。IPv4-compatible addresses have the form ::ipv4_address.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

The IPv4 part of an IPv4-compatible address can also be represented using hexadecimal notation. IPv4兼容地址的IPv4部分也可以使用十六进制表示法表示。For example, 198.51.100.1 has this raw hexadecimal value:例如，198.51.100.1具有以下原始十六进制值：

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

Expressed in IPv4-compatible form, ::198.51.100.1 is equivalent to ::c0a8:0001 or (without leading zeros) ::c0a8:1以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(expr)

This function takes an IPv6 address represented in numeric form as a binary string, as returned by INET6_ATON(). 此函数采用由INET6_ATON()返回的以数字形式表示为二进制字符串的IPv6地址。It returns 1 if the argument is a valid IPv4-mapped IPv6 address, 0 otherwise. 如果参数是有效的IPv4映射IPv6地址，则返回1，否则返回0。IPv4-mapped addresses have the form ::ffff:ipv4_address.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

As with IS_IPV4_COMPAT() the IPv4 part of an IPv4-mapped address can also be represented using hexadecimal notation:与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(expr)

Returns 1 if the argument is a valid IPv6 address specified as a string, 0 otherwise. 如果参数是指定为字符串的有效IPv6地址，则返回1，否则返回0。This function does not consider IPv4 addresses to be valid IPv6 addresses.这个函数不考虑IPv4地址是有效的IPv6地址。

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

For a given argument, if IS_IPV6() returns 1, INET6_ATON() returns non-NULL.对于给定参数，如果IS_IPV6()返回1，则INET6_ATON()返回非NULL。

IS_UUID(string_uuid)

Returns 1 if the argument is a valid string-format UUID, 0 if the argument is not a valid UUID, and NULL if the argument is NULL.如果参数是有效的字符串格式UUID，则返回1；如果参数不是有效的UUID，则返回0；如果参数为NULL，则返回NULL。

“Valid” means that the value is in a format that can be parsed. “Valid”表示值的格式可以解析。That is, it has the correct length and contains only the permitted characters (hexadecimal digits in any lettercase and, optionally, dashes and curly braces). 也就是说，它具有正确的长度，并且只包含允许的字符（任何字母大小写中的十六进制数字，以及可选的破折号和大括号）。This format is most common:这种格式最常见：

aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee

These other formats are also permitted:这些其他格式也是允许的：

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

For the meanings of fields within the value, see the UUID() function description.有关值中字段的含义，请参见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(log_name,log_pos[,timeout][,channel])

This function is useful for control of source/replica synchronization. 此函数用于控制源/副本同步。It blocks until the replica has read and applied all updates up to the specified position in the source's binary log. 它将阻塞，直到复制副本读取并应用所有更新到源二进制日志中的指定位置为止。The return value is the number of log events the replica had to wait for to advance to the specified position. 返回值是复制副本必须等待才能前进到指定位置的日志事件数。The function returns NULL if the replication SQL thread is not started, the replica's source information is not initialized, the arguments are incorrect, or an error occurs. 如果复制SQL线程未启动、副本的源信息未初始化、参数不正确或发生错误，则函数返回NULL。It returns -1 if the timeout has been exceeded. 如果超过超时时间，则返回-1。If the replication SQL thread stops while MASTER_POS_WAIT() is waiting, the function returns NULL. 如果复制SQL线程在MASTER_POS_WAIT()等待时停止，则函数返回NULL。If the replica is past the specified position, the function returns immediately.如果复制副本超过指定位置，则函数将立即返回。

On a multithreaded replica, the function waits until expiry of the limit set by the slave_checkpoint_group or slave_checkpoint_period system variable, when the checkpoint operation is called to update the status of the replica. 在多线程副本上，当调用检查点操作以更新副本的状态时，该函数将一直等待，直到slave_checkpoint_group或slave_checkpoint_period系统变量设置的限制到期。Depending on the setting for the system variables, the function might therefore return some time after the specified position was reached.根据系统变量的设置，函数可能会在到达指定位置后返回一段时间。

If binary log transaction compression is in use and the transaction payload at the specified position is compressed (as a Transaction_payload_event), the function waits until the whole transaction has been read and applied, and the positions have updated.如果正在使用二进制日志事务压缩，并且指定位置的事务负载被压缩（作为Transaction_payload_event），则函数将等待整个事务被读取和应用，并且位置已更新。

If a timeout value is specified, MASTER_POS_WAIT() stops waiting when timeout seconds have elapsed. 如果指定了timeout，则当timeout秒数已过时，MASTER_POS_WAIT()将停止等待。timeout must be greater than 0; a zero or negative timeout means no timeout.timeout必须大于0；零或负timeout表示没有超时。

The optional channel value enables you to name which replication channel the function applies to. 可选channel值使您能够命名该函数应用于哪个复制通道。See Section 17.2.2, “Replication Channels” for more information.有关更多信息，请参阅第17.2.2节，“复制通道”。

This function is unsafe for statement-based replication. 此函数对于基于语句的复制不安全。A warning is logged if you use this function when binlog_format is set to STATEMENT.如果在binlog_format设置为STATEMENT时使用此函数，则会记录警告。

NAME_CONST(name,value)

Returns the given value. When used to produce a result set column, NAME_CONST() causes the column to have the given name. 返回给定值。当用于生成结果集列时，NAME_CONST()使该列具有给定的名称。The arguments should be constants.参数应该是常量。

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

This function is for internal use only. 此功能仅供内部使用。The server uses it when writing statements from stored programs that contain references to local program variables, as described in Section 25.7, “Stored Program Binary Logging”. 服务器在从包含对本地程序变量引用的存储程序中写入语句时使用它，如第25.7节，“存储程序二进制日志记录”所述。You might see this function in the output from mysqlbinlog.您可能会在mysqlbinlog的输出中看到这个函数。

For your applications, you can obtain exactly the same result as in the example just shown by using simple aliasing, like this:对于您的应用程序，您可以通过使用简单的别名获得与刚才所示示例完全相同的结果，如下所示：

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

See Section 13.2.10, “SELECT Statement”, for more information about column aliases.有关列别名的详细信息，请参阅第13.2.10节，“SELECT语句”。

SLEEP(duration)

Sleeps (pauses) for the number of seconds given by the duration argument, then returns 0. 休眠（暂停）duration参数给定的秒数，然后返回0。The duration may have a fractional part. 持续时间可以是小数部分。If the argument is NULL or negative, SLEEP() produces a warning, or an error in strict SQL mode.如果参数为NULL或负值，SLEEP()将在严格SQL模式下生成警告或错误。

When sleep returns normally (without interruption), it returns 0:当睡眠恢复正常（无中断）时，返回0:

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

When SLEEP() is the only thing invoked by a query that is interrupted, it returns 1 and the query itself returns no error. 当SLEEP()是被中断的查询调用的唯一对象时，它返回1，查询本身不返回错误。This is true whether the query is killed or times out:无论查询是终止还是超时，都是如此：

When SLEEP() is only part of a query that is interrupted, the query returns an error:当SLEEP()只是被中断的查询的一部分时，查询将返回错误：

This function is unsafe for statement-based replication. 此函数对于基于语句的复制不安全。A warning is logged if you use this function when binlog_format is set to STATEMENT.如果在binlog_format设置为STATEMENT时使用此函数，则会记录警告。

UUID()

Returns a Universal Unique Identifier (UUID) generated according to RFC 4122, “A Universally Unique IDentifier (UUID) URN Namespace” (http://www.ietf.org/rfc/rfc4122.txt).返回根据RFC 4122“通用唯一标识符（UUID）URN命名空间”生成的通用唯一标识符（UUID）(http://www.ietf.org/rfc/rfc4122.txt）。

A UUID is designed as a number that is globally unique in space and time. UUID被设计为在空间和时间上全局唯一的数字。Two calls to UUID() are expected to generate two different values, even if these calls are performed on two separate devices not connected to each other.对UUID()的两个调用预期会生成两个不同的值，即使这些调用是在两个彼此未连接的单独设备上执行的。

UUID() returns a value that conforms to UUID version 1 as described in RFC 4122. UUID()返回一个值，该值符合RFC 4122中描述的UUID版本1。The value is a 128-bit number represented as a utf8 string of five hexadecimal numbers in aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee format:该值是一个128位的数字，表示为五个十六进制数字的utf8字符串，格式为aaaaaaaa-bbbb-cccc-dddd-eeee：

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

To convert between string and binary UUID values, use the UUID_TO_BIN() and BIN_TO_UUID() functions. 要在字符串和二进制UUID值之间转换，请使用UUID_To_BIN()和BIN_To_UUID()函数。To check whether a string is a valid UUID value, use the IS_UUID() function.要检查字符串是否是有效的UUID值，请使用IS_UUID()函数。

This function is unsafe for statement-based replication. 此函数对于基于语句的复制不安全。A warning is logged if you use this function when binlog_format is set to STATEMENT.如果在binlog_format设置为STATEMENT时使用此函数，则会记录警告。

UUID_SHORT()

Returns a “short” universal identifier as a 64-bit unsigned integer. 以64位无符号整数的形式返回“短”通用标识符。Values returned by UUID_SHORT() differ from the string-format 128-bit identifiers returned by the UUID() function and have different uniqueness properties. UUID_SHORT()返回的值与UUID()函数返回的字符串格式128位标识符不同，并且具有不同的唯一性属性。The value of UUID_SHORT() is guaranteed to be unique if the following conditions hold:如果满足以下条件，则UUID_SHORT()的值保证是唯一的：

The UUID_SHORT() return value is constructed this way:UUID_SHORT()返回值的构造方式如下：

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

mysql> SELECT UUID_SHORT();
        -> 92395783831158784

UUID_TO_BIN(string_uuid), UUID_TO_BIN(string_uuid, swap_flag)

Converts a string UUID to a binary UUID and returns the result. 将字符串UUID转换为二进制UUID并返回结果。(The IS_UUID() function description lists the permitted string UUID formats.) （IS_UUID()函数说明列出了允许的字符串UUID格式。）The return binary UUID is a VARBINARY(16) value. 返回的二进制UUID是VARBINARY(16)值。If the UUID argument is NULL, the return value is NULL. 如果UUID参数为NULL，则返回值为NULL。If any argument is invalid, an error occurs.如果任何参数无效，则会发生错误。

UUID_TO_BIN() takes one or two arguments:UUID _TO _BIN()接受一个或两个参数：

Time-part swapping assumes the use of UUID version 1 values, such as are generated by the UUID() function. 时间部分交换假定使用UUID version 1值，例如由UUID()函数生成的值。For UUID values produced by other means that do not follow version 1 format, time-part swapping provides no benefit. 对于由其他不遵循版本1格式的方法生成的UUID值，时间部分交换没有任何好处。For details about version 1 format, see the UUID() function description.有关版本1格式的详细信息，请参阅UUID()函数说明。

Suppose that you have the following string UUID value:假设您具有以下字符串UUID值：

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

To convert the string UUID to binary with or without time-part swapping, use UUID_TO_BIN():要将字符串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 |
+----------------------------------+

To convert a binary UUID returned by UUID_TO_BIN() to a string UUID, use BIN_TO_UUID(). 要将UUID_TO_BIN()返回的二进制UUID转换为字符串UUID，请使用BIN_TO_UUID()。If you produce a binary UUID by calling UUID_TO_BIN() with a second argument of 1 to swap time parts, you should also pass a second argument of 1 to BIN_TO_UUID() to unswap the time parts when converting the binary UUID back to a string UUID:如果通过使用第二个参数1调用UUID_TO_BIN()以交换时间部分来生成二进制UUID，则在将二进制UUID转换回字符串UUID时，还应将第二个参数1传递给BIN_TO_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 |
+--------------------------------------+

If the use of time-part swapping is not the same for the conversion in both directions, the original UUID is not recovered properly:如果两个方向的转换使用的时间部分交换不同，则原始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 |
+--------------------------------------+

If UUID_TO_BIN() is invoked from within the mysql client, binary strings display using hexadecimal notation, depending on the value of the --binary-as-hex. 如果从mysql客户机中调用UUID_TO_BIN()，则二进制字符串将使用十六进制表示法显示，具体取决于--binary-as-hex的值。For more information about that option, see Section 4.5.1, “mysql — The MySQL Command-Line Client”.有关该选项的更多信息，请参阅第4.5.1节，“mysql-mysql命令行客户端”。

VALUES(col_name)

In an INSERT ... ON DUPLICATE KEY UPDATE statement, you can use the VALUES(col_name) function in the UPDATE clause to refer to column values from the INSERT portion of the statement. 在INSERT ... ON DUPLICATE KEY UPDATE语句中，可以使用UPDATE子句中的VALUES(col_name)函数引用语句INSERT部分的列值。In other words, VALUES(col_name) in the UPDATE clause refers to the value of col_name that would be inserted, had no duplicate-key conflict occurred. 换句话说，UPDATE子句中的VALUES(col_name)指的是在没有出现重复键冲突的情况下将插入的col_name的值。This function is especially useful in multiple-row inserts. 此函数在多行插入中特别有用。The VALUES() function is meaningful only in the ON DUPLICATE KEY UPDATE clause of INSERT statements and returns NULL otherwise. VALUES()函数仅在INSERT语句的ON DUPLICATE KEY UPDATE子句中有意义，否则返回NULL。See Section 13.2.6.2, “INSERT ... ON DUPLICATE KEY UPDATE Statement”.见第13.2.6.2节，“INSERT ... ON DUPLICATE KEY UPDATE语句”。

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