Il existe deux familles de fonctions pour analyser du JSON :
Fonctions simpleJSON (visitParam)
- Le nom du champ (argument de la fonction) doit être une constante.
- Le nom du champ est encodé sous une forme canonique dans le JSON. Par exemple :
simpleJSONHas('{"abc":"def"}', 'abc') = 1, mais simpleJSONHas('{"\\u0061\\u0062\\u0063":"def"}', 'abc') = 0
- Les champs sont recherchés à n’importe quel niveau d’imbrication, sans distinction. S’il existe plusieurs champs correspondants, la première occurrence est utilisée.
- Le JSON ne contient pas d’espaces en dehors des littéraux de chaîne.
Ces fonctions reposent sur simdjson et sont conçues pour répondre à des besoins plus complexes en matière d’analyse syntaxique du JSON.
Ces fonctions effectuent une correspondance de clés ASCII insensible à la casse lors de l’extraction de valeurs depuis des objets JSON.
Elles fonctionnent de manière identique à leurs équivalents sensibles à la casse, à ceci près que les clés des objets sont mises en correspondance sans tenir compte de la casse.
Lorsque plusieurs clés correspondent avec des casses différentes, la première correspondance est renvoyée.
Ces fonctions peuvent être moins performantes que leurs équivalents sensibles à la casse. Utilisez donc les fonctions JSONExtract standard si possible.
json — colonne JSON. JSON
Valeur renvoyée
Renvoie un tableau contenant tous les chemins de la colonne JSON. Array(String)
Exemples
Exemple d’utilisation
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'] │
└──────────────────────────────────────┴────────────────────┘
JSONAllPathsWithTypes(json)
json — colonne JSON. JSON
Valeur renvoyée
Renvoie une map de tous les chemins et de leurs types de données dans la colonne JSON. Map(String, String)
Exemples
Exemple d’utilisation
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'} │
└──────────────────────────────────────┴───────────────────────────────────────────┘
json — colonne JSON. JSON
Valeur renvoyée
Renvoie un tableau de toutes les valeurs de la colonne JSON sous forme de chaînes de caractères. Array(String)
Exemples
Exemple d’utilisation
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'] │
└──────────────────────────────────────┴──────────────────────────┘
NULL si la chaîne JSON d’entrée n’est pas valide.
Syntaxe
Alias : JSON_ARRAY_LENGTH
Arguments
json — Chaîne contenant un JSON valide. String
Valeur renvoyée
Renvoie le nombre d’éléments du tableau si json est une chaîne JSON représentant un tableau valide ; sinon, renvoie NULL. Nullable(UInt64)
Exemples
Exemple d’utilisation
SELECT
JSONArrayLength(''),
JSONArrayLength('[1,2,3]');
┌─JSONArrayLength('')─┬─JSONArrayLength('[1,2,3]')─┐
│ ᴺᵁᴸᴸ │ 3 │
└─────────────────────┴────────────────────────────┘
json — colonne JSON. JSON
Valeur renvoyée
Renvoie un tableau de chemins dynamiques dans la colonne JSON. Array(String)
Exemples
Exemple d’utilisation
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'] │
└──────────────────────────────────────┴────────────────────────┘
JSONDynamicPathsWithTypes
JSONDynamicPathsWithTypes(json)
json — colonne JSON. JSON
Valeur renvoyée
Renvoie une map des chemins dynamiques et de leurs types de données dans la colonne JSON. Map(String, String)
Exemples
Exemple d’utilisation
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))'} │
└──────────────────────────────────────┴─────────────────────────────────┘
JSONExtract(json[, indices_or_keys, ...], return_type)
json — Chaîne JSON à analyser. Stringindices_or_keys — Une liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. String ou (U)Int*return_type — Type de données ClickHouse à renvoyer. String
Valeur renvoyée
Renvoie une valeur du type de données ClickHouse spécifié si possible ; sinon, renvoie la valeur par défaut de ce type.
Exemples
Exemple d’utilisation
SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(String, Array(Float64))') AS res;
┌─res──────────────────────────────┐
│ ('hello',[-100,200,300]) │
└──────────────────────────────────┘
JSONExtractArrayRaw(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. String ou (U)Int*
Valeur renvoyée
Renvoie un tableau de chaînes contenant les éléments du tableau JSON. Si la partie extraite n’est pas un tableau ou n’existe pas, un tableau vide est renvoyé. Array(String)
Exemples
Exemple d’utilisation
SELECT JSONExtractArrayRaw('{"a": "hello", "b": [-100, 200.0, "hello"]}', 'b') AS res;
┌─res──────────────────────────┐
│ ['-100','200.0','"hello"'] │
└──────────────────────────────┘
JSONExtractArrayRaw.
Syntaxe
JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés pour accéder au tableau. Les clés ne tiennent pas compte de la casse String ou (U)Int*
Valeur renvoyée
Renvoie un tableau de chaînes JSON brutes. Array(String)
Exemples
simple
SELECT JSONExtractArrayRawCaseInsensitive('{"Items": [1, 2, 3]}', 'ITEMS')
JSONExtractBool(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. String ou (U)Int*
Valeur renvoyée
Renvoie une valeur Bool si elle existe, sinon 0. Bool
Exemples
Exemple d’utilisation
SELECT JSONExtractBool('{"passed": true}', 'passed') AS res;
JSONExtractBool.
Syntaxe
JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés permettant d’accéder au champ. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*
Valeur renvoyée
Renvoie la valeur booléenne extraite (1 pour true, 0 pour false), ou 0 si elle n’est pas trouvée. UInt8
Exemples
basique
SELECT JSONExtractBoolCaseInsensitive('{"IsActive": true}', 'isactive')
JSONExtract.
Syntaxe
JSONExtractCaseInsensitive(json [, indices_or_keys...], return_type)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés pour accéder au champ. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*return_type — Type de données ClickHouse à extraire String
Valeur renvoyée
Renvoie la valeur extraite dans le type de données spécifié. Any
Exemples
int_type
SELECT JSONExtractCaseInsensitive('{"Number": 123}', 'number', 'Int32')
SELECT JSONExtractCaseInsensitive('{"List": [1, 2, 3]}', 'list', 'Array(Int32)')
JSONExtractFloat(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Une liste de zéro ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. String ou (U)Int*
Valeur renvoyée
Renvoie une valeur Float si elle existe, sinon 0. Float64
Exemples
Exemple d’utilisation
SELECT JSONExtractFloat('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 2) AS res;
JSONExtractFloat.
Syntaxe
JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)
json — chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés permettant d’accéder au champ. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*
Valeur renvoyée
Renvoie la valeur Float extraite, ou 0 si elle est introuvable ou ne peut pas être convertie. Float64
Exemples
de base
SELECT JSONExtractFloatCaseInsensitive('{"Price": 12.34}', 'PRICE')
JSONExtractInt(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. String ou (U)Int*
Valeur renvoyée
Renvoie une valeur de type Int si elle existe, sinon 0. Int64
Exemples
Exemple d’utilisation
SELECT JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) AS res;
┌──res─┐
│ -100 │
└──────┘
JSONExtractInt.
Syntaxe
JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés permettant d’accéder au champ. Les clés ne tiennent pas compte de la casse String ou (U)Int*
Valeur renvoyée
Renvoie la valeur Int extraite, ou 0 si elle est introuvable ou ne peut pas être convertie. Int64
Exemples
simple
SELECT JSONExtractIntCaseInsensitive('{"Value": 123}', 'value')
SELECT JSONExtractIntCaseInsensitive('{"DATA": {"COUNT": 42}}', 'data', 'Count')
JSONExtractKeys(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. String ou (U)Int*
Valeur renvoyée
Renvoie un tableau contenant les clés de l’objet JSON. Array(String)
Exemples
Exemple d’utilisation
SELECT JSONExtractKeys('{"a": "hello", "b": [-100, 200.0, 300]}') AS res;
┌─res─────────┐
│ ['a','b'] │
└─────────────┘
JSONExtractKeysAndValues(json[, indices_or_keys, ...], value_type)
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. String ou (U)Int*value_type — Type de données ClickHouse des valeurs. String
Valeur renvoyée
Renvoie un tableau de tuples contenant les paires clé-valeur analysées. Array(Tuple(String, value_type))
Exemples
Exemple d’utilisation
SELECT JSONExtractKeysAndValues('{"x": {"a": 5, "b": 7, "c": 11}}', 'Int8', 'x') AS res;
┌─res────────────────────┐
│ [('a',5),('b',7),('c',11)] │
└────────────────────────┘
JSONExtractKeysAndValuesCaseInsensitive
JSONExtractKeysAndValues.
Syntaxe
JSONExtractKeysAndValuesCaseInsensitive(json [, indices_or_keys...], value_type)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés pour accéder à l’objet. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*value_type — Le type de données ClickHouse des valeurs String
Valeur renvoyée
Renvoie un tableau de tuples contenant des paires clé-valeur. Array(Tuple(String, T))
Exemples
simple
SELECT JSONExtractKeysAndValuesCaseInsensitive('{"Name": "Alice", "AGE": 30}', 'String')
[('Name','Alice'),('AGE','30')]
JSONExtractKeysAndValuesRaw
JSONExtractKeysAndValuesRaw(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Une liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. String ou (U)Int*
Valeur renvoyée
Renvoie un tableau de tuples contenant des paires clé-valeur analysées, où les valeurs sont des chaînes non analysées. Array(Tuple(String, String))
Exemples
Exemple d’utilisation
SELECT JSONExtractKeysAndValuesRaw('{"a": [-100, 200.0], "b": "hello"}') AS res;
┌─res──────────────────────────────────┐
│ [('a','[-100,200.0]'),('b','"hello"')] │
└──────────────────────────────────────┘
JSONExtractKeysAndValuesRawCaseInsensitive
JSONExtractKeysAndValuesRaw.
Syntaxe
JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)
json — chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés pour naviguer jusqu’à l’objet. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*
Valeur renvoyée
Renvoie un tableau de tuples contenant des paires clé-valeur sous forme de chaînes brutes. Array(Tuple(String, String))
Exemples
de base
SELECT JSONExtractKeysAndValuesRawCaseInsensitive('{"Name": "Alice", "AGE": 30}')
[('Name','"Alice"'),('AGE','30')]
JSONExtractKeys.
Syntaxe
JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés permettant d’accéder à l’objet. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*
Valeur renvoyée
Renvoie un tableau de clés de l’objet JSON. Array(String)
Exemples
de base
SELECT JSONExtractKeysCaseInsensitive('{"Name": "Alice", "AGE": 30}')
SELECT JSONExtractKeysCaseInsensitive('{"User": {"name": "John", "AGE": 25}}', 'user')
JSONExtractRaw(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Une liste d’arguments, éventuellement vide, dont chacun peut être soit une chaîne, soit un entier. String ou (U)Int*
Valeur renvoyée
Renvoie la partie du JSON sous forme de chaîne non analysée. Si cette partie n’existe pas ou si son type est incorrect, une chaîne vide est renvoyée. String
Exemples
Exemple d’utilisation
SELECT JSONExtractRaw('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') AS res;
┌─res──────────────┐
│ [-100,200.0,300] │
└──────────────────┘
JSONExtractRaw.
Syntaxe
JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés permettant d’accéder au champ. Les clés sont mises en correspondance sans tenir compte de la casse String ou (U)Int*
Valeur renvoyée
Renvoie la chaîne JSON brute de l’élément extrait. String
Exemples
objet
SELECT JSONExtractRawCaseInsensitive('{"Object": {"key": "value"}}', 'OBJECT')
JSONExtractString(json[, indices_or_keys, ...])
json — chaîne JSON à analyser. Stringindices_or_keys — Une liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. String ou (U)Int*
Valeur renvoyée
Renvoie une valeur de type String si elle existe, sinon une chaîne vide. String
Exemples
Exemple d’utilisation
SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') AS res;
┌─res───┐
│ hello │
└───────┘
JSONExtractString.
Syntaxe
JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)
json — Chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés permettant d’accéder au champ. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*
Valeur renvoyée
Renvoie la valeur de chaîne extraite, ou une chaîne vide si elle est introuvable. String
Exemples
de base
SELECT JSONExtractStringCaseInsensitive('{"ABC": "def"}', 'abc')
SELECT JSONExtractStringCaseInsensitive('{"User": {"Name": "John"}}', 'user', 'name')
JSONExtractUInt(json [, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. String ou (U)Int*
Valeur renvoyée
Renvoie une valeur UInt si elle existe, sinon 0. UInt64
Exemples
Exemple d’utilisation
SELECT JSONExtractUInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', -1) AS res;
JSONExtractUInt.
Syntaxe
JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)
json — chaîne JSON à analyser Stringindices_or_keys — Facultatif. Indices ou clés pour accéder au champ. Les clés utilisent une correspondance insensible à la casse String ou (U)Int*
Valeur renvoyée
Renvoie la valeur UInt extraite, 0 si elle est introuvable ou ne peut pas être convertie. UInt64
Exemples
de base
SELECT JSONExtractUIntCaseInsensitive('{"COUNT": 789}', 'count')
JSONHas(json[ ,indices_or_keys, ...])
json — Chaîne JSON à analyser String[ ,indices_or_keys, ...] — Une liste de zéro ou plusieurs arguments. String ou (U)Int*
Valeur renvoyée
Renvoie 1 si la valeur existe dans json, sinon 0 UInt8
Exemples
Exemple d’utilisation
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 1;
SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 4) = 0;
JSONKey(json[, indices_or_keys, ...])
json — Chaîne JSON à analyser. Stringindices_or_keys — Liste facultative d’indices ou de clés spécifiant un chemin d’accès vers un élément imbriqué. Chaque argument peut être soit une chaîne (accès par clé), soit un entier (accès par indice à partir de 1). String ou Int*
Valeur renvoyée
Renvoie le nom de la clé à la position spécifiée dans l’objet JSON. String
Exemples
Exemple d’utilisation
SELECT JSONKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1);
0 est renvoyé.
Syntaxe
JSONLength(json [, indices_or_keys, ...])
0 si la valeur n’existe pas ou si elle est du mauvais type. UInt64
Exemples
Exemple d’utilisation
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 3;
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}') = 2;
JSONMergePatch(json1[, json2, ...])
jsonMergePatch
Arguments
json1[, json2, ...] — Une ou plusieurs chaînes contenant du JSON valide. String
Valeur renvoyée
Renvoie la chaîne correspondant à l’objet JSON fusionné, si les chaînes d’objets JSON sont valides. String
Exemples
Exemple d’utilisation
SELECT JSONMergePatch('{"a":1}', '{"name": "joey"}', '{"name": "tom"}', '{"name": "zoey"}') AS res;
┌─res───────────────────┐
│ {"a":1,"name":"zoey"} │
└───────────────────────┘
JSONSharedDataPaths(json)
json — colonne JSON. JSON
Valeur renvoyée
Renvoie un tableau des chemins stockés dans la structure de données partagée de la colonne JSON. Array(String)
Exemples
Exemple d’utilisation
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'] │
└──────────────────────────────────────┴───────────────────────────┘
JSONSharedDataPathsWithTypes
JSONSharedDataPathsWithTypes(json)
json — colonne JSON. JSON
Valeur renvoyée
Renvoie une map des chemins stockés dans la structure de données partagées ainsi que de leurs types de données dans la colonne JSON. Map(String, String)
Exemples
Exemple d’utilisation
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'} │
└──────────────────────────────────────┴─────────────────────────────────────┘
Null=0 est renvoyé.
Syntaxe
JSONType(json[, indices_or_keys, ...])
json — chaîne JSON à analyser Stringjson[, indices_or_keys, ...] — Liste de zéro argument ou plus, chacun pouvant être une chaîne ou un entier. String ou (U)Int8/16/32/64
Valeur renvoyée
Renvoie le type d’une valeur JSON sous forme de chaîne ; si la valeur n’existe pas, renvoie Null=0 Enum
Exemples
Exemple d’utilisation
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 est renvoyé.
Si la valeur n’existe pas, 0 est renvoyé.
Syntaxe
Arguments
json — Une chaîne contenant un JSON valide. Stringpath — Une chaîne représentant le chemin. String
Valeur renvoyée
Renvoie 1 si la valeur existe dans le document JSON, sinon 0. UInt8
Exemples
Exemple d’utilisation
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 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯llo.world')─┐
│ 1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[*]')─┐
│ 1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[0]')─┐
│ 1 │
└──────────────────────────┘
json — Une chaîne contenant du JSON valide. Stringpath — Une chaîne représentant le chemin. String
Valeur renvoyée
Renvoie le tableau JSON ou l’objet JSON extraits sous forme de chaîne, ou une chaîne vide si la valeur n’existe pas. String
Exemples
Exemple d’utilisation
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
- avec SET
function_json_value_return_type_allow_nullable = true, NULL est renvoyé. Si la valeur est d’un type complexe (comme : struct, array, map), une chaîne vide est renvoyée par défaut.
- avec SET
function_json_value_return_type_allow_complex = true, la valeur complexe est renvoyée.
Syntaxe
Arguments
json — Une chaîne contenant un JSON valide. Stringpath — Une chaîne représentant le chemin. String
Valeur renvoyée
Renvoie le scalaire JSON extrait sous forme de chaîne, ou une chaîne vide si la valeur n’existe pas. String
Exemples
Exemple d’utilisation
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;
Dynamic.
Cette fonction permet d’extraire des valeurs d’un type spécifique depuis une colonne Dynamic. Si une ligne contient une valeur
du type demandé, elle renvoie cette valeur. Si la ligne contient une valeur d’un autre type ou NULL, elle renvoie NULL
pour les types scalaires ou un tableau vide pour les types Array.
Syntaxe
dynamicElement(dynamic, type_name)
dynamic — Colonne Dynamic à partir de laquelle effectuer l’extraction. Dynamictype_name — Nom du type de variante à extraire (par ex., ‘String’, ‘Int64’, ‘Array(Int64)’).
Valeur renvoyée
Renvoie les valeurs du type spécifié à partir de la colonne Dynamic. Renvoie NULL pour les types qui ne correspondent pas (ou un tableau vide pour les types Array). Any
Exemples
Extraction de différents types à partir d’une colonne 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] │ ᴺᵁᴸᴸ │ [] │
└───────────────┴────────────────┴─────────────────────────────┴────────────────────────────┴───────────────────────────────────┴───────────────────────────┴────────────────────────────────────┘
Dynamic.
Pour les lignes contenant NULL, la fonction renvoie ‘None’. Pour toutes les autres lignes, elle renvoie le type de données réel
stocké dans la ligne correspondante de la colonne Dynamic (par ex., ‘Int64’, ‘String’, ‘Array(Int64)’).
Syntaxe
Arguments
dynamic — colonne Dynamic à examiner. Dynamic
Valeur renvoyée
Renvoie le nom du type de la valeur stockée dans chaque ligne, ou ‘None’ pour les valeurs NULL. String
Exemples
Vérification des types dans une colonne 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) │
└───────────────┴────────────────┘
isDynamicElementInSharedData
max_types, les valeurs qui dépassent cette limite sont stockées dans un format binaire partagé
au lieu d’être séparées dans des sous-colonnes typées individuelles. Cette fonction permet d’identifier les lignes stockées dans ce format partagé.
Syntaxe
isDynamicElementInSharedData(dynamic)
dynamic — colonne Dynamic à inspecter. Dynamic
Valeur renvoyée
Renvoie true si la valeur est stockée au format de variante partagé, false si elle est stockée dans une sous-colonne distincte ou si elle est NULL. Bool
Exemples
Vérification du format de stockage d’une colonne Dynamic avec la limite 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! │ true │
│ [1,2,3] │ true │
└───────────────┴─────────────────────────────────┘
json — chaîne JSON à valider String
Valeur renvoyée
Renvoie 1 si la chaîne est un JSON valide, sinon 0. UInt8
Exemples
Exemple d’utilisation
SELECT isValidJSON('{"a": "hello", "b": [-100, 200.0, 300]}') = 1;
SELECT isValidJSON('not JSON') = 0;
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);
prettyPrintJSON(json [, indent])
json — Une chaîne JSON valide à mettre en forme. Stringindent — Nombre d’espaces par niveau d’indentation. Par défaut : 4. Max : 32 UInt*
Valeur renvoyée
Une chaîne JSON formatée avec indentation. String
Exemples
Objet simple
SELECT prettyPrintJSON('{"a":1,"b":"hello"}');
SELECT prettyPrintJSON('{"a":1}', 8);
field_name.
Le résultat est UInt8.
Syntaxe
simpleJSONExtractBool(json, field_name)
visitParamExtractBool
Arguments
json — Le JSON dans lequel rechercher le champ. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie 1 si la valeur du champ est true, 0 sinon. Cela signifie que cette fonction renvoie 0, notamment (et pas uniquement) dans les cas suivants :
- Si le champ n’existe pas.
- Si le champ contient
true sous forme de chaîne, par exemple : {"field":"true"}.
- Si le champ contient
1 comme valeur numérique. UInt8
Exemples
Exemple d’utilisation
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;
Float64 de la valeur du champ nommé field_name.
Si field_name est un champ de type chaîne, la fonction essaie d’analyser un nombre à partir du début de la chaîne.
Si le champ n’existe pas, ou s’il existe mais ne contient pas de nombre, la fonction renvoie 0.
Syntaxe
simpleJSONExtractFloat(json, field_name)
visitParamExtractFloat
Arguments
json — Le JSON dans lequel le champ est recherché. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie le nombre extrait du champ si celui-ci existe et contient un nombre, sinon 0. Float64
Exemples
Exemple d’utilisation
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;
Int64 à partir de la valeur du champ nommé field_name.
Si field_name est un champ de type chaîne, la fonction tente d’analyser un nombre au début de la chaîne.
Si le champ n’existe pas, ou s’il existe mais ne contient pas de nombre, la fonction renvoie 0.
Syntaxe
simpleJSONExtractInt(json, field_name)
visitParamExtractInt
Arguments
json — Le JSON dans lequel le champ est recherché. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie le nombre extrait du champ si celui-ci existe et contient un nombre, 0 sinon Int64
Exemples
Exemple d’utilisation
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;
field_name sous forme de String, y compris les séparateurs.
Syntaxe
simpleJSONExtractRaw(json, field_name)
visitParamExtractRaw
Arguments
json — Le JSON dans lequel le champ est recherché. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie la valeur du champ sous forme de chaîne de caractères, y compris les séparateurs si le champ existe, ou une chaîne vide dans le cas contraire String
Exemples
Exemple d’utilisation
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]}
String entre guillemets doubles à partir de la valeur du champ nommé field_name.
Détails d’implémentation
Actuellement, les points de code au format \uXXXX\uYYYY qui ne relèvent pas du plan multilingue de base ne sont pas pris en charge (ils sont convertis en CESU-8 au lieu d’UTF-8).
Syntaxe
simpleJSONExtractString(json, field_name)
visitParamExtractString
Arguments
json — Le JSON dans lequel rechercher le champ. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie la valeur non déséchappée d’un champ sous forme de chaîne, séparateurs compris. Une chaîne vide est renvoyée si le champ ne contient pas de chaîne entre guillemets doubles, si le déséchappement échoue ou si le champ n’existe pas String
Exemples
Exemple d’utilisation
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;
UInt64 de la valeur du champ nommé field_name.
Si field_name est un champ de type chaîne de caractères, la fonction essaie d’analyser un nombre au début de la chaîne.
Si le champ n’existe pas, ou s’il existe mais ne contient pas de nombre, elle renvoie 0.
Syntaxe
simpleJSONExtractUInt(json, field_name)
visitParamExtractUInt
Arguments
json — Le JSON dans lequel le champ est recherché. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie le nombre extrait du champ si celui-ci existe et contient un nombre, 0 sinon UInt64
Exemples
Exemple d’utilisation
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;
field_name.
Syntaxe
simpleJSONHas(json, field_name)
visitParamHas
Arguments
json — Le JSON dans lequel rechercher le champ. Stringfield_name — Le nom du champ à rechercher. const String
Valeur renvoyée
Renvoie 1 si le champ existe, 0 sinon UInt8
Exemples
Exemple d’utilisation
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;
UInt64 ou Int128) sont placés entre guillemets par défaut. output_format_json_quote_64bit_integers contrôle ce comportement.
Les valeurs spéciales NaN et inf sont remplacées par null. Activez le paramètre output_format_json_quote_denormals pour les afficher.
Lors de la sérialisation d’une valeur Enum, la fonction renvoie son nom.
Voir aussi :
Syntaxe
Arguments
value — Valeur à sérialiser. La valeur peut être de n’importe quel type de données. Any
Valeur renvoyée
Renvoie la représentation JSON de la valeur. String
Exemples
Sérialisation d’une Map
SELECT toJSONString(map('key1', 1, 'key2', 2));
┌─toJSONString(map('key1', 1, 'key2', 2))─┐
│ {"key1":1,"key2":2} │
└─────────────────────────────────────────┘
SELECT toJSONString(tuple(1.25, NULL, NaN, +inf, -inf, [])) SETTINGS output_format_json_quote_denormals = 1;
┌─toJSONString(tuple(1.25, NULL, NaN, plus(inf), minus(inf), []))─┐
│ [1.25,null,"nan","inf","-inf",[]] │
└─────────────────────────────────────────────────────────────────┘
