Funções JSON - ClickHouse Documentation

Tipos de funções JSON

Há dois conjuntos de funções para analisar de JSON:

simpleJSON* (visitParam*), feito para fazer o analisar de um subconjunto limitado de JSON com extrema rapidez.
JSONExtract*, feito para fazer o analisar de JSON comum.

funções `simpleJSON` (visitParam)

O ClickHouse tem funções especiais para trabalhar com JSON simplificado. Todas essas funções JSON se baseiam em pressupostos rígidos sobre como o JSON pode ser. Elas procuram fazer o mínimo possível para executar a tarefa o mais rápido possível. Os seguintes pressupostos são adotados:

O nome do campo (argumento da função) deve ser uma constante.
O nome do campo deve estar codificado de forma canônica no JSON. Por exemplo: simpleJSONHas('{"abc":"def"}', 'abc') = 1, mas simpleJSONHas('{"\\u0061\\u0062\\u0063":"def"}', 'abc') = 0
Os campos são procurados em qualquer nível de aninhamento, sem distinção. Se houver vários campos correspondentes, a primeira ocorrência será usada.
O JSON não contém caracteres de espaço fora de literais de string.

Funções JSONExtract

Essas funções são baseadas em simdjson e foram projetadas para necessidades mais complexas de análise de JSON.

Funções JSONExtract sem distinção entre maiúsculas e minúsculas

Essas funções fazem correspondência de chaves em ASCII sem distinção entre maiúsculas e minúsculas ao extrair valores de objetos JSON. Elas funcionam de forma idêntica às equivalentes com distinção entre maiúsculas e minúsculas, exceto pelo fato de que as chaves do objeto são correspondidas sem considerar o uso de maiúsculas e minúsculas. Quando várias chaves correspondem com grafias diferentes entre maiúsculas e minúsculas, a primeira correspondência é retornada.

Essas funções podem ter desempenho inferior ao das equivalentes com distinção entre maiúsculas e minúsculas, portanto, use as funções JSONExtract regulares, se possível.

Sintaxe do JSONPath

As funções JSON_EXISTS, JSON_VALUE e JSON_QUERY aceitam uma expressão JSONPath como segundo argumento. O ClickHouse implementa um pequeno subconjunto do JSONPath, baseado de forma flexível no padrão SQL/JSON (ISO/IEC TR 19075-6), e deliberadamente mais limitado que a RFC 9535 e outras implementações populares. Os operadores compatíveis estão listados abaixo. A implementação de referência está em src/Functions/JSONPath/Parsers.

Operadores compatíveis

Sintaxe	Descrição	Exemplo
`$`	Elemento raiz. Todo caminho deve começar com ele.	`$`
`.key`	Acesso a membro por notação de ponto, sem aspas. A chave pode começar com números ou ser composta apenas por eles.	`$.store.book`, `$.1key`, `$.123`
`."key"`	Acesso a membro por notação de ponto, entre aspas. Use-o para chaves que contenham espaços ou caracteres especiais. São aceitas aspas duplas ou backticks.	`$."foo bar"`
`[key]`	Acesso a membro por notação de colchetes, sem aspas.	`$[hello]`
`['key']`	Acesso a membro por notação de colchetes, entre aspas. São aceitas aspas simples, aspas duplas ou backticks.	`$['foo bar']`
`[n]`	Acesso a elemento de Array por índice (baseado em 0).	`$.items[0]`
`[n, m, ...]`	Acesso a vários elementos de Array.	`$.items[0, 2, 4]`
`[n to m]`	Intervalo de elementos de Array. O índice final `m` é exclusivo.	`$.items[0 to 3]`
`[*]`	Wildcard que corresponde a todos os elementos de um Array.	`$.items[*]`

Observações:

Índices e intervalos podem ser combinados dentro do mesmo par de colchetes (por exemplo, [0 to 2, 4]).
Intervalos de índices e o wildcard não podem ser combinados dentro do mesmo par de colchetes (por exemplo, [* , 0] é inválido).
Em um intervalo [n to m], o início n deve ser estritamente menor que o final m; caso contrário, é gerada uma exceção.
Um índice isolado [n] é equivalente ao intervalo [n to n+1].

Operadores sem suporte

Os seguintes operadores JSONPath, disponíveis na RFC 9535 ou em outras implementações, não têm suporte no ClickHouse:

Sintaxe	Descrição
`..`	Descida recursiva.
`?(@.expr)`	Expressões de filtro.
`[start:end:step]`	Notação de fatia. Use `[n to m]` em vez disso.
`@`	Referência ao nó atual.
`[-n]`	Índices negativos de array (a partir do fim).
Expressões de script	Expressões aritméticas ou de função em um caminho.
`ON ERROR` / `ON EMPTY`	Cláusulas SQL/JSON padrão para controlar o comportamento em caso de erro ou valor vazio.

JSONAllPaths

Introduzido em: v24.8.0 Retorna a lista de todos os caminhos armazenados em cada linha de uma coluna JSON. Sintaxe

JSONAllPaths(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um array com todos os caminhos da coluna JSON. Array(String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONAllPaths(json) FROM test;

Response

┌─json───────────────────────────┬─JSONAllPaths(json)─┐
│ {"a":42}                       │ ['a']              │
│ {"b":"Hello"}                  │ ['b']              │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['a','c']          │
└────────────────────────────────┴────────────────────┘

JSONAllPathsWithTypes

Introduzido em: v24.8.0 Retorna a lista de todos os caminhos e seus tipos de dados armazenados em cada linha de uma coluna JSON. Sintaxe

JSONAllPathsWithTypes(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um map de todos os caminhos e seus tipos de dados na coluna JSON. Map(String, String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONAllPathsWithTypes(json) FROM test;

Response

┌─json───────────────────────────┬─JSONAllPathsWithTypes(json)───────────────┐
│ {"a":42}                       │ {'a':'Int64'}                             │
│ {"b":"Hello"}                  │ {'b':'String'}                            │
│ {"a":[1,2,3],"c":"2020-01-01"} │ {'a':'Array(Nullable(Int64))','c':'Date'} │
└────────────────────────────────┴───────────────────────────────────────────┘

JSONAllValues

Introduzido em: v26.4.0 Retorna todos os valores de cada linha em uma coluna JSON como um array de strings. Os valores são serializados em sua representação textual e ordenados pelos nomes dos caminhos. Sintaxe

JSONAllValues(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um array com todos os valores da coluna JSON como strings. Array(String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json": {"a": 42}}, {"json": {"b": "Hello"}}, {"json": {"a": [1, 2, 3], "c": "2020-01-01"}};
SELECT json, JSONAllValues(json) FROM test;

Response

┌─json───────────────────────────┬─JSONAllValues(json)──────┐
│ {"a":42}                       │ ['42']                   │
│ {"b":"Hello"}                  │ ['Hello']                │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['[1,2,3]','2020-01-01'] │
└────────────────────────────────┴──────────────────────────┘

JSONArrayLength

Introduzido em: v23.2.0 Retorna o número de elementos no array JSON mais externo. A função retorna NULL se a string JSON de entrada for inválida. Sintaxe

JSONArrayLength(json)

Aliases: JSON_ARRAY_LENGTH Argumentos

json — String com JSON válido. String

Valor retornado Retorna o número de elementos do array se json for uma string JSON que representa um array válido; caso contrário, retorna NULL. Nullable(UInt64) Exemplos Exemplo de uso

Query

SELECT
    JSONArrayLength(''),
    JSONArrayLength('[1,2,3]');

Response

┌─JSONArrayLength('')─┬─JSONArrayLength('[1,2,3]')─┐
│                ᴺᵁᴸᴸ │                          3 │
└─────────────────────┴────────────────────────────┘

JSONDynamicPaths

Introduzido em: v24.8.0 Retorna a lista de caminhos dinâmicos armazenados como subcolunas separadas em uma coluna JSON. Sintaxe

JSONDynamicPaths(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um array de caminhos dinâmicos da coluna JSON. Array(String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONDynamicPaths(json) FROM test;

Response

┌─json───────────────────────────┬─JSONDynamicPaths(json)─┐
│ {"a":42}                       │ ['a']                  │
│ {"b":"Hello"}                  │ []                     │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['a']                  │
└────────────────────────────────┴────────────────────────┘

JSONDynamicPathsWithTypes

Introduzido em: v24.8.0 Retorna a lista de caminhos dinâmicos armazenados como subcolunas separadas e seus tipos em cada linha da coluna JSON. Sintaxe

JSONDynamicPathsWithTypes(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um map dos caminhos dinâmicos e seus tipos de dados na coluna JSON. Map(String, String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONDynamicPathsWithTypes(json) FROM test;

Response

┌─json───────────────────────────┬─JSONDynamicPathsWithTypes(json)─┐
│ {"a":42}                       │ {'a':'Int64'}                   │
│ {"b":"Hello"}                  │ {}                              │
│ {"a":[1,2,3],"c":"2020-01-01"} │ {'a':'Array(Nullable(Int64))'}  │
└────────────────────────────────┴─────────────────────────────────┘

JSONExtract

Introduzido em: v19.14.0 Analisa JSON e extrai um valor do tipo de dado ClickHouse especificado. Sintaxe

JSONExtract(json[, indices_or_keys, ...], return_type)

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*
return_type — Tipo de dados do ClickHouse a ser retornado. String

Valor retornado Retorna um valor do tipo de dados do ClickHouse especificado, se possível; caso contrário, retorna o valor padrão desse tipo. Exemplos Exemplo de uso

Query

SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(String, Array(Float64))') AS res;

Response

┌─res──────────────────────┐
│ ('hello',[-100,200,300]) │
└──────────────────────────┘

JSONExtractArrayRaw

Introduzido em: v20.1.0 Retorna um array com os elementos de um array JSON, cada um representado como uma string não analisada. Sintaxe

JSONExtractArrayRaw(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um array de strings com os elementos do array JSON. Se a parte correspondente não for um array ou não existir, será retornado um array vazio. Array(String) Exemplos Exemplo de uso

Query

SELECT JSONExtractArrayRaw('{"a": "hello", "b": [-100, 200.0, "hello"]}', 'b') AS res;

Response

┌─res──────────────────────┐
│ ['-100','200','"hello"'] │
└──────────────────────────┘

JSONExtractArrayRawCaseInsensitive

Introduzido em: v25.8.0 Retorna um array com os elementos de um array JSON, cada um representado como uma string não analisada, usando correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtractArrayRaw. Sintaxe

JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar no array. As chaves não distinguem entre maiúsculas e minúsculas String ou (U)Int*

Valor retornado Retorna um array de strings JSON brutas. Array(String) Exemplos básico

Query

SELECT JSONExtractArrayRawCaseInsensitive('{"Items": [1, 2, 3]}', 'ITEMS')

Response

['1','2','3']

JSONExtractBool

Introduzido em: v20.1.0 Faz o analisar de JSON e extrai um valor do tipo Bool. Sintaxe

JSONExtractBool(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um valor Bool, se existir; caso contrário, retorna 0. Bool Exemplos Exemplo de uso

Query

SELECT JSONExtractBool('{"passed": true}', 'passed') AS res;

Response

┌─res─┐
│   1 │
└─────┘

JSONExtractBoolCaseInsensitive

Introduzido em: v25.8.0 Analisa JSON e extrai um valor booleano usando correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtractBool. Sintaxe

JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência sem diferenciar maiúsculas de minúsculas String ou (U)Int*

Valor retornado Retorna o valor booleano extraído (1 para true, 0 para false) ou 0, se não for encontrado. UInt8 Exemplos básico

Query

SELECT JSONExtractBoolCaseInsensitive('{"IsActive": true}', 'isactive')

Response

JSONExtractCaseInsensitive

Introduzido em: v25.8.0 Analisa JSON e extrai um valor do tipo de dado ClickHouse especificado usando correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtract. Sintaxe

JSONExtractCaseInsensitive(json [, indices_or_keys...], return_type)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência que não distingue entre maiúsculas e minúsculas String ou (U)Int*
return_type — O tipo de dado do ClickHouse a ser extraído String

Valor retornado Retorna o valor extraído no tipo de dado especificado. Any Exemplos int_type

Query

SELECT JSONExtractCaseInsensitive('{"Number": 123}', 'number', 'Int32')

Response

array_type

Query

SELECT JSONExtractCaseInsensitive('{"List": [1, 2, 3]}', 'list', 'Array(Int32)')

Response

[1,2,3]

JSONExtractFloat

Introduzido em: v20.1.0 Analisa o JSON e extrai um valor do tipo Float. Sintaxe

JSONExtractFloat(json[, indices_or_keys, ...])

Argumentos

json — Uma string JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um valor Float, se existir; caso contrário, retorna 0. Float64 Exemplos Exemplo de uso

Query

SELECT JSONExtractFloat('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 2) AS res;

Response

┌─res─┐
│ 200 │
└─────┘

JSONExtractFloatCaseInsensitive

Introduzido na versão: v25.8.0 Analisa JSON e extrai um valor do tipo Float usando correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtractFloat. Sintaxe

JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência sem distinção entre maiúsculas e minúsculas String ou (U)Int*

Valor retornado Retorna o valor Float extraído; 0 se não for encontrado ou se não puder ser convertido. Float64 Exemplos básico

Query

SELECT JSONExtractFloatCaseInsensitive('{"Price": 12.34}', 'PRICE')

Response

12.34

JSONExtractInt

Introduzido em: v20.1.0 Faz o analisaring de JSON e extrai um valor do tipo Int. Sintaxe

JSONExtractInt(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um valor Int, se existir; caso contrário, retorna 0. Int64 Exemplos Exemplo de uso

Query

SELECT JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) AS res;

Response

┌──res─┐
│ -100 │
└──────┘

JSONExtractIntCaseInsensitive

Introduzido em: v25.8.0 Faz o analisar de JSON e extrai um valor do tipo Int usando correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtractInt. Sintaxe

JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência que não distingue entre maiúsculas e minúsculas String ou (U)Int*

Valor retornado Retorna o valor Int extraído, 0 se não for encontrado ou não puder ser convertido. Int64 Exemplos básico

Query

SELECT JSONExtractIntCaseInsensitive('{"Value": 123}', 'value')

Response

aninhado

Query

SELECT JSONExtractIntCaseInsensitive('{"DATA": {"COUNT": 42}}', 'data', 'Count')

Response

JSONExtractKeys

Introduzido em: v21.11.0 Analisa uma string JSON e extrai as chaves. Sintaxe

JSONExtractKeys(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um array com as chaves do objeto JSON. Array(String) Exemplos Exemplo de uso

Query

SELECT JSONExtractKeys('{"a": "hello", "b": [-100, 200.0, 300]}') AS res;

Response

┌─res───────┐
│ ['a','b'] │
└───────────┘

JSONExtractKeysAndValues

Introduzido em: v20.1.0 Extrai pares chave-valor de um JSON em que os valores são do tipo de dado ClickHouse especificado. Sintaxe

JSONExtractKeysAndValues(json[, indices_or_keys, ...], value_type)

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*
value_type — Tipo de dado ClickHouse dos valores. String

Valor retornado Retorna um array de tuplas com os pares chave-valor extraídos. Array(Tuple(String, value_type)) Exemplos Exemplo de uso

Query

SELECT JSONExtractKeysAndValues('{"x": {"a": 5, "b": 7, "c": 11}}', 'x', 'Int8') AS res

Response

┌─res────────────────────────┐
│ [('a',5),('b',7),('c',11)] │
└────────────────────────────┘

JSONExtractKeysAndValuesCaseInsensitive

Introduzido em: v25.8.0 Analisa pares chave-valor de JSON com correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtractKeysAndValues. Sintaxe

JSONExtractKeysAndValuesCaseInsensitive(json [, indices_or_keys...], value_type)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o objeto. As chaves usam correspondência sem distinção entre maiúsculas e minúsculas String ou (U)Int*
value_type — O tipo de dado do ClickHouse para os valores String

Valor retornado Retorna um array de tuplas contendo pares chave-valor. Array(Tuple(String, T)) Exemplos básico

Query

SELECT JSONExtractKeysAndValuesCaseInsensitive('{"Name": "Alice", "AGE": 30}', 'String')

Response

[('Name','Alice'),('AGE','30')]

JSONExtractKeysAndValuesRaw

Introduzido em: v20.4.0 Retorna um array de tuplas com as chaves e os valores de um objeto JSON. Todos os valores são representados como strings não analisadas. Sintaxe

JSONExtractKeysAndValuesRaw(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um array de tuplas com pares chave-valor analisados, em que os valores são strings não analisadas. Array(Tuple(String, String)) Exemplos Exemplo de uso

Query

SELECT JSONExtractKeysAndValuesRaw('{"a": [-100, 200.0], "b": "hello"}') AS res;

Response

┌─res──────────────────────────────────┐
│ [('a','[-100,200]'),('b','"hello"')] │
└──────────────────────────────────────┘

JSONExtractKeysAndValuesRawCaseInsensitive

Introduzido em: v25.8.0 Extrai pares chave-valor brutos de JSON usando correspondência de chaves sem distinção entre maiúsculas e minúsculas. Esta função é semelhante a JSONExtractKeysAndValuesRaw. Sintaxe

JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser processada String
indices_or_keys — Opcional. Índices ou chaves para navegar no objeto. As chaves usam correspondência sem diferenciar maiúsculas de minúsculas String ou (U)Int*

Valor retornado Retorna um array de tuplas contendo pares chave-valor como strings em formato bruto. Array(Tuple(String, String)) Exemplos básico

Query

SELECT JSONExtractKeysAndValuesRawCaseInsensitive('{"Name": "Alice", "AGE": 30}')

Response

[('Name','"Alice"'),('AGE','30')]

JSONExtractKeysCaseInsensitive

Introduzido em: v25.8.0 Analisa uma string JSON e extrai as chaves usando correspondência de chaves sem distinção entre maiúsculas e minúsculas para navegar por objetos aninhados. Esta função é semelhante a JSONExtractKeys. Sintaxe

JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — string JSON a ser processada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o objeto. As chaves usam correspondência que não diferencia maiúsculas de minúsculas String ou (U)Int*

Valor retornado Retorna um array de chaves do objeto JSON. Array(String) Exemplos básico

Query

SELECT JSONExtractKeysCaseInsensitive('{"Name": "Alice", "AGE": 30}')

Response

['Name','AGE']

aninhado

Query

SELECT JSONExtractKeysCaseInsensitive('{"User": {"name": "John", "AGE": 25}}', 'user')

Response

['name','AGE']

JSONExtractRaw

Introduzido em: v20.1.0 Retorna uma parte do JSON como string bruta. Sintaxe

JSONExtractRaw(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna a parte do JSON como uma string bruta. Se a parte não existir ou tiver o tipo incorreto, retorna uma string vazia. String Exemplos Exemplo de uso

Query

SELECT JSONExtractRaw('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') AS res;

Response

┌─res────────────┐
│ [-100,200,300] │
└────────────────┘

JSONExtractRawCaseInsensitive

Introduzido em: v25.8.0 Retorna parte do JSON como uma string bruta usando correspondência de chaves sem diferenciar maiúsculas de minúsculas. Esta função é semelhante a JSONExtractRaw. Sintaxe

JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência sem diferenciar maiúsculas de minúsculas String ou (U)Int*

Valor retornado Retorna a string JSON bruta do elemento extraído. String Exemplos objeto

Query

SELECT JSONExtractRawCaseInsensitive('{"Object": {"key": "value"}}', 'OBJECT')

Response

{"key":"value"}

JSONExtractString

Introduzido em: v20.1.0 Analisa JSON e extrai um valor do tipo String. Sintaxe

JSONExtractString(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista de zero ou mais argumentos, cada um deles podendo ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um valor String, se existir; caso contrário, retorna uma string vazia. String Exemplos Exemplo de uso

Query

SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') AS res;

Response

┌─res───┐
│ hello │
└───────┘

JSONExtractStringCaseInsensitive

Introduzido em: v25.8.0 Analisa JSON e extrai uma string usando correspondência de chaves sem diferenciar letras maiúsculas de minúsculas. Esta função é semelhante a JSONExtractString. Sintaxe

JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência sem diferenciar maiúsculas de minúsculas String ou (U)Int*

Valor retornado Retorna o valor de string extraído ou uma string vazia, se não for encontrado. String Exemplos básico

Query

SELECT JSONExtractStringCaseInsensitive('{"ABC": "def"}', 'abc')

Response

def

aninhado

Query

SELECT JSONExtractStringCaseInsensitive('{"User": {"Name": "John"}}', 'user', 'name')

Response

John

JSONExtractUInt

Introduzido em: v20.1.0 Analisa JSON e extrai um valor do tipo UInt. Sintaxe

JSONExtractUInt(json [, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Uma lista com zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int*

Valor retornado Retorna um valor UInt, se existir; caso contrário, retorna 0. UInt64 Exemplos Exemplo de uso

Query

SELECT JSONExtractUInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', -1) AS res;

Response

┌─res─┐
│ 300 │
└─────┘

JSONExtractUIntCaseInsensitive

Introduzido em: v25.8.0 Faz o parse de JSON e extrai um valor do tipo UInt usando correspondência de chaves sem diferenciar maiúsculas de minúsculas. Esta função é semelhante a JSONExtractUInt. Sintaxe

JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)

Argumentos

json — String JSON a ser analisada String
indices_or_keys — Opcional. Índices ou chaves para navegar até o campo. As chaves usam correspondência sem diferenciar maiúsculas de minúsculas String ou (U)Int*

Valor retornado Retorna o valor UInt extraído, 0 se não for encontrado ou se não puder ser convertido. UInt64 Exemplos básico

Query

SELECT JSONExtractUIntCaseInsensitive('{"COUNT": 789}', 'count')

Response

JSONHas

Introduzido em: v20.1.0 Verifica se o(s) valor(es) fornecido(s) existe(m) no documento JSON. Sintaxe

JSONHas(json[ ,indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada String
[ ,indices_or_keys, ...] — Uma lista de zero ou mais argumentos. String ou (U)Int*

Valor retornado Retorna 1 se o valor existir em json; caso contrário, 0 UInt8 Exemplos Exemplo de uso

Query

SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 1;
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 4) = 0;

Response

1
1

JSONKey

Introduzido em: v20.1.0 Retorna a chave de um campo de um objeto JSON pelo índice (começando em 1). Se o JSON for fornecido como string, ele será analisado primeiro. O segundo argumento é um caminho JSON para navegar por objetos aninhados. A função retorna o nome da chave na posição especificada. Sintaxe

JSONKey(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada. String
indices_or_keys — Lista opcional de índices ou chaves que especifica um caminho para um elemento aninhado. Cada argumento pode ser uma string (acesso por chave) ou um inteiro (acesso por índice, começando em 1). String ou Int*

Valor retornado Retorna o nome da chave na posição especificada no objeto JSON. String Exemplos Exemplo de uso

Query

SELECT JSONKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1);

Response

JSONLength

Introduzido em: v20.1.0 Retorna o tamanho de um array JSON ou de um objeto JSON. Se o valor não existir ou tiver o tipo incorreto, 0 será retornado. Sintaxe

JSONLength(json [, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada String
[, indices_or_keys, ...] — Opcional. Uma lista de zero ou mais argumentos. String ou (U)Int8/16/32/64

Valor retornado Retorna o comprimento do array JSON ou do objeto JSON; caso contrário, retorna 0 se o valor não existir ou for do tipo incorreto. UInt64 Exemplos Exemplo de uso

Query

SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 3;
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}') = 2;

Response

1
1

JSONMergePatch

Introduzido em: v23.10.0 Retorna a string do objeto JSON resultante da mesclagem de vários objetos JSON. Sintaxe

JSONMergePatch(json1[, json2, ...])

Aliases: jsonMergePatch Argumentos

json1[, json2, ...] — Uma ou mais strings contendo JSON válido. String

Valor retornado Retorna a string do objeto JSON resultante da mesclagem, desde que as strings de objeto JSON sejam válidas. String Exemplos Exemplo de uso

Query

SELECT JSONMergePatch('{"a":1}', '{"name": "joey"}', '{"name": "tom"}', '{"name": "zoey"}') AS res;

Response

┌─res───────────────────┐
│ {"a":1,"name":"zoey"} │
└───────────────────────┘

JSONSharedDataPaths

Introduzido em: v24.8.0 Retorna a lista de caminhos armazenados na estrutura de dados compartilhada da coluna JSON. Sintaxe

JSONSharedDataPaths(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um array de caminhos armazenados na estrutura de dados compartilhada da coluna JSON. Array(String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONSharedDataPaths(json) FROM test;

Response

┌─json───────────────────────────┬─JSONSharedDataPaths(json)─┐
│ {"a":42}                       │ []                        │
│ {"b":"Hello"}                  │ ['b']                     │
│ {"a":[1,2,3],"c":"2020-01-01"} │ ['c']                     │
└────────────────────────────────┴───────────────────────────┘

JSONSharedDataPathsWithTypes

Introduzido na versão: v24.8.0 Retorna a lista de caminho armazenados na estrutura de dados compartilhada e seus tipos em cada linha da coluna JSON. Sintaxe

JSONSharedDataPathsWithTypes(json)

Argumentos

json — coluna JSON. JSON

Valor retornado Retorna um map dos caminhos armazenados na estrutura de dados compartilhada e de seus tipos de dados na coluna JSON. Map(String, String) Exemplos Exemplo de uso

Query

CREATE TABLE test (json JSON(max_dynamic_paths=1)) ENGINE = Memory;
INSERT INTO test FORMAT JSONEachRow {"json" : {"a" : 42}}, {"json" : {"b" : "Hello"}}, {"json" : {"a" : [1, 2, 3], "c" : "2020-01-01"}};
SELECT json, JSONSharedDataPathsWithTypes(json) FROM test;

Response

┌─json───────────────────────────┬─JSONSharedDataPathsWithTypes(json)─┐
│ {"a":42}                       │ {}                                 │
│ {"b":"Hello"}                  │ {'b':'String'}                     │
│ {"a":[1,2,3],"c":"2020-01-01"} │ {'c':'Date'}                       │
└────────────────────────────────┴────────────────────────────────────┘

JSONType

Introduzido em: v20.1.0 Retorna o tipo de um valor JSON. Se o valor não existir, Null=0 será retornado. Sintaxe

JSONType(json[, indices_or_keys, ...])

Argumentos

json — String JSON a ser analisada String
json[, indices_or_keys, ...] — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. String ou (U)Int8/16/32/64

Valor retornado Retorna o tipo de um valor JSON como string; se o valor não existir, retorna Null=0 Enum Exemplos Exemplo de uso

Query

SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}') = 'Object';
SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') = 'String';
SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 'Array';

Response

1
1
1

JSON_EXISTS

Introduzido em: v21.8.0 Se o valor existir no documento JSON, 1 será retornado. Se o valor não existir, 0 será retornado. Sintaxe

JSON_EXISTS(json, path)

Argumentos

json — Uma string com JSON válido. String
path — Uma string que representa o caminho. String

Valor retornado Retorna 1 se o valor existir no documento JSON; caso contrário, 0. UInt8 Exemplos Exemplo de uso

Query

SELECT JSON_EXISTS('{"hello":1}', '$.hello');
SELECT JSON_EXISTS('{"hello":{"world":1}}', '$.hello.world');
SELECT JSON_EXISTS('{"hello":["world"]}', '$.hello[*]');
SELECT JSON_EXISTS('{"hello":["world"]}', '$.hello[0]');

Response

┌─JSON_EXISTS('{"hello":1}', '$.hello')─┐
│                                     1 │
└───────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":{"world":1}}', '$.hello.world')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":["world"]}', '$.hello[*]')─┐
│                                                1 │
└──────────────────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":["world"]}', '$.hello[0]')─┐
│                                                1 │
└──────────────────────────────────────────────────┘

JSON_QUERY

Introduzido na versão: v21.8.0 Analisa um JSON e extrai um valor como um array JSON ou um objeto JSON. Se o valor não existir, será retornada uma string vazia. Sintaxe

JSON_QUERY(json, path)

Argumentos

json — Uma string com JSON válido. String
path — Uma string que representa o caminho. String

Valor retornado Retorna o array JSON ou objeto JSON extraído como uma string, ou uma string vazia se o valor não existir. String Exemplos Exemplo de uso

Query

SELECT JSON_QUERY('{"hello":"world"}', '$.hello');
SELECT JSON_QUERY('{"array":[[0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -4, -5]]}', '$.array[*][0 to 2, 4]');
SELECT JSON_QUERY('{"hello":2}', '$.hello');
SELECT toTypeName(JSON_QUERY('{"hello":2}', '$.hello'));

Response

["world"]
[0, 1, 4, 0, -1, -4]
[2]
String

JSON_VALUE

Introduzido em: v21.11.0 Analisa um JSON e extrai um valor como escalar JSON. Se o valor não existir, uma string vazia será retornada por padrão. Esta função é controlada pelas seguintes configurações:

com SET function_json_value_return_type_allow_nullable = true, NULL será retornado. Se o valor for de tipo complexo (como: struct, array, map), uma string vazia será retornada por padrão.
com SET function_json_value_return_type_allow_complex = true, o valor complexo será retornado.

Sintaxe

JSON_VALUE(json, path)

Argumentos

json — Uma string com JSON válido. String
path — Uma string que representa o caminho. String

Valor retornado Retorna o valor escalar JSON extraído como string, ou uma string vazia se o valor não existir. String Exemplos Exemplo de uso

Query

SELECT JSON_VALUE('{"hello":"world"}', '$.hello');
SELECT JSON_VALUE('{"array":[[0, 1, 2, 3, 4, 5], [0, -1, -2, -3, -4, -5]]}', '$.array[*][0 to 2, 4]');
SELECT JSON_VALUE('{"hello":2}', '$.hello');
SELECT JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;

Response

world
0
2
\N

dynamicElement

Introduzido em: v24.1.0 Extrai de uma coluna Dynamic uma coluna do tipo especificado. Esta função permite extrair valores de um tipo específico de uma coluna Dynamic. Se uma linha contiver um valor do tipo solicitado, ela retornará esse valor. Se a linha contiver um tipo diferente ou NULL, ela retornará NULL para tipos escalares ou um array vazio para tipos de array. Sintaxe

dynamicElement(dynamic, type_name)

Argumentos

dynamic — Coluna Dynamic da qual será feita a extração. Dynamic
type_name — O nome do tipo de variante a ser extraído (por exemplo, ‘String’, ‘Int64’, ‘Array(Int64)’).

Valor retornado Retorna valores do tipo especificado da coluna Dynamic. Retorna NULL para tipos não correspondentes (ou um array vazio para tipos array). Any Exemplos Extração de diferentes tipos da coluna Dynamic

Query

CREATE TABLE test (d Dynamic) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT d, dynamicType(d), dynamicElement(d, 'String'), dynamicElement(d, 'Int64'), dynamicElement(d, 'Array(Int64)'), dynamicElement(d, 'Date'), dynamicElement(d, 'Array(String)') FROM test

Response

┌─d─────────────┬─dynamicType(d)─┬─dynamicElement(d, 'String')─┬─dynamicElement(d, 'Int64')─┬─dynamicElement(d, 'Array(Int64)')─┬─dynamicElement(d, 'Date')─┬─dynamicElement(d, 'Array(String)')─┐
│ ᴺᵁᴸᴸ          │ None           │ ᴺᵁᴸᴸ                        │                       ᴺᵁᴸᴸ │ []                                │                      ᴺᵁᴸᴸ │ []                                 │
│ 42            │ Int64          │ ᴺᵁᴸᴸ                        │                         42 │ []                                │                      ᴺᵁᴸᴸ │ []                                 │
│ Hello, World! │ String         │ Hello, World!               │                       ᴺᵁᴸᴸ │ []                                │                      ᴺᵁᴸᴸ │ []                                 │
│ [1,2,3]       │ Array(Int64)   │ ᴺᵁᴸᴸ                        │                       ᴺᵁᴸᴸ │ [1,2,3]                           │                      ᴺᵁᴸᴸ │ []                                 │
└───────────────┴────────────────┴─────────────────────────────┴────────────────────────────┴───────────────────────────────────┴───────────────────────────┴────────────────────────────────────┘

dynamicType

Introduzido em: v24.1.0 Retorna o nome do tipo de variante para cada linha de uma coluna Dynamic. Para linhas que contêm NULL, a função retorna ‘None’. Para todas as outras linhas, retorna o tipo de dado real armazenado naquela linha da coluna Dynamic (por exemplo, ‘Int64’, ‘String’, ‘Array(Int64)’). Sintaxe

dynamicType(dynamic)

Argumentos

dynamic — Coluna Dynamic a ser inspecionada. Dynamic

Valor retornado Retorna o nome do tipo do valor armazenado em cada linha, ou ‘None’ para valores NULL. String Exemplos Inspecionando os tipos na coluna Dynamic

Query

CREATE TABLE test (d Dynamic) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT d, dynamicType(d) FROM test;

Response

┌─d─────────────┬─dynamicType(d)─┐
│ ᴺᵁᴸᴸ          │ None           │
│ 42            │ Int64          │
│ Hello, World! │ String         │
│ [1,2,3]       │ Array(Int64)   │
└───────────────┴────────────────┘

isDynamicElementInSharedData

Introduzido em: v24.1.0 Retorna true para linhas em uma coluna Dynamic que são armazenadas em um formato variante compartilhado, em vez de subcolunas separadas. Quando uma coluna Dynamic tem um limite max_types, os valores que excedem esse limite são armazenados em um formato binário compartilhado em vez de serem separados em subcolunas tipadas individuais. Esta função identifica quais linhas são armazenadas nesse formato compartilhado. Sintaxe

isDynamicElementInSharedData(dynamic)

Argumentos

dynamic — coluna do tipo Dynamic a ser inspecionada. Dynamic

Valor retornado Retorna true se o valor estiver armazenado no formato Variante compartilhado, false se estiver armazenado como uma subcoluna separada ou for NULL. Bool Exemplos Verificando o formato de armazenamento em uma coluna Dynamic com o limite de max_types

Query

CREATE TABLE test (d Dynamic(max_types=2)) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT d, isDynamicElementInSharedData(d) FROM test;

Response

┌─d─────────────┬─isDynamicElementInSharedData(d)─┐
│ ᴺᵁᴸᴸ          │ false                           │
│ 42            │ false                           │
│ Hello, World! │ false                           │
│ [1,2,3]       │ true                            │
└───────────────┴─────────────────────────────────┘

isValidJSON

Introduzido em: v20.1.0 Verifica se a string informada é um JSON válido. Sintaxe

isValidJSON(json)

Argumentos

json — string JSON a ser validada String

Valor retornado Retorna 1 se a string for um JSON válido; caso contrário, 0. UInt8 Exemplos Exemplo de uso

Query

SELECT isValidJSON('{"a": "hello", "b": [-100, 200.0, 300]}') = 1;
SELECT isValidJSON('not JSON') = 0;

Response

1
1

Usando inteiros para acessar arrays JSON e objetos JSON

Query

SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 0);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 1);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 2);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', -1);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', -2);
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 3);

Response

prettyPrintJSON

Introduzido em: v26.4.0 Retorna uma versão formatada de uma string JSON, com quebras de linha e recuo com espaços. Sintaxe

prettyPrintJSON(json [, indent])

Argumentos

json — Uma string JSON válida para formatar. String
indent — Número de espaços por nível de indentação. Padrão: 4. Máx.: 32 UInt*

Valor retornado Uma string JSON formatada de forma legível. String Exemplos Objeto simples

Query

SELECT prettyPrintJSON('{"a":1,"b":"hello"}');

Response

{\n    "a": 1,\n    "b": "hello"\n}

Recuo personalizado

Query

SELECT prettyPrintJSON('{"a":1}', 8);

Response

{\n        "a": 1\n}

simpleJSONExtractBool

Introduzido em: v21.4.0 Interpreta um valor true/false a partir do valor do campo chamado field_name. O resultado é UInt8. Sintaxe

simpleJSONExtractBool(json, field_name)

Aliases: visitParamExtractBool Argumentos

json — O JSON em que o campo será procurado. String
field_name — O nome do campo a ser procurado. const String

Valor retornado Retorna 1 se o valor do campo for true; caso contrário, retorna 0. Isso significa que esta função retornará 0, inclusive — e não apenas — nos seguintes casos:

Se o campo não existir.
Se o campo contiver true como string, por exemplo: {"field":"true"}.
Se o campo contiver 1 como valor numérico. UInt8

Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":false,"bar":true}');
INSERT INTO jsons VALUES ('{"foo":"true","qux":1}');

SELECT simpleJSONExtractBool(json, 'bar') FROM jsons ORDER BY json;
SELECT simpleJSONExtractBool(json, 'foo') FROM jsons ORDER BY json;

Response

simpleJSONExtractFloat

Introduzido na versão: v21.4.0 Analisa um Float64 a partir do valor do campo chamado field_name. Se field_name for um campo do tipo string, ele tentará analisar um número a partir do início da string. Se o campo não existir, ou existir mas não contiver um número, retorna 0. Sintaxe

simpleJSONExtractFloat(json, field_name)

Aliases: visitParamExtractFloat Argumentos

json — O JSON no qual o campo é procurado. String
field_name — O nome do campo a ser procurado. const String

Valor retornado Retorna o número interpretado do campo, se ele existir e contiver um número; caso contrário, 0. Float64 Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"-4e3"}');
INSERT INTO jsons VALUES ('{"foo":-3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":"not1number"}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractFloat(json, 'foo') FROM jsons ORDER BY json;

Response

simpleJSONExtractInt

Introduzido em: v21.4.0 Extrai um Int64 do valor do campo chamado field_name. Se field_name for um campo do tipo string, tenta interpretar um número a partir do início da string. Se o campo não existir, ou existir mas não contiver um número, retorna 0. Sintaxe

simpleJSONExtractInt(json, field_name)

Aliases: visitParamExtractInt Argumentos

json — O JSON no qual o campo é procurado. String
field_name — O nome do campo a ser procurado. const String

Valor retornado Retorna o número extraído do campo, se ele existir e contiver um número; caso contrário, 0 Int64 Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"-4e3"}');
INSERT INTO jsons VALUES ('{"foo":-3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":"not1number"}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractInt(json, 'foo') FROM jsons ORDER BY json;

Response

simpleJSONExtractRaw

Introduzido em: v21.4.0 Retorna o valor do campo field_name como uma String, incluindo os separadores. Sintaxe

simpleJSONExtractRaw(json, field_name)

Aliases: visitParamExtractRaw Argumentos

json — O JSON no qual o campo é procurado. String
field_name — O nome do campo a ser procurado. const String

Valor retornado Retorna o valor do campo como string, incluindo os separadores se o campo existir, ou uma string vazia caso contrário String Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"-4e3"}');
INSERT INTO jsons VALUES ('{"foo":-3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":{"def":[1,2,3]}}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractRaw(json, 'foo') FROM jsons ORDER BY json;

Response

"-4e3"
-3.4
5
{"def":[1,2,3]}

simpleJSONExtractString

Introduzido em: v21.4.0 Extrai uma String entre aspas duplas do valor do campo chamado field_name. Detalhes de implementação No momento, não há suporte a pontos de código no formato \uXXXX\uYYYY que não pertençam ao plano multilíngue básico (eles são convertidos para CESU-8 em vez de UTF-8). Sintaxe

simpleJSONExtractString(json, field_name)

Aliases: visitParamExtractString Argumentos

json — O JSON no qual o campo é pesquisado. String
field_name — O nome do campo a ser pesquisado. const String

Valor retornado Retorna o valor de um campo como string, sem caracteres de escape, incluindo separadores. Uma string vazia é retornada se o campo não contiver uma string entre aspas duplas, se o processamento de remoção de escape falhar ou se o campo não existir String Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"\\n\\u0000"}');
INSERT INTO jsons VALUES ('{"foo":"\\u263"}');
INSERT INTO jsons VALUES ('{"foo":"\\u263a"}');
INSERT INTO jsons VALUES ('{"foo":"hello}');

SELECT simpleJSONExtractString(json, 'foo') FROM jsons ORDER BY json;

Response

\n\0

☺

simpleJSONExtractUInt

Introduzido em: v21.4.0 Extrai UInt64 do valor do campo chamado field_name. Se field_name for um campo do tipo String, tenta analisar um número a partir do início da string. Se o campo não existir, ou existir mas não contiver um número, retorna 0. Sintaxe

simpleJSONExtractUInt(json, field_name)

Aliases: visitParamExtractUInt Argumentos

json — O JSON no qual o campo é pesquisado. String
field_name — O nome do campo a ser pesquisado. const String

Valor retornado Retorna o número analisado do campo, se ele existir e contiver um número; caso contrário, 0 UInt64 Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"4e3"}');
INSERT INTO jsons VALUES ('{"foo":3.4}');
INSERT INTO jsons VALUES ('{"foo":5}');
INSERT INTO jsons VALUES ('{"foo":"not1number"}');
INSERT INTO jsons VALUES ('{"baz":2}');

SELECT simpleJSONExtractUInt(json, 'foo') FROM jsons ORDER BY json;

Response

simpleJSONHas

Introduzido em: v21.4.0 Verifica se há um campo chamado field_name. Sintaxe

simpleJSONHas(json, field_name)

Aliases: visitParamHas Argumentos

json — O JSON em que o campo é pesquisado. String
field_name — O nome do campo a ser pesquisado. const String

Valor retornado Retorna 1 se o campo existir; caso contrário, 0 UInt8 Exemplos Exemplo de uso

Query

CREATE TABLE jsons
(
    `json` String
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO jsons VALUES ('{"foo":"true","qux":1}');

SELECT simpleJSONHas(json, 'foo') FROM jsons;
SELECT simpleJSONHas(json, 'bar') FROM jsons;

Response

1
0

toJSONString

Introduzido em: v21.7.0 Serializa um valor em sua representação JSON. Há suporte para vários tipos de dados e estruturas aninhadas. inteiros de 64 bits ou maiores (como UInt64 ou Int128) são exibidos sem aspas por padrão. output_format_json_quote_64bit_integers controla esse comportamento. Os valores especiais NaN e inf são substituídos por null. Habilite a configuração output_format_json_quote_denormals para exibi-los. Ao serializar um valor Enum, a função retorna seu nome. Veja também:

Sintaxe

toJSONString(value)

Argumentos

value — Valor a ser serializado. O valor pode ser de qualquer tipo de dado. Any

Valor retornado Retorna a representação JSON do valor. String Exemplos Serialização de map

Query

SELECT toJSONString(map('key1', 1, 'key2', 2));

Response

┌─toJSONString(map('key1', 1, 'key2', 2))─┐
│ {"key1":1,"key2":2}                     │
└─────────────────────────────────────────┘

Valores especiais

Query

SELECT toJSONString(tuple(1.25, NULL, NaN, +inf, -inf, [])) SETTINGS output_format_json_quote_denormals = 1;

Response

┌─toJSONString((1.25, NULL, nan, inf, -inf, []))─┐
│ [1.25,null,"nan","inf","-inf",[]]              │
└────────────────────────────────────────────────┘

​Tipos de funções JSON

​funções simpleJSON (visitParam)

​Funções JSONExtract

​Funções JSONExtract sem distinção entre maiúsculas e minúsculas

​Sintaxe do JSONPath

​Operadores compatíveis

​Operadores sem suporte

​JSONAllPaths

​JSONAllPathsWithTypes

​JSONAllValues

​JSONArrayLength

​JSONDynamicPaths

​JSONDynamicPathsWithTypes

​JSONExtract

​JSONExtractArrayRaw

​JSONExtractArrayRawCaseInsensitive

​JSONExtractBool

​JSONExtractBoolCaseInsensitive

​JSONExtractCaseInsensitive

​JSONExtractFloat

​JSONExtractFloatCaseInsensitive

​JSONExtractInt

​JSONExtractIntCaseInsensitive

​JSONExtractKeys

​JSONExtractKeysAndValues

​JSONExtractKeysAndValuesCaseInsensitive

​JSONExtractKeysAndValuesRaw

​JSONExtractKeysAndValuesRawCaseInsensitive

​JSONExtractKeysCaseInsensitive

​JSONExtractRaw

​JSONExtractRawCaseInsensitive

​JSONExtractString

​JSONExtractStringCaseInsensitive

​JSONExtractUInt

​JSONExtractUIntCaseInsensitive

​JSONHas

​JSONKey

​JSONLength

​JSONMergePatch

​JSONSharedDataPaths

​JSONSharedDataPathsWithTypes

​JSONType

​JSON_EXISTS

​JSON_QUERY

​JSON_VALUE

​dynamicElement

​dynamicType

​isDynamicElementInSharedData

​isValidJSON

​prettyPrintJSON

​simpleJSONExtractBool

​simpleJSONExtractFloat

​simpleJSONExtractInt

​simpleJSONExtractRaw

​simpleJSONExtractString

​simpleJSONExtractUInt

​simpleJSONHas

​toJSONString

Tipos de funções JSON

funções `simpleJSON` (visitParam)

Funções JSONExtract

Funções JSONExtract sem distinção entre maiúsculas e minúsculas

Sintaxe do JSONPath

Operadores compatíveis

Operadores sem suporte

JSONAllPaths

JSONAllPathsWithTypes

JSONAllValues

JSONArrayLength

JSONDynamicPaths

JSONDynamicPathsWithTypes

JSONExtract

JSONExtractArrayRaw

JSONExtractArrayRawCaseInsensitive

JSONExtractBool

JSONExtractBoolCaseInsensitive

JSONExtractCaseInsensitive

JSONExtractFloat

JSONExtractFloatCaseInsensitive

JSONExtractInt

JSONExtractIntCaseInsensitive

JSONExtractKeys

JSONExtractKeysAndValues

JSONExtractKeysAndValuesCaseInsensitive

JSONExtractKeysAndValuesRaw

JSONExtractKeysAndValuesRawCaseInsensitive

JSONExtractKeysCaseInsensitive

JSONExtractRaw

JSONExtractRawCaseInsensitive

JSONExtractString

JSONExtractStringCaseInsensitive

JSONExtractUInt

JSONExtractUIntCaseInsensitive

JSONHas

JSONKey

JSONLength

JSONMergePatch

JSONSharedDataPaths

JSONSharedDataPathsWithTypes

JSONType

JSON_EXISTS

JSON_QUERY

JSON_VALUE

dynamicElement

dynamicType

isDynamicElementInSharedData

isValidJSON

prettyPrintJSON

simpleJSONExtractBool

simpleJSONExtractFloat

simpleJSONExtractInt

simpleJSONExtractRaw

simpleJSONExtractString

simpleJSONExtractUInt

simpleJSONHas

toJSONString