# JSON/JSONB函数
JSON/JSONB函数表示可以用于JSON类型（请参考[JSON类型](https://support.huaweicloud.com/sqlreference-911-dws/dws_06_0020.html)）数据的函数。
![](https://support.huaweicloud.com/sqlreference-911-dws/public_sys-resources/note_3.0-zh-cn.png)
JSON/JSONB函数只提供基础功能，如有其他复杂或特殊性能要求场景，请联系技术工程师进行评估。
#### array_to_json(anyarray \[, pretty_bool\])
描述：返回JSON类型的数组。一个多维数组成为一个JSON数组的数组。如果pretty_bool设置为true，将在一维元素之间添加换行符。
返回类型：json
示例：
```
SELECT array_to_json('{{1,5},{99,100}}'::int[]);
array_to_json
------------------
[[1,5],[99,100]]
(1 row)
```
#### row_to_json(record \[, pretty_bool\])
描述：返回JSON类型的行。如果pretty_bool设置为true，将在第一级元素之间添加换行符。
返回类型：json
示例：
```
SELECT row_to_json(row(1,'foo'));
     row_to_json     
---------------------
 {"f1":1,"f2":"foo"}
(1 row)
```
#### json_agg(any)
描述：将值聚集为json数组。
返回类型：array-json
示例：
```
SELECT * FROM classes;
 name | score
 -----+-------
 A    |     2
 A    |     3
 D    |     5
 D    | 
(4 rows)    
SELECT name, json_agg(score) score FROM classes group by name order by name;
 name |      score
 -----+-----------------
 A    | [2, 3]
 D    | [5, null]
      | [null] 
(3 rows)
```
#### json_object_agg(any, any)
描述：将值聚集为json对象。
返回类型：json
示例：
```
SELECT * FROM classes;
 name | score
 -----+-------
 A    |     2
 A    |     3
 D    |     5
 D    |
(4 rows)
 
SELECT json_object_agg(name, score) FROM classes group by name order by name;
     json_object_agg
-------------------------
 { "A" : 2, "A" : 3 }
 { "D" : 5, "D" : null }
(2 rows)
```
#### json_build_array(VARIADIC "any")
描述：从可变参数列表中构建一个可能是异构类型的JSON数组。
返回类型：json
示例：
```
SELECT json_build_array(1,2,'3',4,5);
 json_build_array
-------------------
 [1, 2, "3", 4, 5]
(1 row)
```
#### json_build_object(VARIADIC "any")
描述：从可变参数列表中构建JSON对象。参数列表由交替的键和值组成。其入参必须为偶数个，两两一组组成键值对。注意键不可为null。
返回类型：json
示例：
```
SELECT json_build_object('foo',1,'bar',2);
   json_build_object
------------------------
 {"foo" : 1, "bar" : 2}
(1 row)
```
#### json_object(text\[\])、json_object(text\[\], text\[\])
描述：从文本数组中构建JSON对象。
这是个重载函数，当入参为一个文本数组的时候，其数组长度必须为偶数，成员被当做交替出现的键/值对。两个文本数组的时候，第一个数组被视为键，第二个被视为值，两个数组长度必须相等。键不可为null。
返回类型：json
示例：
```
SELECT json_object('{a, 1, b, "def", c, 3.5}');
              json_object
---------------------------------------
 {"a" : "1", "b" : "def", "c" : "3.5"}
(1 row)
SELECT json_object('{{a, 1},{b, "def"},{c, 3.5}}');
              json_object
---------------------------------------
 {"a" : "1", "b" : "def", "c" : "3.5"}
(1 row)
SELECT json_object('{a,b,"a b c"}', '{a,1,1}');
                json_object
 ---------------------------------------
 {"a" : "a", "b" : "1", "a b c" : "1"}
(1 row)
```
#### to_json(anyelement)
描述：把参数转换为json。
返回类型：json
示例：
```
SELECT to_json('Fred said "Hi."'::text);
       to_json
---------------------
 "Fred said \"Hi.\""
(1 row)
---将列存表json_tbl_2转换为json
SELECT * FROM json_tbl_2;
  a |  b 
 ---+-----
  1 | aaa 
  1 | bbb 
  2 | ccc  
  2 | ddd 
 (4 rows) 
SELECT to_json(t.*) FROM json_tbl_2 t;
      to_json
-------------------
 {"a":1,"b":"bbb"}
 {"a":2,"b":"ddd"}
 {"a":1,"b":"aaa"}
 {"a":2,"b":"ccc"}
(4 rows)
```
#### json_strip_nulls(json)
描述：所有具有空值的对象字段被忽略，其他值保持不变。
返回类型：json
示例：
```
SELECT json_strip_nulls('[{"f1":1,"f2":null},2,null,3]');
  json_strip_nulls
---------------------
 [{"f1":1},2,null,3]
(1 row)
```
#### json_object_field(json, text)
描述：同操作符-\>, 返回对象中指定键对应的值。
返回类型：json
示例：
```
SELECT json_object_field('{"a": {"b":"foo"}}','a');
 json_object_field
-------------------
 {"b":"foo"}
(1 row)
```
#### json_object_field_text(object-json, text)
描述：同操作符-\>\>, 返回对象中指定键对应的值。
返回类型：text
示例：
```
SELECT json_object_field_text('{"a": {"b":"foo"}}','a');
 json_object_field_text
------------------------
 {"b":"foo"}
(1 row)
```
#### json_array_element(array-json, integer)
描述：同操作符-\>, 返回数组中指定下标的元素。
返回类型：json
示例：
```
SELECT json_array_element('[1,true,[1,[2,3]],null]',2);
 json_array_element
--------------------
 [1,[2,3]]
(1 row)
```
#### json_array_element_text(array-json, integer)
描述：同操作符-\>\>, 返回数组中指定下标的元素。
返回类型：text
示例：
```
SELECT json_array_element_text('[1,true,[1,[2,3]],null]',2);
 json_array_element_text
-------------------------
 [1,[2,3]]
(1 row)
```
#### json_extract_path(json, VARIADIC text\[\])
描述：同操作符#\>，返回$2所指路径的JSON值。
返回类型：json
示例：
```
SELECT json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"stringy"}}', 'f4','f6');
 json_extract_path
-------------------
 "stringy"
(1 row)
```
#### json_extract_path_text(json, VARIADIC text\[\])
描述：同操作符#\>\>，返回$2所指路径的text值。
返回类型：text
示例：
```
SELECT json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"stringy"}}', 'f4','f6');
 json_extract_path_text
------------------------
 stringy
(1 row)
```
#### json_array_elements(array-json)
描述：拆分数组，每一个元素返回一行。
返回类型：json
示例：
```
SELECT json_array_elements('[1,true,[1,[2,3]],null]');
 json_array_elements
---------------------
 1
 true
 [1,[2,3]]
 null
(4 rows)
```
#### json_array_elements_text(array-json)
描述：拆分数组，每一个元素返回一行。
返回类型：text
示例：
```
SELECT * FROM json_array_elements_text('[1,true,[1,[2,3]],null]');
   value
-----------
 1
 true
 [1,[2,3]]
(4 rows)
```
#### json_array_length(array-json)
描述：返回数组长度。
返回类型：integer
示例：
```
SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4,null]');
 json_array_length
-------------------
        6
(1 row)
```
#### json_object_keys(object-json)
描述：返回对象中顶层的所有键。
返回类型：text
示例：
```
SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}, "f1":"abcd"}');
 json_object_keys
------------------
 f1
 f2
 f1
(3 rows)
```
#### json_each(object-json)
描述：将对象的每个键值对拆分转换成一行两列。
返回类型：setof(key text, value json)
示例：
```
SELECT * FROM json_each('{"f1":[1,2,3],"f2":{"f3":1},"f4":null}');
 key |  value
-----+----------
 f1  | [1,2,3]
 f2  | {"f3":1}
 f4  | null
(3 rows)
```
#### json_each_text(object-json)
描述：将对象的每个键值对拆分转换成一行两列。
返回类型：setof(key text, value text)
示例：
```
SELECT * FROM json_each_text('{"f1":[1,2,3],"f2":{"f3":1},"f4":null}');
 key |  value
-----+----------
 f1  | [1,2,3]
 f2  | {"f3":1}
 f4  |
(3 rows)
```
#### json_populate_record(anyelement, object-json \[, bool\])
描述：$1必须是一个复合类型的参数。将会把object-json里的每个对键值进行拆分，以键当做列名，与$1中的列名进行匹配查找，并填充到$1的格式中。
![](https://support.huaweicloud.com/sqlreference-911-dws/public_sys-resources/note_3.0-zh-cn.png)
JSON/JSONB函数中入参为复合类型时，可以使用CREATE TYPE或CREATE TABLE定义复合类型，例如：
```
CREATE TYPE jpop AS (a text, b INT, c timestamp);
CREATE TABLE jpop2(a text, b INT, c timestamp);
```
返回类型：anyelement
示例：
```
CREATE TYPE jpop AS (a text, b INT, c timestamp);
SELECT * FROM json_populate_record(null::jpop,'{"a":"blurfl","x":43.2}');
   a    | b | c
--------+---+---
 blurfl |   |
(1 row)
```
#### json_populate_recordset(anyelement, array-json \[, bool\])
描述：参考函数json_populate_record、jsonb_populate_record，对$2数组的每一个元素进行上述参数函数的操作，因此这也要求$2数组的每个元素都是object-json类型。
返回类型：setof anyelement
示例：
```
CREATE TYPE jpop AS (a text, b INT, c timestamp);
SELECT * FROM json_populate_recordset(null::jpop, '[{"a":1,"b":2},{"a":3,"b":4}]');
 a | b | c
---+---+---
 1 | 2 |
 3 | 4 |
(2 rows)
```
#### json_to_record(object-json)
描述：正如所有返回record的函数一样，调用者必须用一个AS子句显式地定义记录的结构。会将object-json的键值对进行拆分重组，把键当做列名，去匹配填充AS显示指定的记录的结构。
返回类型：record
示例：
```
SELECT * FROM json_to_record('{"a":1,"b":"foo","c":"bar"}'::json) as x(a int, b text, d text);
 a |  b  | d
---+-----+---
 1 | foo |
(1 row)
```
#### json_to_recordset(array-json)
描述：参考函数json_to_record，对数组内的每个元素，执行上述函数的操作，因此这要求数组内的每个元素都得是object-json。
返回类型：setof record
示例：
```
SELECT * FROM json_to_recordset('[{"a":1,"b":{"d":"foo"},"c":true},{"a":2,"c":false,"b":{"d":"bar"}}]') AS x(a INT, b json, c BOOLEAN);
 a |      b      | c
---+-------------+---
 1 | {"d":"foo"} | t
 2 | {"d":"bar"} | f
(2 rows)
SELECT * FROM json_to_recordset('[{"a":1,"b":"foo","d":false},{"a":2,"b":"bar","c":true}]') AS x(a INT, b text, c BOOLEAN);
 a |  b  | c
---+-----+---
 1 | foo |
 2 | bar | t
(2 rows)
```
#### json_typeof(json)
描述：检测json类型。
返回类型：text
示例：
```
SELECT value, json_typeof(value) from (values (json '123.4'), (json '"foo"'), (json 'true'), (json 'null'), (json '[1, 2, 3]'), (json '{"x":"foo", "y":123}'), (NULL::json)) as data(value);
        value         | json_typeof
----------------------+-------------
 123.4                | number
 "foo"                | string
 true                 | boolean
 null                 | null
 [1, 2, 3]            | array
 {"x":"foo", "y":123} | object
                      |
(7 rows)
```
#### jsonb_object(text\[\])
描述：从一个文本数组构造一个object-jsonb。这是个重载函数，当入参为一个文本数组的时候，其数组长度必须为偶数，成员被当做交替出现的键/值对。
返回类型：jsonb
示例：
```
SELECT jsonb_object('{a,1,b,2,3,NULL,"d e f","a b c"}');
                   jsonb_object
---------------------------------------------------
 {"3": null, "a": "1", "b": "2", "d e f": "a b c"}
(1 row)
```
#### jsonb_object(text\[\], text\[\])
描述：两个文本数组的时候，第一个数组认为是键，第二个认为是值，两个数组长度必须相等。键不可为null。
返回类型：jsonb
示例：
```
SELECT jsonb_object('{a,b,"a b c"}', '{a,1,1}');
            jsonb_object
------------------------------------
 {"a": "a", "b": "1", "a b c": "1"}
(1 row)
```
#### to_jsonb(anyment)
描述：将其他类型转换成对应的jsonb类型。
返回类型：jsonb
示例：
```
SELECT to_jsonb(1.1);
 to_jsonb
----------
 1.1
(1 row)
```
#### jsonb_agg
描述：将jsonb对象聚合成jsonb数组。
返回类型：jsonb
示例：
```
SELECT * FROM json_tbl_2;
 a |  b
---+-----
 1 | aaa
 1 | bbb
 2 | ccc
 2 | ddd
(4 rows)
SELECT a, jsonb_agg(b) FROM json_tbl_2 GROUP BY a ORDER BY a;
 a |   jsonb_agg
---+----------------
 1 | ["aaa", "bbb"]
 2 | ["ccc", "ddd"]
(2 rows)
```
#### jsonb_object_agg
描述：将键/值对聚集成一个JSON对象。
返回类型：jsonb
示例：
```
SELECT * FROM json_tbl_3;
 a |  b  | c
---+-----+----
 1 | aaa | 10
 1 | bbb | 20
 2 | ccc | 30
 2 | ddd | 40
(4 rows)
SELECT a, jsonb_object_agg(b, c) FROM json_tbl_3 GROUP BY a ORDER BY a;
 a |    jsonb_object_agg
---+------------------------
 1 | {"aaa": 10, "bbb": 20}
 2 | {"ccc": 30, "ddd": 40}
(2 rows)
```
#### jsonb_build_array( \[VARIADIC "any"\] )
描述：从一个可变参数列表构造一个可能包含异质类型的JSON数组。
返回类型：jsonb
示例：
```
SELECT jsonb_build_array('a',1,'b',1.2,'c',true,'d',null,'e',json '{"x": 3, "y": [1,2,3]}','');
                               jsonb_build_array
-------------------------------------------------------------------------------
 ["a", 1, "b", 1.2, "c", true, "d", null, "e", {"x": 3, "y": [1, 2, 3]}, null]
(1 row)
```
#### jsonb_build_object( \[VARIADIC "any"\] )
描述：从一个可变参数列表构造出一个JSON对象，其入参必须为偶数个，两两一组组成键值对。注意键不可为null。
返回类型：jsonb
示例：
```
SELECT jsonb_build_object(1,2);
 jsonb_build_object
--------------------
 {"1": 2}
(1 row)
```
#### jsonb_strip_nulls(jsonb)
描述：所有具有空值的对象字段均被省略。其他空值保持不变。
返回类型：jsonb
示例：
```
SELECT jsonb_strip_nulls('[{"f1":1,"f2":null},2,null,3]');
    jsonb_strip_nulls
-------------------------
 [{"f1": 1}, 2, null, 3]
(1 row)
```
#### jsonb_object_field(jsonb, text)
描述：同操作符-\>, 返回对象中指定键对应的值。
返回类型：jsonb
示例：
```
SELECT jsonb_object_field('{"a": {"b":"foo"}}','a');
 jsonb_object_field
--------------------
 {"b": "foo"}
(1 row)
```
#### jsonb_object_field_text(jsonb, text)
描述：同操作符-\>\>, 返回对象中指定键对应的值。
返回类型：text
示例：
```
SELECT jsonb_object_field_text('{"a": {"b":"foo"}}','a');
 jsonb_object_field_text
-------------------------
 {"b": "foo"}
(1 row)
```
#### jsonb_array_element(array-jsonb, integer)
描述：同操作符-\>, 返回数组中指定下标的元素。
返回类型：jsonb
示例：
```
SELECT jsonb_array_element('[1,true,[1,[2,3]],null]',2);
 jsonb_array_element
---------------------
 [1, [2, 3]]
(1 row)
```
#### jsonb_array_element_text(array-jsonb, integer)
描述：同操作符-\>\>, 返回数组中指定下标的元素。
返回类型：text
示例：
```
SELECT jsonb_array_element_text('[1,true,[1,[2,3]],null]',2);
 jsonb_array_element_text
--------------------------
 [1, [2, 3]]
(1 row)
```
#### jsonb_extract_path(jsonb, VARIADIC text\[\])
描述：等价于操作符#\>，返回$2所指路径的值。
返回类型：jsonb
示例：
```
SELECT jsonb_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"stringy"}}', 'f4','f6');
 jsonb_extract_path
--------------------
 "stringy"
(1 row)
```
#### jsonb_extract_path_text(jsonb, VARIADIC text\[\])
描述：等价于操作符#\>\>，返回$2所指路径的值。
返回类型：text
示例：
```
SELECT jsonb_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"stringy"}}', 'f4','f6');
 jsonb_extract_path_text
-------------------------
 stringy
(1 row)
```
#### jsonb_extract(jsonb, VARIADIC text\[\])
描述：输入任意的object-jsonb类型、array-jsonb类型，返回$2所指路径的值。该函数仅9.1.0及以上集群版本支持。
返回类型：SETOF jsonb
示例：
```
SELECT jsonb_extract('{"f2":{"f3":1},"f4":[{"f5":99},{"f6":"stringy"}]}','f2','f3');
 jsonb_extract
---------------
 1
(1 row)
SELECT jsonb_extract('{"f2":{"f3":1},"f4":[{"f5":99},{"f5":"stringy"}]}', 'f4','f5');
 jsonb_extract
---------------
 99
 "stringy"
(2 rows)
```
#### jsonb_extract_text(jsonb, VARIADIC text\[\])
描述：输入任意的object-jsonb类型、array-jsonb类型，返回$2所指路径的值。该函数仅9.1.0及以上集群版本支持。
返回类型：SETOF text
示例：
```
SELECT jsonb_extract_text('{"f2":{"f3":1},"f4":[{"f5":99},{"f6":"stringy"}]}','f2','f3');
 jsonb_extract_text
--------------------
 1
(1 row)
SELECT jsonb_extract_text('{"f2":{"f3":1},"f4":[{"f5":99},{"f5":"stringy"}]}', 'f4','f5');
 jsonb_extract_text
--------------------
 99
 stringy
(2 rows)
```
#### jsonb_array_elements(array-jsonb)
描述：拆分数组，每一个元素返回一行。
返回类型：jsonb
示例：
```
SELECT jsonb_array_elements('[1,true,[1,[2,3]],null]');
 jsonb_array_elements
----------------------
 1
 true
 [1, [2, 3]]
 null
(4 rows)
```
#### jsonb_array_elements_text(array-jsonb)
描述：拆分数组，每一个元素返回一行。
返回类型：text
示例：
```
SELECT * FROM jsonb_array_elements_text('[1,true,[1,[2,3]],null]');
    value
-------------
 1
 true
 [1, [2, 3]]
(4 rows)
```
#### jsonb_array_length(array-jsonb)
描述：返回数组长度。
返回类型：integer
示例：
```
SELECT jsonb_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4,null]');
 jsonb_array_length
--------------------
          6
(1 row)
```
#### jsonb_object_keys(object-jsonb)
描述：返回对象中顶层的所有键。
返回类型：SETOF text
示例：
```
SELECT jsonb_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}, "f1":"abcd"}');
 jsonb_object_keys
-------------------
 f1
 f2
(2 rows)
```
#### jsonb_each(object-jsonb)
描述：将对象的每个键值对拆分转换成一行两列。
返回类型：setof(key text, value jsonb)
示例：
```
SELECT * FROM jsonb_each('{"f1":[1,2,3],"f2":{"f3":1},"f4":null}');
 key |   value
-----+-----------
 f1  | [1, 2, 3]
 f2  | {"f3": 1}
 f4  | null
(3 rows)
```
#### jsonb_each_text(object-jsonb)
描述：将对象的每个键值对拆分转换成一行两列。
返回类型：setof(key text, value text)
示例：
```
SELECT * FROM jsonb_each_text('{"f1":[1,2,3],"f2":{"f3":1},"f4":null}');
 key |   value
-----+-----------
 f1  | [1, 2, 3]
 f2  | {"f3": 1}
 f4  |
(3 rows)
```
#### jsonb_populate_record(anyelement, object-jsonb \[, bool\])
描述：$1必须是一个复合类型的参数。将会把object-json里的每个对键值进行拆分，以键当做列名，与$1中的列名进行匹配查找，并填充到$1的格式中。
返回类型：anyelement
示例：
```
SELECT * FROM jsonb_populate_record(null::jpop,'{"a":"blurfl","x":43.2}');
   a    | b | c
--------+---+---
 blurfl |   |
(1 row)
```
#### jsonb_populate_recordset(anyelement, array-jsonb \[, bool\])
描述：参考上述函数json_populate_record、jsonb_populate_record，对$2数组的每一个元素进行上述参数函数的操作，因此这也要求$2数组的每个元素都是object-json类型。
返回类型：setof anyelement
示例：
```
SELECT * FROM jsonb_populate_recordset(null::jpop, '[{"a":1,"b":2},{"a":3,"b":4}]');
 a | b | c
---+---+---
 1 | 2 |
 3 | 4 |
(2 rows)
```
#### jsonb_to_record(object-json)
描述：正如所有返回record的函数一样，调用者必须用一个AS子句显式地定义记录的结构。会将object-json的键值对进行拆分重组，把键当做列名，去匹配填充AS显示指定的记录的结构。
返回类型：record
示例：
```
SELECT * FROM jsonb_to_record('{"a":1,"b":"foo","c":"bar"}'::jsonb) as x(a int, b text, d text);
 a |  b  | d
---+-----+---
 1 | foo |
(1 row)
```
#### jsonb_to_recordset(array-json)
描述：参考函数jsonb_to_record，对数组内每个元素，执行上述函数的操作，因此这要求数组内的每个元素都得是object-jsonb。
返回类型：setof record
示例：
```
SELECT * FROM jsonb_to_recordset('[{"a":1,"b":"foo","d":false},{"a":2,"b":"bar","c":true}]') AS x(a INT, b text, c boolean);
 a |  b  | c
---+-----+---
 1 | foo |
 2 | bar | t
(2 rows)
```
#### jsonb_typeof(jsonb)
描述：检测jsonb类型。
返回类型：text
示例：
```
SELECT jsonb_typeof(to_jsonb(1.1));
 jsonb_typeof
--------------
 number
(1 row)
```
#### jsonb_ne(jsonb, jsonb)
描述：同操作符\<\>，比较两个值的大小。
返回类型：bool
示例：
```
SELECT jsonb_ne('{"a":1, "b":2}'::jsonb, '{"a":1, "b":3}'::jsonb);
 jsonb_ne
----------
 t
(1 row)
```
#### jsonb_lt(jsonb, jsonb)
描述：同操作符\<，比较两个值的大小。
返回类型：bool
示例：
```
SELECT jsonb_lt('{"a":1, "b":2}'::jsonb, '{"a":1, "b":3}'::jsonb);
 jsonb_lt
----------
 t
(1 row)
```
#### jsonb_gt(jsonb, jsonb)
描述：同操作符\>，比较两个值的大小。
返回类型：bool
示例：
```
SELECT jsonb_gt('{"a":1, "b":2}'::jsonb, '{"a":1, "b":3}'::jsonb);
 jsonb_gt
----------
 f
(1 row)
```
#### jsonb_le(jsonb, jsonb)
描述：同操作符\<=，比较两个值的大小。
返回类型：bool
示例：
```
SELECT jsonb_le('["a", "b"]', '{"a":1, "b":2}');
 jsonb_le
----------
 t
(1 row)
```
#### jsonb_ge(jsonb, jsonb)
描述：同操作符\>=，比较两个值的大小。
返回类型：bool
示例：
```
SELECT jsonb_ge('["a", "b"]', '{"a":1, "b":2}');
 jsonb_ge
----------
 f
(1 row)
```
#### jsonb_eq(jsonb, jsonb)
描述：同操作符=，比较两个值的大小。
返回类型：bool
示例：
```
SELECT jsonb_eq('["a", "b"]', '{"a":1, "b":2}');
 jsonb_eq
----------
 f
(1 row)
```
#### jsonb_cmp(jsonb, jsonb)
描述：比较大小，正数表示大于，负数表示小于，0表示相等。
返回类型：integer
示例：
```
SELECT jsonb_cmp('["a", "b"]', '{"a":1, "b":2}');
 jsonb_cmp
-----------
 -1
(1 row)
```
#### jsonb_exists(jsonb, text)
描述：同操作符?，字符串$2是否存在$1的顶层以key\\elem\\scalar的形式存在。
返回类型：bool
示例：
```
SELECT jsonb_exists('["1",2,3]', '1');
 jsonb_exists
--------------
 t
(1 row)
```
#### jsonb_exists_any(jsonb, text\[\])
描述：同操作符?\|，字符串数组$2里面是否存在的元素，在$1的顶层以key\\elem\\scalar的形式存在。
返回类型：
示例：
```
SELECT jsonb_exists_any('["1","2",3]', '{1, 2, 4}');
 jsonb_exists_any
------------------
 t
(1 row)
```
#### jsonb_exists_all(jsonb, text\[\])
描述：同操作符?\&，字符串数组$2里面是否所有的元素，都在$1的顶层以key\\elem\\scalar的形式存在。
返回类型：
bool
示例：
```
SELECT jsonb_exists_all('["1","2",3]', '{1, 2}');
 jsonb_exists_all
------------------
 t
(1 row)
```
#### jsonb_contained(jsonb, jsonb)
描述：同操作符\<@, 判断$1中的所有元素是否在$2的顶层存在。
返回类型：bool
示例：
```
SELECT jsonb_contained('[1,2,3]', '[1,2,3,4]');
 jsonb_contained
-----------------
 t
(1 row)
```
#### jsonb_contains(jsonb, jsonb)
描述：同操作符@\>, 判断$1中的顶层所有元素是否包含在$2的所有元素。
返回类型：bool
示例：
```
SELECT jsonb_contains('{"a":1, "b":2, "c":3}'::jsonb, '{"a":1}');
 jsonb_contains
-----------------
 t
(1 row)
```
#### jsonb_concat(jsonb, jsonb)
描述：连接两个jsonb对象为一个jsonb。
返回类型：jsonb
示例：
```
SELECT jsonb_concat('{"a":1, "b":2}'::jsonb, '{"c":3, "d":4}'::jsonb);
           jsonb_concat
----------------------------------
 {"a": 1, "b": 2, "c": 3, "d": 4}
(1 row)
```
#### jsonb_delete(jsonb, text)
描述：删除jsonb中的key值对应的键值对。
返回类型：jsonb
示例：
```
SELECT jsonb_delete('{"a":1, "b":2}'::jsonb, 'a');
 jsonb_delete
--------------
 {"b": 2}
(1 row)
```
#### jsonb_delete_idx(jsonb, text)
描述：删除数组下标对应的元素。
返回类型：jsonb
示例：
```
SELECT jsonb_delete_idx('[0,1,2,3,4]'::jsonb, 2);
 jsonb_delete_idx
------------------
 [0, 1, 3, 4]
(1 row)
```
#### jsonb_delete_array(jsonb, VARIADIC text\[\])
描述：删除jsonb数组中的多个元素。
返回类型：jsonb
示例：
```
SELECT jsonb_delete_array('["a", "b", "c"]'::jsonb , 'a', 'b');
 jsonb_delete_array
--------------------
 ["c"]
(1 row)
```
#### jsonb_delete_path(jsonb, text\[\])
描述：删除jsonb数组中指定路径的元素。
返回类型：jsonb
示例：
```
SELECT jsonb_delete_path('{"a":{"b":{"c":1, "d":2}}, "e":3}'::jsonb , array['a', 'b']);
 jsonb_delete_path
-------------------
 {"a": {}, "e": 3}
(1 row)
```
#### jsonb_set(target jsonb, path text\[\], new_value jsonb \[, create_missing boolean\])
描述：返回target，用path指定的部分被new_value替换，或者如果create_missing为true（默认值为true）且path指定的项不存在，则添加new_value。与面向路径的运算符一样，path中出现的负整数从JSON数组的末尾开始计数。
返回类型：jsonb
示例：
```
SELECT jsonb_set('[{"f1":1,"f2":null},2,null,3]', '{0,f1}','[2,3,4]', false);
                  jsonb_set
---------------------------------------------
 [{"f1": [2, 3, 4], "f2": null}, 2, null, 3]
(1 row)
```
#### jsonb_pretty(jsonb)
描述：以缩进的JSON文本形式返回。
返回类型：jsonb
示例：
```
SELECT jsonb_pretty('{"a":{"b":{"c":1, "d":2}}, "e":3}'::jsonb);
    jsonb_pretty
---------------------
 {                  +
     "a": {         +
         "b": {     +
             "c": 1,+
             "d": 2 +
         }          +
     },             +
     "e": 3         +
 }
(1 row)
```
#### jsonb_insert(target jsonb, path text\[\], new_value jsonb \[, insert_after boolean\])
描述：返回被插入了new_value的target。如果path指定的target部分位于JSONB数组中，则new_value将被插入到目标之前（insert_after为false，默认值）或者之后（insert_after为true）。如果path指定的target部分位于一个JSONB对象内，则仅当target不存在时才插入new_value。与面向路径的运算符一样，path中出现的负整数表示从JSON数组的末尾开始计数。
返回类型：jsonb
示例：
```
SELECT jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"');
         jsonb_insert
-------------------------------
 {"a": [0, "new_value", 1, 2]}
(1 row)
```
#### ts_headline(\[ config regconfig, \] document jsonb, query tsquery \[, options text \])
描述：高亮jsonb搜索结果。
返回类型：jsonb
示例：
```
SELECT ts_headline('english', '[{"id":9928,"user_id":4562,"user_name":"9LOHR4","create_time":"2021-06-22T16:28:16.504518+08:00"}, {"id":9959,"user_id":5524,"user_name":"YID07D","create_time":"2021-06-22T16:28:16.557228+08:00"}, {"id":9962,"user_id":7991,"user_name":"7C6QOM","create_time":"2021-06-22T16:28:16.56234+08:00"}]'::jsonb,
 to_tsquery('english', '9LOHR4'), 'StartSel = <, StopSel = >');
                                                                                                                                                         ts_headline                                                                                                                                                       
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 [{"id": 9928, "user_id": 4562, "user_name": "<9LOHR4>", "create_time": "2021-06-22T16:28:16.504518+08:00"}, {"id": 9959, "user_id": 5524, "user_name": "YID07D", "create_time": "2021-06-22T16:28:16.557228+08:00"}, {"id": 9962, "user_id": 7991, "user_name": "7C6QOM", "create_time": "2021-06-22T16:28:16.56234+08:00"}]
(1 row)
```
#### json_to_tsvector(config regconfig, \] json, jsonb)
描述：将json格式转换为用于支持全文检索的文件格式tsvector。
返回类型：jsonb
示例：
```
SELECT json_to_tsvector('{"a":1, "b":2, "c":3}'::json, to_jsonb('key'::text));
 json_to_tsvector
------------------
 'b':2 'c':4
(1 row)
```