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 值是否包含於第二個 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 相同，差別在於如果選擇性的布林參數為 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 陣列，query_expression 必須是一個 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。 如果 value_expression 評估為 NULL，且指定了 ABSENT ON 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

將指定的表示式（以 UTF8 編碼的 text 或 bytea 字串形式）轉換為 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 的函數。如果輸入 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 解釋為帶有時區的時間戳記，因此結果取決於目前的 TimeZone 設定。由於這種依賴性，這些函數被標記為 stable，這意味著這些函數不能在索引中使用。它們的對應函數是 immutable，因此可以在索引中使用；但是，如果要求進行此類比較，它們將會拋出錯誤。

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