JSON 数组包含以逗号分隔并包含在[和] 字符中的值列表：

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

一个 JSON 对象包含一组以逗号分隔并包含在{和 }字符中的键值对：

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

如示例所示，JSON 数组和对象可以包含标量值（字符串或数字）、JSON 空文字或 JSON 布尔值 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]}

您还可以从 MySQL 为此目的提供的许多函数中获取 JSON 值（请参阅 第 12.18.2 节，“创建 JSON 值的函数”）以及通过将其他类型的值转换为JSON使用的类型 （请参阅 在 JSON 之间转换和非 JSON 值）。接下来的几段描述了 MySQL 如何处理作为输入提供的 JSON 值。 CAST(value AS JSON)

在 MySQL 中，JSON 值被写为字符串。MySQL 解析在需要 JSON 值的上下文中使用的任何字符串，如果它作为 JSON 无效则产生错误。这些上下文包括将值插入具有 JSON数据类型的列并将参数传递给需要 JSON 值的函数（通常在 MySQL JSON 函数的文档中显示为 json_doc或 json_val），如以下示例所示：

utf8mb4MySQL 使用字符集和 utf8mb4_bin排序 规则处理 JSON 上下文中使用的 字符串。其他字符集中的字符串根据需要转换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 8.0.3 及更高版本也支持 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 对象插入到使用此处所示的 SQL 语句创建的表中，这些对象包含表示陈述有关 MySQL 的一些事实的句子的字符串，每个对象都与适当的关键字配对：

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\"."} |
+---------------------------------------------------------+

要查找此特定句子 employing mascot作为键，您可以使用列路径运算符 ->，如下所示：

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

这使反斜杠以及周围的引号保持不变。要使用 as key 显示所需的值 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]} |
+------------------+

这种“ last duplicate key wins ”行为由 RFC 7159建议并由大多数 JavaScript 解析器实现。（缺陷 #86866，缺陷 #26369555）

在 8.0.3 之前的 MySQL 版本中，具有与文档中较早发现的键重复的键的成员将被丢弃。以下 JSON_OBJECT()调用生成的对象值不包括第二个key1元素，因为该键名出现在值的前面：

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

在 MySQL 8.0.3 之前，在将值插入 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": 17} |
| {"x": 17} |
+-----------+

,MySQL 还会丢弃原始 JSON 文档中键、值或元素之间的额外空格，并在显示时在每个逗号 ( ) 或冒号 ( ) 后留下（或在必要时插入）一个空格:。这样做是为了增强可读性。

生成 JSON 值的 MySQL 函数（参见 第 12.18.2 节，“创建 JSON 值的函数”）总是返回规范化的值。

为了提高查找效率，MySQL 还对 JSON 对象的键进行排序。您应该知道，此排序的结果可能会发生变化，并且不能保证在不同版本之间保持一致。

合并 JSON 值

MySQL 8.0.3（及更高版本）支持两种合并算法，由函数 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 文档的函数很有用，以指定在该文档中进行操作的位置。例如，以下查询从 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)

语法是, 其中 和 分别是 JSON 数组中一系列元素的第一个和最后一个索引。必须大于； 必须大于或等于 0。数组元素的索引从 0 开始。 M to NMNNMM

您可以在支持通配符的上下文中使用范围。

最右边的数组元素。  支持该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)

您可以使用 JSON 列标识符和 JSON 路径表达式作为 . 有关详细信息，请参阅 第 12.18.3 节，“搜索 JSON 值的函数”。另请参阅索引生成的列以提供 JSON 列索引。 column->pathJSON_EXTRACT(column, path)

一些函数采用现有的 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]}]                              |
+---------------------------------------------------+

这些路径具有以下效果：

MySQL 支持并在本手册其他地方描述的许多 JSON 函数（请参阅第 12.18 节，“JSON 函数”）需要路径表达式才能标识 JSON 文档中的特定元素。路径由路径的范围和后跟一个或多个路径分支组成。对于 MySQL JSON 函数中使用的路径，范围始终是正在搜索或以其他方式操作的文档，由前导 $字符表示。路径腿由句点字符 ( .) 分隔。数组中的单元格由 表示 ，其中 是一个非负整数。键的名称必须是双引号字符串或有效的 ECMAScript 标识符（请参阅 [N]N标识符名称和标识符，在 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()函数说明。

toMySQL 8.0 还支持使用关键字（例如 ） 对 JSON 数组的子集进行范围表示法$[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 值与 SQLNULL的比较，结果是UNKNOWN.

为了比较 JSON 和非 JSON 值，根据下表中的规则将非 JSON 值转换为 JSON，然后按前面所述比较值。

下表总结了 MySQL 在 JSON 值和其他类型的值之间进行转换时遵循的规则：

ORDER BY对于 JSON 值，GROUP BY根据以下原则工作：

对于排序，将 JSON 标量转换为其他一些本机 MySQL 类型可能是有益的。例如，如果名为的列 jdoc包含 JSON 对象，该对象的成员由一个id键和一个非负值组成，请使用此表达式按id 值排序：

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

如果碰巧有一个生成的列定义为使用与 中相同的表达式ORDER BY，则 MySQL 优化器会识别并考虑将索引用于查询执行计划。请参阅 第 8.3.11 节，“生成列索引的优化器使用”。

对于 JSON 值的聚合，NULL 对于其他数据类型，SQL 值将被忽略。非NULL值将转换为数字类型并聚合，但 MIN()、 MAX()和 除外GROUP_CONCAT()。转换为数字应该为作为数字标量的 JSON 值产生有意义的结果，尽管（取决于值）可能会发生截断和精度损失。转换为其他 JSON 值的数量可能不会产生有意义的结果。