MySQL 8.4 发行说明
本节中的函数对 JSON 值执行搜索或比较操作，以从中提取数据，报告数据是否存在于其中的某个位置，或报告数据在其中的路径。MEMBER OF() 运算符也在此记录。
JSON_CONTAINS(target,candidate[,path])通过返回 1 或 0 来指示给定的
candidateJSON 文档是否包含在targetJSON 文档中，或者（如果提供了path参数）候选文档是否位于目标文档中的特定路径。如果任何参数为NULL，或者路径参数没有标识目标文档的一部分，则返回NULL。如果target或candidate不是有效的 JSON 文档，或者path参数不是有效的路径表达式或包含*或**通配符，则会发生错误。要仅检查路径是否存在任何数据，请改用
JSON_CONTAINS_PATH()。以下规则定义了包含关系
当且仅当候选标量与目标标量可比较且相等时，候选标量才包含在目标标量中。如果两个标量值具有相同的
JSON_TYPE()类型，则它们是可比较的，但类型为INTEGER和DECIMAL的值也可以相互比较。当且仅当候选数组中的每个元素都包含在目标数组的某个元素中时，候选数组才包含在目标数组中。
当且仅当候选非数组包含在目标数组的某个元素中时，候选非数组才包含在目标数组中。
当且仅当候选对象中的每个键在目标对象中都有一个同名键，并且与候选键关联的值包含在与目标键关联的值中时，候选对象才包含在目标对象中。
否则，候选值不包含在目标文档中。
可以使用多值索引优化对
InnoDB表使用JSON_CONTAINS()的查询；有关更多信息，请参阅 多值索引。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 支持
->运算符作为此函数的简写形式，该函数与 2 个参数一起使用，其中左侧是JSON列标识符（而不是表达式），右侧是要在列中匹配的 JSON 路径。->运算符在与两个参数一起使用时充当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)支持嵌套数组。如果在目标 JSON 文档中未找到匹配的键，则使用
->的表达式将被计算为NULL，如下所示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)这是一个改进的、取消引号的提取运算符。
->运算符仅提取值，而->>运算符还会取消对提取结果的引用。换句话说，给定一个JSON列值列和一个路径表达式路径（字符串字面量），以下三个表达式返回相同的值JSON_UNQUOTE(列->路径)列->>路径
->>运算符可以在允许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)有关用于在刚刚显示的一组示例中创建和填充
jemp表的 SQL 语句，请参见 索引生成列以提供 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,"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 在相同情况下如何扩展
->运算符。从 JSON 对象的顶级值返回键作为 JSON 数组，或者，如果给定了
路径参数，则返回所选路径中的顶级键。如果任何参数为NULL，json_doc参数不是对象，或者路径（如果给定）未定位到对象，则返回NULL。如果json_doc参数不是有效的 JSON 文档，或者路径参数不是有效的路径表达式或包含*或**通配符，则会发生错误。如果所选对象为空，则结果数组为空。如果顶级值具有嵌套的子对象，则返回值不包括来自这些子对象的键。
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_OVERLAPS(json_doc1,json_doc2)比较两个 JSON 文档。如果两个文档有任何共同的键值对或数组元素，则返回 true (1)。如果两个参数都是标量，则该函数执行简单的相等测试。如果任一参数为
NULL，则该函数返回NULL。此函数用作
JSON_CONTAINS()的对应函数，后者要求搜索数组的所有元素都存在于被搜索数组中。因此，JSON_CONTAINS()对搜索键执行AND运算，而JSON_OVERLAPS()执行OR运算。在
WHERE子句中使用JSON_OVERLAPS()对InnoDB表的 JSON 列的查询可以使用多值索引进行优化。 多值索引 提供了详细信息和示例。比较两个数组时，如果它们共享一个或多个数组元素，则
JSON_OVERLAPS()返回 true，否则返回 falsemysql> SELECT JSON_OVERLAPS("[1,3,5,7]", "[2,5,7]"); +---------------------------------------+ | JSON_OVERLAPS("[1,3,5,7]", "[2,5,7]") | +---------------------------------------+ | 1 | +---------------------------------------+ 1 row in set (0.00 sec) mysql> SELECT JSON_OVERLAPS("[1,3,5,7]", "[2,6,7]"); +---------------------------------------+ | JSON_OVERLAPS("[1,3,5,7]", "[2,6,7]") | +---------------------------------------+ | 1 | +---------------------------------------+ 1 row in set (0.00 sec) mysql> SELECT JSON_OVERLAPS("[1,3,5,7]", "[2,6,8]"); +---------------------------------------+ | JSON_OVERLAPS("[1,3,5,7]", "[2,6,8]") | +---------------------------------------+ | 0 | +---------------------------------------+ 1 row in set (0.00 sec)部分匹配被视为不匹配，如下所示
mysql> SELECT JSON_OVERLAPS('[[1,2],[3,4],5]', '[1,[2,3],[4,5]]'); +-----------------------------------------------------+ | JSON_OVERLAPS('[[1,2],[3,4],5]', '[1,[2,3],[4,5]]') | +-----------------------------------------------------+ | 0 | +-----------------------------------------------------+ 1 row in set (0.00 sec)比较对象时，如果它们至少有一个共同的键值对，则结果为 true。
mysql> SELECT JSON_OVERLAPS('{"a":1,"b":10,"d":10}', '{"c":1,"e":10,"f":1,"d":10}'); +-----------------------------------------------------------------------+ | JSON_OVERLAPS('{"a":1,"b":10,"d":10}', '{"c":1,"e":10,"f":1,"d":10}') | +-----------------------------------------------------------------------+ | 1 | +-----------------------------------------------------------------------+ 1 row in set (0.00 sec) mysql> SELECT JSON_OVERLAPS('{"a":1,"b":10,"d":10}', '{"a":5,"e":10,"f":1,"d":20}'); +-----------------------------------------------------------------------+ | JSON_OVERLAPS('{"a":1,"b":10,"d":10}', '{"a":5,"e":10,"f":1,"d":20}') | +-----------------------------------------------------------------------+ | 0 | +-----------------------------------------------------------------------+ 1 row in set (0.00 sec)如果两个标量用作函数的参数，则
JSON_OVERLAPS()执行简单的相等测试mysql> SELECT JSON_OVERLAPS('5', '5'); +-------------------------+ | JSON_OVERLAPS('5', '5') | +-------------------------+ | 1 | +-------------------------+ 1 row in set (0.00 sec) mysql> SELECT JSON_OVERLAPS('5', '6'); +-------------------------+ | JSON_OVERLAPS('5', '6') | +-------------------------+ | 0 | +-------------------------+ 1 row in set (0.00 sec)将标量与数组进行比较时，
JSON_OVERLAPS()尝试将标量视为数组元素。在此示例中，第二个参数6被解释为[6]，如下所示mysql> SELECT JSON_OVERLAPS('[4,5,6,7]', '6'); +---------------------------------+ | JSON_OVERLAPS('[4,5,6,7]', '6') | +---------------------------------+ | 1 | +---------------------------------+ 1 row in set (0.00 sec)该函数不执行类型转换
mysql> SELECT JSON_OVERLAPS('[4,5,"6",7]', '6'); +-----------------------------------+ | JSON_OVERLAPS('[4,5,"6",7]', '6') | +-----------------------------------+ | 0 | +-----------------------------------+ 1 row in set (0.00 sec) mysql> SELECT JSON_OVERLAPS('[4,5,6,7]', '"6"'); +-----------------------------------+ | JSON_OVERLAPS('[4,5,6,7]', '"6"') | +-----------------------------------+ | 0 | +-----------------------------------+ 1 row in set (0.00 sec)JSON_SEARCH(json_doc,one_or_all,search_str[,escape_char[,路径] ...])返回 JSON 文档中给定字符串的路径。如果任何
json_doc、search_str或路径参数为NULL，则返回NULL；文档中不存在路径；或者未找到search_str。如果json_doc参数不是有效的 JSON 文档，任何路径参数不是有效的路径表达式，one_or_all不是'one'或'all'，或者escape_char不是常量表达式，则会发生错误。one_or_all参数按如下方式影响搜索'one'：搜索在第一次匹配后终止，并返回一个路径字符串。未定义哪个匹配被视为第一个匹配。'all'：搜索返回所有匹配的路径字符串，以便不包含重复的路径。如果有多个字符串，则它们将自动包装为数组。数组元素的顺序未定义。
在
search_str搜索字符串参数中，%和_字符的作用与LIKE运算符相同：%匹配任意数量的字符（包括零个字符），_匹配一个字符。要在搜索字符串中指定文字
%或_字符，请在其前面加上转义字符。如果escape_char参数缺失或为NULL，则默认为\。否则，escape_char必须是一个为空或一个字符的常量。有关匹配和转义字符行为的更多信息，请参见 第 14.8.1 节“字符串比较函数和运算符” 中对
LIKE的描述。对于转义字符处理，与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 路径语法。从 JSON 文档中指定路径处提取值，并返回提取的值，可以选择将其转换为所需的类型。完整的语法如下所示
JSON_VALUE(json_doc, path [RETURNING type] [on_empty] [on_error]) on_empty: {NULL | ERROR | DEFAULT value} ON EMPTY on_error: {NULL | ERROR | DEFAULT value} ON ERRORjson_doc是一个有效的 JSON 文档。如果这是NULL，则该函数返回NULL。路径是指向文档中某个位置的 JSON 路径。这必须是一个字符串字面量值。类型是以下数据类型之一上面列出的类型与
CAST()函数支持的（非数组）类型相同。如果没有由
RETURNING子句指定，则JSON_VALUE()函数的返回类型为VARCHAR(512)。当没有为返回类型指定字符集时，JSON_VALUE()使用带有二进制排序规则的utf8mb4，这是区分大小写的；如果为结果指定了utf8mb4作为字符集，则服务器使用此字符集的默认排序规则，该规则不区分大小写。当指定路径处的数据包含或解析为 JSON 空值时，该函数返回 SQL
NULL。on_empty（如果指定）确定在给定路径下未找到数据时JSON_VALUE()的行为方式；此子句采用以下值之一NULL ON EMPTY：该函数返回NULL；这是默认的ON EMPTY行为。DEFAULT：返回提供的值ON EMPTY值。值的类型必须与返回类型匹配。ERROR ON EMPTY：该函数抛出错误。
on_error（如果使用）采用以下值之一，并在发生错误时产生相应的输出，如下所示NULL ON ERROR：JSON_VALUE()返回NULL；如果没有使用ON ERROR子句，则这是默认行为。DEFAULT：这是返回的值；其值必须与返回类型匹配。值ON ERRORERROR ON ERROR：抛出错误。
ON EMPTY（如果使用）必须在任何ON ERROR子句之前。以错误的顺序指定它们会导致语法错误。错误处理。 通常，
JSON_VALUE()如下处理错误检查所有 JSON 输入（文档和路径）的有效性。如果其中任何一个无效，则会抛出 SQL 错误，而不会触发
ON ERROR子句。每当发生以下任何事件时，都会触发
ON ERROR尝试提取对象或数组，例如由解析为 JSON 文档中多个位置的路径产生的对象或数组
转换错误，例如尝试将
'asdf'转换为UNSIGNED值值截断
即使指定了
NULL ON ERROR或DEFAULT ... ON ERROR，转换错误始终会触发警告。当源 JSON 文档 (
expr) 在指定位置 (path) 不包含任何数据时，将触发ON EMPTY子句。
**示例。** 此处显示了两个简单示例
mysql> SELECT JSON_VALUE('{"fname": "Joe", "lname": "Palmer"}', '$.fname'); +--------------------------------------------------------------+ | JSON_VALUE('{"fname": "Joe", "lname": "Palmer"}', '$.fname') | +--------------------------------------------------------------+ | Joe | +--------------------------------------------------------------+ mysql> SELECT JSON_VALUE('{"item": "shoes", "price": "49.95"}', '$.price' -> RETURNING DECIMAL(4,2)) AS price; +-------+ | price | +-------+ | 49.95 | +-------+语句
SELECT JSON_VALUE(等效于以下语句json_doc,pathRETURNINGtype)SELECT CAST( JSON_UNQUOTE( JSON_EXTRACT(json_doc, path) ) AS type );JSON_VALUE()通过在许多情况下无需创建生成列然后在生成列上创建索引，从而简化了在 JSON 列上创建索引的过程。您可以在创建具有JSON列的表t1时执行此操作，方法是在使用JSON_VALUE()对该列进行操作的表达式（路径与该列中的值匹配）上创建索引，如下所示CREATE TABLE t1( j JSON, INDEX i1 ( (JSON_VALUE(j, '$.id' RETURNING UNSIGNED)) ) );以下
EXPLAIN输出显示，对t1的查询在WHERE子句中使用索引表达式时，将使用由此创建的索引mysql> EXPLAIN SELECT * FROM t1 -> WHERE JSON_VALUE(j, '$.id' RETURNING UNSIGNED) = 123\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: t1 partitions: NULL type: ref possible_keys: i1 key: i1 key_len: 9 ref: const rows: 1 filtered: 100.00 Extra: NULL这与创建具有生成列索引的表
t2具有相同的效果（请参阅 索引生成列以提供 JSON 列索引），如下所示CREATE TABLE t2 ( j JSON, g INT GENERATED ALWAYS AS (j->"$.id"), INDEX i1 (g) );针对此表引用生成列的查询的
EXPLAIN输出显示，索引的使用方式与先前针对表t1的查询相同mysql> EXPLAIN SELECT * FROM t2 WHERE g = 123\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: t2 partitions: NULL type: ref possible_keys: i1 key: i1 key_len: 5 ref: const rows: 1 filtered: 100.00 Extra: NULL有关对生成列使用索引以间接索引
JSON列的信息，请参阅 索引生成列以提供 JSON 列索引。如果
value是json_array的元素，则返回 true (1)，否则返回 false (0)。value必须是标量或 JSON 文档；如果它是标量，则运算符会尝试将其视为 JSON 数组的元素。如果value或json_array是NULL，则函数返回NULL。可以使用多值索引优化在
WHERE子句中对InnoDB表的 JSON 列使用MEMBER OF()的查询。有关详细信息和示例，请参阅 多值索引。简单标量被视为数组值，如下所示
mysql> SELECT 17 MEMBER OF('[23, "abc", 17, "ab", 10]'); +-------------------------------------------+ | 17 MEMBER OF('[23, "abc", 17, "ab", 10]') | +-------------------------------------------+ | 1 | +-------------------------------------------+ 1 row in set (0.00 sec) mysql> SELECT 'ab' MEMBER OF('[23, "abc", 17, "ab", 10]'); +---------------------------------------------+ | 'ab' MEMBER OF('[23, "abc", 17, "ab", 10]') | +---------------------------------------------+ | 1 | +---------------------------------------------+ 1 row in set (0.00 sec)数组元素值的的部分匹配不匹配
mysql> SELECT 7 MEMBER OF('[23, "abc", 17, "ab", 10]'); +------------------------------------------+ | 7 MEMBER OF('[23, "abc", 17, "ab", 10]') | +------------------------------------------+ | 0 | +------------------------------------------+ 1 row in set (0.00 sec)mysql> SELECT 'a' MEMBER OF('[23, "abc", 17, "ab", 10]'); +--------------------------------------------+ | 'a' MEMBER OF('[23, "abc", 17, "ab", 10]') | +--------------------------------------------+ | 0 | +--------------------------------------------+ 1 row in set (0.00 sec)不执行与字符串类型之间的转换
mysql> SELECT -> 17 MEMBER OF('[23, "abc", "17", "ab", 10]'), -> "17" MEMBER OF('[23, "abc", 17, "ab", 10]')\G *************************** 1. row *************************** 17 MEMBER OF('[23, "abc", "17", "ab", 10]'): 0 "17" MEMBER OF('[23, "abc", 17, "ab", 10]'): 0 1 row in set (0.00 sec)要将此运算符与本身是数组的值一起使用，必须将其显式转换为 JSON 数组。您可以使用
CAST(... AS JSON)来完成此操作mysql> SELECT CAST('[4,5]' AS JSON) MEMBER OF('[[3,4],[4,5]]'); +--------------------------------------------------+ | CAST('[4,5]' AS JSON) MEMBER OF('[[3,4],[4,5]]') | +--------------------------------------------------+ | 1 | +--------------------------------------------------+ 1 row in set (0.00 sec)也可以使用
JSON_ARRAY()函数执行必要的转换，如下所示mysql> SELECT JSON_ARRAY(4,5) MEMBER OF('[[3,4],[4,5]]'); +--------------------------------------------+ | JSON_ARRAY(4,5) MEMBER OF('[[3,4],[4,5]]') | +--------------------------------------------+ | 1 | +--------------------------------------------+ 1 row in set (0.00 sec)任何用作要测试的值或出现在目标数组中的 JSON 对象都必须使用
CAST(... AS JSON)或JSON_OBJECT()强制转换为正确的类型。此外，包含 JSON 对象的目标数组本身必须使用JSON_ARRAY进行转换。以下语句序列演示了这一点mysql> SET @a = CAST('{"a":1}' AS JSON); Query OK, 0 rows affected (0.00 sec) mysql> SET @b = JSON_OBJECT("b", 2); Query OK, 0 rows affected (0.00 sec) mysql> SET @c = JSON_ARRAY(17, @b, "abc", @a, 23); Query OK, 0 rows affected (0.00 sec) mysql> SELECT @a MEMBER OF(@c), @b MEMBER OF(@c); +------------------+------------------+ | @a MEMBER OF(@c) | @b MEMBER OF(@c) | +------------------+------------------+ | 1 | 1 | +------------------+------------------+ 1 row in set (0.00 sec)