json -> integer → json

jsonb -> integer → jsonb

Extrai o n-ésimo elemento da matriz JSON (os elementos da matriz são indexados a partir de zero, mas os números inteiros negativos contam a partir do final).

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

Extrai o campo do objeto JSON com a chave fornecida.

'{"a": {"b":"foo"}}'::json -> 'a' → {"b":"foo"}

json ->> integer → text

jsonb ->> integer → text

Extrai o n-ésimo elemento da matriz JSON, como o tipo de dados text.

'[1,2,3]'::json ->> 2 → 3

json ->> text → text

jsonb ->> text → text

Extrai o campo do objeto JSON com a chave fornecida, como o tipo de dados text.

'{"a":1,"b":2}'::json ->> 'b' → 2

json #> text[] → json

jsonb #> text[] → jsonb

Extrai o subobjeto JSON no caminho especificado, onde os elementos do caminho podem ser chaves de campo ou índices de matriz.

'{"a": {"b": ["foo","bar"]}}'::json #> '{a,b,1}' → "bar"

json #>> text[] → text

jsonb #>> text[] → text

Extrai o subobjeto JSON no caminho especificado, como o tipo de dados text.

'{"a": {"b": ["foo","bar"]}}'::json #>> '{a,b,1}' → bar

jsonb @> jsonb → boolean

O primeiro valor JSON contém o segundo? (Veja a Seção 8.14.3 para obter detalhes sobre contém/está contido.)

'{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb → t

jsonb <@ jsonb → boolean

O primeiro valor JSON está contido no segundo?

'{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb → t

jsonb ? text → boolean

A cadeia de caracteres de texto existe como uma chave de nível superior, ou elemento de matriz, no valor JSON?

'{"a":1, "b":2}'::jsonb ? 'b' → t

'["a", "b", "c"]'::jsonb ? 'b' → t

jsonb ?| text[] → boolean

Alguma das cadeias de caracteres da matriz de texto existe como chave de nível superior ou como elemento da matriz?

'{"a":1, "b":2, "c":3}'::jsonb ?| array['b', 'd'] → t

jsonb ?& text[] → boolean

Todas as cadeias de caracteres da matriz de texto existem como chaves de nível superior ou como elementos da matriz?

'["a", "b", "c"]'::jsonb ?& array['a', 'b'] → t

jsonb || jsonb → jsonb

Concatena dois valores do tipo de dados jsonb. A concatenação de duas matrizes gera uma matriz contendo todos os elementos de cada entrada. A concatenação de dois objetos gera um objeto contendo a união de suas chaves, tomando o valor do segundo objeto quando houver chaves duplicadas. Todos os outros casos são tratados convertendo uma entrada não matriz em uma matriz de elemento único e, em seguida, procedendo como para duas matrizes. Não opera recursivamente: apenas a matriz de nível superior ou a estrutura do objeto é mesclada.

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

Para anexar uma matriz a outra matriz como uma única entrada, envolva-a em uma camada adicional de matriz, por exemplo:

'[1, 2]'::jsonb || jsonb_build_array('[3, 4]'::jsonb) → [1, 2, [3, 4]]

jsonb - text → jsonb

Exclui uma chave (e seu valor) de um objeto JSON, ou valores cadeia de caracteres que correspondem de uma matriz JSON.

'{"a": "b", "c": "d"}'::jsonb - 'a' → {"c": "d"}

'["a", "b", "c", "b"]'::jsonb - 'b' → ["a", "c"]

jsonb - text[] → jsonb

Exclui do operando esquerdo todas as chaves ou elementos de matriz que correspondem.

'{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[] → {}

jsonb - integer → jsonb

Exclui o elemento da matriz com o índice especificado (inteiros negativos contam a partir do final). Gera um erro se o valor JSON não for uma matriz.

'["a", "b"]'::jsonb - 1 → ["a"]

jsonb #- text[] → jsonb

Exclui o campo, ou elemento de matriz, no caminho especificado, onde os elementos de caminho podem ser chaves de campo ou índices de matriz.

'["a", {"b":1}]'::jsonb #- '{1,b}' → ["a", {}]

jsonb @? jsonpath → boolean

O caminho JSON retorna algum item para o valor JSON especificado? (É útil apenas com expressões de caminho JSON padrão SQL, mas não para expressões de verificação de predicado, já que estas sempre retornam um valor.)

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

jsonb @@ jsonpath → boolean

Retorna o resultado de uma verificação de predicado de caminho JSON para o valor JSON especificado. (É útil apenas para expressões de verificação de predicado, mas não para expressões de caminho JSON padrão SQL, porque retornará NULL se o resultado do caminho não for um único valor booleano.)

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

to_json ( anyelement ) → json

to_jsonb ( anyelement ) → jsonb

Converte qualquer valor SQL para os tipos de dados json ou jsonb. As matrizes e valores compostos são convertidos recursivamente em matrizes e objetos (matrizes multidimensionais se tornam matrizes de matrizes em JSON). Senão, se houver uma conversão do tipo de dados SQL para o tipo de dados json, a função de conversão será usada para realizar a conversão ^[a]; caso contrário, será produzido um valor JSON escalar. Para qualquer escalar que não seja um número, um valor booleano ou nulo, a representação de texto será usada, com escape conforme necessário para torná-lo um valor cadeia de caracteres JSON válido.

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

Converte uma matriz SQL em uma matriz JSON. O comportamento é o mesmo da função to_json, exceto por serem adicionadas alimentações de linha (LF) entre os elementos da matriz de nível superior, se o parâmetro booleano opcional for verdade (true).

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

json_array ( [ { value_expression [ FORMAT JSON ] } [, ...] ] [ { NULL | ABSENT } ON NULL ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

json_array ( [ query_expression ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

Constrói uma matriz JSON a partir de uma série de parâmetros value_expression ou a partir dos resultados de query_expression, que deve ser uma consulta SELECT retornando uma única coluna. Se for especificado ABSENT ON NULL, os valores NULL serão ignorados. Isto sempre ocorre quando é usada uma query_expression.

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

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

row_to_json ( record [, boolean ] ) → json

Converte um valor composto SQL em um objeto JSON. O comportamento é o mesmo da função to_json, exceto por serem adicionadas alimentações de linha (LF) entre os elementos de nível superior, se o parâmetro booleano opcional for verdade (true).

row_to_json(row(1,'foo')) → {"f1":1,"f2":"foo"}

json_build_array ( VARIADIC "any" ) → json

jsonb_build_array ( VARIADIC "any" ) → jsonb

Cria uma matriz JSON, com tipos de dados potencialmente heterogêneos, a partir de uma lista de argumentos de comprimento variável. Cada argumento é convertido segundo to_json ou to_jsonb. Cada argumento é convertido pela função to_json ou 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

Cria um objeto JSON a partir de uma lista de argumentos de comprimento variável. Por convenção, a lista de argumentos consiste em chaves e valores alternados. Os argumentos chave são convertidos em texto; os argumentos valor são convertidos pelas funções to_json ou to_jsonb.

json_build_object('foo', 1, 2, row(3,'bar')) → {"foo" : 1, "2" : {"f1":3,"f2":"bar"}}

json_object ( [ { key_expression { VALUE | ':' } value_expression [ FORMAT JSON [ ENCODING UTF8 ] ] }[, ...] ] [ { NULL | ABSENT } ON NULL ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

Constrói um objeto JSON com todos os pares chave/valor fornecidos, ou um objeto vazio caso não seja fornecido nenhum par. key_expression é uma expressão escalar que define a chave JSON, que é convertida para o tipo de dados text. Não pode ser NULL nem pode pertencer a um tipo de dados que tenha conversão para o tipo de dados json. Se for especificado WITH UNIQUE KEYS, não poderá haver nenhuma chave key_expression duplicada. Qualquer par para o qual value_expression seja avaliado como NULL será omitido da saída se for especificado ABSENT ON NULL; se for especificado NULL ON NULL ou a cláusula for omitida, a chave será incluída com o valor NULL.

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

json_object ( text[] ) → json

jsonb_object ( text[] ) → jsonb

Cria um objeto JSON a partir de uma matriz de texto. A matriz deve ter exatamente uma dimensão com um número par de elementos, que neste caso são considerados como pares de chave e valor alternados, ou deve ter duas dimensões, de modo que cada matriz interna tenha exatamente dois elementos, considerados como um par chave e valor. Todos os valores são convertidos em cadeias de caracteres 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

Esta forma da função json_object recebe chaves e valores em pares de matrizes de texto separadas. Fora isto, é idêntica à forma de um argumento.

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

json ( expression [ FORMAT JSON [ ENCODING UTF8 ]] [ { WITH | WITHOUT } UNIQUE [ KEYS ]] ) → json

Converte a expressão fornecida, especificada como text ou cadeia bytea (em codificação UTF-8), em um valor JSON. Se expression for NULL, será retornado um valor SQL nulo. Se for especificado WITH UNIQUE, a expression não deverá conter chaves de objeto duplicadas.

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

json_scalar ( expression )

Converte um valor escalar SQL fornecido em um valor escalar JSON. Se a entrada for NULL, será retornado um valor SQL nulo. Se a entrada for um número ou um valor booleano, será retornado um número ou valor booleano correspondente no formato JSON. Para qualquer outro valor, será retornada uma cadeia de caracteres JSON.

json_scalar(123.45) → 123.45

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

json_serialize ( expression [ FORMAT JSON [ ENCODING UTF8 ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ] )

Converte uma expressão SQL/JSON em uma cadeia de caracteres ou binária. A expression pode ser de qualquer tipo de dados JSON, ou de qualquer tipo de dados de cadeia de caracteres, ou do tipo de dados bytea na codificação UTF8. O tipo de dados retornado usado em RETURNING pode ser qualquer tipo de dados de cadeia de caracteres ou tipo de dados bytea. O padrão é o tipo de dados text.

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

expression IS [ NOT ] JSON [ { VALUE | SCALAR | ARRAY | OBJECT } ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ]

Este predicado testa se a expressão em expression pode ser analisada como JSON, possivelmente de um tipo de dados especificado. Se for especificado SCALAR ou ARRAY ou OBJECT, o teste consistirá em verificar se JSON é ou não deste tipo de dados específico. Se for especificado WITH UNIQUE KEYS, então qualquer objeto na expressão expression também será testado para verificar se possui chaves duplicadas.

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
(5 linhas)

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

         js          | object? | array? | array w. UK? | array w/o UK?
---------------------+---------+--------+--------------+---------------
 [{"a":"1"},        +| f       | t      | f            | t
  {"b":"2","b":"3"}] |         |        |              |
(1 linha)

json_array_elements ( json ) → setof json

jsonb_array_elements ( jsonb ) → setof jsonb

Expande a matriz JSON de nível superior em um conjunto de valores 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

Expande a matriz JSON de nível superior em um conjunto de valores do tipo de dados text.

SELECT * FROM json_array_elements_text('["foo", "bar"]') →

   value
-----------
 foo
 bar

json_array_length ( json ) → integer

jsonb_array_length ( jsonb ) → integer

Retorna o número de elementos na matriz JSON de nível superior.

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 )

Expande o objeto JSON de nível superior em um conjunto de pares de chave/valor.

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 )

Expande o objeto JSON de nível superior em um conjunto de pares de chave/valor. O value retornado será do tipo de dados 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

Extrai o subobjeto JSON no caminho especificado. (É funcionalmente equivalente ao operador #>, mas escrever o caminho como uma lista de comprimento variável pode ser mais conveniente em alguns casos.)

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

Extrai o subobjeto JSON no caminho especificado como o tipo de dados text. (É funcionalmente equivalente ao operador #>>.)

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

Retorna o conjunto de chaves no objeto JSON de nível superior.

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

Expande o objeto JSON de nível superior para uma linha tendo o tipo de dados composto do argumento base. O objeto JSON é verificado em busca de campos cujos nomes correspondem aos nomes das colunas do tipo de linha de saída e seus valores são inseridos nessas colunas da saída. (Os campos que não correspondem a nenhum nome de coluna de saída são ignorados.) No uso típico, o valor para base é apenas NULL, significando que qualquer coluna de saída, que não corresponda a nenhum campo do objeto, será preenchida com nulos. No entanto, se base não for NULL, os valores que contém serão usados para as colunas sem correspondência.

Para converter um valor JSON para o tipo de dados SQL de uma coluna de saída, são aplicadas as seguintes regras em sequência:

Embora o exemplo abaixo use uma constante para o valor JSON, o uso típico seria fazer uma referência lateral a uma coluna do tipo de dados json ou jsonb de outra tabela na cláusula FROM da consulta. Escrever json_populate_record na cláusula FROM é uma boa prática, porque todas as colunas extraídas ficam disponíveis para uso sem chamadas de função repetidas.

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

Função para testar jsonb_populate_record. Retorna true se a entrada jsonb_populate_record terminaria sem erros para o objeto JSON de entrada fornecido; ou seja, é uma entrada válida, caso contrário retorna 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 linha)

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

ERROR:  value too long for type character(2)

SELECT jsonb_populate_record_valid(NULL::jsb_char2, '{"a": "aa"}'); →

 jsonb_populate_record_valid
-----------------------------
 t
(1 linha)

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

 a
----
 aa
(1 linha)

json_populate_recordset ( base anyelement, from_json json ) → setof anyelement

jsonb_populate_recordset ( base anyelement, from_json jsonb ) → setof anyelement

Expande a matriz de objetos JSON de nível superior para um conjunto de linhas com o tipo de dados composto do argumento base. Cada elemento da matriz JSON é processado conforme descrito acima na função 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

Expande o objeto JSON de nível superior para uma linha com o tipo de dados composto definido por uma cláusula AS. (Assim como todas as funções que retornam o tipo de dados record, a consulta que chama deve definir explicitamente a estrutura do registro com uma cláusula AS.) O registro de saída é preenchido a partir de campos do objeto JSON, da mesma forma descrita acima para json[b]_populate_record. Como não há valor de registro de entrada, as colunas sem correspondência são sempre preenchidas com valores nulos.

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

Expande a matriz de objetos JSON de nível superior para um conjunto de linhas com o tipo de dados composto definido por uma cláusula AS. (Assim como todas as funções que retornam o tipo de dados record, a consulta que chama deve definir explicitamente a estrutura do registro com uma cláusula AS.) Cada elemento da matriz JSON é processado conforme descrito acima para 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 |
(2 linhas)

jsonb_set ( target jsonb, path text[], new_value jsonb [, create_if_missing boolean ] ) → jsonb

Retorna o target (alvo) com o item designado pelo path (caminho) substituído pelo new_value (novo valor), ou com o new_value adicionado se create_if_missing (criar se estiver faltando) for verdade (true) (que é o padrão) e o item designado pelo path não existir. Todas as etapas anteriores no caminho devem existir, ou o target será retornado inalterado. Assim como os operadores orientados por caminho, os inteiros negativos que aparecem no path contam a partir do final das matrizes JSON. Se o último passo do caminho for um índice de matriz que está fora do intervalo, e create_if_missing for verdade, o novo valor ser´ adicionado no início da matriz se o índice for negativo, ou no final da matriz se for positivo.

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

Se new_value não for NULL, se comporta de forma idêntica a jsonb_set. Senão se comporta segundo o valor de null_value_treatment (tratamento de valor nulo), que deve ser um entre 'raise_exception', 'use_json_null', 'delete_key', ou 'return_target'. O padrão é '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

Retorna target com o new_value inserido. Se o item designado pelo path for um elemento de matriz, o new_value será inserido antes desse item se insert_after (inserir após) for falso (que é o padrão), ou depois se insert_after for verdade. Se o item designado pelo path for um campo do objeto, o new_value será inserido somente se o objeto ainda não contiver esta chave. Todas as etapas anteriores no caminho devem existir, ou o target será retornado inalterado. Assim como os operadores orientados por caminho, os inteiros negativos que aparecem no path contam a partir do final das matrizes JSON. Se a última etapa do caminho for um índice de matriz fora do intervalo, o novo valor será adicionado no início da matriz se o índice for negativo ou no final da matriz se for positivo.

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

Remove todos os campos do objeto com valor nulo do valor JSON fornecido, recursivamente. Se strip_in_arrays for verdade (o valor padrão é falso), os elementos nulos da matriz também são removidos. Caso contrário, eles não são removidos. Valores nulos puros nunca são removidos.

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

Verifica se o caminho JSON retorna algum item para o valor JSON especificado. (É útil apenas com expressões de caminho JSON padrão SQL, mas não para expressões de verificação de predicado, já que estas sempre retornam um valor.) Se for especificado o argumento vars, este deverá ser um objeto JSON, e seus campos fornecerem valores com nomes a serem substituídos na expressão jsonpath . Se for especificado o argumento silent e for true, esta função irá suprimir os mesmos erros que os operadores @? e @@ suprimem.

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

Retorna o resultado booleano SQL de uma verificação de predicado de caminho JSON para o valor JSON especificado. (É útil apenas para expressões de verificação de predicado, mas não para expressões de caminho JSON padrão SQL, uma vez que irá falhar ou retornar NULL se o resultado do caminho não for um único valor booleano.) Os argumentos opcionais vars e silent atuam da mesma maneira que na função 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

Retorna todos os itens JSON retornados pelo caminho JSON para o valor JSON especificado. Para expressões de caminho JSON padrão SQL, retorna os valores JSON selecionados de target. Para expressões de verificação de predicado retorna o resultado da verificação do predicado: true, false ou null. Os argumentos opcionais vars e silent atuam da mesma maneira que na função 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

Retorna todos os itens JSON retornados pelo caminho JSON para o valor JSON especificado, como uma matriz JSON. Os parâmetros são os mesmos que para a função 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

Retorna o primeiro item JSON retornado pelo caminho JSON para o valor JSON especificado, ou NULL se não houver resultados. Os parâmetros são os mesmos que para a função 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

Estas funções agem como suas contrapartes descritas acima sem o sufixo _tz, exceto por estas funções darem suporte a comparações de valores de data/hora que exigem conversões com reconhecimento de zona horária. O exemplo abaixo requer a interpretação do valor de apenas a data 2015-08-02 como um carimbo de data e hora com zona horária, portanto o resultado depende da configuração corrente de TimeZone. Devido a esta dependência, estas funções são marcadas como estáveis, significando que estas funções não podem ser usadas em índices. Suas contrapartes são imutáveis, portanto podem ser usadas em índices; mas geram erros se solicitadas a fazer tais comparações.

jsonb_path_exists_tz('["2015-08-01 12:00:00-05"]', '$[*] ? (@.datetime() < "2015-08-02".datetime())') → t

jsonb_pretty ( jsonb ) → text

Converte o valor JSON fornecido em texto indentado e com impressão estruturada (pretty-printed).

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

[
    {
        "f1": 1,
        "f2": null
    },
    2
]

json_typeof ( json ) → text

jsonb_typeof ( jsonb ) → text

Retorna o tipo de dados do valor JSON de nível superior como uma cadeia de caracteres de texto. Os tipos de dados possíveis são: object, array, string, number, boolean e null. (O resultado null não deve ser confundido com o NULL do SQL; veja os exemplos.)

json_typeof('-123.4') → number

json_typeof('null'::json) → null

json_typeof(NULL::json) IS NULL → t

JSON_EXISTS (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[{ TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ]) → boolean

Exemplos:

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

ERRO:  O índice da matriz jsonpath está fora dos limites

JSON_QUERY (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ]
[ { WITHOUT | WITH { CONDITIONAL | [UNCONDITIONAL] } } [ ARRAY ] WRAPPER ]
[ { KEEP | OMIT } QUOTES [ ON SCALAR STRING ] ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT expression } ON EMPTY ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT expression } ON ERROR ]) → jsonb

Exemplos:

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

ERRO:  matriz mal formada: "[1, 2]"
DETALHE:  Faltando "]" após as dimensões da matriz.

JSON_VALUE (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[ RETURNING data_type ]
[ { ERROR | NULL | DEFAULT expression } ON EMPTY ]
[ { ERROR | NULL | DEFAULT expression } ON ERROR ]) → text

Exemplos:

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