Funciones JSON

Hay dos conjuntos de funciones para parsear JSON:

• simpleJSON* (visitParam*), diseñadas para parsear un subconjunto limitado de JSON con gran rapidez.
• JSONExtract*, diseñadas para parsear JSON normal.

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

Las funciones JSON_EXISTS, JSON_VALUE y JSON_QUERY aceptan una expresión JSONPath como segundo argumento. ClickHouse implementa un subconjunto limitado de JSONPath basado de forma general en el estándar SQL/JSON (ISO/IEC TR 19075-6), y deliberadamente más limitado que RFC 9535 y otras implementaciones populares. A continuación se enumeran los operadores compatibles.

La implementación de referencia se encuentra en src/Functions/JSONPath/Parsers.

Notas:

• Los índices y rangos se pueden combinar dentro del mismo par de corchetes (por ejemplo, [0 to 2, 4]).
• Los rangos de índices y el comodín no se pueden combinar dentro del mismo par de corchetes (por ejemplo, [* , 0] no es válido).
• En un rango [n to m], el inicio n debe ser estrictamente menor que el final m; de lo contrario, se genera una excepción.
• Un índice sin especificar un rango [n] es equivalente al rango [n to n+1].

Los siguientes operadores JSONPath, disponibles en RFC 9535 u otras implementaciones, no son compatibles con ClickHouse:

Introducido en: v24.8.0

Devuelve la lista de todas las rutas almacenadas en cada fila de una columna JSON.

Sintaxis

JSONAllPaths(json)

Argumentos

• json — columna JSON. JSON

Valor devuelto

Devuelve un array con todas las rutas de la columna JSON. Array(String)

Ejemplos

Ejemplo de uso

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

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

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

JSONAllPathsWithTypes(json)

Argumentos

• json — columna JSON. JSON

Valor devuelto

Devuelve un mapa con todas las rutas y sus tipos de datos de la columna JSON. Map(String, String)

Ejemplos

Ejemplo de uso

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

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

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

JSONAllValues(json)

Argumentos

• json — columna JSON. JSON

Valor devuelto

Devuelve un array con todos los valores de la columna JSON en forma de cadenas. Array(String)

Ejemplos

Ejemplo de uso

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

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

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

JSONArrayLength(json)

Alias: JSON_ARRAY_LENGTH

Argumentos

• json — String con JSON válido. 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)

Ejemplos

Ejemplo de uso

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

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

Introducido en: v24.8.0

Devuelve la lista de rutas dinámicas almacenadas como subcolumnas independientes en la columna JSON.

Sintaxis

JSONDynamicPaths(json)

Argumentos

• json — columna JSON. JSON

Valor devuelto

Devuelve un array de rutas dinámicas de la columna JSON. Array(String)

Ejemplos

Ejemplo de uso

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

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

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

JSONDynamicPathsWithTypes(json)

Argumentos

• json — columna JSON. JSON

Valor devuelto

Devuelve un mapa de rutas dinámicas y sus tipos de datos en la columna JSON. Map(String, String)

Ejemplos

Ejemplo de uso

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

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

Introducido en: v19.14.0

Analiza JSON y extrae un valor del tipo de dato de ClickHouse especificado.

Sintaxis

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

Argumentos

• json — Cadena JSON para analizar. 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 o (U)Int*
• return_type — Tipo de dato de ClickHouse que se va a devolver. 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

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

┌─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

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

Argumentos

• json — Cadena JSON que se va a analizar. 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 o (U)Int*

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)

Ejemplos

Ejemplo de uso

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

┌─res──────────────────────┐
│ ['-100','200','"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.

Sintaxis

JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON que se va a analizar 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 o (U)Int*

Valor devuelto

Devuelve un array de cadenas JSON sin procesar. Array(String)

Ejemplos

básico

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

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

Introducido en: v20.1.0

Analiza JSON y extrae un valor de tipo Bool.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar. 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 o (U)Int*

Valor devuelto

Devuelve un valor Bool si existe; de lo contrario, devuelve 0. Bool

Ejemplos

Ejemplo de uso

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

┌─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.

Sintaxis

JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON para analizar 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 o (U)Int*

Valor devuelto

Devuelve el valor booleano extraído (1 para true, 0 para false), o 0 si no se encuentra. UInt8

Ejemplos

básico

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

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.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar 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 o (U)Int*
• return_type — El tipo de dato de ClickHouse que se va a extraer String

Valor devuelto

Devuelve el valor extraído en el tipo de dato especificado. Any

Ejemplos

int_type

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

123

array_type

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

[1,2,3]

Introducido en: v20.1.0

Analiza JSON y extrae un valor de tipo Float.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar. 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 o (U)Int*

Valor devuelto

Devuelve un valor Float si existe; de lo contrario, devuelve 0. Float64

Ejemplos

Ejemplo de uso

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

┌─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.

Sintaxis

JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON para analizar 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 o (U)Int*

Valor devuelto

Devuelve el valor Float extraído; 0 si no se encuentra o no se puede convertir. Float64

Ejemplos

básico

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

12.34

Introducido en: v20.1.0

Analiza JSON y extrae un valor de tipo Int.

Sintaxis

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

Argumentos

• json — Cadena JSON que se debe analizar. 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 o (U)Int*

Valor devuelto

Devuelve un valor Int si existe; en caso contrario, devuelve 0. Int64

Ejemplos

Ejemplo de uso

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

┌──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.

Sintaxis

JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON para analizar 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 o (U)Int*

Valor devuelto

Devuelve el valor Int extraído; 0 si no se encuentra o no se puede convertir. Int64

Ejemplos

básico

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

123

anidado

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

42

Introducido en: v21.11.0

Analiza una cadena JSON y extrae las claves.

Sintaxis

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

Argumentos

• json — Cadena JSON para analizar. 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 o (U)Int*

Valor devuelto

Devuelve un array con las claves del objeto JSON. Array(String)

Ejemplos

Ejemplo de uso

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

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

Introducido en: v20.1.0

Analiza pares clave-valor de un JSON cuyos valores son del tipo de dato de ClickHouse especificado.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar. 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 o (U)Int*
• value_type — Tipo de dato de ClickHouse de los valores. String

Valor devuelto

Devuelve un array de tuplas con los pares clave-valor analizados. Array(Tuple(String, value_type))

Ejemplos

Ejemplo de uso

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

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

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.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar 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 o (U)Int*
• value_type — El tipo de dato de ClickHouse de los valores String

Valor devuelto

Devuelve un array de tuplas que contienen pares clave-valor. Array(Tuple(String, T))

Ejemplos

básico

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

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

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

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

Argumentos

• json — Cadena JSON para analizar. 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 o (U)Int*

Valor devuelto

Devuelve un array de tuplas con pares clave-valor analizados, donde los valores son cadenas sin analizar. Array(Tuple(String, String))

Ejemplos

Ejemplo de uso

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

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

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.

Sintaxis

JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — cadena JSON para analizar 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 o (U)Int*

Valor devuelto

Devuelve un array de tuplas que contienen pares clave-valor como cadenas sin procesar. Array(Tuple(String, String))

Ejemplos

básico

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

[('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.

Sintaxis

JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON para analizar 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 o (U)Int*

Valor devuelto

Devuelve un array de claves del objeto JSON. Array(String)

Ejemplos

básico

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

['Name','AGE']

anidado

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

['name','AGE']

Introducido en: v20.1.0

Devuelve una parte del JSON como una cadena sin analizar.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar. String
• indices_or_keys — Lista de cero o más argumentos, cada uno de los cuales puede ser una cadena o un entero. String o (U)Int*

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

Ejemplos

Ejemplo de uso

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

┌─res────────────┐
│ [-100,200,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.

Sintaxis

JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON que se va a analizar 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 o (U)Int*

Valor devuelto

Devuelve la cadena JSON sin procesar del elemento extraído. String

Ejemplos

objeto

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

{"key":"value"}

Introducido en: v20.1.0

Analiza JSON y extrae un valor de tipo String.

Sintaxis

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

Argumentos

• json — Cadena JSON para analizar. 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 o (U)Int*

Valor devuelto

Devuelve un valor de tipo String si existe; en caso contrario, devuelve una cadena vacía. String

Ejemplos

Ejemplo de uso

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

┌─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.

Sintaxis

JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON que se va a analizar 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 o (U)Int*

Valor devuelto

Devuelve el valor de cadena extraído; una cadena vacía si no se encuentra. String

Ejemplos

básico

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

def

anidado

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

John

Introducido en: v20.1.0

Analiza JSON y extrae un valor de tipo UInt.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar. 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 o (U)Int*

Valor devuelto

Devuelve un valor UInt si existe; de lo contrario, devuelve 0. UInt64

Ejemplos

Ejemplo de uso

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

┌─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.

Sintaxis

JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)

Argumentos

• json — Cadena JSON para analizar 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 o (U)Int*

Valor devuelto

Devuelve el valor UInt extraído; 0 si no se encuentra o no se puede convertir. UInt64

Ejemplos

básico

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

789

Introducido en: v20.1.0

Comprueba si existen los valores proporcionados en el documento JSON.

Sintaxis

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

Argumentos

• json — Cadena JSON que se va a analizar String
• [ ,indices_or_keys, ...] — Una lista de cero o más argumentos. String o (U)Int*

Valor devuelto

Devuelve 1 si el valor existe en json; en caso contrario, 0 UInt8

Ejemplos

Ejemplo de uso

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

1
1

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

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

Argumentos

• json — Cadena JSON que se va a analizar. 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 o Int*

Valor devuelto

Devuelve el nombre de la clave en la posición especificada del objeto JSON. String

Ejemplos

Ejemplo de uso

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

a

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

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

Argumentos

• json — Cadena JSON para analizar String
• [, indices_or_keys, ...] — Opcional. Una lista de cero o más argumentos. String o (U)Int8/16/32/64

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

Ejemplos

Ejemplo de uso

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

1
1

Introducido en: v23.10.0

Devuelve la cadena del objeto JSON resultante de fusionar varios objetos JSON.

Sintaxis

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

Aliases: jsonMergePatch

Argumentos

• json1[, json2, ...] — Una o más cadenas con JSON válido. String

Valor devuelto

Devuelve la cadena del objeto JSON fusionado, si las cadenas de objetos JSON son válidas. String

Ejemplos

Ejemplo de uso

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

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

Introducido en: v24.8.0

Devuelve la lista de rutas almacenadas en la estructura de datos compartida de la columna JSON.

Sintaxis

JSONSharedDataPaths(json)

Argumentos

• json — columna JSON. JSON

Valor devuelto

Devuelve un array de rutas almacenadas en la estructura de datos compartida de la columna JSON. Array(String)

Ejemplos

Ejemplo de uso

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

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

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

JSONSharedDataPathsWithTypes(json)

Argumentos

• json — columna JSON. JSON

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)

Ejemplos

Ejemplo de uso

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

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

Introducido en: v20.1.0

Devuelve el tipo de un valor JSON. Si el valor no existe, se devuelve Null=0.

Sintaxis

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

Argumentos

• json — cadena JSON que se va a analizar 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 o (U)Int8/16/32/64

Valor devuelto

Devuelve el tipo de un valor JSON como una cadena; si el valor no existe, devuelve Null=0 Enum

Ejemplos

Ejemplo de uso

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

1
1
1

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

JSON_EXISTS(json, path)

Argumentos

• json — Una cadena con JSON válido. String
• path — Una cadena que representa la ruta. String

Valor devuelto

Devuelve 1 si el valor existe en el documento JSON; en caso contrario, 0. UInt8

Ejemplos

Ejemplo de uso

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

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

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

JSON_QUERY(json, path)

Argumentos

• json — Una cadena con JSON válido. String
• path — Una cadena que representa la ruta. 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

Ejemplos

Ejemplo de uso

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

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

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

JSON_VALUE(json, path)

Argumentos

• json — Una cadena con JSON válido. String
• path — Una cadena que representa la ruta. String

Valor devuelto

Devuelve el valor escalar JSON extraído como una cadena, o una cadena vacía si el valor no existe. String

Ejemplos

Ejemplo de uso

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

world
0
2
\N

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

dynamicElement(dynamic, type_name)

Argumentos

• dynamic — Columna Dynamic de la que extraer. 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

Ejemplos

Extracción de distintos tipos de una columna Dynamic

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

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

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

dynamicType(dynamic)

Argumentos

• dynamic — columna Dynamic que se desea inspeccionar. Dynamic

Valor devuelto

Devuelve el nombre del tipo del valor almacenado en cada fila, o 'None' para los valores NULL. String

Ejemplos

Inspección de tipos en una columna Dynamic

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

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

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

isDynamicElementInSharedData(dynamic)

Argumentos

• dynamic — columna Dynamic que se va a inspeccionar. 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

Ejemplos

Comprobación del formato de almacenamiento en una columna Dynamic con el límite max_types

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

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

Introducido en: v20.1.0

Comprueba que la cadena proporcionada sea un JSON válido.

Sintaxis

isValidJSON(json)

Argumentos

• json — Cadena JSON que se debe validar String

Valor devuelto

Devuelve 1 si la cadena es un JSON válido; en caso contrario, 0. UInt8

Ejemplos

Ejemplo de uso

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

1
1

Uso de enteros para acceder tanto a arrays JSON como a objetos JSON

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

0
1
1
1
1
0

Introducido en: v26.4.0

Devuelve una versión con formato legible de una cadena JSON, con saltos de línea y sangría con espacios.

Sintaxis

prettyPrintJSON(json [, indent])

Argumentos

• json — Una cadena JSON válida a la que dar formato. String
• indent — Número de espacios por nivel de sangría. Predeterminado: 4. Máx.: 32 UInt*

Valor devuelto

Una cadena JSON con formato legible. String

Ejemplos

Objeto simple

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

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

Sangría personalizada

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

{\n        "a": 1\n}

Introducido en: v21.4.0

Analiza un valor true/false a partir del valor del campo llamado field_name. El resultado es UInt8.

Sintaxis

simpleJSONExtractBool(json, field_name)

Alias: visitParamExtractBool

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se busca. const 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

Ejemplos

Ejemplo de uso

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

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

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

0
1
0
0

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

simpleJSONExtractFloat(json, field_name)

Alias: visitParamExtractFloat

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se busca. const String

Valor devuelto

Devuelve el número extraído del campo si este existe y contiene un número; de lo contrario, 0. Float64

Ejemplos

Ejemplo de uso

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

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

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

0
-4000
0
-3.4
5

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

simpleJSONExtractInt(json, field_name)

Alias: visitParamExtractInt

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se debe buscar. const String

Valor devuelto

Devuelve el número extraído del campo si este existe y contiene un número; de lo contrario, 0 Int64

Ejemplos

Ejemplo de uso

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

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

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

0
-4
0
-3
5

Introducido en: v21.4.0

Devuelve el valor del campo field_name como un String, incluidos los separadores.

Sintaxis

simpleJSONExtractRaw(json, field_name)

Alias: visitParamExtractRaw

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se debe buscar. const 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

Ejemplos

Ejemplo de uso

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

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

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

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

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

simpleJSONExtractString(json, field_name)

Alias: visitParamExtractString

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se busca. const 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

Ejemplos

Ejemplo de uso

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

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

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

\n\0

☺

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

simpleJSONExtractUInt(json, field_name)

Alias: visitParamExtractUInt

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se debe buscar. const String

Valor devuelto

Devuelve el número extraído del campo si este existe y contiene un número; de lo contrario, 0 UInt64

Ejemplos

Ejemplo de uso

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

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

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

0
4
0
3
5

Introducido en: v21.4.0

Comprueba si existe un campo llamado field_name.

Sintaxis

simpleJSONHas(json, field_name)

Alias: visitParamHas

Argumentos

• json — El JSON en el que se busca el campo. String
• field_name — El nombre del campo que se busca. const String

Valor devuelto

Devuelve 1 si el campo existe y 0 en caso contrario UInt8

Ejemplos

Ejemplo de uso

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

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

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

1
0

Introducido en: v21.7.0

Serializa un valor en su representación JSON. Se admiten varios tipos de datos y estructuras anidadas. Los enteros de 64 bits o superiores (como UInt64 o Int128) se encierran entre comillas de forma predeterminada. 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 para mostrarlos. Al serializar un valor Enum, la función genera su nombre.

Véase también:

• output_format_json_quote_64bit_integers
• output_format_json_quote_denormals

Sintaxis

toJSONString(value)

Argumentos

• value — Valor que se va a serializar. El valor puede ser de cualquier tipo de dato. Any

Valor devuelto

Devuelve la representación JSON del valor. String

Ejemplos

Serialización de Map

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

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

Valores especiales

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

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