Spec-Zone.ru › MySQL 9.2

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

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

  • 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_MERGE_PRESERVE().

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

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

    Примечание

    Для объяснения и примера различий между этой функцией и 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() по сравнению с 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}

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

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

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

    Функции 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 распознаёт последовательности экранирования, показанные в таблице 14.23, «Специальные последовательности экранирования JSON_UNQUOTE()». Для всех остальных последовательностей экранирования обратная косая черта игнорируется. То есть экранированный символ интерпретируется так, как если бы он не был экранирован. Например, \x просто x. Эти последовательности чувствительны к регистру. Например, \b интерпретируется как символ удаления, но \B интерпретируется как B.

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

    Таблица 14.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                         |
+----------------------------+

© 2025 Oracle
Licensed under the GPLv2 License.
https://docs.oracle.com/cd/E17952_01/mysql-8.4-en/json-modification-functions.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API