ANY_VALUE(arg)

Эта функция полезна для GROUP BY запросов, когда режим SQL ONLY_FULL_GROUP_BY включен, в случаях, когда MySQL отклоняет запрос, который вы знаете как корректный по причинам, которые MySQL не может определить. Значение и тип возвращаемого значения функции такие же, как значение и тип возвращаемого значения её аргумента, но результат функции не проверяется на соответствие режиму SQL ONLY_FULL_GROUP_BY.

Например, если 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

Ошибка происходит, потому что address — это столбец без агрегации, который не указан среди GROUP BY столбцов и не функционально зависит от них. В результате, значение address для строк в каждой группе name не определено однозначно. Существует несколько способов заставить MySQL принять запрос:

ANY_VALUE() также полезна, если функциональная зависимость существует между столбцами, но MySQL не может её определить. Следующий запрос корректен, потому что age функционально зависит от столбца группировки age-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() может быть использована для запросов, которые ссылаются на агрегатные функции в отсутствие GROUP BY-запроса:

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

Без GROUP BY существует одна группа, и нет определённости, какое значение name выбрать для группы. ANY_VALUE() говорит MySQL принять запрос:

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

Возможно, из-за некоторых свойств данного набора данных, вы знаете, что выбранный столбец без агрегации фактически функционально зависит от столбца группировки. Например, приложение может гарантировать уникальность одного столбца относительно другого. В этом случае использование ANY_VALUE() для эффективно функционально зависимого столбца может иметь смысл.

Для дополнительной информации см. Раздел 14.19.3, «Обработка GROUP BY в MySQL».

BIN_TO_UUID(binary_uuid), BIN_TO_UUID(binary_uuid, swap_flag)

BIN_TO_UUID() — это обратная функция для UUID_TO_BIN(). Она преобразует двоичный UUID в строковый UUID и возвращает результат. Двоичное значение должно быть UUID в виде значения VARBINARY(16). Возвращаемое значение — строка из пяти шестнадцатеричных чисел, разделенных дефисами. (Подробности о формате см. в описании функции UUID().) Если аргумент UUID — NULL, возвращаемое значение — NULL. При любом недопустимом аргументе возникает ошибка.

BIN_TO_UUID() принимает один или два аргумента:

Для примеров использования и информации о перестановке частей времени см. описание функции UUID_TO_BIN().

DEFAULT(col_name)

Возвращает значение по умолчанию для столбца таблицы. Если у столбца нет значения по умолчанию, возникает ошибка.

Использование DEFAULT(col_name) для указания значения по умолчанию для именованного столбца разрешено только для столбцов с литеральными значениями по умолчанию, а не для столбцов с выражениями по умолчанию.

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

FORMAT(X,D)

Форматирует число X в формате, подобном '#,###,###.##', округляя до D десятичных знаков и возвращает результат в виде строки. Для получения подробной информации см. Раздел 14.8, «Строковые функции и операторы».

GROUPING(expr [, expr] ...)

Для запросов, включающих модификатор WITH ROLLUP, операция ROLLUP создаёт строки сверх-агрегированных результатов, где NULL представляет собой множество всех значений. Функция GROUPING() позволяет отличать значения NULL в строках сверх-агрегированных результатов от значений NULL в обычных сгруппированных строках.

Функция GROUPING() разрешена в списке выбора, в предложении HAVING и в предложении ORDER BY.

Каждый аргумент функции GROUPING() должен быть выражением, точно соответствующим выражению в предложении GROUP BY. Выражение не может быть позиционным спецификатором. Для каждого выражения, функция GROUPING() возвращает 1, если значение выражения в текущей строке является NULL, представляющим сверх-агрегированное значение. В противном случае, GROUPING() возвращает 0, указывая, что значение выражения является NULL для обычной строки результата или не является NULL.

Предположим, что таблица t1 содержит эти строки, где NULL обозначает что-то вроде “другое” или “неизвестно”:

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

Сводка таблицы без 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 |
+------+-------+----------+

Результат содержит NULL значения, но они не представляют сверх-агрегированные строки, поскольку запрос не содержит WITH ROLLUP.

Добавление WITH ROLLUP создаёт строки сверх-агрегированного свода, содержащие дополнительные 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 |
+------+-------+----------+

Для различения значений NULL в строках сверх-агрегированных результатов и в обычных сгруппированных строках используйте GROUPING(), которая возвращает 1 только для значений NULL сверх-агрегированных результатов:

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

Типичные применения функции GROUPING():

Функция GROUPING() допускает несколько аргументов-выражений. В этом случае возвращаемое значение GROUPING() представляет собой битовую маску, составленную из результатов для каждого выражения, где младший бит соответствует результату для правого выражения. Например, с тремя аргументами-выражениями, GROUPING(expr1, expr2, expr3) вычисляется так:

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

Следующий запрос демонстрирует, как результаты 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 |
+------+-------+----------+----------+----------+---------+

При нескольких аргументах-выражениях, возвращаемое значение функции GROUPING() отлично от нуля, если любое выражение представляет значение сверх-агрегированного результата. Синтаксис функции 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 |
+------+------+----------+

Использование функции GROUPING() ограничено следующим:

Дополнительную информацию о WITH ROLLUP и функции GROUPING() см. в разделе 14.19.2, «Модификаторы GROUP BY».

INET_ATON(expr)

Принимая строковое представление IPv4-адреса сети в формате «точка-десятичная», возвращает целое число, представляющее числовое значение адреса в сетевом порядке байтов (big endian). Функция INET_ATON() возвращает NULL, если не понимает свой аргумент или если expr имеет NULL значение.

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

В этом примере возвращаемое значение вычисляется как 10×256³ + 0×256² + 5×256 + 9.

Функция INET_ATON() может или не может возвращать результат, отличный от NULL, для IP-адресов в сокращенном формате (таких как '127.1' как представление '127.0.0.1'). Из-за этого, INET_ATON() не следует использовать для таких адресов.

INET_NTOA(expr)

Принимая числовой IPv4-адрес сети в сетевом порядке байтов, возвращает строковое представление адреса в формате «точка-десятичная» в наборе символов соединения. Функция INET_NTOA() возвращает NULL, если не понимает свой аргумент.

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

INET6_ATON(expr)

Принимая в качестве аргумента строковое представление IPv6 или IPv4 сетевого адреса, возвращает двоичную строку, представляющую числовое значение адреса в сетевом порядке байтов (big endian). Поскольку числовые форматы IPv6-адресов требуют больше байтов, чем наибольший целочисленный тип, представлением, возвращаемым этой функцией, является тип данных VARBINARY: VARBINARY(16) для IPv6-адресов и VARBINARY(4) для IPv4-адресов. Если аргумент не является допустимым адресом или если он NULL, INET6_ATON() возвращает NULL.

В следующих примерах используется функция 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() соблюдает несколько ограничений на допустимые аргументы. Эти ограничения приведены в следующем списке вместе с примерами.

Для преобразования IPv4-адреса expr, представленного в числовом формате как значение INT, в IPv6-адрес, представленный в числовом формате как значение VARBINARY, используйте это выражение:

INET6_ATON(INET_NTOA(expr))

Например:

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

Если функция INET6_ATON() вызывается из клиента mysql, двоичные строки отображаются в шестнадцатеричном формате в зависимости от значения параметра --binary-as-hex. Дополнительную информацию об этом параметре см. в Разделе 6.5.1, «mysql — The MySQL Command-Line Client».

INET6_NTOA(expr)

Принимая в качестве аргумента двоичную строку, представляющую IPv6 или IPv4 сетевой адрес в числовом формате, возвращает строковое представление адреса в строковом формате набора символов соединения. Если аргумент не является допустимым адресом или если он NULL, INET6_NTOA() возвращает NULL.

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'

Если функция INET6_NTOA() вызывается из клиента mysql, двоичные строки отображаются в шестнадцатеричном формате в зависимости от значения параметра --binary-as-hex. Дополнительную информацию об этом параметре см. в Разделе 6.5.1, «mysql — The MySQL Command-Line Client».

IS_IPV4(expr)

Возвращает 1, если аргумент является допустимым IPv4-адресом, указанным в виде строки, и 0 в противном случае. Возвращает NULL, если expr является NULL.

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

Для данного аргумента, если IS_IPV4() возвращает 1, INET_ATON() (и INET6_ATON()) возвращает не-NULL. Обратное утверждение неверно: в некоторых случаях INET_ATON() возвращает не-NULL, когда IS_IPV4() возвращает 0.

Как подразумевается из предыдущих замечаний, IS_IPV4() более строго, чем INET_ATON(), в отношении того, что представляет собой допустимый IPv4-адрес, поэтому может быть полезным для приложений, которым требуются строгие проверки на недопустимые значения. В качестве альтернативы используйте INET6_ATON() для преобразования IPv4-адресов во внутренний формат и проверки на результат NULL (который указывает на недопустимый адрес). INET6_ATON() также настолько же строга, как IS_IPV4(), в отношении проверки IPv4-адресов.

IS_IPV4_COMPAT(expr)

Эта функция принимает IPv6-адрес в числовом формате в виде двоичной строки, как возвращает INET6_ATON(). Она возвращает 1, если аргумент является допустимым IPv4-совместимым IPv6-адресом, и 0 в противном случае (если expr является NULL, в этом случае функция возвращает NULL). 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

NAME_CONST(name,value)

Возвращает заданное значение. При использовании для создания столбца результата набора, NAME_CONST() задаёт столбцу заданное имя. Аргументы должны быть константами.

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

Данная функция предназначена только для внутреннего использования. Сервер использует её при записи инструкций из хранимых программ, содержащих ссылки на локальные переменные программы, как описано в Разделе 27.7, «Хранимая программа двоичного протоколирования». Вы можете увидеть эту функцию в выводе из mysqlbinlog.

Для ваших приложений вы можете получить точно такой же результат, как в приведённом примере, используя простое алиасирование, например так:

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

Дополнительную информацию об алиасах столбцов см. в Разделе 15.2.13, «Инструкция SELECT».

SLEEP(duration)

Засыпает (пауза) на количество секунд, заданное аргументом duration, затем возвращает 0. Длительность может иметь дробную часть. Если аргумент равен NULL или отрицателен, SLEEP() выдаёт предупреждение или ошибку в строгом режиме SQL.

Когда sleep возвращает значение нормально (без прерывания), возвращается 0:

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

Когда SLEEP() является единственной вызываемой частью запроса, который прерывается, она возвращает 1, и сам запрос не возвращает ошибку. Это верно, как если запрос убит, так и если истекло время ожидания:

Если SLEEP() является только частью запроса, который прерывается, запрос возвращает ошибку:

Эта функция небезопасна для репликации на основе инструкций. Предупреждение регистрируется, если вы используете эту функцию, когда binlog_format установлено в значение STATEMENT.

UUID()

Возвращает универсальный уникальный идентификатор (UUID), сгенерированный в соответствии с RFC 4122, «“Универсальный уникальный идентификатор (UUID) простанство имён URN”» (http://www.ietf.org/rfc/rfc4122.txt).

UUID предназначен как число, глобально уникальное в пространстве и времени. Два вызова UUID() ожидаются для генерации двух различных значений, даже если эти вызовы выполняются на двух отдельных устройствах, не подключённых друг к другу.

UUID() возвращает значение, соответствующее версии UUID 1, как описано в RFC 4122. Значение — 128-битное число, представленное как utf8mb3 строка из пяти шестнадцатеричных чисел в формате aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:

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

Для преобразования между строковым и двоичным значениями UUID используйте функции UUID_TO_BIN() и BIN_TO_UUID(). Для проверки, является ли строка допустимым значением UUID, используйте функцию IS_UUID().

Эта функция небезопасна для репликации на основе инструкций. Предупреждение регистрируется, если вы используете эту функцию, когда binlog_format установлено в значение STATEMENT.

UUID_SHORT()

Возвращает «короткий» универсальный идентификатор как 64-битное беззнаковое целое число. Значения, возвращаемые UUID_SHORT(), отличаются от 128-битных идентификаторов в строковом формате, возвращаемых функцией UUID(), и имеют другие свойства уникальности. Значение UUID_SHORT() гарантируется уникальным, если выполняются следующие условия:

Значение возвращаемое 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)

Преобразует строковый UUID в двоичный UUID и возвращает результат. (Описание функции IS_UUID() содержит список разрешенных форматов строковых UUID.) Возвращаемый двоичный UUID является значением типа VARBINARY(16). Если аргумент UUID имеет значение NULL, возвращаемое значение равно NULL. Если какой-либо аргумент некорректен, произойдет ошибка.

UUID_TO_BIN() принимает один или два аргумента:

Перестановка частей time предполагает использование значений UUID версии 1, таких как генерируются функцией UUID(). Для значений UUID, сгенерированных другими средствами, которые не соответствуют формату версии 1, перестановка частей time не приносит никакой пользы. Подробнее о формате версии 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 |
+----------------------------------+

Для преобразования двоичного UUID, возвращаемого функцией UUID_TO_BIN(), в строковый UUID, используйте функцию BIN_TO_UUID(). Если вы генерируете двоичный UUID, вызвав UUID_TO_BIN() со вторым аргументом 1 для перестановки частей time, вы также должны передать второй аргумент 1 в BIN_TO_UUID(), чтобы разменять части time при преобразовании двоичного 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 |
+--------------------------------------+

Если использование перестановки частей time не совпадает при преобразовании в обоих направлениях, исходный 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, двоичные строки отображаются с использованием шестнадцатеричного обозначения, в зависимости от значения опции --binary-as-hex. Дополнительную информацию об этой опции см. в разделе Раздел 6.5.1, «mysql — Клиентская программа командной строки MySQL».

VALUES(col_name)

В операторе INSERT ... ON DUPLICATE KEY UPDATE вы можете использовать функцию VALUES(col_name) в операторной части UPDATE для обращения к значениям столбцов из части INSERT оператора. Другими словами, VALUES(col_name) в операторе UPDATE относится к значению col_name, которое должно быть вставлено, если конфликт с дублирующимся ключом не произошел. Эта функция особенно полезна при вставке нескольких строк. Функция VALUES() имеет смысл только в операторе UPDATE части INSERT операторов и возвращает NULL в противном случае. См. Раздел 15.2.7.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);