> ## 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.

> Documentation sur les fonctions de table

# Fonctions de table

Les fonctions de table permettent de construire des tables.

| Page                                                                                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [azureBlobStorage](/fr/reference/functions/table-functions/azureBlobStorage)                 | Fournit une interface de type table pour sélectionner/insérer des fichiers dans Azure Blob Storage. Similaire à la fonction s3.                                                                                                                                                                                                                                                                                                                                    |
| [azureBlobStorageCluster](/fr/reference/functions/table-functions/azureBlobStorageCluster)   | Permet de traiter en parallèle des fichiers d’Azure Blob Storage avec de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                                                                                                  |
| [clusterAllReplicas](/fr/reference/functions/table-functions/cluster)                        | Permet d’accéder à tous les shards (configurés dans la section `remote_servers`) d’un cluster sans créer de table Distributed.                                                                                                                                                                                                                                                                                                                                     |
| [deltaLake](/fr/reference/functions/table-functions/deltalake)                               | Fournit une interface de type table en lecture seule pour les tables Delta Lake dans Amazon S3.                                                                                                                                                                                                                                                                                                                                                                    |
| [deltaLakeCluster](/fr/reference/functions/table-functions/deltalakeCluster)                 | Il s’agit d’une extension de la fonction de table deltaLake.                                                                                                                                                                                                                                                                                                                                                                                                       |
| [dictionary](/fr/reference/functions/table-functions/dictionary)                             | Affiche les données du dictionnaire sous forme de table ClickHouse. Fonctionne de la même manière que le moteur Dictionary.                                                                                                                                                                                                                                                                                                                                        |
| [executable](/fr/reference/functions/table-functions/executable)                             | La fonction de table `executable` crée une table à partir de la sortie d’une fonction définie par l’utilisateur (UDF) que vous définissez dans un script qui écrit des lignes sur **stdout**.                                                                                                                                                                                                                                                                      |
| [file](/fr/reference/functions/table-functions/file)                                         | Un moteur de table qui fournit une interface de type table pour effectuer des `SELECT` à partir de fichiers et des `INSERT` dans des fichiers, de manière 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 comme S3, GCS ou MinIO.                                                                                                   |
| [fileCluster](/fr/reference/functions/table-functions/fileCluster)                           | Permet le traitement simultané des fichiers correspondant à un chemin spécifié sur plusieurs nœuds d’un cluster. L’initiateur établit des connexions avec les nœuds workers, développe les globs dans le chemin du fichier et leur délègue les tâches de lecture. Chaque nœud worker interroge l’initiateur pour obtenir le fichier suivant à traiter, et ce jusqu’à ce que toutes les tâches soient terminées (c’est-à-dire que tous les fichiers aient été lus). |
| [filesystem](/fr/reference/functions/table-functions/filesystem)                             | Fournit un accès au système de fichiers pour lister les fichiers et renvoyer leurs métadonnées et leur contenu.                                                                                                                                                                                                                                                                                                                                                    |
| [format](/fr/reference/functions/table-functions/format)                                     | Analyse les données à partir des arguments selon le format d’entrée spécifié. Si l’argument de structure n’est pas spécifié, il est extrait des données.                                                                                                                                                                                                                                                                                                           |
| [gcs](/fr/reference/functions/table-functions/gcs)                                           | Fournit une interface de type table pour `SELECT` et `INSERT` des données depuis Google Cloud Storage. Nécessite le rôle IAM `Storage Object User`.                                                                                                                                                                                                                                                                                                                |
| [fuzzQuery](/fr/reference/functions/table-functions/fuzzQuery)                               | Perturbe la chaîne de requête donnée avec des variations aléatoires.                                                                                                                                                                                                                                                                                                                                                                                               |
| [fuzzJSON](/fr/reference/functions/table-functions/fuzzJSON)                                 | Perturbe une chaîne JSON avec des variations aléatoires.                                                                                                                                                                                                                                                                                                                                                                                                           |
| [generateRandom](/fr/reference/functions/table-functions/generate)                           | Génère des données aléatoires selon un schéma donné. Permet de remplir des tables de test avec ces données. Tous les types ne sont pas pris en charge.                                                                                                                                                                                                                                                                                                             |
| [mergeTreeTextIndex](/fr/reference/functions/table-functions/mergeTreeTextIndex)             | Représente le dictionnaire d’un index de texte dans une table MergeTree. Peut être utilisée pour l’introspection.                                                                                                                                                                                                                                                                                                                                                  |
| [mergeTreeProjection](/fr/reference/functions/table-functions/mergeTreeProjection)           | Représente le contenu d’une projection dans des tables MergeTree. Peut être utilisée pour l’introspection.                                                                                                                                                                                                                                                                                                                                                         |
| [mergeTreeIndex](/fr/reference/functions/table-functions/mergeTreeIndex)                     | Représente le contenu des fichiers d’index et de marques des tables MergeTree. Peut être utilisée pour l’introspection.                                                                                                                                                                                                                                                                                                                                            |
| [hdfs](/fr/reference/functions/table-functions/hdfs)                                         | Crée une table à partir de fichiers dans HDFS. Cette fonction de table est similaire aux fonctions de table url et file.                                                                                                                                                                                                                                                                                                                                           |
| [hdfsCluster](/fr/reference/functions/table-functions/hdfsCluster)                           | Permet de traiter en parallèle des fichiers depuis HDFS à partir de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                                                                                                       |
| [hudi](/fr/reference/functions/table-functions/hudi)                                         | Fournit une interface de type table en lecture seule pour les tables Apache Hudi dans Amazon S3.                                                                                                                                                                                                                                                                                                                                                                   |
| [ytsaurus](/fr/reference/functions/table-functions/ytsaurus)                                 | La fonction de table permet de lire des données depuis le cluster YTsaurus.                                                                                                                                                                                                                                                                                                                                                                                        |
| [hudiCluster Table Function](/fr/reference/functions/table-functions/hudiCluster)            | Une extension de la fonction de table hudi. Permet de traiter en parallèle des fichiers de tables Apache Hudi dans Amazon S3 avec de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                                      |
| [iceberg](/fr/reference/functions/table-functions/iceberg)                                   | Fournit une interface de type table en lecture seule pour les tables Apache Iceberg dans Amazon S3, Azure, HDFS ou stockées localement.                                                                                                                                                                                                                                                                                                                            |
| [paimon](/fr/reference/functions/table-functions/paimon)                                     | Fournit une interface de type table en lecture seule pour les tables Apache Paimon dans Amazon S3, Azure, HDFS ou stockées localement.                                                                                                                                                                                                                                                                                                                             |
| [icebergCluster](/fr/reference/functions/table-functions/icebergCluster)                     | Une extension de la fonction de table iceberg qui permet de traiter en parallèle des fichiers Apache Iceberg à partir de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                                                  |
| [paimonCluster](/fr/reference/functions/table-functions/paimonCluster)                       | Une extension de la fonction de table paimon qui permet de traiter en parallèle des fichiers Apache Paimon à partir de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                                                    |
| [input](/fr/reference/functions/table-functions/input)                                       | Fonction de table qui permet de convertir et d’insérer efficacement, dans une table ayant une autre structure, des données envoyées au serveur avec une structure donnée.                                                                                                                                                                                                                                                                                          |
| [jdbc](/fr/reference/functions/table-functions/jdbc)                                         | Renvoie une table connectée via un pilote JDBC.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [merge](/fr/reference/functions/table-functions/merge)                                       | Crée une table Merge temporaire. La structure sera dérivée des tables sous-jacentes en utilisant une union de leurs colonnes et en déduisant des types communs.                                                                                                                                                                                                                                                                                                    |
| [mongodb](/fr/reference/functions/table-functions/mongodb)                                   | Permet d'exécuter des requêtes `SELECT` sur des données stockées sur un serveur MongoDB distant.                                                                                                                                                                                                                                                                                                                                                                   |
| [mysql](/fr/reference/functions/table-functions/mysql)                                       | Permet d'exécuter des requêtes `SELECT` et `INSERT` sur des données stockées sur un serveur MySQL distant.                                                                                                                                                                                                                                                                                                                                                         |
| [null](/fr/reference/functions/table-functions/null)                                         | Crée une table temporaire de la structure spécifiée avec le moteur de table Null. Cette fonction est utilisée pour faciliter l'écriture de tests et les démonstrations.                                                                                                                                                                                                                                                                                            |
| [timeSeriesMetrics](/fr/reference/functions/table-functions/timeSeriesMetrics)               | timeSeriesMetrics renvoie la table des métriques utilisée par la table `db_name.time_series_table`, dont le moteur de table est TimeSeries.                                                                                                                                                                                                                                                                                                                        |
| [timeSeriesSelector](/fr/reference/functions/table-functions/timeSeriesSelector)             | Lit des séries temporelles depuis une table TimeSeries, filtrées par un sélecteur et dont les horodatages appartiennent à un intervalle spécifié.                                                                                                                                                                                                                                                                                                                  |
| [timeSeriesTags](/fr/reference/functions/table-functions/timeSeriesTags)                     | La fonction de table timeSeriesTags renvoie la table des tags utilisée par la table `db_name.time_series_table`, dont le moteur de table est TimeSeries.                                                                                                                                                                                                                                                                                                           |
| [prometheusQueryRange](/fr/reference/functions/table-functions/prometheusQueryRange)         | Évalue une requête Prometheus à l'aide des données d'une table TimeSeries.                                                                                                                                                                                                                                                                                                                                                                                         |
| [zeros](/fr/reference/functions/table-functions/zeros)                                       | Utilisée à des fins de test comme méthode la plus rapide pour générer un grand nombre de lignes. Semblable aux tables système `system.zeros` et `system.zeros_mt`.                                                                                                                                                                                                                                                                                                 |
| [primes](/fr/reference/functions/table-functions/primes)                                     | Renvoie une table avec une seule colonne `prime` contenant des nombres premiers.                                                                                                                                                                                                                                                                                                                                                                                   |
| [numbers](/fr/reference/functions/table-functions/numbers)                                   | Renvoie une table avec une seule colonne `number` contenant une suite d'entiers.                                                                                                                                                                                                                                                                                                                                                                                   |
| [prometheusQuery](/fr/reference/functions/table-functions/prometheusQuery)                   | Évalue une requête Prometheus à l'aide des données d'une table TimeSeries.                                                                                                                                                                                                                                                                                                                                                                                         |
| [timeSeriesSamples](/fr/reference/functions/table-functions/timeSeriesSamples)               | timeSeriesSamples renvoie la table des échantillons utilisée par la table `db_name.time_series_table`, dont le moteur de table est TimeSeries.                                                                                                                                                                                                                                                                                                                     |
| [generate\_series (generateSeries)](/fr/reference/functions/table-functions/generate_series) | Renvoie une table avec l'unique colonne `generate_series` (UInt64), qui contient les entiers de start à stop inclus.                                                                                                                                                                                                                                                                                                                                               |
| [odbc](/fr/reference/functions/table-functions/odbc)                                         | Renvoie la table connectée via ODBC.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [postgresql](/fr/reference/functions/table-functions/postgresql)                             | Permet d'exécuter des requêtes `SELECT` et `INSERT` sur des données stockées sur un serveur PostgreSQL distant.                                                                                                                                                                                                                                                                                                                                                    |
| [redis](/fr/reference/functions/table-functions/redis)                                       | Cette fonction de table permet d'intégrer ClickHouse à Redis.                                                                                                                                                                                                                                                                                                                                                                                                      |
| [remote, remoteSecure](/fr/reference/functions/table-functions/remote)                       | La fonction de table `remote` permet d'accéder à des serveurs distants à la volée, c'est-à-dire sans créer de table distribuée. La fonction de table `remoteSecure` est identique à `remote`, mais via une connexion sécurisée.                                                                                                                                                                                                                                    |
| [s3 Table Function](/fr/reference/functions/table-functions/s3)                              | Fournit une interface de type table pour sélectionner/insérer des fichiers dans Amazon S3 et Google Cloud Storage. Cette fonction de table est similaire à la fonction hdfs, mais fournit des fonctionnalités spécifiques à S3.                                                                                                                                                                                                                                    |
| [s3Cluster](/fr/reference/functions/table-functions/s3Cluster)                               | Extension de la fonction de table s3, qui permet de traiter en parallèle des fichiers provenant d'Amazon S3 et de Google Cloud Storage avec de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                            |
| [sqlite](/fr/reference/functions/table-functions/sqlite)                                     | Permet d'exécuter des requêtes sur des données stockées dans une base de données SQLite.                                                                                                                                                                                                                                                                                                                                                                           |
| [arrowFlight](/fr/reference/functions/table-functions/arrowflight)                           | Permet de lire et d'écrire des données exposées via un serveur Apache Arrow Flight.                                                                                                                                                                                                                                                                                                                                                                                |
| [url](/fr/reference/functions/table-functions/url)                                           | Crée une table à partir de l'`URL`, avec le `format` et la `structure` spécifiés                                                                                                                                                                                                                                                                                                                                                                                   |
| [urlCluster](/fr/reference/functions/table-functions/urlCluster)                             | Permet de traiter en parallèle des fichiers depuis une URL à partir de nombreux nœuds dans un cluster spécifié.                                                                                                                                                                                                                                                                                                                                                    |
| [view](/fr/reference/functions/table-functions/view)                                         | Transforme une sous-requête en table. Cette fonction implémente des vues.                                                                                                                                                                                                                                                                                                                                                                                          |
| [values](/fr/reference/functions/table-functions/values)                                     | crée un stockage temporaire qui remplit les colonnes avec des valeurs.                                                                                                                                                                                                                                                                                                                                                                                             |
| [loop](/fr/reference/functions/table-functions/loop)                                         | La fonction de table loop dans ClickHouse est utilisée pour renvoyer les résultats de la requête dans une boucle infinie.                                                                                                                                                                                                                                                                                                                                          |

<div id="usage">
  ## Utilisation
</div>

Les fonctions de table peuvent être utilisées dans la clause [`FROM`](/fr/reference/statements/select/from)
d’une requête `SELECT`. Par exemple, vous pouvez `SELECT` des données depuis un fichier situé sur votre machine locale
à l’aide de la fonction de table `file`.

```bash title="Query" theme={null}
echo "1, 2, 3" > example.csv
```

```text title="Response" theme={null}
./clickhouse client
:) SELECT * FROM file('example.csv')
┌─c1─┬─c2─┬─c3─┐
│  1 │  2 │  3 │
└────┴────┴────┘
```

Vous pouvez également utiliser des fonctions de table pour créer une table temporaire accessible
uniquement pendant la requête en cours. Par exemple :

```sql title="Query" theme={null}
SELECT * FROM generateSeries(1,5);
```

```response title="Response" theme={null}
┌─generate_series─┐
│               1 │
│               2 │
│               3 │
│               4 │
│               5 │
└─────────────────┘
```

La table est supprimée lorsque la requête se termine.

Les fonctions de table peuvent servir à créer des tables, selon la syntaxe suivante :

```sql title="Query" theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name AS table_function()
```

Par exemple :

```sql title="Query" theme={null}
CREATE TABLE series AS generateSeries(1, 5);
SELECT * FROM series;
```

```response title="Response" theme={null}
┌─generate_series─┐
│               1 │
│               2 │
│               3 │
│               4 │
│               5 │
└─────────────────┘
```

Enfin, les fonctions de table peuvent être utilisées pour `INSERT` des données dans une table. Par exemple,
nous pourrions écrire le contenu de la table que nous avons créée dans l’exemple précédent
dans un fichier sur disque en utilisant à nouveau la fonction de table `file` :

```sql title="Query" theme={null}
INSERT INTO FUNCTION file('numbers.csv', 'CSV') SELECT * FROM series;
```

```bash title="Query" theme={null}
cat numbers.csv
1
2
3
4
5
```

<Note>
  Vous ne pouvez pas utiliser de fonctions de table si le paramètre [allow\_ddl](/fr/reference/settings/session-settings#allow_ddl) est désactivé.
</Note>
