Fonctions JSON - ClickHouse Documentation

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

Fonctions simpleJSON (visitParam)

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 :

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.

Fonctions JSONExtract

Ces fonctions reposent sur simdjson et sont conçues pour répondre à des besoins plus complexes en matière d’analyse syntaxique du JSON.

Fonctions JSONExtract insensibles à la casse

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.

JSONAllPaths

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

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

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

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

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

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

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

Query

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

Response

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

JSONDynamicPaths

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

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

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

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

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

Query

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

Response

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

JSONExtractArrayRaw

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

Query

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

Response

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

JSONExtractArrayRawCaseInsensitive

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

Query

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

Response

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

JSONExtractBool

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

Query

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

Response

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

JSONExtractBoolCaseInsensitive

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

Query

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

Response

JSONExtractCaseInsensitive

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

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

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

Query

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

Response

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

JSONExtractFloatCaseInsensitive

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

Query

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

Response

12.34

JSONExtractInt

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

Query

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

Response

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

JSONExtractIntCaseInsensitive

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

Query

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

Response

imbriqué

Query

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

Response

JSONExtractKeys

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

Query

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

Response

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

JSONExtractKeysAndValues

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

Query

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

Response

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

JSONExtractKeysAndValuesCaseInsensitive

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

Query

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

Response

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

JSONExtractKeysAndValuesRaw

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

Query

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

Response

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

JSONExtractKeysAndValuesRawCaseInsensitive

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

Query

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

Response

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

JSONExtractKeysCaseInsensitive

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

Query

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

Response

['Name','AGE']

Nested

Query

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

Response

['name','AGE']

JSONExtractRaw

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

Query

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

Response

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

JSONExtractRawCaseInsensitive

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

Query

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

Response

{"key":"value"}

JSONExtractString

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

Query

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

Response

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

JSONExtractStringCaseInsensitive

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

Query

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

Response

def

Nested

Query

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

Response

John

JSONExtractUInt

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

Query

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

Response

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

JSONExtractUIntCaseInsensitive

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

Query

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

Response

JSONHas

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

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
0

JSONKey

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

Query

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

Response

JSONLength

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

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

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

Query

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

Response

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

JSONSharedDataPaths

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

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

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

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

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

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

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

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 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯llo.world')─┐
│                        1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[*]')─┐
│                        1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[0]')─┐
│                        1 │
└──────────────────────────┘

JSON_QUERY

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

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

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

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
ᴺᵁᴸᴸ

dynamicElement

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

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

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

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

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

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

isValidJSON

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

Query

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

Response

1
0

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

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

Query

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

Response

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

Retrait personnalisé

Query

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

Response

{
        "a": 1
}

simpleJSONExtractBool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 :

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

Query

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

Response

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

Valeurs spéciales

Query

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

Response

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

​Types de fonctions JSON

​Fonctions simpleJSON (visitParam)

​Fonctions JSONExtract

​Fonctions JSONExtract insensibles à la casse

​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

Types de fonctions JSON

Fonctions simpleJSON (visitParam)

Fonctions JSONExtract

Fonctions JSONExtract insensibles à la casse

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