9.16. Функции и операторы JSON
Пред. НаверхГлава 9. Функции и операторыНачало След.

9.16. Функции и операторы JSON #

9.16.1. Обработка и создание данных JSON
9.16.2. Язык путей SQL/JSON
9.16.3. Функции запросов SQL/JSON
9.16.4. JSON_TABLE

В этом разделе описываются:

  • функции и операторы, предназначенные для работы с данными JSON

  • язык путей SQL/JSON

  • функции запросов SQL/JSON

Postgres Pro реализует модель данных SQL/JSON, обеспечивая встроенную поддержку типов данных JSON в среде SQL. В этой модели данные представляются последовательностями элементов. Каждый элемент может содержать скалярные значения SQL, дополнительно определённое в SQL/JSON значение null и составные структуры данных, образуемые объектами и массивами JSON. Данная модель по сути формализует модель данных, описанную в спецификации JSON RFC 7159.

Поддержка SQL/JSON позволяет обрабатывать данные JSON наряду с обычными данными SQL, используя при этом транзакции, например:

  • Загружать данные JSON в базу и сохранять их в обычных столбцах SQL в виде символьных или двоичных строк.

  • Создавать объекты и массивы JSON из реляционных данных.

  • Обращаться к данным JSON, используя функции запросов SQL/JSON и выражения языка путей SQL/JSON.

Чтобы узнать больше о стандарте SQL/JSON, обратитесь к [sqltr-19075-6]. Типы JSON, поддерживаемые в Postgres Pro, описаны в Разделе 8.14.

9.16.1. Обработка и создание данных JSON #

Примечание

Функции, работающие с JSONB, не принимают символы '\u0000'. Чтобы избежать ошибок и заменять их на лету, необходимо указать символ Unicode в параметре конфигурации unicode_nul_character_replacement_in_jsonb.

В Таблице 9.47 показаны имеющиеся операторы для работы с данными JSON (см. Раздел 8.14). Кроме них для типа jsonb, но не для json, определены обычные операторы сравнения, показанные в Таблице 9.1. Они следуют правилам упорядочивания для операций B-дерева, описанным в Подразделе 8.14.4. В Разделе 9.21 вы также можете узнать об агрегатной функции json_agg, которая агрегирует значения записи в виде JSON, и агрегатной функции json_object_agg, агрегирующей пары значений в объект JSON, а также их аналогах для jsonb, функциях jsonb_agg и jsonb_object_agg.

Таблица 9.47. Операторы для типов json и jsonb

Оператор

Описание

Пример(ы)

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


Примечание

Если структура входного JSON не соответствует запросу, например указанный ключ или элемент массива отсутствует, операторы извлечения поля/элемента/пути не выдают ошибку, а возвращают NULL.

Некоторые из следующих операторов существуют только для jsonb, как показано в Таблице 9.48. В Подразделе 8.14.4 описано, как эти операторы могут использоваться для эффективного поиска в индексированных данных jsonb.

Таблица 9.48. Дополнительные операторы jsonb

Оператор

Описание

Пример(ы)

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? (Это полезно только для выражений пути JSON по стандарту SQL, но не для выражений проверки предикатов, поскольку они всегда возвращают значение.)

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

jsonb @@ jsonpath → boolean

Возвращает результат проверки предиката пути JSON для указанного значения JSON. (Это полезно только для выражений проверки предикатов, но не для выражений пути JSON по стандарту SQL, поскольку возвращается NULL, если результат пути не является одним логическим значением.)

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


Примечание

Операторы jsonpath @? и @@ подавляют следующие ошибки: отсутствие поля объекта или элемента массива, несовпадение типа элемента JSON и ошибки в числах и дате/времени. Описанные ниже функции, связанные с jsonpath, тоже могут подавлять ошибки такого рода. Это может быть полезно, когда нужно произвести поиск по набору документов JSON, имеющих различную структуру.

В Таблице 9.49 показаны функции, позволяющие создавать значения типов json и jsonb. Для некоторых функций в этой таблице имеется предложение RETURNING, которое определяет возвращаемый тип данных. Это должен быть json, jsonb, bytea, тип символьной строки (text, char или varchar) или тип, который можно привести к json. По умолчанию возвращается тип json.

Таблица 9.49. Функции для создания JSON

Функция

Описание

Пример(ы)

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

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]

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 ( [ { выражение_ключа { 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 KEYS в выражении_ключа не должно быть дублирующихся значений. С указанием ABSENT ON NULL вся пара пропускается, если выражение_значения равно 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 ( 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 ( выражение [FORMAT JSON [ENCODING UTF8]] [ { WITH | WITHOUT } UNIQUE [KEYS]] ) → json

Преобразует выражение, заданное в виде строки типа text или bytea (в кодировке UTF-8), в значение JSON. Если в выражении передаётся 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 тип_данных [FORMAT JSON [ENCODING UTF8]]] )

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

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

[a] Например, в расширении hstore определено преобразование из hstore в json, так что значения hstore, преобразуемые функциями создания JSON, будут представлены в виде объектов JSON, а не как примитивные строковые значения.


В Таблице 9.50 описаны средства SQL/JSON для проверки JSON.

Таблица 9.50. Функции проверки SQL/JSON

Сигнатура функции

Описание

Пример(ы)

выражение 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


В Таблице 9.51 показаны функции, предназначенные для работы со значениями json и jsonb.

Таблица 9.51. Функции для обработки JSON

Функция

Описание

Пример(ы)

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-тип выходного столбца последовательно применяются следующие правила:

  • Значение NULL в JSON всегда преобразуется в SQL NULL.

  • Если выходной столбец имеет тип json или jsonb, значение JSON воспроизводится без изменений.

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

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

  • Если же значение JSON является строкой, содержимое этой строки передаётся входной функции преобразования для типа данных целевого столбца.

  • В противном случае функции преобразования для типа данных целевого столбца передаётся обычное текстовое представление значения JSON.

В следующем примере значение 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")

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

SELECT * FROM jsonb_populate_record(NULL::jsb_char2, '{"a": "aaa"}') q; → 

ОШИБКА:  значение не умещается в тип 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, вызывающий запрос должен явно определять структуру записи в 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 ( target json [,strip_in_arrays boolean] ) → json

jsonb_strip_nulls ( target jsonb [,strip_in_arrays boolean] ) → jsonb

Удаляет из данного значения JSON все поля объектов, имеющие значения null, на всех уровнях вложенности. Если для strip_in_arrays задано значение true (по умолчанию — false), также убираются элементы null массива. В противном случае эти элементы не убираются. Простые значения null не убираются никогда.

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

jsonb_strip_nulls('[1,2,null,3,4]', true) → [1,2,3,4]

jsonb_path_exists ( target jsonb, path jsonpath [, vars jsonb [, silent boolean]] ) → boolean

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

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

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

Возвращает все элементы 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 ( target jsonb, path jsonpath [, vars jsonb [, silent boolean]] ) → jsonb

Возвращает первый элемент JSON, полученный по указанному пути для заданного значения JSON, либо 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 ( 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



9.16.2. Язык путей SQL/JSON #

Выражения путей SQL/JSON определяют элементы, извлекаемые из данных JSON, подобно тому, как выражения XPath позволяют обращаться из SQL к XML. В Postgres Pro выражения путей представляются в виде типа данных jsonpath и могут использовать любые элементы, описанные в Подразделе 8.14.7.

Операторы и функции запросов к JSON передают поступившее им выражение обработчику путей для вычисления. Если выражению соответствуют фигурирующие в запросе данные JSON, в результате выдаётся соответствующий элемент JSON или набор элементов. Если совпадение не найдено, в зависимости от функции выдаётся NULL, false или ошибка. Выражения путей записываются на языке путей SQL/JSON и могут включать сложные арифметические выражения и функции.

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

Для обращения к поступившему в запрос значению JSON (элементу контекста) в выражении пути используется переменная $. Первый элемент пути всегда должен быть $. Затем могут следовать один или более операторов обращения, которые, опускаясь в структуре JSON с одного уровня на другой, извлекают элементы, вложенные в текущий элемент контекста. При этом каждый оператор обращения имеет дело с результатом вычисления, полученным на предыдущем шаге, и выдаёт ноль, один или более выходных элементов на каждый входной элемент.

Допустим, нужно проанализировать данные JSON с GPS-трекера, например: 

SELECT '{
  "track": {
    "segments": [
      {
        "location":   [ 47.763, 13.4034 ],
        "start time": "2018-10-14 10:05:14",
        "HR": 73
      },
      {
        "location":   [ 47.706, 13.2635 ],
        "start time": "2018-10-14 10:39:21",
        "HR": 135
      }
    ]
  }
}' AS json \gset

(Пример выше можно скопировать и вставить в psql, чтобы настроить всё для следующих примеров. Затем psql расширит :'json' до строковой константы в соответствующих кавычках, содержащей значение JSON.)

Чтобы получить доступные сегменты отслеживания, используйте оператор доступа .ключ для спуска по окружающим объектам JSON, например: 

=> select jsonb_path_query(:'json', '$.track.segments');
jsonb_path_query
-----------------------------------------------------------​------------------------------------------------------------​--------------------------------------------
[{"HR": 73, "location": [47.763, 13.4034], "start time": "2018-10-14 10:05:14"}, {"HR": 135, "location": [47.706, 13.2635], "start time": "2018-10-14 10:39:21"}]

Для извлечения содержимого массива обычно используется оператор [*]. В следующем примере возвращаются координаты местоположения для всех доступных сегментов треков: 

=> select jsonb_path_query(:'json', '$.track.segments[*].location');
jsonb_path_query
-------------------
[47.763, 13.4034]
[47.706, 13.2635]

Здесь мы начали с целого входного значения JSON ($), затем оператор обращения .track выбрал объект JSON, связанный с ключом объекта "track", оператор обращения .segments выбрал массив JSON, связанный с ключом "segments" внутри этого объекта, оператор обращения [*] выбрал каждый элемент этого массива (создав ряд элементов), а оператор обращения .location выбрал массив JSON, связанный с ключом "location" внутри каждого из этих объектов. В этом примере у каждого из этих объектов был ключ "location", но если бы это было не так, вывод оператора обращения .location был бы пустым для этого элемента ввода.

Чтобы получить координаты только первого сегмента, можно задать соответствующий индекс в операторе обращения []. Обратите внимание, что индексы в JSON-массивах отсчитываются с 0: 

=> select jsonb_path_query(:'json', '$.track.segments[0].location');
 jsonb_path_query
-------------------
 [47.763, 13.4034]

Результат каждого шага вычисления выражения может быть обработан одним или несколькими операторами и методами jsonpath, перечисленными в Подразделе 9.16.2.3. Перед именем метода должна стоять точка. Например, так можно получить размер массива: 

=> select jsonb_path_query(:'json', '$.track.segments.size()');
 jsonb_path_query
------------------
 2

Другие примеры использования операторов и методов jsonpath в выражениях пути приведены ниже в Подразделе 9.16.2.3.

Определяя путь, также можно использовать выражения фильтра, работающие подобно предложению WHERE в SQL. Выражение фильтра начинается со знака вопроса и содержит условие в круглых скобках: 

? (условие)

Выражения фильтра указываются сразу после шага вычисления пути, к которому они должны применяться. Результаты шага проходят через фильтр, и на выходе остаются только те элементы, которые удовлетворяют заданному условию. В SQL/JSON действует троичная логика, то есть результатом проверки условия может быть true, false или unknown (неизвестность). Значение unknown играет ту же роль, что и NULL в SQL, и может быть проверено предикатом is unknown. На последующих шагах вычисления пути будут обрабатываться только те элементы, для которых выражение фильтра выдало true.

Функции и операторы, которые можно использовать в выражениях фильтра, перечислены в Таблице 9.53. Переменная @ в выражении фильтра представляет рассматриваемое значение (результат предыдущего шага в пути). Для получения внутренних элементов этого значения вы можете добавить операторы обращения после @.

Например, нужно получить все значения пульса выше 130. Это можно сделать следующим образом: 

=> select jsonb_path_query(:'json', '$.track.segments[*].HR ? (@ > 130)');
jsonb_path_query
------------------
135

Чтобы получить в результате время начала соответствующих сегментов, нужно отфильтровать ненужные сегменты, а затем выбрать время, так что фильтр будет применяться к предыдущему шагу и путь окажется другим: 

=> select jsonb_path_query(:'json', '$.track.segments[*] ? (@.HR > 130)."start time"');
   jsonb_path_query
-----------------------
 "2018-10-14 10:39:21"

Можно также использовать несколько выражений фильтра по очереди, когда это требуется. Например, следующее выражение выбирает время начала всех сегментов с определёнными координатами и высоким показателем пульса: 

=> select jsonb_path_query(:'json', '$.track.segments[*] ? (@.location[1] < 13.4) ? (@.HR > 130)."start time"');
   jsonb_path_query
-----------------------
 "2018-10-14 10:39:21"

Также возможно использовать фильтры на разных уровнях вложенности. В следующем примере сначала сегменты фильтруются по координатам, а затем для подходящих сегментов, если они находятся, выбираются значения высокого пульса: 

=> select jsonb_path_query(:'json', '$.track.segments[*] ? (@.location[1] < 13.4).HR ? (@ > 130)');
 jsonb_path_query
------------------
 135

Можно также вкладывать выражения фильтра одно в другое. Данное выражение возвращает количество сегментов в треке, если он содержит сегменты с высокими показателями пульса, или пустую последовательность, если таких сегментов нет: 

=> select jsonb_path_query(:'json', '$.track ? (exists(@.segments[*] ? (@.HR > 130))).segments.size()');
 jsonb_path_query
------------------
 2

9.16.2.1. Отличия от стандарта SQL #

Реализация языка путей SQL/JSON в Postgres Pro имеет следующие отличия от стандарта SQL/JSON.

9.16.2.1.1. Выражения проверки булевых предикатов #

Как расширение стандарта SQL, выражение пути Postgres Pro может быть булевым предикатом, тогда как стандарт SQL допускает предикаты только в фильтрах. В то время как выражения пути стандарта SQL возвращают соответствующий элемент(ы) запрошенного значения JSON, выражения проверки предикатов возвращают один из трёх возможных результатов типа jsonb проверки предиката: true, false или null. Например, можно написать такое выражение фильтра стандарта SQL: 

=> select jsonb_path_query(:'json', '$.track.segments ?(@[*].HR > 130)');
                                jsonb_path_query
-----------------------------------------------------------​----------------------
 {"HR": 135, "location": [47.706, 13.2635], "start time": "2018-10-14 10:39:21"}

Аналогичное выражение проверки предикатов просто возвращает true, указывая на то, что совпадение существует: 

=> select jsonb_path_query(:'json', '$.track.segments[*].HR > 130');
 jsonb_path_query
------------------
 true

Примечание

Выражения проверки предикатов обязательны для оператора @@ (и функции jsonb_path_match) и не должны использоваться с оператором @? (или функцией jsonb_path_exists).

9.16.2.1.2. Интерпретация регулярных выражений #

Есть небольшие различия в интерпретации шаблонов регулярных выражений, используемых в фильтрах like_regex; имеющиеся особенности описаны в Подразделе 9.16.2.4.

9.16.2.2. Строгий и нестрогий режимы #

Когда вы обращаетесь к данным JSON, выражение пути может не соответствовать фактической структуре данных JSON. Попытка обратиться к несуществующему члену объекта или элементу массива определяется как ошибка структурного типа. Для обработки такого рода ошибок в выражениях путей SQL/JSON предусмотрены два режима:

  • lax (по умолчанию) — нестрогий режим, в котором обработчик путей неявно адаптирует обрабатываемые данные к указанному пути. Любые структурные ошибки, которые не могут быть устранены указанными ниже способами, подавляются, и запрос не возвращает для них совпадения.

  • strict — строгий режим, в котором структурные ошибки выдаются как есть.

Нестрогий режим упрощает сопоставление документа JSON с выражением пути в случаях, когда данные JSON не соответствуют ожидаемой схеме. Если операнд не удовлетворяет требованиям определённой операции, он может перед выполнением этой операции автоматически оборачиваться в массив SQL/JSON или наоборот, разворачиваться так, чтобы его элементы образовали последовательность SQL/JSON. Также в нестрогом режиме операторы сравнения автоматически разворачивают свои операнды, что позволяет легко сравнивать массивы SQL/JSON. Массив с одним элементом в таком режиме считается равным своему элементу. Автоматическое разворачивание не выполняется в следующих случаях:

  • В выражении пути фигурируют методы size() и type(), возвращающие соответственно число элементов в массиве и тип.

  • Обрабатываемые данные JSON содержат вложенные массивы. В этом случае разворачивается только массив верхнего уровня, а внутренние массивы остаются без изменений. Таким образом, неявное разворачивание может опускаться на каждом шаге вычисления пути только на один уровень.

Например, обрабатывая данные GPS, показанные выше, в нестрогом режиме можно не обращать внимание на то, что в них содержится массив сегментов: 

=> select jsonb_path_query(:'json', 'lax $.track.segments.location');
 jsonb_path_query
-------------------
 [47.763, 13.4034]
 [47.706, 13.2635]

В строгом режиме указанный путь должен точно соответствовать структуре запрашиваемого документа JSON, поэтому использование этого выражения пути вызовет ошибку: 

=> select jsonb_path_query(:'json', 'strict $.track.segments.location');
ОШИБКА:  выражение обращения к члену в jsonpath может применяться только к объекту

Чтобы получить тот же результат, что и в нестрогом режиме, нужно явно развернуть массив segments: 

=> select jsonb_path_query(:'json', 'strict $.track.segments[*].location');
 jsonb_path_query
-------------------
 [47.763, 13.4034]
 [47.706, 13.2635]

Поведение разворачивания в нестрогом режиме может выдавать несколько неожиданные результаты. Например, следующий запрос с оператором обращения .** выберет каждое значение HR дважды: 

=> select jsonb_path_query(:'json', 'lax $.**.HR');
 jsonb_path_query
------------------
 73
 135
 73
 135

Это происходит потому, что оператор .** выбирает и массив segments, и каждый из его элементов, а обращение .HR в нестрогом режиме автоматически разворачивает массивы. Во избежание подобных сюрпризов мы рекомендуем использовать оператор обращения .** только в строгом режиме. Следующий запрос выбирает каждое значение HR в единственном экземпляре: 

=> select jsonb_path_query(:'json', 'strict $.**.HR');
 jsonb_path_query
------------------
 73
 135

Развёртывание массивов также может привести к неожиданным результатам. Рассмотрим пример, в котором выбираются все массивы location: 

=> select jsonb_path_query(:'json', 'lax $.track.segments[*].location');
jsonb_path_query
-------------------
[47.763, 13.4034]
[47.706, 13.2635]
(2 rows)

Как и ожидалось, возвращаются полные массивы. Но применение выражения фильтра приводит к тому, что массивы разворачиваются для оценки каждого элемента, возвращая только те элементы, которые соответствуют выражению: 

=> select jsonb_path_query(:'json', 'lax $.track.segments[*].location ?(@[*] > 15)');
jsonb_path_query
------------------
47,763
47,706
(2 rows)

Это происходит несмотря на то, что выражение пути выбирает полные массивы. Используйте строгий режим для восстановления выбора только массивов: 

=> select jsonb_path_query(:'json', 'strict $.track.segments[*].location ?(@[*] > 15)');
jsonb_path_query
-------------------
[47.763, 13.4034]
[47.706, 13.2635]
(2 rows)

9.16.2.3. Операторы и методы SQL/JSON #

В Таблице 9.52 показаны операторы и методы, поддерживаемые в значениях jsonpath. Обратите внимание, что унарные операторы и методы могут применяться к множеству значений, полученных на предыдущем шаге пути, тогда как бинарные операторы (сложение и т. п.) применяются только к отдельным значениям. В нестрогом режиме методы, применяемые к массиву, будут исполняться для каждого значения в массиве. Исключениями являются .type() и .size(), которые применяются к самому массиву.

Таблица 9.52. Операторы и методы jsonpath

Оператор/Метод

Описание

Пример(ы)

число + число → число

Сложение

jsonb_path_query('[2]', '$[0] + 3') → 5

+ число → число

Унарный плюс (нет операции); в отличие от сложения, он может итерационно применяться к множеству значений

jsonb_path_query_array('{"x": [2,3,4]}', '+ $.x') → [2, 3, 4]

число - число → число

Вычитание

jsonb_path_query('[2]', '7 - $[0]') → 5

- число → число

Смена знака; в отличие от вычитания, этот оператор может итерационно применяться к множеству значений

jsonb_path_query_array('{"x": [2,3,4]}', '- $.x') → [-2, -3, -4]

число * число → число

Умножение

jsonb_path_query('[4]', '2 * $[0]') → 8

число / число → число

Деление

jsonb_path_query('[8.5]', '$[0] / 2') → 4.2500000000000000

число % число → число

Остаток от деления

jsonb_path_query('[32]', '$[0] % 10') → 2

значение . type() → строка

Тип элемента JSON (см. json_typeof)

jsonb_path_query_array('[1, "2", {}]', '$[*].type()') → ["number", "string", "object"]

значение . size() → число

Размер элемента JSON (число элементов в массиве либо 1, если это не массив)

jsonb_path_query('{"m": [11, 15]}', '$.m.size()') → 2

значение . boolean() → логическое_значение

Логическое значение, преобразованное из логического значения JSON, числа или строки

jsonb_path_query_array('[1, "yes", false]', '$[*].boolean()') → [true, true, false]

значение . string() → строка

Строковое значение, преобразованное из логического значения JSON, числа, строки или значения типа дата-время

jsonb_path_query_array('[1.23, "xyz", false]', '$[*].string()') → ["1.23", "xyz", "false"]

jsonb_path_query('"2023-08-15 12:34:56"', '$.timestamp().string()') → "2023-08-15T12:34:56"

значение . double() → число

Приблизительное число с плавающей точкой, преобразованное из строки или числа JSON

jsonb_path_query('{"len": "1.9"}', '$.len.double() * 2') → 3.8

число . ceiling() → число

Ближайшее целое, большее или равное заданному числу

jsonb_path_query('{"h": 1.3}', '$.h.ceiling()') → 2

число . floor() → число

Ближайшее целое, меньшее или равное заданному числу

jsonb_path_query('{"h": 1.7}', '$.h.floor()') → 1

число . abs() → число

Модуль заданного числа (абсолютное значение)

jsonb_path_query('{"z": -0.3}', '$.z.abs()') → 0.3

значение . bigint() → bigint

Большое целочисленное значение, преобразованное из числового или строкового значения JSON

jsonb_path_query('{"len": "9876543219"}', '$.len.bigint()') → 9876543219

значение . decimal( [ точность [ , масштаб ] ] ) → decimal

Округлённое десятичное значение, преобразованное из числового или строкового значения JSON (значения точность и масштаб должны быть целыми числами)

jsonb_path_query('1234.5678', '$.decimal(6, 2)') → 1234.57

значение . integer() → целое_число

Целочисленное значение, преобразованное из числового или строкового значения JSON

jsonb_path_query('{"len": "12345"}', '$.len.integer()') → 12345

значение . number() → число

Числовое значение, преобразованное из числового или строкового значения JSON

jsonb_path_query('{"len": "123.45"}', '$.len.number()') → 123.45

строка . datetime() → тип_даты_времени (см. примечание)

Значение даты/времени, полученное из строки

jsonb_path_query('["2015-8-1", "2015-08-12"]', '$[*] ? (@.datetime() < "2015-08-2".datetime())') → "2015-8-1"

string . datetime(шаблон) → тип_даты_времени (см. примечание)

Значение даты/времени, преобразованное из строки по шаблону to_timestamp

jsonb_path_query_array('["12:30", "18:40"]', '$[*].datetime("HH24:MI")') → ["12:30:00", "18:40:00"]

строка . date() → дата

Значение даты, преобразованное из строки

jsonb_path_query('"2023-08-15"', '$.date()') → "2023-08-15"

строка . time() → время без часового пояса

Значение времени без часового пояса, полученное из строки

jsonb_path_query('"12:34:56"', '$.time()') → "12:34:56"

строка . time(точность) → время без часового пояса

Значение времени без часового пояса, преобразованное из строки, с долями секунды, округлённой до заданной точности

jsonb_path_query('"12:34:56.789"', '$.time(2)') → "12:34:56.79"

строка . time_tz() → время с часовым поясом

Значение времени с часовым поясом, полученное из строки

jsonb_path_query('"12:34:56 +05:30"', '$.time_tz()') → "12:34:56+05:30"

строка . time_tz(точность) → время с часовым поясом

Значение времени с часовым поясом, преобразованное из строки, с долями секунды, округлённой до заданной точности

jsonb_path_query('"12:34:56.789 +05:30"', '$.time_tz(2)') → "12:34:56.79+05:30"

строка . timestamp() → дата и время без часового пояса

Значение даты/времени без часового пояса, полученное из строки

jsonb_path_query('"2023-08-15 12:34:56"', '$.timestamp()') → "2023-08-15T12:34:56"

строка . timestamp(точность) → дата и время без часового пояса

Значение даты-времени без часового пояса, преобразованное из строки, с долями секунды, округлённой до заданной точности

jsonb_path_query('"2023-08-15 12:34:56.789"', '$.timestamp(2)') → "2023-08-15T12:34:56.79"

строка . timestamp_tz() → дата и время с часовым поясом

Значение даты/времени с часовым поясом, полученное из строки

jsonb_path_query('"2023-08-15 12:34:56 +05:30"', '$.timestamp_tz()') → "2023-08-15T12:34:56+05:30"

строка . timestamp_tz(точность) → дата и время с часовым поясом

Значение даты/времени с часовым поясом, преобразованное из строки, с долями секунды, округлённой до заданной точности

jsonb_path_query('"2023-08-15 12:34:56.789 +05:30"', '$.timestamp_tz(2)') → "2023-08-15T12:34:56.79+05:30"

object . keyvalue() → массив

Пары ключ-значение, представленные в виде массива объектов со следующими тремя полями: "key", "value" и "id"; в "id" содержится уникальный идентификатор объекта, к которому относится данная пара ключ-значение

jsonb_path_query_array('{"x": "20", "y": 32}', '$.keyvalue()') → [{"id": 0, "key": "x", "value": "20"}, {"id": 0, "key": "y", "value": 32}]


Примечание

Результирующим типом методов datetime() и datetime(шаблон) может быть date, timetz, time, timestamptz или timestamp. Эти два метода определяют тип своего результата автоматически.

Метод datetime() пытается последовательно сопоставить поступившую на вход строку с ISO-форматами типов date, timetz, time, timestamptz и timestamp. Встретив первый подходящий формат, он останавливается и возвращает соответствующий тип данных.

Метод datetime(шаблон) определяет результирующий тип в соответствии с полями заданного шаблона.

Методы datetime() и datetime(шаблон) применяют те же правила разбора строки, что и SQL-функция to_timestamp (см. Раздел 9.8), но с тремя исключениями. Во-первых, эти методы не позволяют использовать в шаблоне поля, которым не находится соответствие. Во-вторых, в шаблоне допускаются только следующие разделители: знак минуса, точка, косая черта, запятая, апостроф, точка с запятой, запятая и пробел. В-третьих, разделители в шаблоне должны в точности соответствовать входной строке.

Если требуется сравнить значения разных типов даты/времени, применяется неявное приведение типа. Значение date может быть приведено к типу timestamp или timestamptz; timestamp — к типу timestamptz, а time — к timetz. Однако все эти приведения, кроме первого, зависят от текущего значения TimeZone и поэтому не могут выполняться в функциях jsonpath, не учитывающих часовой пояс. Аналогично, в других методах, связанных с датой/временем и преобразующих строки в типы даты/времени, также выполняется это преобразование, в котором может участвовать параметр TimeZone с текущим значением. Поэтому эти преобразования также могут выполняться только в функциях jsonpath с поддержкой часового пояса.

В Таблице 9.53 перечислены допустимые элементы выражения фильтра.

Таблица 9.53. Элементы выражения фильтра jsonpath

Предикат/значение

Описание

Пример(ы)

значение == значение → boolean

Проверка равенства (все операторы сравнения, включая этот, работают с любыми скалярными значениями JSON)

jsonb_path_query_array('[1, "a", 1, 3]', '$[*] ? (@ == 1)') → [1, 1]

jsonb_path_query_array('[1, "a", 1, 3]', '$[*] ? (@ == "a")') → ["a"]

значение != значение → boolean

значение <> значение → boolean

Проверка неравенства

jsonb_path_query_array('[1, 2, 1, 3]', '$[*] ? (@ != 1)') → [2, 3]

jsonb_path_query_array('["a", "b", "c"]', '$[*] ? (@ <> "b")') → ["a", "c"]

значение < значение → boolean

Проверка «меньше»

jsonb_path_query_array('[1, 2, 3]', '$[*] ? (@ < 2)') → [1]

значение <= значение → boolean

Проверка «меньше или равно»

jsonb_path_query_array('["a", "b", "c"]', '$[*] ? (@ <= "b")') → ["a", "b"]

значение > значение → boolean

Проверка «больше»

jsonb_path_query_array('[1, 2, 3]', '$[*] ? (@ > 2)') → [3]

значение >= значение → boolean

Проверка «больше или равно»

jsonb_path_query_array('[1, 2, 3]', '$[*] ? (@ >= 2)') → [2, 3]

true → boolean

JSON-константа true

jsonb_path_query('[{"name": "John", "parent": false}, {"name": "Chris", "parent": true}]', '$[*] ? (@.parent == true)') → {"name": "Chris", "parent": true}

false → boolean

JSON-константа false

jsonb_path_query('[{"name": "John", "parent": false}, {"name": "Chris", "parent": true}]', '$[*] ? (@.parent == false)') → {"name": "John", "parent": false}

null → значение

JSON-константа null (заметьте, что в отличие от SQL сравнение с null работает традиционным образом)

jsonb_path_query('[{"name": "Mary", "job": null}, {"name": "Michael", "job": "driver"}]', '$[*] ? (@.job == null) .name') → "Mary"

логическое_значение && логическое_значение → boolean

Логическое И

jsonb_path_query('[1, 3, 7]', '$[*] ? (@ > 1 && @ < 5)') → 3

логическое_значение || логическое_значение → boolean

Логическое ИЛИ

jsonb_path_query('[1, 3, 7]', '$[*] ? (@ < 1 || @ > 5)') → 7

! логическое_значение → boolean

Логическое НЕ

jsonb_path_query('[1, 3, 7]', '$[*] ? (!(@ < 5))') → 7

логическое_значение is unknown → boolean

Проверяет, является ли unknown результатом логического условия.

jsonb_path_query('[-1, 2, 7, "foo"]', '$[*] ? ((@ > 0) is unknown)') → "foo"

строка like_regex строка [ flag строка ] → boolean

Проверяет, соответствует ли первый операнд регулярному выражению, которое задаёт второй операнд с необязательным аргументом flag, влияющим на поведение выражения (см. Подраздел 9.16.2.4).

jsonb_path_query_array('["abc", "abd", "aBdC", "abdacb", "babc"]', '$[*] ? (@ like_regex "^ab.*c")') → ["abc", "abdacb"]

jsonb_path_query_array('["abc", "abd", "aBdC", "abdacb", "babc"]', '$[*] ? (@ like_regex "^ab.*c" flag "i")') → ["abc", "aBdC", "abdacb"]

строка starts with строка → boolean

Проверяет, является ли второй операнд начальной подстрокой первого.

jsonb_path_query('["John Smith", "Mary Stone", "Bob Johnson"]', '$[*] ? (@ starts with "John")') → "John Smith"

exists ( выражение_пути ) → boolean

Проверяет, соответствует ли выражению пути минимум один элемент SQL/JSON. Возвращает unknown, если вычисление выражения пути могло привести к ошибке; это используется во втором примере для недопущения ошибки «ключ не найден» в строгом режиме.

jsonb_path_query('{"x": [1, 2], "y": [2, 4]}', 'strict $.* ? (exists (@ ? (@[*] > 2)))') → [2, 4]

jsonb_path_query_array('{"value": 41}', 'strict $ ? (exists (@.name)) .name') → []


9.16.2.4. Регулярные выражения SQL/JSON #

Выражения путей SQL/JSON могут содержать фильтры like_regex, позволяющие сопоставлять текст с регулярным выражением. Например, следующий запрос пути SQL/JSON выберет все строки в массиве, которые начинаются с английской гласной в любом регистре: 

$[*] ? (@ like_regex "^[aeiou]" flag "i")

Необязательная строка flag может содержать один или несколько следующих символов: i, делающий поиск регистронезависимым, m, допускающий сопоставление ^ и $ с переводами строк, s, допускающий сопоставление . с символом новой строки, и q, берущий в кавычки весь шаблон (в результате производится простой поиск подстроки).

Стандарт SQL/JSON заимствует определение регулярных выражений от оператора LIKE_REGEX, который, в свою очередь, реализуется по стандарту XQuery. Однако в Postgres Pro оператор LIKE_REGEX в настоящее время отсутствует. Поэтому фильтр like_regex реализован с использованием механизма регулярных выражений POSIX, который описан в Подразделе 9.7.3. Вследствие этого наблюдается ряд небольших отклонений от описанного в стандарте поведения SQL/JSON, о которых рассказывается в Подразделе 9.7.3.8. Заметьте однако, что описанная там несовместимость букв флагов не проявляется на уровне SQL/JSON, так как заданные в SQL/JSON флаги XQuery переводятся во флаги, воспринимаемые механизмом POSIX.

Помните, что аргумент, задающий шаблон для like_regex, является строкой пути JSON и записывается по правилам, описанным в Подразделе 8.14.7. Это в частности означает, что каждую косую черту в регулярном выражении надо дублировать. Например, чтобы отобрать строковые значения, находящиеся на уровне корня документа и содержащие только цифры, нужно написать: 

$.* ? (@ like_regex "^\\d+$")

9.16.3. Функции запросов SQL/JSON #

Функции SQL/JSON JSON_EXISTS(), JSON_QUERY() и JSON_VALUE(), описанные в Таблица 9.54, можно использовать для запросов к документам JSON. Все эти функции используют выражение_пути (запрос пути SQL/JSON) к элементу_контекста (документу). За более подробным описанием возможного содержимого выражения_пути обратитесь к Подразделу 9.16.2. В выражении_пути также можно ссылаться на переменные, значения которых указаны с соответствующими именами в предложении PASSING, которое поддерживается всеми функциями. элемент_контекста может быть значением jsonb или символьной строкой, которая может быть приведена к jsonb.

Таблица 9.54. Функции запросов SQL/JSON

Сигнатура функции

Описание

Пример(ы)

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

  • Возвращает true, если в результате применения выражения_пути SQL/JSON к элементу_контекста были получены какие-либо элементы, и false в противном случае.

  • Предложение ON ERROR определяет поведение, если во время вычисления выражения_пути возникает ошибка. Указание ERROR приведёт к появлению ошибки с соответствующим сообщением. Другие параметры включают возврат значений типа boolean (FALSE или TRUE) или значения UNKNOWN, которое фактически равнозначно SQL NULL. Если предложение ON ERROR не указано, по умолчанию возвращается FALSE.

Примеры:

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 (
элемент_контекста, выражение_пути
[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]) → jsonb

  • Возвращает результат применения выражения_пути SQL/JSON к элементу_контекста.

  • По умолчанию результат возвращается как значение типа jsonb, хотя можно использовать предложение RETURNING для возврата значения и другого типа, к которому можно привести тип jsonb.

  • Если выражение пути может вернуть несколько значений, может потребоваться обернуть эти значения с помощью предложения WITH WRAPPER, чтобы превратить его в допустимую строку JSON, поскольку по умолчанию они не обёртываются, как если бы было указано WITHOUT WRAPPER. Предложение WITH WRAPPER по умолчанию означает WITH UNCONDITIONAL WRAPPER, то есть даже одно значение результата будет обёрнуто. Чтобы применить обёртку только при наличии нескольких значений, укажите WITH CONDITIONAL WRAPPER. Если указано предложение WITHOUT WRAPPER, получение нескольких значений в результате будет рассматриваться как ошибка.

  • Если результатом является скалярная строка, по умолчанию возвращаемое значение заключается в кавычки, чтобы сделать его допустимым значением JSON. Это можно сделать явно, указав KEEP QUOTES. И наоборот, кавычки можно опустить, указав OMIT QUOTES. Чтобы гарантировать, что в результате будет получено допустимое значение JSON, OMIT QUOTES нельзя указывать одновременно с WITH WRAPPER.

  • Предложение ON EMPTY определяет поведение, если вычисление выражения_пути возвращает пустое множество. Предложение ON ERROR определяет поведение, если возникает ошибка при вычислении выражения_пути, при приведении значения результата к типу RETURNING или если вычисление выражение_пути возвращает пустое множество при вычислении выражения ON EMPTY.

  • Как для ON EMPTY, так и для ON ERROR указание ERROR приведёт к выводу соответствующего сообщения об ошибке. При других вариантах возвращаются SQL NULL, пустой массив (EMPTY [ARRAY]), пустой объект (EMPTY OBJECT) или указанное пользователем выражение (DEFAULT выражение), которое может быть приведено к JSONB или типу, указанному в RETURNING. По умолчанию, если не указано ON EMPTY или ON ERROR, возвращается значение SQL NULL.

Примеры:

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

ОШИБКА:  ошибочный литерал массива: "[1, 2]"
ПОДРОБНОСТИ:  После размерностей массива отсутствует "]".

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

  • Возвращает результат применения выражения_пути SQL/JSON к элементу_контекста.

  • Используйте JSON_VALUE() только в том случае, если ожидается, что полученное значение будет представлять собой один скалярный элемент SQL/JSON, получение нескольких значений будет считаться ошибкой. Если ожидается, что извлечённое значение может быть объектом или массивом, используйте функцию JSON_QUERY.

  • По умолчанию результат, который должен быть единственным скалярным значением, возвращается как значение типа text, хотя можно использовать предложение RETURNING для возврата значения и другого типа, к которому можно привести тип text.

  • Предложения ON ERROR и ON EMPTY имеют схожую семантику, указанную в описании JSON_QUERY, но разные наборы значений, возвращаемые вместо ошибки.

  • Обратите внимание, что у скалярных строк, возвращаемых функцией JSON_VALUE, всегда удаляются кавычки, что эквивалентно указанию OMIT QUOTES в JSON_QUERY.

Примеры:

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


Примечание

Выражение элемент_контекста неявно приводится к типу jsonb, если передаётся не этого типа. Однако обратите внимание, что любые ошибки разбора, возникающие во время этого преобразования, выдаются безусловно, то есть не обрабатываются в соответствии с (указанным или неявным) предложением ON ERROR.

Примечание

Функция JSON_VALUE() возвращает SQL NULL, если выражение_пути возвращает JSON null, в отличие от функции JSON_QUERY(), возвращающей JSON null как есть.

9.16.4. JSON_TABLE #

JSON_TABLE — это функция SQL/JSON, которая обрабатывает данные JSON и выдаёт результаты в виде реляционного представления, к которому можно обращаться как к обычной таблице SQL. Использовать JSON_TABLE можно внутри предложения FROM оператора SELECT, UPDATE или DELETE и как источник данных в операторе MERGE.

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

Чтобы разбить шаблон строк на столбцы, в функции JSON_TABLE применяется предложение COLUMNS, определяющее схему создаваемого представления. В этом предложении для каждого создаваемого столбца задаётся отдельное выражение пути, обрабатывающее шаблон строк, извлекающее элемент JSON и возвращающее его в виде отдельного значения SQL для данного столбца.

Данные JSON, хранящиеся на вложенном уровне шаблона строк, можно извлечь с помощью предложения NESTED PATH. Каждое предложение NESTED PATH можно использовать для генерации одного или нескольких столбцов с использованием данных из вложенного уровня шаблона строк. Эти столбцы можно указать в предложении COLUMNS, которое аналогично предложению COLUMNS верхнего уровня. Строки, сгенерированные из NESTED COLUMNS, называются дочерними строками и объединяются со строкой, созданной из столбцов, которые указаны в родительском предложении COLUMNS, чтобы получить строку в конечном представлении. Сами дочерние столбцы могут содержать спецификацию NESTED PATH, что позволяет извлекать данные, расположенные на произвольных уровнях вложенности. Столбцы, созданные несколькими NESTED PATH на одном уровне, считаются соседними, а их строки после соединения с родительской строкой объединяются с помощью UNION.

Строки, формируемые функцией JSON_TABLE, соединяются как последующие (LATERAL) со строкой, из которой они сформированы, поэтому нет необходимости явно соединять создаваемое представление с исходной таблицей, содержащей данные JSON.

Синтаксис:

JSON_TABLE (
    элемент_контекста, выражение_пути [AS имя_пути_json] [PASSING { значение AS имя_переменной } [, ...]]
    COLUMNS ( столбец_таблицы_json [, ...] )
    [{ ERROR | EMPTY [ARRAY]} ON ERROR]
)

Здесь столбец_таблицы_json:
  имя FOR ORDINALITY
  | имя тип
        [FORMAT JSON [ENCODING UTF8]]
        [PATH выражение_пути]
        [{ 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]
  | имя тип EXISTS [PATH выражение_пути]
        [{ ERROR | TRUE | FALSE | UNKNOWN } ON ERROR]
  | NESTED [PATH] выражение_пути [AS имя_пути_json] COLUMNS ( столбец_таблицы_json [, ...] )

Каждый элемент синтаксиса описан ниже более подробно.

элемент_контекста, выражение_пути [AS имя_пути_json] [PASSING { значение AS имя_переменной } [, ...]]

Выражение элемент_контекста указывает входной документ для запроса, выражение_пути — это выражение пути SQL/JSON, определяющее запрос, а имя_пути_json — необязательное имя для выражения_пути. Необязательное предложение PASSING может предоставлять значения данных для переменных, указанных в выражении_пути. Результат обработки входных данных с использованием вышеупомянутых элементов называется шаблоном строк, который используется в качестве источника для значений строк в создаваемом представлении.

COLUMNS ( столбец_таблицы_json [, ...] )

Предложение COLUMNS, определяющее схему сконструированного представления. В этом предложении можно указать, что каждый столбец должен быть заполнен значением SQL/JSON, полученным путём применения выражения пути JSON к шаблону строк. Есть следующие варианты столбца_таблицы_json:

имя FOR ORDINALITY

Добавляет столбец нумерации, который обеспечивает последовательную нумерацию строк, начиная с 1. Каждое выражение NESTED PATH (см. ниже) получает собственный счётчик для любых вложенных столбцов нумерации.

имя тип [FORMAT JSON [ENCODING UTF8]] [ PATH выражение_пути ]

Вставляет значение SQL/JSON, полученное путём применения выражения_пути к шаблону строк, в выходную строку представления после приведения его к указанному типу.

FORMAT JSON явно указывает, что ожидается допустимый объект json. Указывать FORMAT JSON имеет смысл только в том случае, если тип — это bpchar, bytea, character variationing, name, json, jsonb или text или домен над этими типами.

Чтобы форматировать вывод, также можно указать предложения WRAPPER и QUOTES. Обратите внимание, что указание OMIT QUOTES переопределяет FORMAT JSON, поскольку не заключённые в кавычки литералы не являются допустимыми значениями json.

Также можно использовать предложения ON EMPTY и ON ERROR, чтобы выдавалась ошибка или возвращалось указанное значение при пустом результате вычисления пути JSON и при возникновении ошибки во время вычисления пути JSON или приведения значения SQL/JSON к указанному типу соответственно. По умолчанию для обоих случаев возвращается значение NULL.

Примечание

Это предложение внутри преобразуется в JSON_VALUE или JSON_QUERY с соответствующей семантикой. Предложение преобразуется в JSON_QUERY, если указанный тип не является скалярным типом или присутствует одно из следующих предложений: FORMAT JSON, WRAPPER или QUOTES.

имя тип EXISTS [ PATH выражение_пути ]

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

Значение показывает, будут ли получены какие-либо значения в результате применения выражения PATH к шаблону строк.

Указанный тип должен иметь приведение к типу boolean.

Также можно использовать предложение ON ERROR, чтобы выдавалась ошибка или возвращалось указанное значение при возникновении ошибки во время вычисления пути JSON или приведения значения SQL/JSON к указанному типу. По умолчанию в обоих случаях возвращается значение NULL.

Примечание

Это предложение внутри преобразуется в JSON_EXISTS с соответствующей семантикой.

NESTED [ PATH ] выражение_пути [AS имя_пути_json] COLUMNS ( столбец_таблицы_json [, ...] )

Извлекает значения SQL/JSON из вложенных уровней шаблона строк, создаёт один или несколько столбцов, как определено во вложенном предложении COLUMNS, и вставляет извлечённые значения SQL/JSON в эти столбцы. Выражение столбец_таблицы_json во вложенном предложении COLUMNS имеет тот же синтаксис, что и в родительском предложении COLUMNS.

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

Примечание

Во всех вариантах столбца_таблицы_json, описанных выше, если не указано предложение PATH, используется выражение пути $.имя, где имя — указанное имя столбца.

AS имя_пути_json

Необязательный параметр имя_пути_json служит идентификатором заданного выражения_пути. Имя пути должно быть уникальным и отличаться от имён столбцов.

{ ERROR | EMPTY } ON ERROR

Необязательное предложение ON ERROR можно использовать для указания способа обработки ошибок при вычислении выражения_пути верхнего уровня. Используйте предложение ERROR, чтобы выдавались ошибки, и EMPTY, чтобы возвращалась пустая таблица (то есть таблица, содержащая 0 строк). Обратите внимание, что это предложение не влияет на ошибки, возникающие при вычислении столбцов, поведение которых зависит от указания для них предложения ON ERROR.

Примеры

В приведённых примерах будет использоваться следующая таблица, содержащая данные JSON: 

CREATE TABLE my_films ( js jsonb );

INSERT INTO my_films VALUES (
'{ "favorites" : [
   { "kind" : "comedy", "films" : [
     { "title" : "Bananas",
       "director" : "Woody Allen"},
     { "title" : "The Dinner Game",
       "director" : "Francis Veber" } ] },
   { "kind" : "horror", "films" : [
     { "title" : "Psycho",
       "director" : "Alfred Hitchcock" } ] },
   { "kind" : "thriller", "films" : [
     { "title" : "Vertigo",
       "director" : "Alfred Hitchcock" } ] },
   { "kind" : "drama", "films" : [
     { "title" : "Yojimbo",
       "director" : "Akira Kurosawa" } ] }
  ] }');

В следующем запросе показано, как использовать функцию JSON_TABLE для преобразования объектов JSON-таблицы my_films в представление, содержащее столбцы для ключей kind, title и director в исходных данных JSON, а также столбец нумерации: 

SELECT jt.* FROM
 my_films,
 JSON_TABLE (js, '$.favorites[*]' COLUMNS (
   id FOR ORDINALITY,
   kind text PATH '$.kind',
   title text PATH '$.films[*].title' WITH WRAPPER,
   director text PATH '$.films[*].director' WITH WRAPPER)) AS jt;

 id |   kind   |             title              |             director
----+----------+--------------------------------+----------------------------------
  1 | comedy   | ["Bananas", "The Dinner Game"] | ["Woody Allen", "Francis Veber"]
  2 | horror   | ["Psycho"]                     | ["Alfred Hitchcock"]
  3 | thriller | ["Vertigo"]                    | ["Alfred Hitchcock"]
  4 | drama    | ["Yojimbo"]                    | ["Akira Kurosawa"]
(4 rows)

Ниже представлена изменённая версия запроса с использованием аргументов PASSING в фильтре, указанном в выражении пути JSON верхнего уровня, и различными параметрами для отдельных столбцов: 

SELECT jt.* FROM
 my_films,
 JSON_TABLE (js, '$.favorites[*] ? (@.films[*].director == $filter)'
   PASSING 'Alfred Hitchcock' AS filter
     COLUMNS (
     id FOR ORDINALITY,
     kind text PATH '$.kind',
     title text FORMAT JSON PATH '$.films[*].title' OMIT QUOTES,
     director text PATH '$.films[*].director' KEEP QUOTES)) AS jt;

id | kind | title | director
----+----------+---------+--------------------
1 | horror | Psycho | "Alfred Hitchcock"
2 | thriller | Vertigo | "Alfred Hitchcock"
(2 строки)

Ниже представлена изменённая версия запроса с использованием NESTED PATH для заполнения столбцов title и director, демонстрирующая их соединение с родительскими столбцами id и kind: 

SELECT jt.* FROM
 my_films,
 JSON_TABLE ( js, '$.favorites[*] ? (@.films[*].director == $filter)'
   PASSING 'Alfred Hitchcock' AS filter
   COLUMNS (
    id FOR ORDINALITY,
    kind text PATH '$.kind',
    NESTED PATH '$.films[*]' COLUMNS (
      title text FORMAT JSON PATH '$.title' OMIT QUOTES,
      director text PATH '$.director' KEEP QUOTES))) AS jt;

 id |   kind   |  title  |      director
----+----------+---------+--------------------
  1 | horror   | Psycho  | "Alfred Hitchcock"
  2 | thriller | Vertigo | "Alfred Hitchcock"
(2 rows)

Ниже представлен тот же запрос, но без фильтра в корневом пути: 

SELECT jt.* FROM
 my_films,
 JSON_TABLE ( js, '$.favorites[*]'
   COLUMNS (
    id FOR ORDINALITY,
    kind text PATH '$.kind',
    NESTED PATH '$.films[*]' COLUMNS (
      title text FORMAT JSON PATH '$.title' OMIT QUOTES,
      director text PATH '$.director' KEEP QUOTES))) AS jt;

 id |   kind   |      title      |      director
----+----------+-----------------+--------------------
  1 | comedy   | Bananas         | "Woody Allen"
  1 | comedy   | The Dinner Game | "Francis Veber"
  2 | horror   | Psycho          | "Alfred Hitchcock"
  3 | thriller | Vertigo         | "Alfred Hitchcock"
  4 | drama    | Yojimbo         | "Akira Kurosawa"
(5 rows)

Ниже представлен ещё один запрос, использующий в качестве входных данных другой объект JSON. В нём показано объединение «соседей» между путями NESTED $.movies[*] и $.books[*], а также использование столбца FOR ORDINALITY на уровнях NESTED (столбцы movie_id, book_id и author_id): 

SELECT * FROM JSON_TABLE (
'{"favorites":
    [{"movies":
      [{"name": "One", "director": "John Doe"},
       {"name": "Two", "director": "Don Joe"}],
     "books":
      [{"name": "Mystery", "authors": [{"name": "Brown Dan"}]},
       {"name": "Wonder", "authors": [{"name": "Jun Murakami"}, {"name":"Craig Doe"}]}]
}]}'::json, '$.favorites[*]'
COLUMNS (
  user_id FOR ORDINALITY,
  NESTED '$.movies[*]'
    COLUMNS (
    movie_id FOR ORDINALITY,
    mname text PATH '$.name',
    director text),
  NESTED '$.books[*]'
    COLUMNS (
      book_id FOR ORDINALITY,
      bname text PATH '$.name',
      NESTED '$.authors[*]'
        COLUMNS (
          author_id FOR ORDINALITY,
          author_name text PATH '$.name'))));

 user_id | movie_id | mname | director | book_id |  bname  | author_id | author_name
---------+----------+-------+----------+---------+---------+-----------+--------------
       1 |        1 | One   | John Doe |         |         |           |
       1 |        2 | Two   | Don Joe  |         |         |           |
       1 |          |       |          |       1 | Mystery |         1 | Brown Dan
       1 |          |       |          |       2 | Wonder  |         1 | Jun Murakami
       1 |          |       |          |       2 | Wonder  |         2 | Craig Doe
(5 rows)

Пред. Наверх След.
9.15. XML-функции Начало 9.17. Функции для работы с последовательностями

Чтобы сделать работу с сайтом удобнее, мы используем cookie и аналитический сервис «Яндекс.Метрика». Продолжая пользоваться сайтом, вы соглашаетесь с их использованием.