> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentation des fonctions JSON

# Fonctions JSON

<div id="types-of-functions">
  ## Types de fonctions JSON
</div>

Il existe deux familles de fonctions pour analyser du JSON :

* [`simpleJSON*` (`visitParam*`)](#simplejson-visitparam-functions) qui sont conçues pour analyser très rapidement un sous-ensemble limité de JSON.
* [`JSONExtract*`](#jsonextract-functions) qui sont conçues pour analyser du JSON standard.

<div id="simplejson-visitparam-functions">
  ### Fonctions simpleJSON (visitParam)
</div>

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.

<div id="jsonextract-functions">
  ### Fonctions JSONExtract
</div>

Ces fonctions reposent sur [simdjson](https://github.com/lemire/simdjson) et sont conçues pour répondre à des besoins plus complexes en matière d'analyse syntaxique du JSON.

<div id="case-insensitive-jsonextract-functions">
  ### Fonctions JSONExtract insensibles à la casse
</div>

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.

<Note>
  Ces fonctions peuvent être moins performantes que leurs équivalents sensibles à la casse. Utilisez donc les fonctions JSONExtract standard si possible.
</Note>

{/*AUTOGENERATED_START*/}

<div id="JSONAllPaths">
  ## JSONAllPaths
</div>

Introduite dans : v24.8.0

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

**Syntaxe**

```sql theme={null}
JSONAllPaths(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**Valeur renvoyée**

Renvoie un tableau contenant tous les chemins de la colonne JSON. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─json─────────────────────────────────┬─JSONAllPaths(json)─┐
│ {"a":"42"}                           │ ['a']              │
│ {"b":"Hello"}                        │ ['b']              │
│ {"a":["1","2","3"],"c":"2020-01-01"} │ ['a','c']          │
└──────────────────────────────────────┴────────────────────┘
```

<div id="JSONAllPathsWithTypes">
  ## JSONAllPathsWithTypes
</div>

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

```sql theme={null}
JSONAllPathsWithTypes(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**Valeur renvoyée**

Renvoie une map de tous les chemins et de leurs types de données dans la colonne JSON. [`Map(String, String)`](/fr/reference/data-types/map)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─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'} │
└──────────────────────────────────────┴───────────────────────────────────────────┘
```

<div id="JSONAllValues">
  ## JSONAllValues
</div>

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

```sql theme={null}
JSONAllValues(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**Valeur renvoyée**

Renvoie un tableau de toutes les valeurs de la colonne JSON sous forme de chaînes de caractères. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─json─────────────────────────────────┬─JSONAllValues(json)──────┐
│ {"a":42}                             │ ['42']                   │
│ {"b":"Hello"}                        │ ['Hello']                │
│ {"a":[1,2,3],"c":"2020-01-01"}       │ ['[1,2,3]','2020-01-01'] │
└──────────────────────────────────────┴──────────────────────────┘
```

<div id="JSONArrayLength">
  ## JSONArrayLength
</div>

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

```sql theme={null}
JSONArrayLength(json)
```

**Alias** : `JSON_ARRAY_LENGTH`

**Arguments**

* `json` — Chaîne contenant un JSON valide. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/nullable)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT
    JSONArrayLength(''),
    JSONArrayLength('[1,2,3]');
```

```response title=Response theme={null}
┌─JSONArrayLength('')─┬─JSONArrayLength('[1,2,3]')─┐
│                ᴺᵁᴸᴸ │                          3 │
└─────────────────────┴────────────────────────────┘
```

<div id="JSONDynamicPaths">
  ## JSONDynamicPaths
</div>

Introduit dans : v24.8.0

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

**Syntaxe**

```sql theme={null}
JSONDynamicPaths(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**Valeur renvoyée**

Renvoie un tableau de chemins dynamiques dans la colonne JSON. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─json─────────────────────────────────┬─JSONDynamicPaths(json)─┐
│ {"a":"42"}                           │ ['a']                  │
│ {"b":"Hello"}                        │ []                     │
│ {"a":["1","2","3"],"c":"2020-01-01"} │ ['a']                  │
└──────────────────────────────────────┴────────────────────────┘
```

<div id="JSONDynamicPathsWithTypes">
  ## JSONDynamicPathsWithTypes
</div>

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

```sql theme={null}
JSONDynamicPathsWithTypes(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**Valeur renvoyée**

Renvoie une map des chemins dynamiques et de leurs types de données dans la colonne JSON. [`Map(String, String)`](/fr/reference/data-types/map)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─json─────────────────────────────────┬─JSONDynamicPathsWithTypes(json)─┐
│ {"a":"42"}                           │ {'a':'Int64'}                   │
│ {"b":"Hello"}                        │ {}                              │
│ {"a":["1","2","3"],"c":"2020-01-01"} │ {'a':'Array(Nullable(Int64))'}  │
└──────────────────────────────────────┴─────────────────────────────────┘
```

<div id="JSONExtract">
  ## JSONExtract
</div>

Introduit dans : v19.14.0

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

**Syntaxe**

```sql theme={null}
JSONExtract(json[, indices_or_keys, ...], return_type)
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Une liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)
* `return_type` — Type de données ClickHouse à renvoyer. [`String`](/fr/reference/data-types/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**

```sql title=Query theme={null}
SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(String, Array(Float64))') AS res;
```

```response title=Response theme={null}
┌─res──────────────────────────────┐
│ ('hello',[-100,200,300])         │
└──────────────────────────────────┘
```

<div id="JSONExtractArrayRaw">
  ## JSONExtractArrayRaw
</div>

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

```sql theme={null}
JSONExtractArrayRaw(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**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)`](/fr/reference/data-types/array)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT JSONExtractArrayRaw('{"a": "hello", "b": [-100, 200.0, "hello"]}', 'b') AS res;
```

```response title=Response theme={null}
┌─res──────────────────────────┐
│ ['-100','200.0','"hello"']   │
└──────────────────────────────┘
```

<div id="JSONExtractArrayRawCaseInsensitive">
  ## JSONExtractArrayRawCaseInsensitive
</div>

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`](#JSONExtractArrayRaw).

**Syntaxe**

```sql theme={null}
JSONExtractArrayRawCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tableau de chaînes JSON brutes. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**simple**

```sql title=Query theme={null}
SELECT JSONExtractArrayRawCaseInsensitive('{"Items": [1, 2, 3]}', 'ITEMS')
```

```response title=Response theme={null}
['1','2','3']
```

<div id="JSONExtractBool">
  ## JSONExtractBool
</div>

Introduit dans : v20.1.0

Analyse le JSON et extrait une valeur de type Bool.

**Syntaxe**

```sql theme={null}
JSONExtractBool(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une valeur Bool si elle existe, sinon `0`. [`Bool`](/fr/reference/data-types/boolean)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractBool('{"passed": true}', 'passed') AS res;
```

```response title=Response theme={null}
┌─res─┐
│   1 │
└─────┘
```

<div id="JSONExtractBoolCaseInsensitive">
  ## JSONExtractBoolCaseInsensitive
</div>

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`](#JSONExtractBool).

**Syntaxe**

```sql theme={null}
JSONExtractBoolCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**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`](/fr/reference/data-types/int-uint)

**Exemples**

**basique**

```sql title=Query theme={null}
SELECT JSONExtractBoolCaseInsensitive('{"IsActive": true}', 'isactive')
```

```response title=Response theme={null}
1
```

<div id="JSONExtractCaseInsensitive">
  ## JSONExtractCaseInsensitive
</div>

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`](#JSONExtract).

**Syntaxe**

```sql theme={null}
JSONExtractCaseInsensitive(json [, indices_or_keys...], return_type)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Facultatif. Indices ou clés pour accéder au champ. Les clés utilisent une correspondance insensible à la casse [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)
* `return_type` — Type de données ClickHouse à extraire [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie la valeur extraite dans le type de données spécifié. [`Any`](/fr/reference/data-types/index)

**Exemples**

**int\_type**

```sql title=Query theme={null}
SELECT JSONExtractCaseInsensitive('{"Number": 123}', 'number', 'Int32')
```

```response title=Response theme={null}
123
```

**array\_type**

```sql title=Query theme={null}
SELECT JSONExtractCaseInsensitive('{"List": [1, 2, 3]}', 'list', 'Array(Int32)')
```

```response title=Response theme={null}
[1,2,3]
```

<div id="JSONExtractFloat">
  ## JSONExtractFloat
</div>

Introduit dans : v20.1.0

Analyse le JSON et extrait une valeur de type Float.

**Syntaxe**

```sql theme={null}
JSONExtractFloat(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Une liste de zéro ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une valeur Float si elle existe, sinon `0`. [`Float64`](/fr/reference/data-types/float)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractFloat('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 2) AS res;
```

```response title=Response theme={null}
┌─res─┐
│ 200 │
└─────┘
```

<div id="JSONExtractFloatCaseInsensitive">
  ## JSONExtractFloatCaseInsensitive
</div>

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`](#JSONExtractFloat).

**Syntaxe**

```sql theme={null}
JSONExtractFloatCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur Float extraite, ou 0 si elle est introuvable ou ne peut pas être convertie. [`Float64`](/fr/reference/data-types/float)

**Exemples**

**de base**

```sql title=Query theme={null}
SELECT JSONExtractFloatCaseInsensitive('{"Price": 12.34}', 'PRICE')
```

```response title=Response theme={null}
12.34
```

<div id="JSONExtractInt">
  ## JSONExtractInt
</div>

Introduit dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
JSONExtractInt(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une valeur de type Int si elle existe, sinon `0`. [`Int64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) AS res;
```

```response title=Response theme={null}
┌──res─┐
│ -100 │
└──────┘
```

<div id="JSONExtractIntCaseInsensitive">
  ## JSONExtractIntCaseInsensitive
</div>

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`](#JSONExtractInt).

**Syntaxe**

```sql theme={null}
JSONExtractIntCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur Int extraite, ou 0 si elle est introuvable ou ne peut pas être convertie. [`Int64`](/fr/reference/data-types/int-uint)

**Exemples**

**simple**

```sql title=Query theme={null}
SELECT JSONExtractIntCaseInsensitive('{"Value": 123}', 'value')
```

```response title=Response theme={null}
123
```

**imbriqué**

```sql title=Query theme={null}
SELECT JSONExtractIntCaseInsensitive('{"DATA": {"COUNT": 42}}', 'data', 'Count')
```

```response title=Response theme={null}
42
```

<div id="JSONExtractKeys">
  ## JSONExtractKeys
</div>

Introduit dans : v21.11.0

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

**Syntaxe**

```sql theme={null}
JSONExtractKeys(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tableau contenant les clés de l'objet JSON. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractKeys('{"a": "hello", "b": [-100, 200.0, 300]}') AS res;
```

```response title=Response theme={null}
┌─res─────────┐
│ ['a','b']   │
└─────────────┘
```

<div id="JSONExtractKeysAndValues">
  ## JSONExtractKeysAndValues
</div>

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

```sql theme={null}
JSONExtractKeysAndValues(json[, indices_or_keys, ...], value_type)
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Liste de zéro, un ou plusieurs arguments, chacun pouvant être une chaîne ou un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)
* `value_type` — Type de données ClickHouse des valeurs. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie un tableau de tuples contenant les paires clé-valeur analysées. [`Array(Tuple(String, value_type))`](/fr/reference/data-types/array)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractKeysAndValues('{"x": {"a": 5, "b": 7, "c": 11}}', 'Int8', 'x') AS res;
```

```response title=Response theme={null}
┌─res────────────────────┐
│ [('a',5),('b',7),('c',11)] │
└────────────────────────┘
```

<div id="JSONExtractKeysAndValuesCaseInsensitive">
  ## JSONExtractKeysAndValuesCaseInsensitive
</div>

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`](#JSONExtractKeysAndValues).

**Syntaxe**

```sql theme={null}
JSONExtractKeysAndValuesCaseInsensitive(json [, indices_or_keys...], value_type)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Facultatif. Indices ou clés pour accéder à l’objet. Les clés utilisent une correspondance insensible à la casse [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)
* `value_type` — Le type de données ClickHouse des valeurs [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie un tableau de tuples contenant des paires clé-valeur. [`Array(Tuple(String, T))`](/fr/reference/data-types/array)

**Exemples**

**simple**

```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesCaseInsensitive('{"Name": "Alice", "AGE": 30}', 'String')
```

```response title=Response theme={null}
[('Name','Alice'),('AGE','30')]
```

<div id="JSONExtractKeysAndValuesRaw">
  ## JSONExtractKeysAndValuesRaw
</div>

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

```sql theme={null}
JSONExtractKeysAndValuesRaw(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Une liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**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))`](/fr/reference/data-types/array)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesRaw('{"a": [-100, 200.0], "b": "hello"}') AS res;
```

```response title=Response theme={null}
┌─res──────────────────────────────────┐
│ [('a','[-100,200.0]'),('b','"hello"')] │
└──────────────────────────────────────┘
```

<div id="JSONExtractKeysAndValuesRawCaseInsensitive">
  ## JSONExtractKeysAndValuesRawCaseInsensitive
</div>

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`](#JSONExtractKeysAndValuesRaw).

**Syntaxe**

```sql theme={null}
JSONExtractKeysAndValuesRawCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Facultatif. Indices ou clés pour naviguer jusqu’à l’objet. Les clés utilisent une correspondance insensible à la casse [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tableau de tuples contenant des paires clé-valeur sous forme de chaînes brutes. [`Array(Tuple(String, String))`](/fr/reference/data-types/array)

**Exemples**

**de base**

```sql title=Query theme={null}
SELECT JSONExtractKeysAndValuesRawCaseInsensitive('{"Name": "Alice", "AGE": 30}')
```

```response title=Response theme={null}
[('Name','"Alice"'),('AGE','30')]
```

<div id="JSONExtractKeysCaseInsensitive">
  ## JSONExtractKeysCaseInsensitive
</div>

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`](#JSONExtractKeys).

**Syntaxe**

```sql theme={null}
JSONExtractKeysCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie un tableau de clés de l'objet JSON. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**de base**

```sql title=Query theme={null}
SELECT JSONExtractKeysCaseInsensitive('{"Name": "Alice", "AGE": 30}')
```

```response title=Response theme={null}
['Name','AGE']
```

**Nested**

```sql title=Query theme={null}
SELECT JSONExtractKeysCaseInsensitive('{"User": {"name": "John", "AGE": 25}}', 'user')
```

```response title=Response theme={null}
['name','AGE']
```

<div id="JSONExtractRaw">
  ## JSONExtractRaw
</div>

Introduit dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
JSONExtractRaw(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Une liste d'arguments, éventuellement vide, dont chacun peut être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**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`](/fr/reference/data-types/string)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractRaw('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') AS res;
```

```response title=Response theme={null}
┌─res──────────────┐
│ [-100,200.0,300] │
└──────────────────┘
```

<div id="JSONExtractRawCaseInsensitive">
  ## JSONExtractRawCaseInsensitive
</div>

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`](#JSONExtractRaw).

**Syntaxe**

```sql theme={null}
JSONExtractRawCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la chaîne JSON brute de l’élément extrait. [`String`](/fr/reference/data-types/string)

**Exemples**

**objet**

```sql title=Query theme={null}
SELECT JSONExtractRawCaseInsensitive('{"Object": {"key": "value"}}', 'OBJECT')
```

```response title=Response theme={null}
{"key":"value"}
```

<div id="JSONExtractString">
  ## JSONExtractString
</div>

Introduit dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
JSONExtractString(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Une liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une valeur de type String si elle existe, sinon une chaîne vide. [`String`](/fr/reference/data-types/string)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') AS res;
```

```response title=Response theme={null}
┌─res───┐
│ hello │
└───────┘
```

<div id="JSONExtractStringCaseInsensitive">
  ## JSONExtractStringCaseInsensitive
</div>

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`](#JSONExtractString).

**Syntaxe**

```sql theme={null}
JSONExtractStringCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur de chaîne extraite, ou une chaîne vide si elle est introuvable. [`String`](/fr/reference/data-types/string)

**Exemples**

**de base**

```sql title=Query theme={null}
SELECT JSONExtractStringCaseInsensitive('{"ABC": "def"}', 'abc')
```

```response title=Response theme={null}
def
```

**Nested**

```sql title=Query theme={null}
SELECT JSONExtractStringCaseInsensitive('{"User": {"Name": "John"}}', 'user', 'name')
```

```response title=Response theme={null}
John
```

<div id="JSONExtractUInt">
  ## JSONExtractUInt
</div>

Introduit dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
JSONExtractUInt(json [, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Liste de zéro, un ou plusieurs arguments, chacun pouvant être soit une chaîne, soit un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie une valeur UInt si elle existe, sinon `0`. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONExtractUInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', -1) AS res;
```

```response title=Response theme={null}
┌─res─┐
│ 300 │
└─────┘
```

<div id="JSONExtractUIntCaseInsensitive">
  ## JSONExtractUIntCaseInsensitive
</div>

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`](#JSONExtractUInt).

**Syntaxe**

```sql theme={null}
JSONExtractUIntCaseInsensitive(json [, indices_or_keys]...)
```

**Arguments**

* `json` — chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `indices_or_keys` — Facultatif. Indices ou clés pour accéder au champ. Les clés utilisent une correspondance insensible à la casse [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie la valeur UInt extraite, 0 si elle est introuvable ou ne peut pas être convertie. [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**de base**

```sql title=Query theme={null}
SELECT JSONExtractUIntCaseInsensitive('{"COUNT": 789}', 'count')
```

```response title=Response theme={null}
789
```

<div id="JSONHas">
  ## JSONHas
</div>

Introduite dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
JSONHas(json[ ,indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `[ ,indices_or_keys, ...]` — Une liste de zéro ou plusieurs arguments. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie `1` si la valeur existe dans `json`, sinon `0` [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

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

```response title=Response theme={null}
1
0
```

<div id="JSONKey">
  ## JSONKey
</div>

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

```sql theme={null}
JSONKey(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string) ou [`Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie le nom de la clé à la position spécifiée dans l’objet JSON. [`String`](/fr/reference/data-types/string)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
SELECT JSONKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1);
```

```response title=Response theme={null}
a
```

<div id="JSONLength">
  ## JSONLength
</div>

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

```sql theme={null}
JSONLength(json [, indices_or_keys, ...])
```

**Arguments**

* `json` — Chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `[, indices_or_keys, ...]` — Facultatif. Liste de zéro argument ou plus. [`String`](/fr/reference/data-types/string) ou [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)

**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`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 3;
SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}') = 2;
```

```response title=Response theme={null}
1
1
```

<div id="JSONMergePatch">
  ## JSONMergePatch
</div>

Introduit dans : v23.10.0

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

**Syntaxe**

```sql theme={null}
JSONMergePatch(json1[, json2, ...])
```

**Alias** : `jsonMergePatch`

**Arguments**

* `json1[, json2, ...]` — Une ou plusieurs chaînes contenant du JSON valide. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie la chaîne correspondant à l'objet JSON fusionné, si les chaînes d'objets JSON sont valides. [`String`](/fr/reference/data-types/string)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
SELECT JSONMergePatch('{"a":1}', '{"name": "joey"}', '{"name": "tom"}', '{"name": "zoey"}') AS res;
```

```response title=Response theme={null}
┌─res───────────────────┐
│ {"a":1,"name":"zoey"} │
└───────────────────────┘
```

<div id="JSONSharedDataPaths">
  ## JSONSharedDataPaths
</div>

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

```sql theme={null}
JSONSharedDataPaths(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**Valeur renvoyée**

Renvoie un tableau des chemins stockés dans la structure de données partagée de la colonne JSON. [`Array(String)`](/fr/reference/data-types/array)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─json─────────────────────────────────┬─JSONSharedDataPaths(json)─┐
│ {"a":"42"}                           │ []                        │
│ {"b":"Hello"}                        │ ['b']                     │
│ {"a":["1","2","3"],"c":"2020-01-01"} │ ['c']                     │
└──────────────────────────────────────┴───────────────────────────┘
```

<div id="JSONSharedDataPathsWithTypes">
  ## JSONSharedDataPathsWithTypes
</div>

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

```sql theme={null}
JSONSharedDataPathsWithTypes(json)
```

**Arguments**

* `json` — colonne JSON. [`JSON`](/fr/reference/data-types/newjson)

**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)`](/fr/reference/data-types/map)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─json─────────────────────────────────┬─JSONSharedDataPathsWithTypes(json)─┐
│ {"a":"42"}                           │ {}                                  │
│ {"b":"Hello"}                        │ {'b':'String'}                      │
│ {"a":["1","2","3"],"c":"2020-01-01"} │ {'c':'Date'}                        │
└──────────────────────────────────────┴─────────────────────────────────────┘
```

<div id="JSONType">
  ## JSONType
</div>

Introduit dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
JSONType(json[, indices_or_keys, ...])
```

**Arguments**

* `json` — chaîne JSON à analyser [`String`](/fr/reference/data-types/string)
* `json[, indices_or_keys, ...]` — Liste de zéro argument ou plus, chacun pouvant être une chaîne ou un entier. [`String`](/fr/reference/data-types/string) ou [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)

**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`](/fr/reference/data-types/enum)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
1
1
1
```

<div id="JSON_EXISTS">
  ## JSON\_EXISTS
</div>

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

```sql theme={null}
JSON_EXISTS(json, path)
```

**Arguments**

* `json` — Une chaîne contenant un JSON valide. [`String`](/fr/reference/data-types/string)
* `path` — Une chaîne représentant le chemin. [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie `1` si la valeur existe dans le document JSON, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─JSON_EXISTS(⋯ '$.hello')─┐
│                        1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯llo.world')─┐
│                        1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[*]')─┐
│                        1 │
└──────────────────────────┘
┌─JSON_EXISTS(⋯.hello[0]')─┐
│                        1 │
└──────────────────────────┘
```

<div id="JSON_QUERY">
  ## JSON\_QUERY
</div>

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

```sql theme={null}
JSON_QUERY(json, path)
```

**Arguments**

* `json` — Une chaîne contenant du JSON valide. [`String`](/fr/reference/data-types/string)
* `path` — Une chaîne représentant le chemin. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
["world"]
[0, 1, 4, 0, -1, -4]
[2]
String
```

<div id="JSON_VALUE">
  ## JSON\_VALUE
</div>

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

```sql theme={null}
JSON_VALUE(json, path)
```

**Arguments**

* `json` — Une chaîne contenant un JSON valide. [`String`](/fr/reference/data-types/string)
* `path` — Une chaîne représentant le chemin. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/string)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
world
0
2
ᴺᵁᴸᴸ
```

<div id="dynamicElement">
  ## dynamicElement
</div>

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

```sql theme={null}
dynamicElement(dynamic, type_name)
```

**Arguments**

* `dynamic` — Colonne Dynamic à partir de laquelle effectuer l’extraction. [`Dynamic`](/fr/reference/data-types/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`](/fr/reference/data-types/index)

**Exemples**

**Extraction de différents types à partir d’une colonne Dynamic**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─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]                           │                      ᴺᵁᴸᴸ │ []                                 │
└───────────────┴────────────────┴─────────────────────────────┴────────────────────────────┴───────────────────────────────────┴───────────────────────────┴────────────────────────────────────┘
```

<div id="dynamicType">
  ## dynamicType
</div>

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

```sql theme={null}
dynamicType(dynamic)
```

**Arguments**

* `dynamic` — colonne Dynamic à examiner. [`Dynamic`](/fr/reference/data-types/dynamic)

**Valeur renvoyée**

Renvoie le nom du type de la valeur stockée dans chaque ligne, ou 'None' pour les valeurs NULL. [`String`](/fr/reference/data-types/string)

**Exemples**

**Vérification des types dans une colonne Dynamic**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─d─────────────┬─dynamicType(d)─┐
│ ᴺᵁᴸᴸ          │ None           │
│ 42            │ Int64          │
│ Hello, World! │ String         │
│ [1,2,3]       │ Array(Int64)   │
└───────────────┴────────────────┘
```

<div id="isDynamicElementInSharedData">
  ## isDynamicElementInSharedData
</div>

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

```sql theme={null}
isDynamicElementInSharedData(dynamic)
```

**Arguments**

* `dynamic` — colonne Dynamic à inspecter. [`Dynamic`](/fr/reference/data-types/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`](/fr/reference/data-types/boolean)

**Exemples**

**Vérification du format de stockage d'une colonne Dynamic avec la limite max\_types**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─d─────────────┬─isDynamicElementInSharedData(d)─┐
│ ᴺᵁᴸᴸ          │ false                           │
│ 42            │ false                           │
│ Hello, World! │ true                            │
│ [1,2,3]       │ true                            │
└───────────────┴─────────────────────────────────┘
```

<div id="isValidJSON">
  ## isValidJSON
</div>

Introduit dans : v20.1.0

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

**Syntaxe**

```sql theme={null}
isValidJSON(json)
```

**Arguments**

* `json` — chaîne JSON à valider [`String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie `1` si la chaîne est un JSON valide, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

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

```response title=Response theme={null}
1
0
```

**Utiliser des entiers pour accéder à la fois aux tableaux JSON et aux objets JSON**

```sql title=Query theme={null}
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 title=Response theme={null}
0
1
1
1
1
1
0
```

<div id="prettyPrintJSON">
  ## prettyPrintJSON
</div>

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

```sql theme={null}
prettyPrintJSON(json [, indent])
```

**Arguments**

* `json` — Une chaîne JSON valide à mettre en forme. [`String`](/fr/reference/data-types/string)
* `indent` — Nombre d'espaces par niveau d'indentation. Par défaut : 4. Max : 32 [`UInt*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Une chaîne JSON formatée avec indentation. [`String`](/fr/reference/data-types/string)

**Exemples**

**Objet simple**

```sql title=Query theme={null}
SELECT prettyPrintJSON('{"a":1,"b":"hello"}');
```

```response title=Response theme={null}
{
    "a": 1,
    "b": "hello"
}
```

**Retrait personnalisé**

```sql title=Query theme={null}
SELECT prettyPrintJSON('{"a":1}', 8);
```

```response title=Response theme={null}
{
        "a": 1
}
```

<div id="simpleJSONExtractBool">
  ## simpleJSONExtractBool
</div>

Introduit dans : v21.4.0

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

**Syntaxe**

```sql theme={null}
simpleJSONExtractBool(json, field_name)
```

**Alias** : `visitParamExtractBool`

**Arguments**

* `json` — Le JSON dans lequel rechercher le champ. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
0
1
0
0
```

<div id="simpleJSONExtractFloat">
  ## simpleJSONExtractFloat
</div>

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

```sql theme={null}
simpleJSONExtractFloat(json, field_name)
```

**Alias** : `visitParamExtractFloat`

**Arguments**

* `json` — Le JSON dans lequel le champ est recherché. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le nombre extrait du champ si celui-ci existe et contient un nombre, sinon `0`. [`Float64`](/fr/reference/data-types/float)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
0
-4000
0
-3.4
5
```

<div id="simpleJSONExtractInt">
  ## simpleJSONExtractInt
</div>

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

```sql theme={null}
simpleJSONExtractInt(json, field_name)
```

**Alias** : `visitParamExtractInt`

**Arguments**

* `json` — Le JSON dans lequel le champ est recherché. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le nombre extrait du champ si celui-ci existe et contient un nombre, `0` sinon [`Int64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
0
-4
0
-3
5
```

<div id="simpleJSONExtractRaw">
  ## simpleJSONExtractRaw
</div>

Introduit dans : v21.4.0

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

**Syntaxe**

```sql theme={null}
simpleJSONExtractRaw(json, field_name)
```

**Alias** : `visitParamExtractRaw`

**Arguments**

* `json` — Le JSON dans lequel le champ est recherché. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/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`](/fr/reference/data-types/string)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
"-4e3"
-3.4
5
{"def":[1,2,3]}
```

<div id="simpleJSONExtractString">
  ## simpleJSONExtractString
</div>

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

```sql theme={null}
simpleJSONExtractString(json, field_name)
```

**Alias** : `visitParamExtractString`

**Arguments**

* `json` — Le JSON dans lequel rechercher le champ. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/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`](/fr/reference/data-types/string)

**Exemples**

**Exemple d’utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
\n\0

☺
```

<div id="simpleJSONExtractUInt">
  ## simpleJSONExtractUInt
</div>

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

```sql theme={null}
simpleJSONExtractUInt(json, field_name)
```

**Alias** : `visitParamExtractUInt`

**Arguments**

* `json` — Le JSON dans lequel le champ est recherché. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie le nombre extrait du champ si celui-ci existe et contient un nombre, `0` sinon [`UInt64`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
0
4
0
3
5
```

<div id="simpleJSONHas">
  ## simpleJSONHas
</div>

Introduit dans : v21.4.0

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

**Syntaxe**

```sql theme={null}
simpleJSONHas(json, field_name)
```

**Alias** : `visitParamHas`

**Arguments**

* `json` — Le JSON dans lequel rechercher le champ. [`String`](/fr/reference/data-types/string)
* `field_name` — Le nom du champ à rechercher. [`const String`](/fr/reference/data-types/string)

**Valeur renvoyée**

Renvoie `1` si le champ existe, `0` sinon [`UInt8`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

```sql title=Query theme={null}
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 title=Response theme={null}
1
0
```

<div id="toJSONString">
  ## toJSONString
</div>

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](/fr/reference/data-types/int-uint) 64 bits ou plus (comme `UInt64` ou `Int128`) sont placés entre guillemets par défaut. [output\_format\_json\_quote\_64bit\_integers](/fr/reference/settings/formats#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](/fr/reference/settings/formats#output_format_json_quote_denormals) pour les afficher.
Lors de la sérialisation d’une valeur [Enum](/fr/reference/data-types/enum), la fonction renvoie son nom.

Voir aussi :

* [output\_format\_json\_quote\_64bit\_integers](/fr/reference/settings/formats#output_format_json_quote_64bit_integers)
* [output\_format\_json\_quote\_denormals](/fr/reference/settings/formats#output_format_json_quote_denormals)

**Syntaxe**

```sql theme={null}
toJSONString(value)
```

**Arguments**

* `value` — Valeur à sérialiser. La valeur peut être de n’importe quel type de données. [`Any`](/fr/reference/data-types/index)

**Valeur renvoyée**

Renvoie la représentation JSON de la valeur. [`String`](/fr/reference/data-types/string)

**Exemples**

**Sérialisation d’une Map**

```sql title=Query theme={null}
SELECT toJSONString(map('key1', 1, 'key2', 2));
```

```response title=Response theme={null}
┌─toJSONString(map('key1', 1, 'key2', 2))─┐
│ {"key1":1,"key2":2}                     │
└─────────────────────────────────────────┘
```

**Valeurs spéciales**

```sql title=Query theme={null}
SELECT toJSONString(tuple(1.25, NULL, NaN, +inf, -inf, [])) SETTINGS output_format_json_quote_denormals = 1;
```

```response title=Response theme={null}
┌─toJSONString(tuple(1.25, NULL, NaN, plus(inf), minus(inf), []))─┐
│ [1.25,null,"nan","inf","-inf",[]]                               │
└─────────────────────────────────────────────────────────────────┘
```