json -> integer → json

jsonb -> integer → jsonb

Извлекает nn-й элемент массива JSON (элементы массива индексируются с нуля, при этом отрицательные значения позволяют вести отсчет с конца массива).

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

Извлекает nn-й элемент JSON-массива, функции 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 в себе второе значение? (См. Раздел 2.5.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? (Это применимо только к выражениям JSON path в стандарте SQL, но не к выражениям проверки предикатов, так как последние всегда возвращают значение.)

'{"a":[1,2,3,4,5]}'::jsonb @? '$.a[*] ? (@ > 2)' → t

jsonb @@ jsonpath → boolean

Функция возвращает результат проверки предиката JSON path для указанного значения JSON. (Это применимо только к с выражениям проверки предикатов, а не к выражениям JSON path в стандарте SQL, поскольку результат будет возвращен только в том случае, 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. Для любого скалярного значения, отличного от числа, логического значения или значения NULL, используется текстовое представление с применением необходимого экранирования для обеспечения соответствия формату строки 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 ] ] ])

Данная функция формирует массив JSON либо из набора value_expression параметров, либо на основе результатов из query_expression, подзапроса, который должен представлять собой запрос SELECT языка SQL, возвращающий один столбец. Если 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-объект из вариативного списка аргументов. Согласно соглашению, список аргументов состоит из чередующихся ключей и значений. Аргументы, являющиеся ключами, приводятся к типу text; аргументы, являющиеся значениями, преобразуются согласно правилам функции 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 text. Он не может иметь значение NULL, NULL а также не может относиться к типу, для которого определено приведение к типу json text. Если 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 ( ключи text[], значения text[] ) → json

jsonb_object ( ключи text[], значения text[] ) → jsonb

Данная форма json_object принимает ключи и значения попарно из отдельных массивов текста. В остальном она идентична форме с одним аргументом.

json_object('{a,b}', '{1,2}') → {"a": "1", "b": "2"}

json ( выражение [ FORMAT JSON [ ENCODING UTF8 ]] [ { WITH | WITHOUT } UNIQUE [ KEYS ]] ) → json

Преобразует заданное выражение, представленное как text или bytea строка (в кодировке UTF8), в значение типа JSON значение. Если выражение оператор IS NULL возвращает истину, то SQL возвращается значение NULL. Если WITH UNIQUE указано, то выражение не должен содержать дублирующиеся ключи объектов.

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

json_scalar ( выражение )

Функция преобразует заданное скалярное значение языка SQL в скалярное значение JSON. Если входное значение имеет значение NULL, то SQL возвращается значение null. Если входное значение представляет собой число или логическое значение, то соответствующее число или логическое значение JSON возвращается. Для любого другого типа данных возвращается строка JSON.

json_scalar(123.45) → 123.45

json_scalar(CURRENT_TIMESTAMP) → "2022-05-10T10:51:04.62128-04:00"

json_serialize ( выражение [ FORMAT JSON [ ENCODING UTF8 ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ] )

Данная функция преобразует выражение языка SQL/JSON в символьную или двоичную строку. выражение могут иметь любой тип JSON, любой строковый тип данных или bytea в кодировке UTF8. Возвращаемым типом данных, используемым в конструкции RETURNING может быть любой символьный строковый тип или bytea. Значением по умолчанию является text.

json_serialize('{ "a" : 1 } ' RETURNING bytea) → \x7b20226122203a2031207d20

выражение IS [ NOT ] JSON [ { VALUE | SCALAR | ARRAY | OBJECT } ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ]

Данный предикат проверяет, может ли выражение быть выражение могут быть интерпретировано как JSON, при необходимости — заданного типа. Если SCALAR или ARRAY или OBJECT указано, то проверяется соответствие JSON указанному типу. Если WITH UNIQUE KEYS указано, то любой объект в выражение также проверяется на наличие дублирующихся ключей.

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 ( ключ text, значение json )

jsonb_each ( jsonb ) → setof record ( ключ text, значение jsonb )

Данная функция разворачивает JSON-объект верхнего уровня в набор пар «ключ/значение».

select * from json_each('{"a":"foo", "b":"bar"}') →

 key | value
-----+-------
 a   | "foo"
 b   | "bar"

json_each_text ( json ) → setof record ( ключ text, значение text )

jsonb_each_text ( jsonb ) → setof record ( ключ text, значение text )

Данная функция разворачивает JSON-объект верхнего уровня в набор пар «ключ/значение». Возвращаемые значениеы будут иметь тип 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-объект по указанному пути. (Данная операция функционально эквивалентна #> оператору, однако в некоторых случаях может быть удобнее записывать путь в виде списка аргументов переменной длины (variadic list).)

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, в типичных сценариях использования предполагается ссылка на json или jsonb столбец, получаемый латерально из другой таблицы в FROM фразе запроса. Использование json_populate_record в с FROM данной фразы является хорошей практикой, так как все извлеченные столбцы становятся доступны для использования без повторных вызовов функций.

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. Возвращает логическое значение true если входные данные jsonb_populate_record выполнение функции завершится без ошибки для заданного входного объекта JSON; то есть, если это допустимые входные данные, 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 строка)

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, вызывающий запрос должен явно определять структуру записи с помощью фразы символ ASCII. 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 ( целевой запрос jsonb, path text[], new_value jsonb [, create_if_missing boolean ] ) → jsonb

Возвращает значение целевой запрос элементом, указанным в пути path заменены на new_value, либо с элементом, new_value добавленным в случае, если параметр create_if_missing имеет значение true (которое используется по умолчанию), а элемент, указанный в пути path , не существует. Все предыдущие элементы в пути должны существовать, иначе с целевой запрос возвращается в исходном виде. По аналогии с операторами для работы с путями, отрицательные целые числа, которые указаны в 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 ( целевой запрос 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 ( целевой запрос jsonb, path text[], new_value jsonb [, insert_after boolean ] ) → jsonb

Возвращает значение целевой запрос с new_value вставляется. Если элемент, указанный в path является элементом массива элемент, new_value будет вставлен перед этим элементом, если insert_after имеет значение false (которое используется по умолчанию), либо после него если insert_after имеет значение true. Если элемент указанный в path является объектом, поле new_value будет вставлено только в том случае, если данный объект еще не содержит этот ключ. Все предыдущие элементы в пути должны существовать, иначе с целевой запрос возвращается в исходном виде. По аналогии с операторами для работы с путями, отрицательные целые числа, которые указаны в 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-значения все поля объектов, имеющие значение null. Значения null, не являющиеся полями объектов, остаются без изменений.

json_strip_nulls('[{"f1":1, "f2":null}, 2, null, 3]') → [{"f1":1},2,null,3]

jsonb_path_exists ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

Проверяет, возвращает ли путь JSON какие-либо элементы для указанного значения JSON. значение. (Это применимо только к выражениям JSON path в стандарте SQL, но не к выражениям проверки предикатов, так как последние всегда возвращают значение.) Если указан 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 ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

Возвращает логический результат языка SQL при проверке предиката пути JSON для указанного значения JSON. (Это применимо только к с выражениям проверки предикатов, а не к выражениям JSON path в стандарте SQL, так как это приведет либо к ошибке, либо к возврату 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 ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → setof jsonb

Функция возвращает все элементы JSON, полученные в результате применения пути JSON к указанному значению JSON. Для выражений пути JSON стандарта языка SQL функция возвращает значения 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 ( целевой запрос 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 ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

Функция возвращает первый элемент JSON, полученный в результате выполнения пути JSON для заданного значения JSON, или значение `NULL`, 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 ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

jsonb_path_match_tz ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

jsonb_path_query_tz ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → setof jsonb

jsonb_path_query_array_tz ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

jsonb_path_query_first_tz ( целевой запрос jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

Данные функции работают аналогично функциям-аналогам, описанным выше без с _tz суффикса, за исключением того, что эти функции поддерживают сравнение значений даты и времени, требующее выполнения преобразований с учётом часового пояса. Приведённый ниже пример требует интерпретации значения, содержащего только дату, 2015-08-02 как типа timestamp с часовым поясом, вследствие чего результат зависит от текущей настройки TimeZone. 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, строка, количество, boolean, и null. (Полученный null результат не следует путать с NULL-значением в языке SQL; см. примеры.)

json_typeof('-123.4') → количество

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) →

ОШИБКА: индекс массива jsonpath вышел за границы диапазона

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 выражение } ON EMPTY ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT выражение } 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 выражение } ON EMPTY ]
[ { ERROR | NULL | DEFAULT выражение } 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