12.17.4 Functions That Modify JSON Values — MySQL 5.7

12.17.4 Функции, изменяющие значения JSON

Функции в этом разделе изменяют значения JSON и возвращают результат.

JSON_APPEND(json_doc, path, val[, path, val] ...)

Добавляет значения в конец указанных массивов в документе JSON и возвращает результат. Эта функция была переименована в JSON_ARRAY_APPEND() в MySQL 5.7.9; псевдоним JSON_APPEND() теперь устарел в MySQL 5.7 и удален в MySQL 8.0.

JSON_ARRAY_APPEND(json_doc, path, val[, path, val] ...)

Добавляет значения в конец указанных массивов в документе JSON и возвращает результат. Возвращает NULL, если какой-либо аргумент является NULL. Возникает ошибка, если аргумент json_doc не является корректным документом JSON или любой аргумент path не является корректным выражением пути или содержит подстановочный знак * или **.

Пары «путь-значение» оцениваются слева направо. Документ, полученный при оценке одной пары, становится новым значением, относительно которого оценивается следующая пара.

Если путь выбирает скалярное или объектное значение, это значение автоматически оборачивается в массив, и новое значение добавляется в этот массив. Парам, для которых путь не определяет значения в документе JSON, игнорируются.

mysql> SET @j = '["a", ["b", "c"], "d"]';
mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1]', 1);
+----------------------------------+
| JSON_ARRAY_APPEND(@j, '$[1]', 1) |
+----------------------------------+
| ["a", ["b", "c", 1], "d"]        |
+----------------------------------+
mysql> SELECT JSON_ARRAY_APPEND(@j, '$[0]', 2);
+----------------------------------+
| JSON_ARRAY_APPEND(@j, '$[0]', 2) |
+----------------------------------+
| [["a", 2], ["b", "c"], "d"]      |
+----------------------------------+
mysql> SELECT JSON_ARRAY_APPEND(@j, '$[1][0]', 3);
+-------------------------------------+
| JSON_ARRAY_APPEND(@j, '$[1][0]', 3) |
+-------------------------------------+
| ["a", [["b", 3], "c"], "d"]         |
+-------------------------------------+

mysql> SET @j = '{"a": 1, "b": [2, 3], "c": 4}';
mysql> SELECT JSON_ARRAY_APPEND(@j, '$.b', 'x');
+------------------------------------+
| JSON_ARRAY_APPEND(@j, '$.b', 'x')  |
+------------------------------------+
| {"a": 1, "b": [2, 3, "x"], "c": 4} |
+------------------------------------+
mysql> SELECT JSON_ARRAY_APPEND(@j, '$.c', 'y');
+--------------------------------------+
| JSON_ARRAY_APPEND(@j, '$.c', 'y')    |
+--------------------------------------+
| {"a": 1, "b": [2, 3], "c": [4, "y"]} |
+--------------------------------------+

mysql> SET @j = '{"a": 1}';
mysql> SELECT JSON_ARRAY_APPEND(@j, '$', 'z');
+---------------------------------+
| JSON_ARRAY_APPEND(@j, '$', 'z') |
+---------------------------------+
| [{"a": 1}, "z"]                 |
+---------------------------------+

JSON_ARRAY_INSERT(json_doc, path, val[, path, val] ...)

Обновляет документ JSON, вставляя в массив внутри документа и возвращая изменённый документ. Возвращает NULL, если какой-либо аргумент является NULL. Возникает ошибка, если аргумент json_doc не является корректным документом JSON или любой аргумент path не является корректным выражением пути или содержит подстановочный знак * или **, или не заканчивается идентификатором элемента массива.

Пары «путь-значение» оцениваются слева направо. Документ, полученный при оценке одной пары, становится новым значением, относительно которого оценивается следующая пара.

Парам, для которых путь не определяет массив в документе JSON, игнорируются. Если путь определяет элемент массива, соответствующее значение вставляется в позицию этого элемента, смещая все последующие значения вправо. Если путь определяет позицию массива за пределами массива, значение вставляется в конец массива.
```
mysql> SET @j = '["a", {"b": [1, 2]}, [3, 4]]';
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1]', 'x');
+------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[1]', 'x') |
+------------------------------------+
| ["a", "x", {"b": [1, 2]}, [3, 4]]  |
+------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[100]', 'x');
+--------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[100]', 'x') |
+--------------------------------------+
| ["a", {"b": [1, 2]}, [3, 4], "x"]    |
+--------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x');
+-----------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[1].b[0]', 'x') |
+-----------------------------------------+
| ["a", {"b": ["x", 1, 2]}, [3, 4]]       |
+-----------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[2][1]', 'y');
+---------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[2][1]', 'y') |
+---------------------------------------+
| ["a", {"b": [1, 2]}, [3, "y", 4]]     |
+---------------------------------------+
mysql> SELECT JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y');
+----------------------------------------------------+
| JSON_ARRAY_INSERT(@j, '$[0]', 'x', '$[2][1]', 'y') |
+----------------------------------------------------+
| ["x", "a", {"b": [1, 2]}, [3, 4]]                  |
+----------------------------------------------------+
```
Предыдущие изменения влияют на позиции последующих элементов в массиве, поэтому последующие пути в том же вызове JSON_ARRAY_INSERT() должны учитывать это. В последнем примере второй путь ничего не вставляет, так как путь больше не соответствует чему-либо после первой вставки.
JSON_INSERT(json_doc, path, val[, path, val] ...)

Вставляет данные в документ JSON и возвращает результат. Возвращает NULL, если какой-либо аргумент является NULL. Возникает ошибка, если аргумент json_doc не является корректным документом JSON или любой аргумент path не является корректным выражением пути или содержит подстановочный знак * или **.

Пары «путь-значение» оцениваются слева направо. Документ, полученный при оценке одной пары, становится новым значением, относительно которого оценивается следующая пара.

Пара «путь-значение» для существующего пути в документе игнорируется и не перезаписывает существующее значение документа. Пара «путь-значение» для несуществующего пути в документе добавляет значение в документ, если путь идентифицирует один из следующих типов значений:
- Член, отсутствующий в существующем объекте. Член добавляется в объект и связывается с новым значением.
- Позиция за пределами существующего массива. Массив расширяется новым значением. Если существующее значение не является массивом, оно автоматически оборачивается в массив, а затем расширяется новым значением.
В противном случае пара «путь-значение» для несуществующего пути в документе игнорируется и не оказывает никакого влияния.

Для сравнения JSON_INSERT(), JSON_REPLACE() и JSON_SET(), см. обсуждение JSON_SET().
```
mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
+----------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
+----------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": "[true, false]"}        |
+----------------------------------------------------+
```
Третье и последнее значение в результате — это строка в кавычках, а не массив, как второе (которое не заключено в кавычки в выводе); преобразование значений в тип JSON не выполняется. Чтобы вставить массив как массив, нужно явно выполнить такие преобразования, как показано здесь:
```
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON));
+------------------------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', CAST('[true, false]' AS JSON)) |
+------------------------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": [true, false]}                        |
+------------------------------------------------------------------+
1 row in set (0.00 sec)
```

JSON_MERGE(json_doc, json_doc[, json_doc] ...)

Объединяет два или более документов JSON. Синоним для JSON_MERGE_PRESERVE(); устарел в MySQL 5.7.22 и может быть удалён в будущей версии.

mysql> SELECT JSON_MERGE('[1, 2]', '[true, false]');
+---------------------------------------+
| JSON_MERGE('[1, 2]', '[true, false]') |
+---------------------------------------+
| [1, 2, true, false]                   |
+---------------------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
  Level: Warning
   Code: 1287
Message: 'JSON_MERGE' is deprecated and will be removed in a future release. \
 Please use JSON_MERGE_PRESERVE/JSON_MERGE_PATCH instead
1 row in set (0.00 sec)

Для дополнительных примеров см. запись для JSON_MERGE_PRESERVE().

JSON_MERGE_PATCH(json_doc, json_doc[, json_doc] ...)

Выполняет слияние двух или более документов JSON, совместимое с RFC 7396, и возвращает объединённый результат без сохранения членов с дублирующимися ключами. Вызывает ошибку, если хотя бы один из документов, переданных в качестве аргументов этой функции, не является корректным.

Примечание

Объяснение и пример различий между этой функцией и JSON_MERGE_PRESERVE() см. в JSON_MERGE_PATCH() по сравнению с JSON_MERGE_PRESERVE().

JSON_MERGE_PATCH() выполняет слияние следующим образом:
1. Если первый аргумент не является объектом, результат слияния такой же, как если бы пустой объект был объединён со вторым аргументом.
2. Если второй аргумент не является объектом, результат слияния — второй аргумент.
3. Если оба аргумента являются объектами, результат слияния — объект со следующими членами:
  - Все члены первого объекта, у которых нет соответствующего члена с тем же ключом во втором объекте.
  - Все члены второго объекта, у которых нет соответствующего ключа в первом объекте, и чьё значение не является JSON null литералом.
  - Все члены с ключом, существующим как в первом, так и во втором объекте, и чьё значение во втором объекте не является JSON null литералом. Значения этих членов являются результатом рекурсивного слияния значения в первом объекте со значением во втором объекте.
Дополнительную информацию см. в разделе Нормализация, слияние и автоматическое обертывание значений JSON.
```
mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '[true, false]');
+---------------------------------------------+
| JSON_MERGE_PATCH('[1, 2]', '[true, false]') |
+---------------------------------------------+
| [true, false]                               |
+---------------------------------------------+

mysql> SELECT JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}');
+-------------------------------------------------+
| JSON_MERGE_PATCH('{"name": "x"}', '{"id": 47}') |
+-------------------------------------------------+
| {"id": 47, "name": "x"}                         |
+-------------------------------------------------+

mysql> SELECT JSON_MERGE_PATCH('1', 'true');
+-------------------------------+
| JSON_MERGE_PATCH('1', 'true') |
+-------------------------------+
| true                          |
+-------------------------------+

mysql> SELECT JSON_MERGE_PATCH('[1, 2]', '{"id": 47}');
+------------------------------------------+
| JSON_MERGE_PATCH('[1, 2]', '{"id": 47}') |
+------------------------------------------+
| {"id": 47}                               |
+------------------------------------------+

mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }',
     >     '{ "a": 3, "c":4 }');
+-----------------------------------------------------------+
| JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }') |
+-----------------------------------------------------------+
| {"a": 3, "b": 2, "c": 4}                                  |
+-----------------------------------------------------------+

mysql> SELECT JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }',
     >     '{ "a": 5, "d":6 }');
+-------------------------------------------------------------------------------+
| JSON_MERGE_PATCH('{ "a": 1, "b":2 }','{ "a": 3, "c":4 }','{ "a": 5, "d":6 }') |
+-------------------------------------------------------------------------------+
| {"a": 5, "b": 2, "c": 4, "d": 6}                                              |
+-------------------------------------------------------------------------------+
```
Вы можете использовать эту функцию для удаления члена, указав null как значение того же члена во втором аргументе, как показано здесь:
```
mysql> SELECT JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}');
+--------------------------------------------------+
| JSON_MERGE_PATCH('{"a":1, "b":2}', '{"b":null}') |
+--------------------------------------------------+
| {"a": 1}                                         |
+--------------------------------------------------+
```
Этот пример показывает, что функция работает рекурсивно; то есть значения членов не ограничиваются скалярами, но могут сами являться документами JSON:
```
mysql> SELECT JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}');
+----------------------------------------------------+
| JSON_MERGE_PATCH('{"a":{"x":1}}', '{"a":{"y":2}}') |
+----------------------------------------------------+
| {"a": {"x": 1, "y": 2}}                            |
+----------------------------------------------------+
```
JSON_MERGE_PATCH() поддерживается в MySQL 5.7.22 и более поздних версиях.

JSON_MERGE_PATCH() по сравнению с JSON_MERGE_PRESERVE(). Поведение JSON_MERGE_PATCH() такое же, как у JSON_MERGE_PRESERVE(), за исключением двух следующих моментов:
- JSON_MERGE_PATCH() удаляет любой член в первом объекте с соответствующим ключом во втором объекте, при условии, что значение, связанное с ключом во втором объекте, не является JSON null.
- Если второй объект имеет член с ключом, совпадающим с членом в первом объекте, JSON_MERGE_PATCH() заменяет значение в первом объекте значением во втором объекте, тогда как JSON_MERGE_PRESERVE() добавляет второе значение к первому значению.
Этот пример сравнивает результаты слияния одних и тех же 3 JSON-объектов, каждый из которых имеет совпадающий ключ "a", с каждой из этих двух функций:
```
mysql> SET @x = '{ "a": 1, "b": 2 }',
     >     @y = '{ "a": 3, "c": 4 }',
     >     @z = '{ "a": 5, "d": 6 }';

mysql> SELECT  JSON_MERGE_PATCH(@x, @y, @z)    AS Patch,
    ->         JSON_MERGE_PRESERVE(@x, @y, @z) AS Preserve\G
*************************** 1. row ***************************
   Patch: {"a": 5, "b": 2, "c": 4, "d": 6}
Preserve: {"a": [1, 3, 5], "b": 2, "c": 4, "d": 6}
```

END_OF_DOCUMENT_MARKER

JSON_MERGE_PRESERVE(json_doc, json_doc[, json_doc] ...)

Объединяет два или более JSON-документов и возвращает объединённый результат. Возвращает NULL, если какой-либо аргумент является NULL. Возникает ошибка, если какой-либо аргумент не является допустимым JSON-документом.

Объединение происходит по следующим правилам. Дополнительную информацию см. в Нормализация, объединение и автоматическое обрамление JSON-значений.

Смежные массивы объединяются в один массив.
Смежные объекты объединяются в один объект.
Скалярное значение автоматически обрамляется массивом и объединяется как массив.
Смежный массив и объект объединяются путём автоматического обрамления объекта массивом и объединения двух массивов.

mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '[true, false]');
+------------------------------------------------+
| JSON_MERGE_PRESERVE('[1, 2]', '[true, false]') |
+------------------------------------------------+
| [1, 2, true, false]                            |
+------------------------------------------------+

mysql> SELECT JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}');
+----------------------------------------------------+
| JSON_MERGE_PRESERVE('{"name": "x"}', '{"id": 47}') |
+----------------------------------------------------+
| {"id": 47, "name": "x"}                            |
+----------------------------------------------------+

mysql> SELECT JSON_MERGE_PRESERVE('1', 'true');
+----------------------------------+
| JSON_MERGE_PRESERVE('1', 'true') |
+----------------------------------+
| [1, true]                        |
+----------------------------------+

mysql> SELECT JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}');
+---------------------------------------------+
| JSON_MERGE_PRESERVE('[1, 2]', '{"id": 47}') |
+---------------------------------------------+
| [1, 2, {"id": 47}]                          |
+---------------------------------------------+

mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }',
     >    '{ "a": 3, "c": 4 }');
+--------------------------------------------------------------+
| JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c":4 }') |
+--------------------------------------------------------------+
| {"a": [1, 3], "b": 2, "c": 4}                                |
+--------------------------------------------------------------+

mysql> SELECT JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }',
     >    '{ "a": 5, "d": 6 }');
+----------------------------------------------------------------------------------+
| JSON_MERGE_PRESERVE('{ "a": 1, "b": 2 }','{ "a": 3, "c": 4 }','{ "a": 5, "d": 6 }') |
+----------------------------------------------------------------------------------+
| {"a": [1, 3, 5], "b": 2, "c": 4, "d": 6}                                         |
+----------------------------------------------------------------------------------+

Эта функция была добавлена в MySQL 5.7.22 в качестве синонима для JSON_MERGE(). Функция JSON_MERGE() теперь устарела и может быть удалена в будущих версиях MySQL.

Эта функция похожа на, но отличается от JSON_MERGE_PATCH() во многих аспектах; см. JSON_MERGE_PATCH() по сравнению с JSON_MERGE_PRESERVE() для получения дополнительной информации.

JSON_REMOVE(json_doc, path[, path] ...)

Удаляет данные из JSON-документа и возвращает результат. Возвращает NULL, если любой аргумент является NULL. Возникает ошибка, если аргумент json_doc не является допустимым JSON-документом или любой аргумент path не является допустимым выражением пути, не является $ или содержит подстановочный знак * или **.

Аргументы path вычисляются слева направо. Документ, полученный в результате вычисления одного пути, становится новым значением, по отношению к которому вычисляется следующий путь.

Если элемент, подлежащий удалению, не существует в документе, это не является ошибкой; в этом случае путь не влияет на документ.
```
mysql> SET @j = '["a", ["b", "c"], "d"]';
mysql> SELECT JSON_REMOVE(@j, '$[1]');
+-------------------------+
| JSON_REMOVE(@j, '$[1]') |
+-------------------------+
| ["a", "d"]              |
+-------------------------+
```

JSON_REPLACE(json_doc, path, val[, path, val] ...)

Заменяет существующие значения в JSON-документе и возвращает результат. Возвращает NULL, если json_doc или любой аргумент path является NULL. Возникает ошибка, если аргумент json_doc не является допустимым JSON-документом или любой аргумент path не является допустимым выражением пути или содержит подстановочный знак * или **.

Пары путь-значение вычисляются слева направо. Документ, полученный в результате вычисления одной пары, становится новым значением, по отношению к которому вычисляется следующая пара.

Пара путь-значение для существующего пути в документе перезаписывает существующее значение документа новым значением. Пара путь-значение для несуществующего пути в документе игнорируется и не оказывает никакого влияния.

Для сравнения JSON_INSERT(), JSON_REPLACE() и JSON_SET() см. обсуждение JSON_SET().

mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
+-----------------------------------------------------+
| JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
+-----------------------------------------------------+
| {"a": 10, "b": [2, 3]}                              |
+-----------------------------------------------------+

mysql> SELECT JSON_REPLACE(NULL, '$.a', 10, '$.c', '[true, false]');
+-------------------------------------------------------+
| JSON_REPLACE(NULL, '$.a', 10, '$.c', '[true, false]') |
+-------------------------------------------------------+
| NULL                                                  |
+-------------------------------------------------------+

mysql> SELECT JSON_REPLACE(@j, NULL, 10, '$.c', '[true, false]');
+----------------------------------------------------+
| JSON_REPLACE(@j, NULL, 10, '$.c', '[true, false]') |
+----------------------------------------------------+
| NULL                                               |
+----------------------------------------------------+

mysql> SELECT JSON_REPLACE(@j, '$.a', NULL, '$.c', '[true, false]');
+-------------------------------------------------------+
| JSON_REPLACE(@j, '$.a', NULL, '$.c', '[true, false]') |
+-------------------------------------------------------+
| {"a": null, "b": [2, 3]}                              |
+-------------------------------------------------------+

JSON_SET(json_doc, path, val[, path, val] ...)

Вставляет или обновляет данные в JSON-документе и возвращает результат. Возвращает NULL, если json_doc или path являются NULL, или если path, если задан, не находит объект. В противном случае возникает ошибка, если аргумент json_doc не является допустимым JSON-документом или любой аргумент path не является допустимым выражением пути или содержит подстановочный знак * или **.

Пары путь-значение вычисляются слева направо. Документ, полученный в результате вычисления одной пары, становится новым значением, по отношению к которому вычисляется следующая пара.

Пара путь-значение для существующего пути в документе перезаписывает существующее значение документа новым значением. Пара путь-значение для несуществующего пути в документе добавляет значение в документ, если путь идентифицирует один из следующих типов значений:
- Член, отсутствующий в существующем объекте. Член добавляется в объект и связывается с новым значением.
- Позиция после конца существующего массива. Массив расширяется новым значением. Если существующее значение не является массивом, оно автоматически обрамляется массивом, а затем расширяется новым значением.
В противном случае пара путь-значение для несуществующего пути в документе игнорируется и не оказывает никакого влияния.

Функции JSON_SET(), JSON_INSERT() и JSON_REPLACE() взаимосвязаны:
- JSON_SET() заменяет существующие значения и добавляет несуществующие.
- JSON_INSERT() вставляет значения без замены существующих.
- JSON_REPLACE() заменяет только существующие значения.
Следующие примеры иллюстрируют эти различия, используя один путь, который существует в документе ($.a), и другой, который не существует ($.c):
```
mysql> SET @j = '{ "a": 1, "b": [2, 3]}';
mysql> SELECT JSON_SET(@j, '$.a', 10, '$.c', '[true, false]');
+-------------------------------------------------+
| JSON_SET(@j, '$.a', 10, '$.c', '[true, false]') |
+-------------------------------------------------+
| {"a": 10, "b": [2, 3], "c": "[true, false]"}    |
+-------------------------------------------------+
mysql> SELECT JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]');
+----------------------------------------------------+
| JSON_INSERT(@j, '$.a', 10, '$.c', '[true, false]') |
+----------------------------------------------------+
| {"a": 1, "b": [2, 3], "c": "[true, false]"}        |
+----------------------------------------------------+
mysql> SELECT JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]');
+-----------------------------------------------------+
| JSON_REPLACE(@j, '$.a', 10, '$.c', '[true, false]') |
+-----------------------------------------------------+
| {"a": 10, "b": [2, 3]}                              |
+-----------------------------------------------------+
```

JSON_UNQUOTE(json_val)

Удаляет кавычки из JSON-значения и возвращает результат в виде utf8mb4 строки. Возвращает NULL, если аргумент является NULL. Возникает ошибка, если значение начинается и заканчивается двойными кавычками, но не является допустимой строковой литералом JSON.

Внутри строки определённые последовательности имеют специальное значение, если не включен SQL-режим NO_BACKSLASH_ESCAPES. Каждая из этих последовательностей начинается с обратной косой черты (\), известной как символ экранирования. MySQL распознаёт последовательности экранирования, показанные в таблице 12.23, «JSON_UNQUOTE() Специальные последовательности экранирования символов». Для всех остальных последовательностей экранирования обратная косая черта игнорируется. То есть экранированный символ интерпретируется так, как если бы он не был экранирован. Например, \x просто отображает x. Эти последовательности чувствительны к регистру. Например, \b интерпретируется как возврат на одну позицию назад, но \B интерпретируется как B.

Таблица 12.23 JSON_UNQUOTE() Специальные последовательности экранирования символов

Таблица 12.23 JSON_UNQUOTE() Специальные последовательности экранирования символов
Последовательность экранирования	Символ, представленный последовательностью
`\"`	Символ двойной кавычки (`"`)
`\b`	Символ возврата на одну позицию назад
`\f`	Символ подачи формы
`\n`	Символ перевода строки
`\r`	Символ возврата каретки
`\t`	Символ табуляции
`\\`	Символ обратной косой черты (`\`)
`\uXXXX`	UTF-8 байты для Unicode-значения `XXXX`

Два простых примера использования этой функции показаны здесь:

mysql> SET @j = '"abc"';
mysql> SELECT @j, JSON_UNQUOTE(@j);
+-------+------------------+
| @j    | JSON_UNQUOTE(@j) |
+-------+------------------+
| "abc" | abc              |
+-------+------------------+
mysql> SET @j = '[1, 2, 3]';
mysql> SELECT @j, JSON_UNQUOTE(@j);
+-----------+------------------+
| @j        | JSON_UNQUOTE(@j) |
+-----------+------------------+
| [1, 2, 3] | [1, 2, 3]        |
+-----------+------------------+

Следующий набор примеров показывает, как JSON_UNQUOTE обрабатывает экранирования при отключённом и включённом режиме NO_BACKSLASH_ESCAPES:

mysql> SELECT @@sql_mode;
+------------+
| @@sql_mode |
+------------+
|            |
+------------+

mysql> SELECT JSON_UNQUOTE('"\\t\\u0032"');
+------------------------------+
| JSON_UNQUOTE('"\\t\\u0032"') |
+------------------------------+
|       2                           |
+------------------------------+

mysql> SET @@sql_mode = 'NO_BACKSLASH_ESCAPES';
mysql> SELECT JSON_UNQUOTE('"\\t\\u0032"');
+------------------------------+
| JSON_UNQUOTE('"\\t\\u0032"') |
+------------------------------+
| \t\u0032                     |
+------------------------------+

mysql> SELECT JSON_UNQUOTE('"\t\u0032"');
+----------------------------+
| JSON_UNQUOTE('"\t\u0032"') |
+----------------------------+
|       2                         |
+----------------------------+