json -> integer → json

jsonb -> integer → jsonb

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

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

Извлекает n-ый элемент из 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 содержит второе? (Что означает «содержит», подробно описывается в Подразделе 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?

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

jsonb @@ jsonpath → boolean

Возвращает результат проверки предиката пути JSON для заданного значения 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, применяется эта функция приведения;^[a] для всех остальных выдаётся скалярное значение. Значения всех скалярных типов, кроме числового, логического и NULL, представляются в текстовом виде; при этом может добавляться экранирование символов, необходимое для получения допустимых строковых значений json или jsonb.

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]]

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 ( 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_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-объект верхнего уровня в набор пар ключ/значение (key/value).

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-объект верхнего уровня в набор пар ключ/значение (key/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 фиксировано, но обычно такая функция обращается с использованием LATERAL к столбцу 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")

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 либо значение new_value добавляется, когда параметр create_if_missing равен true (это значение по умолчанию) и элемент, на который указывает path, не существует. Чтобы это изменение произошло, все предыдущие элементы, на которые указывает путь, должны существовать. В противном случае 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

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

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. В случае присутствия аргумента 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. При этом учитывается только первый элемент результата. Если результат не является логическим, возвращается 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. Дополнительные аргументы 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-массива. Дополнительные аргументы vars и silent действуют так же, как и для jsonb_path_exists.

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, либо NULL, если этому пути не соответствуют никакие элементы. Дополнительные аргументы vars и silent действуют так же, как и для jsonb_path_exists.

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 ( выражение [FORMAT JSON [ENCODING UTF8]] [ { WITH | WITHOUT } UNIQUE [KEYS]] [RETURNING тип_данных_json])

Аргумент выражение может быть любого текстового типа или типа bytea в кодировке UTF-8. Если в выражении передаётся NULL, возвращается значение SQL NULL. С указанием WITH UNIQUE в выражении не должно быть объектов с дублирующимися ключами.

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

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

json_scalar (выражение [RETURNING тип_данных_json])

Возвращает скалярное значение 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_object ( [ { выражение_ключа { VALUE | ':' } выражение_значения [FORMAT JSON [ENCODING UTF8]] }[, ...]] [ { NULL | ABSENT } ON NULL] [ { WITH | WITHOUT } UNIQUE [KEYS]] [RETURNING тип_данных [FORMAT JSON [ENCODING UTF8]]])

Создаёт объект JSON из всех заданных пар ключ/значение или пустой объект, если ни одна пара не задана. В аргументе выражение_ключа передаётся скалярное выражение, определяющее ключ JSON, который преобразуется в тип text. Этот параметр не может быть NULL и не должен иметь тип, приводимый к json. С указанием WITH UNIQUE в выражении_ключа не должно быть дублирующихся значений. С указанием ABSENT ON NULL вся пара пропускается, если выражение_значения равно NULL.

json_object('code' VALUE 'P123', 'title': 'Jaws') → {"code" : "P123", "title" : "Jaws"}

json_objectagg ( [ { выражение_ключа { VALUE | ':' } выражение_значения } ] [ { NULL | ABSENT } ON NULL] [ { WITH | WITHOUT } UNIQUE [KEYS]] [RETURNING тип_данных [FORMAT JSON [ENCODING UTF8]]])

Ведёт себя так же, как описанная выше функция json_object, но является агрегатной, поэтому принимает только один параметр выражение_ключа и один параметр выражение_значения.

SELECT json_objectagg(k:v) FROM (VALUES ('a'::text,current_date),('b',current_date + 1)) AS t(k,v) → { "a" : "2022-05-10", "b" : "2022-05-11" }

json_array ( [ { выражение_значения [FORMAT JSON] } [, ...]] [ { NULL | ABSENT } ON NULL] [RETURNING тип_данных [FORMAT JSON [ENCODING UTF8]]])

json_array ( [выражение_запроса] [RETURNING тип_данных [FORMAT JSON [ENCODING UTF8]]])

Создаёт массив JSON либо из набора параметров выражения_значения, либо из результатов выражения_запроса, которое должно быть запросом SELECT, возвращающим один столбец. С указанием ABSENT ON NULL значения NULL игнорируются. Такие значения всегда игнорируются, если используется выражение_запроса.

json_array(1,true,json '{"a":null}') → [1, true, {"a":null}]

json_array(SELECT * FROM (VALUES(1),(2)) t) → [1, 2]

json_arrayagg ( [выражение_значения] [ORDER BY выражение_сортировки] [ { NULL | ABSENT } ON NULL] [RETURNING тип_данных [FORMAT JSON [ENCODING UTF8]]])

Ведёт себя так же, как функция json_array, но агрегатная, поэтому принимает только один параметр выражение_значения. С указанием ABSENT ON NULL любые значения NULL пропускаются. С указанием ORDER BY элементы добавляются в массив в заданном порядке, а не в том порядке, в котором они вводятся.

SELECT json_arrayagg(v) FROM (VALUES(2),(1)) t(v) → [2, 1]

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

Этот предикат проверяет, может ли аргумент выражение представлять собой JSON (возможно, указанного типа). Если указано SCALAR, ARRAY или OBJECT, проверяется, относится ли JSON к этому конкретному типу. С указанием WITH UNIQUE все объекты в выражении также проверяются на наличие дубликатов ключей.

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

json_serialize ( выражение [FORMAT JSON [ENCODING UTF8]] [RETURNING тип_данных [FORMAT JSON [ENCODING UTF8]]])

Преобразует значение SQL/JSON в символьную или двоичную строку. Аргумент выражение может быть любого типа JSON, любого типа символьных строк или bytea в кодировке UTF-8. Возвращаемый тип может быть любым типом символьных строк или bytea, по умолчанию — text.

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

json_exists ( элемент_контекста, выражение_пути [PASSING { значение AS имя_переменной } [, ...]] [RETURNING тип_данных] [ { TRUE | FALSE | UNKNOWN | ERROR } ON ERROR])

Возвращает true, если результатом применения выражения_пути к элементу_контекста с использованием значения оказывается непустое множество элементов. Предложение ON ERROR определяет, что выдаётся в случае возникновения ошибки. Обратите внимание, что если в выражении_пути передаётся strict, в случае отсутствия элементов возникает ошибка. Значение по умолчанию — UNKNOWN, то есть при ошибке выдаётся NULL.

json_exists(jsonb '{"key1": [1,2,3]}', 'strict $.key1[*] ? (@ > 2)') → 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 (ОШИБКА: индекс массива jsonpath вне диапазона)

json_value ( элемент_контекста, выражение_пути [PASSING { значение AS имя_переменной } [, ...]] [RETURNING тип_данных] [ { ERROR | NULL | DEFAULT выражение } ON EMPTY] [ { ERROR | NULL | DEFAULT выражение } ON ERROR])

Возвращает результат применения выражения_пути к элементу_контекста с использованием значения. Извлечённое значение должно быть одним скалярным элементом SQL/JSON. Для результатов, которые являются объектами или массивами, вместо этого используйте json_query. Возвращаемый тип_данных имеет ту же семантику, что и для функций-конструкторов, таких как json_objectagg. По умолчанию возвращается тип text. Предложение ON EMPTY определяет поведение, если выражение_пути не выдаёт никакого значения. Предложение ON ERROR определяет поведение в случае ошибки, возникшей либо при вычислении jsonpath (включая приведение к выходному типу), либо при вычислении предложения ON EMPTY (вызванного пустым результатом вычисления jsonpath).

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 $[*]' DEFAULT 9 ON ERROR) → 9

json_query ( элемент_контекста, выражение_пути [PASSING { значение AS имя_переменной } [, ...]] [RETURNING тип_данных [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])

Возвращает результат применения выражения_пути к элементу_контекста с использованием значения. Эта функция должна возвращать строку JSON, поэтому если выражение пути возвращает несколько элементов SQL/JSON, результат следует обернуть, применив предложение WITH WRAPPER. Если выбрана обёртка UNCONDITIONAL, всегда будет применяться обёртка массива, даже если возвращаемое значение уже является одиночным объектом JSON или массивом, но если выбрана обёртка CONDITIONAL, она не будет применяться к одиночному массиву или объекту. По умолчанию используется обёртка UNCONDITIONAL. Если результатом является скалярная строка, возвращаемое значение по умолчанию заключается в кавычки, что делает его допустимым значением JSON. Однако если указано OMIT QUOTES, это поведение меняется (кавычки не добавляются). Предложения ON ERROR и ON EMPTY имеют семантику, аналогичную семантике этих предложений для json_value. Возвращаемый тип_данных имеет ту же семантику, что и для функций-конструкторов, таких как json_objectagg. По умолчанию возвращается тип text.

json_query(jsonb '[1,[2,3],null]', 'lax $[*][1]' WITH CONDITIONAL WRAPPER) → [3]