> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentación sobre funciones JSON
# Funciones JSON
## Tipos de funciones JSON
Hay dos conjuntos de funciones para parsear JSON:
* [`simpleJSON*` (`visitParam*`)](#simplejson-visitparam-functions), diseñadas para parsear un subconjunto limitado de JSON con gran rapidez.
* [`JSONExtract*`](#jsonextract-functions), diseñadas para parsear JSON normal.
### funciones simpleJSON (visitParam)
ClickHouse tiene funciones especiales para trabajar con JSON simplificado. Todas estas funciones JSON se basan en suposiciones estrictas sobre cómo puede ser el JSON. Intentan hacer lo mínimo indispensable para realizar la tarea lo más rápido posible.
Se hacen las siguientes suposiciones:
1. El nombre del campo (argumento de la función) debe ser una constante.
2. El nombre del campo está codificado de forma canónica en JSON. Por ejemplo: `simpleJSONHas('{"abc":"def"}', 'abc') = 1`, pero `simpleJSONHas('{"\\u0061\\u0062\\u0063":"def"}', 'abc') = 0`
3. Los campos se buscan en cualquier nivel de anidamiento, sin distinción. Si hay varios campos coincidentes, se usa la primera aparición.
4. El JSON no tiene caracteres de espacio fuera de los literales de cadena.
Estas funciones se basan en [simdjson](https://github.com/lemire/simdjson) y están diseñadas para casos de análisis de JSON más complejos.
Estas funciones realizan coincidencia de claves ASCII sin distinción entre mayúsculas y minúsculas al extraer valores de objetos JSON.
Funcionan de forma idéntica a sus equivalentes sensibles a mayúsculas y minúsculas, salvo que las claves del objeto se comparan sin tener en cuenta las mayúsculas y minúsculas.
Cuando varias claves coinciden con distintas combinaciones de mayúsculas y minúsculas, se devuelve la primera coincidencia.
Estas funciones pueden tener un rendimiento inferior al de sus equivalentes sensibles a mayúsculas y minúsculas, así que use las funciones JSONExtract habituales siempre que sea posible.
{/*AUTOGENERATED_START*/}
## JSONAllPaths
Introducido en: v24.8.0
Devuelve la lista de todas las rutas almacenadas en cada fila de una columna JSON.
**Sintaxis**
```sql theme={null}
JSONAllPaths(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un array con todas las rutas de la columna JSON. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v24.8.0
Devuelve la lista de todas las rutas y los tipos de datos almacenados en cada fila de una columna JSON.
**Sintaxis**
```sql theme={null}
JSONAllPathsWithTypes(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un mapa con todas las rutas y sus tipos de datos de la columna JSON. [`Map(String, String)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo 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
Introducido en: v26.4.0
Devuelve todos los valores de cada fila de una columna JSON como un array de cadenas.
Los valores se serializan en su representación textual y se ordenan por sus nombres de ruta.
**Sintaxis**
```sql theme={null}
JSONAllValues(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un array con todos los valores de la columna JSON en forma de cadenas. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v23.2.0
Devuelve el número de elementos de la matriz JSON de nivel superior.
La función devuelve `NULL` si la cadena JSON de entrada no es válida.
**Sintaxis**
```sql theme={null}
JSONArrayLength(json)
```
**Alias**: `JSON_ARRAY_LENGTH`
**Argumentos**
* `json` — String con JSON válido. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de elementos del array si `json` es una cadena JSON válida que contiene un array; de lo contrario, devuelve `NULL`. [`Nullable(UInt64)`](/es/reference/data-types/nullable)
**Ejemplos**
**Ejemplo 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
Introducido en: v24.8.0
Devuelve la lista de rutas dinámicas almacenadas como subcolumnas independientes en la columna JSON.
**Sintaxis**
```sql theme={null}
JSONDynamicPaths(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un array de rutas dinámicas de la columna JSON. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v24.8.0
Devuelve la lista de rutas dinámicas almacenadas como subcolumnas independientes y sus tipos en cada fila de la columna JSON.
**Sintaxis**
```sql theme={null}
JSONDynamicPathsWithTypes(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un mapa de rutas dinámicas y sus tipos de datos en la columna JSON. [`Map(String, String)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo 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))'} │
└──────────────────────────────────────┴─────────────────────────────────┘
```
Introducido en: v19.14.0
Analiza JSON y extrae un valor del tipo de dato de ClickHouse especificado.
**Sintaxis**
```sql theme={null}
JSONExtract(json[, indices_or_keys, ...], return_type)
```
**Argumentos**
* `json` — Cadena JSON para analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
* `return_type` — Tipo de dato de ClickHouse que se va a devolver. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor del tipo de dato de ClickHouse especificado, si es posible; de lo contrario, devuelve el valor predeterminado de ese tipo.
**Ejemplos**
**Ejemplo 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]) │
└──────────────────────────────────┘
```
Introducido en: v20.1.0
Devuelve un array con los elementos de un array JSON, cada uno representado como una cadena sin analizar.
**Sintaxis**
```sql theme={null}
JSONExtractArrayRaw(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de cadenas con los elementos del array JSON. Si esa parte no es un array o no existe, se devuelve un array vacío. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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"'] │
└──────────────────────────────┘
```
Introducido en: v25.8.0
Devuelve un array con los elementos de un array JSON, cada uno representado como una cadena sin analizar, mediante coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractArrayRaw`](#JSONExtractArrayRaw).
**Sintaxis**
```sql theme={null}
JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para desplazarse por el array. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de cadenas JSON sin procesar. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractArrayRawCaseInsensitive('{"Items": [1, 2, 3]}', 'ITEMS')
```
```response title=Response theme={null}
['1','2','3']
```
Introducido en: v20.1.0
Analiza JSON y extrae un valor de tipo Bool.
**Sintaxis**
```sql theme={null}
JSONExtractBool(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor Bool si existe; de lo contrario, devuelve `0`. [`Bool`](/es/reference/data-types/boolean)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT JSONExtractBool('{"passed": true}', 'passed') AS res;
```
```response title=Response theme={null}
┌─res─┐
│ 1 │
└─────┘
```
Introducido en: v25.8.0
Analiza JSON y extrae un valor booleano mediante coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractBool`](#JSONExtractBool).
**Sintaxis**
```sql theme={null}
JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para llegar al campo. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el valor booleano extraído (1 para true, 0 para false), o 0 si no se encuentra. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractBoolCaseInsensitive('{"IsActive": true}', 'isactive')
```
```response title=Response theme={null}
1
```
Introducido en: v25.8.0
Analiza JSON y extrae un valor del tipo de dato de ClickHouse especificado mediante coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtract`](#JSONExtract).
**Sintaxis**
```sql theme={null}
JSONExtractCaseInsensitive(json [, indices_or_keys...], return_type)
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para navegar hasta el campo. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
* `return_type` — El tipo de dato de ClickHouse que se va a extraer [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor extraído en el tipo de dato especificado. [`Any`](/es/reference/data-types)
**Ejemplos**
**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]
```
Introducido en: v20.1.0
Analiza JSON y extrae un valor de tipo Float.
**Sintaxis**
```sql theme={null}
JSONExtractFloat(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor Float si existe; de lo contrario, devuelve `0`. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo 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 │
└─────┘
```
Introducido en: v25.8.0
Analiza JSON y extrae un valor de tipo Float mediante una coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractFloat`](#JSONExtractFloat).
**Sintaxis**
```sql theme={null}
JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para llegar al campo. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el valor Float extraído; 0 si no se encuentra o no se puede convertir. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractFloatCaseInsensitive('{"Price": 12.34}', 'PRICE')
```
```response title=Response theme={null}
12.34
```
Introducido en: v20.1.0
Analiza JSON y extrae un valor de tipo Int.
**Sintaxis**
```sql theme={null}
JSONExtractInt(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se debe analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor Int si existe; en caso contrario, devuelve `0`. [`Int64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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 │
└──────┘
```
Introducido en: v25.8.0
Analiza JSON y extrae un valor de tipo Int mediante coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractInt`](#JSONExtractInt).
**Sintaxis**
```sql theme={null}
JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para llegar al campo. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el valor Int extraído; 0 si no se encuentra o no se puede convertir. [`Int64`](/es/reference/data-types/int-uint)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractIntCaseInsensitive('{"Value": 123}', 'value')
```
```response title=Response theme={null}
123
```
**anidado**
```sql title=Query theme={null}
SELECT JSONExtractIntCaseInsensitive('{"DATA": {"COUNT": 42}}', 'data', 'Count')
```
```response title=Response theme={null}
42
```
Introducido en: v21.11.0
Analiza una cadena JSON y extrae las claves.
**Sintaxis**
```sql theme={null}
JSONExtractKeys(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON para analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array con las claves del objeto JSON. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v20.1.0
Analiza pares clave-valor de un JSON cuyos valores son del tipo de dato de ClickHouse especificado.
**Sintaxis**
```sql theme={null}
JSONExtractKeysAndValues(json[, indices_or_keys, ...], value_type)
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
* `value_type` — Tipo de dato de ClickHouse de los valores. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un array de tuplas con los pares clave-valor analizados. [`Array(Tuple(String, value_type))`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v25.8.0
Analiza pares clave-valor de JSON con coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractKeysAndValues`](#JSONExtractKeysAndValues).
**Sintaxis**
```sql theme={null}
JSONExtractKeysAndValuesCaseInsensitive(json [, indices_or_keys...], value_type)
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para acceder al objeto. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
* `value_type` — El tipo de dato de ClickHouse de los valores [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un array de tuplas que contienen pares clave-valor. [`Array(Tuple(String, T))`](/es/reference/data-types/array)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesCaseInsensitive('{"Name": "Alice", "AGE": 30}', 'String')
```
```response title=Response theme={null}
[('Name','Alice'),('AGE','30')]
```
## JSONExtractKeysAndValuesRaw
Introducido en: v20.4.0
Devuelve un array de tuplas con claves y valores de un objeto JSON. Todos los valores se representan como cadenas sin analizar.
**Sintaxis**
```sql theme={null}
JSONExtractKeysAndValuesRaw(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON para analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de tuplas con pares clave-valor analizados, donde los valores son cadenas sin analizar. [`Array(Tuple(String, String))`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v25.8.0
Extrae pares clave-valor sin procesar de JSON mediante coincidencia de claves sin distinguir entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractKeysAndValuesRaw`](#JSONExtractKeysAndValuesRaw).
**Sintaxis**
```sql theme={null}
JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para navegar por el objeto. Las claves usan coincidencia sin distinción entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de tuplas que contienen pares clave-valor como cadenas sin procesar. [`Array(Tuple(String, String))`](/es/reference/data-types/array)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesRawCaseInsensitive('{"Name": "Alice", "AGE": 30}')
```
```response title=Response theme={null}
[('Name','"Alice"'),('AGE','30')]
```
Introducido en: v25.8.0
Analiza una cadena JSON y extrae las claves usando coincidencia de claves sin distinción entre mayúsculas y minúsculas para acceder a objetos anidados. Esta función es similar a [`JSONExtractKeys`](#JSONExtractKeys).
**Sintaxis**
```sql theme={null}
JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para navegar hasta el objeto. Las claves se comparan sin distinguir entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de claves del objeto JSON. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractKeysCaseInsensitive('{"Name": "Alice", "AGE": 30}')
```
```response title=Response theme={null}
['Name','AGE']
```
**anidado**
```sql title=Query theme={null}
SELECT JSONExtractKeysCaseInsensitive('{"User": {"name": "John", "AGE": 25}}', 'user')
```
```response title=Response theme={null}
['name','AGE']
```
Introducido en: v20.1.0
Devuelve una parte del JSON como una cadena sin analizar.
**Sintaxis**
```sql theme={null}
JSONExtractRaw(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a parsear. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la parte del JSON como una cadena sin analizar. Si la parte no existe o tiene un tipo incorrecto, se devuelve una cadena vacía. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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] │
└──────────────────┘
```
Introducido en: v25.8.0
Devuelve una parte del JSON como una cadena sin analizar utilizando coincidencia de claves sin distinción entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractRaw`](#JSONExtractRaw).
**Sintaxis**
```sql theme={null}
JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para navegar hasta el campo. Las claves usan una coincidencia sin distinguir mayúsculas de minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la cadena JSON sin procesar del elemento extraído. [`String`](/es/reference/data-types/string)
**Ejemplos**
**objeto**
```sql title=Query theme={null}
SELECT JSONExtractRawCaseInsensitive('{"Object": {"key": "value"}}', 'OBJECT')
```
```response title=Response theme={null}
{"key":"value"}
```
Introducido en: v20.1.0
Analiza JSON y extrae un valor de tipo String.
**Sintaxis**
```sql theme={null}
JSONExtractString(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON para analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor de tipo String si existe; en caso contrario, devuelve una cadena vacía. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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 │
└───────┘
```
Introducido en: v25.8.0
Analiza JSON y extrae una cadena mediante coincidencia de claves sin distinguir entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractString`](#JSONExtractString).
**Sintaxis**
```sql theme={null}
JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para navegar hasta el campo. Las claves usan coincidencia sin distinguir entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el valor de cadena extraído; una cadena vacía si no se encuentra. [`String`](/es/reference/data-types/string)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractStringCaseInsensitive('{"ABC": "def"}', 'abc')
```
```response title=Response theme={null}
def
```
**anidado**
```sql title=Query theme={null}
SELECT JSONExtractStringCaseInsensitive('{"User": {"Name": "John"}}', 'user', 'name')
```
```response title=Response theme={null}
John
```
Introducido en: v20.1.0
Analiza JSON y extrae un valor de tipo UInt.
**Sintaxis**
```sql theme={null}
JSONExtractUInt(json [, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un valor UInt si existe; de lo contrario, devuelve `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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 │
└─────┘
```
Introducido en: v25.8.0
Analiza JSON y extrae un valor de tipo UInt mediante coincidencia de claves sin distinguir entre mayúsculas y minúsculas. Esta función es similar a [`JSONExtractUInt`](#JSONExtractUInt).
**Sintaxis**
```sql theme={null}
JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)
```
**Argumentos**
* `json` — Cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Opcional. Índices o claves para navegar hasta el campo. Las claves usan coincidencia sin distinguir entre mayúsculas y minúsculas [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el valor UInt extraído; 0 si no se encuentra o no se puede convertir. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT JSONExtractUIntCaseInsensitive('{"COUNT": 789}', 'count')
```
```response title=Response theme={null}
789
```
## JSONHas
Introducido en: v20.1.0
Comprueba si existen los valores proporcionados en el documento JSON.
**Sintaxis**
```sql theme={null}
JSONHas(json[ ,indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `[ ,indices_or_keys, ...]` — Una lista de cero o más argumentos. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve `1` si el valor existe en `json`; en caso contrario, `0` [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
Introducido en: v20.1.0
Devuelve la clave de un campo de un objeto JSON según su índice (a partir de 1). Si el JSON se pasa como una cadena, primero se parsea. El segundo argumento es una ruta JSON para navegar por objetos anidados. La función devuelve el nombre de la clave en la posición especificada.
**Sintaxis**
```sql theme={null}
JSONKey(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON que se va a analizar. [`String`](/es/reference/data-types/string)
* `indices_or_keys` — Lista opcional de índices o claves que especifican una ruta hacia un elemento anidado. Cada argumento puede ser una cadena (acceso por clave) o un entero (acceso por índice a partir de 1). [`String`](/es/reference/data-types/string) o [`Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el nombre de la clave en la posición especificada del objeto JSON. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT JSONKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1);
```
```response title=Response theme={null}
a
```
## JSONLength
Introducido en: v20.1.0
Devuelve la longitud de un array JSON o de un objeto JSON.
Si el valor no existe o no es del tipo correcto, se devolverá `0`.
**Sintaxis**
```sql theme={null}
JSONLength(json [, indices_or_keys, ...])
```
**Argumentos**
* `json` — Cadena JSON para analizar [`String`](/es/reference/data-types/string)
* `[, indices_or_keys, ...]` — Opcional. Una lista de cero o más argumentos. [`String`](/es/reference/data-types/string) o [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve la longitud de la matriz JSON o del objeto JSON; en caso contrario, devuelve `0` si el valor no existe o es de un tipo incorrecto. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
Introducido en: v23.10.0
Devuelve la cadena del objeto JSON resultante de fusionar varios objetos JSON.
**Sintaxis**
```sql theme={null}
JSONMergePatch(json1[, json2, ...])
```
**Aliases**: `jsonMergePatch`
**Argumentos**
* `json1[, json2, ...]` — Una o más cadenas con JSON válido. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la cadena del objeto JSON fusionado, si las cadenas de objetos JSON son válidas. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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
Introducido en: v24.8.0
Devuelve la lista de rutas almacenadas en la estructura de datos compartida de la columna JSON.
**Sintaxis**
```sql theme={null}
JSONSharedDataPaths(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un array de rutas almacenadas en la estructura de datos compartidos de la columna JSON. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 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
Introducido en: v24.8.0
Devuelve la lista de rutas almacenadas en la estructura de datos compartida y sus tipos en cada fila de la columna JSON.
**Sintaxis**
```sql theme={null}
JSONSharedDataPathsWithTypes(json)
```
**Argumentos**
* `json` — columna JSON. [`JSON`](/es/reference/data-types/newjson)
**Valor devuelto**
Devuelve un mapa con las rutas almacenadas en la estructura de datos compartida y sus tipos de datos en la columna JSON. [`Map(String, String)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo 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
Introducido en: v20.1.0
Devuelve el tipo de un valor JSON. Si el valor no existe, se devuelve `Null=0`.
**Sintaxis**
```sql theme={null}
JSONType(json[, indices_or_keys, ...])
```
**Argumentos**
* `json` — cadena JSON que se va a analizar [`String`](/es/reference/data-types/string)
* `json[, indices_or_keys, ...]` — Una lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. [`String`](/es/reference/data-types/string) o [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el tipo de un valor JSON como una cadena; si el valor no existe, devuelve `Null=0` [`Enum`](/es/reference/data-types/enum)
**Ejemplos**
**Ejemplo 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
Introducido en: v21.8.0
Si el valor existe en el documento JSON, se devuelve `1`.
Si el valor no existe, se devuelve `0`.
**Sintaxis**
```sql theme={null}
JSON_EXISTS(json, path)
```
**Argumentos**
* `json` — Una cadena con JSON válido. [`String`](/es/reference/data-types/string)
* `path` — Una cadena que representa la ruta. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si el valor existe en el documento JSON; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
Introducido en: v21.8.0
Analiza un JSON y extrae un valor como un array JSON o un objeto JSON.
Si el valor no existe, se devolverá una cadena vacía.
**Sintaxis**
```sql theme={null}
JSON_QUERY(json, path)
```
**Argumentos**
* `json` — Una cadena con JSON válido. [`String`](/es/reference/data-types/string)
* `path` — Una cadena que representa la ruta. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el array JSON o el objeto JSON extraído como una cadena, o una cadena vacía si el valor no existe. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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
Introducido en: v21.11.0
Analiza un JSON y extrae un valor como escalar JSON. Si el valor no existe, de forma predeterminada se devolverá una cadena vacía.
Esta función se controla con los siguientes ajustes:
* con SET `function_json_value_return_type_allow_nullable` = `true`, se devolverá `NULL`. Si el valor es de tipo complejo (como: struct, array, map), de forma predeterminada se devolverá una cadena vacía.
* con SET `function_json_value_return_type_allow_complex` = `true`, se devolverá el valor complejo.
**Sintaxis**
```sql theme={null}
JSON_VALUE(json, path)
```
**Argumentos**
* `json` — Una cadena con JSON válido. [`String`](/es/reference/data-types/string)
* `path` — Una cadena que representa la ruta. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor escalar JSON extraído como una cadena, o una cadena vacía si el valor no existe. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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
Introducido en: v24.1.0
Extrae una columna del tipo especificado a partir de una columna `Dynamic`.
Esta función permite extraer valores de un tipo específico de una columna `Dynamic`. Si una fila contiene un valor
del tipo solicitado, devuelve ese valor. Si la fila contiene un tipo distinto o NULL, devuelve NULL
para los tipos escalares o un array vacío para los tipos Array.
**Sintaxis**
```sql theme={null}
dynamicElement(dynamic, type_name)
```
**Argumentos**
* `dynamic` — Columna Dynamic de la que extraer. [`Dynamic`](/es/reference/data-types/dynamic)
* `type_name` — Nombre del tipo variante que se va a extraer (p. ej., 'String', 'Int64', 'Array(Int64)').
**Valor devuelto**
Devuelve valores del tipo especificado extraídos de la columna Dynamic. Devuelve NULL para los tipos que no coinciden (o un array vacío para los tipos de array). [`Any`](/es/reference/data-types)
**Ejemplos**
**Extracción de distintos tipos de una columna 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
Introducido en: v24.1.0
Devuelve el nombre del tipo variante para cada fila de una columna `Dynamic`.
Para las filas que contienen NULL, la función devuelve 'None'. Para todas las demás filas, devuelve el nombre del tipo de datos real
almacenado en esa fila de la columna Dynamic (p. ej., 'Int64', 'String', 'Array(Int64)').
**Sintaxis**
```sql theme={null}
dynamicType(dynamic)
```
**Argumentos**
* `dynamic` — columna Dynamic que se desea inspeccionar. [`Dynamic`](/es/reference/data-types/dynamic)
**Valor devuelto**
Devuelve el nombre del tipo del valor almacenado en cada fila, o 'None' para los valores NULL. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Inspección de tipos en una columna 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
Introducido en: v24.1.0
Devuelve true para las filas de una columna Dynamic que se almacenan en formato Variant compartido, en lugar de como subcolumnas separadas.
Cuando una columna Dynamic tiene un límite de `max_types`, los valores que superan ese límite se almacenan en un formato binario compartido
en lugar de separarse en subcolumnas tipadas individuales. Esta función identifica qué filas se almacenan en ese formato compartido.
**Sintaxis**
```sql theme={null}
isDynamicElementInSharedData(dynamic)
```
**Argumentos**
* `dynamic` — columna Dynamic que se va a inspeccionar. [`Dynamic`](/es/reference/data-types/dynamic)
**Valor devuelto**
Devuelve true si el valor se almacena en formato Variant compartido, y false si se almacena como una subcolumna independiente o es NULL. [`Bool`](/es/reference/data-types/boolean)
**Ejemplos**
**Comprobación del formato de almacenamiento en una columna Dynamic con el límite 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
Introducido en: v20.1.0
Comprueba que la cadena proporcionada sea un JSON válido.
**Sintaxis**
```sql theme={null}
isValidJSON(json)
```
**Argumentos**
* `json` — Cadena JSON que se debe validar [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la cadena es un JSON válido; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
```
**Uso de enteros para acceder tanto a arrays JSON como a 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
```
Introducido en: v21.4.0
Analiza un valor `true`/`false` a partir del valor del campo llamado `field_name`.
El resultado es `UInt8`.
**Sintaxis**
```sql theme={null}
simpleJSONExtractBool(json, field_name)
```
**Alias**: `visitParamExtractBool`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se busca. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si el valor del campo es `true`; `0` en caso contrario. Esto significa que esta función también devolverá `0` (y no solo) en los siguientes casos:
* Si el campo no existe.
* Si el campo contiene `true` como cadena, por ejemplo: `{"field":"true"}`.
* Si el campo contiene `1` como valor numérico. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
```
Introducido en: v21.4.0
Analiza un `Float64` a partir del valor del campo llamado `field_name`.
Si `field_name` es un campo de cadena, intenta analizar un número desde el inicio de la cadena.
Si el campo no existe, o existe pero no contiene un número, devuelve `0`.
**Sintaxis**
```sql theme={null}
simpleJSONExtractFloat(json, field_name)
```
**Alias**: `visitParamExtractFloat`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se busca. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número extraído del campo si este existe y contiene un número; de lo contrario, `0`. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo 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
```
Introducido en: v21.4.0
Extrae un `Int64` del valor del campo llamado `field_name`.
Si `field_name` es un campo de tipo cadena, intenta analizar un número desde el comienzo de la cadena.
Si el campo no existe, o existe pero no contiene un número, devuelve `0`.
**Sintaxis**
```sql theme={null}
simpleJSONExtractInt(json, field_name)
```
**Alias**: `visitParamExtractInt`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se debe buscar. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número extraído del campo si este existe y contiene un número; de lo contrario, `0` [`Int64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
```
Introducido en: v21.4.0
Devuelve el valor del campo `field_name` como un `String`, incluidos los separadores.
**Sintaxis**
```sql theme={null}
simpleJSONExtractRaw(json, field_name)
```
**Alias**: `visitParamExtractRaw`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se debe buscar. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor del campo como una cadena, incluidos los separadores si el campo existe; de lo contrario, devuelve una cadena vacía [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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]}
```
Introducido en: v21.4.0
Extrae un `String` entre comillas dobles del valor del campo llamado `field_name`.
**Detalles de implementación**
Actualmente no hay compatibilidad con puntos de código en el formato `\uXXXX\uYYYY` que no pertenezcan al plano multilingüe básico (se convierten a CESU-8 en lugar de UTF-8).
**Sintaxis**
```sql theme={null}
simpleJSONExtractString(json, field_name)
```
**Alias**: `visitParamExtractString`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se busca. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor de un campo como cadena, sin caracteres de escape e incluyendo los separadores. Se devuelve una cadena vacía si el campo no contiene una cadena entre comillas dobles, si falla la eliminación de escapes o si el campo no existe [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo 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
☺
```
Introducido en: v21.4.0
Extrae un `UInt64` del valor del campo llamado `field_name`.
Si `field_name` es un campo de tipo cadena, intenta analizar un número desde el inicio de la cadena.
Si el campo no existe, o existe pero no contiene un número, devuelve `0`.
**Sintaxis**
```sql theme={null}
simpleJSONExtractUInt(json, field_name)
```
**Alias**: `visitParamExtractUInt`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se debe buscar. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número extraído del campo si este existe y contiene un número; de lo contrario, `0` [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
Introducido en: v21.4.0
Comprueba si existe un campo llamado `field_name`.
**Sintaxis**
```sql theme={null}
simpleJSONHas(json, field_name)
```
**Alias**: `visitParamHas`
**Argumentos**
* `json` — El JSON en el que se busca el campo. [`String`](/es/reference/data-types/string)
* `field_name` — El nombre del campo que se busca. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si el campo existe y `0` en caso contrario [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo 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
Introducido en: v21.7.0
Serializa un valor en su representación JSON. Se admiten varios tipos de datos y estructuras anidadas.
Los [enteros](/es/reference/data-types/int-uint) de 64 bits o superiores (como `UInt64` o `Int128`) se encierran entre comillas de forma predeterminada. [output\_format\_json\_quote\_64bit\_integers](/es/reference/settings/formats#output_format_json_quote_64bit_integers) controla este comportamiento.
Los valores especiales `NaN` e `inf` se sustituyen por `null`. Active la configuración [output\_format\_json\_quote\_denormals](/es/reference/settings/formats#output_format_json_quote_denormals) para mostrarlos.
Al serializar un valor [Enum](/es/reference/data-types/enum), la función genera su nombre.
Véase también:
* [output\_format\_json\_quote\_64bit\_integers](/es/reference/settings/formats#output_format_json_quote_64bit_integers)
* [output\_format\_json\_quote\_denormals](/es/reference/settings/formats#output_format_json_quote_denormals)
**Sintaxis**
```sql theme={null}
toJSONString(value)
```
**Argumentos**
* `value` — Valor que se va a serializar. El valor puede ser de cualquier tipo de dato. [`Any`](/es/reference/data-types)
**Valor devuelto**
Devuelve la representación JSON del valor. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Serialización 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 especiales**
```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",[]] │
└─────────────────────────────────────────────────────────────────┘
```