9.15. JSON 函数和操作符
上一页 上一级第 9 章 函数和操作符起始页 下一页

9.15. JSON 函数和操作符

9.15.1. 处理和创建JSON数据
9.15.2. SQL/JSON路径语言

本节描述:

要了解有关SQL/JSON标准的更多信息，请参阅[sqltr-19075-6]。有关PostgreSQL中支持的JSON类型的详细信息，见 第 8.14 节。 .

9.15.1. 处理和创建JSON数据

表 9.44展示了可以用于 JSON 数据类型（见第 8.14 节）的操作符。

表 9.44. json和jsonb 操作符

操作符右操作数类型返回类型描述例子例子结果
->intjson or jsonb获得 JSON 数组元素（索引从 0 开始，负整数从末尾开始计）'[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json->2{"c":"baz"}
->textjson or jsonb通过键获得 JSON 对象域'{"a": {"b":"foo"}}'::json->'a'{"b":"foo"}
->>inttext以text形式获得 JSON 数组元素'[1,2,3]'::json->>23
->>texttext以text形式获得 JSON 对象域'{"a":1,"b":2}'::json->>'b'2
#>text[]json or jsonb获取在指定路径的 JSON 对象'{"a": {"b":{"c": "foo"}}}'::json#>'{a,b}'{"c": "foo"}
#>>text[]text以text形式获取在指定路径的 JSON 对象'{"a":[1,2,3],"b":[4,5,6]}'::json#>>'{a,2}'3

注意

对json和jsonb类型，这些操作符都有其并行变体。 域/元素/路径抽取操作符返回与其左手输入（json或jsonb） 相同的类型，不过那些被指定为返回text的除外，它们的返回值会被强制 为文本。如果该 JSON 输入没有匹配请求的正确结构（例如那样的元素不存在），这些 域/元素/路径抽取操作符会返回 NULL 而不是失败。 接受整数 JSON 数组下标的 域/元素/路径抽取操作符都支持表示从数组末尾开始的负值下标形式。

表 9.1中展示的标准比较操作符只对 jsonb有效，而不适合json。它们遵循在第 8.14.4 节中给出的 B 树操作规则。

如表 9.45中所示，还存在一些只适合 jsonb的操作符。这些操作符中的很多可以用jsonb 操作符类索引。jsonb包含和存在语义的完整描述可参见第 8.14.3 节。第 8.14.4 节描述了如何 用这些操作符来有效地索引jsonb数据。

表 9.45. 额外的jsonb操作符

操作符右操作数类型描述例子
@>jsonb左边的 JSON 值是否在顶层包含右边的 JSON 路径/值项？'{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb
<@jsonb左边的 JSON 路径/值项是否被包含在右边的 JSON 值的顶层？'{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb
?text键/元素字符串是否存在于 JSON 值的顶层？'{"a":1, "b":2}'::jsonb ? 'b'
?|text[]这些数组字符串中的任何一个是否做为顶层键存在？'{"a":1, "b":2, "c":3}'::jsonb ?| array['b', 'c']
?&text[]是否所有这些数组字符串都作为顶层键存在？'["a", "b"]'::jsonb ?& array['a', 'b']
||jsonb把两个jsonb值串接成一个新的jsonb值'["a", "b"]'::jsonb || '["c", "d"]'::jsonb
-text从左操作数删除键/值对或者string 元素。键/值对基于它们的键值来匹配。'{"a": "b"}'::jsonb - 'a'
-text[]从左操作数中删除多个键/值对或者string元素。键/值对基于它们的键值来匹配。'{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[]
-integer删除具有指定索引（负值表示倒数）的数组元素。如果 顶层容器不是数组则抛出一个错误。'["a", "b"]'::jsonb - 1
#-text[]删除具有指定路径的域或者元素（对于 JSON 数组，负值 表示倒数）'["a", {"b":1}]'::jsonb #- '{1,b}'
@?jsonpathJSON路径是否返回指定的JSON值的任何项目？'{"a":[1,2,3,4,5]}'::jsonb @? '$.a[*] ? (@ > 2)'
@@jsonpath返回指定的JSON路径谓词检查结果。只考虑结果的第一项。 如果结果不是布尔值，那么返回 null 。'{"a":[1,2,3,4,5]}'::jsonb @@ '$.a[*] > 2'

注意

||操作符将其每一个操作数的顶层的元素串接起来。它不会递归 操作。例如，如果两个操作数都是具有公共域名称的对象，结果中的域值将 只是来自右手操作数的值。

注意

@?和@@@操作符会抑制以下错误：缺乏对象字段或数组元素、意外的JSON项类型和数字错误。当搜索不同结构的JSON文档集合时，这种行为可能会有帮助。

表 9.46展示了可用于创建 json 和 jsonb值的函数（没有用于 jsonb的与row_to_json和 array_to_json等价的函数。不过，to_jsonb函数 提供了这些函数的很大一部分相同的功能）。

表 9.46. JSON 创建函数

函数描述例子例子结果

to_json(anyelement)

to_jsonb(anyelement)

把该值返回为json或者jsonb。数组和组合 会被（递归）转换成数组和对象；对于不是数组和组合的值，如果有 从该类型到json的造型，造型函数将被用来执行该 转换；否则将产生一个标量值。对于任何不是数字、布尔、空值的标 量类型，将使用文本表达，在这种风格下它是一个合法的 json或者jsonb值。 to_json('Fred said "Hi."'::text)"Fred said \"Hi.\""
array_to_json(anyarray [, pretty_bool]) 把数组作为一个 JSON 数组返回。一个 PostgreSQL 多维数组会成为一个数组 的 JSON 数组。如果pretty_bool为真，将在 第 1 维度的元素之间增加换行。 array_to_json('{{1,5},{99,100}}'::int[])[[1,5],[99,100]]
row_to_json(record [, pretty_bool]) 把行作为一个 JSON 对象返回。如果pretty_bool为真，将在第1层元素之间增加换行。 row_to_json(row(1,'foo')){"f1":1,"f2":"foo"}

json_build_array(VARIADIC "any")

jsonb_build_array(VARIADIC "any")

从一个可变参数列表构造一个可能包含异质类型的 JSON 数组。 json_build_array(1,2,'3',4,5)[1, 2, "3", 4, 5]

json_build_object(VARIADIC "any")

jsonb_build_object(VARIADIC "any")

从一个可变参数列表构造一个 JSON 对象。通过转换，该参数列表由交替 出现的键和值构成。 json_build_object('foo',1,'bar',2){"foo": 1, "bar": 2}

json_object(text[])

jsonb_object(text[])

从一个文本数组构造一个 JSON 对象。该数组必须可以是具有偶数个成员的 一维数组（成员被当做交替出现的键/值对），或者是一个二维数组（每一个 内部数组刚好有 2 个元素，可以被看做是键/值对）。

json_object('{a, 1, b, "def", c, 3.5}')

json_object('{{a, 1},{b, "def"},{c, 3.5}}')

{"a": "1", "b": "def", "c": "3.5"}

json_object(keys text[], values text[])

jsonb_object(keys text[], values text[])

json_object的这种形式从两个独立的数组得到键/值对。在其 他方面和一个参数的形式相同。 json_object('{a, b}', '{1,2}'){"a": "1", "b": "2"}

注意

array_to_json和row_to_json与to_json 具有相同的行为，不过它们提供了更好的打印选项。针对to_json所描述 的行为同样也适用于由其他 JSON 创建函数转换的每个值。

注意

hstore扩展有一个从hstore到json 的造型，因此通过 JSON 创建函数转换的hstore值将被表示为 JSON 对象，而不是原始字符串值。

表 9.47展示了可用来处理json 和jsonb值的函数。

表 9.47. JSON 处理

函数返回值描述例子例子结果

json_array_length(json)

jsonb_array_length(jsonb)

int 返回最外层 JSON 数组中的元素数量。 json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]')5

json_each(json)

jsonb_each(jsonb)

setof key text, value json

setof key text, value jsonb

扩展最外层的 JSON 对象成为一组键/值对。 select * from json_each('{"a":"foo", "b":"bar"}') 
 key | value
-----+-------
 a   | "foo"
 b   | "bar"

json_each_text(json)

jsonb_each_text(jsonb)

setof key text, value text 扩展最外层的 JSON 对象成为一组键/值对。返回值将是text类型。 select * from json_each_text('{"a":"foo", "b":"bar"}') 
 key | value
-----+-------
 a   | foo
 b   | bar

json_extract_path(from_json json, VARIADIC path_elems text[])

jsonb_extract_path(from_json jsonb, VARIADIC path_elems text[])

json

jsonb

返回由path_elems指向的 JSON 值（等效于#>操作符）。 json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4'){"f5":99,"f6":"foo"}

json_extract_path_text(from_json json, VARIADIC path_elems text[])

jsonb_extract_path_text(from_json jsonb, VARIADIC path_elems text[])

text 以text返回由path_elems指向的 JSON 值（等效于#>>操作符）。 json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4', 'f6')foo

json_object_keys(json)

jsonb_object_keys(jsonb)

setof text 返回最外层 JSON 对象中的键集合。 json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}') 
 json_object_keys
------------------
 f1
 f2

json_populate_record(base anyelement, from_json json)

jsonb_populate_record(base anyelement, from_json jsonb)

anyelement 扩展from_json中的对象成一个行，它的列匹配由base定义的记录类型（见下文的注释）。 select * from json_populate_record(null::myrowtype, '{"a": 1, "b": ["2", "a b"], "c": {"d": 4, "e": "a b c"}}') 
 a |   b       |      c
---+-----------+-------------
 1 | {2,"a b"} | (4,"a b c")

json_populate_recordset(base anyelement, from_json json)

jsonb_populate_recordset(base anyelement, from_json jsonb)

setof anyelement 扩展from_json中最外的对象数组为一个集合，该集合的列匹配由base定义的记录类型。 select * from json_populate_recordset(null::myrowtype, '[{"a":1,"b":2},{"a":3,"b":4}]') 
 a | b
---+---
 1 | 2
 3 | 4

json_array_elements(json)

jsonb_array_elements(jsonb)

setof json

setof jsonb

把一个 JSON 数组扩展成一个 JSON 值的集合。 select * from json_array_elements('[1,true, [2,false]]') 
   value
-----------
 1
 true
 [2,false]

json_array_elements_text(json)

jsonb_array_elements_text(jsonb)

setof text 把一个 JSON 数组扩展成一个text值集合。 select * from json_array_elements_text('["foo", "bar"]') 
   value
-----------
 foo
 bar

json_typeof(json)

jsonb_typeof(jsonb)

text 把最外层的 JSON 值的类型作为一个文本字符串返回。可能的类型是： object、array、string、number、 boolean以及null。 json_typeof('-123.4')number

json_to_record(json)

jsonb_to_record(jsonb)

record 从一个 JSON 对象（见下文的注解）构建一个任意的记录。正如所有返回record 的函数一样，调用者必须用一个AS子句显式地定义记录的结构。 select * from json_to_record('{"a":1,"b":[1,2,3],"c":[1,2,3],"e":"bar","r": {"a": 123, "b": "a b c"}}') as x(a int, b text, c int[], d text, r myrowtype) 
 a |    b    |    c    | d |       r
---+---------+---------+---+---------------
 1 | [1,2,3] | {1,2,3} |   | (123,"a b c")

json_to_recordset(json)

jsonb_to_recordset(jsonb)

setof record 从一个 JSON 对象数组（见下文的注解）构建一个任意的记录集合。正如所有返回record 的函数一样，调用者必须用一个AS子句显式地定义记录的结构。 select * from json_to_recordset('[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]') as x(a int, b text); 
 a |  b
---+-----
 1 | foo
 2 |

json_strip_nulls(from_json json)

jsonb_strip_nulls(from_json jsonb)

json

jsonb

 返回from_json，其中所有具有空值的 对象域都被省略。其他空值不动。 json_strip_nulls('[{"f1":1,"f2":null},2,null,3]')[{"f1":1},2,null,3]

jsonb_set(target jsonb, path text[], new_value jsonb[,create_missing boolean])

jsonb

 返回target，其中由 path指定的节用 new_value替换，如果 path指定的项不存在并且 create_missing为真（默认为 true）则加上 new_value。正如面向路径的 操作符一样，出现在path中的 负整数表示从 JSON 数组的末尾开始数。

jsonb_set('[{"f1":1,"f2":null},2,null,3]', '{0,f1}','[2,3,4]', false)

jsonb_set('[{"f1":1,"f2":null},2]', '{0,f3}','[2,3,4]')

[{"f1":[2,3,4],"f2":null},2,null,3]

[{"f1": 1, "f2": null, "f3": [2, 3, 4]}, 2]

sonb_insert(target jsonb, path text[], new_value jsonb [, insert_after boolean])

jsonb

 返回被插入了new_value的target。如果path指定的target节在一个 JSONB 数组中，new_value将被插入到目标之前（insert_after为false，默认情况）或者之后（insert_after为真）。如果path指定的target节在一个 JSONB 对象内，则只有当target不存在时才插入new_value。对于面向路径的操作符来说，出现在path中的负整数表示从 JSON 数组的末尾开始计数。

jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"')

jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"', true)

{"a": [0, "new_value", 1, 2]}

{"a": [0, 1, "new_value", 2]}

jsonb_pretty(from_json jsonb)

text

 把from_json返回成一段 缩进后的 JSON 文本。 jsonb_pretty('[{"f1":1,"f2":null},2,null,3]') 
[
    {
        "f1": 1,
        "f2": null
    },
    2,
    null,
    3
]

jsonb_path_exists(target jsonb, path jsonpath [, vars jsonb [, silent bool]])

boolean 检查JSON路径是否为指定的JSON值返回任何项目。

jsonb_path_exists('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')

true

jsonb_path_match(target jsonb, path jsonpath [, vars jsonb [, silent bool]])

boolean 返回指定的JSON路径谓词检查结果。 只考虑结果的第一项。 如果结果不是布尔值，则返回null。

jsonb_path_match('{"a":[1,2,3,4,5]}', 'exists($.a[*] ? (@ >= $min && @ <= $max))', '{"min":2,"max":4}')

true

jsonb_path_query(target jsonb, path jsonpath [, vars jsonb [, silent bool]])

setof jsonb 获取指定的JSON值的JSON路径返回的所有JSON项。

select * from jsonb_path_query('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}'); 

 jsonb_path_query
------------------
 2
 3
 4

jsonb_path_query_array(target jsonb, path jsonpath [, vars jsonb [, silent bool]])

jsonb 获取指定JSON路径返回的所有JSON项，并将结果封装成数组。

jsonb_path_query_array('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')

[2, 3, 4]

jsonb_path_query_first(target jsonb, path jsonpath [, vars jsonb [, silent bool]])

jsonb 获取指定的JSON值的第一个JSON路径返回的JSON项。 如果没有结果，则返回NULL。

jsonb_path_query_first('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')

2


注意

很多这些函数和操作符将把 JSON 字符串中的 Unicode 转义转换成合适的单一字符。如果 输入类型是jsonb，这就没有问题，因为该转换已经完成了。但是对于json 输入，这可能会导致抛出一个错误（如第 8.14 节所述）。

注意

函数 json[b]_populate_record, json[b]_populate_recordset, json[b]_to_record and json[b]_to_recordset 对JSON对象或对象数组进行操作，并提取与输出行类型的列名匹配的键相关的值。不对应于任何输出列名的对象字段将被忽略，不匹配任何对象字段的输出列将被填充为空。要将JSON值转换为输出列的SQL类型，需要依次应用以下规则:

  • 在所有情况下，JSON空值都会被转换为SQL空值。

  • 如果输出列的类型为json或jsonb，那么JSON值就会被完全复制。

  • 如果输出的列是复合（行）类型，而JSON值是JSON对象，则通过递归应用这些规则，将该对象的字段转换为输出行类型的列。

  • 同样，如果输出列是一个数组类型，而JSON值是一个JSON数组，则通过递归应用这些规则将JSON数组的元素转换为输出数组的元素。

  • 否则，如果JSON值是一个字符串的字段，则该字符串的内容被送入列的数据类型的输入转换函数。

  • 否则，将JSON值的普通文本表示方式送入该列的数据类型的输入转换函数。

虽然这些函数的例子使用了常量，但典型的用法是在FROM子句中引用一个表，并使用其中的json或jsonb列作为函数的参数。 然后，提取的键值可以被引用到查询的其他部分，比如WHERE子句和目标列表。 用这种方式提取多个值，比用每键操作符分别提取多个值可以提高性能。

注意

jsonb_set和jsonb_insert的path参数中除最后一项之外的所有项都必须存在于target中。如果create_missing为假，jsonb_set的path参数的所有项都必须存在。如果这些条件不满足，则返回的target不会被改变。

如果最后的路径项是一个对象键，在它不存在且给定了新值的情况下会创建它。如果最后的路径项是一个数组索引，为正值则表示从左边开始计数，为负值表示从右边开始计数 - -1表示最右边的元素，以此类推。如果该项超过范围 -array_length .. array_length -1 并且 create_missing 为真，则该项为负时把新值加载数组的开始处，而该项为正时把新值加在数组的末尾处。

注意

不要把json_typeof函数的null返回值与 SQL 的 NULL 弄混。 虽然调用json_typeof('null'::json)将会返回null，但调用 json_typeof(NULL::json)将会返回一个 SQL 的 NULL。

注意

如果json_strip_nulls的参数在任何对象中包含重复的域名称， 结果在语义上可能有所不同，具体取决于它们发生的顺序。这不是 jsonb_strip_nulls的一个问题，因为jsonb值 不能具有重复的对象域名称。

注意

jsonb_path_exists、jsonb_path_match、jsonb_path_query、jsonb_path_query_array。和 jsonb_path_query_first函数有可选的vars和silent参数。

如果指定了vars参数，它提供了一个包含命名的变量的对象，要替换到jsonpath表达式中。

如果指定了silent参数，并且具有true值，那么这些函数将抑制与@?和@@操作符相同的错误。

也可参见第 9.20 节了解聚集函数json_agg，它可以把记录值聚集成 JSON。还有聚集函数json_object_agg，它可以把值对聚集成一个 JSON 对象。还有它们的jsonb等效体，jsonb_agg和jsonb_object_agg.

9.15.2. SQL/JSON路径语言

SQL/JSON路径表达式指定了要从JSON数据中检索的项目，类似于SQL访问XML时使用的XPath表达式。在PostgreSQL中，路径表达式作为jsonpath数据类型实现，可以使用第 8.14.6 节中描述的任何元素。

JSON查询函数和操作符将提供的路径表达式传递给路径引擎进行评估。如果表达式与被查询的JSON数据匹配，则返回相应的SQL/JSON项。路径表达式是用SQL/JSON路径语言编写的，也可以包括算术表达式和函数。查询函数将提供的表达式视为文本字符串，所以必须用单引号括起来。

一个路径表达式由jsonpath数据类型允许的元素序列组成。路径表达式从左至右进行评估，但你可以使用括号来改变操作顺序。如果评价成功，则会产生一个SQL/JSON项的序列（SQL/JSON序列），并将评价结果返回给完成指定计算的JSON查询函数。

要引用要查询的JSON数据（context项），请在路径表达式中使用$符号。后面可以有一个或多个accessor操作符，它可以逐级递减JSON结构中的上下文项的内容。下面的每一个操作符都涉及到上一个评估步骤的结果。

例如，假设你有一些来自GPS追踪器的JSON数据，你想对其进行解析，例如： 

{
  "track": {
    "segments": [
      {
        "location":   [ 47.763, 13.4034 ],
        "start time": "2018-10-14 10:05:14",
        "HR": 73
      },
      {
        "location":   [ 47.706, 13.2635 ],
        "start time": "2018-10-14 10:39:21",
        "HR": 135
      }
    ]
  }
}

要检索可用的轨迹段，需要使用.key访问器操作符来检索前面所有的JSON对象。 

'$.track.segments'

如果要检索的项目是一个数组的元素，你必须使用[*]操作符来取消这个数组的嵌套。例如，下面的路径将返回所有可用的轨道段的位置坐标。 

'$.track.segments[*].location'

要只返回第一段的坐标，可以在[]访问器操作符中指定相应的下标。请注意，SQL/JSON数组是0相关的: 

'$.track.segments[0].location'

每个路径评估步骤的结果可以由一个或多个jsonpath操作符和第 9.15.2.3 节中列出的方法处理。每个方法名称前必须有一个点。例如，你可以得到一个数组大小: 

'$.track.segments.size()'

关于在路径表达式中使用jsonpath操作符和方法的更多示例，请参见 第 9.15.2.3 节.

在定义路径时，你还可以使用一个或多个过滤表达式，其工作原理类似于SQL中的WHERE子句。一个过滤表达式以问号开头，并在括号中提供一个条件: 

? (condition)

筛选表达式必须在应用于路径评估步骤之后立即指定。这个步骤的结果被过滤，只包括那些满足所提供条件的项。SQL/JSON定义了三值逻辑，所以条件可以是true、false或unknown。unknown值的作用与SQL的NULL相同，可以用is unknown谓词来测试。进一步的路径评估步骤只使用那些过滤表达式返回true的项目。

在表 9.49中列出了可以在过滤表达式中使用的函数和操作符。要过滤的路径评价结果由@变量表示。要引用存储在较低嵌套层的JSON元素，可以在@之后添加一个或多个访问符操作符。

假设你想检索所有心率值大于130的心率值。你可以用下面的表达式来实现: 

'$.track.segments[*].HR ? (@ > 130)'

如果要得到带有这样的值的段的起始时间，需要在返回起始时间之前过滤掉不相关的段，所以过滤表达式应用于上一步，条件中使用的路径不同: 

'$.track.segments[*] ? (@.HR > 130)."start time"'

如果需要，你可以在同一个嵌套层上使用多个过滤表达式。例如，下面的表达式选择所有包含有相关坐标和高心率值的位置的位置段，并选择了以下表达式: 

'$.track.segments[*] ? (@.location[1] < 13.4) ? (@.HR > 130)."start time"'

也允许使用不同嵌套级别的过滤表达式。下面的例子首先按位置过滤所有的段，然后返回这些段的高心率值，如果可用的话: 

'$.track.segments[*] ? (@.location[1] < 13.4).HR ? (@ > 130)'

你也可以在彼此之间嵌套过滤表达式: 

'$.track ? (exists(@.segments[*] ? (@.HR > 130))).segments.size()'

该表达式返回轨道的大小，如果它包含任何具有高心跳值的片段，则返回轨道的大小，否则返回空序列。

PostgreSQL的SQL/JSON路径语言的实现与SQL/JSON标准有以下偏差。

  • .datetime()项方法还没有实现，这主要是因为不可变的jsonpath函数和操作符不能引用会话时区，而这是在一些日期时间操作中使用的。 在未来版本的PostgreSQL中，将在jsonpath中加入对Datetime的支持。

  • 路径表达式可以是一个布尔谓词，尽管SQL/JSON标准只允许在过滤器中使用谓词。 这对于实现@@操作符是必要的。例如，下面的jsonpath表达式在PostgreSQL中有效。 

    '$.track.segments[*].HR < 70'

  • 第 9.15.2.2 节中描述的like_regex过滤器中使用的正则表达式模式的解释有一些小的差异。

9.15.2.1. 严格和宽松模式

当你查询JSON数据时，路径表达式可能与实际的JSON数据结构不匹配。试图访问一个对象或数组元素中不存在的成员，会导致结构错误。SQL/JSON路径表达式有两种模式来处理结构性错误。

  • lax (默认值) — 路径引擎隐式地将被查询的数据适应指定的路径。任何剩余的结构性错误都会被压制并转换为空的SQL/JSON序列。

  • 严格的—如果发生结构性错误，则会提出错误。

宽松模式方便了JSON文档结构和路径的匹配。如果JSON数据不符合预期的模式，那么就会使用JSON表达式。如果一个操作项不符合特定操作的要求。 它可以被自动包装成一个SQL/JSON数组，或者通过 将其元素转换为SQL/JSON序列，然后再执行 这个操作。此外，比较操作者会自动解开他们的 运算子在宽松模式下，所以你可以比较SQL/JSON数组中的 开箱即用。一个大小为1的数组被认为等于它的唯一元素。自动解包并不是只有在以下情况下才会执行。

  • 路径表达式包含type()或size()方法，这些方法分别返回数组中的类型和元素数量。

  • 被查询的JSON数据包含嵌套数组。在这种情况下，只有最外层的数组被解包，而所有内部数组保持不变。因此，在每个路径评估步骤中，隐式解包只能往下走一层。

例如，在查询上面列出的GPS数据时，可以抽象出它在使用宽松模式时存储了一个数组段的事实。 

'lax $.track.segments.location'

在严格模式下，指定的路径必须与被查询的JSON文档的结构完全匹配才能返回一个SQL/JSON项，所以使用这个路径表达式会导致错误。为了得到与宽松模式下相同的结果，你必须显式地解包segments数组。 

'strict $.track.segments[*].location'

9.15.2.2. 正则表达式

SQL/JSON路径表达式允许用like_regex过滤器将文本匹配到正则表达式。 例如，下面的SQL/JSON路径查询将对数组中所有以英文元音开头的字符串进行大小写匹配。 

'$[*] ? (@ like_regex "^[aeiou]" flag "i")'

可选的flag字符串可以包括一个或多个字符i，用于不区分大小写的匹配，m允许^和$在换行处匹配，s允许. 匹配一个新行，而q引用整个模式（将行为还原为简单的子串匹配）。

SQL/JSON标准借用了正则表达式的定义。LIKE_REGEX操作符，而该操作符又使用了 XQuery标准。 PostgreSQL目前不支持 LIKE_REGEX运算符。 因此。 like_regex 过滤器是用 POSIX正则表达式引擎在 第 9.7.3 节。 这导致了各种小的 与标准SQL/JSON行为的差异，这些差异在 第 9.7.3.8 节。但是，请注意，这里所描述的旗帜-字母不兼容的问题 不适用于SQL/JSON，因为它将XQuery标志字母转换为 匹配POSIX引擎的期望值。

请记住，like_regex的模式参数是一个JSON路径字符串字段，根据第 8.14.6 节中给出的规则编写。 这特别意味着，你想在正则表达式中使用的任何反斜线必须是双倍的。例如，要匹配只包含数字的字符串。 

'$ ? (@ like_regex "^\\d+$")'

9.15.2.3. SQL/JSON路径操作符和方法

表 9.48显示了jsonpath中的操作符和方法。 表 9.49显示了可用的过滤器表达式元素。

表 9.48. jsonpath 运算符和方法

运算符和方法描述JSON举例 Query举例结果
+ (unary)加号运算符，可对SQL/JSON序列进行迭代。{"x": [2.85, -14.7, -9.4]}+ $.x.floor()2, -15, -10
- (unary)对SQL/JSON序列进行迭代的减法运算器{"x": [2.85, -14.7, -9.4]}- $.x.floor()-2, 15, 10
+ (binary)加号[2]2 + $[0]4
- (binary)减号[2]4 - $[0]2
*乘号[4]2 * $[0]8
/除号[8]$[0] / 24
%取模[32]$[0] % 102
type()SQL/JSON项的类型[1, "2", {}]$[*].type()"number", "string", "object"
size()SQL/JSON项的大小{"m": [11, 15]}$.m.size()2
double()由SQL/JSON数字或字符串转换而来的近似浮点数{"len": "1.9"}$.len.double() * 23.8
ceiling()大于或等于SQL/JSON数的最近整数{"h": 1.3}$.h.ceiling()2
floor()小于或等于SQL/JSON数的最近整数{"h": 1.3}$.h.floor()1
abs()SQL/JSON号的绝对值{"z": -0.3}$.z.abs()0.3
keyvalue() 对象的键-值对的序列，用包含三个字段的数组来表示。 ("key", "value", 和 "id"). "id" 是键-值对所属对象的唯一标识符。 {"x": "20", "y": 32}$.keyvalue(){"key": "x", "value": "20", "id": 0}, {"key": "y", "value": 32, "id": 0}

表 9.49. jsonpath 筛选表达式元素

值/谓语描述JSON举例Query举例结果
==等号运算符[1, 2, 1, 3]$[*] ? (@ == 1)1, 1
!=不等号运算符[1, 2, 1, 3]$[*] ? (@ != 1)2, 3
<>不等号运算符(same as !=)[1, 2, 1, 3]$[*] ? (@ <> 1)2, 3
<小于运算符[1, 2, 3]$[*] ? (@ < 2)1
<=小于等于运算符[1, 2, 3]$[*] ? (@ <= 2)1, 2
>大于号运算符[1, 2, 3]$[*] ? (@ > 2)3
>=大于等于运算符[1, 2, 3]$[*] ? (@ >= 2)2, 3
trueValue used to perform comparison with JSON true literal[{"name": "John", "parent": false}, {"name": "Chris", "parent": true}]$[*] ? (@.parent == true){"name": "Chris", "parent": true}
falseValue used to perform comparison with JSON false literal[{"name": "John", "parent": false}, {"name": "Chris", "parent": true}]$[*] ? (@.parent == false){"name": "John", "parent": false}
nullValue used to perform comparison with JSON null value[{"name": "Mary", "job": null}, {"name": "Michael", "job": "driver"}]$[*] ? (@.job == null) .name"Mary"
&&布尔与[1, 3, 7]$[*] ? (@ > 1 && @ < 5)3
||布尔或[1, 3, 7]$[*] ? (@ < 1 || @ > 5)7
!布尔非[1, 3, 7]$[*] ? (!(@ < 5))7
like_regex 测试第一个操作项是否与第二个操作项给出的正则表达式相匹配，可选择用flag字符串描述的修改（见第 9.15.2.2 节）。 ["abc", "abd", "aBdC", "abdacb", "babc"]$[*] ? (@ like_regex "^ab.*c" flag "i")"abc", "aBdC", "abdacb"
starts with测试第二个执行项是否是第一个执行项的初始子串。["John Smith", "Mary Stone", "Bob Johnson"]$[*] ? (@ starts with "John")"John Smith"
exists测试一个路径表达式是否至少匹配一个SQL/JSON项。{"x": [1, 2], "y": [2, 4]}strict $.* ? (exists (@ ? (@[*] > 2)))2, 4
is unknown测试一个布尔条件是否是 unknown[-1, 2, 7, "infinity"]$[*] ? ((@ > 0) is unknown)"infinity"

上一页 上一级 下一页
9.14. XML 函数 起始页 9.16. 序列操作函数