Funciones JSON - ClickHouse Documentation

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

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:

El nombre del campo (argumento de la función) debe ser una constante.
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
Los campos se buscan en cualquier nivel de anidamiento, sin distinción. Si hay varios campos coincidentes, se usa la primera aparición.
El JSON no tiene caracteres de espacio fuera de los literales de cadena.

Funciones JSONExtract

Estas funciones se basan en simdjson y están diseñadas para casos de análisis de JSON más complejos.

Funciones JSONExtract sin distinción entre mayúsculas y minúsculas

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.

Sintaxis de JSONPath

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.

Operadores compatibles

Sintaxis	Descripción	Ejemplo
`$`	Elemento raíz. Toda ruta debe comenzar con él.	`$`
`.key`	Acceso a miembros mediante notación de punto sin comillas. La clave puede comenzar por números o estar compuesta únicamente por números.	`$.store.book`, `$.1key`, `$.123`
`."key"`	Acceso a miembros mediante notación de punto con comillas. Úsela para claves que contengan espacios o caracteres especiales. Se aceptan comillas dobles o acentos graves.	`$."foo bar"`
`[key]`	Acceso a miembros mediante notación de corchetes sin comillas.	`$[hello]`
`['key']`	Acceso a miembros mediante notación de corchetes con comillas. Se aceptan comillas simples, dobles o acentos graves.	`$['foo bar']`
`[n]`	Acceso a elementos de un Array por índice (basado en 0).	`$.items[0]`
`[n, m, ...]`	Acceso a varios elementos de un Array.	`$.items[0, 2, 4]`
`[n to m]`	Rango de elementos de un Array. El índice final `m` es exclusivo.	`$.items[0 to 3]`
`[*]`	Comodín que coincide con todos los elementos de un Array.	`$.items[*]`

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

Operadores no compatibles

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

Sintaxis	Descripción
`..`	Descenso recursivo.
`?(@.expr)`	Expresiones de filtro.
`[start:end:step]`	Notación de segmentos. Use `[n to m]` en su lugar.
`@`	Referencia al nodo actual.
`[-n]`	Índices negativos de Array (desde el final).
Expresiones de script	Expresiones aritméticas o de función dentro de una ruta.
`ON ERROR` / `ON EMPTY`	Cláusulas estándar de SQL/JSON para controlar el comportamiento ante errores y valores vacíos.

JSONAllPaths

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

Query

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

Response

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

JSONAllPathsWithTypes

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

Query

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

Response

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

JSONAllValues

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

Query

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

Response

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

JSONArrayLength

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

Query

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

Response

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

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

Query

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

Response

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

JSONDynamicPathsWithTypes

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

Query

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

Response

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

JSONExtract

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

Query

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

Response

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

JSONExtractArrayRaw

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

Query

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

Response

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

JSONExtractArrayRawCaseInsensitive

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

Query

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

Response

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

JSONExtractBool

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

Query

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

Response

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

JSONExtractBoolCaseInsensitive

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

Query

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

Response

JSONExtractCaseInsensitive

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

Query

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

Response

array_type

Query

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

Response

[1,2,3]

JSONExtractFloat

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

Query

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

Response

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

JSONExtractFloatCaseInsensitive

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

Query

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

Response

12.34

JSONExtractInt

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

Query

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

Response

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

JSONExtractIntCaseInsensitive

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

Query

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

Response

anidado

Query

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

Response

JSONExtractKeys

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

Query

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

Response

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

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

Query

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

Response

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

Query

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

Response

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

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

Query

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

Response

┌─res──────────────────────────────────┐
│ [('a','[-100,200]'),('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. 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

Query

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

Response

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

JSONExtractKeysCaseInsensitive

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

Query

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

Response

['Name','AGE']

anidado

Query

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

Response

['name','AGE']

JSONExtractRaw

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

Query

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

Response

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

JSONExtractRawCaseInsensitive

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

Query

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

Response

{"key":"value"}

JSONExtractString

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

Query

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

Response

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

JSONExtractStringCaseInsensitive

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

Query

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

Response

def

anidado

Query

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

Response

John

JSONExtractUInt

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

Query

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

Response

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

JSONExtractUIntCaseInsensitive

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

Query

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

Response

JSONHas

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

Query

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

Response

1
1

JSONKey

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

Query

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

Response

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

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

Query

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

Response

1
1

JSONMergePatch

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

Query

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

Response

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

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

Query

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

Response

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

JSONSharedDataPathsWithTypes

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

Query

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

Response

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

JSONType

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

Query

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

Response

1
1
1

JSON_EXISTS

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

Query

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

Response

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

JSON_QUERY

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

Query

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

Response

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

JSON_VALUE

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

Query

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

Response

world
0
2
\N

dynamicElement

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

Query

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

Response

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

dynamicType

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

Query

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

Response

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

isDynamicElementInSharedData

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

Query

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

Response

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

isValidJSON

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

Query

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

Response

1
1

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

Query

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

Response

prettyPrintJSON

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

Query

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

Response

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

Sangría personalizada

Query

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

Response

{\n        "a": 1\n}

simpleJSONExtractBool

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

Query

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

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

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

Response

simpleJSONExtractFloat

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

Query

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

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

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

Response

simpleJSONExtractInt

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

Query

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

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

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

Response

simpleJSONExtractRaw

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

Query

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

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

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

Response

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

simpleJSONExtractString

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

Query

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

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

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

Response

\n\0

☺

simpleJSONExtractUInt

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

Query

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

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

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

Response

simpleJSONHas

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

Query

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

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

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

Response

1
0

toJSONString

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 generan sin 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:

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

Query

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

Response

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

Valores especiales

Query

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

Response

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

​Tipos de funciones JSON

​funciones simpleJSON (visitParam)

​Funciones JSONExtract

​Funciones JSONExtract sin distinción entre mayúsculas y minúsculas

​Sintaxis de JSONPath

​Operadores compatibles

​Operadores no compatibles

​JSONAllPaths

​JSONAllPathsWithTypes

​JSONAllValues

​JSONArrayLength

​JSONDynamicPaths

​JSONDynamicPathsWithTypes

​JSONExtract

​JSONExtractArrayRaw

​JSONExtractArrayRawCaseInsensitive

​JSONExtractBool

​JSONExtractBoolCaseInsensitive

​JSONExtractCaseInsensitive

​JSONExtractFloat

​JSONExtractFloatCaseInsensitive

​JSONExtractInt

​JSONExtractIntCaseInsensitive

​JSONExtractKeys

​JSONExtractKeysAndValues

​JSONExtractKeysAndValuesCaseInsensitive

​JSONExtractKeysAndValuesRaw

​JSONExtractKeysAndValuesRawCaseInsensitive

​JSONExtractKeysCaseInsensitive

​JSONExtractRaw

​JSONExtractRawCaseInsensitive

​JSONExtractString

​JSONExtractStringCaseInsensitive

​JSONExtractUInt

​JSONExtractUIntCaseInsensitive

​JSONHas

​JSONKey

​JSONLength

​JSONMergePatch

​JSONSharedDataPaths

​JSONSharedDataPathsWithTypes

​JSONType

​JSON_EXISTS

​JSON_QUERY

​JSON_VALUE

​dynamicElement

​dynamicType

​isDynamicElementInSharedData

​isValidJSON

​prettyPrintJSON

​simpleJSONExtractBool

​simpleJSONExtractFloat

​simpleJSONExtractInt

​simpleJSONExtractRaw

​simpleJSONExtractString

​simpleJSONExtractUInt

​simpleJSONHas

​toJSONString

Tipos de funciones JSON

funciones simpleJSON (visitParam)

Funciones JSONExtract

Funciones JSONExtract sin distinción entre mayúsculas y minúsculas

Sintaxis de JSONPath

Operadores compatibles

Operadores no compatibles

JSONAllPaths

JSONAllPathsWithTypes

JSONAllValues

JSONArrayLength

JSONDynamicPaths

JSONDynamicPathsWithTypes

JSONExtract

JSONExtractArrayRaw

JSONExtractArrayRawCaseInsensitive

JSONExtractBool

JSONExtractBoolCaseInsensitive

JSONExtractCaseInsensitive

JSONExtractFloat

JSONExtractFloatCaseInsensitive

JSONExtractInt

JSONExtractIntCaseInsensitive

JSONExtractKeys

JSONExtractKeysAndValues

JSONExtractKeysAndValuesCaseInsensitive

JSONExtractKeysAndValuesRaw

JSONExtractKeysAndValuesRawCaseInsensitive

JSONExtractKeysCaseInsensitive

JSONExtractRaw

JSONExtractRawCaseInsensitive

JSONExtractString

JSONExtractStringCaseInsensitive

JSONExtractUInt

JSONExtractUIntCaseInsensitive

JSONHas

JSONKey

JSONLength

JSONMergePatch

JSONSharedDataPaths

JSONSharedDataPathsWithTypes

JSONType

JSON_EXISTS

JSON_QUERY

JSON_VALUE

dynamicElement

dynamicType

isDynamicElementInSharedData

isValidJSON

prettyPrintJSON

simpleJSONExtractBool

simpleJSONExtractFloat

simpleJSONExtractInt

simpleJSONExtractRaw

simpleJSONExtractString

simpleJSONExtractUInt

simpleJSONHas

toJSONString