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

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

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

json ->> 文本 → 文本

jsonb ->> 文本 → 文本

将指定的键值提取 JSON 对象字段作为 文本。

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

json #> 文本数组 → json

jsonb #> 文本数组 → jsonb

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

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

json #>> 文本数组 → 文本

jsonb #>> 文本数组 → 文本

将指定路径中的 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 ? 文本 → 布尔值

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

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

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

jsonb ?| 文本数组 → 布尔值

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

'{"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 相同，但如果可选布尔参数为 true，则会在顶级数组元素之间添加换行符。

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 对象。行为与 to_json 相同，但如果可选布尔参数为 true，则会在顶级元素之间添加换行符。

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 的标量表达式key，转换为 text 类型。它不能是 NULL，也不能属于可以转换为 json 类型的类型。如果指定了 WITH UNIQUE KEYS，则不能有任何重复的 key_expression。如果指定了 ABSENT ON NULL，则对于 value_expression 评估为 NULL 的任何对从输出中省略；如果指定了 NULL ON NULL 或省略该子句，则 key 包含在值 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，则SQLnull 值返回。如果指定了 WITH UNIQUE，则 expression 不得包含任何重复对象键。

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

json_scalar ( expression )

将给定的 SQL 标量值转换为 JSON 标量值。如果输入为 NULL，则SQLnull 返回。如果是数字或布尔值，则返回相应的 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，可能为指定类型。如果指定了 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

将指定路径处的 JSON 子对象作为 text 提取。（这在功能上等同于 #>> 运算符。）

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，这意味着不匹配任何对象字段的任何输出列都将填充为 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 所述。由于没有输入记录值，因此不匹配的列始终填充为 null。

创建 myrowtype 类型为 (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

使用 new_value 替换 path 指定的项目，或在 create_if_missing 为 true（这是默认值）且 path 指定的项目不存在时添加 new_value，返回 target。路径中的所有较早步骤必须存在，否则 target 将保持不变。与面向路径的 operator 一样，出现在 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，则 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 (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 解释为带有时区的 时间戳，因此结果取决于当前 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