json -> integer → json

jsonb -> integer → jsonb

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

'[{"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

以 text 提取 JSON 数组的第 n 个元素。

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

json ->> text → text

jsonb ->> text → text

用给定的键以 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[] → text

jsonb #>> text[] → text

以 text 在指定的路径上提取 JSON 子对象。

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

jsonb @> jsonb → boolean

第一个 JSON 值是否包含第二个？ （关于包含关系的细节请参见 Section 8.14.3。）

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

jsonb <@ jsonb → boolean

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

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

jsonb ? text → boolean

该文本字符串是否作为顶层键或数组元素存在于 JSON 值之中？

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

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

jsonb ?| text[] → boolean

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

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

jsonb ?& text[] → boolean

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

'["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 → boolean

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 值。 对于数字、布尔或空值之外的任何标量， 将使用其文本表示， 并在必要时进行转义以构成合法的 JSON 字符串值。

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

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

array_to_json ( anyarray [, boolean ] ) → json

把一个 SQL 数组转换为一个 JSON 数组。 行为与 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 的结果构造一个 JSON 数组， 后者必须是一条返回单列的 SELECT 查询。 如果指定了 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 对象。 行为与 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 对象。 该数组必须恰好有一个维度且成员数量为偶数， 在那种情况下它们被当作交替的键/值对； 或者有两个维度， 使得每个内部数组恰好有两个元素， 它们被当作一个键/值对。 所有的值都会被转换为 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 空。 如果输入是数字或布尔值， 则返回相应的 JSON 数字或布尔值。 对于任何其他值， 则返回一个 JSON 字符串。

json_scalar(123.45) → 123.45

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

json_serialize ( expression [ FORMAT JSON [ ENCODING UTF8 ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ] )

把一个 SQL/JSON 表达式转换为字符或二进制字符串。 expression 可以是任何 JSON 类型、 任何字符串类型， 或 UTF8 编码的 bytea。 在 RETURNING 中使用的返回类型可以是任何字符串类型或 bytea。 默认为 text。

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

expression IS [ NOT ] JSON [ { VALUE | SCALAR | ARRAY | OBJECT } ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ]

这个谓词测试 expression 是否可以被解析为 JSON， 可能是某种指定类型的 JSON。 如果指定了 SCALAR 或 ARRAY 或 OBJECT， 那么测试的就是 JSON 是否属于那种特定的类型。 如果指定了 WITH UNIQUE KEYS， 那么 expression 中的任何对象也都会被测试是否拥有重复的键。

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 ) → setof 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 对象中键的集合。

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， 这意味着任何不匹配任何对象字段的输出列都会被填充为空。 然而， 如果 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 的函数。 如果对于给定的输入 JSON 对象， 一次 jsonb_populate_record 输入会不出错地完成 （也就是说， 它是有效的输入）， 则返回 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 描述的相同。 由于没有输入记录值， 未匹配的列总是被填充为空。

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 为真 （这是默认值） 且由 path 指定的项不存在， 则加入 new_value。 路径中所有更早的步骤都必须存在， 否则会原样返回 target。 与面向路径的操作符一样， path 中出现的负整数从 JSON 数组的末尾开始计数。 如果最后的路径步骤是一个越界的数组索引， 并且 create_if_missing 为真， 那么当索引为负时， 新值会被加在数组的开头， 为正时加在末尾。

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 为假 （这是默认值） 时， new_value 会被插在该项之前， 为真时插在其后。 如果由 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 ( target json [,strip_in_arrays boolean ] ) → json

jsonb_strip_nulls ( target jsonb [,strip_in_arrays boolean ] ) → jsonb

递归地从给定的 JSON 值中删除所有具有空值的对象字段。 如果 strip_in_arrays 为真 （默认为假）， 空的数组元素也会被去除。 否则它们不会被去除。 单纯的空值永远不会被去除。

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

jsonb_strip_nulls('[1,2,null,3,4]', true) → [1,2,3,4]

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 布尔结果。 （这只对 谓词检查表达式 有用， 对 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 解释为一个带时区的时间戳， 因此结果取决于当前的 TimeZone 设置。 由于这种依赖关系， 这些函数被标记为稳定的， 这意味着它们不能被用在索引中。 它们的对应函数是不可变的， 因此可以用于索引； 但如果被要求做这样的比较， 它们会抛出错误。

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

JSON_EXISTS (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[{ TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ]) → boolean

Examples:

JSON_EXISTS(jsonb '{"key1": [1,2,3]}', 'strict $.key1[*] ? (@ > $x)' PASSING 2 AS x) → t

JSON_EXISTS(jsonb '{"a": [1,2,3]}', 'lax $.a[5]' ERROR ON ERROR) → f

JSON_EXISTS(jsonb '{"a": [1,2,3]}', 'strict $.a[5]' ERROR ON ERROR) →

ERROR:  jsonpath array subscript is out of bounds

JSON_QUERY (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ]
[ { WITHOUT | WITH { CONDITIONAL | [UNCONDITIONAL] } } [ ARRAY ] WRAPPER ]
[ { KEEP | OMIT } QUOTES [ ON SCALAR STRING ] ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT expression } ON EMPTY ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT expression } ON ERROR ]) → jsonb

Examples:

JSON_QUERY(jsonb '[1,[2,3],null]', 'lax $[*][$off]' PASSING 1 AS off WITH CONDITIONAL WRAPPER) → 3

JSON_QUERY(jsonb '{"a": "[1, 2]"}', 'lax $.a' OMIT QUOTES) → [1, 2]

JSON_QUERY(jsonb '{"a": "[1, 2]"}', 'lax $.a' RETURNING int[] OMIT QUOTES ERROR ON ERROR) →

ERROR:  malformed array literal: "[1, 2]"
DETAIL:  Missing "]" after array dimensions.

JSON_VALUE (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[ RETURNING data_type ]
[ { ERROR | NULL | DEFAULT expression } ON EMPTY ]
[ { ERROR | NULL | DEFAULT expression } ON ERROR ]) → text

Examples:

JSON_VALUE(jsonb '"123.45"', '$' RETURNING float) → 123.45

JSON_VALUE(jsonb '"03:04 2015-02-01"', '$.datetime("HH24:MI YYYY-MM-DD")' RETURNING date) → 2015-02-01

JSON_VALUE(jsonb '[1,2]', 'strict $[$off]' PASSING 1 as off) → 2

JSON_VALUE(jsonb '[1,2]', 'strict $[*]' DEFAULT 9 ON ERROR) → 9