Fonctions JSON

Il existe deux familles de fonctions pour analyser du JSON :

• simpleJSON* (visitParam*) qui sont conçues pour analyser très rapidement un sous-ensemble limité de JSON.
• JSONExtract* qui sont conçues pour analyser du JSON standard.

ClickHouse dispose de fonctions spéciales pour manipuler du JSON simplifié. Toutes ces fonctions JSON reposent sur des hypothèses strictes quant à la forme que peut prendre le JSON. Elles cherchent à en faire le moins possible afin d'exécuter l'opération aussi rapidement que possible.

Les hypothèses suivantes sont faites :

1. Le nom du champ (argument de la fonction) doit être une constante.
2. 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
3. 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.
4. 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.

Les fonctions JSON_EXISTS, JSON_VALUE et JSON_QUERY acceptent une expression JSONPath comme deuxième argument. ClickHouse implémente un sous-ensemble limité de JSONPath, librement inspiré de la norme SQL/JSON (ISO/IEC TR 19075-6), et intentionnellement plus restreint que la RFC 9535 et d'autres implémentations populaires. Les opérateurs pris en charge sont répertoriés ci-dessous.

L'implémentation de référence se trouve dans src/Functions/JSONPath/Parsers.

Remarques :

• Les index et les plages peuvent être combinés dans une même paire de crochets (par exemple, [0 to 2, 4]).
• Les plages d'index et le caractère générique ne peuvent pas être combinés dans une même paire de crochets (par exemple, [* , 0] n'est pas valide).
• Dans une plage [n to m], le début n doit être strictement inférieur à la fin m, sinon une exception est levée.
• Un index seul [n] est équivalent à la plage [n to n+1].

Les opérateurs JSONPath suivants, disponibles dans la RFC 9535 ou dans d'autres implémentations, ne sont pas pris en charge par ClickHouse :

Introduite dans : v24.8.0

Renvoie la liste de tous les chemins stockés dans chaque ligne d’une colonne JSON.

Syntaxe

JSONAllPaths(json)

Arguments

• 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']          │
└────────────────────────────────┴────────────────────┘

Introduit dans : v24.8.0

Renvoie la liste de tous les chemins et de leurs types de données présents dans chaque ligne d’une colonne JSON.

Syntaxe

JSONAllPathsWithTypes(json)

Arguments

• 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'} │
└────────────────────────────────┴───────────────────────────────────────────┘

Introduit dans : v26.4.0

Renvoie toutes les valeurs de chaque ligne d’une colonne JSON sous forme de tableau de chaînes de caractères. Les valeurs sont sérialisées dans leur représentation textuelle et ordonnées selon leurs chemins d’accès.

Syntaxe

JSONAllValues(json)

Arguments

• 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'] │
└────────────────────────────────┴──────────────────────────┘

Introduit dans : v23.2.0

Renvoie le nombre d’éléments du tableau JSON de plus haut niveau. La fonction renvoie NULL si la chaîne JSON d’entrée n’est pas valide.

Syntaxe

JSONArrayLength(json)

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 │
└─────────────────────┴────────────────────────────┘

Introduit dans : v24.8.0

Renvoie la liste des chemins dynamiques stockés sous forme de sous-colonnes distinctes dans une colonne JSON.

Syntaxe

JSONDynamicPaths(json)

Arguments

• 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']                  │
└────────────────────────────────┴────────────────────────┘

Introduit dans : v24.8.0

Renvoie la liste des chemins dynamiques stockés sous forme de sous-colonnes distinctes, ainsi que leurs types, dans chaque ligne de la colonne JSON.

Syntaxe

JSONDynamicPathsWithTypes(json)

Arguments

• 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))'}  │
└────────────────────────────────┴─────────────────────────────────┘

Introduit dans : v19.14.0

Analyse du JSON et extrait une valeur du type de données ClickHouse spécifié.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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]) │
└──────────────────────────┘

Introduit dans : v20.1.0

Renvoie un tableau dont chaque élément du tableau JSON est représenté sous forme de chaîne non analysée.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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','"hello"'] │
└──────────────────────────┘

Introduit dans : v25.8.0

Renvoie un tableau contenant les éléments d’un tableau JSON, chacun étant représenté sous forme de chaîne non analysée, avec une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractArrayRaw.

Syntaxe

JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — Chaîne JSON à analyser String
• indices_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')

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

Introduit dans : v20.1.0

Analyse le JSON et extrait une valeur de type Bool.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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;

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

Introduit dans : v25.8.0

Analyse du JSON et extrait une valeur booléenne en utilisant une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractBool.

Syntaxe

JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — Chaîne JSON à analyser String
• indices_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')

1

Introduit dans : v25.8.0

Parse du JSON et extrait une valeur du type de données ClickHouse donné à l’aide d’une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtract.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser String
• indices_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')

123

array_type

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

[1,2,3]

Introduit dans : v20.1.0

Analyse le JSON et extrait une valeur de type Float.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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;

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

Introduit dans : v25.8.0

Analyse du JSON et extraction d’une valeur de type Float à l’aide d’une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractFloat.

Syntaxe

JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — chaîne JSON à analyser String
• indices_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')

12.34

Introduit dans : v20.1.0

Analyse un JSON et en extrait une valeur de type Int.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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 │
└──────┘

Introduite dans : v25.8.0

Analyse le JSON et en extrait une valeur de type Int avec une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractInt.

Syntaxe

JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — Chaîne JSON à analyser String
• indices_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')

123

imbriqué

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

42

Introduit dans : v21.11.0

Analyse une chaîne JSON et en extrait les clés.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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'] │
└───────────┘

Introduit dans : v20.1.0

Analyse des paires clé-valeur à partir d’un JSON dont les valeurs sont du type de données ClickHouse spécifié.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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}}', 'x', 'Int8') AS res

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

Introduit dans : v25.8.0

Analyse des paires clé-valeur dans un JSON à l’aide d’une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractKeysAndValues.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser String
• indices_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')]

Introduit dans : v20.4.0

Renvoie un tableau de tuples contenant les clés et les valeurs d’un objet JSON. Toutes les valeurs sont représentées sous forme de chaînes non analysées.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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]'),('b','"hello"')] │
└──────────────────────────────────────┘

Introduit dans : v25.8.0

Extrait des paires clé-valeur brutes d’un JSON à l’aide d’une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractKeysAndValuesRaw.

Syntaxe

JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — chaîne JSON à analyser String
• indices_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')]

Introduit dans : v25.8.0

Analyse une chaîne JSON et en extrait les clés en utilisant une correspondance de clés insensible à la casse pour accéder à des objets imbriqués. Cette fonction est similaire à JSONExtractKeys.

Syntaxe

JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — Chaîne JSON à analyser String
• indices_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}')

['Name','AGE']

Nested

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

['name','AGE']

Introduit dans : v20.1.0

Renvoie une partie du JSON sous forme de chaîne non analysée.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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,300] │
└────────────────┘

Introduite dans : v25.8.0

Renvoie une partie du JSON sous forme de chaîne non analysée, avec une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractRaw.

Syntaxe

JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — Chaîne JSON à analyser String
• indices_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')

{"key":"value"}

Introduit dans : v20.1.0

Analyse du JSON et en extrait une valeur de type String.

Syntaxe

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

Arguments

• json — chaîne JSON à analyser. String
• indices_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 │
└───────┘

Introduit dans : v25.8.0

Analyse le JSON et extrait une chaîne de caractères à l’aide d’une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractString.

Syntaxe

JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — Chaîne JSON à analyser String
• indices_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')

def

Nested

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

John

Introduit dans : v20.1.0

Analyse le JSON et en extrait une valeur de type UInt.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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;

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

Introduit dans : v25.8.0

Analyse du JSON et extrait une valeur de type UInt en utilisant une correspondance de clés insensible à la casse. Cette fonction est similaire à JSONExtractUInt.

Syntaxe

JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)

Arguments

• json — chaîne JSON à analyser String
• indices_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')

789

Introduite dans : v20.1.0

Vérifie la présence de la ou des valeurs fournies dans le document JSON.

Syntaxe

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

Arguments

• 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;

1
1

Introduit dans : v20.1.0

Renvoie la clé d’un champ d’un objet JSON en fonction de son index (à partir de 1). Si le JSON est transmis sous forme de chaîne, il est d’abord analysé. Le deuxième argument est un chemin JSON permettant de naviguer dans des objets imbriqués. La fonction renvoie le nom de la clé à la position indiquée.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser. String
• indices_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);

a

Introduit dans : v20.1.0

Renvoie la longueur d’un tableau JSON ou d’un objet JSON. Si la valeur n’existe pas ou n’est pas du bon type, 0 est renvoyé.

Syntaxe

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

Arguments

• json — Chaîne JSON à analyser String
• [, indices_or_keys, ...] — Facultatif. Liste de zéro argument ou plus. String ou (U)Int8/16/32/64

Valeur renvoyée

Renvoie la longueur du tableau JSON ou de l'objet JSON ; sinon, renvoie 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;

1
1

Introduit dans : v23.10.0

Renvoie la chaîne représentant l’objet JSON fusionné, obtenue en fusionnant plusieurs objets JSON.

Syntaxe

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

Alias : 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"} │
└───────────────────────┘

Introduit dans : v24.8.0

Renvoie la liste des chemins stockés dans la structure de données partagée d'une colonne JSON.

Syntaxe

JSONSharedDataPaths(json)

Arguments

• 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']                     │
└────────────────────────────────┴───────────────────────────┘

Introduit dans : v24.8.0

Renvoie, pour chaque ligne de la colonne JSON, la liste des chemins stockés dans la structure de données partagées ainsi que leurs types.

Syntaxe

JSONSharedDataPathsWithTypes(json)

Arguments

• 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'}                       │
└────────────────────────────────┴────────────────────────────────────┘

Introduit dans : v20.1.0

Renvoie le type d’une valeur JSON. Si la valeur n’existe pas, Null=0 est renvoyé.

Syntaxe

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

Arguments

• json — chaîne JSON à analyser String
• json[, 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
1
1

Introduit dans : v21.8.0

Si la valeur existe dans le document JSON, 1 est renvoyé. Si la valeur n’existe pas, 0 est renvoyé.

Syntaxe

JSON_EXISTS(json, path)

Arguments

• json — Une chaîne contenant un JSON valide. String
• path — 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}', '$.hello')─┐
│                                     1 │
└───────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":{"world":1}}', '$.hello.world')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":["world"]}', '$.hello[*]')─┐
│                                                1 │
└──────────────────────────────────────────────────┘
┌─JSON_EXISTS('{"hello":["world"]}', '$.hello[0]')─┐
│                                                1 │
└──────────────────────────────────────────────────┘

Introduit dans : v21.8.0

Analyse un JSON et en extrait une valeur sous la forme d’un tableau JSON ou d’un objet JSON. Si la valeur n’existe pas, une chaîne vide est renvoyée.

Syntaxe

JSON_QUERY(json, path)

Arguments

• json — Une chaîne contenant du JSON valide. String
• path — 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

Introduit dans : v21.11.0

Analyse un JSON et en extrait une valeur sous forme de scalaire JSON. Si la valeur n'existe pas, une chaîne vide est renvoyée par défaut.

Le comportement de cette fonction est contrôlé par les paramètres suivants :

• 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

JSON_VALUE(json, path)

Arguments

• json — Une chaîne contenant un JSON valide. String
• path — 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;

world
0
2
\N

Introduit dans : v24.1.0

Extrait une colonne du type spécifié depuis une colonne 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)

Arguments

• dynamic — Colonne Dynamic à partir de laquelle effectuer l’extraction. Dynamic
• type_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]                           │                      ᴺᵁᴸᴸ │ []                                 │
└───────────────┴────────────────┴─────────────────────────────┴────────────────────────────┴───────────────────────────────────┴───────────────────────────┴────────────────────────────────────┘

Introduit dans : v24.1.0

Renvoie le nom du type de variante pour chaque ligne d’une colonne 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

dynamicType(dynamic)

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)   │
└───────────────┴────────────────┘

Introduit dans : v24.1.0

Renvoie true pour les lignes d’une colonne Dynamic qui sont stockées au format de variante partagé plutôt que dans des sous-colonnes distinctes.

Lorsqu’une colonne Dynamic a une limite 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)

Arguments

• 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! │ false                           │
│ [1,2,3]       │ true                            │
└───────────────┴─────────────────────────────────┘

Introduit dans : v20.1.0

Vérifie que la chaîne passée en argument est un JSON valide.

Syntaxe

isValidJSON(json)

Arguments

• 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;

1
1

Utiliser des entiers pour accéder à la fois aux tableaux JSON et aux objets 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

Introduit dans : v26.4.0

Renvoie une version mise en forme d’une chaîne JSON, avec des sauts de ligne et une indentation par espaces.

Syntaxe

prettyPrintJSON(json [, indent])

Arguments

• json — Une chaîne JSON valide à mettre en forme. String
• indent — 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"}');

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

Retrait personnalisé

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

{\n        "a": 1\n}

Introduit dans : v21.4.0

Analyse la valeur true/false du champ nommé field_name. Le résultat est UInt8.

Syntaxe

simpleJSONExtractBool(json, field_name)

Alias : visitParamExtractBool

Arguments

• json — Le JSON dans lequel rechercher le champ. String
• field_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;

0
1
0
0

Introduit dans : v21.4.0

Extrait un 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)

Alias : visitParamExtractFloat

Arguments

• json — Le JSON dans lequel le champ est recherché. String
• field_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;

0
-4000
0
-3.4
5

Introduit dans : v21.4.0

Extrait un 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)

Alias : visitParamExtractInt

Arguments

• json — Le JSON dans lequel le champ est recherché. String
• field_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;

0
-4
0
-3
5

Introduit dans : v21.4.0

Renvoie la valeur du champ field_name sous forme de String, y compris les séparateurs.

Syntaxe

simpleJSONExtractRaw(json, field_name)

Alias : visitParamExtractRaw

Arguments

• json — Le JSON dans lequel le champ est recherché. String
• field_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]}

Introduit dans : v21.4.0

Analyse une 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)

Alias : visitParamExtractString

Arguments

• json — Le JSON dans lequel rechercher le champ. String
• field_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;

\n\0

☺

Introduit dans : v21.4.0

Extrait un 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)

Alias : visitParamExtractUInt

Arguments

• json — Le JSON dans lequel le champ est recherché. String
• field_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;

0
4
0
3
5

Introduit dans : v21.4.0

Vérifie la présence d’un champ nommé field_name.

Syntaxe

simpleJSONHas(json, field_name)

Alias : visitParamHas

Arguments

• json — Le JSON dans lequel rechercher le champ. String
• field_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;

1
0

Introduit dans : v21.7.0

Sérialise une valeur dans sa représentation JSON. Divers types de données et structures imbriquées sont pris en charge. Les entiers 64 bits ou plus (comme 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 :

• output_format_json_quote_64bit_integers
• output_format_json_quote_denormals

Syntaxe

toJSONString(value)

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}                     │
└─────────────────────────────────────────┘

Valeurs spéciales

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",[]]              │
└────────────────────────────────────────────────┘