mysql json 函式-有解無憂

12.17.1 JSON函式參考
12.17.2創建JSON值的函式
12.17.3搜索JSON值的函式
12.17.4修改JSON值的函式
12.17.5回傳JSON值屬性的函式
12.17.6 JSON實用程式功能

12.17.1 JSON函式參考

表12.21 JSON函式

Name	描述
`->`	評估路徑后從JSON列回傳值；等效于JSON_EXTRACT（），
`->>` （介紹5.7.13）	評估路徑并取消參考結果后，從JSON列回傳值；等效于JSON_UNQUOTE（JSON_EXTRACT（）），
`JSON_APPEND()` （已棄用）	將資料附加到JSON檔案
`JSON_ARRAY()`	創建JSON陣列
`JSON_ARRAY_APPEND()`	將資料附加到JSON檔案
`JSON_ARRAY_INSERT()`	插入JSON陣列
`JSON_CONTAINS()`	JSON檔案是否在路徑中包含特定物件
`JSON_CONTAINS_PATH()`	JSON檔案是否在路徑中包含任何資料
`JSON_DEPTH()`	JSON檔案的最大深度
`JSON_EXTRACT()`	從JSON檔案回傳資料
`JSON_INSERT()`	將資料插入JSON檔案
`JSON_KEYS()`	JSON檔案中的鍵陣列
`JSON_LENGTH()`	JSON檔案中的元素數
`JSON_MERGE()` （不建議使用5.7.22）	合并JSON檔案，保留重復的鍵，JSON_MERGE_PRESERVE（）的已棄用同義詞
`JSON_MERGE_PATCH()` （介紹5.7.22）	合并JSON檔案，替換重復鍵的值
`JSON_MERGE_PRESERVE()` （介紹5.7.22）	合并JSON檔案，保留重復的鍵
`JSON_OBJECT()`	創建JSON物件
`JSON_PRETTY()` （介紹5.7.22）	以易于閱讀的格式列印JSON檔案
`JSON_QUOTE()`	參考JSON檔案
`JSON_REMOVE()`	從JSON檔案中洗掉資料
`JSON_REPLACE()`	替換JSON檔案中的值
`JSON_SEARCH()`	JSON檔案中值的路徑
`JSON_SET()`	將資料插入JSON檔案
`JSON_STORAGE_SIZE()` （介紹5.7.22）	用于存盤JSON檔案的二進制表示的空間
`JSON_TYPE()`	JSON值型別
`JSON_UNQUOTE()`	取消參考JSON值
`JSON_VALID()`	JSON值是否有效

MySQL 5.7.22和更高版本支持兩個聚合JSON函式 JSON_ARRAYAGG()和 JSON_OBJECTAGG()，有關這些功能的說明，請參見第12.20節“集合函式”，

同樣從MySQL 5.7.22開始：

可以使用該JSON_PRETTY()函式以易于讀取的格式對JSON值進行 “ 漂亮列印 ”，
您可以使用看到給定JSON值占用了多少存盤空間JSON_STORAGE_SIZE()，

有關這兩個函式的完整說明，請參見第12.17.6節“ JSON實用程式函式”，

12.17.2創建JSON值的函式

本節中列出的功能由組件元素組成JSON值，

JSON_ARRAY([val[, val\] ...])

評估（可能為空）值串列，并回傳包含這些值的JSON陣列，

mysql> SELECT JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME());
+---------------------------------------------+
| JSON_ARRAY(1, "abc", NULL, TRUE, CURTIME()) |
+---------------------------------------------+
| [1, "abc", null, true, "11:30:24.000000"]   |
+---------------------------------------------+

JSON_OBJECT([key, val[, key, val\] ...])

評估鍵值對的串列（可能為空），并回傳包含這些對的JSON物件，如果任何鍵名是NULL或引數個數是奇數，則會發生錯誤，

mysql> SELECT JSON_OBJECT('id', 87, 'name', 'carrot');
+-----------------------------------------+
| JSON_OBJECT('id', 87, 'name', 'carrot') |
+-----------------------------------------+
| {"id": 87, "name": "carrot"}            |
+-----------------------------------------+

JSON_QUOTE(string)

通過將字串用雙引號引起來并轉義內部引號和其他字符來將utf8mb4字串引為JSON值，然后將結果作為字串回傳，NULL如果引數為，則回傳 NULL，

此函式通常用于生成有效的JSON字串文字，以包含在JSON檔案中，

根據表12.22“ JSON_UNQUOTE（）特殊字符轉義序列”中所示的轉義序列，使用反斜杠對某些特殊字符進行轉義，

mysql> SELECT JSON_QUOTE('null'), JSON_QUOTE('"null"');
+--------------------+----------------------+
| JSON_QUOTE('null') | JSON_QUOTE('"null"') |
+--------------------+----------------------+
| "null"             | "\"null\""           |
+--------------------+----------------------+
mysql> SELECT JSON_QUOTE('[1, 2, 3]');
+-------------------------+
| JSON_QUOTE('[1, 2, 3]') |
+-------------------------+
| "[1, 2, 3]"             |
+-------------------------+

您還可以通過JSON使用將其他型別的值強制轉換為該型別來獲取JSON值，有關更多資訊，請參見在JSON和非JSON值之間轉換， CAST(value AS JSON)

提供了兩個生成JSON值的聚合函式（MySQL 5.7.22和更高版本）， JSON_ARRAYAGG()回傳結果集作為單個JSON陣列，并 JSON_OBJECTAGG()回傳結果集作為單個JSON物件，有關更多資訊，請參見第12.20節“聚合函式”，

12.17.3搜索JSON值的函式

本節中的函式對JSON值執行搜索操作，以從中提取資料，報告資料是否在其中的某個位置或報告其中的資料的路徑，

JSON_CONTAINS(target, candidate[, path\])

通過回傳1或0來指示給定的candidateJSON檔案是否包含在targetJSON檔案中，或者（如果提供了path 引數）指示是否在目標內的特定路徑上找到了候選物件，回傳 NULL是否有任何引數是 NULL，或者path引數沒有標識目標檔案的一部分，如果target或 candidate不是有效的JSON檔案，或者path引數不是有效的路徑運算式或包含 `或通配符，則會發生錯誤，

要僅檢查路徑上是否存在任何資料，請 JSON_CONTAINS_PATH()改用，

以下規則定義了圍堵：
- 當且僅當候選標量可比較且相等時，才包含在目標標量中，如果兩個標量值具有相同的JSON_TYPE()型別，則它們是可比較的，但型別的值INTEGER 和DECIMAL也可彼此比較，
- 當且僅當候選物件中的每個元素都包含在目標的某個元素中時，候選陣列才包含在目標陣列中，
- 當且僅當候選非陣列包含在目標的某個元素中時，該候選非陣列才包含在目標陣列中，
- 當且僅當候選物件中的每個關鍵字在目標中存在一個具有相同名稱的關鍵字并且與候選關鍵字相關聯的值包含在與目標關鍵字相關聯的值中時，候選物件才包含在目標物件中，
否則，候選值將不包含在目標檔案中，
```
mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SET @j2 = '1';
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.a');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.a') |
+-------------------------------+
|                             1 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.b');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.b') |
+-------------------------------+
|                             0 |
+-------------------------------+

mysql> SET @j2 = '{"d": 4}';
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.a');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.a') |
+-------------------------------+
|                             0 |
+-------------------------------+
mysql> SELECT JSON_CONTAINS(@j, @j2, '$.c');
+-------------------------------+
| JSON_CONTAINS(@j, @j2, '$.c') |
+-------------------------------+
|                             1 |
+-------------------------------+
```

JSON_CONTAINS_PATH(json_doc, one_or_all, path[, path\] ...)

回傳0或1以指示JSON檔案是否包含給定路徑中的資料，回傳NULL 是否有任何引數NULL，如果json_doc引數不是有效的JSON檔案，任何path 引數不是有效的路徑運算式，或者 one_or_all不是 'one'或，都會發生錯誤'all'，

要檢查路徑上的特定值，請 JSON_CONTAINS()改用，

如果檔案中沒有指定的路徑，則回傳值為0，否則，回傳值取決于 one_or_all引數：

'one'：如果檔案中至少存在一個路徑，則為1，否則為0，
'all'：如果檔案中存在所有路徑，則為1，否則為0，

mysql> SET @j = '{"a": 1, "b": 2, "c": {"d": 4}}';
mysql> SELECT JSON_CONTAINS_PATH(@j, 'one', '$.a', '$.e');
+---------------------------------------------+
| JSON_CONTAINS_PATH(@j, 'one', '$.a', '$.e') |
+---------------------------------------------+
|                                           1 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH(@j, 'all', '$.a', '$.e');
+---------------------------------------------+
| JSON_CONTAINS_PATH(@j, 'all', '$.a', '$.e') |
+---------------------------------------------+
|                                           0 |
+---------------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH(@j, 'one', '$.c.d');
+----------------------------------------+
| JSON_CONTAINS_PATH(@j, 'one', '$.c.d') |
+----------------------------------------+
|                                      1 |
+----------------------------------------+
mysql> SELECT JSON_CONTAINS_PATH(@j, 'one', '$.a.d');
+----------------------------------------+
| JSON_CONTAINS_PATH(@j, 'one', '$.a.d') |
+----------------------------------------+
|                                      0 |
+----------------------------------------+

JSON_EXTRACT(json_doc, path[, path\] ...)

從JSON檔案中回傳資料，該資料是從與path 引數匹配的檔案部分中選擇的，回傳NULL是否有任何引數 NULL在檔案中找到值的路徑，如果json_doc引數不是有效的JSON檔案或任何path引數不是有效的路徑運算式，則會發生錯誤，

回傳值由path引數匹配的所有值組成，如果這些引數有可能回傳多個值，則匹配的值將按照與生成它們的路徑相對應的順序自動包裝為陣列，否則，回傳值是單個匹配值，

mysql> SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]');
+--------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]') |
+--------------------------------------------+
| 20                                         |
+--------------------------------------------+
mysql> SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]');
+----------------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]', '$[0]') |
+----------------------------------------------------+
| [20, 10]                                           |
+----------------------------------------------------+
mysql> SELECT JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]');
+-----------------------------------------------+
| JSON_EXTRACT('[10, 20, [30, 40]]', '$[2][*]') |
+-----------------------------------------------+
| [30, 40]                                      |
+-----------------------------------------------+

MySQL 5.7.9和更高版本支持 -> 此函式的快捷方式，與2個引數一起使用，其中左側是 JSON列識別符號（不是運算式），右側是要在列中匹配的JSON路徑，

column->path

在MySQL 5.7.9及更高版本中，與兩個引數一起使用時，該 -> 運算子充當JSON_EXTRACT()函式的別名，兩個引數分別是左側的列識別符號和右側的JSON路徑（針對JSON檔案（列值）進行評估），您可以在SQL陳述句中的任何位置使用此類運算式代替列識別符號，

SELECT此處顯示的兩個陳述句產生相同的輸出：

mysql> SELECT c, JSON_EXTRACT(c, "$.id"), g
     > FROM jemp
     > WHERE JSON_EXTRACT(c, "$.id") > 1
     > ORDER BY JSON_EXTRACT(c, "$.name");
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set (0.00 sec)

mysql> SELECT c, c->"$.id", g
     > FROM jemp
     > WHERE c->"$.id" > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+
| c                             | c->"$.id" | g    |
+-------------------------------+-----------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 |
+-------------------------------+-----------+------+
3 rows in set (0.00 sec)

此功能不限于 SELECT，如下所示：

mysql> ALTER TABLE jemp ADD COLUMN n INT;
Query OK, 0 rows affected (0.68 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> UPDATE jemp SET n=1 WHERE c->"$.id" = "4";
Query OK, 1 row affected (0.04 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT(c, "$.id") > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "4", "name": "Betty"}  | "4"       |    4 |    1 |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
3 rows in set (0.00 sec)

mysql> DELETE FROM jemp WHERE c->"$.id" = "4";
Query OK, 1 row affected (0.04 sec)

mysql> SELECT c, c->"$.id", g, n
     > FROM jemp
     > WHERE JSON_EXTRACT(c, "$.id") > 1
     > ORDER BY c->"$.name";
+-------------------------------+-----------+------+------+
| c                             | c->"$.id" | g    | n    |
+-------------------------------+-----------+------+------+
| {"id": "3", "name": "Barney"} | "3"       |    3 | NULL |
| {"id": "2", "name": "Wilma"}  | "2"       |    2 | NULL |
+-------------------------------+-----------+------+------+
2 rows in set (0.00 sec)

（有關用于創建和填充剛剛顯示的表的陳述句，請參見索引生成的列以提供JSON列索引，）

這也適用于JSON陣列值，如下所示：

mysql> CREATE TABLE tj10 (a JSON, b INT);
Query OK, 0 rows affected (0.26 sec)

mysql> INSERT INTO tj10
     > VALUES ("[3,10,5,17,44]", 33), ("[3,10,5,17,[22,44,66]]", 0);
Query OK, 1 row affected (0.04 sec)

mysql> SELECT a->"$[4]" FROM tj10;
+--------------+
| a->"$[4]"    |
+--------------+
| 44           |
| [22, 44, 66] |
+--------------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM tj10 WHERE a->"$[0]" = 3;
+------------------------------+------+
| a                            | b    |
+------------------------------+------+
| [3, 10, 5, 17, 44]           |   33 |
| [3, 10, 5, 17, [22, 44, 66]] |    0 |
+------------------------------+------+
2 rows in set (0.00 sec)

支持嵌套陣列，使用的運算式的 ->求值就像NULL 在目標JSON檔案中找不到匹配的鍵一樣，如下所示：

mysql> SELECT * FROM tj10 WHERE a->"$[4][1]" IS NOT NULL;
+------------------------------+------+
| a                            | b    |
+------------------------------+------+
| [3, 10, 5, 17, [22, 44, 66]] |    0 |
+------------------------------+------+

mysql> SELECT a->"$[4][1]" FROM tj10;
+--------------+
| a->"$[4][1]" |
+--------------+
| NULL         |
| 44           |
+--------------+
2 rows in set (0.00 sec)

這與在使用JSON_EXTRACT()以下情況時看到的行為相同：

mysql> SELECT JSON_EXTRACT(a, "$[4][1]") FROM tj10;
+----------------------------+
| JSON_EXTRACT(a, "$[4][1]") |
+----------------------------+
| NULL                       |
| 44                         |
+----------------------------+
2 rows in set (0.00 sec)

column->>path

這是MySQL 5.7.13和更高版本中提供的一種改進的，取消參考的提取運算子，而 ->操作者簡單地提取的值時， ->>在加法運算unquotes提取結果，換句話說，給定一個 JSON列值 column和一個路徑運算式 path，以下三個運算式回傳相同的值：

JSON_UNQUOTE( JSON_EXTRACT(column, path) )
JSON_UNQUOTE(column -> path)
column->>path

->>可以JSON_UNQUOTE(JSON_EXTRACT())在允許的任何地方使用該運算子，這包括（但不限于） SELECT串列，WHERE和 HAVING條款，并ORDER BY和GROUP BY條款，

接下來的幾條陳述句演示了->>與mysql客戶端中其他運算式的一些運算子等效項：

mysql> SELECT * FROM jemp WHERE g > 2;
+-------------------------------+------+
| c                             | g    |
+-------------------------------+------+
| {"id": "3", "name": "Barney"} |    3 |
| {"id": "4", "name": "Betty"}  |    4 |
+-------------------------------+------+
2 rows in set (0.01 sec)

mysql> SELECT c->'$.name' AS name
    ->     FROM jemp WHERE g > 2;
+----------+
| name     |
+----------+
| "Barney" |
| "Betty"  |
+----------+
2 rows in set (0.00 sec)

mysql> SELECT JSON_UNQUOTE(c->'$.name') AS name
    ->     FROM jemp WHERE g > 2;
+--------+
| name   |
+--------+
| Barney |
| Betty  |
+--------+
2 rows in set (0.00 sec)

mysql> SELECT c->>'$.name' AS name
    ->     FROM jemp WHERE g > 2;
+--------+
| name   |
+--------+
| Barney |
| Betty  |
+--------+
2 rows in set (0.00 sec)

請參閱為已生成的列編制索引以提供JSON列索引，以獲取用于jemp在剛剛顯示的示例集中創建和填充表的SQL陳述句，

此運算子也可以與JSON陣列一起使用，如下所示：

mysql> CREATE TABLE tj10 (a JSON, b INT);
Query OK, 0 rows affected (0.26 sec)

mysql> INSERT INTO tj10 VALUES
    ->     ('[3,10,5,"x",44]', 33),
    ->     ('[3,10,5,17,[22,"y",66]]', 0);
Query OK, 2 rows affected (0.04 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> SELECT a->"$[3]", a->"$[4][1]" FROM tj10;
+-----------+--------------+
| a->"$[3]" | a->"$[4][1]" |
+-----------+--------------+
| "x"       | NULL         |
| 17        | "y"          |
+-----------+--------------+
2 rows in set (0.00 sec)

mysql> SELECT a->>"$[3]", a->>"$[4][1]" FROM tj10;
+------------+---------------+
| a->>"$[3]" | a->>"$[4][1]" |
+------------+---------------+
| x          | NULL          |
| 17         | y             |
+------------+---------------+
2 rows in set (0.00 sec)

與一樣 ->，->>運算子總是在的輸出中擴展EXPLAIN，如以下示例所示：

mysql> EXPLAIN SELECT c->>'$.name' AS name
    ->     FROM jemp WHERE g > 2\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: jemp
   partitions: NULL
         type: range
possible_keys: i
          key: i
      key_len: 5
          ref: NULL
         rows: 2
     filtered: 100.00
        Extra: Using where
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
  Level: Note
   Code: 1003
Message: /* select#1 */ select
json_unquote(json_extract(`jtest`.`jemp`.`c`,'$.name')) AS `name` from
`jtest`.`jemp` where (`jtest`.`jemp`.`g` > 2)
1 row in set (0.00 sec)

這類似于MySQL -> 在相同情況下擴展運算子的方式，

該->>運算子是在MySQL 5.7.13中添加的，

JSON_KEYS(json_doc[, path\])

以JSON陣列的形式回傳JSON物件的頂級值中的鍵，或者，如果提供了path 引數，則回傳所選路徑中的頂級鍵，NULL如果任何引數是 NULL，則回傳，該 json_doc引數不是物件，或者path如果給定，則不定位物件，如果json_doc引數不是有效的JSON檔案，或者path引數不是有效的路徑運算式或包含 `或通配符，則會發生錯誤，

如果所選物件為空，則結果陣列為空，如果頂級值具有嵌套的子物件，則回傳值不包含來自那些子物件的鍵，
```
mysql> SELECT JSON_KEYS('{"a": 1, "b": {"c": 30}}');
+---------------------------------------+
| JSON_KEYS('{"a": 1, "b": {"c": 30}}') |
+---------------------------------------+
| ["a", "b"]                            |
+---------------------------------------+
mysql> SELECT JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b');
+----------------------------------------------+
| JSON_KEYS('{"a": 1, "b": {"c": 30}}', '$.b') |
+----------------------------------------------+
| ["c"]                                        |
+----------------------------------------------+
```

JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path\] ...])

回傳JSON檔案中給定字串的路徑，NULL如果任何一個，或引數為 json_doc，則回傳；檔案內不存在；或找不到，如果引數不是有效的JSON檔案，任何引數不是有效的路徑運算式，不是或或不是常數運算式，都會發生錯誤， search_strpathNULLpathsearch_strjson_docpathone_or_all'one'``'all'escape_char

該one_or_all引數影響搜索，如下所示：

'one'：搜索在第一個匹配項后終止，并回傳一個路徑字串，未定義首先考慮哪個匹配，
'all'：搜索將回傳所有匹配的路徑字串，以便不包括重復的路徑，如果有多個字串，它們將自動包裝為一個陣列，陣列元素的順序是不確定的，

在search_str搜索字串引數中，%和_ 字符與LIKE 運算子的作用相同：%匹配任意數量的字符（包括零個字符），并 _精確匹配一個字符，

要在搜索字串中指定文字%或 _字符，請在其前面加上轉義字符，默認值是 \，如果 escape_char引數丟失或 NULL，否則， escape_char必須為慷訓一個字符的常量，

有關匹配和轉義字符行為的詳細資訊，請參閱的說明 LIKE在 12.7.1節，“字串比較函式和運算子”，對于轉義字符處理，與LIKE行為的區別在于，轉義字符JSON_SEARCH() 必須在編譯時而不是僅在執行時求值為常數，例如，如果 JSON_SEARCH()在準備好的陳述句中 escape_char使用并且?引數使用引數提供，則引數值在執行時可能是恒定的，但在編譯時卻不是，

mysql> SET @j = '["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]';

mysql> SELECT JSON_SEARCH(@j, 'one', 'abc');
+-------------------------------+
| JSON_SEARCH(@j, 'one', 'abc') |
+-------------------------------+
| "$[0]"                        |
+-------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', 'abc');
+-------------------------------+
| JSON_SEARCH(@j, 'all', 'abc') |
+-------------------------------+
| ["$[0]", "$[2].x"]            |
+-------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', 'ghi');
+-------------------------------+
| JSON_SEARCH(@j, 'all', 'ghi') |
+-------------------------------+
| NULL                          |
+-------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10');
+------------------------------+
| JSON_SEARCH(@j, 'all', '10') |
+------------------------------+
| "$[1][0].k"                  |
+------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$');
+-----------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$') |
+-----------------------------------------+
| "$[1][0].k"                             |
+-----------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[*]');
+--------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[*]') |
+--------------------------------------------+
| "$[1][0].k"                                |
+--------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$**.k');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$**.k') |
+---------------------------------------------+
| "$[1][0].k"                                 |
+---------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[*][0].k');
+-------------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[*][0].k') |
+-------------------------------------------------+
| "$[1][0].k"                                     |
+-------------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[1]');
+--------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[1]') |
+--------------------------------------------+
| "$[1][0].k"                                |
+--------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '10', NULL, '$[1][0]');
+-----------------------------------------------+
| JSON_SEARCH(@j, 'all', '10', NULL, '$[1][0]') |
+-----------------------------------------------+
| "$[1][0].k"                                   |
+-----------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', 'abc', NULL, '$[2]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', 'abc', NULL, '$[2]') |
+---------------------------------------------+
| "$[2].x"                                    |
+---------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%a%');
+-------------------------------+
| JSON_SEARCH(@j, 'all', '%a%') |
+-------------------------------+
| ["$[0]", "$[2].x"]            |
+-------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%b%');
+-------------------------------+
| JSON_SEARCH(@j, 'all', '%b%') |
+-------------------------------+
| ["$[0]", "$[2].x", "$[3].y"]  |
+-------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[0]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', NULL, '$[0]') |
+---------------------------------------------+
| "$[0]"                                      |
+---------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[2]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', NULL, '$[2]') |
+---------------------------------------------+
| "$[2].x"                                    |
+---------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', NULL, '$[1]');
+---------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', NULL, '$[1]') |
+---------------------------------------------+
| NULL                                        |
+---------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', '', '$[1]');
+-------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', '', '$[1]') |
+-------------------------------------------+
| NULL                                      |
+-------------------------------------------+

mysql> SELECT JSON_SEARCH(@j, 'all', '%b%', '', '$[3]');
+-------------------------------------------+
| JSON_SEARCH(@j, 'all', '%b%', '', '$[3]') |
+-------------------------------------------+
| "$[3].y"                                  |
+-------------------------------------------+

有關MySQL支持JSON的路徑語法，包括有關通配符運營規則的詳細資訊 `，并請參閱 JSON路徑語法，

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引數不是有效的路徑運算式或包含 `或通配符，則會發生錯誤，

The path-value pairs are evaluated left to right. The document produced by evaluating one pair becomes the new value against which the next pair is evaluated.

A path-value pair for an existing path in the document is ignored and does not overwrite the existing document value. A path-value pair for a nonexisting path in the document adds the value to the document if the path identifies one of these types of values:
- A member not present in an existing object. The member is added to the object and associated with the new value.
- A position past the end of an existing array. The array is extended with the new value. If the existing value is not an array, it is autowrapped as an array, then extended with the new value.
Otherwise, a path-value pair for a nonexisting path in the document is ignored and has no effect.

For a comparison of JSON_INSERT(), JSON_REPLACE(), and JSON_SET(), see the discussion of 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() 執行如下合并：

如果第一個引數不是物件，則合并的結果與將空物件與第二個引數合并的結果相同，
如果第二個引數不是物件，則合并的結果為第二個引數，
如果兩個引數都是物件，則合并結果是具有以下成員的物件：
- 第一個物件的所有成員在第二個物件中不具有具有相同鍵的對應成員，
- 第二個物件的所有成員，在第一個物件中沒有對應的鍵，并且其值不是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在seond引數中指定相同成員的值來洗掉成員，如下所示：

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() 將第二個值附加到第一個值中，

本示例比較了將兩個相同的JSON物件（每個具有一個匹配的key "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}                                         |
+----------------------------------------------------------------------------------+

此功能已在MySQL 5.7.22中添加為的同義詞 JSON_MERGE()，JSON_MERGE()現在不推薦使用該功能，并且在將來的MySQL版本中可能會洗掉該功能，

This function is similar to but differs from JSON_MERGE_PATCH() in significant respects; see JSON_MERGE_PATCH() compared with JSON_MERGE_PRESERVE(), for more information.

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

Removes data from a JSON document and returns the result. Returns NULL if any argument is NULL. An error occurs if the json_doc argument is not a valid JSON document or any path argument is not a valid path expression or is $ or contains a ` or wildcard.

該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是否有任何引數 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]}                              |
+-----------------------------------------------------+
```
JSON_SET(json_doc, path, val[, path, val\] ...)

在JSON檔案中插入或更新資料并回傳結果，NULL如果任何引數是 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)

Unquotes JSON value and returns the result as a utf8mb4 string. Returns NULL if the argument is NULL. An error occurs if the value starts and ends with double quotes but is not a valid JSON string literal.

在字串中，某些序列具有特殊含義，除非NO_BACKSLASH_ESCAPES啟用了SQL模式，每個序列都以反斜杠（\）開頭，即 轉義字符，MySQL可以識別表12.22“ JSON_UNQUOTE（）特殊字符轉義序列”中所示的轉義序列，對于所有其他轉義序列，將忽略反斜杠，即，將轉義字符解釋為好像沒有轉義，例如，\xis x，這些序列區分大小寫，例如， \b被解釋為退格，但 \B被解釋為B，

表12.22 JSON_UNQUOTE（）特殊字符轉義序列

轉義序列	序串列示的字符
`\"`	雙引號（`"`）字符
`\b`	退格字符
`\f`	換頁符
`\n`	換行符（換行符）
`\r`	回車符
`\t`	制表符
`\\`	反斜杠（`\`）字符
`\uXXXX`	Unicode值的UTF-8位元組 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                         |
+----------------------------+

12.17.5回傳JSON值屬性的函式

本節中的函式回傳JSON值的屬性，

JSON_DEPTH(json_doc)

回傳JSON檔案的最大深度，NULL如果引數為，則回傳 NULL，如果引數不是有效的JSON檔案，則會發生錯誤，

空數組，空物件或標量值的深度為1，僅包含深度1的元素的非空陣列或僅包含深度1的成員值的非空物件的深度為2，否則，JSON檔案的深度大于2，

mysql> SELECT JSON_DEPTH('{}'), JSON_DEPTH('[]'), JSON_DEPTH('true');
+------------------+------------------+--------------------+
| JSON_DEPTH('{}') | JSON_DEPTH('[]') | JSON_DEPTH('true') |
+------------------+------------------+--------------------+
|                1 |                1 |                  1 |
+------------------+------------------+--------------------+
mysql> SELECT JSON_DEPTH('[10, 20]'), JSON_DEPTH('[[], {}]');
+------------------------+------------------------+
| JSON_DEPTH('[10, 20]') | JSON_DEPTH('[[], {}]') |
+------------------------+------------------------+
|                      2 |                      2 |
+------------------------+------------------------+
mysql> SELECT JSON_DEPTH('[10, {"a": 20}]');
+-------------------------------+
| JSON_DEPTH('[10, {"a": 20}]') |
+-------------------------------+
|                             3 |
+-------------------------------+

JSON_LENGTH(json_doc[, path\])

回傳JSON檔案的長度，或者，如果提供了path引數，則回傳由路徑標識的檔案中值的長度，回傳NULL是否有任何自變數 NULL或自path 變數不能標識檔案中的值，如果json_doc引數不是有效的JSON檔案，或者 path引數不是有效的路徑運算式或包含`或通配符，則會發生錯誤，

檔案長度確定如下：

標量的長度為1，
陣列的長度是陣列元素的數量，
物件的長度是物件成員的數量，
該長度不計算嵌套陣列或物件的長度，

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

JSON_TYPE(json_val)

回傳utf8mb4指示JSON值型別的字串，可以是物件，陣列或標量型別，如下所示：

mysql> SET @j = '{"a": [10, true]}';
mysql> SELECT JSON_TYPE(@j);
+---------------+
| JSON_TYPE(@j) |
+---------------+
| OBJECT        |
+---------------+
mysql> SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a'));
+------------------------------------+
| JSON_TYPE(JSON_EXTRACT(@j, '$.a')) |
+------------------------------------+
| ARRAY                              |
+------------------------------------+
mysql> SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a[0]'));
+---------------------------------------+
| JSON_TYPE(JSON_EXTRACT(@j, '$.a[0]')) |
+---------------------------------------+
| INTEGER                               |
+---------------------------------------+
mysql> SELECT JSON_TYPE(JSON_EXTRACT(@j, '$.a[1]'));
+---------------------------------------+
| JSON_TYPE(JSON_EXTRACT(@j, '$.a[1]')) |
+---------------------------------------+
| BOOLEAN                               |
+---------------------------------------+

JSON_TYPE()回傳 NULL引數是否為 NULL：

mysql> SELECT JSON_TYPE(NULL);
+-----------------+
| JSON_TYPE(NULL) |
+-----------------+
| NULL            |
+-----------------+

如果引數不是有效的JSON值，則會發生錯誤：

mysql> SELECT JSON_TYPE(1);
ERROR 3146 (22032): Invalid data type for JSON data in argument 1
to function json_type; a JSON string or JSON type is required.

對于NULL非錯誤結果，以下串列描述了可能的 JSON_TYPE()回傳值：

純JSON型別：
- OBJECT：JSON物件
- ARRAY：JSON陣列
- BOOLEAN：JSON正確和錯誤文字
- NULL：JSON空文字
數值型別：
- INTEGER：MySQL的 TINYINT， SMALLINT， MEDIUMINT和 INT和 BIGINT標量
- DOUBLE：MySQL 標量 DOUBLE FLOAT
- DECIMAL：MySQL DECIMAL和 NUMERIC標量
時間型別：
- DATETIME：MySQL DATETIME和 TIMESTAMP標量
- DATE：MySQL DATE標量
- TIME：MySQL TIME標量
字串型別：
- STRING：MySQL的 utf8字符型別標量： CHAR， VARCHAR， TEXT， ENUM，和 SET
二進制型別：
- BLOB：MySQL二進制型別標量： BINARY， VARBINARY， BLOB
- BIT：MySQL BIT標量
所有其他型別：
- OPAQUE （原始位）

JSON_VALID(val)

回傳0或1以指示值是否有效JSON，NULL如果引數為，則回傳NULL，

mysql> SELECT JSON_VALID('{"a": 1}');
+------------------------+
| JSON_VALID('{"a": 1}') |
+------------------------+
|                      1 |
+------------------------+
mysql> SELECT JSON_VALID('hello'), JSON_VALID('"hello"');
+---------------------+-----------------------+
| JSON_VALID('hello') | JSON_VALID('"hello"') |
+---------------------+-----------------------+
|                   0 |                     1 |
+---------------------+-----------------------+

12.17.6 JSON實用程式功能

本節介紹了作用于JSON值的實用程式函式，或可以決議為JSON值的字串， JSON_PRETTY()以易于閱讀的格式輸出JSON值， JSON_STORAGE_SIZE()顯示給定JSON值使用的存盤空間量，

JSON_PRETTY(json_val)

提供漂亮的JSON值列印，類似于用PHP以及其他語言和資料庫系統實作的JSON值，提供的值必須是JSON值或JSON值的有效字串表示形式，此值中存在多余的空格和換行符對輸出沒有影響，對于NULL值，函式回傳NULL，如果該值不是JSON檔案，或者無法將其決議為一個檔案，則該函式將失敗并顯示錯誤，

此函式的輸出格式遵循以下規則：

每個陣列元素或物件成員都顯示在單獨的行上，與其父級相比縮進了一個附加級別，
每個縮進級別都會添加兩個前導空格，
在分隔兩個元素或成員的換行符之前，將逗號分隔單個陣列元素或物件成員列印出來，
物件成員的鍵和值用冒號分隔，后跟一個空格（' : '），
空物件或陣列將列印在一行上，左括號和右括號之間沒有印刷空間，
字串標量和鍵名中的特殊字符使用該JSON_QUOTE()函式使用的相同規則進行轉義，

mysql> SELECT JSON_PRETTY('123'); # scalar
+--------------------+
| JSON_PRETTY('123') |
+--------------------+
| 123                |
+--------------------+

mysql> SELECT JSON_PRETTY("[1,3,5]"); # array
+------------------------+
| JSON_PRETTY("[1,3,5]") |
+------------------------+
| [
  1,
  3,
  5
]      |
+------------------------+

mysql> SELECT JSON_PRETTY('{"a":"10","b":"15","x":"25"}'); # object
+---------------------------------------------+
| JSON_PRETTY('{"a":"10","b":"15","x":"25"}') |
+---------------------------------------------+
| {
  "a": "10",
  "b": "15",
  "x": "25"
}   |
+---------------------------------------------+

mysql> SELECT JSON_PRETTY('["a",1,{"key1":
     >    "value1"},"5",     "77" ,
     >       {"key2":["value3","valueX",
     > "valueY"]},"j", "2"   ]')\G  # nested arrays and objects
*************************** 1. row ***************************
JSON_PRETTY('["a",1,{"key1":
             "value1"},"5",     "77" ,
                {"key2":["value3","valuex",
          "valuey"]},"j", "2"   ]'): [
  "a",
  1,
  {
    "key1": "value1"
  },
  "5",
  "77",
  {
    "key2": [
      "value3",
      "valuex",
      "valuey"
    ]
  },
  "j",
  "2"
]

在MySQL 5.7.22中添加，

JSON_STORAGE_SIZE(json_val)

此函式回傳用于存盤JSON檔案的二進制表示形式的位元組數，當引數為JSON列時，這是用于存盤JSON檔案的空間，json_val 必須是有效的JSON檔案或可以決議為一個字串，如果是字串，該函式將通過將字串決議為JSON并將其轉換為二進制來創建的JSON二進制表示形式回傳存盤空間量，NULL如果引數為，則回傳NULL，

當json_val不是NULL，并且不是或無法成功決議為JSON檔案時，將導致錯誤，

為了說明此函式在以JSON列作為引數時的行為，我們創建了一個jtable包含 JSON列jcol的表，在表中插入JSON值，然后使用來獲得該列使用的存盤空間 JSON_STORAGE_SIZE()，如下所示：

mysql> CREATE TABLE jtable (jcol JSON);
Query OK, 0 rows affected (0.42 sec)

mysql> INSERT INTO jtable VALUES
    ->     ('{"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"}');
Query OK, 1 row affected (0.04 sec)

mysql> SELECT
    ->     jcol,
    ->     JSON_STORAGE_SIZE(jcol) AS Size
    -> FROM jtable;
+-----------------------------------------------+------+
| jcol                                          | Size |
+-----------------------------------------------+------+
| {"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"} |   47 |
+-----------------------------------------------+------+
1 row in set (0.00 sec)

根據的輸出 JSON_STORAGE_SIZE()，插入到列中的JSON檔案占用47個位元組，更新后，該函式將顯示用于新設定值的存盤：

mysql> UPDATE jtable
mysql>     SET jcol = '{"a": 4.55, "b": "wxyz", "c": "[true, false]"}';
Query OK, 1 row affected (0.04 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT
    ->     jcol,
    ->     JSON_STORAGE_SIZE(jcol) AS Size
    -> FROM jtable;
+------------------------------------------------+------+
| jcol                                           | Size |
+------------------------------------------------+------+
| {"a": 4.55, "b": "wxyz", "c": "[true, false]"} |   56 |
+------------------------------------------------+------+
1 row in set (0.00 sec)

此函式還顯示當前用于在用戶變數中存盤JSON檔案的空間：

mysql> SET @j = '[100, "sakila", [1, 3, 5], 425.05]';
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
+------------------------------------+------+
| @j                                 | Size |
+------------------------------------+------+
| [100, "sakila", [1, 3, 5], 425.05] |   45 |
+------------------------------------+------+
1 row in set (0.00 sec)

mysql> SET @j = JSON_SET(@j, '$[1]', "json");
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
+----------------------------------+------+
| @j                               | Size |
+----------------------------------+------+
| [100, "json", [1, 3, 5], 425.05] |   43 |
+----------------------------------+------+
1 row in set (0.00 sec)

mysql> SET @j = JSON_SET(@j, '$[2][0]', JSON_ARRAY(10, 20, 30));
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @j, JSON_STORAGE_SIZE(@j) AS Size;
+---------------------------------------------+------+
| @j                                          | Size |
+---------------------------------------------+------+
| [100, "json", [[10, 20, 30], 3, 5], 425.05] |   56 |
+---------------------------------------------+------+
1 row in set (0.00 sec)

對于JSON文字，此函式還回傳當前使用的存盤空間，如下所示：

mysql> SELECT
    ->     JSON_STORAGE_SIZE('[100, "sakila", [1, 3, 5], 425.05]') AS A,
    ->     JSON_STORAGE_SIZE('{"a": 1000, "b": "a", "c": "[1, 3, 5, 7]"}') AS B,
    ->     JSON_STORAGE_SIZE('{"a": 1000, "b": "wxyz", "c": "[1, 3, 5, 7]"}') AS C,
    ->     JSON_STORAGE_SIZE('[100, "json", [[10, 20, 30], 3, 5], 425.05]') AS D;
+----+----+----+----+
| A  | B  | C  | D  |
+----+----+----+----+
| 45 | 44 | 47 | 56 |
+----+----+----+----+
1 row in set (0.00 sec)

此功能已在MySQL 5.7.22中添加，

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/8672.html

標籤：MySQL

上一篇：遇見SQL（2)

下一篇：遇見SQL（3）