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() также полезна для запросов, которые ссылаются на агрегатные функции в отсутствие фрагмента 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;

Возможно, из-за свойств набора данных вы знаете, что выбранный столбец без агрегирования фактически функционально зависит от столбца GROUP BY. Например, приложение может гарантировать уникальность одного столбца относительно другого. В этом случае использование 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.8, «Хранимые программы — протоколирование двоичных данных». Вы можете увидеть эту функцию в выводе из 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)” (http://www.ietf.org/rfc/rfc4122.txt).

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

UUID() возвращает значение, соответствующее версии 1 UUID, как описано в 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);