json和jsonb 操作符
| 操作符 | 右操作數類型 | 描述 | 例子 | 例子結果 |
|---|---|---|---|---|
-> |
int |
獲得 JSON 數組元素（索引從 0 開始，負整數從末尾開始計） | '[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json->2 |
{"c":"baz"} |
-> |
text |
通過鍵獲得 JSON 對象域 | '{"a": {"b":"foo"}}'::json->'a' |
{"b":"foo"} |
->> |
int |
以text形式獲得 JSON 數組元素 |
'[1,2,3]'::json->>2 |
3 |
->> |
text |
以text形式獲得 JSON 對象域 |
'{"a":1,"b":2}'::json->>'b' |
2 |
#> |
text[] |
獲取在指定路徑的 JSON 對象 | '{"a": {"b":{"c": "foo"}}}'::json#>'{a,b}' |
{"c": "foo"} |
#>> |
text[] |
以text形式獲取在指定路徑的 JSON 對象 |
'{"a":[1,2,3],"b":[4,5,6]}'::json#>>'{a,2}' |
3 |
額外的jsonb操作符
| 操作符 | 右操作數類型 | 描述 | 例子 |
|---|---|---|---|
@> |
jsonb |
左邊的 JSON 值是否在頂層包含右邊的 JSON 路徑/值項？ | '{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb |
<@ |
jsonb |
左邊的 JSON 路徑/值項是否被包含在右邊的 JSON 值的頂層？ | '{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb |
? |
text |
鍵/元素字符串是否存在於 JSON 值的頂層？ | '{"a":1, "b":2}'::jsonb ? 'b' |
?| |
text[] |
這些數組字符串中的任何一個是否做爲頂層鍵存在？ | '{"a":1, "b":2, "c":3}'::jsonb ?| array['b', 'c'] |
?& |
text[] |
是否所有這些數組字符串都作爲頂層鍵存在？ | '["a", "b"]'::jsonb ?& array['a', 'b'] |
|| |
jsonb |
把兩個jsonb值串接成一個新的jsonb值 |
'["a", "b"]'::jsonb || '["c", "d"]'::jsonb |
- |
text |
從左操作數刪除鍵/值對或者string 元素。鍵/值對基於它們的鍵值來匹配。 | '{"a": "b"}'::jsonb - 'a' |
- |
text[] |
從左操作數中刪除多個鍵/值對或者string元素。鍵/值對基於它們的鍵值來匹配。 | '{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[] |
- |
integer |
刪除具有指定索引（負值表示倒數）的數組元素。如果 頂層容器不是數組則拋出一個錯誤。 | '["a", "b"]'::jsonb - 1 |
#- |
text[] |
刪除具有指定路徑的域或者元素（對於 JSON 數組，負值 表示倒數） | '["a", {"b":1}]'::jsonb #- '{1,b}' |
JSON 創建函數
| 函數 | 描述 | 例子 | 例子結果 |
|---|---|---|---|
|
|
把該值返回爲json或者jsonb。數組和組合 會被（遞歸）轉換成數組和對象；對於不是數組和組合的值，如果有 從該類型到json的造型，造型函數將被用來執行該 轉換；否則將產生一個標量值。對於任何不是數字、布爾、空值的標 量類型，將使用文本表達，在這種風格下它是一個合法的 json或者jsonb值。 |
to_json('Fred said "Hi."'::text) |
"Fred said \"Hi.\"" |
array_to_json(anyarray [, pretty_bool]) |
把數組作爲一個 JSON 數組返回。一個 PostgreSQL 多維數組會成爲一個數組 的 JSON 數組。如果pretty_bool爲真，將在 第 1 維度的元素之間增加換行。 |
array_to_json('{{1,5},{99,100}}'::int[]) |
[[1,5],[99,100]] |
row_to_json(record [, pretty_bool]) |
把行作爲一個 JSON 對象返回。如果pretty_bool爲真，將在第1層元素之間增加換行。 |
row_to_json(row(1,'foo')) |
{"f1":1,"f2":"foo"} |
|
|
從一個可變參數列表構造一個可能包含異質類型的 JSON 數組。 | json_build_array(1,2,'3',4,5) |
[1, 2, "3", 4, 5] |
|
|
從一個可變參數列表構造一個 JSON 對象。通過轉換，該參數列表由交替 出現的鍵和值構成。 | json_build_object('foo',1,'bar',2) |
{"foo": 1, "bar": 2} |
|
|
從一個文本數組構造一個 JSON 對象。該數組必須可以是具有偶數個成員的 一維數組（成員被當做交替出現的鍵/值對），或者是一個二維數組（每一個 內部數組剛好有 2 個元素，可以被看做是鍵/值對）。 |
|
{"a": "1", "b": "def", "c": "3.5"} |
|
|
json_object的這種形式從兩個獨立的數組得到鍵/值對。在其 他方面和一個參數的形式相同。 |
json_object('{a, b}', '{1,2}') |
{"a": "1", "b": "2"} |
JSON 處理
| 函數 | 返回值 | 描述 | 例子 | 例子結果 |
|---|---|---|---|---|
|
|
int |
返回最外層 JSON 數組中的元素數量。 | json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]') |
5 |
|
|
|
擴展最外層的 JSON 對象成爲一組鍵/值對。 | select * from json_each('{"a":"foo", "b":"bar"}') |
key | value -----+------- a | "foo" b | "bar" |
|
|
setof key text, value text |
擴展最外層的 JSON 對象成爲一組鍵/值對。返回值將是text類型。 |
select * from json_each_text('{"a":"foo", "b":"bar"}') |
key | value -----+------- a | foo b | bar |
|
|
|
返回由path_elems指向的 JSON 值（等效於#>操作符）。 |
json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4') |
{"f5":99,"f6":"foo"} |
|
|
text |
以text返回由path_elems指向的 JSON 值（等效於#>>操作符）。 |
json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}','f4', 'f6') |
foo |
|
|
setof text |
返回最外層 JSON 對象中的鍵集合。 | json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}') |
json_object_keys ------------------ f1 f2 |
|
|
anyelement |
擴展from_json中的對象成一個行，它的列匹配由base定義的記錄類型（見下文的註釋）。 |
select * from json_populate_record(null::myrowtype, '{"a": 1, "b": ["2", "a b"], "c": {"d": 4, "e": "a b c"}}') |
a | b | c
---+-----------+-------------
1 | {2,"a b"} | (4,"a b c")
|
|
|
setof anyelement |
擴展from_json中最外的對象數組爲一個集合，該集合的列匹配由base定義的記錄類型。 |
select * from json_populate_recordset(null::myrowtype, '[{"a":1,"b":2},{"a":3,"b":4}]') |
a | b ---+--- 1 | 2 3 | 4 |
|
|
|
把一個 JSON 數組擴展成一個 JSON 值的集合。 | select * from json_array_elements('[1,true, [2,false]]') |
value ----------- 1 true [2,false] |
|
|
setof text |
把一個 JSON 數組擴展成一個text值集合。 |
select * from json_array_elements_text('["foo", "bar"]') |
value ----------- foo bar |
|
|
text |
把最外層的 JSON 值的類型作爲一個文本字符串返回。可能的類型是： object、array、string、number、 boolean以及null。 |
json_typeof('-123.4') |
number |
|
|
record |
從一個 JSON 對象（見下文的註解）構建一個任意的記錄。正如所有返回record 的函數一樣，調用者必須用一個AS子句顯式地定義記錄的結構。 |
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")
|
|
|
setof record |
從一個 JSON 對象數組（見下文的註解）構建一個任意的記錄集合。正如所有返回record 的函數一樣，調用者必須用一個AS子句顯式地定義記錄的結構。 |
select * from json_to_recordset('[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]') as x(a int, b text); |
a | b ---+----- 1 | foo 2 | |
|
|
|
返回from_json，其中所有具有空值的 對象域都被省略。其他空值不動。 |
json_strip_nulls('[{"f1":1,"f2":null},2,null,3]') |
[{"f1":1},2,null,3] |
|
|
|
返回target，其中由 path指定的節用 new_value替換，如果 path指定的項不存在並且 create_missing爲真（默認爲 true）則加上 new_value。正如面向路徑的 操作符一樣，出現在path中的 負整數表示從 JSON 數組的末尾開始數。 |
|
|
|
|
|
返回被插入了new_value的target。如果path指定的target節在一個 JSONB 數組中，new_value將被插入到目標之前（insert_after爲false，默認情況）或者之後（insert_after爲真）。如果path指定的target節在一個 JSONB 對象內，則只有當target不存在時才插入new_value。對於面向路徑的操作符來說，出現在path中的負整數表示從 JSON 數組的末尾開始計數。 |
|
|
|
|
|
把from_json返回成一段 縮進後的 JSON 文本。 |
jsonb_pretty('[{"f1":1,"f2":null},2,null,3]') |
[
{
"f1": 1,
"f2": null
},
2,
null,
3
]
|
上面內容看起來比較晦澀，其實postgreSQL中json函數的操作在實際用的時候也是比較方便的。
發文筆記本沒有安裝數據庫工具，公司不能訪問外網，就不上代碼了
我在csdn已經找到同僚分析的代碼部分示例，相信你看過我轉載的內容，就能對json有個新的認知，一通百通。理解這一個，其他的函數，自己嘗試驗證一下。
一、 -> 和 ->> ：
-> 表示獲取一個JSON數組元素，支持下標值(下標從0開始)、Key獲取。->> 表示獲取一個JSON對象字符串。
代碼：
SELECT '[{"a":1},{"b":2},{"c":3}]'::JSON -> 1;
結果：
{"b":2}
以上，::JSON 表示聲明前面的字符串爲一個JSON字符串對象，而且PostgreSQL中的JSON、JSONB對象 Key的聲明必須是字符串 。同時，1表示獲取JSON數組中下標值爲1的JSON對象。
接下來，看下 ->> 的用法：
代碼：
SELECT '[{"a":1},{"b":2},{"c":3}]'::JSON ->> 1;
結果：
{"b":2}
以上，->> 的查詢結果和 -> 對比不太直觀，我們可以進一步驗證。
代碼：
SELECT '[{"a":1},{"b":2},{"c":3}]'::JSON -> 1 -> 'b';
結果：
2
以上，我們可以看到首先我們使用下標的方式，獲取JSON數組中下標值爲1的JSON對象 {"b":2}。然後，我們通過Key的方式來獲取這個JSON對象的Value值，結果是 2。
接下來，我們測試下 ->> 的方式來獲取：
代碼：
SELECT '[{"a":1},{"b":2},{"c":3}]'::JSON ->> 1 -> 'b';
報錯：
[SQL]SELECT '[{"a":1},{"b":2},{"c":3}]'::JSON ->> 1 -> 'b';
[Err] 錯誤: 操作符不存在: text -> unknown
LINE 1: SELECT '[{"a":1},{"b":2},{"c":3}]'::JSON ->> 1 -> 'b';
^
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.
以上，可以看到錯誤提示操作符不存在，因爲第一步查詢出來的是一個字符串，不是JSON對象。當然，我們可以改造下這個查詢語句：
代碼：
SELECT ('[{"a":1},{"b":2},{"c":3}]'::JSON ->> 1)::JSON -> 'b';
結果：
2
以上，可以看到現在可以正確查詢出結果，我們將第一步查詢出來的字符串轉成JSON對象，然後通過 Key 的方式來獲取 Value。不過，這種查詢方式相對於 -> 來說還是比較繁瑣的。
二、 #> 和 #>> ：
在前一步，我們在一個JSON數組中可以使用 -> 下標值的方式來獲取一個JSON對象。但是，如果我們我們檢索的不是JSON數組，而是一個JSON對象中的JSON對象。很顯然，這種下標獲取的方式不再適用。不過，我們可以使用下面的方式來獲取。
#> 表示獲取指定路徑的一個JSON對象，#>>表示獲取指定路徑的一個JSON對象的字符串。
代碼：
SELECT '{"a":1,"b":{"ba":"b1","bb":"b2"},"c":3}'::JSON #> '{b}'
結果：
{"ba":"b1","bb":"b2"}
以上，我們使用 #> 方式來獲取一個JSON對象中的JSON對象。
注意：
在獲取一個JSON對象時，除非是JSON數組中的下標，必須要要用 { } 將JSON對象的 Key 包裹起來，否則會拋出異常。
代碼：
SELECT '{"a":1,"b":{"ba":"b1","bb":"b2"},"c":3}'::JSON#>'b'
結果：
[SQL]SELECT '{"a":1,"b":{"ba":"b1","bb":"b2"},"c":3}'::JSON#>'b'
[Err] 錯誤: 有缺陷的數組常量:"b"
LINE 1: SELECT '{"a":1,"b":{"ba":"b1","bb":"b2"},"c":3}'::JSON#>'b'
^
DETAIL: 數組值必須以 "{" 或者維度信息開始。
同樣的，我們還可以在 #> 的基礎上，繼續獲取這個JSON對象內的相關信息。
代碼：
SELECT '{"a":1,"b":{"ba":"b1","bb":"b2"},"c":3}'::JSON#>'{b}'->'ba'
結果：
"b1"
以上，可以看到 -> 獲取的是一個JSON對象。->>是獲取的一個text 文本