> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Page décrivant l’inférence automatique du schéma à partir des données d’entrée dans ClickHouse
# Inférence automatique du schéma à partir des données d’entrée
ClickHouse peut déterminer automatiquement la structure des données d’entrée dans presque tous les [formats d’entrée](/fr/reference/formats/index).
Ce document explique quand l’inférence de schéma est utilisée, comment elle fonctionne avec différents formats d’entrée et quels paramètres
permettent de la contrôler.
## Utilisation
L’inférence de schéma est utilisée lorsque ClickHouse doit lire des données dans un format spécifique et que la structure est inconnue.
## Fonctions de table [file](/fr/reference/functions/table-functions/file), [s3](/fr/reference/functions/table-functions/s3), [url](/fr/reference/functions/table-functions/url), [hdfs](/fr/reference/functions/table-functions/hdfs), [azureBlobStorage](/fr/reference/functions/table-functions/azureBlobStorage).
Ces fonctions de table incluent l’argument facultatif `structure`, qui définit la structure des données d’entrée. Si cet argument n’est pas spécifié ou s’il est défini sur `auto`, la structure sera inférée à partir des données.
**Exemple :**
Supposons que nous ayons un fichier `hobbies.jsonl` au format JSONEachRow dans le répertoire `user_files`, avec le contenu suivant :
```json theme={null}
{"id" : 1, "age" : 25, "name" : "Josh", "hobbies" : ["football", "cooking", "music"]}
{"id" : 2, "age" : 19, "name" : "Alan", "hobbies" : ["tennis", "art"]}
{"id" : 3, "age" : 32, "name" : "Lana", "hobbies" : ["fitness", "reading", "shopping"]}
{"id" : 4, "age" : 47, "name" : "Brayan", "hobbies" : ["movies", "skydiving"]}
```
ClickHouse peut lire ces données sans que vous ayez à préciser leur structure :
```sql theme={null}
SELECT * FROM file('hobbies.jsonl')
```
```response theme={null}
┌─id─┬─age─┬─name───┬─hobbies──────────────────────────┐
│ 1 │ 25 │ Josh │ ['football','cooking','music'] │
│ 2 │ 19 │ Alan │ ['tennis','art'] │
│ 3 │ 32 │ Lana │ ['fitness','reading','shopping'] │
│ 4 │ 47 │ Brayan │ ['movies','skydiving'] │
└────┴─────┴────────┴──────────────────────────────────┘
```
Remarque : le format `JSONEachRow` a été détecté automatiquement à partir de l’extension de fichier `.jsonl`.
Vous pouvez afficher la structure détectée automatiquement à l’aide de la requête `DESCRIBE` :
```sql theme={null}
DESCRIBE file('hobbies.jsonl')
```
```response theme={null}
┌─name────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ id │ Nullable(Int64) │ │ │ │ │ │
│ age │ Nullable(Int64) │ │ │ │ │ │
│ name │ Nullable(String) │ │ │ │ │ │
│ hobbies │ Array(Nullable(String)) │ │ │ │ │ │
└─────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
## Moteurs de table [File](/fr/reference/engines/table-engines/special/file), [S3](/fr/reference/engines/table-engines/integrations/s3), [URL](/fr/reference/engines/table-engines/special/url), [HDFS](/fr/reference/engines/table-engines/integrations/hdfs), [azureBlobStorage](/fr/reference/engines/table-engines/integrations/azureBlobStorage)
Si la liste des colonnes n’est pas spécifiée dans la requête `CREATE TABLE`, la structure de la table sera automatiquement inférée à partir des données.
**Exemple :**
Utilisons le fichier `hobbies.jsonl`. Nous pouvons créer une table avec le moteur `File` à partir des données de ce fichier :
```sql theme={null}
CREATE TABLE hobbies ENGINE=File(JSONEachRow, 'hobbies.jsonl')
```
```response theme={null}
Ok.
```
```sql theme={null}
SELECT * FROM hobbies
```
```response theme={null}
┌─id─┬─age─┬─name───┬─hobbies──────────────────────────┐
│ 1 │ 25 │ Josh │ ['football','cooking','music'] │
│ 2 │ 19 │ Alan │ ['tennis','art'] │
│ 3 │ 32 │ Lana │ ['fitness','reading','shopping'] │
│ 4 │ 47 │ Brayan │ ['movies','skydiving'] │
└────┴─────┴────────┴──────────────────────────────────┘
```
```sql theme={null}
DESCRIBE TABLE hobbies
```
```response theme={null}
┌─name────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ id │ Nullable(Int64) │ │ │ │ │ │
│ age │ Nullable(Int64) │ │ │ │ │ │
│ name │ Nullable(String) │ │ │ │ │ │
│ hobbies │ Array(Nullable(String)) │ │ │ │ │ │
└─────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
## clickhouse-local
`clickhouse-local` dispose d’un paramètre facultatif `-S/--structure` permettant de définir la structure des données d’entrée. Si ce paramètre n’est pas renseigné ou s’il est défini sur `auto`, la structure sera inférée à partir des données.
**Exemple :**
Utilisons le fichier `hobbies.jsonl`. Nous pouvons interroger les données de ce fichier avec `clickhouse-local` :
```shell theme={null}
clickhouse-local --file='hobbies.jsonl' --table='hobbies' --query='DESCRIBE TABLE hobbies'
```
```response theme={null}
id Nullable(Int64)
age Nullable(Int64)
name Nullable(String)
hobbies Array(Nullable(String))
```
```shell theme={null}
clickhouse-local --file='hobbies.jsonl' --table='hobbies' --query='SELECT * FROM hobbies'
```
```response theme={null}
1 25 Josh ['football','cooking','music']
2 19 Alan ['tennis','art']
3 32 Lana ['fitness','reading','shopping']
4 47 Brayan ['movies','skydiving']
```
## Utilisation de la structure de la table d’insertion
Lorsque les fonctions de table `file/s3/url/hdfs` sont utilisées pour insérer des données dans une table,
il est possible d’utiliser la structure de la table d’insertion au lieu de l’extraire des données.
Cela peut améliorer les performances d’insertion, car l’inférence de schéma peut prendre un certain temps. Cela est également utile lorsque la table possède un schéma optimisé, car
aucune conversion de type ne sera alors effectuée.
Il existe un paramètre spécial [use\_structure\_from\_insertion\_table\_in\_table\_functions](/fr/reference/settings/session-settings#use_structure_from_insertion_table_in_table_functions)
qui contrôle ce comportement. Il a 3 valeurs possibles :
* 0 - la fonction de table extraira la structure des données.
* 1 - la fonction de table utilisera la structure de la table d’insertion.
* 2 - ClickHouse déterminera automatiquement s’il est possible d’utiliser la structure de la table d’insertion ou de recourir à l’inférence de schéma. Valeur par défaut.
**Exemple 1 :**
Créons la table `hobbies1` avec la structure suivante :
```sql theme={null}
CREATE TABLE hobbies1
(
`id` UInt64,
`age` LowCardinality(UInt8),
`name` String,
`hobbies` Array(String)
)
ENGINE = MergeTree
ORDER BY id;
```
Et insérez les données du fichier `hobbies.jsonl` :
```sql theme={null}
INSERT INTO hobbies1 SELECT * FROM file(hobbies.jsonl)
```
Dans ce cas, toutes les colonnes du fichier sont insérées dans la table sans modification ; ClickHouse utilisera donc la structure de la table d’insertion au lieu de l’inférence de schéma.
**Exemple 2 :**
Créons la table `hobbies2` avec la structure suivante :
```sql theme={null}
CREATE TABLE hobbies2
(
`id` UInt64,
`age` LowCardinality(UInt8),
`hobbies` Array(String)
)
ENGINE = MergeTree
ORDER BY id;
```
Et insérez les données du fichier `hobbies.jsonl` :
```sql theme={null}
INSERT INTO hobbies2 SELECT id, age, hobbies FROM file(hobbies.jsonl)
```
Dans ce cas, toutes les colonnes de la requête `SELECT` sont présentes dans la table, donc ClickHouse utilisera la structure de la table d’insertion.
Notez que cela ne fonctionne que pour les formats d’entrée qui prennent en charge la lecture d’un sous-ensemble de colonnes, comme JSONEachRow, TSKV, Parquet, etc. (cela ne fonctionne donc pas, par exemple, avec le format TSV).
**Exemple 3 :**
Créons la table `hobbies3` avec la structure suivante :
```sql theme={null}
CREATE TABLE hobbies3
(
`identifier` UInt64,
`age` LowCardinality(UInt8),
`hobbies` Array(String)
)
ENGINE = MergeTree
ORDER BY identifier;
```
Et insérez les données à partir du fichier `hobbies.jsonl` :
```sql theme={null}
INSERT INTO hobbies3 SELECT id, age, hobbies FROM file(hobbies.jsonl)
```
Dans ce cas, la colonne `id` est utilisée dans la requête `SELECT`, mais la table ne contient pas cette colonne (elle contient une colonne nommée `identifier`) ;
ClickHouse ne peut donc pas utiliser la structure de la table d’insertion, et l’inférence de schéma sera utilisée.
**Exemple 4 :**
Créons la table `hobbies4` avec la structure suivante :
```sql theme={null}
CREATE TABLE hobbies4
(
`id` UInt64,
`any_hobby` Nullable(String)
)
ENGINE = MergeTree
ORDER BY id;
```
Puis insérez des données depuis le fichier `hobbies.jsonl` :
```sql theme={null}
INSERT INTO hobbies4 SELECT id, empty(hobbies) ? NULL : hobbies[1] FROM file(hobbies.jsonl)
```
Dans ce cas, certaines opérations sont appliquées à la colonne `hobbies` dans la requête `SELECT` avant son insertion dans la table ; ClickHouse ne peut donc pas utiliser la structure de la table d’insertion, et l’inférence de schéma sera utilisée.
## Cache d’inférence de schéma
Pour la plupart des formats d’entrée, l’inférence de schéma lit une partie des données pour en déterminer la structure, et ce processus peut prendre un certain temps.
Pour éviter de réinférer le même schéma chaque fois que ClickHouse lit les données du même fichier, le schéma inféré est mis en cache et, lors d’un nouvel accès au même fichier, ClickHouse utilise le schéma du cache.
Il existe des paramètres spéciaux qui contrôlent ce cache :
* `schema_inference_cache_max_elements_for_{file/s3/hdfs/url/azure}` - le nombre maximal de schémas mis en cache pour la fonction de table correspondante. La valeur par défaut est `4096`. Ces paramètres doivent être définis dans la configuration du serveur.
* `schema_inference_use_cache_for_{file,s3,hdfs,url,azure}` - permet d’activer ou de désactiver l’utilisation du cache pour l’inférence de schéma. Ces paramètres peuvent être utilisés dans les requêtes.
Le schéma du fichier peut être modifié en changeant les données ou les paramètres de format.
Pour cette raison, le cache d’inférence de schéma identifie le schéma à partir de la source du fichier, du nom du format, des paramètres de format utilisés et de la date de dernière modification du fichier.
Remarque : certains fichiers accessibles par URL dans la fonction de table `url` peuvent ne pas contenir d’informations sur la date de dernière modification ; dans ce cas, il existe un paramètre spécial
`schema_inference_cache_require_modification_time_for_url`. Désactiver ce paramètre permet d’utiliser le schéma du cache sans date de dernière modification pour ces fichiers.
Il existe également une table système [schema\_inference\_cache](/fr/reference/system-tables/schema_inference_cache) contenant tous les schémas actuellement présents dans le cache, ainsi que la requête système `SYSTEM CLEAR SCHEMA CACHE [FOR File/S3/URL/HDFS]`
qui permet de vider le cache d’inférence de schéma pour toutes les sources ou pour une source spécifique.
**Exemples :**
Essayons d’inférer la structure d’un jeu de données d’exemple depuis S3 `github-2022.ndjson.gz` et voyons comment fonctionne le cache d’inférence de schéma :
```sql theme={null}
DESCRIBE TABLE s3('https://datasets-documentation.s3.eu-west-3.amazonaws.com/github/github-2022.ndjson.gz')
```
```response theme={null}
┌─name───────┬─type─────────────────────────────────────────┐
│ type │ Nullable(String) │
│ actor │ Tuple( ↴│
│ │↳ avatar_url Nullable(String), ↴│
│ │↳ display_login Nullable(String), ↴│
│ │↳ id Nullable(Int64), ↴│
│ │↳ login Nullable(String), ↴│
│ │↳ url Nullable(String)) │
│ repo │ Tuple( ↴│
│ │↳ id Nullable(Int64), ↴│
│ │↳ name Nullable(String), ↴│
│ │↳ url Nullable(String)) │
│ created_at │ Nullable(String) │
│ payload │ Tuple( ↴│
│ │↳ action Nullable(String), ↴│
│ │↳ distinct_size Nullable(Int64), ↴│
│ │↳ pull_request Tuple( ↴│
│ │↳ author_association Nullable(String),↴│
│ │↳ base Tuple( ↴│
│ │↳ ref Nullable(String), ↴│
│ │↳ sha Nullable(String)), ↴│
│ │↳ head Tuple( ↴│
│ │↳ ref Nullable(String), ↴│
│ │↳ sha Nullable(String)), ↴│
│ │↳ number Nullable(Int64), ↴│
│ │↳ state Nullable(String), ↴│
│ │↳ title Nullable(String), ↴│
│ │↳ updated_at Nullable(String), ↴│
│ │↳ user Tuple( ↴│
│ │↳ login Nullable(String))), ↴│
│ │↳ ref Nullable(String), ↴│
│ │↳ ref_type Nullable(String), ↴│
│ │↳ size Nullable(Int64)) │
└────────────┴──────────────────────────────────────────────┘
5 rows in set. Elapsed: 0.601 sec.
```
```sql theme={null}
DESCRIBE TABLE s3('https://datasets-documentation.s3.eu-west-3.amazonaws.com/github/github-2022.ndjson.gz')
```
```response theme={null}
┌─name───────┬─type─────────────────────────────────────────┐
│ type │ Nullable(String) │
│ actor │ Tuple( ↴│
│ │↳ avatar_url Nullable(String), ↴│
│ │↳ display_login Nullable(String), ↴│
│ │↳ id Nullable(Int64), ↴│
│ │↳ login Nullable(String), ↴│
│ │↳ url Nullable(String)) │
│ repo │ Tuple( ↴│
│ │↳ id Nullable(Int64), ↴│
│ │↳ name Nullable(String), ↴│
│ │↳ url Nullable(String)) │
│ created_at │ Nullable(String) │
│ payload │ Tuple( ↴│
│ │↳ action Nullable(String), ↴│
│ │↳ distinct_size Nullable(Int64), ↴│
│ │↳ pull_request Tuple( ↴│
│ │↳ author_association Nullable(String),↴│
│ │↳ base Tuple( ↴│
│ │↳ ref Nullable(String), ↴│
│ │↳ sha Nullable(String)), ↴│
│ │↳ head Tuple( ↴│
│ │↳ ref Nullable(String), ↴│
│ │↳ sha Nullable(String)), ↴│
│ │↳ number Nullable(Int64), ↴│
│ │↳ state Nullable(String), ↴│
│ │↳ title Nullable(String), ↴│
│ │↳ updated_at Nullable(String), ↴│
│ │↳ user Tuple( ↴│
│ │↳ login Nullable(String))), ↴│
│ │↳ ref Nullable(String), ↴│
│ │↳ ref_type Nullable(String), ↴│
│ │↳ size Nullable(Int64)) │
└────────────┴──────────────────────────────────────────────┘
5 rows in set. Elapsed: 0.059 sec.
```
Comme vous pouvez le voir, la seconde requête s’est exécutée presque instantanément.
Essayons de modifier certains paramètres qui peuvent affecter le schéma inféré :
```sql theme={null}
DESCRIBE TABLE s3('https://datasets-documentation.s3.eu-west-3.amazonaws.com/github/github-2022.ndjson.gz')
SETTINGS input_format_json_try_infer_named_tuples_from_objects=0, input_format_json_read_objects_as_strings = 1
┌─name───────┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ type │ Nullable(String) │ │ │ │ │ │
│ actor │ Nullable(String) │ │ │ │ │ │
│ repo │ Nullable(String) │ │ │ │ │ │
│ created_at │ Nullable(String) │ │ │ │ │ │
│ payload │ Nullable(String) │ │ │ │ │ │
└────────────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
5 rows in set. Elapsed: 0.611 sec
```
Comme vous pouvez le voir, le schéma mis en cache n’a pas été utilisé pour le même fichier, car le paramètre susceptible d’affecter le schéma inféré a été modifié.
Vérifions le contenu de la table `system.schema_inference_cache` :
```sql theme={null}
SELECT schema, format, source FROM system.schema_inference_cache WHERE storage='S3'
```
```response theme={null}
┌─schema──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─format─┬─source───────────────────────────────────────────────────────────────────────────────────────────────────┐
│ type Nullable(String), actor Tuple(avatar_url Nullable(String), display_login Nullable(String), id Nullable(Int64), login Nullable(String), url Nullable(String)), repo Tuple(id Nullable(Int64), name Nullable(String), url Nullable(String)), created_at Nullable(String), payload Tuple(action Nullable(String), distinct_size Nullable(Int64), pull_request Tuple(author_association Nullable(String), base Tuple(ref Nullable(String), sha Nullable(String)), head Tuple(ref Nullable(String), sha Nullable(String)), number Nullable(Int64), state Nullable(String), title Nullable(String), updated_at Nullable(String), user Tuple(login Nullable(String))), ref Nullable(String), ref_type Nullable(String), size Nullable(Int64)) │ NDJSON │ datasets-documentation.s3.eu-west-3.amazonaws.com443/datasets-documentation/github/github-2022.ndjson.gz │
│ type Nullable(String), actor Nullable(String), repo Nullable(String), created_at Nullable(String), payload Nullable(String) │ NDJSON │ datasets-documentation.s3.eu-west-3.amazonaws.com443/datasets-documentation/github/github-2022.ndjson.gz │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴────────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Comme vous pouvez le constater, il existe deux schémas différents pour le même fichier.
Nous pouvons vider le cache des schémas à l’aide d’une requête SYSTEM :
```sql theme={null}
SYSTEM CLEAR SCHEMA CACHE FOR S3
```
```response theme={null}
Ok.
```
```sql theme={null}
SELECT count() FROM system.schema_inference_cache WHERE storage='S3'
```
```response theme={null}
┌─count()─┐
│ 0 │
└─────────┘
```
## Formats textuels
Pour les formats textuels, ClickHouse lit les données ligne par ligne, extrait les valeurs des colonnes selon le format,
puis utilise des parseurs récursifs et des heuristiques pour déterminer le type de chaque valeur. Le nombre maximal de lignes et d’octets lus dans les données lors de l’inférence de schéma
est contrôlé par les paramètres `input_format_max_rows_to_read_for_schema_inference` (25000 par défaut) et `input_format_max_bytes_to_read_for_schema_inference` (32Mb par défaut).
Par défaut, tous les types inférés sont [Nullable](/fr/reference/data-types/nullable), mais vous pouvez modifier ce comportement en définissant `schema_inference_make_columns_nullable` (voir des exemples dans la section [paramètres](#settings-for-text-formats)).
### Formats JSON
Dans les formats JSON, ClickHouse analyse les valeurs conformément à la spécification JSON, puis tente de déterminer le type de données le plus approprié pour chacune d'elles.
Voyons comment cela fonctionne, quels types peuvent être inférés et quels paramètres spécifiques peuvent être utilisés dans les formats JSON.
**Exemples**
Ici et dans la suite, la table function [format](/fr/reference/functions/table-functions/format) sera utilisée dans les exemples.
Integers, Floats, Bools, Strings :
```sql theme={null}
DESC format(JSONEachRow, '{"int" : 42, "float" : 42.42, "string" : "Hello, World!"}');
```
```response theme={null}
┌─name───┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ int │ Nullable(Int64) │ │ │ │ │ │
│ float │ Nullable(Float64) │ │ │ │ │ │
│ bool │ Nullable(Bool) │ │ │ │ │ │
│ string │ Nullable(String) │ │ │ │ │ │
└────────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Dates, DateTimes :
```sql theme={null}
DESC format(JSONEachRow, '{"date" : "2022-01-01", "datetime" : "2022-01-01 00:00:00", "datetime64" : "2022-01-01 00:00:00.000"}')
```
```response theme={null}
┌─name───────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ date │ Nullable(Date) │ │ │ │ │ │
│ datetime │ Nullable(DateTime) │ │ │ │ │ │
│ datetime64 │ Nullable(DateTime64(9)) │ │ │ │ │ │
└────────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Arrays :
```sql theme={null}
DESC format(JSONEachRow, '{"arr" : [1, 2, 3], "nested_arrays" : [[1, 2, 3], [4, 5, 6], []]}')
```
```response theme={null}
┌─name──────────┬─type──────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ arr │ Array(Nullable(Int64)) │ │ │ │ │ │
│ nested_arrays │ Array(Array(Nullable(Int64))) │ │ │ │ │ │
└───────────────┴───────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si un tableau contient `null`, ClickHouse utilisera les types des autres éléments du tableau :
```sql theme={null}
DESC format(JSONEachRow, '{"arr" : [null, 42, null]}')
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ arr │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si un tableau contient des valeurs de types différents et que le paramètre `input_format_json_infer_array_of_dynamic_from_array_of_different_types` est activé (activé par défaut), il aura le type `Array(Dynamic)` :
```sql theme={null}
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=1;
DESC format(JSONEachRow, '{"arr" : [42, "hello", [1, 2, 3]]}');
```
```response theme={null}
┌─name─┬─type───────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ arr │ Array(Dynamic) │ │ │ │ │ │
└──────┴────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Tuples nommés :
Lorsque le paramètre `input_format_json_try_infer_named_tuples_from_objects` est activé, ClickHouse tentera, lors de l’inférence de schéma, d’inférer un Tuple nommé à partir d’objets JSON.
Le Tuple nommé obtenu contiendra tous les éléments de tous les objets JSON correspondants présents dans les données d’échantillon.
```sql theme={null}
SET input_format_json_try_infer_named_tuples_from_objects = 1;
DESC format(JSONEachRow, '{"obj" : {"a" : 42, "b" : "Hello"}}, {"obj" : {"a" : 43, "c" : [1, 2, 3]}}, {"obj" : {"d" : {"e" : 42}}}')
```
```response theme={null}
┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Tuple(a Nullable(Int64), b Nullable(String), c Array(Nullable(Int64)), d Tuple(e Nullable(Int64))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Tuples non nommés :
Si le paramètre `input_format_json_infer_array_of_dynamic_from_array_of_different_types` est désactivé, les Arrays dont les éléments sont de types différents sont traités comme des Tuples non nommés dans les formats JSON.
```sql theme={null}
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types = 0;
DESC format(JSONEachRow, '{"tuple" : [1, "Hello, World!", [1, 2, 3]]}')
```
```response theme={null}
┌─name──┬─type─────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ tuple │ Tuple(Nullable(Int64), Nullable(String), Array(Nullable(Int64))) │ │ │ │ │ │
└───────┴──────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si certaines valeurs sont `null` ou vides, nous utilisons les types des valeurs correspondantes présentes dans les autres lignes :
```sql theme={null}
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=0;
DESC format(JSONEachRow, $$
{"tuple" : [1, null, null]}
{"tuple" : [null, "Hello, World!", []]}
{"tuple" : [null, null, [1, 2, 3]]}
$$)
```
```response theme={null}
┌─name──┬─type─────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ tuple │ Tuple(Nullable(Int64), Nullable(String), Array(Nullable(Int64))) │ │ │ │ │ │
└───────┴──────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Maps :
En JSON, il est possible de lire des objets dont les valeurs sont du même type que le type Map.
Remarque : cela ne fonctionne que lorsque les paramètres `input_format_json_read_objects_as_strings` et `input_format_json_try_infer_named_tuples_from_objects` sont désactivés.
```sql theme={null}
SET input_format_json_read_objects_as_strings = 0, input_format_json_try_infer_named_tuples_from_objects = 0;
DESC format(JSONEachRow, '{"map" : {"key1" : 42, "key2" : 24, "key3" : 4}}')
```
```response theme={null}
┌─name─┬─type─────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ map │ Map(String, Nullable(Int64)) │ │ │ │ │ │
└──────┴──────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Types complexes Nested :
```sql theme={null}
DESC format(JSONEachRow, '{"value" : [[[42, 24], []], {"key1" : 42, "key2" : 24}]}')
```
```response theme={null}
┌─name──┬─type─────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ value │ Tuple(Array(Array(Nullable(String))), Tuple(key1 Nullable(Int64), key2 Nullable(Int64))) │ │ │ │ │ │
└───────┴──────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si ClickHouse ne peut pas déterminer le type d’une clé parce que les données ne contiennent que des valeurs nulles/objets vides/tableaux vides, le type `String` sera utilisé si le paramètre `input_format_json_infer_incomplete_types_as_strings` est activé ; sinon, une exception sera levée :
```sql theme={null}
DESC format(JSONEachRow, '{"arr" : [null, null]}') SETTINGS input_format_json_infer_incomplete_types_as_strings = 1;
```
```response theme={null}
┌─name─┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ arr │ Array(Nullable(String)) │ │ │ │ │ │
└──────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(JSONEachRow, '{"arr" : [null, null]}') SETTINGS input_format_json_infer_incomplete_types_as_strings = 0;
```
```response theme={null}
Code: 652. DB::Exception: Received from localhost:9000. DB::Exception:
Cannot determine type for column 'arr' by first 1 rows of data,
most likely this column contains only Nulls or empty Arrays/Maps.
...
```
#### Paramètres JSON
##### input\_format\_json\_try\_infer\_numbers\_from\_strings
L’activation de ce paramètre permet de déduire des nombres à partir de valeurs de type chaîne.
Ce paramètre est désactivé par défaut.
**Exemple :**
```sql theme={null}
SET input_format_json_try_infer_numbers_from_strings = 1;
DESC format(JSONEachRow, $$
{"value" : "42"}
{"value" : "424242424242"}
$$)
```
```response theme={null}
┌─name──┬─type────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ value │ Nullable(Int64) │ │ │ │ │ │
└───────┴─────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
##### input\_format\_json\_try\_infer\_named\_tuples\_from\_objects
L’activation de ce paramètre permet d’inférer des tuples nommés à partir d’objets JSON. Le tuple nommé obtenu contiendra tous les éléments de tous les objets JSON correspondants présents dans l’échantillon de données.
Cela peut être utile lorsque les données JSON ne sont pas clairsemées, de sorte que l’échantillon de données contienne toutes les clés d’objet possibles.
Ce paramètre est activé par défaut.
**Exemple**
```sql title="Query" theme={null}
SET input_format_json_try_infer_named_tuples_from_objects = 1;
DESC format(JSONEachRow, '{"obj" : {"a" : 42, "b" : "Hello"}}, {"obj" : {"a" : 43, "c" : [1, 2, 3]}}, {"obj" : {"d" : {"e" : 42}}}')
```
```response title="Response" theme={null}
┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Tuple(a Nullable(Int64), b Nullable(String), c Array(Nullable(Int64)), d Tuple(e Nullable(Int64))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql title="Query" theme={null}
SET input_format_json_try_infer_named_tuples_from_objects = 1;
DESC format(JSONEachRow, '{"array" : [{"a" : 42, "b" : "Hello"}, {}, {"c" : [1,2,3]}, {"d" : "2020-01-01"}]}')
```
```markdown title="Response" theme={null}
┌─name──┬─type────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ array │ Array(Tuple(a Nullable(Int64), b Nullable(String), c Array(Nullable(Int64)), d Nullable(Date))) │ │ │ │ │ │
└───────┴─────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
##### input\_format\_json\_use\_string\_type\_for\_ambiguous\_paths\_in\_named\_tuples\_inference\_from\_objects
L’activation de ce paramètre permet d’utiliser le type String pour les chemins ambigus lors de l’inférence de tuples nommés à partir d’objets JSON (lorsque `input_format_json_try_infer_named_tuples_from_objects` est activé), au lieu de lever une exception.
Cela permet de lire des objets JSON comme des tuples nommés même en présence de chemins ambigus.
Désactivé par défaut.
**Exemples**
Avec le paramètre désactivé :
```sql title="Query" theme={null}
SET input_format_json_try_infer_named_tuples_from_objects = 1;
SET input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects = 0;
DESC format(JSONEachRow, '{"obj" : {"a" : 42}}, {"obj" : {"a" : {"b" : "Hello"}}}');
```
```response title="Response" theme={null}
Code: 636. DB::Exception: The table structure cannot be extracted from a JSONEachRow format file. Error:
Code: 117. DB::Exception: JSON objects have ambiguous data: in some objects path 'a' has type 'Int64' and in some - 'Tuple(b String)'. You can enable setting input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects to use String type for path 'a'. (INCORRECT_DATA) (version 24.3.1.1).
You can specify the structure manually. (CANNOT_EXTRACT_TABLE_STRUCTURE)
```
Lorsque ce paramètre est activé :
```sql title="Query" theme={null}
SET input_format_json_try_infer_named_tuples_from_objects = 1;
SET input_format_json_use_string_type_for_ambiguous_paths_in_named_tuples_inference_from_objects = 1;
DESC format(JSONEachRow, '{"obj" : "a" : 42}, {"obj" : {"a" : {"b" : "Hello"}}}');
SELECT * FROM format(JSONEachRow, '{"obj" : {"a" : 42}}, {"obj" : {"a" : {"b" : "Hello"}}}');
```
```response title="Response" theme={null}
┌─name─┬─type──────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Tuple(a Nullable(String)) │ │ │ │ │ │
└──────┴───────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
┌─obj─────────────────┐
│ ('42') │
│ ('{"b" : "Hello"}') │
└─────────────────────┘
```
##### input\_format\_json\_read\_objects\_as\_strings
L’activation de ce paramètre permet de lire les objets JSON imbriqués sous forme de chaînes.
Ce paramètre peut être utilisé pour lire des objets JSON imbriqués sans utiliser le type JSON object.
Ce paramètre est activé par défaut.
Remarque : l’activation de ce paramètre ne prend effet que si le paramètre `input_format_json_try_infer_named_tuples_from_objects` est désactivé.
```sql theme={null}
SET input_format_json_read_objects_as_strings = 1, input_format_json_try_infer_named_tuples_from_objects = 0;
DESC format(JSONEachRow, $$
{"obj" : {"key1" : 42, "key2" : [1,2,3,4]}}
{"obj" : {"key3" : {"nested_key" : 1}}}
$$)
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
##### input\_format\_json\_read\_numbers\_as\_strings
L’activation de ce paramètre permet de lire les valeurs numériques sous forme de chaînes.
Ce paramètre est activé par défaut.
**Exemple**
```sql theme={null}
SET input_format_json_read_numbers_as_strings = 1;
DESC format(JSONEachRow, $$
{"value" : 1055}
{"value" : "unknown"}
$$)
```
```response theme={null}
┌─name──┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ value │ Nullable(String) │ │ │ │ │ │
└───────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
##### input\_format\_json\_read\_bools\_as\_numbers
L’activation de ce paramètre permet de lire les valeurs booléennes comme des nombres.
Ce paramètre est activé par défaut.
**Exemple :**
```sql theme={null}
SET input_format_json_read_bools_as_numbers = 1;
DESC format(JSONEachRow, $$
{"value" : true}
{"value" : 42}
$$)
```
```response theme={null}
┌─name──┬─type────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ value │ Nullable(Int64) │ │ │ │ │ │
└───────┴─────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
##### input\_format\_json\_read\_bools\_as\_strings
L’activation de ce paramètre permet de lire les valeurs Bool sous forme de chaînes de caractères.
Ce paramètre est activé par défaut.
**Exemple :**
```sql theme={null}
SET input_format_json_read_bools_as_strings = 1;
DESC format(JSONEachRow, $$
{"value" : true}
{"value" : "Hello, World"}
$$)
```
```response theme={null}
┌─name──┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ value │ Nullable(String) │ │ │ │ │ │
└───────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
##### input\_format\_json\_read\_arrays\_as\_strings
L’activation de ce paramètre permet de lire les valeurs des tableaux JSON sous forme de chaînes de caractères.
Ce paramètre est activé par défaut.
**Exemple**
```sql theme={null}
SET input_format_json_read_arrays_as_strings = 1;
SELECT arr, toTypeName(arr), JSONExtractArrayRaw(arr)[3] from format(JSONEachRow, 'arr String', '{"arr" : [1, "Hello", [1,2,3]]}');
```
```response theme={null}
┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String │ [1,2,3] │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘
```
##### input\_format\_json\_infer\_incomplete\_types\_as\_strings
L’activation de ce paramètre permet d’utiliser le type String pour les clés JSON qui ne contiennent que `Null`/`{}`/`[]` dans l’échantillon de données lors de l’inférence de schéma.
Dans les formats JSON, toute valeur peut être lue comme String si tous les paramètres correspondants sont activés (ils le sont tous par défaut), ce qui permet d’éviter des erreurs comme `Cannot determine type for column 'column_name' by first 25000 rows of data, most likely this column contains only Nulls or empty Arrays/Maps` lors de l’inférence de schéma
en utilisant le type String pour les clés dont le type est inconnu.
Exemple :
```sql title="Query" theme={null}
SET input_format_json_infer_incomplete_types_as_strings = 1, input_format_json_try_infer_named_tuples_from_objects = 1;
DESCRIBE format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}');
SELECT * FROM format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}');
```
```markdown title="Response" theme={null}
┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ obj │ Tuple(a Array(Nullable(Int64)), b Nullable(String), c Nullable(String), d Nullable(String), e Array(Nullable(String))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
┌─obj────────────────────────────┐
│ ([1,2,3],'hello',NULL,'{}',[]) │
└────────────────────────────────┘
```
### CSV
Dans le format CSV, ClickHouse extrait les valeurs de colonne à partir de la ligne en fonction des délimiteurs. ClickHouse s’attend à ce que tous les types, à l’exception des nombres et des chaînes, soient entourés de guillemets doubles. Si la valeur est entre guillemets doubles, ClickHouse essaie d’analyser
le contenu entre guillemets à l’aide du parseur récursif, puis essaie de déterminer le type de données le plus approprié. Si la valeur n’est pas entre guillemets doubles, ClickHouse essaie de l’analyser comme un nombre,
et si la valeur n’est pas un nombre, ClickHouse la traite comme une chaîne.
Si vous ne voulez pas que ClickHouse essaie de déterminer des types complexes à l’aide de certains parseurs et heuristiques, vous pouvez désactiver le paramètre `input_format_csv_use_best_effort_in_schema_inference`
et ClickHouse traitera alors toutes les colonnes comme des Strings.
Si le paramètre `input_format_csv_detect_header` est activé, ClickHouse essaiera de détecter l’en-tête avec les noms de colonnes (et éventuellement les types) lors de l’inférence du schéma. Ce paramètre est activé par défaut.
**Exemples :**
Entiers, Floats, Bools, Strings:
```sql theme={null}
DESC format(CSV, '42,42.42,true,"Hello,World!"')
```
```response theme={null}
┌─name─┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Int64) │ │ │ │ │ │
│ c2 │ Nullable(Float64) │ │ │ │ │ │
│ c3 │ Nullable(Bool) │ │ │ │ │ │
│ c4 │ Nullable(String) │ │ │ │ │ │
└──────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Chaînes sans guillemets :
```sql theme={null}
DESC format(CSV, 'Hello world!,World hello!')
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(String) │ │ │ │ │ │
│ c2 │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Dates, DateTimes :
```sql theme={null}
DESC format(CSV, '"2020-01-01","2020-01-01 00:00:00","2022-01-01 00:00:00.000"')
```
```response theme={null}
┌─name─┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Date) │ │ │ │ │ │
│ c2 │ Nullable(DateTime) │ │ │ │ │ │
│ c3 │ Nullable(DateTime64(9)) │ │ │ │ │ │
└──────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Tableaux :
```sql theme={null}
DESC format(CSV, '"[1,2,3]","[[1, 2], [], [3, 4]]"')
```
```response theme={null}
┌─name─┬─type──────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(Int64)) │ │ │ │ │ │
│ c2 │ Array(Array(Nullable(Int64))) │ │ │ │ │ │
└──────┴───────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(CSV, $$"['Hello', 'world']","[['Abc', 'Def'], []]"$$)
```
```response theme={null}
┌─name─┬─type───────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(String)) │ │ │ │ │ │
│ c2 │ Array(Array(Nullable(String))) │ │ │ │ │ │
└──────┴────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si un tableau contient la valeur NULL, ClickHouse utilisera les types des autres éléments du tableau :
```sql theme={null}
DESC format(CSV, '"[NULL, 42, NULL]"')
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Maps :
```sql theme={null}
DESC format(CSV, $$"{'key1' : 42, 'key2' : 24}"$$)
```
```response theme={null}
┌─name─┬─type─────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Map(String, Nullable(Int64)) │ │ │ │ │ │
└──────┴──────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Nested, tableaux et Maps :
```sql theme={null}
DESC format(CSV, $$"[{'key1' : [[42, 42], []], 'key2' : [[null], [42]]}]"$$)
```
```response theme={null}
┌─name─┬─type──────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Map(String, Array(Array(Nullable(Int64))))) │ │ │ │ │ │
└──────┴───────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si ClickHouse ne peut pas déterminer le type entre guillemets parce que les données ne contiennent que des valeurs NULL, ClickHouse le traitera comme String :
```sql theme={null}
DESC format(CSV, '"[NULL, NULL]"')
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Exemple avec le paramètre `input_format_csv_use_best_effort_in_schema_inference` désactivé :
```sql theme={null}
SET input_format_csv_use_best_effort_in_schema_inference = 0
DESC format(CSV, '"[1,2,3]",42.42,Hello World!')
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(String) │ │ │ │ │ │
│ c2 │ Nullable(String) │ │ │ │ │ │
│ c3 │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Exemples de détection automatique de l’en-tête (lorsque `input_format_csv_detect_header` est activé) :
Noms uniquement :
```sql theme={null}
SELECT * FROM format(CSV,
$$"number","string","array"
42,"Hello","[1, 2, 3]"
43,"World","[4, 5, 6]"
$$)
```
```response theme={null}
┌─number─┬─string─┬─array───┐
│ 42 │ Hello │ [1,2,3] │
│ 43 │ World │ [4,5,6] │
└────────┴────────┴─────────┘
```
Noms et types :
```sql theme={null}
DESC format(CSV,
$$"number","string","array"
"UInt32","String","Array(UInt16)"
42,"Hello","[1, 2, 3]"
43,"World","[4, 5, 6]"
$$)
```
```response theme={null}
┌─name───┬─type──────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ number │ UInt32 │ │ │ │ │ │
│ string │ String │ │ │ │ │ │
│ array │ Array(UInt16) │ │ │ │ │ │
└────────┴───────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Notez que l’en-tête ne peut être détecté que s’il existe au moins une colonne d’un type autre que String. Si toutes les colonnes sont de type String, l’en-tête n’est pas détecté :
```sql theme={null}
SELECT * FROM format(CSV,
$$"first_column","second_column"
"Hello","World"
"World","Hello"
$$)
```
```response theme={null}
┌─c1───────────┬─c2────────────┐
│ first_column │ second_column │
│ Hello │ World │
│ World │ Hello │
└──────────────┴───────────────┘
```
#### Paramètres CSV
##### input\_format\_csv\_try\_infer\_numbers\_from\_strings
L’activation de ce paramètre permet d’inférer des nombres à partir de valeurs de chaîne de caractères.
Ce paramètre est désactivé par défaut.
**Exemple :**
```sql theme={null}
SET input_format_json_try_infer_numbers_from_strings = 1;
DESC format(CSV, '42,42.42');
```
```response theme={null}
┌─name─┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Int64) │ │ │ │ │ │
│ c2 │ Nullable(Float64) │ │ │ │ │ │
└──────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### TSV/TSKV
Dans les formats TSV/TSKV, ClickHouse extrait la valeur de la colonne à partir de la ligne en fonction des délimiteurs de tabulation, puis analyse la valeur extraite à l'aide
du parseur récursif afin de déterminer le type le plus approprié. Si le type ne peut pas être déterminé, ClickHouse traite cette valeur comme String.
Si vous ne souhaitez pas que ClickHouse tente de déterminer des types complexes à l'aide de certains parseurs et heuristiques, vous pouvez désactiver le paramètre `input_format_tsv_use_best_effort_in_schema_inference`
et ClickHouse traitera alors toutes les colonnes comme des Strings.
Si le paramètre `input_format_tsv_detect_header` est activé, ClickHouse essaiera de détecter l'en-tête contenant les noms de colonnes (et éventuellement les types) lors de l'inférence du schéma. Ce paramètre est activé par défaut.
**Exemples :**
Entiers, Floats, Bools, Strings:
```sql theme={null}
DESC format(TSV, '42 42.42 true Hello,World!')
```
```response theme={null}
┌─name─┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Int64) │ │ │ │ │ │
│ c2 │ Nullable(Float64) │ │ │ │ │ │
│ c3 │ Nullable(Bool) │ │ │ │ │ │
│ c4 │ Nullable(String) │ │ │ │ │ │
└──────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(TSKV, 'int=42 float=42.42 bool=true string=Hello,World!\n')
```
```response theme={null}
┌─name───┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ int │ Nullable(Int64) │ │ │ │ │ │
│ float │ Nullable(Float64) │ │ │ │ │ │
│ bool │ Nullable(Bool) │ │ │ │ │ │
│ string │ Nullable(String) │ │ │ │ │ │
└────────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Dates, DateTimes:
```sql theme={null}
DESC format(TSV, '2020-01-01 2020-01-01 00:00:00 2022-01-01 00:00:00.000')
```
```response theme={null}
┌─name─┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Date) │ │ │ │ │ │
│ c2 │ Nullable(DateTime) │ │ │ │ │ │
│ c3 │ Nullable(DateTime64(9)) │ │ │ │ │ │
└──────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
tableaux :
```sql theme={null}
DESC format(TSV, '[1,2,3] [[1, 2], [], [3, 4]]')
```
```response theme={null}
┌─name─┬─type──────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(Int64)) │ │ │ │ │ │
│ c2 │ Array(Array(Nullable(Int64))) │ │ │ │ │ │
└──────┴───────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(TSV, '[''Hello'', ''world''] [[''Abc'', ''Def''], []]')
```
```response theme={null}
┌─name─┬─type───────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(String)) │ │ │ │ │ │
│ c2 │ Array(Array(Nullable(String))) │ │ │ │ │ │
└──────┴────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si un tableau contient NULL, ClickHouse utilisera les types des autres éléments du tableau :
```sql theme={null}
DESC format(TSV, '[NULL, 42, NULL]')
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Tuples :
```sql theme={null}
DESC format(TSV, $$(42, 'Hello, world!')$$)
```
```response theme={null}
┌─name─┬─type─────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Tuple(Nullable(Int64), Nullable(String)) │ │ │ │ │ │
└──────┴──────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Maps :
```sql theme={null}
DESC format(TSV, $${'key1' : 42, 'key2' : 24}$$)
```
```response theme={null}
┌─name─┬─type─────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Map(String, Nullable(Int64)) │ │ │ │ │ │
└──────┴──────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Nested tableaux, Tuples et Maps :
```sql theme={null}
DESC format(TSV, $$[{'key1' : [(42, 'Hello'), (24, NULL)], 'key2' : [(NULL, ','), (42, 'world!')]}]$$)
```
```response theme={null}
┌─name─┬─type────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Map(String, Array(Tuple(Nullable(Int64), Nullable(String))))) │ │ │ │ │ │
└──────┴─────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si ClickHouse ne peut pas déterminer le type parce que les données ne contiennent que des valeurs NULL, ClickHouse le traitera comme String :
```sql theme={null}
DESC format(TSV, '[NULL, NULL]')
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Exemple avec le paramètre `input_format_tsv_use_best_effort_in_schema_inference` désactivé :
```sql theme={null}
SET input_format_tsv_use_best_effort_in_schema_inference = 0
DESC format(TSV, '[1,2,3] 42.42 Hello World!')
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(String) │ │ │ │ │ │
│ c2 │ Nullable(String) │ │ │ │ │ │
│ c3 │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Exemples de détection automatique de l’en-tête (lorsque `input_format_tsv_detect_header` est activé) :
Noms uniquement :
```sql theme={null}
SELECT * FROM format(TSV,
$$number string array
42 Hello [1, 2, 3]
43 World [4, 5, 6]
$$);
```
```response theme={null}
┌─number─┬─string─┬─array───┐
│ 42 │ Hello │ [1,2,3] │
│ 43 │ World │ [4,5,6] │
└────────┴────────┴─────────┘
```
Noms et types :
```sql theme={null}
DESC format(TSV,
$$number string array
UInt32 String Array(UInt16)
42 Hello [1, 2, 3]
43 World [4, 5, 6]
$$)
```
```response theme={null}
┌─name───┬─type──────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ number │ UInt32 │ │ │ │ │ │
│ string │ String │ │ │ │ │ │
│ array │ Array(UInt16) │ │ │ │ │ │
└────────┴───────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Notez que l’en-tête ne peut être détecté que s’il existe au moins une colonne d’un type autre que String. Si toutes les colonnes sont de type String, l’en-tête n’est pas détecté :
```sql theme={null}
SELECT * FROM format(TSV,
$$first_column second_column
Hello World
World Hello
$$)
```
```response theme={null}
┌─c1───────────┬─c2────────────┐
│ first_column │ second_column │
│ Hello │ World │
│ World │ Hello │
└──────────────┴───────────────┘
```
### Valeurs
Dans le format Values, ClickHouse extrait la valeur de la colonne depuis la ligne, puis l'analyse à l'aide du parseur récursif, de la même façon que les littéraux sont analysés.
**Exemples :**
Integers, Floats, Bools, Strings :
```sql theme={null}
DESC format(Values, $$(42, 42.42, true, 'Hello,World!')$$)
```
```response theme={null}
┌─name─┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Int64) │ │ │ │ │ │
│ c2 │ Nullable(Float64) │ │ │ │ │ │
│ c3 │ Nullable(Bool) │ │ │ │ │ │
│ c4 │ Nullable(String) │ │ │ │ │ │
└──────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Dates, DateTimes :
```sql theme={null}
DESC format(Values, $$('2020-01-01', '2020-01-01 00:00:00', '2022-01-01 00:00:00.000')$$)
```
```response theme={null}
┌─name─┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Date) │ │ │ │ │ │
│ c2 │ Nullable(DateTime) │ │ │ │ │ │
│ c3 │ Nullable(DateTime64(9)) │ │ │ │ │ │
└──────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Arrays :
```sql theme={null}
DESC format(Values, '([1,2,3], [[1, 2], [], [3, 4]])')
```
```response theme={null}
┌─name─┬─type──────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(Int64)) │ │ │ │ │ │
│ c2 │ Array(Array(Nullable(Int64))) │ │ │ │ │ │
└──────┴───────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si un tableau contient null, ClickHouse utilisera les types des autres éléments du tableau :
```sql theme={null}
DESC format(Values, '([NULL, 42, NULL])')
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Tuples :
```sql theme={null}
DESC format(Values, $$((42, 'Hello, world!'))$$)
```
```response theme={null}
┌─name─┬─type─────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Tuple(Nullable(Int64), Nullable(String)) │ │ │ │ │ │
└──────┴──────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Maps :
```sql theme={null}
DESC format(Values, $$({'key1' : 42, 'key2' : 24})$$)
```
```response theme={null}
┌─name─┬─type─────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Map(String, Nullable(Int64)) │ │ │ │ │ │
└──────┴──────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Nested Arrays, Tuples et Maps :
```sql theme={null}
DESC format(Values, $$([{'key1' : [(42, 'Hello'), (24, NULL)], 'key2' : [(NULL, ','), (42, 'world!')]}])$$)
```
```response theme={null}
┌─name─┬─type────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Array(Map(String, Array(Tuple(Nullable(Int64), Nullable(String))))) │ │ │ │ │ │
└──────┴─────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Si ClickHouse ne peut pas déterminer le type, car les données ne contiennent que des valeurs NULL, une exception sera levée :
```sql theme={null}
DESC format(Values, '([NULL, NULL])')
```
```response theme={null}
Code: 652. DB::Exception: Received from localhost:9000. DB::Exception:
Cannot determine type for column 'c1' by first 1 rows of data,
most likely this column contains only Nulls or empty Arrays/Maps.
...
```
Exemple avec le paramètre `input_format_tsv_use_best_effort_in_schema_inference` désactivé :
```sql theme={null}
SET input_format_tsv_use_best_effort_in_schema_inference = 0
DESC format(TSV, '[1,2,3] 42.42 Hello World!')
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(String) │ │ │ │ │ │
│ c2 │ Nullable(String) │ │ │ │ │ │
│ c3 │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### CustomSeparated
Dans le format CustomSeparated, ClickHouse extrait d’abord toutes les valeurs des colonnes de la ligne selon les délimiteurs spécifiés, puis tente d’inférer
le type de données de chaque valeur en fonction de la règle d’échappement.
Si le paramètre `input_format_custom_detect_header` est activé, ClickHouse essaiera de détecter l’en-tête contenant les noms de colonnes (et éventuellement les types) lors de l’inférence du schéma. Ce paramètre est activé par défaut.
**Exemple**
```sql theme={null}
SET format_custom_row_before_delimiter = '',
format_custom_row_after_delimiter = '\n',
format_custom_row_between_delimiter = '\n',
format_custom_result_before_delimiter = '\n',
format_custom_result_after_delimiter = '\n',
format_custom_field_delimiter = '',
format_custom_escaping_rule = 'Quoted'
DESC format(CustomSeparated, $$
42.42'Some string 1'[1, NULL, 3]
NULL'Some string 3'[1, 2, NULL]
$$)
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Float64) │ │ │ │ │ │
│ c2 │ Nullable(String) │ │ │ │ │ │
│ c3 │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Exemple de détection automatique de l’en-tête (lorsque `input_format_custom_detect_header` est activé) :
```sql theme={null}
SET format_custom_row_before_delimiter = '',
format_custom_row_after_delimiter = '\n',
format_custom_row_between_delimiter = '\n',
format_custom_result_before_delimiter = '\n',
format_custom_result_after_delimiter = '\n',
format_custom_field_delimiter = '',
format_custom_escaping_rule = 'Quoted'
DESC format(CustomSeparated, $$
'number''string''array'
42.42'Some string 1'[1, NULL, 3]
NULL'Some string 3'[1, 2, NULL]
$$)
```
```response theme={null}
┌─number─┬─string────────┬─array──────┐
│ 42.42 │ Some string 1 │ [1,NULL,3] │
│ ᴺᵁᴸᴸ │ Some string 3 │ [1,2,NULL] │
└────────┴───────────────┴────────────┘
```
### Template
Dans le format Template, ClickHouse extrait d'abord de la ligne les valeurs de toutes les colonnes selon le modèle spécifié, puis essaie d'inférer le type de données de chaque valeur en fonction de sa règle d'échappement.
**Exemple**
Supposons que nous ayons un fichier `resultset` avec le contenu suivant :
```bash theme={null}
${data}
```
Et un fichier `row_format` avec le contenu suivant :
```text theme={null}
${column_1:CSV}${column_2:Quoted}${column_3:JSON}
```
Nous pouvons ensuite exécuter les requêtes suivantes :
```sql theme={null}
SET format_template_rows_between_delimiter = '\n',
format_template_row = 'row_format',
format_template_resultset = 'resultset_format'
DESC format(Template, $$
42.42'Some string 1'[1, null, 2]
\N'Some string 3'[1, 2, null]
$$)
```
```response theme={null}
┌─name─────┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ column_1 │ Nullable(Float64) │ │ │ │ │ │
│ column_2 │ Nullable(String) │ │ │ │ │ │
│ column_3 │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### Regexp
Comme avec Template, dans le format Regexp, ClickHouse extrait d’abord de la ligne toutes les valeurs des colonnes selon l’expression régulière spécifiée, puis tente d’inférer
le type de données de chaque valeur selon la règle d’échappement spécifiée.
**Exemple**
```sql theme={null}
SET format_regexp = '^Line: value_1=(.+?), value_2=(.+?), value_3=(.+?)',
format_regexp_escaping_rule = 'CSV'
DESC format(Regexp, $$Line: value_1=42, value_2="Some string 1", value_3="[1, NULL, 3]"
Line: value_1=2, value_2="Some string 2", value_3="[4, 5, NULL]"$$)
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Int64) │ │ │ │ │ │
│ c2 │ Nullable(String) │ │ │ │ │ │
│ c3 │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### Paramètres des formats texte
#### input\_format\_max\_rows\_to\_read\_for\_schema\_inference/input\_format\_max\_bytes\_to\_read\_for\_schema\_inference
Ces paramètres contrôlent la quantité de données à lire lors de l’inférence du schéma.
Plus le nombre de lignes ou d’octets lus est élevé, plus l’inférence du schéma prend du temps, mais plus les chances de
déterminer correctement les types sont élevées (en particulier lorsque les données contiennent beaucoup de valeurs NULL).
Valeurs par défaut :
* `25000` pour `input_format_max_rows_to_read_for_schema_inference`.
* `33554432` (32 Mb) pour `input_format_max_bytes_to_read_for_schema_inference`.
#### column\_names\_for\_schema\_inference
La liste des noms de colonnes à utiliser pour l’inférence du schéma dans les formats sans noms de colonnes explicites. Les noms spécifiés seront utilisés à la place des noms par défaut `c1,c2,c3,...`. Format : `column1,column2,column3,...`.
**Exemple**
```sql theme={null}
DESC format(TSV, 'Hello, World! 42 [1, 2, 3]') settings column_names_for_schema_inference = 'str,int,arr'
```
```response theme={null}
┌─name─┬─type───────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ str │ Nullable(String) │ │ │ │ │ │
│ int │ Nullable(Int64) │ │ │ │ │ │
│ arr │ Array(Nullable(Int64)) │ │ │ │ │ │
└──────┴────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
#### schema\_inference\_hints
La liste des noms et types de colonnes à utiliser pour l’inférence du schéma à la place des types déterminés automatiquement. Format : 'column\_name1 column\_type1, column\_name2 column\_type2, ...'.
Ce paramètre peut être utilisé pour spécifier les types de colonnes qui n’ont pas pu être déterminés automatiquement ou pour optimiser le schéma.
**Exemple**
```sql theme={null}
DESC format(JSONEachRow, '{"id" : 1, "age" : 25, "name" : "Josh", "status" : null, "hobbies" : ["football", "cooking"]}') SETTINGS schema_inference_hints = 'age LowCardinality(UInt8), status Nullable(String)', allow_suspicious_low_cardinality_types=1
```
```response theme={null}
┌─name────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ id │ Nullable(Int64) │ │ │ │ │ │
│ age │ LowCardinality(UInt8) │ │ │ │ │ │
│ name │ Nullable(String) │ │ │ │ │ │
│ status │ Nullable(String) │ │ │ │ │ │
│ hobbies │ Array(Nullable(String)) │ │ │ │ │ │
└─────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
#### schema\_inference\_make\_columns\_nullable \$
Contrôle si les types inférés sont rendus `Nullable` lors de l'inférence de schéma pour les formats ne contenant pas d'information sur la nullabilité. Valeurs possibles :
* 0 - le type inféré ne sera jamais `Nullable`,
* 1 - tous les types inférés seront `Nullable`,
* 2 ou 'auto' - pour les formats texte, le type inféré sera `Nullable` uniquement si la colonne contient `NULL` dans un échantillon analysé lors de l’inférence du schéma ; pour les formats fortement typés (Parquet, ORC, Arrow), les informations de nullabilité sont extraites des métadonnées du fichier,
* 3 - pour les formats texte, utilisez `Nullable` ; pour les formats fortement typés, utilisez les métadonnées du fichier.
Par défaut : 3.
**Exemples**
```sql theme={null}
SET schema_inference_make_columns_nullable = 1;
DESC format(JSONEachRow, $$
{"id" : 1, "age" : 25, "name" : "Josh", "status" : null, "hobbies" : ["football", "cooking"]}
{"id" : 2, "age" : 19, "name" : "Alan", "status" : "married", "hobbies" : ["tennis", "art"]}
$$)
```
```response theme={null}
┌─name────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ id │ Nullable(Int64) │ │ │ │ │ │
│ age │ Nullable(Int64) │ │ │ │ │ │
│ name │ Nullable(String) │ │ │ │ │ │
│ status │ Nullable(String) │ │ │ │ │ │
│ hobbies │ Array(Nullable(String)) │ │ │ │ │ │
└─────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
SET schema_inference_make_columns_nullable = 'auto';
DESC format(JSONEachRow, $$
{"id" : 1, "age" : 25, "name" : "Josh", "status" : null, "hobbies" : ["football", "cooking"]}
{"id" : 2, "age" : 19, "name" : "Alan", "status" : "married", "hobbies" : ["tennis", "art"]}
$$)
```
```response theme={null}
┌─name────┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ id │ Int64 │ │ │ │ │ │
│ age │ Int64 │ │ │ │ │ │
│ name │ String │ │ │ │ │ │
│ status │ Nullable(String) │ │ │ │ │ │
│ hobbies │ Array(String) │ │ │ │ │ │
└─────────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
SET schema_inference_make_columns_nullable = 0;
DESC format(JSONEachRow, $$
{"id" : 1, "age" : 25, "name" : "Josh", "status" : null, "hobbies" : ["football", "cooking"]}
{"id" : 2, "age" : 19, "name" : "Alan", "status" : "married", "hobbies" : ["tennis", "art"]}
$$)
```
```response theme={null}
┌─name────┬─type──────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ id │ Int64 │ │ │ │ │ │
│ age │ Int64 │ │ │ │ │ │
│ name │ String │ │ │ │ │ │
│ status │ String │ │ │ │ │ │
│ hobbies │ Array(String) │ │ │ │ │ │
└─────────┴───────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
#### input\_format\_try\_infer\_integers
Ce paramètre ne s’applique pas au type de données `JSON`.
S’il est activé, ClickHouse essaiera d’inférer des entiers plutôt que des nombres à virgule flottante lors de l’inférence du schéma pour les formats texte.
Si tous les nombres de la colonne dans les données d’échantillon sont des entiers, le type résultant sera `Int64` ; si au moins un nombre est à virgule flottante, le type résultant sera `Float64`.
Si les données d’échantillon ne contiennent que des entiers et qu’au moins l’un d’eux est positif et dépasse `Int64`, ClickHouse inférera `UInt64`.
Activé par défaut.
**Exemples**
```sql theme={null}
SET input_format_try_infer_integers = 0
DESC format(JSONEachRow, $$
{"number" : 1}
{"number" : 2}
$$)
```
```response theme={null}
┌─name───┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ number │ Nullable(Float64) │ │ │ │ │ │
└────────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
SET input_format_try_infer_integers = 1
DESC format(JSONEachRow, $$
{"number" : 1}
{"number" : 2}
$$)
```
```response theme={null}
┌─name───┬─type────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ number │ Nullable(Int64) │ │ │ │ │ │
└────────┴─────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(JSONEachRow, $$
{"number" : 1}
{"number" : 18446744073709551615}
$$)
```
```response theme={null}
┌─name───┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ number │ Nullable(UInt64) │ │ │ │ │ │
└────────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(JSONEachRow, $$
{"number" : 1}
{"number" : 2.2}
$$)
```
```response theme={null}
┌─name───┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ number │ Nullable(Float64) │ │ │ │ │ │
└────────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
#### input\_format\_try\_infer\_datetimes
S’il est activé, ClickHouse essaiera d’inférer le type `DateTime` ou `DateTime64` à partir des champs de type chaîne lors de l’inférence du schéma pour les formats texte.
Si tous les champs d’une colonne dans les données d’exemple ont pu être interprétés avec succès comme des valeurs datetime, le type résultant sera `DateTime` ou `DateTime64(9)` (si au moins une valeur datetime comportait une partie fractionnaire),
si au moins un champ n’a pas pu être interprété comme une valeur datetime, le type résultant sera `String`.
Activé par défaut.
**Exemples**
```sql theme={null}
SET input_format_try_infer_datetimes = 0;
DESC format(JSONEachRow, $$
{"datetime" : "2021-01-01 00:00:00", "datetime64" : "2021-01-01 00:00:00.000"}
{"datetime" : "2022-01-01 00:00:00", "datetime64" : "2022-01-01 00:00:00.000"}
$$)
```
```response theme={null}
┌─name───────┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ datetime │ Nullable(String) │ │ │ │ │ │
│ datetime64 │ Nullable(String) │ │ │ │ │ │
└────────────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
SET input_format_try_infer_datetimes = 1;
DESC format(JSONEachRow, $$
{"datetime" : "2021-01-01 00:00:00", "datetime64" : "2021-01-01 00:00:00.000"}
{"datetime" : "2022-01-01 00:00:00", "datetime64" : "2022-01-01 00:00:00.000"}
$$)
```
```response theme={null}
┌─name───────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ datetime │ Nullable(DateTime) │ │ │ │ │ │
│ datetime64 │ Nullable(DateTime64(9)) │ │ │ │ │ │
└────────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(JSONEachRow, $$
{"datetime" : "2021-01-01 00:00:00", "datetime64" : "2021-01-01 00:00:00.000"}
{"datetime" : "unknown", "datetime64" : "unknown"}
$$)
```
```response theme={null}
┌─name───────┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ datetime │ Nullable(String) │ │ │ │ │ │
│ datetime64 │ Nullable(String) │ │ │ │ │ │
└────────────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
#### input\_format\_try\_infer\_datetimes\_only\_datetime64
S’il est activé, ClickHouse inférera toujours `DateTime64(9)` lorsque `input_format_try_infer_datetimes` est activé, même si les valeurs de date et d’heure ne comportent pas de partie fractionnaire.
Désactivé par défaut.
**Exemples**
```sql theme={null}
SET input_format_try_infer_datetimes = 1;
SET input_format_try_infer_datetimes_only_datetime64 = 1;
DESC format(JSONEachRow, $$
{"datetime" : "2021-01-01 00:00:00", "datetime64" : "2021-01-01 00:00:00.000"}
{"datetime" : "2022-01-01 00:00:00", "datetime64" : "2022-01-01 00:00:00.000"}
$$)
```
```response theme={null}
┌─name───────┬─type────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ datetime │ Nullable(DateTime64(9)) │ │ │ │ │ │
│ datetime64 │ Nullable(DateTime64(9)) │ │ │ │ │ │
└────────────┴─────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Remarque : lors de l’inférence du schéma, l’analyse des valeurs DateTime respecte le paramètre [date\_time\_input\_format](/fr/reference/settings/formats#date_time_input_format)
#### input\_format\_try\_infer\_dates
S'il est activé, ClickHouse essaiera d'inférer le type `Date` à partir des champs de chaîne lors de l'inférence du schéma pour les formats texte.
Si tous les champs d'une colonne dans les données d'échantillon ont été correctement interprétés comme des dates, le type résultant sera `Date`,
si au moins un champ n'a pas pu être interprété comme une date, le type résultant sera `String`.
Activé par défaut.
**Exemples**
```sql theme={null}
SET input_format_try_infer_datetimes = 0, input_format_try_infer_dates = 0
DESC format(JSONEachRow, $$
{"date" : "2021-01-01"}
{"date" : "2022-01-01"}
$$)
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ date │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
SET input_format_try_infer_dates = 1
DESC format(JSONEachRow, $$
{"date" : "2021-01-01"}
{"date" : "2022-01-01"}
$$)
```
```response theme={null}
┌─name─┬─type───────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ date │ Nullable(Date) │ │ │ │ │ │
└──────┴────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
```sql theme={null}
DESC format(JSONEachRow, $$
{"date" : "2021-01-01"}
{"date" : "unknown"}
$$)
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ date │ Nullable(String) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
#### input\_format\_try\_infer\_exponent\_floats
S’il est activé, ClickHouse essaiera d’inférer les nombres à virgule flottante en notation exponentielle pour les formats texte (sauf JSON, où les nombres en notation exponentielle sont toujours inférés).
Désactivé par défaut.
**Exemple**
```sql theme={null}
SET input_format_try_infer_exponent_floats = 1;
DESC format(CSV,
$$1.1E10
2.3e-12
42E00
$$)
```
```response theme={null}
┌─name─┬─type──────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ c1 │ Nullable(Float64) │ │ │ │ │ │
└──────┴───────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
## Formats auto-descriptifs
Les formats auto-descriptifs contiennent dans les données elles-mêmes des informations sur leur structure :
il peut s’agir d’un en-tête avec une description, d’un arbre binaire de types ou d’une sorte de table.
Pour inférer automatiquement un schéma à partir de fichiers dans de tels formats, ClickHouse lit une partie des données contenant
des informations sur les types et les convertit en schéma de table ClickHouse.
### Formats avec le suffixe -WithNamesAndTypes
ClickHouse prend en charge certains formats texte avec le suffixe -WithNamesAndTypes. Ce suffixe signifie que les données contiennent deux lignes supplémentaires indiquant les noms et les types de colonnes avant les données proprement dites.
Lors de l’inférence du schéma pour ces formats, ClickHouse lit les deux premières lignes et en extrait les noms et les types de colonnes.
**Exemple**
```sql theme={null}
DESC format(TSVWithNamesAndTypes,
$$num str arr
UInt8 String Array(UInt8)
42 Hello, World! [1,2,3]
$$)
```
```response theme={null}
┌─name─┬─type─────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ num │ UInt8 │ │ │ │ │ │
│ str │ String │ │ │ │ │ │
│ arr │ Array(UInt8) │ │ │ │ │ │
└──────┴──────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### Formats JSON avec métadonnées
Certains formats d'entrée JSON ([JSON](/fr/reference/formats/JSON/JSON), [JSONCompact](/fr/reference/formats/JSON/JSONCompact), [JSONColumnsWithMetadata](/fr/reference/formats/JSON/JSONColumnsWithMetadata)) contiennent des métadonnées incluant les noms et les types des colonnes.
Lors de l'inférence du schéma pour ces formats, ClickHouse lit ces métadonnées.
**Exemple**
```sql theme={null}
DESC format(JSON, $$
{
"meta":
[
{
"name": "num",
"type": "UInt8"
},
{
"name": "str",
"type": "String"
},
{
"name": "arr",
"type": "Array(UInt8)"
}
],
"data":
[
{
"num": 42,
"str": "Hello, World",
"arr": [1,2,3]
}
],
"rows": 1,
"statistics":
{
"elapsed": 0.005723915,
"rows_read": 1,
"bytes_read": 1
}
}
$$)
```
```response theme={null}
┌─name─┬─type─────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ num │ UInt8 │ │ │ │ │ │
│ str │ String │ │ │ │ │ │
│ arr │ Array(UInt8) │ │ │ │ │ │
└──────┴──────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### Avro
Avec le format Avro, ClickHouse lit le schéma à partir des données et le convertit en schéma ClickHouse à l’aide des correspondances de types suivantes :
| Type de données Avro | Type de données ClickHouse |
| ---------------------------------- | ------------------------------------------------------------------------ |
| `boolean` | [Bool](/fr/reference/data-types/boolean) |
| `int` | [Int32](/fr/reference/data-types/int-uint) |
| `int (date)` \* | [Date32](/fr/reference/data-types/date32) |
| `long` | [Int64](/fr/reference/data-types/int-uint) |
| `float` | [Float32](/fr/reference/data-types/float) |
| `double` | [Float64](/fr/reference/data-types/float) |
| `bytes`, `string` | [String](/fr/reference/data-types/string) |
| `fixed` | [FixedString(N)](/fr/reference/data-types/fixedstring) |
| `enum` | [Enum](/fr/reference/data-types/enum) |
| `array(T)` | [Array(T)](/fr/reference/data-types/array) |
| `union(null, T)`, `union(T, null)` | [Nullable(T)](/fr/reference/data-types/date) |
| `null` | [Nullable(Nothing)](/fr/reference/data-types/special-data-types/nothing) |
| `string (uuid)` \* | [UUID](/fr/reference/data-types/uuid) |
| `binary (decimal)` \* | [Decimal(P, S)](/fr/reference/data-types/decimal) |
* [Types logiques Avro](https://avro.apache.org/docs/current/spec.html#Logical+Types)
Les autres types Avro ne sont pas pris en charge.
### Parquet
Dans le format Parquet, ClickHouse lit le schéma à partir des données et le convertit en schéma ClickHouse à l’aide des correspondances de types suivantes :
| Type de données Parquet | Type de données ClickHouse |
| ---------------------------- | ------------------------------------------------- |
| `BOOL` | [Bool](/fr/reference/data-types/boolean) |
| `UINT8` | [UInt8](/fr/reference/data-types/int-uint) |
| `INT8` | [Int8](/fr/reference/data-types/int-uint) |
| `UINT16` | [UInt16](/fr/reference/data-types/int-uint) |
| `INT16` | [Int16](/fr/reference/data-types/int-uint) |
| `UINT32` | [UInt32](/fr/reference/data-types/int-uint) |
| `INT32` | [Int32](/fr/reference/data-types/int-uint) |
| `UINT64` | [UInt64](/fr/reference/data-types/int-uint) |
| `INT64` | [Int64](/fr/reference/data-types/int-uint) |
| `FLOAT` | [Float32](/fr/reference/data-types/float) |
| `DOUBLE` | [Float64](/fr/reference/data-types/float) |
| `DATE` | [Date32](/fr/reference/data-types/date32) |
| `TIME (ms)` | [DateTime](/fr/reference/data-types/datetime) |
| `TIMESTAMP`, `TIME (us, ns)` | [DateTime64](/fr/reference/data-types/datetime64) |
| `STRING`, `BINARY` | [String](/fr/reference/data-types/string) |
| `DECIMAL` | [Decimal](/fr/reference/data-types/decimal) |
| `LIST` | [Array](/fr/reference/data-types/array) |
| `STRUCT` | [Tuple](/fr/reference/data-types/tuple) |
| `MAP` | [Map](/fr/reference/data-types/map) |
Les autres types Parquet ne sont pas pris en charge.
### Arrow
Au format Arrow, ClickHouse lit le schéma à partir des données et le convertit en schéma ClickHouse grâce aux correspondances de types suivantes :
| Type de données Arrow | Type de données ClickHouse |
| ------------------------------- | ------------------------------------------------- |
| `BOOL` | [Bool](/fr/reference/data-types/boolean) |
| `UINT8` | [UInt8](/fr/reference/data-types/int-uint) |
| `INT8` | [Int8](/fr/reference/data-types/int-uint) |
| `UINT16` | [UInt16](/fr/reference/data-types/int-uint) |
| `INT16` | [Int16](/fr/reference/data-types/int-uint) |
| `UINT32` | [UInt32](/fr/reference/data-types/int-uint) |
| `INT32` | [Int32](/fr/reference/data-types/int-uint) |
| `UINT64` | [UInt64](/fr/reference/data-types/int-uint) |
| `INT64` | [Int64](/fr/reference/data-types/int-uint) |
| `FLOAT`, `HALF_FLOAT` | [Float32](/fr/reference/data-types/float) |
| `DOUBLE` | [Float64](/fr/reference/data-types/float) |
| `DATE32` | [Date32](/fr/reference/data-types/date32) |
| `DATE64` | [DateTime](/fr/reference/data-types/datetime) |
| `TIMESTAMP`, `TIME32`, `TIME64` | [DateTime64](/fr/reference/data-types/datetime64) |
| `STRING`, `BINARY` | [String](/fr/reference/data-types/string) |
| `DECIMAL128`, `DECIMAL256` | [Decimal](/fr/reference/data-types/decimal) |
| `LIST` | [Array](/fr/reference/data-types/array) |
| `STRUCT` | [Tuple](/fr/reference/data-types/tuple) |
| `MAP` | [Map](/fr/reference/data-types/map) |
Les autres types Arrow ne sont pas pris en charge.
### ORC
Dans le format ORC, ClickHouse lit le schéma à partir des données et le convertit en schéma ClickHouse à l’aide des correspondances de types suivantes :
| Type de données ORC | Type de données ClickHouse |
| ------------------------------------ | ------------------------------------------------- |
| `Boolean` | [Bool](/fr/reference/data-types/boolean) |
| `Tinyint` | [Int8](/fr/reference/data-types/int-uint) |
| `Smallint` | [Int16](/fr/reference/data-types/int-uint) |
| `Int` | [Int32](/fr/reference/data-types/int-uint) |
| `Bigint` | [Int64](/fr/reference/data-types/int-uint) |
| `Float` | [Float32](/fr/reference/data-types/float) |
| `Double` | [Float64](/fr/reference/data-types/float) |
| `Date` | [Date32](/fr/reference/data-types/date32) |
| `Timestamp` | [DateTime64](/fr/reference/data-types/datetime64) |
| `String`, `Char`, `Varchar`,`BINARY` | [String](/fr/reference/data-types/string) |
| `Decimal` | [Decimal](/fr/reference/data-types/decimal) |
| `List` | [Array](/fr/reference/data-types/array) |
| `Struct` | [Tuple](/fr/reference/data-types/tuple) |
| `Map` | [Map](/fr/reference/data-types/map) |
Les autres types ORC ne sont pas pris en charge.
### Native
Le format Native est utilisé en interne dans ClickHouse et intègre le schéma aux données.
Lors de l’inférence de schéma, ClickHouse lit le schéma à partir des données sans aucune transformation.
## Formats avec schéma externe
Ces formats nécessitent un schéma décrivant les données dans un fichier distinct, rédigé dans un langage de schéma spécifique.
Pour inférer automatiquement un schéma à partir de fichiers dans ces formats, ClickHouse lit le schéma externe depuis un fichier distinct et le convertit en schéma de table ClickHouse.
### Protobuf
Pour l’inférence de schéma au format Protobuf, ClickHouse utilise les correspondances de types suivantes :
| type de données Protobuf | type de données ClickHouse |
| ----------------------------- | ------------------------------------------- |
| `bool` | [UInt8](/fr/reference/data-types/int-uint) |
| `float` | [Float32](/fr/reference/data-types/float) |
| `double` | [Float64](/fr/reference/data-types/float) |
| `int32`, `sint32`, `sfixed32` | [Int32](/fr/reference/data-types/int-uint) |
| `int64`, `sint64`, `sfixed64` | [Int64](/fr/reference/data-types/int-uint) |
| `uint32`, `fixed32` | [UInt32](/fr/reference/data-types/int-uint) |
| `uint64`, `fixed64` | [UInt64](/fr/reference/data-types/int-uint) |
| `string`, `bytes` | [String](/fr/reference/data-types/string) |
| `enum` | [Enum](/fr/reference/data-types/enum) |
| `repeated T` | [Array(T)](/fr/reference/data-types/array) |
| `message`, `group` | [Tuple](/fr/reference/data-types/tuple) |
### CapnProto
Pour l’inférence de schéma du format CapnProto, ClickHouse utilise les correspondances de types suivantes :
| Type de données CapnProto | Type de données ClickHouse |
| ---------------------------------- | ------------------------------------------------ |
| `Bool` | [UInt8](/fr/reference/data-types/int-uint) |
| `Int8` | [Int8](/fr/reference/data-types/int-uint) |
| `UInt8` | [UInt8](/fr/reference/data-types/int-uint) |
| `Int16` | [Int16](/fr/reference/data-types/int-uint) |
| `UInt16` | [UInt16](/fr/reference/data-types/int-uint) |
| `Int32` | [Int32](/fr/reference/data-types/int-uint) |
| `UInt32` | [UInt32](/fr/reference/data-types/int-uint) |
| `Int64` | [Int64](/fr/reference/data-types/int-uint) |
| `UInt64` | [UInt64](/fr/reference/data-types/int-uint) |
| `Float32` | [Float32](/fr/reference/data-types/float) |
| `Float64` | [Float64](/fr/reference/data-types/float) |
| `Text`, `Data` | [String](/fr/reference/data-types/string) |
| `enum` | [Enum](/fr/reference/data-types/enum) |
| `List` | [Array](/fr/reference/data-types/array) |
| `struct` | [Tuple](/fr/reference/data-types/tuple) |
| `union(T, Void)`, `union(Void, T)` | [Nullable(T)](/fr/reference/data-types/nullable) |
## Formats binaires fortement typés
Dans ces formats, chaque valeur sérialisée contient des informations sur son type (et éventuellement sur son nom), mais aucune information n’est fournie sur l’ensemble de la table.
Lors de l’inférence de schéma pour ces formats, ClickHouse lit les données ligne par ligne (jusqu’à `input_format_max_rows_to_read_for_schema_inference` lignes ou `input_format_max_bytes_to_read_for_schema_inference` octets) et extrait
le type (et éventuellement le nom) de chaque valeur à partir des données, puis convertit ces types en types ClickHouse.
### MsgPack
Dans le format MsgPack, il n’existe pas de délimiteur entre les lignes. Pour utiliser l’inférence de schéma avec ce format, vous devez spécifier le nombre de colonnes de la table
à l’aide du paramètre `input_format_msgpack_number_of_columns`. ClickHouse utilise les correspondances de types suivantes :
| Type de données MessagePack (`INSERT`) | Type de données ClickHouse |
| ------------------------------------------------------------------ | ----------------------------------------------- |
| `int N`, `uint N`, `negative fixint`, `positive fixint` | [Int64](/fr/reference/data-types/int-uint) |
| `bool` | [UInt8](/fr/reference/data-types/int-uint) |
| `fixstr`, `str 8`, `str 16`, `str 32`, `bin 8`, `bin 16`, `bin 32` | [String](/fr/reference/data-types/string) |
| `float 32` | [Float32](/fr/reference/data-types/float) |
| `float 64` | [Float64](/fr/reference/data-types/float) |
| `uint 16` | [Date](/fr/reference/data-types/date) |
| `uint 32` | [DateTime](/fr/reference/data-types/datetime) |
| `uint 64` | [DateTime64](/fr/reference/data-types/datetime) |
| `fixarray`, `array 16`, `array 32` | [Array](/fr/reference/data-types/array) |
| `fixmap`, `map 16`, `map 32` | [Map](/fr/reference/data-types/map) |
Par défaut, tous les types inférés sont encapsulés dans `Nullable`, mais ce comportement peut être modifié à l’aide du paramètre `schema_inference_make_columns_nullable`.
### BSONEachRow
Dans BSONEachRow, chaque ligne de données est présentée sous forme de document BSON. Lors de l’inférence de schéma, ClickHouse lit les documents BSON un par un et en extrait les
valeurs, les noms et les types, puis convertit ces types en types ClickHouse selon les correspondances de types suivantes :
| Type BSON | Type ClickHouse |
| ------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| `\x08` booléen | [Bool](/fr/reference/data-types/boolean) |
| `\x10` int32 | [Int32](/fr/reference/data-types/int-uint) |
| `\x12` int64 | [Int64](/fr/reference/data-types/int-uint) |
| `\x01` double | [Float64](/fr/reference/data-types/float) |
| `\x09` date-heure | [DateTime64](/fr/reference/data-types/datetime64) |
| `\x05` binaire avec `\x00` comme binary subtype, `\x02` chaîne, `\x0E` symbole, `\x0D` code JavaScript | [String](/fr/reference/data-types/string) |
| `\x07` ObjectId, | [FixedString(12)](/fr/reference/data-types/fixedstring) |
| `\x05` binaire avec `\x04` comme sous-type uuid, taille = 16 | [UUID](/fr/reference/data-types/uuid) |
| `\x04` tableau | [Array](/fr/reference/data-types/array)/[Tuple](/fr/reference/data-types/tuple) (si les types imbriqués sont différents) |
| `\x03` document | [Named Tuple](/fr/reference/data-types/tuple)/[Map](/fr/reference/data-types/map) (avec des clés String) |
Par défaut, tous les types inférés sont dans `Nullable`, mais ce comportement peut être modifié à l’aide du paramètre `schema_inference_make_columns_nullable`.
## Formats à schéma constant
Les données de ces formats ont toujours le même schéma.
### LineAsString
Dans ce format, ClickHouse lit toute la ligne des données dans une seule colonne de type `String`. Le type inféré pour ce format est toujours `String` et le nom de la colonne est `line`.
**Exemple**
```sql theme={null}
DESC format(LineAsString, 'Hello\nworld!')
```
```response theme={null}
┌─name─┬─type───┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ line │ String │ │ │ │ │ │
└──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### JSONAsString
Dans ce format, ClickHouse lit l’intégralité de l’objet JSON des données dans une seule colonne de type `String`. Le type inféré pour ce format est toujours `String`, et le nom de la colonne est `json`.
**Exemple**
```sql theme={null}
DESC format(JSONAsString, '{"x" : 42, "y" : "Hello, World!"}')
```
```response theme={null}
┌─name─┬─type───┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ json │ String │ │ │ │ │ │
└──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
### JSONAsObject
Dans ce format, ClickHouse lit l’intégralité de l’objet JSON des données dans une seule colonne de type `JSON`. Pour ce format, le type inféré est toujours `JSON` et le nom de la colonne est `json`.
**Exemple**
```sql theme={null}
DESC format(JSONAsObject, '{"x" : 42, "y" : "Hello, World!"}');
```
```response theme={null}
┌─name─┬─type─┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ json │ JSON │ │ │ │ │ │
└──────┴──────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
## Modes d’inférence de schéma
L’inférence de schéma à partir de l’ensemble des fichiers de données peut fonctionner selon 2 modes distincts : `default` et `union`.
Le mode est contrôlé par le paramètre `schema_inference_mode`.
### Mode par défaut
En mode par défaut, ClickHouse part du principe que tous les fichiers ont le même schéma et essaie de l’inférer en lisant les fichiers un par un jusqu’à ce qu’il y parvienne.
Exemple :
Supposons que nous ayons 3 fichiers `data1.jsonl`, `data2.jsonl` et `data3.jsonl` avec le contenu suivant :
`data1.jsonl`:
```json theme={null}
{"field1" : 1, "field2" : null}
{"field1" : 2, "field2" : null}
{"field1" : 3, "field2" : null}
```
`data2.jsonl` :
```json theme={null}
{"field1" : 4, "field2" : "Data4"}
{"field1" : 5, "field2" : "Data5"}
{"field1" : 6, "field2" : "Data5"}
```
`data3.jsonl`:
```json theme={null}
{"field1" : 7, "field2" : "Data7", "field3" : [1, 2, 3]}
{"field1" : 8, "field2" : "Data8", "field3" : [4, 5, 6]}
{"field1" : 9, "field2" : "Data9", "field3" : [7, 8, 9]}
```
Essayons d’utiliser l’inférence de schéma sur ces 3 fichiers :
```sql title="Query" theme={null}
:) DESCRIBE file('data{1,2,3}.jsonl') SETTINGS schema_inference_mode='default'
```
```response title="Response" theme={null}
┌─name───┬─type─────────────┐
│ field1 │ Nullable(Int64) │
│ field2 │ Nullable(String) │
└────────┴──────────────────┘
```
Comme on peut le constater, nous n'avons pas `field3` du fichier `data3.jsonl`.
Cela s'explique par le fait que ClickHouse a d'abord tenté d'inférer le schéma à partir du fichier `data1.jsonl`, mais a échoué car le champ `field2` ne contenait que des valeurs NULL,
puis a tenté d'inférer le schéma à partir de `data2.jsonl` et a réussi ; les données du fichier `data3.jsonl` n'ont donc pas été lues.
### Mode union
En mode union, ClickHouse part du principe que les fichiers peuvent avoir des schémas différents ; il en infère donc les schémas, puis les fusionne en un schéma commun.
Supposons que nous ayons 3 fichiers `data1.jsonl`, `data2.jsonl` et `data3.jsonl` avec le contenu suivant :
`data1.jsonl`:
```json theme={null}
{"field1" : 1}
{"field1" : 2}
{"field1" : 3}
```
`data2.jsonl`:
```json theme={null}
{"field2" : "Data4"}
{"field2" : "Data5"}
{"field2" : "Data5"}
```
`data3.jsonl`:
```json theme={null}
{"field3" : [1, 2, 3]}
{"field3" : [4, 5, 6]}
{"field3" : [7, 8, 9]}
```
Essayons d’appliquer l’inférence de schéma à ces 3 fichiers :
```sql title="Query" theme={null}
:) DESCRIBE file('data{1,2,3}.jsonl') SETTINGS schema_inference_mode='union'
```
```response title="Response" theme={null}
┌─name───┬─type───────────────────┐
│ field1 │ Nullable(Int64) │
│ field2 │ Nullable(String) │
│ field3 │ Array(Nullable(Int64)) │
└────────┴────────────────────────┘
```
Comme on peut le voir, nous avons tous les champs de tous les fichiers.
Remarque :
* Comme certains fichiers peuvent ne pas contenir certaines colonnes du schéma résultant, le mode union est pris en charge uniquement pour les formats qui permettent la lecture d’un sous-ensemble de colonnes (comme JSONEachRow, Parquet, TSVWithNames, etc.) et ne fonctionnera pas avec les autres formats (comme CSV, TSV, JSONCompactEachRow, etc.).
* Si ClickHouse ne parvient pas à inférer le schéma de l’un des fichiers, une exception sera levée.
* Si vous avez beaucoup de fichiers, la lecture du schéma de chacun d’eux peut prendre beaucoup de temps.
## Détection automatique du format
Si le format des données n’est pas indiqué et ne peut pas être déterminé à partir de l’extension du fichier, ClickHouse essaiera de détecter le format du fichier à partir de son contenu.
**Exemples :**
Supposons que `data` contienne les éléments suivants :
```csv theme={null}
"a","b"
1,"Data1"
2,"Data2"
3,"Data3"
```
Nous pouvons examiner et interroger ce fichier sans préciser le format ni la structure :
```sql theme={null}
:) desc file(data);
```
```response theme={null}
┌─name─┬─type─────────────┐
│ a │ Nullable(Int64) │
│ b │ Nullable(String) │
└──────┴──────────────────┘
```
```sql theme={null}
:) select * from file(data);
```
```response theme={null}
┌─a─┬─b─────┐
│ 1 │ Data1 │
│ 2 │ Data2 │
│ 3 │ Data3 │
└───┴───────┘
```
ClickHouse ne peut détecter qu’un nombre limité de formats, et cette détection prend un certain temps. Il est donc toujours préférable de spécifier explicitement le format.