JSON_CONTAINS (目标，候选人[，路径]）

通过返回1或0表示是否给定候选人JSON文档包含在目标JSON文档，或者如果a路径参数—是否在目标内的特定路径上找到候选对象。返回零如果任何参数是零，或者如果path参数没有标识目标文档的某个部分。如果出现以下情况，则会出现错误目标或候选人不是有效的JSON文档，或者路径参数不是有效的路径表达式或包含＊或**通配符。

若要仅检查路径上是否存在任何数据，请使用JSON_CONTAINS_PATH ()代替。

以下规则定义了遏制:

否则，目标文档中不包含候选值。

从MySQL 8.0.17开始，查询使用JSON_CONTAINS ()在InnoDB表可以使用多值索引进行优化;看到多值的索引，以查询更多资料。

mysql >设置@j = '{“a”:1、“b”:2,“c”:{“d”:4}}';mysql> SET @j2 = '1';SELECT JSON_CONTAINS(@j， @j2， '$.a');+-------------------------------+ | JSON_CONTAINS (@j @j2,”美元。 ') | +-------------------------------+ | 1  | +-------------------------------+ mysql >选择JSON_CONTAINS (@j、@j2美元。b);+-------------------------------+ | JSON_CONTAINS (@j @j2,”美元。b ') | +-------------------------------+ | 0  | +-------------------------------+ mysql >设置@j2 = '{“d”:4}';SELECT JSON_CONTAINS(@j， @j2， '$.a');+-------------------------------+ | JSON_CONTAINS (@j @j2,”美元。 ') | +-------------------------------+ | 0  | +-------------------------------+ mysql >选择JSON_CONTAINS (@j @j2, ' $ c ');+-------------------------------+ | JSON_CONTAINS (@j, @j2 $ . c ') | +-------------------------------+ | 1  | +-------------------------------+

JSON_CONTAINS_PATH (json_doc，one_or_all，路径[，路径]…)

返回0或1以指示JSON文档是否包含给定路径上的数据。返回零如果任何参数是零．，则会发生错误json_doc参数不是有效的JSON文档路径参数不是有效的路径表达式，或者one_or_all不是“一个”或“所有”．

若要检查路径上的特定值，请使用JSON_CONTAINS ()代替。

如果文档中不存在指定的路径，则返回值为0。否则，返回值取决于one_or_all论点:

mysql >设置@j = '{“a”:1、“b”:2,“c”:{“d”:4}}';mysql> SELECT JSON_CONTAINS_PATH(@j， 'one'， '$. '),即美元);+---------------------------------------------+ | JSON_CONTAINS_PATH (@j '一',' $。”、“即美元 ') | +---------------------------------------------+ | 1  | +---------------------------------------------+ mysql >选择JSON_CONTAINS_PATH (@j,“所有”,“美元。,即美元);+---------------------------------------------+ | JSON_CONTAINS_PATH (@j,“所有”、“美元。”、“即美元 ') | +---------------------------------------------+ | 0  | +---------------------------------------------+ mysql >选择JSON_CONTAINS_PATH (@j,“一个”,“.c.d美元”);+----------------------------------------+ | JSON_CONTAINS_PATH (@j,‘一个’,‘.c.d美元 ') | +----------------------------------------+ | 1  | +----------------------------------------+ mysql >选择JSON_CONTAINS_PATH (@j,“一个”,“.a.d美元”);+----------------------------------------+ | JSON_CONTAINS_PATH (@j,‘一个’,‘.a.d美元 ') | +----------------------------------------+ | 0  | +----------------------------------------+

JSON_EXTRACT (json_doc，路径[，路径]…)

控件匹配的文档部分中选择的JSON文档返回数据路径参数。返回零如果任何参数是零或者在文档中没有路径定位值。，则会发生错误json_doc参数不是有效的JSON文档路径参数不是有效的路径表达式。

方法匹配的所有值组成返回值路径参数。如果这些参数可能返回多个值，则匹配的值将自动包装为一个数组，其顺序与生成它们的路径对应。否则，返回值为单个匹配值。

mysql >选择JSON_EXTRACT(“[10年,20年,[30 40]]','[1]美元');+--------------------------------------------+ | JSON_EXTRACT(“[10年,20年,[30 40]]','[1美元 ]') | +--------------------------------------------+ | 20  | +--------------------------------------------+ mysql >选择JSON_EXTRACT(“[10年,20年,[30 40]]”,“[1]美元”,“[0]美元”);+----------------------------------------------------+ | JSON_EXTRACT(“[10年,20年,[30 40]]”,“[1]美元”,“[0美元 ]') | +----------------------------------------------------+ | [ 20日10 ] | +----------------------------------------------------+ mysql >选择JSON_EXTRACT(“[10年,20年,[30 40]]',' $ [2][*]');+-----------------------------------------------+ | JSON_EXTRACT(“[10年,20年,[30 40]]','[2美元 ][*]') | +-----------------------------------------------+ | [ 30、40 ] | +-----------------------------------------------+

MySQL支持->运算符作为这个函数的简写，它有两个参数左边是aJSON列标识符(不是表达式)，右边是要在列中匹配的JSON路径。

列->路径

的->类的别名JSON_EXTRACT ()函数在与两个参数一起使用时，左边是列标识符，右边是JSON路径(字符串文字)，根据JSON文档(列值)求值。您可以在SQL语句中任何出现列引用的地方使用这种表达式。

这两个选择这里显示的语句产生相同的输出:

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”、“名称”:“巴尼”}| 3 | 3 | | {" id ":“4”、“名称”:“贝蒂”}|“4”| 4 | | {" id ":“2”,“名字”:“威尔玛”}|“2”| 2  | +-------------------------------+-----------+------+ 3行集(0.00秒)mysql >选择c, c - > " $。id"， g > FROM jemp > WHERE c->"$。id" > 1 > ORDER BY c->"$.name";+-------------------------------+-----------+------+ | c | c - > " $。id”| g  | +-------------------------------+-----------+------+ | {" id”:“3”、“名称”:“巴尼”}| 3 | 3 | | {" id ":“4”、“名称”:“贝蒂”}|“4”| 4 | | {" id ":“2”,“名字”:“威尔玛”}|“2”| 2  | +-------------------------------+-----------+------+ 3行集(0.00秒)

此功能并不局限于选择，如下所示:

修改表jemp的列查询OK, 0 rows affected (0.68 sec) Records: 0 duplicate: 0 Warnings: 0 mysql> UPDATE jemp SET n=1 WHERE c->"$。id”=“4”;查询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”、“名称”:“巴尼”}| 3 | 3 |零| | {" id ":“4”、“名称”:“贝蒂”}|“4”| 4 | 1 | | {" id ":“2”,“名字”:“威尔玛”}|“2”| 2 | NULL  | +-------------------------------+-----------+------+------+ 3行集(0.00秒)mysql >删除从jemp c - >”。id”=“4”;查询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”、“名称”:“巴尼”}| 3 | 3 |零| | {" id ":“2”,“名字”:“威尔玛”}|“2”| 2 | NULL  | +-------------------------------+-----------+------+------+ 2行集(0.00秒)

(见为生成的列建立索引以提供JSON列索引，用于创建和填充刚才显示的表的语句。)

这也适用于JSON数组值，如下所示:

CREATE TABLE tj10 (a JSON, b INT);查询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);查询OK, 1 row affected (0.04 sec) mysql> SELECT a->"$[4]" FROM tj10;+--------------+ | - >“[4美元 ]" | +--------------+ | 44 | |(22日,66 ] | +--------------+ 2行集(0.00秒)mysql > SELECT *从tj10 - >“[0]美元”= 3;+------------------------------+------+ | a |  | +------------------------------+------+ | [ 3、10、5、17日,44]33 | | |(3、10、5、17日[22日66]]| 0  | +------------------------------+------+ 2行集(0.00秒)

支持嵌套数组。一个表达式使用->评估作为零如果在目标JSON文档中没有找到匹配的键，如下所示:

mysql> SELECT * FROM tj10 WHERE a->"$[4][1]" NOT NULL;+------------------------------+------+ | a |  | +------------------------------+------+ | [ 3、10、5、17日[22日66]]| 0  | +------------------------------+------+ mysql >选择- >“美元[4][1]“tj10;+--------------+ | - >”[4][1美元 ]" | +--------------+ | 零| | 44  | +--------------+ 2行集(0.00秒)

这与使用时在这种情况下看到的行为相同JSON_EXTRACT ()：

SELECT JSON_EXTRACT(a， "$[4][1]") FROM tj10;+----------------------------+ | JSON_EXTRACT (a,”[4][1美元 ]") | +----------------------------+ | 零| | 44  | +----------------------------+ 2行集(0.00秒)

列->>路径

这是一个改进的、不引用的提取运算符。而->操作符只是提取一个值->>此外，操作符取消对提取结果的引号。换句话说，给定aJSON列值列和一个路径表达式路径(字符串字面量)，下面三个表达式返回相同的值:

的->>运算符可以在任何地方使用JSON_UNQUOTE (JSON_EXTRACT ())将被允许。这包括(但不限于)选择列表,在哪里而且有条款,命令而且集团条款。

下面的几个语句演示了一些->>中与其他表达式的运算符等价mysql客户:

mysql> SELECT * FROM jemp WHERE g > 2;+-------------------------------+------+ | c | g  | +-------------------------------+------+ | {" id”:“3”、“名称”:“巴尼”}| 3 | | {" id ":“4”、“名称”:“贝蒂”}| 4  | +-------------------------------+------+ 2行(0.01秒)mysql >选择c - > $ . name的名字——>从jemp g > 2;+----------+ | 的名字  | +----------+ | " 巴尼“| |”贝蒂 " | +----------+ 2行(0.00秒)mysql >选择JSON_UNQUOTE (c - > $ . name)的名字——>从jemp g > 2;+--------+ | 的名字  | +--------+ | 巴尼| |贝蒂  | +--------+ 2行(0.00秒)mysql >选择c - > > . name美元的名字——>从jemp g > 2;+--------+ | 的名字  | +--------+ | 巴尼| |贝蒂  | +--------+ 2行集(0.00秒)

看到为生成的列建立索引以提供JSON列索引的SQL语句，用于创建和填充jemp表中刚刚展示的一组例子。

这个运算符也可以用于JSON数组，如下所示:

CREATE TABLE tj10 (a JSON, b INT);查询好,0行影响(0.26秒)mysql >插入tj10价值观——>(“[3、10、5、“x”,44]”,33),- - - - - - >(“[3、10、5、17日[22,66年" y "]] ', 0);查询OK, 2 rows affected (0.04 sec) Records: 2 duplicate: 0 warning: 0 mysql> SELECT a->"$[3]"， a->"$[4][1]" FROM tj10;+-----------+--------------+ | “[3]美元”——> | - >”[4][1美元 ]" | +-----------+--------------+ | " 17 x”零| | | |“y " | +-----------+--------------+ 2行(0.00秒)mysql >选择- > > " $ [3]",a - > > " $[4][1]“tj10;+------------+---------------+ | a - > > |“[3]美元”——> >”[4][1美元 ]" | +------------+---------------+ | 17 x零| | | | y  | +------------+---------------+ 2行集(0.00秒)

与->,->>运算符总是在的输出中展开解释，如下例所示:

mysql >解释选择c - > > . name美元的名字——>从jemp g > 2 \ g  *************************** 1。row *************************** id: 1 select_type: SIMPLE table: jemp partitions: NULL type: range possible le_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 ***************************行  *************************** 水平:注意代码:1003信息:/ *选择# 1 * /选择json_unquote (json_extract(“jtest”。“jemp”。' c ', ' $ . name '))从jtest的“名字”。“jemp”(“jtest”。“jemp”的地方。' g ' > 2)在set中1行(0.00 sec)

这类似于MySQL如何扩展->同一情况下的操作员。

JSON_KEYS (json_doc[，路径]）

返回JSON对象的顶层值中的键作为JSON数组，或者，如果路径参数时，所选路径的顶级键。返回零如果任何参数是零,json_doc参数不是一个对象，或者路径，如果给定，则不定位对象。，则会发生错误json_doc参数不是有效的JSON文档或路径参数不是有效的路径表达式或包含＊或**通配符。

如果所选对象为空，则结果数组为空。如果顶层值有嵌套子对象，则返回值不包括来自这些子对象的键。

mysql >选择JSON_KEYS('{“a”:1、“b”:{“c”:30}}”);+---------------------------------------+ | JSON_KEYS('{“a”:1、“b”:{“c”:30 }}') | +---------------------------------------+ | [" a”、“b "] | +---------------------------------------+ mysql >选择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)。如果两个参数都是标量，则函数执行一个简单的相等检验。

这个函数相当于JSON_CONTAINS ()，它要求所搜索的数组的所有元素都出现在所搜索的数组中。因此,JSON_CONTAINS ()执行一个和搜索键上的操作，而JSON_OVERLAPS ()执行一个或操作。

的JSON列的查询InnoDB表的使用JSON_OVERLAPS ()在在哪里子句可以使用多值索引进行优化。多值的索引，提供详细信息和示例。

当比较两个数组时，JSON_OVERLAPS ()如果它们共享一个或多个数组元素，则返回true，否则返回false:

mysql >选择JSON_OVERLAPS(“(1、3、5、7)”、“(2、5、7)”);+---------------------------------------+ | JSON_OVERLAPS(“(1、3、5、7)”、“(2、5、7 ]") | +---------------------------------------+ | 1  | +---------------------------------------+ 1行组(0.00秒)mysql >选择JSON_OVERLAPS(“(1、3、5、7)”、“(2、6、7)”);+---------------------------------------+ | JSON_OVERLAPS(“(1、3、5、7)”、“(2、6、7 ]") | +---------------------------------------+ | 1  | +---------------------------------------+ 1行组(0.00秒)mysql >选择JSON_OVERLAPS(“(1、3、5、7)”、“(2、6、8)”);+---------------------------------------+ | JSON_OVERLAPS(“(1、3、5、7)”、“(2、6、8 ]") | +---------------------------------------+ | 0  | +---------------------------------------+ 1行集(0.00秒)

部分匹配被视为不匹配，如下所示:

mysql >选择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行集(0.00秒)

在比较对象时，如果对象至少有一个共同的键-值对，则结果为真。

mysql >选择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行组(0.00秒)mysql >选择JSON_OVERLAPS(“{“a”:1、“b”:10“d”:10}’,‘{“e”:“一”:5日10日“f”:1、“d”:20}”);+-----------------------------------------------------------------------+ | JSON_OVERLAPS('{“a”:1、“b”:10“d”:10}’,‘{“e”:“一”:5日10日“f”:1、“d”:20 }') | +-----------------------------------------------------------------------+ | 0  | +-----------------------------------------------------------------------+ 1行集(0.00秒)

如果用两个标量作为函数的参数，JSON_OVERLAPS ()执行一个简单的相等性测试:

SELECT JSON_OVERLAPS('5'， '5');+-------------------------+ | JSON_OVERLAPS (' 5 ', ' 5 ') | +-------------------------+ | 1  | +-------------------------+ 1行组(0.00秒)mysql >选择JSON_OVERLAPS(“5”、“6”);+-------------------------+ | JSON_OVERLAPS(“5”、“6 ') | +-------------------------+ | 0  | +-------------------------+ 1行集(0.00秒)

在比较标量和数组时，JSON_OVERLAPS ()试图将标量视为数组元素。在这个例子中，第二个参数6被解释为[6]，如下所示:

mysql> SELECT JSON_OVERLAPS('[4,5,6,7]'， '6');+---------------------------------+ | JSON_OVERLAPS('(4、5、6、7)”,“6 ') | +---------------------------------+ | 1  | +---------------------------------+ 1行集(0.00秒)

该函数不执行类型转换:

mysql> SELECT JSON_OVERLAPS('[4,5，"6"，7]'， '6');+-----------------------------------+ | JSON_OVERLAPS('(4、5、“6”、7]”,“6 ') | +-----------------------------------+ | 0  | +-----------------------------------+ 1行组(0.00秒)mysql >选择JSON_OVERLAPS(’(4、5、6、7)”,“6”);+-----------------------------------+ | JSON_OVERLAPS('(4、5、6、7)”,“6 "') | +-----------------------------------+ | 0  | +-----------------------------------+ 1行集(0.00秒)

JSON_OVERLAPS ()在MySQL 8.0.17中添加。

JSON_SEARCH (json_doc，one_or_all，search_str[，escape_char[，路径]…])

返回JSON文档中给定字符串的路径。返回零如果任何json_doc，search_str,或路径参数是零；没有路径存在于文档中;或search_str没有找到。，则会发生错误json_doc参数不是有效的JSON文档路径参数不是有效的路径表达式，one_or_all不是“一个”或“所有”,或escape_char不是常量表达式。

的one_or_all参数对搜索的影响如下:

在search_str搜索字符串参数％而且＿字符的工作就像就像接线员:％匹配任意数量的字符(包括零字符)，和＿只匹配一个字符。

要指定一个文字％或＿字符，在其前面加上转义字符。默认值是＼如果escape_char参数缺失或零．否则,escape_char必须为空或一个字符的常量。

有关匹配和转义字符行为的详细信息，请参见就像在第12.8.1节“字符串比较函数和操作符”．对于转义字符处理，区别于就像行为就是转义字符JSON_SEARCH ()必须在编译时计算为常量，而不仅仅是在执行时。例如,如果JSON_SEARCH ()在预备语句中使用escape_char参数使用?参数，则参数值可能在执行时为常量，但在编译时不是。

search_str而且路径总是被解释为utf8mb4字符串，而不管它们的实际编码。这是一个已知的问题，已在MySQL 8.0.24中修复(Bug #32449181)。

mysql >设置@j = '[“abc”,[{“k”:“10”},“def”),{“x”:“abc”},{“y”:“bcd”}]”;mysql> SELECT JSON_SEARCH(@j， 'one'， 'abc');+-------------------------------+ | JSON_SEARCH (@j,‘一个’,”美国广播公司 ') | +-------------------------------+ | "$[ 0 ]" | +-------------------------------+ mysql >选择JSON_SEARCH (@j,“所有”,“abc”);+-------------------------------+ | JSON_SEARCH (@j,“所有”、“abc ') | +-------------------------------+ | ["$[ 0]”、“美元[2]。x "] | +-------------------------------+ mysql >选择JSON_SEARCH (@j,“所有”、“全球健康行动计划”);+-------------------------------+ | JSON_SEARCH (@j,“所有”、“全球健康行动计划 ') | +-------------------------------+ | 零  | +-------------------------------+ mysql >选择JSON_SEARCH (@j,‘所有’,‘10’);+------------------------------+ | JSON_SEARCH (@j,“所有”、“10 ') | +------------------------------+ | "$[ 1][0]。k " | +------------------------------+ mysql >选择JSON_SEARCH (@j,‘所有’,‘10’,NULL,“美元”);+-----------------------------------------+ | JSON_SEARCH (@j,‘所有’,‘10’,NULL , '$') | +-----------------------------------------+ | "$[ 1][0]。k " | +-----------------------------------------+ mysql >选择JSON_SEARCH (@j,‘所有’,‘10’,NULL , '$[*]');+--------------------------------------------+ | JSON_SEARCH (@j,‘所有’,‘10’,NULL , '$[*]') | +--------------------------------------------+ | "$[ 1][0]。k " | +--------------------------------------------+ mysql >选择JSON_SEARCH (@j,‘所有’,‘10’,NULL,美元* *同意);+---------------------------------------------+ | JSON_SEARCH (@j,‘所有’,‘10’,NULL,“美元* *同意 ') | +---------------------------------------------+ | "$[ 1][0]。k " | +---------------------------------------------+ mysql >选择JSON_SEARCH (@j,‘所有’,‘10’,NULL,“[*][0]同意美元”);+-------------------------------------------------+ | JSON_SEARCH (@j,‘所有’,‘10’,NULL,“美元[*][0]同意 ') | +-------------------------------------------------+ | "$[ 1][0]。k " | +-------------------------------------------------+ mysql >选择JSON_SEARCH (@j,‘所有’,‘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_VALUE (json_doc，路径）

从指定文档中给定的路径处的JSON文档中提取值，并返回提取的值，可以将其转换为所需的类型。完整的语法如下所示:

JSON_VALUE (json_doc，路径(返回类型] [on_empty] [on_error]）on_empty: {null | error | default价值}在空on_error: {null | error | default价值}上的错误

json_doc是一个有效的JSON文档。

路径是指向文档中某个位置的JSON路径。这必须是一个字符串文字值。

类型是以下数据类型之一:

控件支持的(非数组)类型与刚刚列出的类型相同把()函数。

如果没有指定返回条款,JSON_VALUE ()函数的返回类型为VARCHAR (512)．当没有为返回类型指定字符集时，JSON_VALUE ()使用utf8mb4使用二进制排序，区分大小写;如果utf8mb4指定为结果的字符集时，服务器对此字符集使用默认排序规则，它不区分大小写。

当指定路径上的数据由JSON空文本组成或解析为JSON空文本时，函数返回SQL零．

on_empty，如果指定，则决定如何JSON_VALUE ()当在给定的路径上没有发现数据时，行为;该子句接受以下值之一:

如果使用,on_error当发生错误时，接受以下值之一和相应的结果，如下所示:

在空，如果使用，则必须在any之前在错误条款。以错误的顺序指定它们会导致语法错误。

错误处理。通常，错误由JSON_VALUE ()如下:

JSON_VALUE ()是在MySQL 8.0.21中引入的。

的例子。下面是两个简单的例子:

mysql >选择JSON_VALUE('{“帧”:“乔”,“lname”:“帕尔默”}”,“.fname美元”);+--------------------------------------------------------------+ | JSON_VALUE('{“帧”:“乔”,“lname”:“帕尔默”}’,‘.fname美元 ') | +--------------------------------------------------------------+ | 乔  | +--------------------------------------------------------------+ mysql >选择JSON_VALUE('{“项”:“鞋”,“价格”:“49.95”}',' $。返回DECIMAL(4,2))作为价格;+-------+ |价格| +-------+ | 49.95 | +-------+

该声明选择JSON_VALUE (json_doc，路径返回类型）相当于以下语句:

Select cast (json_unquote (json_extract (json_doc，路径))类型）;

JSON_VALUE ()简化了在JSON列上创建索引的过程，在许多情况下无需先创建生成的列，然后再在生成的列上创建索引。可以在创建表时执行此操作t1有一个JSON列，方法是在使用JSON_VALUE ()操作该列(与该列中的值匹配的路径)，如下所示:

CREATE TABLE t1(j JSON, INDEX i1 ((JSON_VALUE(j， '$. JSON))id'返回UNSIGNED))));

以下解释输出显示查询t1中使用索引表达式在哪里子句使用这样创建的索引:

mysql>解释SELECT * FROM t1 -> WHERE JSON_VALUE(j， '$。id '返回无符号)= 123 \ G  *************************** 1。row *************************** id: 1 select_type: SIMPLE table: t1 partitions: NULL type: ref possible le_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 (j));

的解释对该表的查询的输出引用了生成的列，显示索引的使用方式与前面对表的查询相同t1：

mysql >解释选择从t2 * g = 123 \ g  *************************** 1。row *************************** id: 1 select_type: SIMPLE table: t2 partitions: NULL type: ref possible le_keys: i1 key: i1 key_len: 5 ref: const rows: 1 filtered: 100.00 Extra: NULL

的间接索引在生成的列上使用索引的信息JSON列,看到为生成的列建立索引以提供JSON列索引．

价值成员(json_array）

返回true (1)价值是json_array，否则返回false(0)。价值必须是一个标量或JSON文档;如果它是标量，操作符将尝试将其作为JSON数组的一个元素处理。

查询使用成员()的JSON列InnoDB表在哪里子句可以使用多值索引进行优化。看到多值的索引参阅详细资料和例子。

简单标量被视为数组值，如下所示:

mysql> SELECT 17 MEMBER OF('[23， "abc"， 17， "ab"， 10]');+-------------------------------------------+ | 17个成员(“[23日“abc”,17日“ab”,10 ]') | +-------------------------------------------+ | 1  | +-------------------------------------------+ 1行组(0.00秒)mysql >选择“ab”的成员(“[23日“abc”,17日“ab”,10]”);+---------------------------------------------+ | ' ab的成员(“[23日“abc”,17日“ab”,10 ]') | +---------------------------------------------+ | 1  | +---------------------------------------------+ 1行集(0.00秒)

数组元素值的部分匹配不匹配:

mysql> SELECT 7 MEMBER OF('[23， "abc"， 17， "ab"， 10]');+------------------------------------------+ | 7的成员(“[23日“abc”,17日“ab”,10 ]') | +------------------------------------------+ | 0  | +------------------------------------------+ 1行集(0.00秒)

mysql >选择“a”的成员(“[23日“abc”,17日“ab”,10]”);+--------------------------------------------+ | ' 的成员(“[23日“abc”,17日“ab”,10 ]') | +--------------------------------------------+ | 0  | +--------------------------------------------+ 1行集(0.00秒)

不会执行与字符串类型之间的转换:

mysql >选择- > 17的成员(“[23日“abc”,“17”、“ab”,10]”),- - - - - - >“17”的成员(“[23日“abc”,17日“ab”,10]”)\ G  *************************** 1。行  *************************** 17个成员(“[23日“abc”,“17”、“ab”,10]”):0“17”的成员(“[23日“abc”,17日“ab”,10]”):0 1行组(0.00秒)

若要对本身为数组的值使用此操作符，必须显式将其转换为JSON数组。你可以用铸造(…JSON)：

mysql >选择演员(“(4、5)”为JSON)的成员(“[[3,4],[4,5]]”);+--------------------------------------------------+ | 铸造((4、5)的JSON)的成员(“[[3,4],[4 5 ]]') | +--------------------------------------------------+ | 1  | +--------------------------------------------------+ 1行集(0.00秒)

方法也可以执行必要的强制转换JSON_ARRAY ()函数,如下:

mysql >选择JSON_ARRAY(4、5)的成员(“[[3,4],[4,5]]”);+--------------------------------------------+ | JSON_ARRAY(4、5)的成员(“[[3,4],[4 5 ]]') | +--------------------------------------------+ | 1  | +--------------------------------------------+ 1行集(0.00秒)

任何用作测试值或出现在目标数组中的JSON对象都必须使用强制转换为正确的类型铸造(…JSON)或JSON_OBJECT ()．此外，包含JSON对象的目标数组本身必须使用JSON_ARRAY．这可以通过以下语句序列来演示:

mysql> SET @a = CAST('{"a":1}' AS JSON);查询OK, 0 rows affected (0.00 sec) mysql> SET @b = JSON_OBJECT("b"， 2);查询OK, 0 rows affected (0.00 sec) mysql> SET @c = JSON_ARRAY(17， @b， "abc"， @a, 23);查询OK, 0 rows affected (0.00 sec) mysql> SELECT @a MEMBER OF(@c)， @b MEMBER OF(@c);+------------------+------------------+ | @ 的一员(@c) | @b (@c的成员 ) | +------------------+------------------+ | 1 | 1  | +------------------+------------------+ 1行集(0.00秒)

的成员()MySQL 8.0.17中增加了operator。