• 创建 JSON 值

• JSON 值的规范化、合并和自动包装

• 搜索和修改 JSON 值

• JSON 路径语法

• JSON 值的比较和排序

• 在 JSON 和非 JSON 值之间转换

• JSON 值的聚合

MySQL 优化器还在虚拟列上查找与 JSON 表达式匹配的兼容索引。 在 MySQL 8.0.17 及更高版本中， InnoDB 存储引擎支持 JSON 数组上的多值索引。请参阅 多值索引 。 MySQL NDB Cluster 8.0 支持 JSON 列和 MySQL JSON 函数，包括在从列生成的 JSON 列上创建索引作为无法索引 JSON 列的解决方法。每个表 最多支持 3 JSON 列 。 NDB

JSON 值的部分更新

可以通过这种方式优化 JSON 单个语句 中多个列的更新； UPDATE MySQL 只能对那些使用刚刚列出的三个函数更新值的列执行部分更新。 输入列和目标列必须是同一列； UPDATE mytable SET jcol1 = JSON_SET(jcol2, '$.a', 100) 不能作为部分更新执行 只要输入列和目标列相同，更新可以以任意组合对上一项中列出的任何函数使用嵌套调用。 所有更改都用新值替换现有数组或对象值，并且不向父对象或数组添加任何新元素。 被替换的值必须至少与替换值一样大。换句话说，新值不能比旧值大。 当先前的部分更新为较大的值留下足够的空间时，可能会出现此要求的例外情况。您可以使用该函数 JSON_STORAGE_FREE() 查看列的任何部分更新释放了多少空间 JSON 。 可以使用节省空间的紧凑格式将此类部分更新写入二进制日志；这可以通过将 binlog_row_value_options 系统变量设置为来启用 PARTIAL_JSON 。

JSON 将存储在表中的列值的部分更新与将行的部分更新写入二进制日志 区分开来很重要 。可以将列的完整更新 JSON 作为部分更新记录在二进制日志中。当不满足先前列表中的最后两个条件中的一个（或两个）但满足其他条件时，可能会发生这种情况。 另请参阅 的说明 binlog_row_value_options 。 接下来的几节提供了有关 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> CREATE TABLE t1 (jdoc JSON);
Query OK, 0 rows affected (0.20 sec)
mysql> INSERT INTO t1 VALUES('{"key1": "value1", "key2": "value2"}');
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO t1 VALUES('[1, 2,');
ERROR 3140 (22032) at line 2: Invalid JSON text:
"Invalid value." at position 6 in value (or column) '[1, 2,'.

此类错误消息中“ at position ” 的 位置是从 0 开始的，但应被视为值中问题实际发生位置的粗略指示。 该 JSON_TYPE() 函数需要一个 JSON 参数并尝试将其解析为 JSON 值。如果有效则返回值的 JSON 类型，否则会产生错误：

mysql> SELECT JSON_TYPE('["a", "b", 1]');
+----------------------------+
| JSON_TYPE('["a", "b", 1]') |
+----------------------------+
| ARRAY                      |
+----------------------------+
mysql> SELECT JSON_TYPE('"hello"');
+----------------------+
| JSON_TYPE('"hello"') |
+----------------------+
| STRING               |
+----------------------+
mysql> SELECT JSON_TYPE('hello');
ERROR 3146 (22032): Invalid data type for JSON data in argument 1
to function json_type; a JSON string or JSON type is required.

utf8mb4 MySQL 使用字符集和 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 |
+-----------------------------------+

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'.

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

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

NO_BACKSLASH_ESCAPES 如果启用了服务器 SQL 模式 ，前面的示例将无法正常工作 。如果设置了此模式，则可以使用单个反斜杠而不是双反斜杠来插入 JSON 对象文字，并保留反斜杠。如果 JSON_OBJECT() 在执行插入时使用该函数并且设置了此模式，则必须交替使用单引号和双引号，如下所示：

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

JSON_UNQUOTE() 有关此模式对 JSON 值中转义字符的影响的更多信息， 请参阅函数说明 当一个字符串被解析并发现是一个有效的 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 值

合并数组。 在组合多个数组的上下文中，数组被合并为一个数组。 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"}

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

路径语法使用一个前导 $ 字符来表示所考虑的 JSON 文档，可选地后跟选择器，这些选择器依次指示文档的更具体部分： 句点后跟一个键名，用给定的键命名对象中的成员。如果不带引号的名称在路径表达式中不合法（例如，如果它包含空格），则必须在双引号内指定密钥名称。 [ N ] 附加到 path 选择数组的 a 命名数组中位置处的值 N 。数组位置是从零开始的整数。如果 path 不选择数组值， path [0] 的计算结果与 相同 path ：

mysql> SELECT JSON_SET('"x"', '$[0]', 'a');
+------------------------------+
| JSON_SET('"x"', '$[0]', 'a') |
+------------------------------+
| "a"                          |
+------------------------------+
1 row in set (0.00 sec)

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

{"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]                                                  |
+------------------------------------------------------------+

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

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)

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)

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

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]]      |
+--------------------------------------------+

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]]      |
+-----------------------------------------------+

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]]             |
+------------------------------------------------+

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

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 值转换为本机 MySQL 数字或字符串数​​据类型，以便它们具有一致的非 JSON 标量类型。
        JSON 值的比较发生在两个级别。第一级比较基于比较值的 JSON 类型。如果类型不同，则比较结果仅由具有更高优先级的类型决定。如果两个值具有相同的 JSON 类型，则使用特定于类型的规则进行第二级比较。
        以下列表显示了 JSON 类型的优先级，从最高优先级到最低优先级。（类型名称是JSON_TYPE()
        函数返回的名称。）在一行上一起显示的类型具有相同的优先级。具有列表前面列出的 JSON 类型的任何值比较大于列表中后面列出的 JSON 类型的任何值。
OPAQUE
DATETIME
BOOLEAN
ARRAY
OBJECT
STRING
INTEGER, DOUBLE
        对于相同优先级的 JSON 值，比较规则是类型特定的：
          
N比较两个值
            的第一个字节，其中N是较短值中的字节数。如果
            N两个值的第一个字节相同，则较短的值排在较长的值之前。
            与 相同的规则BLOB。
            OPAQUE
            与 相同的规则BLOB。
            OPAQUE值是未分类为其他类型之一的值。
            DATETIME
            表示较早时间点的值排在表示较晚时间点的值之前。如果两个值最初分别来自 MySQL
            DATETIME和TIMESTAMP
            类型，那么如果它们表示相同的时间点，则它们是相等的。
            两个时间值中较小的一个排在较大的之前。
            较早的日期在较新的日期之前排序。
            ARRAY
            如果两个 JSON 数组具有相同的长度并且数组中相应位置的值相等，则它们是相等的。
            如果数组不相等，则它们的顺序由第一个不同位置的元素决定。在该位置具有较小值的数组首先排序。如果较短数组的所有值都等于较长数组中的相应值，则较短数组排在第一位。
          
[] < ["a"] < ["ab"] < ["ab", "cd", "ef"] < ["ab", "ef"]

{"a": 1, "b": 2} = {"b": 2, "a": 1}

"a" < "ab" < "b" < "bc"

"A" < "a"

9223372036854775805 < 9223372036854775806 < 9223372036854775807

9223372036854775805 = 9223372036854775806 = 9223372036854775807 = 9.223372036854776e18

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