json -> integer → json

jsonb -> integer → jsonb

Извлекает n-й элемент массива 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

Извлекает n-й элемент массива JSON в виде текста.

'[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 по указанному пути в виде текста.

'{"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). В противном случае, если существует приведение типов из 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, за исключением того, что между элементами массива верхнего уровня будут добавлены переводы строк, если опциональный логический параметр истинный.

array_to_json('{{1,5},{99,100}}'::int[]) → [[1,5],[99,100]]

row_to_json ( record [, boolean ] ) → json

Преобразует составное значение SQL в объект JSON. Поведение аналогично функции to_json, за исключением того, что между элементами верхнего уровня будут добавлены переводы строк, если необязательный логический параметр истинный.

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 ( 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-объекта в набор пар ключ/значение.

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 по указанному пути в виде текста. (Это функционально эквивалентно оператору #>>).

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

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

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

Удаляет все поля объекта, которые имеют значение null из заданного JSON значения, рекурсивно. Значения 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-путем для указанного 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-значения, в виде 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-путем для указанного 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