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 個元素，作為 text。

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

json ->> text → text

jsonb ->> text → text

提取具有給定鍵的 JSON 物件欄位，作為 text。

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

將指定路徑的 JSON 子物件提取為 text。

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

jsonb @> jsonb → boolean

第一個 JSON 值是否包含第二個？（有關包含的詳細資訊，請參閱 第 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 中的陣列和物件（多維陣列成為 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 的結果構造一個 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 相同，不同之處在於，如果可選的布林引數為 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鍵，它被轉換為 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，則返回一個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。

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 ( target json [,strip_in_arrays boolean ] ) → json

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

遞迴地從給定 JSON 值中刪除所有具有 null 值的物件欄位。如果 strip_in_arrays 為 true（預設值為 false），則也會刪除空陣列元素。否則它們不會被刪除。裸 null 值永遠不會被刪除。

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

示例

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

示例

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

示例

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