> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Utiliser Parquet avec ClickHouse
> Page décrivant comment utiliser Parquet avec ClickHouse
Parquet est un format de fichier efficace pour stocker les données au format colonnaire.
ClickHouse prend en charge aussi bien la lecture que l’écriture de fichiers Parquet.
Lorsque vous indiquez un chemin de fichier dans une requête, l’emplacement depuis lequel ClickHouse tentera de lire dépend de la version de ClickHouse que vous utilisez.
Si vous utilisez [`clickhouse-local`](/docs/fr/concepts/features/tools-and-utilities/clickhouse-local), il lira depuis un emplacement relatif au répertoire depuis lequel vous avez lancé ClickHouse Local.
Si vous utilisez ClickHouse Server ou ClickHouse Cloud via `clickhouse client`, il lira depuis un emplacement relatif au répertoire `/var/lib/clickhouse/user_files/` sur le serveur.
## Importation à partir de Parquet
Avant de charger les données, nous pouvons utiliser la fonction [file()](/docs/fr/reference/functions/regular-functions/files#file) pour examiner la structure d’un [fichier Parquet d’exemple](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/data.parquet) :
```sql theme={null}
DESCRIBE TABLE file('data.parquet', Parquet);
```
Nous avons utilisé [Parquet](/docs/fr/reference/formats/Parquet/Parquet) comme deuxième argument, afin que ClickHouse reconnaisse le format du fichier. Cela affichera les colonnes avec leur type :
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ path │ Nullable(String) │ │ │ │ │ │
│ date │ Nullable(String) │ │ │ │ │ │
│ hits │ Nullable(Int64) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Nous pouvons également inspecter des fichiers avant d’importer réellement des données, grâce à toute la puissance de SQL :
```sql theme={null}
SELECT *
FROM file('data.parquet', Parquet)
LIMIT 3;
```
```response theme={null}
┌─path──────────────────────┬─date───────┬─hits─┐
│ Akiba_Hebrew_Academy │ 2017-08-01 │ 241 │
│ Aegithina_tiphia │ 2018-02-01 │ 34 │
│ 1971-72_Utah_Stars_season │ 2016-10-01 │ 1 │
└───────────────────────────┴────────────┴──────┘
```
Il est possible d’omettre la définition explicite du format pour `file()` et `INFILE`/`OUTFILE`.
Dans ce cas, ClickHouse détectera automatiquement le format à partir de l’extension du fichier.
## Importer dans une table existante
Créons une table dans laquelle nous importerons des données Parquet :
```sql theme={null}
CREATE TABLE sometable
(
`path` String,
`date` Date,
`hits` UInt32
)
ENGINE = MergeTree
ORDER BY (date, path);
```
Nous pouvons maintenant importer des données à l’aide de la clause `FROM INFILE` :
```sql theme={null}
INSERT INTO sometable
FROM INFILE 'data.parquet' FORMAT Parquet;
SELECT *
FROM sometable
LIMIT 5;
```
```response theme={null}
┌─path──────────────────────────┬───────date─┬─hits─┐
│ 1988_in_philosophy │ 2015-05-01 │ 70 │
│ 2004_Green_Bay_Packers_season │ 2015-05-01 │ 970 │
│ 24_hours_of_lemans │ 2015-05-01 │ 37 │
│ 25604_Karlin │ 2015-05-01 │ 20 │
│ ASCII_ART │ 2015-05-01 │ 9 │
└───────────────────────────────┴────────────┴──────┘
```
Notez que ClickHouse a automatiquement converti les chaînes Parquet (dans la colonne `date`) en type `Date`. Cela s'explique par le fait que ClickHouse effectue automatiquement une conversion de type en fonction des types de la table cible.
## Insérer un fichier local dans un serveur distant
Si vous souhaitez insérer un fichier Parquet local dans un serveur ClickHouse distant, vous pouvez le faire en acheminant le contenu du fichier vers `clickhouse-client`, comme illustré ci-dessous :
```sql theme={null}
clickhouse client -q "INSERT INTO sometable FORMAT Parquet" < data.parquet
```
## Création de nouvelles tables à partir de fichiers Parquet
Comme ClickHouse lit le schéma d’un fichier Parquet, nous pouvons créer des tables à la volée :
```sql theme={null}
CREATE TABLE imported_from_parquet
ENGINE = MergeTree
ORDER BY tuple() AS
SELECT *
FROM file('data.parquet', Parquet)
```
Cela créera automatiquement une table et la peuplera à partir d’un fichier Parquet spécifié :
```sql theme={null}
DESCRIBE TABLE imported_from_parquet;
```
```response theme={null}
┌─name─┬─type─────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐
│ path │ Nullable(String) │ │ │ │ │ │
│ date │ Nullable(String) │ │ │ │ │ │
│ hits │ Nullable(Int64) │ │ │ │ │ │
└──────┴──────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Par défaut, ClickHouse applique strictement les noms de colonnes, les types et les valeurs. Mais il est parfois possible d’ignorer des colonnes inexistantes ou des valeurs non prises en charge lors de l’importation. Cela peut être configuré avec les [paramètres Parquet](/docs/fr/reference/formats/Parquet/Parquet#format-settings).
## Exportation au format Parquet
Lorsque vous utilisez `INTO OUTFILE` avec ClickHouse Cloud, vous devez exécuter les commandes dans `clickhouse client` sur la machine où le fichier sera écrit.
Pour exporter n’importe quelle table ou tout résultat de la requête vers un fichier Parquet, nous pouvons utiliser une clause `INTO OUTFILE` :
```sql theme={null}
SELECT *
FROM sometable
INTO OUTFILE 'export.parquet'
FORMAT Parquet
```
Cela créera le fichier `export.parquet` dans le répertoire de travail.
## Types de données ClickHouse et Parquet
Les types de données ClickHouse et Parquet sont en grande partie identiques, mais [présentent tout de même quelques différences](/docs/fr/reference/formats/Parquet/Parquet#data-types-matching-parquet). Par exemple, ClickHouse exporte le type `DateTime` sous la forme d’un `int64` Parquet. Si nous le réimportons ensuite dans ClickHouse, nous verrons des nombres ([fichier time.parquet](https://clickhouse-docs-assets.s3.us-east-1.amazonaws.com/time.parquet)) :
```sql theme={null}
SELECT * FROM file('time.parquet', Parquet);
```
```response theme={null}
┌─n─┬───────time─┐
│ 0 │ 1673622611 │
│ 1 │ 1673622610 │
│ 2 │ 1673622609 │
│ 3 │ 1673622608 │
│ 4 │ 1673622607 │
└───┴────────────┘
```
Dans ce cas, on peut utiliser la [conversion de type](/docs/fr/reference/functions/regular-functions/type-conversion-functions) :
```sql theme={null}
SELECT
n,
toDateTime(time) <--- int to time
FROM file('time.parquet', Parquet);
```
```response theme={null}
┌─n─┬────toDateTime(time)─┐
│ 0 │ 2023-01-13 15:10:11 │
│ 1 │ 2023-01-13 15:10:10 │
│ 2 │ 2023-01-13 15:10:09 │
│ 3 │ 2023-01-13 15:10:08 │
│ 4 │ 2023-01-13 15:10:07 │
└───┴─────────────────────┘
```
## Lectures complémentaires
ClickHouse prend en charge de nombreux formats, aussi bien textuels que binaires, afin de couvrir divers scénarios et plateformes. Découvrez d'autres formats et différentes façons de les utiliser dans les articles suivants :
* [Formats CSV et TSV](/docs/fr/guides/clickhouse/data-formats/csv-tsv)
* [Avro, Arrow et ORC](/docs/fr/guides/clickhouse/data-formats/arrow-avro-orc)
* [Formats JSON](/docs/fr/guides/clickhouse/data-formats/json/intro)
* [Regex et templates](/docs/fr/guides/clickhouse/data-formats/templates-regex)
* [Formats natifs et binaires](/docs/fr/guides/clickhouse/data-formats/binary)
* [Formats SQL](/docs/fr/guides/clickhouse/data-formats/sql)
Consultez également [clickhouse-local](https://clickhouse.com/blog/extracting-converting-querying-local-files-with-sql-clickhouse-local) - un outil portable complet pour travailler sur des fichiers locaux/distants sans avoir besoin d'un ClickHouse server.