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

> Un moteur de table qui fournit une interface de type table pour exécuter des `SELECT` à partir de fichiers et des `INSERT` dans des fichiers, similaire à la fonction de table s3. Utilisez `file` lorsque vous travaillez avec des fichiers locaux, et `s3` lorsque vous travaillez avec des buckets dans un stockage objet tel que S3, GCS ou MinIO.

# file

export const CloudNotSupportedBadge = () => {
  return <a href="https://clickhouse.com/docs/products/cloud/guides/cloud-compatibility#list-of-unsupported-features" className="cloudNotSupportedBadge">
            <div className="cloudNotSupportedIcon">
            <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
                <path strokeWidth="1.5" d="M6.33366 12.6666L12.3739 12.6667C13.6593 12.6667 14.7073 11.6187 14.7073 10.3334C14.7073 9.04804 13.6593 8.00003 12.3739 8.00003C12.3739 8.00003 12.3337 7.66659 12.0003 7.33325M10.667 5.33322C8.00033 2.33325 4.45395 4.78537 4.14195 6.68203C2.55728 6.7627 1.29395 8.06203 1.29395 9.6667C1.29395 11.3234 2.66699 12.6666 4.00033 12.6666" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
                <path strokeWidth="1.5" d="M2.66699 14L12.0003 4.66663" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
            </svg>

        </div>
            Non pris en charge par ClickHouse Cloud
        </a>;
};

export const ExperimentalBadge = () => {
  return <a href="https://clickhouse.com/docs/reference/settings/beta-and-experimental-features#experimental-features" className="experimentalBadge">
            <div className="experimentalIcon">
            <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
                <path strokeWidth="1.25" d="M5.5 2H10.5" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
                <path strokeWidth="1.25" d="M9.50015 2V6.19625L13.4283 12.7425C13.4738 12.8183 13.4985 12.9049 13.4996 12.9934C13.5008 13.0818 13.4785 13.169 13.435 13.246C13.3914 13.323 13.3283 13.3871 13.2519 13.4317C13.1755 13.4764 13.0886 13.4999 13.0002 13.5H3.00015C2.91164 13.5 2.8247 13.4766 2.74822 13.432C2.67174 13.3874 2.60847 13.3233 2.56487 13.2463C2.52126 13.1693 2.49889 13.082 2.50004 12.9935C2.50119 12.905 2.52582 12.8184 2.5714 12.7425L6.50015 6.19625V2" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
                <path strokeWidth="1.25" d="M4.47656 9.56754C5.30344 9.41254 6.47656 9.47942 7.99969 10.25C10.0153 11.2707 11.4216 11.0569 12.2184 10.7282" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" />
            </svg>
        </div>
            Fonctionnalité expérimentale
        </a>;
};

Un moteur de table qui fournit une interface de type table pour exécuter des `SELECT` à partir de fichiers et des `INSERT` dans des fichiers, similaire à la fonction de table [s3](/fr/reference/functions/table-functions/s3). Utilisez `file` lorsque vous travaillez avec des fichiers locaux, et `s3` lorsque vous travaillez avec des buckets dans un stockage objet tel que S3, GCS ou MinIO.

La fonction `file` peut être utilisée dans des requêtes `SELECT` et `INSERT` pour lire des fichiers ou y écrire.

## Syntaxe

```sql theme={null}
file([path_to_archive ::] path [,format] [,structure] [,compression])
```

Pour les requêtes `SELECT`, `path` peut aussi être une expression qui renvoie un `Array(String)` :

```sql theme={null}
file(['file1.csv', 'file2.csv'], 'CSV', 'column1 UInt32, column2 UInt32')
```

## Arguments

| Parameter | Description |
| - | - |
| `path` | Le chemin relatif vers le fichier à partir de [user\_files\_path](/fr/reference/settings/server-settings/settings/user#user_files_path), ou un `Array(String)` de chemins dans les requêtes `SELECT`. En mode lecture seule, prend en charge les [globs](#globs-in-path) suivants : `*`, `?`, `{abc,def}` (où `'abc'` et `'def'` sont des chaînes de caractères) et `{N..M}` (où `N` et `M` sont des nombres). |
| `path_to_archive` | Le chemin relatif vers une archive zip/tar/7z. Prend en charge les mêmes globs que `path`. |
| `format` | Le [format](/fr/reference/formats/index) du fichier. |
| `structure` | Structure de la table. Format : `'column1_name column1_type, column2_name column2_type, ...'`. |
| `compression` | Le type de compression existant lorsqu’il est utilisé dans une requête `SELECT`, ou le type de compression souhaité lorsqu’il est utilisé dans une requête `INSERT`. Les valeurs prises en charge sont `none` (sans compression), `gzip/gz`, `deflate`, `brotli/br`, `lzma/xz`, `zstd/zst`, `lz4`, `bz2` et `snappy`. Pour `snappy`, le format de transmission est sélectionné par le paramètre [snappy\_mode](/fr/reference/settings/session-settings/other#snappy_mode) (`basic` par défaut). |

<Tip>
  Lorsque l’argument `structure` est omis, ClickHouse déduit le schéma du format lui-même.
  Les différents formats produisent des noms et des types de colonnes par défaut différents.
  Pour afficher le schéma d’un format donné, utilisez [`DESC`](/fr/reference/statements/describe-table) avec la fonction de table [`format`](/fr/reference/functions/table-functions/format).

  Par 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 │              │                    │         │                  │                │
  └──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
  ```
</Tip>

## Valeur retournée

Une table permettant de lire ou d’écrire des données dans un fichier.

## Exemples d’écriture dans un fichier

### Écrire dans un fichier TSV

```sql theme={null}
INSERT INTO TABLE FUNCTION
file('test.tsv', 'TSV', 'column1 UInt32, column2 UInt32, column3 UInt32')
VALUES (1, 2, 3), (3, 2, 1), (1, 3, 2)
```

Par conséquent, les données sont enregistrées dans le fichier `test.tsv` :

```bash theme={null}
# cat /var/lib/clickhouse/user_files/test.tsv
1    2    3
3    2    1
1    3    2
```

### Écriture partitionnée dans plusieurs fichiers TSV

Si vous spécifiez une expression `PARTITION BY` lors de l’insertion de données dans une fonction de table de type `file`, un fichier distinct est créé pour chaque partition. Répartir les données dans des fichiers distincts permet d’améliorer les performances des opérations de lecture.

```sql theme={null}
INSERT INTO TABLE FUNCTION
file('test_{_partition_id}.tsv', 'TSV', 'column1 UInt32, column2 UInt32, column3 UInt32')
PARTITION BY column3
VALUES (1, 2, 3), (3, 2, 1), (1, 3, 2)
```

Par conséquent, les données sont écrites dans trois fichiers : `test_1.tsv`, `test_2.tsv` et `test_3.tsv`.

```bash theme={null}
# cat /var/lib/clickhouse/user_files/test_1.tsv
3    2    1

# cat /var/lib/clickhouse/user_files/test_2.tsv
1    3    2

# cat /var/lib/clickhouse/user_files/test_3.tsv
1    2    3
```

## Exemples de lecture depuis un fichier

### SELECT depuis un fichier CSV

Commencez par définir `user_files_path` dans la configuration du serveur et préparez un fichier `test.csv` :

```bash theme={null}
$ grep user_files_path /etc/clickhouse-server/config.xml
    <user_files_path>/var/lib/clickhouse/user_files/</user_files_path>

$ cat /var/lib/clickhouse/user_files/test.csv
    1,2,3
    3,2,1
    78,43,45
```

Ensuite, chargez les données de `test.csv` dans une table, puis sélectionnez ses deux premières lignes :

```sql theme={null}
SELECT * FROM
file('test.csv', 'CSV', 'column1 UInt32, column2 UInt32, column3 UInt32')
LIMIT 2;
```

```text theme={null}
┌─column1─┬─column2─┬─column3─┐
│       1 │       2 │       3 │
│       3 │       2 │       1 │
└─────────┴─────────┴─────────┘
```

### Insérer des données d’un fichier dans une table

```sql theme={null}
INSERT INTO FUNCTION
file('test.csv', 'CSV', 'column1 UInt32, column2 UInt32, column3 UInt32')
VALUES (1, 2, 3), (3, 2, 1);
```

```sql theme={null}
SELECT * FROM
file('test.csv', 'CSV', 'column1 UInt32, column2 UInt32, column3 UInt32');
```

```text theme={null}
┌─column1─┬─column2─┬─column3─┐
│       1 │       2 │       3 │
│       3 │       2 │       1 │
└─────────┴─────────┴─────────┘
```

Lecture des données à partir de `table.csv`, situé dans `archive1.zip` ou/et `archive2.zip` :

```sql theme={null}
SELECT * FROM file('user_files/archives/archive{1..2}.zip :: table.csv');
```

## Globs dans le chemin

Les chemins peuvent utiliser des globs. Les fichiers doivent correspondre à l’intégralité du motif de chemin, et pas seulement au suffixe ou au préfixe. Il existe une exception : si le chemin fait référence à un répertoire existant
et n’utilise pas de globs, un `*` sera implicitement ajouté au chemin afin que
tous les fichiers du répertoire soient sélectionnés.

* `*` — Représente un nombre arbitraire de caractères, sauf `/`, y compris la chaîne vide.
* `?` — Représente un caractère arbitraire unique.
* `{some_string,another_string,yet_another_one}` — Remplace par l’une des chaînes `'some_string', 'another_string', 'yet_another_one'`. Les chaînes peuvent contenir le symbole `/`.
* `{N..M}` — Représente tout nombre `>= N` et `<= M`.
* `**` - Représente récursivement tous les fichiers à l’intérieur d’un répertoire.

Les constructions avec `{}` sont similaires aux fonctions de table [remote](/fr/reference/functions/table-functions/remote) et [hdfs](/fr/reference/functions/table-functions/hdfs).

## Exemples

**Exemple**

Supposons que les fichiers suivants existent avec ces chemins relatifs :

* `some_dir/some_file_1`
* `some_dir/some_file_2`
* `some_dir/some_file_3`
* `another_dir/some_file_1`
* `another_dir/some_file_2`
* `another_dir/some_file_3`

Interrogez le nombre total de lignes de tous les fichiers :

```sql theme={null}
SELECT count(*) FROM file('{some,another}_dir/some_file_{1..3}', 'TSV', 'name String, value UInt32');
```

Une autre expression de chemin qui donne le même résultat :

```sql theme={null}
SELECT count(*) FROM file('{some,another}_dir/*', 'TSV', 'name String, value UInt32');
```

Récupérez le nombre total de lignes de `some_dir` à l’aide du `*` implicite :

```sql theme={null}
SELECT count(*) FROM file('some_dir', 'TSV', 'name String, value UInt32');
```

<Note>
  Si votre liste de fichiers contient des plages de nombres avec des zéros en tête, utilisez la construction avec des accolades pour chaque chiffre séparément, ou utilisez `?`.
</Note>

**Exemple**

Interrogez le nombre total de lignes des fichiers nommés `file000`, `file001`, ... , `file999` :

```sql theme={null}
SELECT count(*) FROM file('big_dir/file{0..9}{0..9}{0..9}', 'CSV', 'name String, value UInt32');
```

**Exemple**

Interrogez le nombre total de lignes de tous les fichiers du répertoire `big_dir/` et de ses sous-répertoires :

```sql theme={null}
SELECT count(*) FROM file('big_dir/**', 'CSV', 'name String, value UInt32');
```

**Exemple**

Exécutez une requête pour obtenir le nombre total de lignes de tous les fichiers `file002` présents dans n’importe quel dossier du répertoire `big_dir/`, de façon récursive :

```sql theme={null}
SELECT count(*) FROM file('big_dir/**/file002', 'CSV', 'name String, value UInt32');
```

## Colonnes virtuelles

* `_path` — Chemin du fichier. Type : `LowCardinality(String)`.
* `_file` — Nom du fichier. Type : `LowCardinality(String)`.
* `_size` — Taille du fichier en octets. Type : `Nullable(UInt64)`. Si la taille du fichier est inconnue, la valeur est `NULL`.
* `_time` — Date et heure de la dernière modification du fichier. Type : `Nullable(DateTime)`. Si la date et l’heure sont inconnues, la valeur est `NULL`.

## paramètre use\_hive\_partitioning

Lorsque le paramètre `use_hive_partitioning` est défini sur 1, ClickHouse détecte le partitionnement de type Hive dans le chemin (`/name=value/`) et permet d’utiliser les colonnes de partition comme colonnes virtuelles dans la requête. Ces colonnes virtuelles porteront les mêmes noms que dans le chemin partitionné.

**Exemple**

Utiliser une colonne virtuelle créée avec un partitionnement de type Hive

```sql theme={null}
SELECT * FROM file('data/path/date=*/country=*/code=*/*.parquet') WHERE date > '2020-01-01' AND country = 'Netherlands' AND code = 42;
```

## Paramètres

| Paramètre | Description |
| - | - |
| [engine\_file\_empty\_if\_not\_exists](/fr/reference/settings/session-settings/engine-file#engine_file_empty_if_not_exists) | permet de lire des données vides depuis un fichier inexistant. Désactivé par défaut. |
| [engine\_file\_truncate\_on\_insert](/fr/reference/settings/session-settings/engine-file#engine_file_truncate_on_insert) | permet de tronquer le fichier avant d'y insérer des données. Désactivé par défaut. |
| [engine\_file\_allow\_create\_multiple\_files](/fr/reference/settings/session-settings/engine-file#engine_file_allow_create_multiple_files) | permet de créer un nouveau fichier à chaque insert si le format a un suffixe. Désactivé par défaut. |
| [engine\_file\_skip\_empty\_files](/fr/reference/settings/session-settings/engine-file#engine_file_skip_empty_files) | permet d'ignorer les fichiers vides lors de la lecture. Désactivé par défaut. |
| [storage\_file\_read\_method](/fr/reference/settings/session-settings/storage#storage_file_read_method) | méthode de lecture des données depuis le fichier de stockage ; valeurs possibles : read, pread, mmap (uniquement pour clickhouse-local). Valeur par défaut : `pread` pour clickhouse-server, `mmap` pour clickhouse-local. |

## Voir aussi

* [Colonnes virtuelles](/fr/reference/engines/table-engines/index#table_engines-virtual_columns)
* [Renommer les fichiers après traitement](/fr/reference/settings/session-settings/other#rename_files_after_processing)