Массив JSON содержит список значений, разделенных запятыми и заключенных в символы [ и ]:

["abc", 10, null, true, false]

Объект JSON содержит набор пар ключ-значение, разделенных запятыми и заключенных в символы { и }:

{"k1": "value", "k2": 10}

Как показывают примеры, массивы и объекты JSON могут содержать скалярные значения, которые являются строками или числами, литерал JSON null или литералы JSON boolean true или false. Ключи в объектах JSON должны быть строками. Также разрешены скалярные временные значения (дата, время или дата и время):

["12:18:29.000000", "2015-07-29", "2015-07-29 12:18:29.000000"]

Вложенность разрешена внутри элементов массива JSON и значений ключей объекта JSON:

[99, {"id": "HK500", "cost": 75.99}, ["hot", "cold"]]
{"k1": "value", "k2": [10, 20]}

Вы также можете получить значения JSON с помощью ряда функций MySQL для этой цели (см. Раздел 14.17.2, «Функции для создания значений JSON»), а также путем приведения значений других типов к типу JSON с помощью CAST(value AS JSON) (см. Преобразование между значениями JSON и не-JSON). Следующие несколько абзацев описывают, как MySQL обрабатывает значения JSON, предоставленные в качестве входных данных.

В MySQL значения JSON записываются в виде строк. MySQL анализирует любую строку, используемую в контексте, требующем значения JSON, и выдает ошибку, если она не является допустимым JSON. Эти контексты включают вставку значения в столбец, имеющий тип данных JSON, и передачу аргумента функции, ожидающей значение JSON (обычно показанной как json_doc или json_val в документации по функциям MySQL JSON), как демонстрируют следующие примеры:

MySQL обрабатывает строки, используемые в контексте JSON, используя наборы символов utf8mb4 и правила сопоставления utf8mb4_bin. Строки в других наборах символов преобразуются в utf8mb4 по мере необходимости. (Для строк в наборах символов ascii или utf8mb3 преобразование не требуется, потому что ascii и utf8mb3 являются подмножествами utf8mb4.)

В качестве альтернативы записи значений JSON с использованием литеральных строк существуют функции для составления значений JSON из компонентов. JSON_ARRAY() принимает (возможно, пустой) список значений и возвращает массив JSON, содержащий эти значения:

mysql> SELECT JSON_ARRAY('a', 1, NOW());
+----------------------------------------+
| JSON_ARRAY('a', 1, NOW())              |
+----------------------------------------+
| ["a", 1, "2015-07-27 09:43:47.000000"] |
+----------------------------------------+

JSON_OBJECT() принимает (возможно, пустой) список пар ключ-значение и возвращает объект JSON, содержащий эти пары:

mysql> SELECT JSON_OBJECT('key1', 1, 'key2', 'abc');
+---------------------------------------+
| JSON_OBJECT('key1', 1, 'key2', 'abc') |
+---------------------------------------+
| {"key1": 1, "key2": "abc"}            |
+---------------------------------------+

JSON_MERGE_PRESERVE() принимает два или более JSON-документов и возвращает объединенный результат:

mysql> SELECT JSON_MERGE_PRESERVE('["a", 1]', '{"key": "value"}');
+-----------------------------------------------------+
| JSON_MERGE_PRESERVE('["a", 1]', '{"key": "value"}') |
+-----------------------------------------------------+
| ["a", 1, {"key": "value"}]                          |
+-----------------------------------------------------+
1 row in set (0.00 sec)

Сведения о правилах объединения см. в Нормализация, объединение и автообертывание значений JSON.

(MySQL также поддерживает JSON_MERGE_PATCH(), которая имеет несколько иное поведение. См. JSON_MERGE_PATCH() по сравнению с JSON_MERGE_PRESERVE() для получения информации о различиях между этими двумя функциями.)

Значения JSON можно присвоить определяемым пользователем переменным:

mysql> SET @j = JSON_OBJECT('key', 'value');
mysql> SELECT @j;
+------------------+
| @j               |
+------------------+
| {"key": "value"} |
+------------------+

Однако определяемые пользователем переменные не могут иметь тип данных JSON, поэтому, хотя @j в приведенном выше примере выглядит как значение JSON и имеет тот же набор символов и правила сопоставления, что и значение JSON, оно не имеет тип данных JSON. Вместо этого результат JSON_OBJECT() преобразуется в строку при присвоении переменной.

Строки, полученные путем преобразования значений JSON, имеют набор символов utf8mb4 и правила сопоставления utf8mb4_bin:

mysql> SELECT CHARSET(@j), COLLATION(@j);
+-------------+---------------+
| CHARSET(@j) | COLLATION(@j) |
+-------------+---------------+
| utf8mb4     | utf8mb4_bin   |
+-------------+---------------+

Поскольку utf8mb4_bin — это двоичное правило сопоставления, сравнение значений JSON является регистрозависимым.

mysql> SELECT JSON_ARRAY('x') = JSON_ARRAY('X');
+-----------------------------------+
| JSON_ARRAY('x') = JSON_ARRAY('X') |
+-----------------------------------+
|                                 0 |
+-----------------------------------+

Регистрозависимость также применяется к литералам JSON null, true и false, которые всегда должны быть написаны строчными буквами:

mysql> SELECT JSON_VALID('null'), JSON_VALID('Null'), JSON_VALID('NULL');
+--------------------+--------------------+--------------------+
| JSON_VALID('null') | JSON_VALID('Null') | JSON_VALID('NULL') |
+--------------------+--------------------+--------------------+
|                  1 |                  0 |                  0 |
+--------------------+--------------------+--------------------+

mysql> SELECT CAST('null' AS JSON);
+----------------------+
| CAST('null' AS JSON) |
+----------------------+
| null                 |
+----------------------+
1 row in set (0.00 sec)

mysql> SELECT CAST('NULL' AS JSON);
ERROR 3141 (22032): Invalid JSON text in argument 1 to function cast_as_json:
"Invalid value." at position 0 in 'NULL'.

Регистрозависимость литералов JSON отличается от регистрозависимости SQL-литералов NULL, TRUE и FALSE, которые можно писать в любом регистре:

mysql> SELECT ISNULL(null), ISNULL(Null), ISNULL(NULL);
+--------------+--------------+--------------+
| ISNULL(null) | ISNULL(Null) | ISNULL(NULL) |
+--------------+--------------+--------------+
|            1 |            1 |            1 |
+--------------+--------------+--------------+

Иногда может потребоваться или быть желательным вставить символы кавычек (" или ') в JSON-документ. Предположим для этого примера, что вы хотите вставить несколько JSON-объектов, содержащих строки, представляющие предложения, описывающие некоторые факты о MySQL, каждый сопоставленный с соответствующим ключевым словом, в таблицу, созданную с помощью SQL-запроса, показанного здесь:

mysql> CREATE TABLE facts (sentence JSON);

Среди этих пар «ключевое слово-предложение» есть такая:

mascot: The MySQL mascot is a dolphin named "Sakila".

Один из способов вставки этого как JSON-объекта в таблицу facts — использовать функцию MySQL JSON_OBJECT(). В этом случае вы должны экранировать каждый символ кавычки с помощью обратного слэша, как показано здесь:

mysql> INSERT INTO facts VALUES
     >   (JSON_OBJECT("mascot", "Our mascot is a dolphin named \"Sakila\"."));

Это не работает так же, если вы вставляете значение как литерал JSON-объекта, в этом случае вы должны использовать двойной обратный слэш, как это:

mysql> INSERT INTO facts VALUES
     >   ('{"mascot": "Our mascot is a dolphin named \\"Sakila\\"."}');

Использование двойного обратного слэша предотвращает обработку последовательностей экранирования MySQL и вместо этого заставляет его передавать строковый литерал в движок хранения для обработки. После вставки JSON-объекта одним из только что показанных способов вы можете увидеть, что обратные слэши присутствуют в значении столбца JSON, выполнив простое SELECT, как это:

mysql> SELECT sentence FROM facts;
+---------------------------------------------------------+
| sentence                                                |
+---------------------------------------------------------+
| {"mascot": "Our mascot is a dolphin named \"Sakila\"."} |
+---------------------------------------------------------+

Чтобы найти это конкретное предложение, используя mascot в качестве ключа, вы можете использовать оператор пути столбца ->, как показано здесь:

mysql> SELECT col->"$.mascot" FROM qtest;
+---------------------------------------------+
| col->"$.mascot"                             |
+---------------------------------------------+
| "Our mascot is a dolphin named \"Sakila\"." |
+---------------------------------------------+
1 row in set (0.00 sec)

Это оставляет обратные слэши нетронутыми, наряду с окружающими кавычками. Чтобы отобразить желаемое значение, используя mascot в качестве ключа, но без включения окружающих кавычек или каких-либо экранирований, используйте оператор встраиваемого пути ->>, как это:

mysql> SELECT sentence->>"$.mascot" FROM facts;
+-----------------------------------------+
| sentence->>"$.mascot"                   |
+-----------------------------------------+
| Our mascot is a dolphin named "Sakila". |
+-----------------------------------------+

mysql> INSERT INTO facts VALUES
     > (JSON_OBJECT('mascot', 'Our mascot is a dolphin named "Sakila".'));

При парсинге строки, которая оказывается корректным документом JSON, выполняется также нормализация. Это означает, что члены с ключами, дублирующими ключи, встречающиеся позже в документе, считывая слева направо, отбрасываются. Значение объекта, создаваемое следующим вызовом JSON_OBJECT(), включает только второй key1 элемент, поскольку это имя ключа встречается раньше в значении, как показано здесь:

mysql> SELECT JSON_OBJECT('key1', 1, 'key2', 'abc', 'key1', 'def');
+------------------------------------------------------+
| JSON_OBJECT('key1', 1, 'key2', 'abc', 'key1', 'def') |
+------------------------------------------------------+
| {"key1": "def", "key2": "abc"}                       |
+------------------------------------------------------+

Нормализация также выполняется при вставке значений в столбцы JSON, как показано здесь:

mysql> CREATE TABLE t1 (c1 JSON);

mysql> INSERT INTO t1 VALUES
     >     ('{"x": 17, "x": "red"}'),
     >     ('{"x": 17, "x": "red", "x": [3, 5, 7]}');

mysql> SELECT c1 FROM t1;
+------------------+
| c1               |
+------------------+
| {"x": "red"}     |
| {"x": [3, 5, 7]} |
+------------------+

Это поведение “последний дублирующий ключ выигрывает” предлагается в RFC 7159 и реализуется большинством парсеров JavaScript. (Ошибка #86866, Ошибка #26369555)

MySQL отбрасывает лишние пробелы между ключами, значениями или элементами в исходном документе JSON и оставляет (или вставляет при необходимости) один пробел после каждой запятой (,) или двоеточия (:) при отображении. Это делается для повышения удобочитаемости.

Функции MySQL, которые производят значения JSON (см. Раздел 14.17.2, «Функции создания значений JSON»), всегда возвращают нормализованные значения.

Для повышения эффективности поиска MySQL также сортирует ключи JSON-объекта. Следует учитывать, что результат этой сортировки может изменяться и не гарантируется, что он будет стабильным в разных выпусках.

Слияние значений JSON

Поддерживаются два алгоритма слияния, реализованные функциями JSON_MERGE_PRESERVE() и JSON_MERGE_PATCH(). Они различаются тем, как обрабатываются дублирующие ключи: JSON_MERGE_PRESERVE() сохраняет значения для дублирующих ключей, а JSON_MERGE_PATCH() отбрасывает все значения, кроме последнего. В следующих абзацах объясняется, как каждая из этих двух функций обрабатывает слияние различных комбинаций JSON-документов (то есть объектов и массивов).

Слияние массивов. В контекстах, объединяющих несколько массивов, массивы сливаются в один массив. JSON_MERGE_PRESERVE() делает это, конкатенируя массивы, указанные позже, в конец первого массива. JSON_MERGE_PATCH() рассматривает каждый аргумент как массив, состоящий из одного элемента (поэтому с индексом 0), а затем применяет логику “последний дублирующий ключ выигрывает” для выбора только последнего аргумента. Вы можете сравнить результаты, показанные этим запросом:

mysql> SELECT
    ->   JSON_MERGE_PRESERVE('[1, 2]', '["a", "b", "c"]', '[true, false]') AS Preserve,
    ->   JSON_MERGE_PATCH('[1, 2]', '["a", "b", "c"]', '[true, false]') AS Patch\G
*************************** 1. row ***************************
Preserve: [1, 2, "a", "b", "c", true, false]
   Patch: [true, false]

При слиянии нескольких объектов получается один объект. JSON_MERGE_PRESERVE() обрабатывает несколько объектов с одинаковым ключом, объединяя все уникальные значения для этого ключа в массив; этот массив затем используется как значение для этого ключа в результате. JSON_MERGE_PATCH() отбрасывает значения, для которых найдены дублирующие ключи, работая слева направо, так что результат содержит только последнее значение для этого ключа. Следующий запрос иллюстрирует разницу в результатах для дублирующего ключа a:

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

Значения, не являющиеся массивами, используемые в контексте, требующем значения массива, автообёртются: значение окружено [ и ] символами, чтобы преобразовать его в массив. В следующем операторе каждый аргумент автообёртётся как массив ([1], [2]). Затем они сливаются, чтобы получить один массив результатов; как и в предыдущих двух случаях, JSON_MERGE_PRESERVE() объединяет значения с одинаковым ключом, а JSON_MERGE_PATCH() отбрасывает значения для всех дублирующих ключей, кроме последнего, как показано здесь:

mysql> SELECT
	  ->   JSON_MERGE_PRESERVE('1', '2') AS Preserve,
	  ->   JSON_MERGE_PATCH('1', '2') AS Patch\G
*************************** 1. row ***************************
Preserve: [1, 2]
   Patch: 2

Массивы и объекты сливаются путём автообёртки объекта как массива и слияния массивов путём объединения значений или по логике “последний дублирующий ключ выигрывает” в соответствии с выбором функции слияния (JSON_MERGE_PRESERVE() или JSON_MERGE_PATCH() соответственно), как можно увидеть в этом примере:

mysql> SELECT
	  ->   JSON_MERGE_PRESERVE('[10, 20]', '{"a": "x", "b": "y"}') AS Preserve,
	  ->   JSON_MERGE_PATCH('[10, 20]', '{"a": "x", "b": "y"}') AS Patch\G
*************************** 1. row ***************************
Preserve: [10, 20, {"a": "x", "b": "y"}]
   Patch: {"a": "x", "b": "y"}

Выражение пути JSON выбирает значение внутри документа JSON.

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

mysql> SELECT JSON_EXTRACT('{"id": 14, "name": "Aztalan"}', '$.name');
+---------------------------------------------------------+
| JSON_EXTRACT('{"id": 14, "name": "Aztalan"}', '$.name') |
+---------------------------------------------------------+
| "Aztalan"                                               |
+---------------------------------------------------------+

Синтаксис пути использует ведущий символ $ для представления рассматриваемого документа JSON, за которым необязательно следуют селекторы, указывающие последовательно более конкретные части документа:

Пусть $ относится к этому массиву JSON с тремя элементами:

[3, {"a": [5, 6], "b": 10}, [99, 100]]

Тогда:

Поскольку $[1] и $[2] оцениваются как значения, отличные от скаляров, они могут использоваться в качестве основы для более конкретных выражений пути, выбирающих вложенные значения. Примеры:

Как упоминалось ранее, компоненты пути, которые называют ключи, должны быть заключены в кавычки, если имя ключа без кавычек недопустимо в выражениях путей. Пусть $ относится к этому значению:

{"a fish": "shark", "a bird": "sparrow"}

Ключи оба содержат пробел и должны быть заключены в кавычки:

Пути, использующие подстановочные знаки, оцениваются как массив, который может содержать несколько значений:

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

В следующем примере путь $**.b оценивается как несколько путей ($.a.b и $.c.b) и генерирует массив соответствующих значений пути:

mysql> SELECT JSON_EXTRACT('{"a": {"b": 1}, "c": {"b": 2}}', '$**.b');
+---------------------------------------------------------+
| JSON_EXTRACT('{"a": {"b": 1}, "c": {"b": 2}}', '$**.b') |
+---------------------------------------------------------+
| [1, 2]                                                  |
+---------------------------------------------------------+

Диапазоны из массивов JSON. Вы можете использовать ключевое слово to для указания подмножеств массивов JSON. Например, $[1 to 3] включает второй, третий и четвертый элементы массива, как показано здесь:

mysql> SELECT JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[1 to 3]');
+----------------------------------------------+
| JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[1 to 3]') |
+----------------------------------------------+
| [2, 3, 4]                                    |
+----------------------------------------------+
1 row in set (0.00 sec)

Синтаксис — M to N, где M и N — это соответственно первый и последний индексы диапазона элементов из массива JSON. N должно быть больше M; M должно быть больше или равно 0. Элементы массива индексируются, начиная с 0.

Вы можете использовать диапазоны в контекстах, где поддерживаются подстановочные знаки.

Правый элемент массива. Ключевое слово last поддерживается как синоним индекса последнего элемента массива. Выражения вида last - N могут использоваться для относительной адресации и в определениях диапазонов, как в этом примере:

mysql> SELECT JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[last-3 to last-1]');
+--------------------------------------------------------+
| JSON_EXTRACT('[1, 2, 3, 4, 5]', '$[last-3 to last-1]') |
+--------------------------------------------------------+
| [2, 3, 4]                                              |
+--------------------------------------------------------+
1 row in set (0.01 sec)

Если путь оценивается по отношению к значению, которое не является массивом, результат оценки такой же, как если бы значение было заключено в массив из одного элемента:

mysql> SELECT JSON_REPLACE('"Sakila"', '$[last]', 10);
+-----------------------------------------+
| JSON_REPLACE('"Sakila"', '$[last]', 10) |
+-----------------------------------------+
| 10                                      |
+-----------------------------------------+
1 row in set (0.00 sec)

Вы можете использовать column->path с идентификатором столбца JSON и выражением пути JSON как синоним JSON_EXTRACT(column, path). Дополнительная информация приведена в разделе 14.17.3, «Функции поиска значений JSON». См. также Индексирование сгенерированного столбца для создания индекса столбца JSON.

Некоторые функции принимают существующий документ JSON, изменяют его каким-либо образом и возвращают результирующий измененный документ. Выражения путей указывают, где в документе нужно внести изменения. Например, функции JSON_SET(), JSON_INSERT() и JSON_REPLACE() каждая принимают документ JSON и одну или несколько пар путь-значение, описывающих место изменения документа и значения, которые нужно использовать. Функции отличаются тем, как они обрабатывают существующие и несуществующие значения в документе.

Рассмотрим этот документ:

mysql> SET @j = '["a", {"b": [true, false]}, [10, 20]]';

JSON_SET() заменяет значения для существующих путей и добавляет значения для несуществующих путей:

mysql> SELECT JSON_SET(@j, '$[1].b[0]', 1, '$[2][2]', 2);
+--------------------------------------------+
| JSON_SET(@j, '$[1].b[0]', 1, '$[2][2]', 2) |
+--------------------------------------------+
| ["a", {"b": [1, false]}, [10, 20, 2]]      |
+--------------------------------------------+

В этом случае путь $[1].b[0] выбирает существующее значение (true), которое заменяется значением, следующим за аргументом пути (1). Путь $[2][2] не существует, поэтому соответствующее значение (2) добавляется к значению, выбранному по пути $[2].

JSON_INSERT() добавляет новые значения, но не заменяет существующие значения:

mysql> SELECT JSON_INSERT(@j, '$[1].b[0]', 1, '$[2][2]', 2);
+-----------------------------------------------+
| JSON_INSERT(@j, '$[1].b[0]', 1, '$[2][2]', 2) |
+-----------------------------------------------+
| ["a", {"b": [true, false]}, [10, 20, 2]]      |
+-----------------------------------------------+

JSON_REPLACE() заменяет существующие значения и игнорирует новые значения:

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

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

JSON_REMOVE() принимает документ JSON и одну или несколько путей, указывающих значения, которые нужно удалить из документа. Возвращаемое значение — исходный документ минус значения, выбранные путями, которые существуют в документе:

mysql> SELECT JSON_REMOVE(@j, '$[2]', '$[1].b[1]', '$[1].b[1]');
+---------------------------------------------------+
| JSON_REMOVE(@j, '$[2]', '$[1].b[1]', '$[1].b[1]') |
+---------------------------------------------------+
| ["a", {"b": [true]}]                              |
+---------------------------------------------------+

Пути имеют такие эффекты:

Многие функции JSON, поддерживаемые MySQL и описанные в другом месте данного руководства (см. Раздел 14.17, «Функции JSON»), требуют выражения пути для идентификации конкретного элемента в документе JSON. Путь состоит из области действия пути, за которой следует один или несколько сегментов пути. Для путей, используемых в функциях JSON MySQL, область действия всегда является документом, по которому выполняется поиск или иные операции, представленная ведущим символом $. Сегменты пути разделены точками (.). Ячейки в массивах представлены как [N], где N — неотрицательное целое число. Имена ключей должны быть строками в двойных кавычках или допустимыми идентификаторами ECMAScript (см. Имена идентификаторов и идентификаторы в Спецификации языка ECMAScript). Выражения путей, подобно тексту JSON, должны быть закодированы с использованием набора символов ascii, utf8mb3 или utf8mb4. Другие кодировки символов неявно преобразуются в utf8mb4. Полный синтаксис показан здесь:

pathExpression:
    scope[(pathLeg)*]

pathLeg:
    member | arrayLocation | doubleAsterisk

member:
    period ( keyName | asterisk )

arrayLocation:
    leftBracket ( nonNegativeInteger | asterisk ) rightBracket

keyName:
    ESIdentifier | doubleQuotedString

doubleAsterisk:
    '**'

period:
    '.'

asterisk:
    '*'

leftBracket:
    '['

rightBracket:
    ']'

Как отмечалось ранее, в MySQL область действия пути всегда является документом, по которому выполняется операция, представленная как $. Вы можете использовать '$' в качестве синонима для документа в выражениях путей JSON.

Дикий символ * и маркер ** используются следующим образом:

Примеры синтаксиса путей см. в описаниях различных функций JSON, которые принимают пути в качестве аргументов, таких как JSON_CONTAINS_PATH(), JSON_SET() и JSON_REPLACE(). Примеры, включающие использование диких символов * и **, см. в описании функции JSON_SEARCH().

MySQL также поддерживает нотацию диапазона для подмножеств массивов JSON, используя ключевое слово to (например, $[2 to 10]), а также ключевое слово last в качестве синонима для правого крайнего элемента массива. См. Поиск и изменение значений JSON для получения дополнительной информации и примеров.

Значения JSON можно сравнивать с помощью операторов =, <, <=, >, >=, <>, != и <=>.

Следующие операторы сравнения и функции пока не поддерживаются со значениями JSON:

Обходным путём для операторов сравнения и функций, перечисленных выше, является приведение значений JSON к нативному чис­ленному или строковому типу данных MySQL, чтобы они имели кон­систентный не-JSON скалярный тип.

Сравнение значений JSON происходит на двух уровнях. Первый уровень сравнения основан на типах JSON сравниваемых значений. Если типы отличаются, результат сравнения определяется исключительно типом с более высоким приоритетом. Если два значения имеют один и тот же тип JSON, происходит сравнение на втором уровне с использованием правил, специфичных для типа.

Следующий список показывает приоритеты типов JSON, от наивысшего к наименьшему. (Имена типов — это те, которые возвращает функция JSON_TYPE()). Типы, показанные вместе в строке, имеют одинаковый приоритет. Любое значение, имеющее тип JSON, указанный раньше в списке, сравнивается больше, чем любое значение, имеющее тип JSON, указанный позже в списке.

BLOB
BIT
OPAQUE
DATETIME
TIME
DATE
BOOLEAN
ARRAY
OBJECT
STRING
INTEGER, DOUBLE
NULL

Для значений JSON с одинаковым приоритетом правила сравнения специфичны для типа:

При сравнении любого значения JSON со SQL NULL, результатом является UNKNOWN.

При сравнении значений JSON и не-JSON значений, значение не-JSON преобразуется в JSON согласно правилам в следующей таблице, затем значения сравниваются как описано ранее.

В следующей таблице представлен свод правил, которым следует MySQL при приведении типов между JSON значениями и значениями других типов:

Сортировка и GROUP BY для значений JSON работают по этим принципам:

Для сортировки может быть полезно привести скалярное значение JSON к какому-либо другому встроенному типу MySQL. Например, если столбец с именем jdoc содержит JSON объекты, имеющие член, состоящий из ключа id и неотрицательного значения, используйте это выражение для сортировки по значениям id:

ORDER BY CAST(JSON_EXTRACT(jdoc, '$.id') AS UNSIGNED)

Если определён столбец с вычисляемым значением, использующий такое же выражение, как и в ORDER BY, оптимизатор MySQL распознаёт это и рассматривает использование индекса для плана выполнения запроса. См. Раздел 10.3.11, «Использование оптимизатором индексов вычисляемых столбцов».

При агрегировании значений JSON SQL NULL значения игнорируются, как и для других типов данных. Не-NULL значения преобразуются в числовой тип и агрегируются, за исключением MIN(), MAX() и GROUP_CONCAT(). Преобразование в число должно давать осмысленный результат для JSON значений, являющихся числовыми скалярами, хотя (в зависимости от значений) может произойти усечение и потеря точности. Преобразование в число других JSON значений может не давать осмысленного результата.