json -> integer → json

jsonb -> integer → jsonb

提取 JSON 数组的第 n 个元素（数组元素从 0 开始索引，但负整数从结尾计数）。

'[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json -> 2 → {"c":"baz"}

'[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json -> -3 → {"a":"foo"}

json -> text → json

jsonb -> text → jsonb

提取具有给定键的 JSON 对象字段。

'{"a": {"b":"foo"}}'::json -> 'a' → {"b":"foo"}

json ->> integer → text

jsonb ->> integer → text

提取 JSON 数组的第 n 个元素，作为 text。

'[1,2,3]'::json ->> 2 → 3

json ->> text → 文本

jsonb ->> text → 文本

作为 文本，提取具有给定键的 JSON 对象字段。

'{"a":1,"b":2}'::json ->> 'b' → 2

json #> text[] → json

jsonb #> text[] → jsonb

提取指定路径处的 JSON 子对象，其中路径元素可以是字段键数组或索引。

'{"a": {"b": ["foo","bar"]}}'::json #> '{a,b,1}' → "bar"

json #>> text[] → 文本

jsonb #>> text[] → 文本

作为 文本，提取指定路径处的 JSON 子对象。

'{"a": {"b": ["foo","bar"]}}'::json #>> '{a,b,1}' → bar

jsonb @> jsonb → 布尔

第一个 JSON 值是否包含第二个 JSON 值？（有关包含的详细信息，请参见章节 8.14.3。）

'{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb → t

jsonb <@ jsonb → 布尔

第一个 JSON 值是否包含在第二个 JSON 值中？

'{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb → t

jsonb ? text → 布尔

文本字符串是否作为顶级键或 JSON 值内的数组元素存在？

'{"a":1, "b":2}'::jsonb ? 'b' → t

'["a", "b", "c"]'::jsonb ? 'b' → t

jsonb ?| text[] → 布尔

文本数组中的任何字符串是否作为顶级键或数组元素存在？

'{"a":1, "b":2, "c":3}'::jsonb ?| array['b', 'd'] → t

jsonb ?& text[] → 布尔值

文本数组中的所有字符串是否都作为顶级键或数组元素存在？

'["a", "b", "c"]'::jsonb ?& array['a', 'b'] → t

jsonb || jsonb → jsonb

连接两个 jsonb 值。连接两个数组会生成一个数组，其中包含每个输入的所有元素。连接两个对象会生成一个包含其键的并集的对象，当存在重复键时采用第二个对象的值。所有其他情况都通过将非数组输入转换为一个元素数组来处理，然后按两个数组进行处理。不会递归操作：只会合并顶级数组或对象结构。

'["a", "b"]'::jsonb || '["a", "d"]'::jsonb → ["a", "b", "a", "d"]

'{"a": "b"}'::jsonb || '{"c": "d"}'::jsonb → {"a": "b", "c": "d"}

'[1, 2]'::jsonb || '3'::jsonb → [1, 2, 3]

'{"a": "b"}'::jsonb || '42'::jsonb → [{"a": "b"}, 42]

若要将数组作为单个条目追加到另一个数组，请将其包装在额外的数组层中，例如

'[1, 2]'::jsonb || jsonb_build_array('[3, 4]'::jsonb) → [1, 2, [3, 4]]

jsonb - text → jsonb

从 JSON 对象中删除键（及其值），或从 JSON 数组中删除匹配的字符串值。

'{"a": "b", "c": "d"}'::jsonb - 'a' → {"c": "d"}

'["a", "b", "c", "b"]'::jsonb - 'b' → ["a", "c"]

jsonb - text[] → jsonb

删除左操作数中的所有匹配的键或数组元素。

'{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[] → {}

jsonb - integer → jsonb

删除具有指定索引的数组元素（负整数从末尾计数）。如果 JSON 值不是数组，则抛出错误。

'["a", "b"]'::jsonb - 1 → ["a"]

jsonb #- text[] → jsonb

删除指定路径处的字段或数组元素，其中路径元素可以是字段键或数组索引。

'["a", {"b":1}]'::jsonb #- '{1,b}' → ["a", {}]

jsonb @? jsonpath → 布尔值

JSON 路径为指定 JSON 值返回任意项目吗？（这仅与 SQL 标准 JSON 路径表达式而非谓词检查表达式谓词检查表达式一同使用时有用，因为后者始终返回一个值。）

'{"a":[1,2,3,4,5]}'::jsonb @? '$.a[*] ? (@ > 2)' → t

jsonb @@ jsonpath → boolean

返回针对指定 JSON 值的 JSON 路径谓词检查的结果。（这仅与谓词检查表达式而非 SQL 标准 JSON 路径表达式一同使用时有用，因为它将返回 NULL，如果路径结果不是一个单独的布尔值。）

'{"a":[1,2,3,4,5]}'::jsonb @@ '$.a[*] > 2' → t

to_json ( anyelement ) → json

to_jsonb ( anyelement ) → jsonb

将任何 SQL 值转换为 json 或 jsonb。数组和复合类型会递归式转换为数组和对象（多维数组在 JSON 中变为数组的数组）。否则，如果 SQL 数据类型可以转换为 json，则会使用转换函数执行转换;^[a] 否则，会生成一个标量 JSON 值。对于除数字、布尔或 null 值之外的任意标量，将使用文本表示形式，并按需要转义文本表示形式使其成为一个有效的 JSON 字符串值。

to_json('Fred 说 "Hi."'::text) → "Fred 说 \"Hi.\""

to_jsonb(row(42, 'Fred 说 "Hi."'::text)) → {"f1": 42, "f2": "Fred 说 \"Hi.\""}

array_to_json ( anyarray [, boolean ] ) → json

将 SQL 数组转换为 JSON 数组。如果可选布尔参数为 true，则行为与 to_json 相同，但顶层数组元素之间将添加换行符。

array_to_json('{{1,5},{99,100}}'::int[]) → [[1,5],[99,100]]

json_array ( [ { value_expression [ FORMAT JSON ] } [, ...] ] [ { NULL | ABSENT } ON NULL ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

json_array ( [ query_expression ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

从一系列 value_expression 参数或 query_expression（必须是一个只返回一列的 SELECT 查询）的结果构建一个 JSON 数组。如果指定 ABSENT ON NULL，则会忽略 NULL 值。如果使用 query_expression，则始终如此。

json_array(1,true,json '{"a":null}') → [1, true, {"a":null}]

json_array(SELECT * FROM (VALUES(1),(2)) t) → [1, 2]

row_to_json ( record [, boolean ] ) → json

将 SQL 复合值转换为 JSON 对象。如果可选布尔参数为 true，则行为与 to_json 相同，但顶层元素之间将添加换行符。

row_to_json(row(1,'foo')) → {"f1":1,"f2":"foo"}

json_build_array ( VARIADIC "any" ) → json

jsonb_build_array ( VARIADIC "any" ) → jsonb

将一个可变参数列表构建为一个可能类型不同的 JSON 数组。每个参数会按照 to_json 或 to_jsonb 进行转换。

json_build_array(1, 2, 'foo', 4, 5) → [1, 2, "foo", 4, 5]

json_build_object ( VARIADIC "any" ) → json

jsonb_build_object ( VARIADIC "any" ) → jsonb

将一个可变参数列表构建为一个 JSON 对象。按照惯例，参数列表包含交替出现的键和值。键参数强制转换为文本；值参数按照 to_json 或 to_jsonb 进行转换。

json_build_object('foo', 1, 2, row(3,'bar')) → {"foo" : 1, "2" : {"f1":3,"f2":"bar"}}

json_object ( [ { key_expression { VALUE | ':' } value_expression [ FORMAT JSON [ ENCODING UTF8 ] ] }[, ...] ] [ { NULL | ABSENT } ON NULL ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

用给定的所有键/值对来构造一个 JSON 对象，如果未给出任何值，则为一个空对象。key_expression 是一个标量表达式，定义JSON键，它会转换为 text 类型。它不能为 NULL，它也不属于会强制转换为 json 类型的类型。如果指定了 WITH UNIQUE KEYS，则不能出现重复的 key_expression。如果 ABSENT ON NULL 被指定，则其中的 value_expression 会评估为 NULL 的所有对都将省略输出结果；如果指定了 NULL ON NULL，或者省略此子句，则将包含该键的值 NULL。

json_object('code' VALUE 'P123', 'title': 'Jaws') → {"code" : "P123", "title" : "Jaws"}

json_object ( text[] ) → json

jsonb_object ( text[] ) → jsonb

从文本数组中构建 JSON 对象。数组必须具有恰好一个维度和偶数个成员，这种情况下，以它们作为交替的键值对；或者具有两个维度，使得每个内部数组恰好有 2 个元素，它们被视为键值对。所有值都转换 JSON 字符串。

json_object('{a, 1, b, "def", c, 3.5}') → {"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[] ) → json

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

这种形式的 json_object 从独立的文本数组中对键和值进行成对配对。在其他方面，它与一种参数形式相同。

json_object('{a,b}', '{1,2}') → {"a": "1", "b": "2"}

json ( expression [ FORMAT JSON [ ENCODING UTF8 ]] [ { WITH | WITHOUT } UNIQUE [ KEYS ]] ) → json

将指定为 text 或 bytea 字符串的给定表达式（采用 UTF8 编码）转换为 JSON 值。如果 expression 为 NULL，则SQL空值返回。如果指定了 WITH UNIQUE，则 expression 不得包含任何重复的对象键。

json('{"a":123, "b":[true,"foo"], "a":"bar"}') → {"a":123, "b":[true,"foo"], "a":"bar"}

json_scalar ( expression )

将给定的 SQL 标量值转换为 JSON 标量值。如果输入为 NULL，则SQL返回 null。如果输入是数字或布尔值，则返回相应的 JSON 数字或布尔值。对于任何其他值，则返回 JSON 字符串。

json_scalar(123.45) → 123.45

json_scalar(CURRENT_TIMESTAMP) → "2022-05-10T10:51:04.62128-04:00"

json_serialize ( 表达式 [ 格式 JSON [ 编码 UTF8 ] ] [ 返回 数据类型 [ 格式 JSON [ 编码 UTF8 ] ] ] )

将 SQL/JSON 表达式转换成字符或二进制字符串。 表达式 可以是任何 JSON 类型、任何字符类型字符串或 UTF8 编码下的 bytea。 返回 中使用的返回类型可以是任何字符类型字符串或 bytea。默认类型为 text。

json_serialize('{ "a" : 1 } ' RETURNING bytea) → \x7b20226122203a2031207d20

表达式 是 [ 并非 ] JSON [ { 值 | 标量 | 数组 | 对象 } ] [ { 具有 | 不具有 } 唯一 [ 键 ] ]

此谓词测试 表达式 是否可以解析为 JSON，它可以是指定类型。如果指定了 标量、数组 或 对象，则测试 JSON 是不是属于特定类型。如果指定了 具有唯一键，也将会测试 表达式 中的任何对象是否具有重复的键。

SELECT js,
  js IS JSON "json?",
  js IS JSON SCALAR "scalar?",
  js IS JSON OBJECT "object?",
  js IS JSON ARRAY "array?"
FROM (VALUES
      ('123'), ('"abc"'), ('{"a": "b"}'), ('[1,2]'),('abc')) foo(js);
     js     | json? | scalar? | object? | array?
------------+-------+---------+---------+--------
 123        | t     | t       | f       | f
 "abc"      | t     | t       | f       | f
 {"a": "b"} | t     | f       | t       | f
 [1,2]      | t     | f       | f       | t
 abc        | f     | f       | f       | f

SELECT js,
  js IS JSON OBJECT "object?",
  js IS JSON ARRAY "array?",
  js IS JSON ARRAY WITH UNIQUE KEYS "array w. UK?",
  js IS JSON ARRAY WITHOUT UNIQUE KEYS "array w/o UK?"
FROM (VALUES ('[{"a":"1"},
 {"b":"2","b":"3"}]')) foo(js);
-[ RECORD 1 ]-+--------------------
js            | [{"a":"1"},        +
              |  {"b":"2","b":"3"}]
object?       | f
array?        | t
array w. UK?  | f
array w/o UK? | t

json_array_elements ( json ) → json 集

jsonb_array_elements ( jsonb ) → setof jsonb

将顶层 JSON 数组扩展到一组 JSON 值。

select * from json_array_elements('[1,true, [2,false]]') →

   value
-----------
 1
 true
 [2,false]

json_array_elements_text ( json ) → setof text

jsonb_array_elements_text ( jsonb ) → setof text

将顶层 JSON 数组扩展到一组 text 值。

select * from json_array_elements_text('["foo", "bar"]') →

   value
-----------
 foo
 bar

json_array_length ( json ) → integer

jsonb_array_length ( jsonb ) → integer

返回顶层 JSON 数组中的元素数。

json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]') → 5

jsonb_array_length('[]') → 0

json_each ( json ) → setof record ( key text, value json )

jsonb_each ( jsonb ) → setof record ( key text, value jsonb )

将顶层 JSON 对象扩展到一组键/值对。

select * from json_each('{"a":"foo", "b":"bar"}') →

 key | value
-----+-------
 a   | "foo"
 b   | "bar"

json_each_text ( json ) → setof record ( key text, value text )

jsonb_each_text ( jsonb ) → setof record ( key text, value text )

将顶层 JSON 对象扩展到一组键/值对。返回的 value 类型为 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[] ) → json

jsonb_extract_path ( from_json jsonb, VARIADIC path_elems text[] ) → jsonb

从指定路径提取 JSON 子对象。（在功能上等于 #> 运算符，但在某些情况下，将路径写为变长列表会更方便。）

json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}', 'f4', 'f6') → "foo"

json_extract_path_text ( from_json json, VARIADIC path_elems text[] ) → text

jsonb_extract_path_text ( from_json jsonb, VARIADIC path_elems text[] ) → text

以 text 形式从指定路径中提取 JSON 子对象。（在功能上等于 #>> 运算符。）

json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}', 'f4', 'f6') → foo

json_object_keys ( json ) → setof text

jsonb_object_keys ( jsonb ) → setof text

返回顶级 JSON 对象中键的 set。

select * from json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}') →

 json_object_keys
------------------
 f1
 f2

json_populate_record ( base anyelement, from_json json ) → anyelement

jsonb_populate_record ( base anyelement, from_json jsonb ) → anyelement

将顶级 JSON 对象扩展到具有与 base 参数相同复合类型的行。该 JSON 对象会被扫描以寻找其名称与输出行类型的列名称匹配的字段，然后将字段值插入到输出行的这些列中。（与任何输出列名称不对应的字段将被忽略。）在典型用法中，base 的值为 NULL，这意味着在任何输出列中，与任何对象字段不匹配的列都将填充为 null 值。然而，如果 base 不为 NULL，则将使用它包含的值来填充与对象字段不匹配的列。

要将 JSON 值转换成输出列的 SQL 类型，将按如下顺序应用以下规则

虽然以下示例使用了常量 JSON 值，但典型用法是在查询的 FROM 子句中从另一个表的某一 json 或 jsonb 侧向引用一个列。在 FROM 子句中编写 json_populate_record 是一个好习惯，因为所有提取的列都可以使用，无需重复函数调用

create type subrowtype as (d int, e text); create type myrowtype as (a int, b text[], c subrowtype);

select * from json_populate_record(null::myrowtype, '{"a": 1, "b": ["2", "a b"], "c": {"d": 4, "e": "a b c"}, "x": "foo"}') →

 a |   b       |      c
---+-----------+-------------
 1 | {2,"a b"} | (4,"a b c")

jsonb_populate_record_valid ( base anyelement, from_json json ) → boolean

用于测试 jsonb_populate_record 的函数。如果输入 jsonb_populate_record 对于给定的输入 JSON 对象运行且不会出错，则返回 true；也就是说，它是有效输入，否则返回 false

create type jsb_char2 as (a char(2));

select jsonb_populate_record_valid(NULL::jsb_char2, '{"a": "aaa"}'); →

 jsonb_populate_record_valid
-----------------------------
 f
(1 row)

select * from jsonb_populate_record(NULL::jsb_char2, '{"a": "aaa"}') q; →

ERROR:  value too long for type character(2)

select jsonb_populate_record_valid(NULL::jsb_char2, '{"a": "aa"}'); →

 jsonb_populate_record_valid
-----------------------------
 t
(1 row)

select * from jsonb_populate_record(NULL::jsb_char2, '{"a": "aa"}') q; →

 a
----
 aa
(1 row)

json_populate_recordset ( base anyelement, from_json json ) → setof anyelement

jsonb_populate_recordset ( base anyelement, from_json jsonb ) → setof anyelement

将对象顶级 JSON 数组扩展到一组行的组合类型，此组合类型由 base 参数确定。处理 JSON 数组的每个元素时，都采用上述针对 json[b]_populate_record 所述的方法。

create type twoints as (a int, b int);

select * from json_populate_recordset(null::twoints, '[{"a":1,"b":2}, {"a":3,"b":4}]') →

 a | b
---+---
 1 | 2
 3 | 4

json_to_record ( json ) → record

jsonb_to_record ( jsonb ) → record

将顶级 JSON 对象扩展到一行，此行的组合类型由 AS 子句定义。（与所有返回 record 的函数一样，调用查询必须使用 AS 子句明确定义记录的结构。）通过 JSON 对象的字段来填充输出记录，其方法如上文针对 json[b]_populate_record 所述相同。由于没有输入记录值，因此不匹配的列始终填充为 null。

create type myrowtype as (a int, b text);

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 ) → setof record

jsonb_to_recordset ( jsonb ) → setof record

将对象顶级 JSON 数组扩展到一组行的组合类型，此组合类型由 AS 子句定义。（与所有返回 record 的函数一样，调用查询必须使用 AS 子句明确定义记录的结构。）处理 JSON 数组的每个元素时，都采用上述针对 json[b]_populate_record 所述的方法。

select * from json_to_recordset('[{"a":1,"b":"foo"}, {"a":"2","c":"bar"}]') as x(a int, b text) →

 a |  b
---+-----
 1 | foo
 2 |

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

返回 target，其中由 path 指定的项替换为 new_value，或者如果 create_if_missing 为 true（这是默认值），且由 path 指定的项不存在，则添加 new_value。路径中的所有早期步骤必须存在，否则 target 保持不变。与面向路径的操作符一样，出现在 path 中的负整数从 JSON 数组的末尾计数。如果最后一个路径步骤是一个超出范围的数组索引，并且 create_if_missing 为 true，则如果索引为负，则在数组的开头添加新值，否则如果索引为正，则在数组的末尾添加新值。

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

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

jsonb_set_lax ( target jsonb, path text[], new_value jsonb [, create_if_missing boolean [, null_value_treatment text ]] ) → jsonb

如果 new_value 不为 NULL，则行为与 jsonb_set 相同。否则，根据 null_value_treatment 的值执行行为，该值必须为 'raise_exception'、'use_json_null'、'delete_key' 或 'return_target' 中的一个。默认值为 'use_json_null'。

jsonb_set_lax('[{"f1":1,"f2":null},2,null,3]', '{0,f1}', null) → [{"f1": null, "f2": null}, 2, null, 3]

jsonb_set_lax('[{"f1":99,"f2":null},2]', '{0,f3}', null, true, 'return_target') → [{"f1": 99, "f2": null}, 2]

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

返回已插入 new_value 的 target。如果 path 指定的项是数组元素，如果 insert_after 为 false（这是默认值），则将在该项之前插入 new_value；如果 insert_after 为 true，则将在该项之后插入。如果 path 指定的项是对象字段，则仅当对象还没有包含该键的情况下才会插入 new_value。路径中的所有较早步骤都必须存在，否则 target 将保持不变。与面向路径的操作符一样，如果 path 中的负整数出现在 JSON 数组的末尾。如果最后路径步骤是范围外的数组索引，则如果索引为负数，新值将添加到数组的开头；如果索引为正数，则将添加到数组的末尾。

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

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

json_strip_nulls ( json ) → json

jsonb_strip_nulls ( jsonb ) → jsonb

从给定的 JSON 值中递归删除所有具有空值的字段。没有设定空值的字段不受影响。

json_strip_nulls('[{"f1":1, "f2":null}, 2, null, 3]') → [{"f1":1},2,null,3]

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

检查 JSON 路径是否返回指定 JSON 值的任何项。（这仅与 SQL 标准 JSON 路径表达式一起使用时才很有用，不适用于 谓词检查表达式，因为这些表达式始终会返回一个值。）如果指定了 vars 参数，它必须是一个 JSON 对象，且其字段提供了要替换到 jsonpath 表达式中的命名值。如果指定了 silent 参数并且是 true，则该函数会抑制与 @? 和 @@ 运算符相同的错误。

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

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

返回指定 JSON 值的 JSON 路径谓词检查的结果。（这仅对 谓词检查表达式 有用，而不是 SQL 标准 JSON 路径表达式，因为如果路径结果不是单个布尔值，它将失败或返回 NULL。）可选的 vars 和 silent 参数与 jsonb_path_exists 中的作用相同。

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

jsonb_path_query ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → setof jsonb

返回指定 JSON 值的 JSON 路径返回的所有 JSON 项。对于 SQL 标准 JSON 路径表达式，它返回从 target 中选择的 JSON 值。对于 谓词检查表达式，它返回谓词检查的结果：true、false 或 null。可选的 vars 和 silent 参数与 jsonb_path_exists 中的作用相同。

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 boolean ]] ) → jsonb

将指定 JSON 值的 JSON 路径返回的所有 JSON 项，作为 JSON 数组返回。参数与 jsonb_path_query 相同。

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 boolean ]] ) → jsonb

返回指定的 JSON 值的 JSON 路径返回的第一个 JSON 项，如果没有任何结果，则返回 NULL。参数与 jsonb_path_query 的参数相同。

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

jsonb_path_exists_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

jsonb_path_match_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

jsonb_path_query_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → setof jsonb

jsonb_path_query_array_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

jsonb_path_query_first_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

这些函数的行为与上面描述的对等函数类似，没有 _tz 后缀，不同之处在于这些函数支持需要具有时区感知转换的日期/时间值比较。下面的示例需要将只含日期的值 2015-08-02 作为带时区的 timestamp 进行解释，所以结果取决于当前设置的 TimeZone。因为存在此依赖性，所以这些函数被标记为 stable，这意味着不能在索引中使用这些函数。它们的对等函数不可变，因此可以在索引中使用；但如果要求进行此类比较，则它们将抛出错误。

jsonb_path_exists_tz('["2015-08-01 12:00:00-05"]', '$[*] ? (@.datetime() < "2015-08-02".datetime())') → t

jsonb_pretty ( jsonb ) → text

将给定的 JSON 值转换为漂亮打印的缩进文本。

jsonb_pretty('[{"f1":1,"f2":null}, 2]') →

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

json_typeof ( json ) → text

jsonb_typeof ( jsonb ) → text

将最顶层的 JSON 值的类型作为文本字符串返回。可能的类型有 object、array、string、number、boolean 和 null。（null 结果不应该与 SQL NULL 混淆；请参见示例。）

json_typeof('-123.4') → number

json_typeof('null'::json) → null

json_typeof(NULL::json) IS NULL → t