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.

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:

1. O nome do campo (argumento da função) deve ser uma constante.
2. 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
3. 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.
4. O JSON não contém caracteres de espaço fora de literais de string.

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

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.

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.

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

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

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

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;

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

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

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;

┌─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'} │
└────────────────────────────────┴───────────────────────────────────────────┘

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

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;

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

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

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

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

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

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;

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

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

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;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1

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

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

123

array_type

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

[1,2,3]

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

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

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

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

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

12.34

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

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

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

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

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

123

aninhado

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

42

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

['Name','AGE']

aninhado

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

['name','AGE']

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

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

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

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

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

{"key":"value"}

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

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

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

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

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

def

aninhado

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

John

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

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

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

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

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

789

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

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

1
1

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

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

a

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

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

1
1

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

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

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

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

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;

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

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

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;

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

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

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

1
1
1

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

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

┌─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 │
└──────────────────────────────────────────────────┘

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

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

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

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

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;

world
0
2
\N

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

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

┌─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]                           │                      ᴺᵁᴸᴸ │ []                                 │
└───────────────┴────────────────┴─────────────────────────────┴────────────────────────────┴───────────────────────────────────┴───────────────────────────┴────────────────────────────────────┘

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

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

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

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

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;

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

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

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

1
1

Usando inteiros para acessar arrays JSON e objetos JSON

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

0
1
1
1
1
0

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

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

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

Recuo personalizado

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

{\n        "a": 1\n}

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

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;

0
1
0
0

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

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;

0
-4000
0
-3.4
5

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

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;

0
-4
0
-3
5

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

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;

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

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

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;

\n\0

☺

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

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;

0
4
0
3
5

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

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;

1
0

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 colocados entre 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:

• output_format_json_quote_64bit_integers
• output_format_json_quote_denormals

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

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

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

Valores especiais

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

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