> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentação sobre Funções JSON
# Funções JSON
## Tipos de funções JSON
Há dois conjuntos de funções para analisar de JSON:
* [`simpleJSON*` (`visitParam*`)](#simplejson-visitparam-functions), feito para fazer o analisar de um subconjunto limitado de JSON com extrema rapidez.
* [`JSONExtract*`](#jsonextract-functions), 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:
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](https://github.com/lemire/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.
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.
{/*AUTOGENERATED_START*/}
## JSONAllPaths
Introduzido em: v24.8.0
Retorna a lista de todos os caminhos armazenados em cada linha de uma coluna JSON.
**Sintaxe**
```sql theme={null}
JSONAllPaths(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**Valor retornado**
Retorna um array com todos os caminhos da coluna JSON. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
JSONAllPathsWithTypes(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**Valor retornado**
Retorna um map de todos os caminhos e seus tipos de dados na coluna JSON. [`Map(String, String)`](/pt-BR/reference/data-types/map)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
JSONAllValues(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**Valor retornado**
Retorna um array com todos os valores da coluna JSON como strings. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
JSONArrayLength(json)
```
**Aliases**: `JSON_ARRAY_LENGTH`
**Argumentos**
* `json` — String com JSON válido. [`String`](/pt-BR/reference/data-types/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)`](/pt-BR/reference/data-types/nullable)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
JSONArrayLength(''),
JSONArrayLength('[1,2,3]');
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
JSONDynamicPaths(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**Valor retornado**
Retorna um array de caminhos dinâmicos da coluna JSON. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
JSONDynamicPathsWithTypes(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**Valor retornado**
Retorna um mapa dos caminhos dinâmicos e seus tipos de dados na coluna JSON. [`Map(String, String)`](/pt-BR/reference/data-types/map)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
JSONExtract(json[, indices_or_keys, ...], return_type)
```
**Argumentos**
* `json` — String JSON a ser processada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `return_type` — Tipo de dados do ClickHouse a ser retornado. [`String`](/pt-BR/reference/data-types/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**
```sql title=Query theme={null}
SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(String, Array(Float64))') AS res;
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
JSONExtractArrayRaw(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractArrayRaw('{"a": "hello", "b": [-100, 200.0, "hello"]}', 'b') AS res;
```
```response title=Response theme={null}
┌─res──────────────────────────┐
│ ['-100','200.0','"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`](#JSONExtractArrayRaw).
**Sintaxe**
```sql theme={null}
JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices ou chaves para navegar no array. As chaves não distinguem entre maiúsculas e minúsculas [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array de strings JSON brutas. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractArrayRawCaseInsensitive('{"Items": [1, 2, 3]}', 'ITEMS')
```
```response title=Response theme={null}
['1','2','3']
```
Introduzido em: v20.1.0
Faz o analisar de JSON e extrai um valor do tipo Bool.
**Sintaxe**
```sql theme={null}
JSONExtractBool(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Bool, se existir; caso contrário, retorna `0`. [`Bool`](/pt-BR/reference/data-types/boolean)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractBool('{"passed": true}', 'passed') AS res;
```
```response title=Response theme={null}
┌─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`](#JSONExtractBool).
**Sintaxe**
```sql theme={null}
JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o valor booleano extraído (1 para true, 0 para false) ou 0, se não for encontrado. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractBoolCaseInsensitive('{"IsActive": true}', 'isactive')
```
```response title=Response theme={null}
1
```
Introduzido em: v25.8.0
Faz o analisar de 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`](#JSONExtract).
**Sintaxe**
```sql theme={null}
JSONExtractCaseInsensitive(json [, indices_or_keys...], return_type)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `return_type` — O tipo de dado do ClickHouse a ser extraído [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor extraído no tipo de dado especificado. [`Any`](/pt-BR/reference/data-types)
**Exemplos**
**int\_type**
```sql title=Query theme={null}
SELECT JSONExtractCaseInsensitive('{"Number": 123}', 'number', 'Int32')
```
```response title=Response theme={null}
123
```
**array\_type**
```sql title=Query theme={null}
SELECT JSONExtractCaseInsensitive('{"List": [1, 2, 3]}', 'list', 'Array(Int32)')
```
```response title=Response theme={null}
[1,2,3]
```
Introduzido em: v20.1.0
Analisa o JSON e extrai um valor do tipo Float.
**Sintaxe**
```sql theme={null}
JSONExtractFloat(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Uma string JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Float, se existir; caso contrário, retorna `0`. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractFloat('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 2) AS res;
```
```response title=Response theme={null}
┌─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`](#JSONExtractFloat).
**Sintaxe**
```sql theme={null}
JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o valor Float extraído; 0 se não for encontrado ou se não puder ser convertido. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractFloatCaseInsensitive('{"Price": 12.34}', 'PRICE')
```
```response title=Response theme={null}
12.34
```
Introduzido em: v20.1.0
Faz o analisaring de JSON e extrai um valor do tipo Int.
**Sintaxe**
```sql theme={null}
JSONExtractInt(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor Int, se existir; caso contrário, retorna `0`. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) AS res;
```
```response title=Response theme={null}
┌──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`](#JSONExtractInt).
**Sintaxe**
```sql theme={null}
JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o valor Int extraído, 0 se não for encontrado ou não puder ser convertido. [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractIntCaseInsensitive('{"Value": 123}', 'value')
```
```response title=Response theme={null}
123
```
**aninhado**
```sql title=Query theme={null}
SELECT JSONExtractIntCaseInsensitive('{"DATA": {"COUNT": 42}}', 'data', 'Count')
```
```response title=Response theme={null}
42
```
Introduzido em: v21.11.0
Analisa uma string JSON e extrai as chaves.
**Sintaxe**
```sql theme={null}
JSONExtractKeys(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array com as chaves do objeto JSON. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractKeys('{"a": "hello", "b": [-100, 200.0, 300]}') AS res;
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
JSONExtractKeysAndValues(json[, indices_or_keys, ...], value_type)
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `value_type` — Tipo de dado ClickHouse dos valores. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um array de tuplas com os pares chave-valor extraídos. [`Array(Tuple(String, value_type))`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractKeysAndValues('{"x": {"a": 5, "b": 7, "c": 11}}', 'Int8', 'x') AS res;
```
```response title=Response theme={null}
┌─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`](#JSONExtractKeysAndValues).
**Sintaxe**
```sql theme={null}
JSONExtractKeysAndValuesCaseInsensitive(json [, indices_or_keys...], value_type)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `value_type` — O tipo de dado do ClickHouse para os valores [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um array de tuplas contendo pares chave-valor. [`Array(Tuple(String, T))`](/pt-BR/reference/data-types/array)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesCaseInsensitive('{"Name": "Alice", "AGE": 30}', 'String')
```
```response title=Response theme={null}
[('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**
```sql theme={null}
JSONExtractKeysAndValuesRaw(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**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))`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesRaw('{"a": [-100, 200.0], "b": "hello"}') AS res;
```
```response title=Response theme={null}
┌─res──────────────────────────────────┐
│ [('a','[-100,200.0]'),('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`](#JSONExtractKeysAndValuesRaw).
**Sintaxe**
```sql theme={null}
JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser processada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array de tuplas contendo pares chave-valor como strings em formato bruto. [`Array(Tuple(String, String))`](/pt-BR/reference/data-types/array)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesRawCaseInsensitive('{"Name": "Alice", "AGE": 30}')
```
```response title=Response theme={null}
[('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`](#JSONExtractKeys).
**Sintaxe**
```sql theme={null}
JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — string JSON a ser processada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array de chaves do objeto JSON. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractKeysCaseInsensitive('{"Name": "Alice", "AGE": 30}')
```
```response title=Response theme={null}
['Name','AGE']
```
**aninhado**
```sql title=Query theme={null}
SELECT JSONExtractKeysCaseInsensitive('{"User": {"name": "John", "AGE": 25}}', 'user')
```
```response title=Response theme={null}
['name','AGE']
```
Introduzido em: v20.1.0
Retorna uma parte do JSON como string não analisada.
**Sintaxe**
```sql theme={null}
JSONExtractRaw(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna a parte do JSON como uma string não analisada. Se a parte não existir ou tiver o tipo incorreto, retorna uma string vazia. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractRaw('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') AS res;
```
```response title=Response theme={null}
┌─res──────────────┐
│ [-100,200.0,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`](#JSONExtractRaw).
**Sintaxe**
```sql theme={null}
JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna a string JSON bruta do elemento extraído. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**objeto**
```sql title=Query theme={null}
SELECT JSONExtractRawCaseInsensitive('{"Object": {"key": "value"}}', 'OBJECT')
```
```response title=Response theme={null}
{"key":"value"}
```
Introduzido em: v20.1.0
Analisa JSON e extrai um valor do tipo String.
**Sintaxe**
```sql theme={null}
JSONExtractString(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista de zero ou mais argumentos, cada um deles podendo ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor String, se existir; caso contrário, retorna uma string vazia. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') AS res;
```
```response title=Response theme={null}
┌─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`](#JSONExtractString).
**Sintaxe**
```sql theme={null}
JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o valor de string extraído ou uma string vazia, se não for encontrado. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractStringCaseInsensitive('{"ABC": "def"}', 'abc')
```
```response title=Response theme={null}
def
```
**aninhado**
```sql title=Query theme={null}
SELECT JSONExtractStringCaseInsensitive('{"User": {"Name": "John"}}', 'user', 'name')
```
```response title=Response theme={null}
John
```
Introduzido em: v20.1.0
Analisa JSON e extrai um valor do tipo UInt.
**Sintaxe**
```sql theme={null}
JSONExtractUInt(json [, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/string)
* `indices_or_keys` — Uma lista com zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um valor UInt, se existir; caso contrário, retorna `0`. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractUInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', -1) AS res;
```
```response title=Response theme={null}
┌─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`](#JSONExtractUInt).
**Sintaxe**
```sql theme={null}
JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o valor UInt extraído, 0 se não for encontrado ou se não puder ser convertido. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractUIntCaseInsensitive('{"COUNT": 789}', 'count')
```
```response title=Response theme={null}
789
```
## JSONHas
Introduzido em: v20.1.0
Verifica se o(s) valor(es) fornecido(s) existe(m) no documento JSON.
**Sintaxe**
```sql theme={null}
JSONHas(json[ ,indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/string)
* `[ ,indices_or_keys, ...]` — Uma lista de zero ou mais argumentos. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna `1` se o valor existir em `json`; caso contrário, `0` [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 1;
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 4) = 0;
```
```response title=Response theme={null}
1
0
```
## 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**
```sql theme={null}
JSONKey(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string) ou [`Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o nome da chave na posição especificada no objeto JSON. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1);
```
```response title=Response theme={null}
a
```
## 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**
```sql theme={null}
JSONLength(json [, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/string)
* `[, indices_or_keys, ...]` — Opcional. Uma lista de zero ou mais argumentos. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int8/16/32/64`](/pt-BR/reference/data-types/int-uint)
**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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 3;
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}') = 2;
```
```response title=Response theme={null}
1
1
```
## JSONMergePatch
Introduzido em: v23.10.0
Retorna a string do objeto JSON resultante da mesclagem de vários objetos JSON.
**Sintaxe**
```sql theme={null}
JSONMergePatch(json1[, json2, ...])
```
**Aliases**: `jsonMergePatch`
**Argumentos**
* `json1[, json2, ...]` — Uma ou mais strings contendo JSON válido. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna a string do objeto JSON resultante da mesclagem, desde que as strings de objeto JSON sejam válidas. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT JSONMergePatch('{"a":1}', '{"name": "joey"}', '{"name": "tom"}', '{"name": "zoey"}') AS res;
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
JSONSharedDataPaths(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**Valor retornado**
Retorna um array de caminhos armazenados na estrutura de dados compartilhada da coluna JSON. [`Array(String)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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 compartilhados e seus tipos em cada linha da coluna JSON.
**Sintaxe**
```sql theme={null}
JSONSharedDataPathsWithTypes(json)
```
**Argumentos**
* `json` — coluna JSON. [`JSON`](/pt-BR/reference/data-types/newjson)
**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)`](/pt-BR/reference/data-types/map)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
JSONType(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — String JSON a ser analisada [`String`](/pt-BR/reference/data-types/string)
* `json[, indices_or_keys, ...]` — Uma lista de zero ou mais argumentos, cada um dos quais pode ser uma string ou um inteiro. [`String`](/pt-BR/reference/data-types/string) ou [`(U)Int8/16/32/64`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna o tipo de um valor JSON como string; se o valor não existir, retorna `Null=0` [`Enum`](/pt-BR/reference/data-types/enum)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
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**
```sql theme={null}
JSON_EXISTS(json, path)
```
**Argumentos**
* `json` — Uma string com JSON válido. [`String`](/pt-BR/reference/data-types/string)
* `path` — Uma string que representa o caminho. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se o valor existir no documento JSON; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─JSON_EXISTS(⋯ '$.hello')─┐
│ 1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯llo.world')─┐
│ 1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[*]')─┐
│ 1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.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**
```sql theme={null}
JSON_QUERY(json, path)
```
**Argumentos**
* `json` — Uma string com JSON válido. [`String`](/pt-BR/reference/data-types/string)
* `path` — Uma string que representa o caminho. [`String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
["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**
```sql theme={null}
JSON_VALUE(json, path)
```
**Argumentos**
* `json` — Uma string com JSON válido. [`String`](/pt-BR/reference/data-types/string)
* `path` — Uma string que representa o caminho. [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o valor escalar JSON extraído como string, ou uma string vazia se o valor não existir. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
world
0
2
ᴺᵁᴸᴸ
```
## 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**
```sql theme={null}
dynamicElement(dynamic, type_name)
```
**Argumentos**
* `dynamic` — Coluna Dynamic da qual será feita a extração. [`Dynamic`](/pt-BR/reference/data-types/dynamic)
* `type_name` — O nome do tipo 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`](/pt-BR/reference/data-types)
**Exemplos**
**Extração de diferentes tipos da coluna Dynamic**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
dynamicType(dynamic)
```
**Argumentos**
* `dynamic` — Coluna Dynamic a ser inspecionada. [`Dynamic`](/pt-BR/reference/data-types/dynamic)
**Valor retornado**
Retorna o nome do tipo do valor armazenado em cada linha, ou 'None' para valores NULL. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Inspecionando os tipos na coluna Dynamic**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
isDynamicElementInSharedData(dynamic)
```
**Argumentos**
* `dynamic` — coluna do tipo Dynamic a ser inspecionada. [`Dynamic`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/boolean)
**Exemplos**
**Verificando o formato de armazenamento em uma coluna Dynamic com o limite de max\_types**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─d─────────────┬─isDynamicElementInSharedData(d)─┐
│ ᴺᵁᴸᴸ │ false │
│ 42 │ false │
│ Hello, World! │ true │
│ [1,2,3] │ true │
└───────────────┴─────────────────────────────────┘
```
## isValidJSON
Introduzido em: v20.1.0
Verifica se a string informada é um JSON válido.
**Sintaxe**
```sql theme={null}
isValidJSON(json)
```
**Argumentos**
* `json` — string JSON a ser validada [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se a string for um JSON válido; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT isValidJSON('{"a": "hello", "b": [-100, 200.0, 300]}') = 1;
SELECT isValidJSON('not JSON') = 0;
```
```response title=Response theme={null}
1
0
```
**Usando inteiros para acessar arrays JSON e objetos JSON**
```sql title=Query theme={null}
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 title=Response theme={null}
0
1
1
1
1
1
0
```
Introduzido em: v21.4.0
Interpreta um valor true/false a partir do valor do campo chamado `field_name`.
O resultado é `UInt8`.
**Sintaxe**
```sql theme={null}
simpleJSONExtractBool(json, field_name)
```
**Aliases**: `visitParamExtractBool`
**Argumentos**
* `json` — O JSON em que o campo será procurado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser procurado. [`const String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
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**
```sql theme={null}
simpleJSONExtractFloat(json, field_name)
```
**Aliases**: `visitParamExtractFloat`
**Argumentos**
* `json` — O JSON no qual o campo é procurado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser procurado. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número interpretado do campo, se ele existir e contiver um número; caso contrário, `0`. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
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**
```sql theme={null}
simpleJSONExtractInt(json, field_name)
```
**Aliases**: `visitParamExtractInt`
**Argumentos**
* `json` — O JSON no qual o campo é procurado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser procurado. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número extraído do campo, se ele existir e contiver um número; caso contrário, `0` [`Int64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
0
-4
0
-3
5
```
Introduzido em: v21.4.0
Retorna o valor do campo `field_name` como uma `String`, incluindo os separadores.
**Sintaxe**
```sql theme={null}
simpleJSONExtractRaw(json, field_name)
```
**Aliases**: `visitParamExtractRaw`
**Argumentos**
* `json` — O JSON no qual o campo é procurado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser procurado. [`const String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
"-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**
```sql theme={null}
simpleJSONExtractString(json, field_name)
```
**Aliases**: `visitParamExtractString`
**Argumentos**
* `json` — O JSON no qual o campo é pesquisado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser pesquisado. [`const String`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/string)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
\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**
```sql theme={null}
simpleJSONExtractUInt(json, field_name)
```
**Aliases**: `visitParamExtractUInt`
**Argumentos**
* `json` — O JSON no qual o campo é pesquisado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser pesquisado. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna o número analisado do campo, se ele existir e contiver um número; caso contrário, `0` [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
0
4
0
3
5
```
## simpleJSONHas
Introduzido em: v21.4.0
Verifica se há um campo chamado `field_name`.
**Sintaxe**
```sql theme={null}
simpleJSONHas(json, field_name)
```
**Aliases**: `visitParamHas`
**Argumentos**
* `json` — O JSON em que o campo é pesquisado. [`String`](/pt-BR/reference/data-types/string)
* `field_name` — O nome do campo a ser pesquisado. [`const String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna `1` se o campo existir; caso contrário, `0` [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
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](/pt-BR/reference/data-types/int-uint) de 64 bits ou maiores (como `UInt64` ou `Int128`) são colocados entre aspas por padrão. [output\_format\_json\_quote\_64bit\_integers](/pt-BR/reference/settings/formats#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](/pt-BR/reference/settings/formats#output_format_json_quote_denormals) para exibi-los.
Ao serializar um valor [Enum](/pt-BR/reference/data-types/enum), a função retorna seu nome.
Veja também:
* [output\_format\_json\_quote\_64bit\_integers](/pt-BR/reference/settings/formats#output_format_json_quote_64bit_integers)
* [output\_format\_json\_quote\_denormals](/pt-BR/reference/settings/formats#output_format_json_quote_denormals)
**Sintaxe**
```sql theme={null}
toJSONString(value)
```
**Argumentos**
* `value` — Valor a ser serializado. O valor pode ser de qualquer tipo de dado. [`Any`](/pt-BR/reference/data-types)
**Valor retornado**
Retorna a representação JSON do valor. [`String`](/pt-BR/reference/data-types/string)
**Exemplos**
**Serialização de map**
```sql title=Query theme={null}
SELECT toJSONString(map('key1', 1, 'key2', 2));
```
```response title=Response theme={null}
┌─toJSONString(map('key1', 1, 'key2', 2))─┐
│ {"key1":1,"key2":2} │
└─────────────────────────────────────────┘
```
**Valores especiais**
```sql title=Query theme={null}
SELECT toJSONString(tuple(1.25, NULL, NaN, +inf, -inf, [])) SETTINGS output_format_json_quote_denormals = 1;
```
```response title=Response theme={null}
┌─toJSONString(tuple(1.25, NULL, NaN, plus(inf), minus(inf), []))─┐
│ [1.25,null,"nan","inf","-inf",[]] │
└─────────────────────────────────────────────────────────────────┘
```