const` (et, de manière équivalente, `ifNull`, ou avec la constante à gauche) en une disjonction avant l’analyse des index, afin de pouvoir utiliser la clé primaire par colonne et les skip indexes sur chaque `a_i`. Les formes partiellement constantes telles que `coalesce(a, 42, b)` et `coalesce(a, b, 42)` sont également prises en charge."}]}]} />
Permet à la clé primaire MergeTree et aux skip indexes d’élaguer les granules pour les prédicats `WHERE`/`PREWHERE` qui utilisent `coalesce` ou `ifNull`. Sans ce paramètre, ces prédicats sont opaques pour l’analyse des index et ne permettent pas d’élagage, de sorte que des granules qui ne peuvent pas correspondre sont tout de même lus. Cela n’affecte que les granules lus ; les résultats de la requête restent inchangés, car les lignes sont toujours filtrées par le prédicat d’origine.
Deux formes de prédicats sont réécrites avant l’analyse des index :
* Une comparaison avec `coalesce`/`ifNull`, telle que `coalesce(a, b) = 5`, devient une disjonction afin qu’un index sur chaque argument puisse élaguer : `a = 5 OR (a IS NULL AND b = 5)`, avec extension au cas de plusieurs arguments.
* Un `coalesce`/`ifNull` avec une constante par défaut falsy (zéro), utilisé directement comme condition, tel que `ifNull(a = 5, 0)` ou `coalesce(a = 5, 0)`, est ramené à son prédicat interne `a = 5`. De tels wrappers ramènent le résultat à trois valeurs du prédicat interne à un booléen explicite (en faisant correspondre `NULL` à `false`).
## allow\_limit\_by\_partitions\_independently
Activer l’évaluation indépendante de `LIMIT BY` pour chaque partition dans des threads distincts lorsque l’expression de partition est une fonction déterministe des colonnes de `LIMIT BY`.
## allow\_materialized\_view\_with\_bad\_select
Autorise CREATE MATERIALIZED VIEW avec une requête SELECT qui référence des tables ou des colonnes inexistantes. Elle doit toutefois rester syntaxiquement valide. Ne s’applique pas aux MV actualisables. Ne s’applique pas si le schéma de la MV doit être inféré à partir de la requête SELECT (c.-à-d. si le CREATE ne comporte ni liste de colonnes ni table TO). Peut être utilisé pour créer une MV avant sa table source.
## allow\_named\_collection\_override\_by\_default
Autorise par défaut la redéfinition des champs des collections nommées.
## allow\_non\_metadata\_alters
Autorise l’exécution d’opérations ALTER qui modifient non seulement les métadonnées des tables, mais aussi les données sur disque
## allow\_nonconst\_timezone\_arguments
Autorise les arguments de fuseau horaire non constants dans certaines fonctions liées à l’heure, comme toTimeZone(), fromUnixTimestamp\*() et snowflakeToDateTime\*().
Ce paramètre existe uniquement pour des raisons de compatibilité. Dans ClickHouse, le fuseau horaire est une propriété du type de données et, par conséquent, de la colonne.
L’activation de ce paramètre donne à tort l’impression que différentes valeurs d’une même colonne peuvent avoir des fuseaux horaires différents.
N’activez donc pas ce paramètre.
## allow\_nondeterministic\_mutations
Paramètre défini au niveau de l’utilisateur qui autorise les mutations sur les tables répliquées à utiliser des fonctions non déterministes telles que `dictGet`.
Comme, par exemple, les dictionnaires peuvent ne pas être synchronisés entre les nœuds, les mutations qui en extraient des valeurs sont interdites par défaut sur les tables répliquées. L’activation de ce paramètre autorise ce comportement ; il incombe alors à l’utilisateur de veiller à ce que les données utilisées soient synchronisées sur l’ensemble des nœuds.
**Exemple**
```xml theme={null}
1
```
## allow\_nondeterministic\_optimize\_skip\_unused\_shards
Autorise les fonctions non déterministes (comme `rand` ou `dictGet`, ce dernier présentant certaines limitations lors des mises à jour) dans la clé de sharding.
Valeurs possibles :
* 0 — Interdit.
* 1 — Autorisé.
## allow\_nullable\_tuple\_in\_extracted\_subcolumns
Détermine si les sous-colonnes extraites de type `Tuple(...)` peuvent être typées comme `Nullable(Tuple(...))`.
* `false` : renvoie `Tuple(...)` et utilise les valeurs de tuple par défaut pour les lignes où la sous-colonne est absente.
* `true` : renvoie `Nullable(Tuple(...))` et utilise `NULL` pour les lignes où la sous-colonne est absente.
Ce paramètre contrôle uniquement le comportement des sous-colonnes extraites.
Il ne détermine pas si des colonnes `Nullable(Tuple(...))` peuvent être créées dans des tables ; cela est contrôlé par `enable_nullable_tuple_type`.
ClickHouse utilise la valeur de ce paramètre chargée au démarrage du serveur.
Les modifications effectuées avec `SET` ou `SETTINGS` au niveau de la requête ne modifient pas le comportement des sous-colonnes extraites.
Pour modifier le comportement des sous-colonnes extraites, mettez à jour `allow_nullable_tuple_in_extracted_subcolumns` dans la configuration du profil de démarrage (par exemple, users.xml) et redémarrez le serveur.
## allow\_prefetched\_read\_pool\_for\_local\_filesystem
Privilégie le pool de threads de prélecture si toutes les parts se trouvent sur le système de fichiers local
## allow\_prefetched\_read\_pool\_for\_remote\_filesystem
Préférer le pool de threads de prélecture si toutes les part se trouvent sur un système de fichiers distant
## allow\_push\_predicate\_ast\_for\_distributed\_subqueries
Autorise la propagation des prédicats au niveau de l’AST pour les sous-requêtes Distributed lorsque l’analyseur est activé
## allow\_push\_predicate\_when\_subquery\_contains\_with
Autorise la propagation des prédicats lorsque la sous-requête contient une clause WITH
## allow\_rank\_dense\_rank\_arguments
Autorise le passage d’arguments aux fonctions de fenêtre `RANK` et `DENSE_RANK` afin d’assurer la rétrocompatibilité.
Selon la norme SQL, `RANK` et `DENSE_RANK` ne prennent aucun argument : elles classent les lignes uniquement en fonction de la fenêtre `OVER (ORDER BY ...)`. Dans les versions de ClickHouse antérieures à la 26.5, des requêtes comme `RANK(x) OVER (...)` acceptaient silencieusement l’argument et l’ignoraient, ce qui prêtait à confusion (la présence visible de l’argument laissait penser qu’il influençait le classement, alors que ce n’était pas le cas).
Lorsque ce paramètre est défini sur `false` (valeur par défaut), `RANK` et `DENSE_RANK` rejettent tout argument et lèvent `NUMBER_OF_ARGUMENTS_DOESNT_MATCH`. Lorsqu’il est défini sur `true`, le comportement permissif legacy est rétabli : les arguments sont silencieusement ignorés, comme avant la version 26.5.
## allow\_reorder\_prewhere\_conditions
Lors du déplacement des conditions de WHERE vers PREWHERE, autoriser leur réordonnancement pour optimiser le filtrage
## allow\_settings\_after\_format\_in\_insert
Indique si `SETTINGS` après `FORMAT` dans les requêtes `INSERT` est autorisé ou non. Il n'est pas recommandé d'utiliser ce paramètre, car une partie de `SETTINGS` peut être interprétée comme des valeurs.
Exemple :
```sql theme={null}
INSERT INTO FUNCTION null('foo String') SETTINGS max_threads=1 VALUES ('bar');
```
Mais la requête suivante ne fonctionnera que si `allow_settings_after_format_in_insert` est activé :
```sql theme={null}
SET allow_settings_after_format_in_insert=1;
INSERT INTO FUNCTION null('foo String') VALUES ('bar') SETTINGS max_threads=1;
```
Valeurs possibles :
* 0 — Interdire.
* 1 — Autoriser.
Utilisez ce paramètre uniquement pour assurer la rétrocompatibilité si vos cas d’usage dépendent de l’ancienne syntaxe.
## allow\_simdjson
Permet d'utiliser la bibliothèque simdjson dans les fonctions 'JSON\*' si les instructions AVX2 sont disponibles. Si cette option est désactivée, rapidjson est utilisé.
## allow\_special\_serialization\_kinds\_in\_output\_formats
Permet de produire des colonnes avec des modes de sérialisation spéciaux comme Sparse et Replicated sans les convertir en représentation complète de colonne.
Cela permet d'éviter des copies de données inutiles lors du formatage.
## allow\_statistics
**Alias** : `allow_experimental_statistics`
Permet de définir des colonnes avec des [statistiques](/fr/reference/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-creating-a-table) et de [gérer les statistiques](/fr/reference/engines/table-engines/mergetree-family/mergetree#column-statistics).
## allow\_statistics\_optimize
**Alias** : `allow_statistic_optimize`
Permet d'utiliser des statistiques pour optimiser les requêtes
## allow\_suspicious\_codecs
S'il est défini sur true, autorise la spécification de codecs de compression dénués de sens.
## allow\_suspicious\_fixed\_string\_types
Dans l’instruction CREATE TABLE, autorise la création de colonnes de type FixedString(n) avec n > 256. Un FixedString de longueur >= 256 est suspect et indique très probablement une mauvaise utilisation
## allow\_suspicious\_indices
Rejette les index primaires/secondaires et les clés de tri ayant des expressions identiques
## allow\_suspicious\_low\_cardinality\_types
Autorise ou restreint l'utilisation de [LowCardinality](/fr/reference/data-types/lowcardinality) avec des types de données de taille fixe inférieure ou égale à 8 octets : types de données numériques et `FixedString(8_bytes_or_less)`.
Pour des valeurs fixes de petite taille, l'utilisation de `LowCardinality` est généralement inefficace, car ClickHouse stocke un index numérique pour chaque ligne. Par conséquent :
* L'utilisation de l'espace disque peut augmenter.
* La consommation de RAM peut être plus élevée, selon la taille du dictionnaire.
* Certaines fonctions peuvent être plus lentes en raison d'opérations supplémentaires d'encodage.
Les temps de fusion dans les tables du moteur [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) peuvent augmenter pour toutes les raisons décrites ci-dessus.
Valeurs possibles :
* 1 — L'utilisation de `LowCardinality` n'est pas restreinte.
* 0 — L'utilisation de `LowCardinality` est restreinte.
## allow\_suspicious\_primary\_key
Autoriser les `PRIMARY KEY`/`ORDER BY` jugés suspects pour MergeTree (c.-à-d. SimpleAggregateFunction).
## allow\_suspicious\_ttl\_expressions
Rejette les expressions TTL qui ne dépendent d’aucune colonne de la table. Cela signale le plus souvent une erreur utilisateur.
## allow\_suspicious\_types\_in\_group\_by
Autorise ou interdit l’utilisation des types [Variant](/fr/reference/data-types/variant) et [Dynamic](/fr/reference/data-types/dynamic) dans les clés GROUP BY.
## allow\_suspicious\_types\_in\_order\_by
Autorise ou restreint l'utilisation des types [Variant](/fr/reference/data-types/variant) et [Dynamic](/fr/reference/data-types/dynamic) dans les clés ORDER BY.
## allow\_suspicious\_variant\_types
Dans l’instruction CREATE TABLE, autorise la spécification du type Variant avec des types de variantes similaires (par exemple, différents types numériques ou de date). L’activation de ce paramètre peut introduire une certaine ambiguïté lors de la manipulation de valeurs de types similaires.
## allow\_unrestricted\_reads\_from\_keeper
Autorise les lectures sans restriction (sans condition sur le chemin) depuis la table system.zookeeper ; cela peut être pratique, mais n'est pas sûr pour ZooKeeper
## alter\_move\_to\_space\_execute\_async
Exécuter ALTER TABLE MOVE ... TO \[DISK|VOLUME] de manière asynchrone
## alter\_partition\_verbose\_result
Active ou désactive l’affichage d’informations sur les parts auxquelles les opérations de manipulation de partitions et de parts ont été appliquées avec succès.
S’applique à [ATTACH PARTITION|PART](/fr/reference/statements/alter/partition#attach-partitionpart) et à [FREEZE PARTITION](/fr/reference/statements/alter/partition#freeze-partition).
Valeurs possibles :
* 0 — désactiver le mode verbeux.
* 1 — activer le mode verbeux.
**Exemple**
```sql theme={null}
CREATE TABLE test(a Int64, d Date, s String) ENGINE = MergeTree PARTITION BY toYYYYMDECLARE(d) ORDER BY a;
INSERT INTO test VALUES(1, '2021-01-01', '');
INSERT INTO test VALUES(1, '2021-01-01', '');
ALTER TABLE test DETACH PARTITION ID '202101';
ALTER TABLE test ATTACH PARTITION ID '202101' SETTINGS alter_partition_verbose_result = 1;
┌─command_type─────┬─partition_id─┬─part_name────┬─old_part_name─┐
│ ATTACH PARTITION │ 202101 │ 202101_7_7_0 │ 202101_5_5_0 │
│ ATTACH PARTITION │ 202101 │ 202101_8_8_0 │ 202101_6_6_0 │
└──────────────────┴──────────────┴──────────────┴───────────────┘
ALTER TABLE test FREEZE SETTINGS alter_partition_verbose_result = 1;
┌─command_type─┬─partition_id─┬─part_name────┬─backup_name─┬─backup_path───────────────────┬─part_backup_path────────────────────────────────────────────┐
│ FREEZE ALL │ 202101 │ 202101_7_7_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_7_7_0 │
│ FREEZE ALL │ 202101 │ 202101_8_8_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_8_8_0 │
└──────────────┴──────────────┴──────────────┴─────────────┴───────────────────────────────┴─────────────────────────────────────────────────────────────┘
```
## alter\_sync
**Alias** : `replication_alter_partitions_sync`
Permet de définir le comportement d’attente pour les actions à exécuter sur les répliques par les requêtes [`ALTER`](/fr/reference/statements/alter/index), [`OPTIMIZE`](/fr/reference/statements/optimize) ou [`TRUNCATE`](/fr/reference/statements/truncate).
Valeurs possibles :
* `0` — Ne pas attendre.
* `1` — Attendre l’exécution locale.
* `2` — Attendre toutes les répliques.
* `3` - Attendre uniquement les répliques actives.
Valeur par défaut dans Cloud : `0`.
`alter_sync` s’applique uniquement aux tables `Replicated` et `SharedMergeTree` ; ce paramètre est sans effet sur les tables non `Replicated` ou `Shared`.
## alter\_update\_mode
Mode des requêtes `ALTER` contenant des commandes `UPDATE`.
Valeurs possibles :
* `heavy` - exécute une mutation classique.
* `lightweight` - exécute une mise à jour légère si possible, sinon exécute une mutation classique.
* `lightweight_force` - exécute une mise à jour légère si possible, sinon lève une exception.
## analyze\_index\_with\_space\_filling\_curves
Si une table possède une courbe de remplissage de l’espace dans son index, par exemple `ORDER BY mortonEncode(x, y)` ou `ORDER BY hilbertEncode(x, y)`, et si la requête comporte des conditions sur ses arguments, par exemple `x >= 10 AND x <= 20 AND y >= 20 AND y <= 30`, la courbe de remplissage de l’espace est utilisée pour l’analyse de l’index.
## analyzer\_compatibility\_allow\_compound\_identifiers\_in\_unflatten\_nested
Permet d’ajouter à `Nested` des identifiants composés. Il s’agit d’un paramètre de compatibilité, car il modifie le résultat de la requête. Lorsqu’il est désactivé, `SELECT a.b.c FROM table ARRAY JOIN a` ne fonctionne pas, et `SELECT a FROM table` n’inclut pas la colonne `a.b.c` dans le résultat `Nested a`.
## analyzer\_compatibility\_join\_using\_top\_level\_identifier
Force la résolution de l’identifiant dans JOIN USING à partir de la projection (par exemple, dans `SELECT a + 1 AS b FROM t1 JOIN t2 USING (b)`, la jointure sera effectuée sur `t1.a + 1 = t2.b`, plutôt que sur `t1.b = t2.b`).
## analyzer\_compatibility\_prefer\_alias\_over\_subcolumn
Lorsqu’un identifiant multipartite comme `b.id` peut faire référence soit à la colonne `id` d’une table avec l’alias `b`, soit à une sous-colonne Tuple `b.id` d’une autre colonne, privilégiez l’interprétation avec préfixe d’alias (colonne `id` de `b`). Par défaut, le nouvel analyseur privilégie la sous-colonne. Activez ce paramètre pour retrouver la résolution de l’ancien analyseur.
## analyzer\_inline\_views
Lorsqu’il est activé, l’analyseur remplace les vues ordinaires (non matérialisées, non paramétrées) par les sous-requêtes qui les définissent, ce qui permet des optimisations transversales comme le pushdown de prédicats et l’élagage des colonnes.
## any\_join\_distinct\_right\_table\_keys
Active le comportement legacy du serveur ClickHouse pour les opérations `ANY INNER|LEFT JOIN`.
Utilisez ce paramètre uniquement pour la rétrocompatibilité si vos cas d’usage dépendent du comportement legacy de `JOIN`.
Lorsque le comportement legacy est activé :
* Les résultats des opérations `t1 ANY LEFT JOIN t2` et `t2 ANY RIGHT JOIN t1` ne sont pas identiques, car ClickHouse utilise une logique de correspondance des clés de table de gauche à droite, de plusieurs vers une.
* Les résultats des opérations `ANY INNER JOIN` contiennent toutes les lignes de la table de gauche, comme dans les opérations `SEMI LEFT JOIN`.
Lorsque le comportement legacy est désactivé :
* Les résultats des opérations `t1 ANY LEFT JOIN t2` et `t2 ANY RIGHT JOIN t1` sont identiques, car ClickHouse utilise une logique qui assure une correspondance des clés de un vers plusieurs dans les opérations `ANY RIGHT JOIN`.
* Les résultats des opérations `ANY INNER JOIN` contiennent une ligne par clé provenant des tables de gauche et de droite.
Valeurs possibles :
* 0 — Le comportement legacy est désactivé.
* 1 — Le comportement legacy est activé.
Voir aussi :
* [Strictness de JOIN](/fr/reference/statements/select/join#settings)
## apply\_deleted\_mask
Permet de filtrer les lignes supprimées avec le DELETE léger. Si cette option est désactivée, une requête pourra lire ces lignes. Cela est utile pour le débogage et les scénarios de « restauration » de suppression
## apply\_mutations\_on\_fly
Si la valeur est true, les mutations (UPDATE et DELETE) qui ne sont pas matérialisées dans les data parts seront appliquées lors des SELECT.
## apply\_patch\_parts
Si la valeur est true, les patch parts (qui représentent des mises à jour légères) sont appliquées lors des requêtes SELECT.
## apply\_patch\_parts\_join\_cache\_buckets
Le nombre de buckets dans le cache temporaire utilisé pour appliquer les patch parts en mode Join.
## apply\_prewhere\_after\_final
Lorsqu'il est activé, les conditions PREWHERE sont appliquées après le traitement FINAL pour ReplacingMergeTree et les moteurs similaires.
Cela peut être utile lorsque PREWHERE fait référence à des colonnes dont les valeurs peuvent différer entre des lignes dupliquées,
et que vous souhaitez que FINAL sélectionne la ligne retenue avant le filtrage. Lorsqu'il est désactivé, PREWHERE est appliqué lors de la lecture.
Remarque : si apply\_row\_level\_security\_after\_final est activé et que la politique de ligne utilise des colonnes qui ne font pas partie de la clé de tri, PREWHERE sera également
différé afin de préserver le bon ordre d'exécution (la politique de ligne doit être appliquée avant PREWHERE).
## apply\_row\_policy\_after\_final
Lorsqu’il est activé, les politiques de ligne et PREWHERE sont appliqués après le traitement FINAL pour les tables \*MergeTree. (En particulier pour ReplacingMergeTree)
Lorsqu’il est désactivé, les politiques de ligne sont appliquées avant FINAL, ce qui peut produire des résultats différents lorsque la politique
filtre des lignes qui devraient être utilisées pour la déduplication dans ReplacingMergeTree ou des moteurs similaires.
Si l’expression de la politique de ligne dépend uniquement des colonnes de ORDER BY, elle sera tout de même appliquée avant FINAL à titre d’optimisation,
car un tel filtrage ne peut pas affecter le résultat de la déduplication.
Valeurs possibles :
* 0 — La politique de ligne et PREWHERE sont appliqués avant FINAL (par défaut).
* 1 — La politique de ligne et PREWHERE sont appliqués après FINAL.
## apply\_settings\_from\_server
Indique si le client doit accepter les paramètres du serveur.
Cela n’affecte que les opérations effectuées côté client, en particulier l’analyse des données d’entrée INSERT et le formatage du résultat de la requête. La majeure partie de l’exécution des requêtes se fait sur le serveur et n’est pas affectée par ce paramètre.
Normalement, ce paramètre doit être défini dans le profil utilisateur (`users.xml` ou via des requêtes comme `ALTER USER`), et non via le client (arguments de ligne de commande du client, requête `SET` ou section `SETTINGS` d’une requête `SELECT`). Via le client, il peut être défini sur false, mais pas sur true (car le serveur n’enverra pas les paramètres si le profil utilisateur contient `apply_settings_from_server = false`).
Notez qu’au départ (24.12), il existait un paramètre serveur (`send_settings_to_client`), mais il a ensuite été remplacé par ce paramètre client, pour une meilleure ergonomie.
## archive\_adaptive\_buffer\_max\_size\_bytes
Limite la taille maximale du buffer adaptatif utilisé lors de l’écriture vers des fichiers d’archive (par exemple, des archives tar
## arrow\_flight\_request\_descriptor\_type
Type de descripteur à utiliser pour les requêtes Arrow Flight. 'path' envoie le nom du jeu de données sous forme de descripteur de chemin. 'command' envoie une requête SQL sous forme de descripteur de commande (obligatoire pour Dremio).
Valeurs possibles :
* 'path' — Utilise FlightDescriptor::Path (par défaut, fonctionne avec la plupart des serveurs Arrow Flight)
* 'command' — Utilise FlightDescriptor::Command avec une requête SELECT (obligatoire pour Dremio)
## ast\_fuzzer\_any\_query
Lorsque la valeur est false (par défaut), le server-side AST fuzzer (contrôlé par `ast_fuzzer_runs`) ne soumet au fuzzing que les requêtes en lecture seule (SELECT, EXPLAIN, SHOW, DESCRIBE, EXISTS). Lorsque la valeur est true, tous les types de requêtes, y compris DDL et INSERT, sont soumis au fuzzing.
## ast\_fuzzer\_runs
Active l’AST fuzzer côté serveur, qui exécute des requêtes aléatoires après chaque requête normale, sans conserver leurs résultats.
* 0 : désactivé (par défaut).
* Une valeur comprise entre 0 et 1 (exclusive) : probabilité d’exécuter une seule requête fuzzée.
* Une valeur >= 1 : nombre de requêtes fuzzées à exécuter par requête normale.
Le fuzzer accumule des fragments d’AST issus de toutes les requêtes de toutes les sessions, ce qui produit au fil du temps des mutations de plus en plus intéressantes. Les requêtes fuzzées qui échouent sont ignorées silencieusement ; leurs résultats ne sont jamais renvoyés au client.
## asterisk\_include\_alias\_columns
Inclure les colonnes [ALIAS](/fr/reference/statements/create/table#alias) dans les requêtes avec caractère générique (`SELECT *`).
Valeurs possibles :
* 0 - désactivé
* 1 - activé
## asterisk\_include\_materialized\_columns
Inclut les colonnes [MATERIALIZED](/fr/reference/statements/create/view#materialized-view) dans les requêtes avec caractère générique (`SELECT *`).
Valeurs possibles :
* 0 - désactivé
* 1 - activé
## asterisk\_include\_virtual\_columns
Inclure les colonnes virtuelles dans les requêtes avec caractère générique (`SELECT *`).
Valeurs possibles :
* 0 - désactivé
* 1 - activé
## async\_insert
Si true, les données de la requête INSERT sont placées dans une file d’attente, puis écrites dans la table en arrière-plan. Si wait\_for\_async\_insert est false, la requête INSERT est traitée presque instantanément ; sinon, le client attend que les données soient écrites dans la table.
## async\_insert\_busy\_timeout\_decrease\_rate
Le taux de croissance exponentielle selon lequel le délai d'expiration adaptatif de l'insertion asynchrone diminue
## async\_insert\_busy\_timeout\_increase\_rate
Le taux de croissance exponentielle selon lequel augmente le délai d'attente adaptatif des insertions asynchrones
## async\_insert\_busy\_timeout\_max\_ms
**Alias** : `async_insert_busy_timeout_ms`
Temps d’attente maximal avant de vider les données collectées pour chaque requête à partir de l’arrivée des premières données.
Valeur par défaut dans Cloud : `1000` (1s).
## async\_insert\_busy\_timeout\_min\_ms
Si l’ajustement automatique est activé via async\_insert\_use\_adaptive\_busy\_timeout, durée minimale d’attente avant de vider les données collectées pour chaque requête à partir de l’arrivée des premières données. Elle sert également de valeur initiale pour l’algorithme adaptatif
## async\_insert\_deduplicate
Pour les requêtes INSERT asynchrones dans une table répliquée, indique si la déduplication des blocs insérés doit être effectuée
## async\_insert\_max\_data\_size
Taille maximale, en octets, des données non analysées accumulées pour chaque requête avant leur insertion
Valeur par défaut dans Cloud : `104857600` (100 MiB).
## async\_insert\_max\_query\_number
Nombre maximal de requêtes d’insertion avant leur insertion.
Ne prend effet que si le paramètre [`async_insert_deduplicate`](#async_insert_deduplicate) vaut 1.
## async\_insert\_poll\_timeout\_ms
Délai d’expiration pour l’interrogation des données de la file d’attente des insertions asynchrones
## async\_insert\_use\_adaptive\_busy\_timeout
Si ce paramètre est défini sur true, le délai d’expiration d’activité adaptatif est utilisé pour les insertions asynchrones
## async\_query\_sending\_for\_remote
Active la création asynchrone des connexions et l'envoi des requêtes lors de l'exécution d'une requête distante.
Activé par défaut.
## async\_socket\_for\_remote
Active la lecture asynchrone à partir du socket lors de l'exécution d'une requête distante.
Activé par défaut.
## automatic\_parallel\_replicas\_min\_bytes\_per\_replica
Seuil d’octets à lire par réplique pour activer automatiquement les répliques parallèles (s’applique uniquement lorsque `automatic_parallel_replicas_mode`=1). 0 signifie qu’il n’y a pas de seuil.
Le nombre total d’octets à lire est estimé à partir des statistiques collectées.
## automatic\_parallel\_replicas\_mode
Active le basculement automatique vers une exécution avec des répliques parallèles en fonction des statistiques collectées. Nécessite `enable_analyzer = 1`, `enable_parallel_replicas != 0`, `parallel_replicas_local_plan = 1`, ainsi que la définition de `cluster_for_parallel_replicas`.
0 - désactivé, 1 - activé, 2 - seule la collecte de statistiques est activée (le basculement vers une exécution avec des répliques parallèles est désactivé).
## azure\_allow\_parallel\_part\_upload
Utilisez plusieurs threads pour le téléversement multipart sur Azure.
## azure\_check\_objects\_after\_upload
Vérifie chaque objet téléversé dans le stockage Blob Azure afin de s’assurer que le téléversement a réussi
## azure\_connect\_timeout\_ms
Délai d’expiration de connexion à l’hôte pour les disques Azure.
## azure\_create\_new\_file\_on\_insert
Active ou désactive la création d’un nouveau fichier à chaque insertion dans les tables du moteur Azure
## azure\_ignore\_file\_doesnt\_exist
Ignorer l'absence de fichier s'il n'existe pas lors de la lecture de certaines clés.
Valeurs possibles :
* 1 — `SELECT` renvoie un résultat vide.
* 0 — `SELECT` lève une exception.
## azure\_list\_object\_keys\_size
Nombre maximal de fichiers pouvant être renvoyés par lot lors d'une requête ListObject
## azure\_max\_blocks\_in\_multipart\_upload
Nombre maximal de blocs dans un téléversement multipart pour Azure.
## azure\_max\_get\_burst
Nombre maximal de requêtes pouvant être envoyées simultanément avant d'atteindre la limite de requêtes par seconde. Par défaut (0), cette valeur est égale à `azure_max_get_rps`
## azure\_max\_get\_rps
Limite du nombre de requêtes GET Azure par seconde avant l’application du throttling. Zéro signifie aucune limite.
## azure\_max\_inflight\_parts\_for\_one\_file
Le nombre maximal de parties chargées simultanément dans une requête de téléversement multipart. 0 signifie illimité.
## azure\_max\_put\_burst
Nombre maximal de requêtes pouvant être émises simultanément avant d’atteindre la limite de requêtes par seconde. Par défaut (0), il est égal à `azure_max_put_rps`
## azure\_max\_put\_rps
Limite du nombre de requêtes PUT Azure par seconde avant l'application d'une limitation du débit. Zéro signifie qu'il n'y a pas de limite.
## azure\_max\_redirects
Nombre maximal de redirections Azure successives autorisées.
## azure\_max\_single\_part\_copy\_size
La taille maximale d’un objet pouvant être copié vers Azure blob storage au moyen d’une copie en une seule partie.
## azure\_max\_single\_part\_upload\_size
Taille maximale d’un objet pouvant être téléversé en une seule partie vers Azure blob storage.
## azure\_max\_single\_read\_retries
Le nombre maximal de tentatives de nouvelle lecture unique depuis Azure Blob Storage.
## azure\_max\_unexpected\_write\_error\_retries
Le nombre maximal de nouvelles tentatives en cas d’erreurs inattendues lors de l’écriture dans Azure Blob Storage
## azure\_max\_upload\_part\_size
La taille maximale d'une partie à téléverser lors d'un téléversement multipart vers Azure blob storage.
## azure\_min\_upload\_part\_size
La taille minimale d'une partie à téléverser lors d'un téléversement multipart vers Azure Blob Storage.
## azure\_request\_timeout\_ms
Délai d'inactivité pour l'envoi et la réception de données vers/depuis azure. Échoue si un seul appel TCP de lecture ou d'écriture reste bloqué pendant ce délai.
## azure\_sdk\_max\_retries
Nombre maximal de réessais dans l’Azure SDK
## azure\_sdk\_retry\_initial\_backoff\_ms
Délai de backoff minimal entre les tentatives dans l’Azure SDK
## azure\_sdk\_retry\_max\_backoff\_ms
Délai de backoff maximal entre les tentatives dans azure sdk
## azure\_skip\_empty\_files
Active ou désactive la possibilité d’ignorer les fichiers vides dans le moteur S3.
Valeurs possibles :
* 0 — `SELECT` lève une exception si le fichier vide n’est pas compatible avec le format demandé.
* 1 — `SELECT` renvoie un résultat vide pour un fichier vide.
## azure\_strict\_upload\_part\_size
La taille exacte de la partie à téléverser lors d’un téléversement multipart vers Azure blob storage.
## azure\_throw\_on\_zero\_files\_match
Lever une erreur si aucun fichier ne correspond aux règles d’expansion des motifs glob.
Valeurs possibles :
* 1 — `SELECT` lève une exception.
* 0 — `SELECT` renvoie un résultat vide.
## azure\_truncate\_on\_insert
Active ou désactive la suppression de toutes les données avant insertion dans les tables utilisant le moteur Azure.
## azure\_upload\_part\_size\_multiply\_factor
Multipliez azure\_min\_upload\_part\_size par ce facteur chaque fois que azure\_multiply\_parts\_count\_threshold parties ont été téléversées en une seule écriture vers Azure Blob Storage.
## azure\_upload\_part\_size\_multiply\_parts\_count\_threshold
Chaque fois que ce nombre de parties a été téléversé vers Azure blob storage, azure\_min\_upload\_part\_size est multiplié par azure\_upload\_part\_size\_multiply\_factor.
## azure\_use\_adaptive\_timeouts
Lorsque cette option est définie sur `true`, les deux premières tentatives de toutes les requêtes Azure utilisent des délais d’expiration d’envoi et de réception courts.
Lorsque cette option est définie sur `false`, toutes les tentatives utilisent des délais d’expiration identiques.
## backup\_restore\_batch\_size\_for\_keeper\_multi
Taille maximale du lot pour une requête multiple adressée à \[Zoo]Keeper lors d'une sauvegarde ou d'une restauration
## backup\_restore\_batch\_size\_for\_keeper\_multiread
Taille maximale du lot pour une requête de lecture multiple vers \[Zoo]Keeper lors d’une sauvegarde ou d’une restauration
## backup\_restore\_failure\_after\_host\_disconnected\_for\_seconds
Si, pendant une opération BACKUP ON CLUSTER ou RESTORE ON CLUSTER, un hôte ne recrée pas son nœud éphémère « alive » dans ZooKeeper dans ce délai, l’ensemble de la sauvegarde ou de la restauration est considéré comme échoué.
Cette valeur doit être supérieure à tout délai raisonnable nécessaire à un hôte pour se reconnecter à ZooKeeper après une défaillance.
Zéro signifie illimité.
## backup\_restore\_finish\_timeout\_after\_error\_sec
Durée pendant laquelle l’initiateur doit attendre que les autres hôtes réagissent au nœud « error » et cessent de travailler sur l’opération BACKUP ON CLUSTER ou RESTORE ON CLUSTER en cours.
## backup\_restore\_keeper\_fault\_injection\_probability
Probabilité approximative d’échec d’une requête Keeper pendant la sauvegarde ou la restauration. La valeur valide est comprise dans l’intervalle \[0.0f, 1.0f]
## backup\_restore\_keeper\_fault\_injection\_seed
0 - graine aléatoire ; sinon, la valeur du paramètre
## backup\_restore\_keeper\_max\_retries
Nombre maximal de tentatives pour les opérations \[Zoo]Keeper au cours d'une opération de sauvegarde ou de restauration.
Doit être suffisamment élevé pour que l'opération complète n'échoue pas en raison d'une défaillance temporaire de \[Zoo]Keeper.
## backup\_restore\_keeper\_max\_retries\_while\_handling\_error
Nombre maximal de nouvelles tentatives pour les opérations \[Zoo]Keeper lors du traitement d’une erreur survenue pendant une opération BACKUP ON CLUSTER ou RESTORE ON CLUSTER.
## backup\_restore\_keeper\_max\_retries\_while\_initializing
Nombre maximal de tentatives pour les opérations sur \[Zoo]Keeper lors de l'initialisation d'une opération BACKUP ON CLUSTER ou RESTORE ON CLUSTER.
## backup\_restore\_keeper\_retry\_initial\_backoff\_ms
Délai de backoff initial pour les opérations \[Zoo]Keeper lors de la sauvegarde ou de la restauration
## backup\_restore\_keeper\_retry\_max\_backoff\_ms
Délai maximal de backoff pour les opérations \[Zoo]Keeper lors d'une sauvegarde ou d'une restauration
Valeur par défaut dans Cloud : `60000`.
## backup\_restore\_keeper\_value\_max\_size
Taille maximale des données d’un nœud \[Zoo]Keeper lors de la sauvegarde
## backup\_restore\_s3\_retry\_attempts
Paramètre de Aws::Client::RetryStrategy, Aws::Client gère lui-même les tentatives de nouvelle exécution, 0 signifie aucune tentative. S’applique uniquement à la sauvegarde/restauration.
## backup\_restore\_s3\_retry\_initial\_backoff\_ms
Délai de backoff initial en millisecondes avant la première nouvelle tentative lors d’une sauvegarde ou d’une restauration. Chaque nouvelle tentative suivante augmente ce délai de façon exponentielle, jusqu’au maximum spécifié par `backup_restore_s3_retry_max_backoff_ms`
## backup\_restore\_s3\_retry\_jitter\_factor
Facteur de gigue appliqué au délai de backoff des tentatives dans Aws::Client::RetryStrategy pendant les opérations de sauvegarde et de restauration. Le délai de backoff calculé est multiplié par un facteur aléatoire compris entre \[1.0, 1.0 + jitter], jusqu’à la valeur maximale `backup_restore_s3_retry_max_backoff_ms`. Doit être compris dans l’intervalle \[0.0, 1.0]
## backup\_restore\_s3\_retry\_max\_backoff\_ms
Délai maximal, en millisecondes, entre deux tentatives lors des opérations de sauvegarde et de restauration.
## backup\_slow\_all\_threads\_after\_retryable\_s3\_error
Lorsqu’il est défini sur `true`, tous les threads exécutant des requêtes S3 vers le même endpoint de sauvegarde sont ralentis
dès qu’une seule requête S3 rencontre une erreur S3 réessayable, telle que 'Slow Down'.
Lorsqu’il est défini sur `false`, chaque thread gère le backoff des requêtes S3 indépendamment des autres.
## cache\_warmer\_threads
N’a d’effet que dans ClickHouse Cloud. Nombre de threads en arrière-plan utilisés pour télécharger de manière spéculative de nouvelles parties de données dans le cache du système de fichiers lorsque [cache\_populated\_by\_fetch](/fr/reference/settings/merge-tree-settings#cache_populated_by_fetch) est activé. Zéro pour désactiver.
## calculate\_text\_stack\_trace
Calcule une stack trace textuelle en cas d'exception pendant l'exécution d'une requête. Il s'agit du comportement par défaut. Cela nécessite une résolution de symboles, ce qui peut ralentir les tests de fuzzing lorsqu'un très grand nombre de requêtes erronées sont exécutées. En temps normal, vous ne devriez pas désactiver cette option.
## cancel\_http\_readonly\_queries\_on\_client\_close
Annule les requêtes HTTP en lecture seule (par ex. SELECT) lorsqu’un client ferme la connexion sans attendre de réponse.
Valeur par défaut dans Cloud : `1`.
## cast\_ipv4\_ipv6\_default\_on\_conversion\_error
L'opérateur CAST vers IPv4, l'opérateur CAST vers le type IPv6, ainsi que les fonctions toIPv4 et toIPv6 renverront la valeur par défaut au lieu de lever une exception en cas d'erreur de conversion.
## cast\_keep\_nullable
Active ou désactive la conservation du type de données `Nullable` dans les opérations [CAST](/fr/reference/functions/regular-functions/type-conversion-functions#CAST).
Lorsque ce paramètre est activé et que l'argument de la fonction `CAST` est `Nullable`, le résultat est lui aussi converti en type `Nullable`. Lorsque ce paramètre est désactivé, le résultat a toujours exactement le type de destination.
Valeurs possibles :
* 0 — Le résultat de `CAST` a exactement le type de destination spécifié.
* 1 — Si le type de l'argument est `Nullable`, le résultat de `CAST` est converti en `Nullable(DestinationDataType)`.
**Exemples**
La requête suivante renvoie exactement le type de données de destination :
```sql theme={null}
SET cast_keep_nullable = 0;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
```
Résultat :
```text theme={null}
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Int32 │
└───┴───────────────────────────────────────────────────┘
```
La requête suivante applique la modification `Nullable` au type de données de destination :
```sql theme={null}
SET cast_keep_nullable = 1;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
```
Résultat :
```text theme={null}
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Nullable(Int32) │
└───┴───────────────────────────────────────────────────┘
```
**Voir aussi**
* [CAST](/fr/reference/functions/regular-functions/type-conversion-functions#CAST) fonctio
## cast\_string\_to\_date\_time\_mode
Permet de choisir un parseur pour la représentation textuelle de la date et de l’heure lors du cast depuis String.
Valeurs possibles :
* `'best_effort'` — Active l’analyse étendue.
ClickHouse peut analyser le format de base `YYYY-MM-DD HH:MM:SS` ainsi que tous les formats de date et d’heure [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601). Par exemple, `'2018-06-08T01:02:03.000Z'`.
* `'best_effort_us'` — Similaire à `best_effort` (voir la différence dans [parseDateTimeBestEffortUS](/fr/reference/functions/regular-functions/type-conversion-functions#parseDateTimeBestEffortUS)
* `'basic'` — Utilise le parseur de base.
ClickHouse peut analyser uniquement le format de base `YYYY-MM-DD HH:MM:SS` ou `YYYY-MM-DD`. Par exemple, `2019-08-20 10:18:56` ou `2019-08-20`.
Voir aussi :
* [Type de données DateTime.](/fr/reference/data-types/datetime)
* [Fonctions de manipulation des dates et des heures.](/fr/reference/functions/regular-functions/date-time-functions)
## cast\_string\_to\_dynamic\_use\_inference
Utiliser l'inférence de types lors de la conversion de String en Dynamic
## cast\_string\_to\_variant\_use\_inference
Utiliser l’inférence de types lors de la conversion de String vers Variant.
## check\_named\_collection\_dependencies
Vérifie que DROP NAMED COLLECTION ne rendra pas inutilisables les tables qui en dépendent
## check\_query\_single\_value\_result
Définit le niveau de détail du résultat de la requête [CHECK TABLE](/fr/reference/statements/check-table) pour les moteurs de la famille `MergeTree` .
Valeurs possibles :
* 0 — la requête affiche un statut de vérification pour chaque partie de données d'une table.
* 1 — la requête affiche le statut général de vérification de la table.
## check\_referential\_table\_dependencies
Vérifie qu’une requête DDL (telle que DROP TABLE ou RENAME) ne rompra pas les dépendances de référence
## check\_table\_dependencies
Vérifie qu'une requête DDL (telle que DROP TABLE ou RENAME) n'interrompra pas les dépendances
## checksum\_on\_read
Vérifie les sommes de contrôle à la lecture. Ce paramètre est activé par défaut et doit toujours l’être en production. Ne vous attendez à aucun bénéfice en le désactivant. Il ne doit être utilisé que pour des expériences et des benchmarks. Ce paramètre s’applique uniquement aux tables de la famille MergeTree. Les sommes de contrôle sont toujours vérifiées pour les autres moteurs de table et lors de la réception de données via le réseau.
## cloud\_mode
Mode Cloud
Valeur par défaut pour Cloud : `1`.
## cloud\_mode\_database\_engine
Le moteur de base de données autorisé dans Cloud. 1 - réécrit les DDLs pour utiliser Replicated database, 2 - réécrit les DDLs pour utiliser Shared database
Valeur par défaut dans Cloud : `2`.
## cloud\_mode\_engine
La famille de moteurs autorisée dans Cloud.
* 0 - tout autoriser
* 1 - réécrire les DDLs pour utiliser \*ReplicatedMergeTree
* 2 - réécrire les DDLs pour utiliser SharedMergeTree
* 3 - réécrire les DDLs pour utiliser SharedMergeTree, sauf lorsqu'un disk distant est explicitement spécifié
* 4 - identique à 3, mais utilise en plus Alias au lieu de Distributed (la table Alias pointera vers la table de destination de la table Distributed et utilisera donc la table locale correspondante)
UInt64 pour réduire au minimum la partie publique
Valeur par défaut dans Cloud : `2`.
## cluster\_for\_parallel\_replicas
Cluster du segment où se trouve le serveur actuel
Valeur par défaut Cloud : `default`.
## cluster\_function\_process\_archive\_on\_multiple\_nodes
Si cette option est définie sur `true`, les performances du traitement des archives dans les fonctions de cluster sont améliorées. Elle doit être définie sur `false` pour garantir la compatibilité et éviter les erreurs lors de la mise à niveau vers la version 25.7 ou ultérieure si vous utilisez des fonctions de cluster avec des archives sur des versions antérieures.
## cluster\_table\_function\_buckets\_batch\_size
Définit la taille approximative d’un lot (en octets) utilisé pour le traitement distribué des tâches dans les fonctions de table de cluster avec une granularité de découpage `bucket`. Le système accumule les données jusqu’à ce qu’au moins ce volume soit atteint. La taille réelle peut être légèrement supérieure afin de respecter les limites des données.
## cluster\_table\_function\_split\_granularity
Contrôle la façon dont les données sont découpées en tâches lors de l’exécution d’une CLUSTER TABLE FUNCTION.
Ce paramètre définit la granularité de la distribution du travail dans le cluster :
* `file` — chaque tâche traite un fichier entier.
* `bucket` — des tâches sont créées pour chaque bloc de données interne au sein d’un fichier (par exemple, les groupes de lignes Parquet).
Choisir une granularité plus fine (comme `bucket`) peut améliorer le parallélisme lorsque vous travaillez avec un petit nombre de gros fichiers.
Par exemple, si un fichier Parquet contient plusieurs groupes de lignes, l’activation de la granularité `bucket` permet de traiter chaque groupe indépendamment par différents workers.
## collect\_hash\_table\_stats\_during\_aggregation
Active la collecte des statistiques de la table de hachage afin d’optimiser l’allocatio
## collect\_hash\_table\_stats\_during\_joins
Activer la collecte de statistiques sur la table de hachage afin d’optimiser l’allocation de mémoire
## compatibility
Le paramètre `compatibility` indique à ClickHouse d’utiliser les paramètres par défaut d’une version antérieure de ClickHouse, cette version étant fournie comme valeur du paramètre.
Si certains paramètres ont des valeurs autres que les valeurs par défaut, ces valeurs sont conservées (seuls les paramètres qui n’ont pas été modifiés sont affectés par le paramètre `compatibility`).
Ce paramètre prend comme valeur un numéro de version de ClickHouse sous forme de chaîne, par exemple `22.3` ou `22.8`. Une valeur vide signifie que ce paramètre est désactivé.
Désactivé par défaut.
Dans ClickHouse Cloud, le paramètre de compatibilité par défaut au niveau du service doit être défini par le support ClickHouse Cloud. Veuillez [ouvrir un ticket](https://clickhouse.cloud/support) pour le faire configurer.
Toutefois, le paramètre `compatibility` peut être redéfini au niveau de l’utilisateur, du rôle, du profil, de la query ou de la session à l’aide des mécanismes standard de configuration de ClickHouse, par exemple `SET compatibility = '22.3'` dans une session ou `SETTINGS compatibility = '22.3'` dans une query.
## compatibility\_ignore\_auto\_increment\_in\_create\_table
Ignore le mot-clé AUTO\_INCREMENT dans la déclaration de colonne si la valeur est true, sinon renvoie une erreur. Cela simplifie la migration depuis MySQL
## compatibility\_ignore\_collation\_in\_create\_table
Compatibilité : ignorer la collation lors de CREATE TABLE
## compatibility\_s3\_presigned\_url\_query\_in\_path
Compatibilité : lorsqu’elle est activée, les paramètres de requête d’une URL pré-signée (par ex. X-Amz-\*) sont incorporés à la clé S3 (comportement legacy),
de sorte que « ? » agit comme un caractère générique dans le chemin. Lorsqu’elle est désactivée (par défaut), les paramètres de requête d’une URL pré-signée sont conservés dans la chaîne de requête de l’URL
afin d’éviter d’interpréter « ? » comme un caractère générique.
## compile\_aggregate\_expressions
Active ou désactive la compilation JIT des fonctions d'agrégation en code natif. L'activation de ce paramètre peut améliorer les performances.
Valeurs possibles :
* 0 — L'agrégation s'effectue sans compilation JIT.
* 1 — L'agrégation s'effectue avec compilation JIT.
**Voir aussi**
* [min\_count\_to\_compile\_aggregate\_expression](#min_count_to_compile_aggregate_expression)
## compile\_expressions
Compile une partie des fonctions scalaires et des opérateurs en code natif.
## compile\_sort\_description
Compile la description de tri en code natif.
## connect\_timeout
Délai d’expiration de connexion en l’absence de répliques.
## connect\_timeout\_with\_failover\_ms
Délai d’attente, en millisecondes, pour établir une connexion à un serveur distant avec un moteur de table Distributed, si les sections 'shard' et 'replica' sont utilisées dans la définition du cluster.
En cas d’échec, plusieurs tentatives sont effectuées pour se connecter à différentes répliques.
## connect\_timeout\_with\_failover\_secure\_ms
Délai d’expiration de la connexion lors de la sélection de la première réplique saine (pour les connexions sécurisées).
## connection\_pool\_max\_wait\_ms
Le temps d’attente, en millisecondes, d’une connexion lorsque le pool de connexions est saturé.
Valeurs possibles :
* Entier positif.
* 0 — délai d’expiration infini.
## connections\_with\_failover\_max\_tries
Nombre maximal de tentatives de connexion à chaque réplique pour le moteur de table Distributed.
## convert\_query\_to\_cnf
Lorsqu’il est défini sur `true`, une requête `SELECT` est convertie en forme normale conjonctive (CNF). Dans certains cas, la réécriture d’une requête en CNF peut s’exécuter plus rapidement (consultez cette [issue GitHub](https://github.com/ClickHouse/ClickHouse/issues/11749) pour plus d’explications).
Par exemple, notez que la requête `SELECT` suivante n’est pas modifiée (comportement par défaut) :
```sql theme={null}
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = false;
```
Le résultat est :
```response theme={null}
┌─explain────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ ) AS a │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ SETTINGS convert_query_to_cnf = 0 │
└────────────────────────────────────────────────────────────────┘
```
Définissons `convert_query_to_cnf` à `true` et voyons ce qui change :
```sql theme={null}
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = true;
```
Notez que la clause `WHERE` est réécrite en FNC, mais le jeu de résultats reste identique - la logique booléenne est inchangée :
```response theme={null}
┌─explain───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x <= 15) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x >= 10) OR (x >= 1)) │
│ ) AS a │
│ WHERE ((x >= 10) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x <= 15) OR (x <= 5)) │
│ SETTINGS convert_query_to_cnf = 1 │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Valeurs possibles : true, false
## correlated\_subqueries\_default\_join\_kind
Contrôle le type de JOIN utilisé dans le plan de requête décorrélé. La valeur par défaut est `right`, ce qui signifie que le plan décorrélé contiendra des RIGHT JOIN avec la sous-requête en entrée du côté droit.
Valeurs possibles :
* `left` - Le processus de décorrélation produira des LEFT JOIN et la table d'entrée apparaîtra du côté gauche.
* `right` - Le processus de décorrélation produira des RIGHT JOIN et la table d'entrée apparaîtra du côté droit.
## correlated\_subqueries\_substitute\_equivalent\_expressions
Utilisez des expressions de filtre pour déduire des expressions équivalentes et les substituer plutôt que de créer un CROSS JOIN.
## correlated\_subqueries\_use\_in\_memory\_buffer
Utilise un tampon en mémoire pour l'entrée des sous-requêtes corrélées afin d'éviter leur réévaluation.
## count\_distinct\_implementation
Indique laquelle des fonctions `uniq*` doit être utilisée pour effectuer l'opération [COUNT(DISTINCT ...)](/fr/reference/functions/aggregate-functions/count).
Valeurs possibles :
* [uniq](/fr/reference/functions/aggregate-functions/uniq)
* [uniqCombined](/fr/reference/functions/aggregate-functions/uniqCombined)
* [uniqCombined64](/fr/reference/functions/aggregate-functions/uniqCombined64)
* [uniqHLL12](/fr/reference/functions/aggregate-functions/uniqHLL12)
* [uniqExact](/fr/reference/functions/aggregate-functions/uniqExact)
## count\_distinct\_optimization
Réécrire count distinct en sous-requête avec group by
## count\_matches\_stop\_at\_empty\_match
Interrompt le comptage dès qu'un motif correspond à une chaîne vide dans la fonction `countMatches`.
## create\_if\_not\_exists
Active par défaut `IF NOT EXISTS` pour l’instruction `CREATE`. Si ce paramètre ou `IF NOT EXISTS` est spécifié et qu’une table portant ce nom existe déjà, aucune exception n’est levée.
## create\_index\_ignore\_unique
Ignore le mot-clé UNIQUE dans CREATE UNIQUE INDEX. Prévu pour les tests de compatibilité SQL.
## create\_replicated\_merge\_tree\_fault\_injection\_probability
La probabilité d’une injection de fautes lors de la création d’une table, après la création des métadonnées dans ZooKeeper
## create\_table\_empty\_primary\_key\_by\_default
Autorise la création de tables \*MergeTree avec une clé primaire vide lorsque ORDER BY et PRIMARY KEY ne sont pas spécifiés
## cross\_join\_min\_bytes\_to\_compress
Taille minimale du bloc à compresser dans un CROSS JOIN. Une valeur de zéro signifie que ce seuil est désactivé. Le bloc est compressé dès que l’un des deux seuils (en lignes ou en octets) est atteint.
## cross\_join\_min\_rows\_to\_compress
Nombre minimal de lignes à partir duquel compresser le bloc dans un CROSS JOIN. Une valeur nulle signifie la désactivation de ce seuil. Ce bloc est compressé dès que l'un des deux seuils (en lignes ou en octets) est atteint.
## cross\_to\_inner\_join\_rewrite
Utilisez un INNER JOIN au lieu d'une jointure par virgule/CROSS JOIN s'il existe des expressions de jointure dans la clause WHERE. Valeurs : 0 - aucune réécriture, 1 - appliquer si possible aux jointures par virgule/CROSS JOIN, 2 - forcer la réécriture de toutes les jointures par virgule, CROSS - si possible
## data\_type\_default\_nullable
Permet aux types de données sans modificateurs explicites [NULL or NOT NULL](/fr/reference/statements/create/table#null-or-not-null-modifiers) dans la définition d’une colonne d’être [Nullable](/fr/reference/data-types/nullable).
Valeurs possibles :
* 1 — Les types de données dans les définitions de colonnes sont `Nullable` par défaut.
* 0 — Les types de données dans les définitions de colonnes ne sont pas `Nullable` par défaut.
## database\_atomic\_wait\_for\_drop\_and\_detach\_synchronously
Ajoute un modificateur `SYNC` à toutes les requêtes `DROP` et `DETACH`.
Valeurs possibles :
* 0 — Les requêtes seront exécutées avec un délai.
* 1 — Les requêtes seront exécutées sans délai.
## database\_datalake\_require\_metadata\_access
Indique s’il faut lever une erreur ou non si l’on ne dispose pas des droits nécessaires pour obtenir les métadonnées de la table dans le moteur de base de données DataLakeCatalog.
## database\_replicated\_allow\_explicit\_uuid
0 - Ne pas autoriser la spécification explicite des UUID pour les tables dans les bases de données Replicated. 1 - Autoriser. 2 - Autoriser, mais ignorer l'UUID spécifié et en générer un aléatoire à la place.
## database\_replicated\_allow\_heavy\_create
Autorise les requêtes DDL de longue durée (CREATE AS SELECT et POPULATE) avec le moteur de base de données Replicated. Notez que cela peut bloquer la file d'attente DDL pendant longtemps.
## database\_replicated\_allow\_only\_replicated\_engine
Autorise la création uniquement de tables Replicated dans une base de données utilisant le moteur Replicated
Cloud default value: `1`.
## database\_replicated\_allow\_replicated\_engine\_arguments
0 - Ne permet pas de spécifier explicitement le chemin ZooKeeper ni le nom de réplique pour les tables \*MergeTree dans les bases de données Replicated. 1 - Autoriser. 2 - Autoriser, mais ignorer le chemin spécifié et utiliser le chemin par défaut à la place. 3 - Autoriser et ne pas consigner d’avertissement.
## database\_replicated\_always\_detach\_permanently
Exécute DETACH TABLE en tant que DETACH TABLE PERMANENTLY si le moteur de base de données est Replicated
## database\_replicated\_enforce\_synchronous\_settings
Force l’attente synchrone pour certaines requêtes (voir aussi database\_atomic\_wait\_for\_drop\_and\_detach\_synchronously, mutations\_sync, alter\_sync). Il n’est pas recommandé d’activer ces paramètres.
## database\_replicated\_initial\_query\_timeout\_sec
Définit, en secondes, la durée pendant laquelle la requête DDL initiale doit attendre que la base de données Replicated traite les entrées précédentes de la file d’attente DDL.
Valeurs possibles :
* Entier positif.
* 0 — Illimité.
## database\_shared\_drop\_table\_delay\_seconds
Le délai, en secondes, avant qu'une table supprimée ne soit effectivement retirée d'une base de données Shared. Cela permet de la récupérer pendant ce délai à l'aide de l'instruction `UNDROP TABLE`.
## decimal\_check\_overflow
Contrôle le dépassement de capacité lors des opérations arithmétiques et de comparaison sur les nombres décimaux
## deduplicate\_blocks\_in\_dependent\_materialized\_views
Active ou désactive la vérification de déduplication pour les vues matérialisées qui reçoivent des données de tables Replicated\*.
Valeurs possibles :
0 — Désactivé.
1 — Activé.
Lorsqu’il est activé, ClickHouse effectue la déduplication des blocs dans les vues matérialisées qui dépendent de tables Replicated\*.
Ce paramètre est utile pour garantir que les vues matérialisées ne contiennent pas de doublons lorsque l’opération d’insertion est retentée à la suite d’un échec.
**Voir aussi**
* [Traitement de NULL dans les opérateurs IN](/fr/concepts/features/operations/insert/deduplicating-inserts-on-retries#insert-deduplication-with-materialized-views)
## deduplicate\_insert
Active ou désactive la déduplication des blocs de `INSERT INTO` (pour les tables Replicated\*).
Ce paramètre remplace les paramètres `insert_deduplicate` et `async_insert_deduplicate`.
Ce paramètre a trois valeurs possibles :
* disable — La déduplication est désactivée pour la requête `INSERT INTO`.
* enable — La déduplication est activée pour la requête `INSERT INTO`.
* backward\_compatible\_choice — La déduplication est activée si `insert_deduplicate` ou `async_insert_deduplicate` sont activés pour le type d'insert concerné.
## deduplicate\_insert\_select
Active ou désactive la déduplication de blocs pour `INSERT SELECT` (sur les tables Replicated\*).
Ce paramètre remplace `insert_deduplicate` et `deduplicate_insert` pour les requêtes `INSERT SELECT`.
Ce paramètre a quatre valeurs possibles :
* disable — La déduplication est désactivée pour la requête `INSERT SELECT`.
* force\_enable — La déduplication est activée pour la requête `INSERT SELECT`. Si le résultat du `SELECT` n'est pas stable, une exception est levée.
* enable\_when\_possible — La déduplication est activée si `insert_deduplicate` est activé et si le résultat du `SELECT` est stable, sinon elle est désactivée.
* enable\_even\_for\_bad\_queries - La déduplication est activée si `insert_deduplicate` est activé. Si le résultat du `SELECT` n'est pas stable, un avertissement est journalisé, mais la requête est exécutée avec déduplication. Cette option est conservée pour la rétrocompatibilité. Envisagez plutôt d'utiliser d'autres options, car elle peut entraîner des résultats inattendus.
## default\_materialized\_view\_sql\_security
Permet de définir la valeur par défaut de l’option SQL SECURITY lors de la création d’une vue matérialisée. [En savoir plus sur sécurité SQL](/fr/reference/statements/create/view#sql_security).
La valeur par défaut est `DEFINER`.
## default\_max\_bytes\_in\_join
Taille maximale de la table de droite si une limite est requise mais que `max_bytes_in_join` n'est pas défini.
## default\_normal\_view\_sql\_security
Permet de définir l’option `SQL SECURITY` par défaut lors de la création d’une vue normale. [En savoir plus sur la sécurité SQL](/fr/reference/statements/create/view#sql_security).
La valeur par défaut est `INVOKER`.
## default\_table\_engine
Moteur de table par défaut à utiliser lorsque `ENGINE` n’est pas défini dans une instruction `CREATE`.
Valeurs possibles :
* une chaîne représentant n’importe quel nom de moteur de table valide
Valeur par défaut dans Cloud : `SharedMergeTree`.
**Exemple**
Requête :
```sql theme={null}
SET default_table_engine = 'Log';
SELECT name, value, changed FROM system.settings WHERE name = 'default_table_engine';
```
Résultat :
```response theme={null}
┌─name─────────────────┬─value─┬─changed─┐
│ default_table_engine │ Log │ 1 │
└──────────────────────┴───────┴─────────┘
```
Dans cet exemple, toute nouvelle table qui ne précise pas d’`Engine` utilisera le moteur de table `Log` :
Requête :
```sql theme={null}
CREATE TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TABLE my_table;
```
Résultat :
```response theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
```
## default\_temporary\_table\_engine
Identique à [default\_table\_engine](#default_table_engine), mais pour les tables temporaires.
Dans cet exemple, toute nouvelle table temporaire qui ne précise pas d'`Engine` utilisera le moteur de table `Log` :
Requête :
```sql theme={null}
SET default_temporary_table_engine = 'Log';
CREATE TEMPORARY TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TEMPORARY TABLE my_table;
```
Résultat :
```response theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TEMPORARY TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
```
## default\_view\_definer
Permet de définir l’option `DEFINER` par défaut lors de la création d’une vue. [En savoir plus sur la sécurité SQL](/fr/reference/statements/create/view#sql_security).
La valeur par défaut est `CURRENT_USER`.
## defer\_partition\_pruning\_after\_final
Lorsqu’il est activé (par défaut), l’élagage des partitions est ignoré pour les requêtes `FINAL` sur les tables dont les
colonnes de clé de partition ne font pas partie de la clé de tri. Il s’agit du comportement sans risque pour la correction
introduit dans la version 26.3 : `FINAL` peut avoir besoin de dédupliquer des lignes qui partagent une clé primaire mais se trouvent
dans des partitions différentes, et l’élagage des partitions exclurait alors silencieusement ces lignes du
jeu de données soumis à la déduplication.
Lorsqu’il est désactivé, l’élagage des partitions est appliqué même avec `FINAL`, ce qui rétablit le
comportement antérieur à 26.3. Cela peut être nettement plus rapide pour les requêtes avec des
prédicats `WHERE` sur la colonne de partition, mais cela n’est correct que lorsque des lignes ayant la même clé primaire ne peuvent pas exister
dans des partitions différentes — par exemple, les tables de journaux d’événements dont la colonne de partition est définie au moment de l’insertion
et ne change jamais.
Ce paramètre n’affecte que les tables partitionnées dont les colonnes de clé de partition ne sont pas incluses
dans la clé de tri ; pour les autres tables, l’élagage des partitions est toujours appliqué.
Valeurs possibles :
* 0 — Appliquer l’élagage des partitions avant `FINAL` (comportement antérieur à 26.3, plus rapide mais non sûr dans le cas général).
* 1 — Reporter l’élagage des partitions après `FINAL` (par défaut, sans risque pour la correction).
## delta\_lake\_enable\_engine\_predicate
Active l’élagage interne des données dans delta-kernel.
## delta\_lake\_enable\_expression\_visitor\_logging
Active les logs de niveau Test du visiteur d'expressions de DeltaLake. Ces logs peuvent être trop verbeux, même pour une journalisation de test.
## delta\_lake\_insert\_max\_bytes\_in\_data\_file
Définit la taille maximale, en octets, d’un fichier de données inséré dans Delta Lake.
## delta\_lake\_insert\_max\_rows\_in\_data\_file
Définit le nombre maximal de lignes pour un seul fichier de données inséré dans Delta Lake.
## delta\_lake\_log\_metadata
Active la journalisation des fichiers de métadonnées Delta Lake dans la table système.
## delta\_lake\_reload\_schema\_for\_consistency
S'il est activé, le schéma est rechargé à partir des métadonnées de DeltaLake avant l'exécution de chaque requête afin de garantir
la cohérence entre le schéma utilisé lors de l'analyse de la requête et le schéma utilisé lors de l'exécution.
## delta\_lake\_snapshot\_end\_version
Version de fin de l’instantané Delta Lake à lire. La valeur -1 signifie qu’il faut lire la dernière version (la valeur 0 est une version d’instantané valide).
## delta\_lake\_snapshot\_start\_version
Version initiale de l’instantané Delta Lake à lire. La valeur -1 signifie qu’il faut lire la dernière version (la valeur 0 est une version d’instantané valide).
## delta\_lake\_snapshot\_version
Version de l’instantané Delta Lake à lire. La valeur -1 indique qu’il faut lire la version la plus récente (0 est une version d’instantané valide).
## delta\_lake\_throw\_on\_engine\_predicate\_error
Active la levée d'une exception en cas d'erreur lors de l'analyse du prédicat de scan dans delta-kernel.
## describe\_compact\_output
Si true, inclut uniquement les noms et les types de colonnes dans le résultat de la requête DESCRIBE
## describe\_include\_subcolumns
Permet de décrire les sous-colonnes dans une requête [DESCRIBE](/fr/reference/statements/describe-table). Par exemple, les membres d’un [Tuple](/fr/reference/data-types/tuple) ou les sous-colonnes d’un type de données [Map](/fr/reference/data-types/map#reading-subcolumns-of-map), [Nullable](/fr/reference/data-types/nullable#finding-null) ou [Array](/fr/reference/data-types/array#array-size).
Valeurs possibles :
* 0 — Les sous-colonnes ne sont pas incluses dans les requêtes `DESCRIBE`.
* 1 — Les sous-colonnes sont incluses dans les requêtes `DESCRIBE`.
**Exemple**
Voir un exemple de l’instruction [DESCRIBE](/fr/reference/statements/describe-table).
## describe\_include\_virtual\_columns
Si true, les colonnes virtuelles de la table seront incluses dans le résultat de la requête DESCRIBE
## dialecte
Dialecte utilisé pour analyser la requête
## dictionary\_use\_async\_executor
Exécute un pipeline de lecture de la source du dictionnaire sur plusieurs threads. Pris en charge uniquement par les dictionnaires avec une source CLICKHOUSE locale.
## dictionary\_validate\_primary\_key\_type
Valider le type de clé primaire pour les dictionnaires. Par défaut, le type de l’ID des layouts simples est converti implicitement en UInt64.
## distinct\_overflow\_mode
Définit ce qui se passe lorsque la quantité de données dépasse l'une des limites.
Valeurs possibles :
* `throw` : lever une exception (par défaut).
* `break` : arrêter l'exécution de la requête et renvoyer un résultat partiel, comme si les
données source étaient épuisées.
## distributed\_aggregation\_memory\_efficient
Indique si le mode d'agrégation distribuée économe en mémoire est activé.
## distributed\_background\_insert\_batch
**Aliases** : `distributed_directory_monitor_batch_inserts`
Active ou désactive l’envoi par lots des données insérées.
Lorsque l’envoi par lots est activé, le moteur de table [Distributed](/fr/reference/engines/table-engines/special/distributed) tente d’envoyer plusieurs fichiers de données insérées en une seule opération au lieu de les envoyer séparément. L’envoi par lots améliore les performances du cluster en exploitant plus efficacement les ressources du serveur et du réseau.
Valeurs possibles :
* 1 — Activé.
* 0 — Désactivé.
## distributed\_background\_insert\_max\_sleep\_time\_ms
**Alias** : `distributed_directory_monitor_max_sleep_time_ms`
Intervalle maximal permettant au moteur de table [Distributed](/fr/reference/engines/table-engines/special/distributed) d'envoyer des données. Limite la croissance exponentielle de l'intervalle défini dans le réglage [distributed\_background\_insert\_sleep\_time\_ms](#distributed_background_insert_sleep_time_ms).
Valeurs possibles :
* Un nombre entier positif de millisecondes.
## distributed\_background\_insert\_sleep\_time\_ms
**Alias** : `distributed_directory_monitor_sleep_time_ms`
Intervalle de base du moteur de table [Distributed](/fr/reference/engines/table-engines/special/distributed) pour l’envoi des données. L’intervalle réel augmente de façon exponentielle en cas d’erreur.
Valeurs possibles :
* Un nombre entier positif de millisecondes.
## distributed\_background\_insert\_split\_batch\_on\_failure
**Alias** : `distributed_directory_monitor_split_batch_on_failure`
Active ou désactive le fractionnement des batches en cas d’échec.
Il peut arriver que l’envoi d’un batch donné vers le shard distant échoue à cause d’un pipeline en aval complexe (par ex. `MATERIALIZED VIEW` avec `GROUP BY`), en raison de `Memory limit exceeded` ou d’erreurs similaires. Dans ce cas, réessayer ne servira à rien (et bloquera les envois distribués pour la table), tandis que l’envoi des fichiers de ce batch un par un peut permettre à `INSERT` de réussir.
Ainsi, définir ce paramètre sur `1` désactive le batching pour ces batches (c.-à-d. désactive temporairement `distributed_background_insert_batch` pour les batches en échec).
Valeurs possibles :
* 1 — Activé.
* 0 — Désactivé.
Ce paramètre affecte également les batches corrompus (qui peuvent apparaître à la suite d’un arrêt anormal du serveur (machine) et de l’absence de `fsync_after_insert`/`fsync_directories` pour le moteur de table [Distributed](/fr/reference/engines/table-engines/special/distributed)).
Vous ne devez pas vous reposer sur le fractionnement automatique des batches, car cela peut nuire aux performances.
## distributed\_background\_insert\_timeout
**Alias** : `insert_distributed_timeout`
Délai d’expiration de la requête d’insert dans Distributed. Ce paramètre est utilisé uniquement lorsque insert\_distributed\_sync est activé. Une valeur de 0 signifie qu’il n’y a pas de délai d’expiration.
## distributed\_cache\_alignment
N'a d'effet que dans ClickHouse Cloud. Paramètre réservé aux tests, ne le modifiez pas
## distributed\_cache\_bypass\_connection\_pool
N'a d'effet que dans ClickHouse Cloud. Permet de contourner le pool de connexions du cache distribué
## distributed\_cache\_connect\_backoff\_max\_ms
N'a d'effet que dans ClickHouse Cloud. Délai de backoff maximal, en millisecondes, pour la création de connexions au cache distribué.
## distributed\_cache\_connect\_backoff\_min\_ms
N'a d'effet que dans ClickHouse Cloud. Délai minimal de backoff, en millisecondes, pour la création de connexions au cache distribué.
## distributed\_cache\_connect\_max\_tries
N'a d'effet que dans ClickHouse Cloud. Nombre de tentatives de connexion au cache distribué en cas d'échec
## distributed\_cache\_connect\_timeout\_ms
N'a d'effet que dans ClickHouse Cloud. Délai d'expiration de connexion lors de l'établissement d'une connexion au serveur cache distribué.
## distributed\_cache\_credentials\_refresh\_period\_seconds
N'a d'effet que dans ClickHouse Cloud. Période de rafraîchissement des identifiants d’authentification.
## distributed\_cache\_data\_packet\_ack\_window
N’a d’effet que dans ClickHouse Cloud. Fenêtre d’envoi des ACK pour la séquence DataPacket au sein d’une même requête de lecture du cache distribué
## distributed\_cache\_discard\_connection\_if\_unread\_data
N’a d’effet que dans ClickHouse Cloud. Interrompt la connexion si certaines données n’ont pas été lues.
## distributed\_cache\_fetch\_metrics\_only\_from\_current\_az
Ne prend effet que dans ClickHouse Cloud. Récupère les métriques uniquement depuis la zone de disponibilité actuelle dans system.distributed\_cache\_metrics, system.distributed\_cache\_events
## distributed\_cache\_file\_cache\_name
N’a d’effet que dans ClickHouse Cloud. Paramètre utilisé uniquement pour les tests CI : nom du cache du système de fichiers à utiliser pour le cache distribué.
## distributed\_cache\_log\_mode
N’a d’effet que dans ClickHouse Cloud. Mode d’écriture dans system.distributed\_cache\_log
## distributed\_cache\_max\_unacked\_inflight\_packets
N'a d'effet que dans ClickHouse Cloud. Nombre maximal de paquets en transit non acquittés dans une même requête de lecture du cache distribué
## distributed\_cache\_min\_bytes\_for\_seek
N'a d'effet que dans ClickHouse Cloud. Nombre minimal d'octets à partir duquel effectuer un seek dans le cache distribué.
## distributed\_cache\_pool\_behaviour\_on\_limit
N’a d’effet que dans ClickHouse Cloud. Définit le comportement de la connexion du cache distribué lorsque la limite du pool est atteinte
## distributed\_cache\_prefer\_bigger\_buffer\_size
N’a d’effet que dans ClickHouse Cloud. Identique à filesystem\_cache\_prefer\_bigger\_buffer\_size, mais pour le cache distribué.
## distributed\_cache\_read\_only\_from\_current\_az
N'a d'effet que dans ClickHouse Cloud. Permet de lire uniquement depuis la zone de disponibilité actuelle. Si ce paramètre est désactivé, la lecture s'effectue depuis tous les serveurs de cache de toutes les zones de disponibilité.
## distributed\_cache\_read\_request\_max\_tries
N'a d'effet que dans ClickHouse Cloud. Nombre de tentatives pour effectuer une requête de lecture au cache distribué en cas d'échec
## distributed\_cache\_receive\_response\_wait\_milliseconds
N'a d'effet que dans ClickHouse Cloud. Délai d'attente, en millisecondes, pour recevoir les données d'une requête depuis le cache distribué
## distributed\_cache\_receive\_timeout\_milliseconds
N'a d'effet que dans ClickHouse Cloud. Délai d'attente, en millisecondes, pour recevoir tout type de réponse du cache distribué
Valeur par défaut dans Cloud : `20000`.
## distributed\_cache\_receive\_timeout\_ms
N’a d’effet que dans ClickHouse Cloud. Délai d’attente, en millisecondes, pour recevoir des données du serveur cache distribué. Si aucun octet n’est reçu pendant cet intervalle, une exception est levée.
## distributed\_cache\_send\_timeout\_ms
N'a d'effet que dans ClickHouse Cloud. Délai d'expiration, en millisecondes, pour l'envoi de données au serveur de cache distribué. Si un client doit envoyer des données mais ne parvient pas à transmettre le moindre octet dans ce délai, une exception est levée.
## distributed\_cache\_tcp\_keep\_alive\_timeout\_ms
N'a d'effet que dans ClickHouse Cloud. Durée, en millisecondes, pendant laquelle la connexion au serveur cache distribué doit rester inactive avant que TCP ne commence à envoyer des sondes de keepalive.
## distributed\_cache\_throw\_on\_error
N'a d'effet que dans ClickHouse Cloud. Relance l'exception survenue lors de la communication avec le distributed cache ou l'exception renvoyée par le distributed cache. Sinon, revient à ignorer le distributed cache en cas d'erreur
## distributed\_cache\_use\_clients\_cache\_for\_read
N’a d’effet que dans ClickHouse Cloud. Utilise le cache des clients pour les requêtes de lecture.
## distributed\_cache\_use\_clients\_cache\_for\_write
N'a d'effet que dans ClickHouse Cloud. Utilise le cache des clients pour les requêtes d'écriture.
## distributed\_cache\_wait\_connection\_from\_pool\_milliseconds
N'a d'effet que dans ClickHouse Cloud. Temps d'attente, en millisecondes, pour obtenir une connexion depuis le pool de connexions si distributed\_cache\_pool\_behaviour\_on\_limit est défini sur wait
## distributed\_cache\_write\_request\_max\_tries
N’a d’effet que dans ClickHouse Cloud. Nombre de tentatives pour effectuer une requête d’écriture du distributed cache en cas d’échec
## distributed\_connections\_pool\_size
Le nombre maximal de connexions simultanées aux serveurs distants pour le traitement distribué de toutes les requêtes sur une même table Distributed. Nous recommandons de définir une valeur au moins égale au nombre de serveurs du cluster.
## distributed\_ddl\_entry\_format\_version
Version de compatibilité des requêtes DDL distribuées (ON CLUSTER)
Valeur par défaut dans Cloud : `6`.
## distributed\_ddl\_output\_mode
Définit le format du jeu de résultats d'une requête DDL distribuée.
Valeurs possibles :
* `throw` — Renvoie un jeu de résultats avec le statut d'exécution de la requête pour tous les hôtes où la requête est terminée. Si la requête a échoué sur certains hôtes, la première exception est relancée. Si la requête n'est pas encore terminée sur certains hôtes et que [distributed\_ddl\_task\_timeout](#distributed_ddl_task_timeout) est dépassé, l'exception `TIMEOUT_EXCEEDED` est levée.
* `none` — Similaire à `throw`, mais la requête DDL distribuée ne renvoie aucun jeu de résultats.
* `null_status_on_timeout` — Renvoie `NULL` comme statut d'exécution dans certaines lignes du jeu de résultats au lieu de lever `TIMEOUT_EXCEEDED` si la requête n'est pas terminée sur les hôtes correspondants.
* `never_throw` — Ne lève pas `TIMEOUT_EXCEEDED` et ne relance pas les exceptions si la requête a échoué sur certains hôtes.
* `none_only_active` - similaire à `none`, mais n'attend pas les répliques inactives de la base de données `Replicated`. Remarque : avec ce mode, il est impossible de savoir que la requête n'a pas été exécutée sur une réplique et qu'elle sera exécutée en arrière-plan.
* `null_status_on_timeout_only_active` — similaire à `null_status_on_timeout`, mais n'attend pas les répliques inactives de la base de données `Replicated`
* `throw_only_active` — similaire à `throw`, mais n'attend pas les répliques inactives de la base de données `Replicated`
Valeur par défaut dans Cloud : `none_only_active`.
## distributed\_ddl\_task\_timeout
Définit le délai d’attente des réponses aux requêtes DDL de tous les hôtes du cluster. Si une requête DDL n’a pas été exécutée sur tous les hôtes, la réponse contiendra une erreur de délai d’attente et la requête sera exécutée en mode asynchrone. Une valeur négative signifie un délai illimité.
Valeurs possibles :
* Entier positif.
* 0 — Mode asynchrone.
* Entier négatif — délai d’attente illimité.
## distributed\_foreground\_insert
**Alias** : `insert_distributed_sync`
Active ou désactive l’insertion synchrone de données dans une table [Distributed](/fr/reference/engines/table-engines/special/distributed).
Par défaut, lors de l’insertion de données dans une table `Distributed`, le serveur ClickHouse envoie les données aux nœuds du cluster en arrière-plan. Lorsque `distributed_foreground_insert=1`, les données sont traitées de manière synchrone, et l’opération `INSERT` n’aboutit qu’après l’enregistrement de toutes les données sur tous les shards (au moins une réplique pour chaque shard si `internal_replication` vaut true).
Valeurs possibles :
* `0` — Les données sont insérées en arrière-plan.
* `1` — Les données sont insérées en mode synchrone.
Valeur par défaut dans Cloud : `1`.
**Voir aussi**
* [Moteur de table Distributed](/fr/reference/engines/table-engines/special/distributed)
* [Gestion des tables distribuées](/fr/reference/statements/system#managing-distributed-tables)
## distributed\_group\_by\_no\_merge
Ne fusionne pas les états d’agrégation de différents serveurs lors du traitement distribué des requêtes ; vous pouvez l’utiliser lorsqu’il est certain que les clés sont différentes sur les différents shards
Valeurs possibles :
* `0` — Désactivé (le traitement final de la requête est effectué sur le nœud initiateur).
* `1` - Ne fusionne pas les états d’agrégation de différents serveurs lors du traitement distribué des requêtes (la requête est entièrement traitée sur le shard, l’initiateur se contente de relayer les données) ; peut être utilisé lorsqu’il est certain que les clés sont différentes sur les différents shards.
* `2` - Identique à `1`, mais applique `ORDER BY` et `LIMIT` sur l’initiateur (ce qui n’est pas possible lorsque la requête est entièrement traitée sur le nœud distant, comme avec `distributed_group_by_no_merge=1`) ; peut être utilisé pour les requêtes avec `ORDER BY` et/ou `LIMIT`.
**Exemple**
```sql theme={null}
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 1
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
│ 0 │
└───────┘
```
```sql theme={null}
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 2
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
└───────┘
```
## distributed\_index\_analysis
L’analyse d’index distribuée sera répartie entre les répliques.
Particulièrement utile avec un stockage partagé et de très grands volumes de données dans le cluster.
S’appuie sur les répliques de cluster\_for\_parallel\_replicas.
**Voir aussi**
* [distributed\_index\_analysis\_for\_non\_shared\_merge\_tree](#distributed_index_analysis_for_non_shared_merge_tree)
* [distributed\_index\_analysis\_min\_parts\_to\_activate](/fr/reference/settings/merge-tree-settings#distributed_index_analysis_min_parts_to_activate)
* [distributed\_index\_analysis\_min\_indexes\_bytes\_to\_activate](/fr/reference/settings/merge-tree-settings#distributed_index_analysis_min_indexes_bytes_to_activate)
## distributed\_index\_analysis\_for\_non\_shared\_merge\_tree
Activer l’analyse d’index distribuée même pour les moteurs autres que SharedMergeTree (moteur disponible uniquement dans Cloud).
## distributed\_index\_analysis\_only\_on\_coordinator
Si ce paramètre est activé, l’analyse d’index distribuée s’effectue uniquement sur le coordinateur.
Cela évite de générer des requêtes en O(N^2) lorsque le prédicat contient des sous-requêtes (par ex. `IN (SELECT ...)`),
car sinon chaque réplique suiveuse déclencherait indépendamment sa propre analyse d’index distribuée,
mais l’analyse d’index distribuée devient alors moins efficace si les sous-requêtes utilisent de grandes tables.
## distributed\_insert\_skip\_read\_only\_replicas
Permet d’ignorer les répliques en lecture seule pour les requêtes INSERT dans Distributed.
Valeurs possibles :
* 0 — INSERT se comporte comme d’habitude ; si l’opération cible une réplique en lecture seule, elle échoue
* 1 — L’initiateur ignorera les répliques en lecture seule avant d’envoyer les données aux shards.
## distributed\_plan\_default\_reader\_bucket\_count
Nombre par défaut de tâches pour la lecture parallèle dans une requête distribuée. Les tâches sont réparties entre les répliques.
## distributed\_plan\_default\_shuffle\_join\_bucket\_count
Nombre de buckets par défaut du distributed shuffle-hash-join.
## distributed\_plan\_execute\_locally
Exécute localement toutes les tâches d’un plan de requête distribuée. Utile pour les tests et le débogage.
## distributed\_plan\_force\_exchange\_kind
Force le type spécifié d’opérateurs Exchange entre les étapes d’une requête distribuée.
Valeurs possibles :
* '' - ne force aucun type d’opérateurs Exchange, laisse l’optimiseur choisir,
* 'Persisted' - utilise des fichiers temporaires dans le stockage d’objets,
* 'Streaming' - transmet les données d’échange sur le réseau.
## distributed\_plan\_force\_shuffle\_aggregation
Utilise la stratégie d’agrégation Shuffle au lieu de PartialAggregation + Merge dans le plan de requête distribuée.
## distributed\_plan\_max\_rows\_to\_broadcast
Nombre maximal de lignes pour utiliser un broadcast join au lieu d’un shuffle join dans le plan de requête distribué.
## distributed\_plan\_optimize\_exchanges
Supprime les échanges inutiles dans le plan de requête distribuée. Désactivez ce paramètre pour le débogage.
## distributed\_plan\_prefer\_replicas\_over\_workers
Sérialise le plan de requête distribué pour l’exécuter sur les répliques.
## distributed\_product\_mode
Modifie le comportement des [sous-requêtes distribuées](/fr/reference/statements/in).
ClickHouse applique ce paramètre lorsque la requête contient le produit de tables distribuées, c’est-à-dire lorsqu’une requête sur une table distribuée contient une sous-requête non-GLOBAL sur une table distribuée.
Restrictions :
* S’applique uniquement aux sous-requêtes IN et JOIN.
* Uniquement si la section FROM utilise une table distribuée contenant plus d’un shard.
* Uniquement si la sous-requête porte sur une table distribuée contenant plus d’un shard.
* N’est pas utilisé pour une fonction de table [remote](/fr/reference/functions/table-functions/remote).
Valeurs possibles :
* `deny` — Valeur par défaut. Interdit l’utilisation de ces types de sous-requêtes (renvoie l’exception "Double-distributed in/JOIN subqueries is denied").
* `local` — Remplace la base de données et la table dans la sous-requête par leurs équivalents locaux pour le serveur de destination (shard), en conservant le `IN`/`JOIN` normal.
* `global` — Remplace la requête `IN`/`JOIN` par `GLOBAL IN`/`GLOBAL JOIN`.
* `allow` — Autorise l’utilisation de ces types de sous-requêtes.
## distributed\_push\_down\_limit
Active ou désactive l’application de [LIMIT](#limit) séparément sur chaque segment.
Cela permet d’éviter :
* l’envoi de lignes supplémentaires sur le réseau ;
* le traitement, sur l’initiateur, des lignes au-delà de la limite.
À partir de la version 21.9, il n’est plus possible d’obtenir de résultats inexacts, car `distributed_push_down_limit` ne modifie l’exécution de la requête que si au moins une des conditions suivantes est remplie :
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge) > 0.
* La requête **n’a pas** de `GROUP BY`/`DISTINCT`/`LIMIT BY`, mais comporte `ORDER BY`/`LIMIT`.
* La requête **comporte** `GROUP BY`/`DISTINCT`/`LIMIT BY` avec `ORDER BY`/`LIMIT` et :
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards) est activé.
* [optimize\_distributed\_group\_by\_sharding\_key](#optimize_distributed_group_by_sharding_key) est activé.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Voir aussi :
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge)
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards)
* [optimize\_distributed\_group\_by\_sharding\_key](#optimize_distributed_group_by_sharding_key)
## distributed\_replica\_error\_cap
* Type : entier non signé
* Valeur par défaut : 1000
Le nombre d'erreurs de chaque réplique est limité à cette valeur, afin d'éviter qu'une même réplique n'en accumule trop.
Voir aussi :
* [load\_balancing](#load_balancing-round_robin)
* [Moteur de table Distributed](/fr/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_half\_life](#distributed_replica_error_half_life)
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
## distributed\_replica\_error\_half\_life
* Type : secondes
* Valeur par défaut : 60 secondes
Contrôle la rapidité avec laquelle les erreurs des tables distribuées sont ramenées à zéro. Si une réplique est indisponible pendant un certain temps, accumule 5 erreurs et que distributed\_replica\_error\_half\_life est défini à 1 seconde, alors la réplique est de nouveau considérée comme normale 3 secondes après la dernière erreur.
Voir aussi :
* [load\_balancing](#load_balancing-round_robin)
* [Moteur de table Distributed](/fr/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_cap](#distributed_replica_error_cap)
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
## distributed\_replica\_max\_ignored\_errors
* Type : entier non signé
* Valeur par défaut : 0
Le nombre d’erreurs qui seront ignorées lors de la sélection des répliques (selon l’algorithme `load_balancing`).
Voir aussi :
* [load\_balancing](#load_balancing-round_robin)
* [Moteur de table Distributed](/fr/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_cap](#distributed_replica_error_cap)
* [distributed\_replica\_error\_half\_life](#distributed_replica_error_half_life)
## do\_not\_merge\_across\_partitions\_select\_final
Améliore les requêtes FINAL en évitant les fusions entre partitions différentes.
Lorsqu’il est activé, lors des requêtes SELECT FINAL, les parts provenant de partitions différentes ne sont pas fusionnées entre elles. À la place, la fusion s’effectue uniquement au sein de chaque partition. Cela peut améliorer considérablement les performances des requêtes sur les tables partitionnées.
## dynamic\_disk\_allow\_from\_env
Autorise l'utilisation des substitutions `from_env` dans la configuration dynamique des disques (c'est-à-dire dans les arguments de la fonction `disk()`).
Désactivé par défaut afin d'empêcher les utilisateurs de lire des variables d'environnement arbitraires lors de la définition du stockage d'une table.
## dynamic\_disk\_allow\_from\_zk
Autorise l'utilisation des substitutions `from_zk` dans la configuration dynamique des disques (c'est-à-dire dans les arguments de la fonction `disk()`).
Désactivé par défaut.
## dynamic\_disk\_allow\_include
Autorise l’utilisation de `include` dans la configuration dynamique des disques (c’est-à-dire dans les arguments de la fonction `disk()`).
Désactivé par défaut.
## dynamic\_throw\_on\_type\_mismatch
Lorsqu’une fonction est appliquée à une colonne [Dynamic](/fr/reference/data-types/dynamic) à l’aide de l’implémentation par défaut,
ce paramètre contrôle ce qui se passe pour les lignes dont le type réel est incompatible avec la fonction :
* `true` (par défaut) — lever une exception.
* `false` — renvoyer `NULL` pour ces lignes à la place.
## empty\_result\_for\_aggregation\_by\_constant\_keys\_on\_empty\_set
Renvoie un résultat vide en cas d’agrégation par clés constantes sur un ensemble vide.
## empty\_result\_for\_aggregation\_by\_empty\_set
Renvoie un résultat vide lors d’une agrégation sans clés sur un ensemble vide.
## enable\_adaptive\_memory\_spill\_scheduler
Permet au processeur de déverser de manière adaptative les données en mémoire vers le stockage externe. Seul grace join est actuellement pris en charge.
## enable\_add\_distinct\_to\_in\_subqueries
Active `DISTINCT` dans les sous-requêtes `IN`. Ce paramètre implique un compromis : son activation peut réduire considérablement la taille des tables temporaires transférées pour les sous-requêtes distribuées avec `IN` et accélérer significativement le transfert de données entre les shards, en garantissant que seules des valeurs uniques sont envoyées.
Cependant, l’activation de ce paramètre ajoute un surcoût de fusion sur chaque nœud, car la déduplication (`DISTINCT`) doit être effectuée. Utilisez ce paramètre lorsque le transfert réseau constitue un goulot d’étranglement et que ce surcoût de fusion est acceptable.
## enable\_automatic\_decision\_for\_merging\_across\_partitions\_for\_final
Si ce paramètre est activé, ClickHouse active automatiquement cette optimisation lorsque l'expression de la clé de partition est déterministe et que toutes les colonnes utilisées dans cette expression sont incluses dans la clé primaire.
Cette déduction automatique garantit que les lignes ayant les mêmes valeurs de clé primaire appartiennent toujours à la même partition, ce qui permet d'éviter en toute sécurité les fusions entre partitions.
## enable\_blob\_storage\_log
Enregistrer des informations sur les opérations de stockage blob dans la table system.blob\_storage\_log
## enable\_blob\_storage\_log\_for\_read\_operations
Enregistre des informations sur les opérations de lecture du stockage de blobs dans la table system.blob\_storage\_log.
Nécessite également que `enable_blob_storage_log` soit activé.
## enable\_early\_constant\_folding
Active l’optimisation des requêtes consistant à analyser les résultats des fonctions et des sous-requêtes, puis à réécrire la requête si des constantes y sont présentes
## enable\_extended\_results\_for\_datetime\_functions
Active ou désactive le renvoi de résultats de type `Date32` avec une plage étendue (par rapport au type `Date`)
ou de type `DateTime64` avec une plage étendue (par rapport au type `DateTime`).
Valeurs possibles :
* `0` — Les fonctions renvoient `Date` ou `DateTime` pour tous les types d’arguments.
* `1` — Les fonctions renvoient `Date32` ou `DateTime64` pour les arguments de type `Date32` ou `DateTime64`, et `Date` ou `DateTime` dans les autres cas.
Le tableau ci-dessous présente le comportement de ce paramètre pour différentes fonctions de date et d’heure.
| Function | `enable_extended_results_for_datetime_functions = 0` | `enable_extended_results_for_datetime_functions = 1` |
| ------------------------- | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `toStartOfYear` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toStartOfISOYear` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toStartOfQuarter` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toStartOfMonth` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toStartOfWeek` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toLastDayOfWeek` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toLastDayOfMonth` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toMonday` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toStartOfDay` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de l’intervalle 1970-2149* | Renvoie `DateTime` pour une valeur d’entrée `Date`/`DateTime`
Renvoie `DateTime64` pour une valeur d’entrée `Date32`/`DateTime64` |
| `toStartOfHour` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs en dehors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée `Date32`/`DateTime64` |
| `toStartOfFifteenMinutes` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour les entrées `Date`/`DateTime`
Renvoie `DateTime64` pour les entrées `Date32`/`DateTime64` |
| `toStartOfTenMinutes` | Renvoie `DateTime`
*Remarque : résultats incorrects pour des valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée de type `Date32`/`DateTime64` |
| `toStartOfFiveMinutes` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour les entrées `Date`/`DateTime`
Renvoie `DateTime64` pour les entrées `Date32`/`DateTime64` |
| `toStartOfMinute` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour les entrées `Date`/`DateTime`
Renvoie `DateTime64` pour les entrées `Date32`/`DateTime64` |
| `timeSlot` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour les entrées `Date`/`DateTime`
Renvoie `DateTime64` pour les entrées `Date32`/`DateTime64` |
## enable\_filesystem\_cache
Utilise le cache pour le système de fichiers distant. Ce paramètre n’active ni ne désactive le cache des disques (cela doit être configuré via la config du disque), mais permet de contourner le cache pour certaines requêtes, si nécessaire
## enable\_filesystem\_cache\_log
Permet d’enregistrer le journal du cache du système de fichiers pour chaque requête
## enable\_filesystem\_cache\_on\_write\_operations
Active ou désactive le cache `write-through`. Si cette option est définie sur `false`, le cache `write-through` est désactivé pour les opérations d’écriture. Si elle est définie sur `true`, le cache `write-through` est activé tant que `cache_on_write_operations` est activé dans la section de configuration du disque de cache de la configuration du serveur.
Consultez [« Utilisation du cache local »](/fr/concepts/features/configuration/server-config/storing-data#using-local-cache) pour plus de détails.
Valeur par défaut dans Cloud : `1`.
## enable\_filesystem\_read\_prefetches\_log
Consigne dans system.filesystem prefetch\_log les opérations de prefetch pendant la requête. À utiliser uniquement pour les tests ou le débogage ; il n'est pas recommandé de l'activer par défaut.
## enable\_full\_text\_index
**Alias** : `allow_experimental_full_text_index`
Si ce paramètre est défini sur true, l’utilisation de l’index textuel est autorisée.
## enable\_global\_with\_statement
Propage les instructions WITH vers les requêtes UNION et toutes les sous-requêtes
## enable\_hdfs\_pread
Active ou désactive `pread` pour les fichiers HDFS. Par défaut, `hdfsPread` est utilisé. Si cette option est désactivée, `hdfsRead` et `hdfsSeek` sont utilisés pour lire les fichiers HDFS.
## enable\_http\_compression
Active ou désactive la compression des données dans la réponse à une requête HTTP.
Pour plus d’informations, consultez la [description de l’interface HTTP](/fr/concepts/features/interfaces/http).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## enable\_identifier\_resolve\_cache
Active le cache de résolution des identifiants dans l’analyseur de requêtes. Le cache mutualise les nœuds d’alias résolus afin d’éviter une explosion de l’AST lorsque le même alias est utilisé plusieurs fois. Définissez la valeur sur false pour désactiver la mise en cache en cas de suspicion de résultats incorrects.
## enable\_job\_stack\_trace
Affiche la trace de pile du créateur d'un job lorsque celui-ci se solde par une exception. Désactivé par défaut pour éviter une surcharge de performances.
## enable\_join\_fixed\_hash\_table\_conversion
Activer la conversion de la table de hachage en tableau plat pour les jointures lorsque la clé est un seul entier avec une plage de valeurs réduite.
## enable\_join\_runtime\_filters
Filtre la partie gauche à l’aide de l’ensemble des clés de jointure JOIN collectées sur la partie droite à l’exécution.
## enable\_join\_transitive\_predicates
Infère des prédicats transitifs d’équi-jointure à partir des conditions de jointure existantes.
Par exemple, étant donné `A.x = B.x` et `B.x = C.x`, un prédicat synthétique `A.x = C.x`
est ajouté afin que l’optimiseur de l’ordre des jointures puisse prendre en compte des plans directs `(A JOIN C)`.
## enable\_lazy\_columns\_replication
Active la réplication différée des colonnes dans JOIN et ARRAY JOIN, ce qui permet d’éviter de copier inutilement les mêmes lignes plusieurs fois en mémoire.
## enable\_lightweight\_delete
**Alias** : `allow_experimental_lightweight_delete`
Active les mutations DELETE légères pour les tables MergeTree.
## enable\_lightweight\_update
**Aliases** : `allow_experimental_lightweight_update`
Permet d'utiliser les mises à jour légères.
## enable\_materialized\_cte
Active les expressions de table communes matérialisées ; elles sont prioritaires sur enable\_global\_with\_statement
## enable\_memory\_bound\_merging\_of\_aggregation\_results
Active la stratégie de fusion sous contrainte mémoire pour l’agrégation.
## enable\_multiple\_prewhere\_read\_steps
Déplace davantage de conditions de WHERE vers PREWHERE, et effectue les lectures depuis le disque ainsi que le filtrage en plusieurs étapes s’il y a plusieurs conditions combinées avec AND
## enable\_named\_columns\_in\_function\_tuple
Générer des tuples nommés dans la fonction tuple() lorsque tous les noms sont uniques et peuvent être traités comme des identifiants non quotés.
## enable\_optimize\_predicate\_expression
Active le pushdown des prédicats dans les requêtes `SELECT`.
Le pushdown des prédicats peut réduire considérablement le trafic réseau des requêtes distribuées.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Utilisation
Examinez les requêtes suivantes :
1. `SELECT count() FROM test_table WHERE date = '2018-10-10'`
2. `SELECT count() FROM (SELECT * FROM test_table) WHERE date = '2018-10-10'`
Si `enable_optimize_predicate_expression = 1`, le temps d’exécution de ces requêtes est identique, car ClickHouse applique `WHERE` à la sous-requête pendant son traitement.
Si `enable_optimize_predicate_expression = 0`, le temps d’exécution de la deuxième requête est beaucoup plus long, car la clause `WHERE` n’est appliquée à l’ensemble des données qu’une fois la sous-requête terminée.
## enable\_optimize\_predicate\_expression\_to\_final\_subquery
Permet de pousser le prédicat vers la sous-requête FINAL.
## enable\_order\_by\_all
Active ou désactive le tri à l’aide de la syntaxe `ORDER BY ALL`. Voir [ORDER BY](/fr/reference/statements/select/order-by).
Valeurs possibles :
* 0 — Désactive ORDER BY ALL.
* 1 — Active ORDER BY ALL.
**Exemple**
Requête :
```sql theme={null}
CREATE TABLE TAB(C1 Int, C2 Int, ALL Int) ENGINE=Memory();
INSERT INTO TAB VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM TAB ORDER BY ALL; -- returns an error that ALL is ambiguous
SELECT * FROM TAB ORDER BY ALL SETTINGS enable_order_by_all = 0;
```
Résultat :
```text theme={null}
┌─C1─┬─C2─┬─ALL─┐
│ 20 │ 20 │ 10 │
│ 30 │ 10 │ 20 │
│ 10 │ 20 │ 30 │
└────┴────┴─────┘
```
## enable\_parallel\_blocks\_marshalling
Affecte uniquement les requêtes distribuées. Si ce paramètre est activé, les blocs seront (dé)sérialisés et (dé)compressés dans les threads du pipeline (c.-à-d. avec un parallélisme supérieur à celui utilisé par défaut) avant/après leur envoi à l’initiateur.
## enable\_parsing\_to\_custom\_serialization
Si la valeur est true, les données peuvent être interprétées directement dans des colonnes avec une sérialisation personnalisée (par ex. Sparse), selon les indications de sérialisation fournies par la table.
## enable\_positional\_arguments
Active ou désactive la prise en charge des arguments positionnels pour les clauses [GROUP BY](/fr/reference/statements/select/group-by), [LIMIT BY](/fr/reference/statements/select/limit-by) et [ORDER BY](/fr/reference/statements/select/order-by).
Valeurs possibles :
* 0 — Les arguments positionnels ne sont pas pris en charge.
* 1 — Les arguments positionnels sont pris en charge : les numéros de colonnes peuvent être utilisés à la place des noms de colonnes.
**Exemple**
Requête :
```sql theme={null}
CREATE TABLE positional_arguments(one Int, two Int, three Int) ENGINE=Memory();
INSERT INTO positional_arguments VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM positional_arguments ORDER BY 2,3;
```
Résultat :
```text theme={null}
┌─one─┬─two─┬─three─┐
│ 30 │ 10 │ 20 │
│ 20 │ 20 │ 10 │
│ 10 │ 20 │ 30 │
└─────┴─────┴───────┘
```
## enable\_positional\_arguments\_for\_projections
Active ou désactive la prise en charge des arguments positionnels dans les définitions de PROJECTION. Voir aussi le paramètre [enable\_positional\_arguments](#enable_positional_arguments).
Il s'agit d'un paramètre de niveau expert, et vous ne devriez pas le modifier si vous débutez avec ClickHouse.
Valeurs possibles :
* 0 — Les arguments positionnels ne sont pas pris en charge.
* 1 — Les arguments positionnels sont pris en charge : les numéros de colonnes peuvent être utilisés à la place des noms de colonnes.
## enable\_producing\_buckets\_out\_of\_order\_in\_aggregation
Autorise une agrégation économe en mémoire (voir `distributed_aggregation_memory_efficient`) à produire des buckets dans le désordre.
Cela peut améliorer les performances lorsque la taille des buckets d'agrégation est déséquilibrée, en permettant à une réplique d'envoyer à l'initiateur des buckets avec des ID plus élevés pendant qu'elle traite encore certains buckets volumineux avec des ID plus faibles.
L'inconvénient est une utilisation de la mémoire potentiellement plus élevée.
## enable\_reads\_from\_query\_cache
Si cette option est activée, les résultats des requêtes `SELECT` sont extraits du [cache de requêtes](/fr/concepts/features/performance/caches/query-cache).
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## enable\_s3\_requests\_logging
Active la journalisation très détaillée des requêtes S3. À n’utiliser que pour le débogage.
## enable\_scalar\_subquery\_optimization
Si ce paramètre est défini sur true, il empêche les sous-requêtes scalaires de (dé)sérialiser de grandes valeurs scalaires et peut éventuellement éviter d'exécuter la même sous-requête plus d'une fois.
## enable\_scopes\_for\_with\_statement
S'il est désactivé, les déclarations dans les clauses WITH parentes auront la même portée que si elles étaient déclarées dans la portée courante.
Notez qu'il s'agit d'un paramètre de compatibilité de l'analyseur, destiné à permettre l'exécution de certaines requêtes invalides que l'ancien analyseur pouvait exécuter.
## enable\_sharding\_aggregator
Active l’optimisation de `GROUP BY` par partitionnement, qui répartit les lignes entre les threads en hachant la clé de regroupement, de sorte que chaque thread agrège un sous-ensemble distinct de clés sans phase de fusion.
Cette approche est efficace pour les clés à forte cardinalité avec des données uniformément réparties, mais peut être moins performante si la distribution des clés est très déséquilibrée ou si les requêtes comportent très peu de clés distinctes.
Valeurs possibles :
* 0 — L’optimisation d’agrégation par partitionnement est désactivée.
* 1 — L’optimisation d’agrégation par partitionnement est activée.
## enable\_shared\_storage\_snapshot\_in\_query
Si ce paramètre est activé, toutes les sous-requêtes d’une même requête partageront le même StorageSnapshot pour chaque table.
Cela garantit une vue cohérente des données dans l’ensemble de la requête, même si la même table est utilisée plusieurs fois.
Ce paramètre est nécessaire pour les requêtes où la cohérence interne des data parts est importante. Exemple :
```sql theme={null}
SELECT
count()
FROM events
WHERE (_part, _part_offset) IN (
SELECT _part, _part_offset
FROM events
WHERE user_id = 42
)
```
Sans ce paramètre, la requête externe et la requête interne peuvent s’exécuter sur des snapshots de données différents, ce qui peut entraîner des résultats incorrects.
L’activation de ce paramètre désactive l’optimisation qui supprime des snapshots les parties de données inutiles une fois l’étape de planification terminée.
Par conséquent, les requêtes de longue durée peuvent conserver des parties obsolètes pendant toute leur exécution, ce qui retarde le nettoyage des parties et accroît la pression sur le stockage.
Ce paramètre s’applique actuellement uniquement aux tables de la famille MergeTree.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## enable\_sharing\_sets\_for\_mutations
Autorise le partage des objets set construits pour les sous-requêtes IN entre différentes tâches d'une même mutation. Cela réduit l'utilisation de la mémoire et la consommatio
## enable\_software\_prefetch\_in\_aggregation
Activer l'utilisation du software prefetch dans l'agrégatio
## enable\_software\_prefetch\_in\_join
Active l’utilisation du software prélecture dans la phase de probe du hash join afin de masquer la latence des accès mémoire pour les grandes tables de hachage.
## enable\_streaming\_queries
Autorise les requêtes continues `SELECT ... FROM t STREAM [CURSOR '{...}']`.
Lorsqu’il est désactivé, toute expression de table utilisant le modificateur `STREAM` est rejetée
lors de la construction du plan. Ce paramètre constitue le contrôle principal de la
fonctionnalité de requêtes en streaming ; des capacités supplémentaires peuvent être régies par leurs propres paramètres.
## enable\_time\_time64\_type
**Alias** : `allow_experimental_time_time64_type`
Permet de créer les types de données [Time](/fr/reference/data-types/time) et [Time64](/fr/reference/data-types/time64).
## enable\_unaligned\_array\_join
Autorise ARRAY JOIN avec plusieurs tableaux de tailles différentes. Lorsque ce paramètre est activé, les tableaux sont redimensionnés à la taille du plus grand.
## enable\_url\_encoding
Permet d’activer ou de désactiver le décodage/l’encodage du chemin dans l’URI pour les tables du moteur [URL](/fr/reference/engines/table-engines/special/url).
Désactivé par défaut.
## enable\_vertical\_final
Si ce paramètre est activé, les lignes dupliquées sont supprimées pendant FINAL en les marquant comme supprimées, puis en les filtrant ultérieurement au lieu de les fusionner
## enable\_writes\_to\_query\_cache
Si cette option est activée, les résultats des requêtes `SELECT` sont stockés dans le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache).
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## enforce\_strict\_identifier\_format
Si ce paramètre est activé, seuls les identifiants contenant des caractères alphanumériques et des underscores sont autorisés.
## engine\_file\_allow\_create\_multiple\_files
Active ou désactive la création d’un nouveau fichier à chaque insertion dans les tables utilisant le moteur File si le format comporte le suffixe (`JSON`, `ORC`, `Parquet`, etc.). Si ce paramètre est activé, un nouveau fichier est créé à chaque insertion selon le modèle de nommage suivant :
`data.Parquet` -> `data.1.Parquet` -> `data.2.Parquet`, etc.
Valeurs possibles :
* 0 — la requête `INSERT` ajoute les nouvelles données à la fin du fichier.
* 1 — la requête `INSERT` crée un nouveau fichier.
## engine\_file\_empty\_if\_not\_exists
Permet de sélectionner des données dans une table utilisant le moteur File, même sans fichier.
Valeurs possibles :
* 0 — `SELECT` lève une exception.
* 1 — `SELECT` renvoie un résultat vide.
## engine\_file\_skip\_empty\_files
Active ou désactive la prise en compte des fichiers vides dans les tables du moteur [File](/fr/reference/engines/table-engines/special/file).
Valeurs possibles :
* 0 — `SELECT` lève une exception si le fichier vide n’est pas compatible avec le format demandé.
* 1 — `SELECT` renvoie un résultat vide pour un fichier vide.
## engine\_file\_truncate\_on\_insert
Active ou désactive la troncature avant l’insertion dans les tables du moteur [File](/fr/reference/engines/table-engines/special/file).
Valeurs possibles :
* 0 — la requête `INSERT` ajoute de nouvelles données à la fin du fichier.
* 1 — la requête `INSERT` remplace le contenu existant du fichier par les nouvelles données.
## engine\_url\_skip\_empty\_files
Active ou désactive la prise en compte des fichiers vides dans les tables du moteur [URL](/fr/reference/engines/table-engines/special/url).
Valeurs possibles :
* 0 — `SELECT` lève une exception si le fichier vide n’est pas compatible avec le format demandé.
* 1 — `SELECT` renvoie un résultat vide pour un fichier vide.
## exact\_rows\_before\_limit
Lorsqu'il est activé, ClickHouse fournit la valeur exacte de la statistique rows\_before\_limit\_at\_least, mais au prix d'une lecture complète des données avant la limite.
## except\_default\_mode
Définit le mode par défaut de la requête EXCEPT. Valeurs possibles : chaîne vide, 'ALL', 'DISTINCT'. Si elle est vide, une requête sans mode générera une exception.
## exclude\_materialize\_skip\_indexes\_on\_insert
Empêche la construction et le stockage des skip indexes spécifiés lors des INSERTs. Les skip indexes exclus seront tout de même construits et stockés [lors des fusions](/fr/reference/settings/merge-tree-settings#materialize_skip_indexes_on_merge) ou par une requête explicite
[MATERIALIZE INDEX](/fr/reference/statements/alter/skipping-index#materialize-index).
N'a aucun effet si [materialize\_skip\_indexes\_on\_insert](#materialize_skip_indexes_on_insert) est défini sur false.
Exemple :
```sql theme={null}
CREATE TABLE tab
(
a UInt64,
b UInt64,
INDEX idx_a a TYPE minmax,
INDEX idx_b b TYPE set(3)
)
ENGINE = MergeTree ORDER BY tuple();
SET exclude_materialize_skip_indexes_on_insert='idx_a'; -- idx_a will be not be updated upon insert
--SET exclude_materialize_skip_indexes_on_insert='idx_a, idx_b'; -- neither index would be updated on insert
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- only idx_b is updated
-- since it is a session setting it can be set on a per-query level
INSERT INTO tab SELECT number, number / 50 FROM numbers(100, 100) SETTINGS exclude_materialize_skip_indexes_on_insert='idx_b';
ALTER TABLE tab MATERIALIZE INDEX idx_a; -- this query can be used to explicitly materialize the index
SET exclude_materialize_skip_indexes_on_insert = DEFAULT; -- reset setting to default
```
## execute\_exists\_as\_scalar\_subquery
Exécute les sous-requêtes `EXISTS` non corrélées comme des sous-requêtes scalaires. Comme pour les sous-requêtes scalaires, le cache est utilisé et le pliage de constantes s'applique au résultat.
Valeur par défaut dans Cloud : `0`.
## external\_storage\_connect\_timeout\_sec
Délai d’expiration de la connexion, en secondes. Actuellement pris en charge uniquement pour MySQL
## external\_storage\_max\_read\_bytes
Limite le nombre maximal d’octets lorsque la table avec un moteur externe doit écrire les données d’historique. Actuellement, ce paramètre n’est pris en charge que pour le moteur de table MySQL, le moteur de base de données et le dictionnaire. S’il est égal à 0, ce paramètre est désactivé
## external\_storage\_max\_read\_rows
Limite le nombre maximal de lignes lorsqu’une table utilisant un moteur externe doit purger les données d’historique. Actuellement, ce paramètre n’est pris en charge que pour le moteur de table MySQL, le moteur de base de données et le dictionnaire. Si cette valeur est égale à 0, ce paramètre est désactivé
## external\_storage\_rw\_timeout\_sec
Délai d’expiration en lecture/écriture, en secondes. Actuellement pris en charge uniquement pour MySQL
## external\_table\_functions\_use\_nulls
Définit comment les fonctions de table [mysql](/fr/reference/functions/table-functions/mysql), [postgresql](/fr/reference/functions/table-functions/postgresql) et [odbc](/fr/reference/functions/table-functions/odbc) utilisent des colonnes Nullable.
Valeurs possibles :
* 0 — La fonction de table utilise explicitement des colonnes Nullable.
* 1 — La fonction de table utilise implicitement des colonnes Nullable.
**Utilisation**
Si ce paramètre est défini sur `0`, la fonction de table ne rend pas les colonnes Nullable et insère à la place des valeurs par défaut au lieu de NULL. Cela s'applique également aux valeurs NULL dans les tableaux.
## external\_table\_strict\_query
Si cette option est définie sur true, il est interdit de transformer une expression en filtre local pour les requêtes sur des tables externes.
**Alias** : `extract_kvp_max_pairs_per_row`
Nombre maximal de paires que la fonction `extractKeyValuePairs` peut produire. Sert de garde-fou pour éviter une consommation excessive de mémoire.
## extremes
Indique s’il faut comptabiliser les valeurs extrêmes (les valeurs minimales et maximales dans les colonnes du résultat de la requête). Accepte 0 ou 1. Par défaut : 0 (désactivé).
Pour plus d’informations, consultez la section « Valeurs extrêmes ».
## fallback\_to\_stale\_replicas\_for\_distributed\_queries
Force l'exécution d'une requête sur une réplique obsolète si les données à jour ne sont pas disponibles. Voir [Réplication](/fr/reference/engines/table-engines/mergetree-family/replication).
ClickHouse sélectionne la réplique la plus pertinente parmi les répliques obsolètes de la table.
Utilisé lors de l'exécution d'un `SELECT` sur une table distribuée pointant vers des tables répliquées.
Par défaut, 1 (activé).
## file\_like\_engine\_default\_partition\_strategy
Stratégie de partition par défaut pour les moteurs de type fichier.
## filesystem\_cache\_allow\_background\_download
Autorise le cache du système de fichiers à placer en file d’attente des téléchargements en arrière-plan pour les données lues depuis un stockage distant. Désactivez cette option pour que les téléchargements restent au premier plan pour la requête/session en cours.
## filesystem\_cache\_boundary\_alignment
Alignement aux limites du cache du système de fichiers. Ce paramètre s’applique uniquement aux lectures ne provenant pas du disque (par exemple, pour le cache des moteurs de table distants / fonctions de table, mais pas pour la configuration de stockage des tables MergeTree). La valeur 0 signifie qu’aucun alignement n’est appliqué.
## filesystem\_cache\_enable\_background\_download\_during\_fetch
N’a d’effet que dans ClickHouse Cloud. Temps d’attente pour obtenir le verrou du cache lors de la réservation d’espace dans le cache du système de fichiers
## filesystem\_cache\_enable\_background\_download\_for\_metadata\_files\_in\_packed\_storage
N’a d’effet que dans ClickHouse Cloud. Temps d’attente pour obtenir le verrou du cache lors de la réservation d’espace dans le cache du système de fichiers
## filesystem\_cache\_max\_download\_size
Taille maximale du cache du système de fichiers distant qu’une seule requête peut télécharger
## filesystem\_cache\_name
Nom du cache du système de fichiers à utiliser avec les moteurs de table sans état ou les lacs de données
## filesystem\_cache\_prefer\_bigger\_buffer\_size
Privilégie une taille de tampon plus importante si le cache du système de fichiers est activé, afin d’éviter l’écriture de petits segments de fichier, qui dégradent les performances du cache. En revanche, l’activation de ce paramètre peut augmenter l’utilisation de la mémoire.
## filesystem\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Temps d’attente pour obtenir le verrou du cache lors de la réservation d’espace dans le cache du système de fichiers
## filesystem\_cache\_segments\_batch\_size
Limite de la taille d’un lot de segments de fichier qu’un tampon de lecture peut demander au cache. Une valeur trop faible entraînera un nombre excessif de requêtes vers le cache, tandis qu’une valeur trop élevée peut ralentir l’éviction du cache
## filesystem\_cache\_skip\_download\_if\_exceeds\_per\_query\_cache\_write\_limit
**Alias** : `skip_download_if_exceeds_query_cache`
Ne pas télécharger depuis le système de fichiers distant si la taille dépasse celle du cache de requêtes
## filesystem\_prefetch\_max\_memory\_usage
Utilisation mémoire maximale pour les prélectures.
Valeur par défaut dans Cloud : 10 % de la mémoire totale.
## filesystem\_prefetch\_step\_bytes
Pas de prélecture, en octets. Zéro signifie `auto` : le pas de prélecture optimal sera déduit automatiquement de façon approximative, mais il ne sera pas forcément optimal à 100 %. La valeur réelle peut être différente en raison du paramètre filesystem\_prefetch\_min\_bytes\_for\_single\_read\_task
## filesystem\_prefetch\_step\_marks
Étape de prélecture en marks. Zéro signifie `auto` : l’étape de prélecture approximativement la plus adaptée sera déduite automatiquement, mais elle ne sera pas forcément optimale à 100 %. La valeur réelle peut être différente en raison du paramètre filesystem\_prefetch\_min\_bytes\_for\_single\_read\_task
## filesystem\_prefetches\_limit
Nombre maximal de prélectures. Zéro signifie sans limite. Il est recommandé d'utiliser le paramètre `filesystem_prefetches_max_memory_usage` si vous souhaitez limiter le nombre de prélectures
## final
Applique automatiquement le modificateur [FINAL](/fr/reference/statements/select/from#final-modifier) à toutes les tables d’une requête auxquelles [FINAL](/fr/reference/statements/select/from#final-modifier) s’applique, y compris les tables jointes, les tables des sous-requêtes et les
tables distribuées.
Valeurs possibles :
* 0 - désactivé
* 1 - activé
Exemple :
```sql theme={null}
CREATE TABLE test
(
key Int64,
some String
)
ENGINE = ReplacingMergeTree
ORDER BY key;
INSERT INTO test FORMAT Values (1, 'first');
INSERT INTO test FORMAT Values (1, 'second');
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
┌─key─┬─some──┐
│ 1 │ first │
└─────┴───────┘
SELECT * FROM test SETTINGS final = 1;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
SET final = 1;
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
```
## finalize\_projection\_parts\_synchronously
Lorsqu’il est activé, les parties de projection sont finalisées de manière synchrone pendant l’INSERT, ce qui réduit l’utilisation maximale de la mémoire au prix d’un parallélisme moindre des téléversements S3. Par défaut, le flux de sortie de chaque projection reste actif jusqu’à la finalisation de la part entière (y compris toutes les projections), ce qui permet de faire se chevaucher les téléversements S3, mais augmente l’utilisation maximale de la mémoire proportionnellement au nombre de projections. Ce paramètre n’affecte que le chemin d’INSERT ; les opérations de merge et de mutation finalisent déjà les projections de manière synchrone.
## flatten\_nested
Définit le format des données des colonnes [Nested](/fr/reference/data-types/nested-data-structures/index).
Valeurs possibles :
* 1 — La colonne Nested est convertie en tableaux distincts.
* 0 — La colonne Nested reste un tableau unique de tuples.
**Utilisation**
Si le paramètre est défini sur `0`, il est possible d'utiliser un niveau d'imbrication arbitraire.
**Exemples**
Requête :
```sql theme={null}
SET flatten_nested = 1;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
```
Résultat :
```text theme={null}
┌─statement───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n.a` Array(UInt32),
`n.b` Array(UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Requête :
```sql theme={null}
SET flatten_nested = 0;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
```
Résultat :
```text theme={null}
┌─statement──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n` Nested(a UInt32, b UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## force\_aggregate\_partitions\_independently
Force l’utilisation de l’optimisation lorsqu’elle est applicable, même si les heuristiques ont décidé de ne pas l’utiliser
## force\_aggregation\_in\_order
Ce paramètre est utilisé par le serveur lui-même pour prendre en charge les requêtes distribuées. Ne le modifiez pas manuellement, car cela perturberait le fonctionnement normal. (Force l’utilisation de l’agrégation dans l’ordre sur les nœuds distants lors d’une agrégation distribuée).
## force\_data\_skipping\_indices
Désactive l’exécution de la requête si les index de saut de données spécifiés n’ont pas été utilisés.
Considérez l’exemple suivant :
```sql theme={null}
CREATE TABLE data
(
key Int,
d1 Int,
d1_null Nullable(Int),
INDEX d1_idx d1 TYPE minmax GRANULARITY 1,
INDEX d1_null_idx assumeNotNull(d1_null) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
SELECT * FROM data_01515;
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices=''; -- query will produce CANNOT_PARSE_TEXT error.
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices='d1_idx'; -- query will produce INDEX_NOT_USED error.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='d1_idx'; -- Ok.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`'; -- Ok (example of full featured parser).
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- query will produce INDEX_NOT_USED error, since d1_null_idx is not used.
SELECT * FROM data_01515 WHERE d1 = 0 AND assumeNotNull(d1_null) = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- Ok.
```
## force\_grouping\_standard\_compatibility
Fait en sorte que la fonction GROUPING renvoie 1 lorsque l'argument n'est pas utilisé comme clé d'agrégation
## force\_index\_by\_date
Désactive l’exécution de la requête si l’index ne peut pas être utilisé sur la date.
Fonctionne avec les tables de la famille MergeTree.
Si `force_index_by_date=1`, ClickHouse vérifie si la requête contient une condition sur la clé de date qui peut être utilisée pour restreindre les plages de données. S’il n’existe pas de condition appropriée, une exception est levée. Cependant, le système ne vérifie pas si cette condition réduit la quantité de données à lire. Par exemple, la condition `Date != ' 2000-01-01 '` est acceptable même lorsqu’elle correspond à toutes les données de la table (c’est-à-dire que l’exécution de la requête nécessite un parcours complet). Pour plus d’informations sur les plages de données dans les tables MergeTree, consultez [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree).
## force\_optimize\_projection
Active ou désactive l'utilisation obligatoire des [projections](/fr/reference/engines/table-engines/mergetree-family/mergetree#projections) dans les requêtes `SELECT` lorsque l'optimisation des projections est activée (voir le paramètre [optimize\_use\_projections](#optimize_use_projections)).
Valeurs possibles :
* 0 — L'optimisation des projections n'est pas obligatoire.
* 1 — L'optimisation des projections est obligatoire.
## force\_optimize\_projection\_name
S'il est défini sur une chaîne non vide, le système vérifie que cette projection est utilisée au moins une fois dans la requête.
Valeurs possibles :
* chaîne : nom de la projection utilisée dans une requête
## force\_optimize\_skip\_unused\_shards
Active ou désactive l'exécution des requêtes lorsque [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards) est activé et qu'il n'est pas possible d'ignorer les shards inutilisés. Si cela n'est pas possible et que ce paramètre est activé, une exception est levée.
Valeurs possibles :
* 0 — Désactivé. ClickHouse ne lève pas d'exception.
* 1 — Activé. L'exécution des requêtes est désactivée uniquement si la table possède une clé de sharding.
* 2 — Activé. L'exécution des requêtes est désactivée, qu'une clé de sharding soit définie ou non pour la table.
## force\_optimize\_skip\_unused\_shards\_nesting
Contrôle le comportement de [`force_optimize_skip_unused_shards`](#force_optimize_skip_unused_shards) en fonction du niveau d’imbrication de la requête distribuée (lorsqu’une table `Distributed` interroge une autre table `Distributed`). Ce paramètre requiert donc toujours [`force_optimize_skip_unused_shards`](#force_optimize_skip_unused_shards).
Valeurs possibles :
* 0 - Désactivé, `force_optimize_skip_unused_shards` s’applique toujours.
* 1 — Active `force_optimize_skip_unused_shards` uniquement pour le premier niveau.
* 2 — Active `force_optimize_skip_unused_shards` jusqu’au deuxième niveau.
## force\_primary\_key
Désactive l’exécution de la requête si l’indexation par la clé primaire n’est pas possible.
Fonctionne avec les tables de la famille MergeTree.
Si `force_primary_key=1`, ClickHouse vérifie si la requête comporte une condition sur la clé primaire pouvant être utilisée pour restreindre les plages de données. S’il n’existe pas de condition appropriée, il lève une exception. Cependant, il ne vérifie pas si cette condition réduit la quantité de données à lire. Pour plus d’informations sur les plages de données dans les tables MergeTree, consultez [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree).
## force\_remove\_data\_recursively\_on\_drop
Supprime récursivement les données lors d'une requête DROP. Évite l'erreur « Directory not empty », mais peut supprimer silencieusement des données detached
## formatdatetime\_e\_with\_space\_padding
Le spécificateur de format '%e' dans la fonction 'formatDateTime' affiche les jours à un seul chiffre précédés d'une espace, par ex. ' 2' au lieu de '2'.
## formatdatetime\_f\_prints\_scale\_number\_of\_digits
Le spécificateur de format '%f' de la fonction 'formatDateTime' n'affiche que le nombre de chiffres correspondant à la précision d'un DateTime64, au lieu d'en afficher systématiquement 6.
## formatdatetime\_f\_prints\_single\_zero
Le spécificateur de format '%f' dans la fonction 'formatDateTime' affiche un seul zéro au lieu de six zéros lorsque la valeur formatée ne comporte pas de secondes fractionnaires.
## formatdatetime\_format\_without\_leading\_zeros
Les spécificateurs de format '%c', '%l' et '%k' de la fonction 'formatDateTime' affichent les mois et les heures sans zéro initial.
## formatdatetime\_parsedatetime\_m\_is\_month\_name
Le spécificateur de format '%M' dans les fonctions 'formatDateTime' et 'parseDateTime' affiche/analyse le nom du mois au lieu des minutes.
## fsync\_metadata
Active ou désactive [fsync](http://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html) lors de l’écriture des fichiers `.sql`. Activé par défaut.
Il peut être pertinent de le désactiver si le serveur possède des millions de petites tables qui sont constamment créées et supprimées.
## function\_base58\_max\_input\_size
Taille maximale, en octets, d’une valeur d’entrée unique pour les fonctions `base58Encode`, `base58Decode` et `tryBase58Decode`. La conversion générique `base58` est quadratique par rapport à la longueur de l’entrée ; une seule valeur volumineuse peut donc mettre très longtemps à s’exécuter. `base58` est conçu pour des données courtes (clés, hachages, adresses) ; la valeur par défaut de 10 Ko constitue donc un seuil de sécurité généreux. `base58Encode` et `base58Decode` lèvent `TOO_LARGE_STRING_SIZE` pour les entrées plus volumineuses, tandis que `tryBase58Decode` renvoie une chaîne vide. Une valeur de `0` désactive la limite (c’était le comportement avant l’introduction de ce paramètre). Les fonctions linéaires `base32` et `base64` ne sont pas affectées.
## function\_date\_trunc\_return\_type\_behavior
Permet de modifier le comportement du type de retour de la fonction `dateTrunc`.
Valeurs possibles :
* 0 - Lorsque le deuxième argument est `DateTime64/Date32`, le type de retour sera `DateTime64/Date32` quelle que soit l’unité de temps du premier argument.
* 1 - Pour `Date32`, le résultat est toujours `Date`. Pour `DateTime64`, le résultat est `DateTime` pour les unités de temps `second` et supérieures.
## function\_implementation
Choisissez l’implémentation de la fonction pour une cible spécifique ou une variante (expérimental). Si vide, active toutes les implémentations.
## function\_json\_value\_return\_type\_allow\_complex
Indique s’il est permis de renvoyer un type complexe (tel que : struct, array, map) pour la fonction json\_value.
```sql theme={null}
SELECT JSON_VALUE('{"hello":{"world":"!"}}', '$.hello') settings function_json_value_return_type_allow_complex=true
┌─JSON_VALUE('{"hello":{"world":"!"}}', '$.hello')─┐
│ {"world":"!"} │
└──────────────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
```
Valeurs possibles :
* true — Autorise.
* false — Interdit.
## function\_json\_value\_return\_type\_allow\_nullable
Détermine s'il est autorisé de renvoyer `NULL` lorsque la valeur n'existe pas pour la fonction JSON\_VALUE.
```sql theme={null}
SELECT JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;
┌─JSON_VALUE('{"hello":"world"}', '$.b')─┐
│ ᴺᵁᴸᴸ │
└────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
```
Valeurs possibles :
* true — Autorisé.
* false — Interdit.
## function\_locate\_has\_mysql\_compatible\_argument\_order
Contrôle l’ordre des arguments de la fonction [locate](/fr/reference/functions/regular-functions/string-search-functions#locate).
Valeurs possibles :
* 0 — La fonction `locate` accepte les arguments `(haystack, needle[, start_pos])`.
* 1 — La fonction `locate` accepte les arguments `(needle, haystack, [, start_pos])` (comportement compatible avec MySQL)
## function\_range\_max\_elements\_in\_block
Définit le seuil de sécurité du volume de données généré par la fonction [range](/fr/reference/functions/regular-functions/array-functions#range). Il définit le nombre maximal de valeurs générées par la fonction par bloc de données (somme des tailles des tableaux pour chaque ligne d’un bloc).
Valeurs possibles :
* Entier positif.
**Voir aussi**
* [`max_block_size`](#max_block_size)
* [`min_insert_block_size_rows`](#min_insert_block_size_rows)
## function\_sleep\_max\_microseconds\_per\_block
Nombre maximal de microsecondes pendant lesquelles la fonction `sleep` est autorisée à se mettre en veille pour chaque bloc. Si un utilisateur l'appelle avec une valeur plus élevée, elle lève une exception. Il s'agit d'un seuil de sécurité.
## function\_visible\_width\_behavior
Version du comportement de `visibleWidth`. 0 - compte uniquement le nombre de points de code ; 1 - compte correctement les caractères de largeur nulle et les caractères combinés, compte les caractères à pleine largeur comme deux, estime la largeur des tabulations et compte les caractères de suppression.
## functions\_h3\_default\_if\_invalid
Si false, les fonctions h3, par exemple h3CellAreaM2, lèvent une exception si l'entrée est invalide. Si true, elles renvoient 0 ou la valeur par défaut.
## geo\_distance\_returns\_float64\_on\_float64\_arguments
Si les quatre arguments des fonctions `geoDistance`, `greatCircleDistance` et `greatCircleAngle` sont de type Float64, elles retournent un Float64 et utilisent la double précision pour les calculs internes. Dans les versions précédentes de ClickHouse, ces fonctions retournaient toujours un Float32.
## geotoh3\_argument\_order
La fonction 'geoToH3' accepte (lon, lat) si ce paramètre est défini sur 'lon\_lat', et (lat, lon) s'il est défini sur 'lat\_lon'.
## glob\_expansion\_max\_elements
Nombre maximal d’adresses autorisées (pour les stockages externes, les fonctions de table, etc.).
## grace\_hash\_join\_initial\_buckets
Nombre initial de buckets pour le grace hash join
## grace\_hash\_join\_max\_buckets
Nombre maximal de buckets pour le grace hash join
## group\_by\_overflow\_mode
Définit ce qui se produit lorsque le nombre de clés uniques pour l’agrégation dépasse la limite :
* `throw` : lever une exception
* `break` : arrêter l’exécution de la requête et renvoyer un résultat partiel
* `any` : poursuivre l’agrégation pour les clés déjà présentes dans le set, sans ajouter de nouvelles clés au set.
L’utilisation de la valeur 'any' permet d’exécuter une approximation de GROUP BY. La qualité de
cette approximation dépend de la nature statistique des données.
## group\_by\_two\_level\_threshold
Nombre de clés à partir duquel une agrégation à deux niveaux démarre. 0 - le seuil n'est pas défini.
## group\_by\_two\_level\_threshold\_bytes
Taille, en octets, de l’état d’agrégation à partir de laquelle une agrégation à deux niveaux commence à être utilisée. 0 : le seuil n’est pas défini. L’agrégation à deux niveaux est utilisée lorsqu’au moins l’un des seuils est déclenché.
## group\_by\_use\_nulls
Modifie la manière dont la clause [GROUP BY](/fr/reference/statements/select/group-by) traite les types des clés d’agrégation.
Lorsque les spécificateurs `ROLLUP`, `CUBE` ou `GROUPING SETS` sont utilisés, certaines clés d’agrégation peuvent ne pas être utilisées pour produire certaines lignes de résultat.
Les colonnes correspondant à ces clés sont remplies soit avec la valeur par défaut, soit avec `NULL` dans les lignes correspondantes, selon ce paramètre.
Valeurs possibles :
* 0 — La valeur par défaut du type de clé d’agrégation est utilisée pour produire les valeurs manquantes.
* 1 — ClickHouse exécute `GROUP BY` de la même manière que le prescrit la norme SQL. Les types des clés d’agrégation sont convertis en [Nullable](/fr/reference/data-types/nullable). Les colonnes correspondant aux clés d’agrégation sont remplies avec [NULL](/fr/reference/syntax#null) pour les lignes où elles n’ont pas été utilisées.
Voir aussi :
* [clause GROUP BY](/fr/reference/statements/select/group-by)
## h3togeo\_lon\_lat\_result\_order
La fonction 'h3ToGeo' renvoie (lon, lat) si true, et (lat, lon) sinon.
## handshake\_timeout\_ms
Délai d’expiration, en millisecondes, pour la réception du paquet Hello provenant des répliques lors de la négociation initiale.
## hdfs\_create\_new\_file\_on\_insert
Active ou désactive la création d’un nouveau fichier à chaque insertion dans les tables du moteur HDFS. Si cette option est activée, un nouveau fichier HDFS est créé à chaque insertion, avec un nom de ce type :
initial : `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
Valeurs possibles :
* 0 — la requête `INSERT` ajoute de nouvelles données à la fin du fichier.
* 1 — la requête `INSERT` crée un nouveau fichier.
## hdfs\_ignore\_file\_doesnt\_exist
Ignorer l'absence d'un fichier lorsqu'il n'existe pas pendant la lecture de certaines clés.
Valeurs possibles :
* 1 — `SELECT` renvoie un résultat vide.
* 0 — `SELECT` lève une exception.
## hdfs\_replication
Le nombre réel de réplications peut être indiqué lors de la création du fichier HDFS.
## hdfs\_skip\_empty\_files
Permet d’ignorer ou non les fichiers vides dans les tables du moteur [HDFS](/fr/reference/engines/table-engines/integrations/hdfs).
Valeurs possibles :
* 0 — `SELECT` lève une exception si un fichier vide n’est pas compatible avec le format demandé.
* 1 — `SELECT` renvoie un résultat vide pour un fichier vide.
## hdfs\_throw\_on\_zero\_files\_match
Génère une erreur si aucun fichier ne correspond aux règles d’expansion des motifs glob.
Valeurs possibles :
* 1 — `SELECT` lève une exception.
* 0 — `SELECT` renvoie un résultat vide.
## hdfs\_truncate\_on\_insert
Active ou désactive le tronquage avant une insertion dans les tables du moteur HDFS. Si cette option est désactivée, une exception sera levée en cas de tentative d'insertion si un fichier existe déjà dans HDFS.
Valeurs possibles :
* 0 — la requête `INSERT` ajoute de nouvelles données à la fin du fichier.
* 1 — la requête `INSERT` remplace le contenu existant du fichier par les nouvelles données.
## hedged\_connection\_timeout\_ms
Délai d’expiration pour établir une connexion avec une réplique pour les requêtes Hedged
## highlight\_max\_matches\_per\_row
Définit le nombre maximal de correspondances mises en surbrillance par ligne dans la fonction [highlight](/fr/reference/functions/regular-functions/string-search-functions#highlight). Utilisez-le pour éviter une utilisation excessive de la mémoire lors de la mise en surbrillance de motifs très répétitifs dans de grands textes.
Valeurs possibles :
* Entier positif.
## hnsw\_candidate\_list\_size\_for\_search
Taille de la liste dynamique de candidats lors de la recherche dans l’index de similarité vectorielle, également appelée « ef\_search ».
## hsts\_max\_age
Durée d’expiration du HSTS. 0 signifie que le HSTS est désactivé.
## http\_connection\_timeout
Délai d’expiration de la connexion HTTP (en secondes).
Valeurs possibles :
* Tout nombre entier positif.
* 0 - Désactivé (délai d’expiration infini).
N’envoyez pas les en-têtes HTTP X-ClickHouse-Progress plus souvent qu’à l’intervalle spécifié.
Temps maximal, en secondes, pour lire tous les en-têtes de requête HTTP. Il s’agit d’un délai global pour toute la phase d’analyse des en-têtes, et non d’un délai d’expiration par lecture. Protège contre les attaques de type slowloris, dans lesquelles un client envoie lentement les données d’en-tête afin de maintenir les connexions ouvertes.
## http\_make\_head\_request
Le paramètre `http_make_head_request` permet d'effectuer une requête `HEAD` lors de la lecture de données via HTTP afin d'obtenir des informations sur le fichier à lire, comme sa taille. Étant activé par défaut, il peut être utile de désactiver ce paramètre lorsque le serveur ne prend pas en charge les requêtes `HEAD`.
## http\_max\_field\_name\_size
Longueur maximale d’un nom de champ dans les en-têtes de requête HTTP, les paramètres de requête et les données de formulaire.
## http\_max\_field\_value\_size
Longueur maximale de la valeur d’un champ dans les en-têtes de requête HTTP, les paramètres de requête et les données de formulaire.
## http\_max\_fields
Nombre maximal de champs dans les en-têtes de requête HTTP, les paramètres de requête et les données de formulaire.
## http\_max\_multipart\_form\_data\_size
Limite de taille du contenu multipart/form-data. Ce paramètre ne peut pas être défini via des paramètres d’URL et doit être configuré dans un profil utilisateur. Notez que le contenu est analysé et que les tables externes sont créées en mémoire avant le début de l’exécution de la requête. C’est la seule limite qui s’applique à cette étape (les limites de memory usage et de temps d’exécution maximal n’ont aucun effet lors de la lecture des form data HTTP).
Taille totale maximale, en octets, de tous les en-têtes de requête HTTP (noms et valeurs combinés).
## http\_max\_request\_param\_data\_size
Limite de la taille des données de requête utilisées comme paramètre de requête dans les requêtes HTTP prédéfinies.
## http\_max\_tries
Nombre maximal de tentatives de lecture via HTTP.
## http\_max\_uri\_size
Définit la longueur maximale de l’URI d’une requête HTTP.
Valeurs possibles :
* Entier positif.
## http\_native\_compression\_disable\_checksumming\_on\_decompress
Active ou désactive la vérification de la somme de contrôle lors de la décompression des données POST HTTP envoyées par le client. Utilisé uniquement avec le format de compression natif de ClickHouse (non utilisé avec `gzip` ou `deflate`).
Pour plus d’informations, consultez la [description de l’interface HTTP](/fr/concepts/features/interfaces/http).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## http\_receive\_timeout
Délai d'attente de réception HTTP (en secondes).
Valeurs possibles :
* N’importe quel entier positif.
* 0 - Désactivé (délai d'attente infini).
## http\_response\_buffer\_size
Le nombre d’octets à mettre en tampon dans la mémoire du serveur avant d’envoyer une réponse HTTP au client ou d’écrire sur disque (lorsque http\_wait\_end\_of\_query est activé).
Permet d'ajouter ou de remplacer les en-têtes HTTP que le serveur renverra dans la réponse lorsqu'une requête aboutit.
Cela n'affecte que l'interface HTTP.
Si l'en-tête est déjà défini par défaut, la valeur fournie le remplacera.
Si l'en-tête n'est pas défini par défaut, il sera ajouté à la liste des en-têtes.
Les en-têtes définis par défaut par le serveur et non remplacés par ce paramètre seront conservés.
Ce paramètre permet de définir un en-tête avec une valeur constante. Il n'existe actuellement aucun moyen de définir un en-tête avec une valeur calculée dynamiquement.
Ni les noms ni les valeurs ne peuvent contenir de caractères de contrôle ASCII.
Si vous implémentez une application UI qui permet aux utilisateurs de modifier les paramètres tout en prenant des décisions en fonction des en-têtes renvoyés, il est recommandé de restreindre ce paramètre à readonly.
Exemple : `SET http_response_headers = '{"Content-Type": "image/png"}'`
## http\_retry\_initial\_backoff\_ms
Délai minimal de backoff, en millisecondes, lors d'une nouvelle tentative de lecture via HTTP
## http\_retry\_max\_backoff\_ms
Nombre maximal de millisecondes de backoff lors d’une nouvelle tentative de lecture via HTTP
## http\_send\_timeout
Délai d'expiration de l'envoi HTTP (en secondes).
Valeurs possibles :
* Tout nombre entier positif.
* 0 - Désactivé (délai d'expiration infini).
Cela s'applique uniquement au profil par défaut. Un redémarrage du serveur est nécessaire pour que les modifications prennent effet.
## http\_skip\_not\_found\_url\_for\_globs
Ignorer les URL correspondant à des globs en cas d’erreur HTTP\_NOT\_FOUND
## http\_wait\_end\_of\_query
Active la mise en tampon de la réponse HTTP côté serveur.
## http\_write\_exception\_in\_output\_format
Écrit l'exception dans le format de sortie afin de produire une sortie valide. Fonctionne avec les formats JSON et XML.
## http\_zlib\_compression\_level
Définit le niveau de compression des données dans la réponse à une requête HTTP si [enable\_http\_compression = 1](#enable_http_compression).
Valeurs possibles : de 1 à 9.
## iceberg\_compaction\_data\_cleanup
Le délai après lequel les données seront supprimées.
## iceberg\_compaction\_delay\_bias
Temps d’attente minimal entre deux opérations de compaction en arrière-plan.
## iceberg\_data\_file\_size\_lower\_threshold\_compaction
Seuil inférieur de taille des fichiers de données pour la compaction dans Iceberg.
## iceberg\_data\_file\_size\_upper\_threshold\_compaction
Seuil supérieur de taille des fichiers de données pour la compaction dans Iceberg.
## iceberg\_delete\_data\_on\_drop
Indique s’il faut supprimer tous les fichiers Iceberg lors de la suppression ou non.
## iceberg\_expire\_default\_max\_ref\_age\_ms
Valeur par défaut de la propriété de table Iceberg `history.expire.max-ref-age-ms`, utilisée par `expire_snapshots` lorsque cette propriété n’est pas définie.
## iceberg\_expire\_default\_max\_snapshot\_age\_ms
Valeur par défaut de la propriété de table Iceberg `history.expire.max-snapshot-age-ms` utilisée par `expire_snapshots` en l’absence de cette propriété.
## iceberg\_expire\_default\_min\_snapshots\_to\_keep
Valeur par défaut de la propriété de table Iceberg `history.expire.min-snapshots-to-keep` qu’`expire_snapshots` utilise lorsque cette propriété est absente.
## iceberg\_insert\_max\_bytes\_in\_data\_file
Taille maximale, en octets, du fichier de données Parquet Iceberg lors d’une opération d’insertion.
## iceberg\_insert\_max\_partitions
Nombre maximal de partitions autorisées pour une opération d'insertion dans le moteur de table Iceberg.
## iceberg\_insert\_max\_rows\_in\_data\_file
Nombre maximal de lignes dans un fichier de données Parquet Iceberg lors d’une opération d’insertion.
## iceberg\_max\_number\_datafiles\_to\_compact
Seuil pour la compaction des fichiers de données dans Iceberg.
## iceberg\_metadata\_compression\_method
Méthode de compression du fichier `.metadata.json`.
## iceberg\_metadata\_log\_level
Contrôle le niveau de journalisation des métadonnées des tables Iceberg dans system.iceberg\_metadata\_log.
Ce paramètre peut généralement être modifié à des fins de débogage.
Valeurs possibles :
* none - Aucun journal de métadonnées.
* metadata - Fichier racine metadata.json.
* manifest\_list\_metadata - Tout ce qui précède + métadonnées de la liste de manifestes avro correspondant à un snapshot.
* manifest\_list\_entry - Tout ce qui précède + entrées de la liste de manifestes avro.
* manifest\_file\_metadata - Tout ce qui précède + métadonnées des fichiers manifestes avro parcourus.
* manifest\_file\_entry - Tout ce qui précède + entrées des fichiers manifestes avro parcourus.
## iceberg\_metadata\_staleness\_ms
S'il est différent de zéro, la récupération des métadonnées Iceberg depuis le catalogue distant est ignorée s'il existe un snapshot de métadonnées mis en cache plus récent que la fenêtre d'ancienneté indiquée. Zéro signifie qu'il faut toujours récupérer la version la plus récente des métadonnées depuis le catalogue distant. Définir ce paramètre sur une valeur non nulle revient à accepter un certain décalage des métadonnées en échange d'une latence plus faible pour les opérations de lecture.
## iceberg\_orphan\_files\_older\_than\_seconds
Seuil d’ancienneté par défaut, en secondes, pour la suppression des fichiers orphelins dans les tables Iceberg. Les fichiers plus récents que ce seuil ne sont pas considérés comme orphelins. Utilisé lorsque l’argument older\_than est omis de l’appel à la procédure remove\_orphan\_files(). La valeur par défaut est 259200 (3 jours).
## iceberg\_snapshot\_id
Interrogez la table Iceberg à l’aide de l’ID de snapshot spécifié.
## iceberg\_timestamp\_ms
Interrogez une table Iceberg à l’aide du snapshot en vigueur pour un horodatage donné.
## idle\_connection\_timeout
Délai avant la fermeture des connexions TCP inactives après le nombre de secondes spécifié.
Valeurs possibles :
* Entier positif (0 : fermeture immédiate, après 0 seconde).
## ignore\_cold\_parts\_seconds
N'a d'effet que dans ClickHouse Cloud. Exclut les nouvelles parties de données des requêtes SELECT tant qu'elles n'ont pas été préchauffées (voir [cache\_populated\_by\_fetch](/fr/reference/settings/merge-tree-settings#cache_populated_by_fetch)) ou qu'elles n'ont pas atteint cet âge en secondes. Uniquement pour Replicated-/SharedMergeTree.
## ignore\_data\_skipping\_indices
Ignore les index de saut de données spécifiés s’ils sont utilisés par la requête.
Considérez l’exemple suivant :
```sql theme={null}
CREATE TABLE data
(
key Int,
x Int,
y Int,
INDEX x_idx x TYPE minmax GRANULARITY 1,
INDEX y_idx y TYPE minmax GRANULARITY 1,
INDEX xy_idx (x,y) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
INSERT INTO data VALUES (1, 2, 3);
SELECT * FROM data;
SELECT * FROM data SETTINGS ignore_data_skipping_indices=''; -- query will produce CANNOT_PARSE_TEXT error.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='x_idx'; -- Ok.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='na_idx'; -- Ok.
SELECT * FROM data WHERE x = 1 AND y = 1 SETTINGS ignore_data_skipping_indices='xy_idx',force_data_skipping_indices='xy_idx' ; -- query will produce INDEX_NOT_USED error, since xy_idx is explicitly ignored.
SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
```
La requête sans ignorer aucun index :
```sql theme={null}
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2;
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
Skip
Name: xy_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
```
En ignorant l’index `xy_idx` :
```sql theme={null}
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
```
Compatible avec les tables de la famille MergeTree.
## ignore\_drop\_queries\_probability
Si cette option est activée, le serveur ignorera toutes les requêtes DROP table avec la probabilité spécifiée (pour les moteurs Memory et JOIN, il remplacera DROP par TRUNCATE). Cette option est utilisée à des fins de test
## ignore\_format\_null\_for\_explain
Si cette option est activée, `FORMAT Null` est ignoré pour les requêtes `EXPLAIN`, et le format de sortie par défaut est utilisé à la place.
Si elle est désactivée, les requêtes `EXPLAIN` avec `FORMAT Null` ne produisent aucune sortie (comportement rétrocompatible).
## ignore\_materialized\_views\_with\_dropped\_target\_table
Ignorer les vues matérialisées dont la table cible a été supprimée lors de l’envoi vers les vues
## ignore\_on\_cluster\_for\_replicated\_access\_entities\_queries
Ignore la clause ON CLUSTER pour les requêtes de gestion des entités d'accès répliquées.
## ignore\_on\_cluster\_for\_replicated\_database
Ignore toujours la clause ON CLUSTER pour les requêtes DDL avec des bases de données répliquées.
## ignore\_on\_cluster\_for\_replicated\_named\_collections\_queries
Ignorer la clause ON CLUSTER pour les requêtes d'administration des collections nommées répliquées.
## ignore\_on\_cluster\_for\_replicated\_udf\_queries
Ignore la clause ON CLUSTER pour les requêtes de gestion des UDF répliquées.
## implicit\_select
Permet d’écrire des requêtes SELECT simples sans le mot-clé SELECT au début, ce qui facilite une utilisation de type calculatrice ; par ex., `1 + 2` devient une requête valide.
Dans `clickhouse-local`, il est activé par défaut et peut être désactivé explicitement.
## implicit\_table\_at\_top\_level
S’il n’est pas vide, les requêtes sans FROM au niveau supérieur liront à partir de cette table au lieu de system.one.
Ce paramètre est utilisé dans clickhouse-local pour le traitement des données d’entrée.
Le paramètre peut être défini explicitement par un utilisateur, mais il n’est pas destiné à ce type d’utilisation.
Les sous-requêtes ne sont pas affectées par ce paramètre (ni les sous-requêtes scalaires, FROM ou IN).
Les SELECT au niveau supérieur des chaînes UNION, INTERSECT, EXCEPT sont traités uniformément et sont affectés par ce paramètre, quel que soit leur regroupement entre parenthèses.
La manière dont ce paramètre affecte les vues et les requêtes distribuées n’est pas spécifiée.
Le paramètre accepte un nom de table (la table est alors résolue à partir de la base de données courante) ou un nom qualifié de la forme 'database.table'.
Les noms de base de données et de table ne doivent pas être entre guillemets : seuls les identifiants simples sont autorisés.
## implicit\_transaction
Si cette option est activée et qu’aucune transaction n’est déjà en cours, la requête est encapsulée dans une transaction complète (begin + commit ou rollback)
## inject\_random\_order\_for\_select\_without\_order\_by
Si ce paramètre est activé, 'ORDER BY rand()' est injecté dans les requêtes SELECT sans clause ORDER BY.
S'applique uniquement à une profondeur de sous-requête = 0. Les sous-requêtes et INSERT INTO ... SELECT ne sont pas affectés.
Si la construction de plus haut niveau est UNION, 'ORDER BY rand()' est injecté indépendamment dans chacune de ses branches.
Utile uniquement pour les tests et le développement (l'absence de ORDER BY est une source de résultats de requête non déterministes).
## insert\_allow\_materialized\_columns
Si ce paramètre est activé, les colonnes matérialisées sont autorisées dans INSERT.
## insert\_deduplicate
Active ou désactive la déduplication des blocs de `INSERT` (pour les tables Replicated\*).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Par défaut, les blocs insérés dans des tables répliquées par l’instruction `INSERT` sont dédupliqués (voir [Réplication des données](/fr/reference/engines/table-engines/mergetree-family/replication)).
Pour les tables répliquées, seuls les 100 blocs les plus récents de chaque partition sont dédupliqués par défaut (voir [replicated\_deduplication\_window](/fr/reference/settings/merge-tree-settings#replicated_deduplication_window), [replicated\_deduplication\_window\_seconds](/fr/reference/settings/merge-tree-settings#replicated_deduplication_window_seconds)).
Pour les tables non répliquées, voir [non\_replicated\_deduplication\_window](/fr/reference/settings/merge-tree-settings#non_replicated_deduplication_window).
## insert\_deduplication\_token
Ce paramètre permet à l'utilisateur de définir son propre mécanisme de déduplication dans MergeTree/ReplicatedMergeTree.
Par exemple, en fournissant une valeur unique pour ce paramètre dans chaque instruction INSERT,
l'utilisateur peut éviter que les mêmes données insérées soient dédupliquées.
Valeurs possibles :
* Toute chaîne de caractères
`insert_deduplication_token` n'est utilisé pour la déduplication *que* lorsqu'il n'est pas vide.
Pour les tables répliquées, par défaut, seules les 100 insertions les plus récentes de chaque partition sont dédupliquées (voir [replicated\_deduplication\_window](/fr/reference/settings/merge-tree-settings#replicated_deduplication_window), [replicated\_deduplication\_window\_seconds](/fr/reference/settings/merge-tree-settings#replicated_deduplication_window_seconds)).
Pour les tables non répliquées, voir [non\_replicated\_deduplication\_window](/fr/reference/settings/merge-tree-settings#non_replicated_deduplication_window).
`insert_deduplication_token` fonctionne au niveau de la partition (comme la somme de contrôle `insert_deduplication`). Plusieurs partitions peuvent avoir le même `insert_deduplication_token`.
Exemple :
```sql theme={null}
CREATE TABLE test_table
( A Int64 )
ENGINE = MergeTree
ORDER BY A
SETTINGS non_replicated_deduplication_window = 100;
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (1);
-- the next insert won't be deduplicated because insert_deduplication_token is different
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test1' VALUES (1);
-- the next insert will be deduplicated because insert_deduplication_token
-- is the same as one of the previous
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (2);
SELECT * FROM test_table
┌─A─┐
│ 1 │
└───┘
┌─A─┐
│ 1 │
└───┘
```
## insert\_keeper\_fault\_injection\_probability
Probabilité approximative de défaillance d'une requête Keeper lors d'un insert. La valeur valide se situe dans l'intervalle \[0.0f, 1.0f]
## insert\_keeper\_fault\_injection\_seed
0 : graine aléatoire ; sinon, valeur du paramètre
## insert\_keeper\_max\_retries
Ce paramètre définit le nombre maximal de nouvelles tentatives pour les requêtes ClickHouse Keeper (ou ZooKeeper) lors de l’insertion dans un MergeTree répliqué. Seules les requêtes Keeper ayant échoué à cause d’une erreur réseau, d’un timeout de session Keeper ou d’un timeout de requête peuvent faire l’objet de nouvelles tentatives.
Valeurs possibles :
* Entier positif.
* 0 — Les nouvelles tentatives sont désactivées
Valeur par défaut Cloud : `20`.
Les nouvelles tentatives pour les requêtes Keeper sont effectuées après un certain délai d’attente. Ce délai est contrôlé par les paramètres suivants : `insert_keeper_retry_initial_backoff_ms`, `insert_keeper_retry_max_backoff_ms`.
La première nouvelle tentative est effectuée après le délai `insert_keeper_retry_initial_backoff_ms`. Les délais suivants sont calculés comme suit :
```
timeout = min(insert_keeper_retry_max_backoff_ms, latest_timeout * 2)
```
Par exemple, si `insert_keeper_retry_initial_backoff_ms=100`, `insert_keeper_retry_max_backoff_ms=10000` et `insert_keeper_max_retries=8`, les délais seront de `100, 200, 400, 800, 1600, 3200, 6400, 10000`.
Au-delà de la tolérance aux pannes, les nouvelles tentatives visent à offrir une meilleure expérience utilisateur : elles permettent d’éviter de renvoyer une erreur lors de l’exécution d’INSERT si Keeper redémarre, par exemple à la suite d’une mise à niveau.
## insert\_keeper\_retry\_initial\_backoff\_ms
Délai initial (en millisecondes) avant de réessayer une requête Keeper ayant échoué lors de l’exécution d’une requête INSERT
Valeurs possibles :
* Entier positif.
* 0 — Aucun délai d’attente
## insert\_keeper\_retry\_max\_backoff\_ms
Délai maximal (en millisecondes) avant de retenter une requête Keeper ayant échoué pendant l'exécution de la requête INSERT
Valeurs possibles :
* Entier positif.
* 0 — Le délai maximal n'est pas limité
## insert\_null\_as\_default
Active ou désactive l’insertion des [valeurs par défaut](/fr/reference/statements/create/table#default_values) à la place de [NULL](/fr/reference/syntax#null) dans les colonnes dont le type de données n’est pas [Nullable](/fr/reference/data-types/nullable).
Si le type de la colonne n’est pas Nullable et que ce paramètre est désactivé, l’insertion de `NULL` provoque une exception. Si le type de la colonne est Nullable, les valeurs `NULL` sont insérées telles quelles, quel que soit ce paramètre.
Ce paramètre s’applique aux requêtes [INSERT ... SELECT](/fr/reference/statements/insert-into#inserting-the-results-of-select). Notez que les sous-requêtes `SELECT` peuvent être concaténées avec la clause `UNION ALL`.
Valeurs possibles :
* 0 — L’insertion de `NULL` dans une colonne non Nullable provoque une exception.
* 1 — La valeur par défaut de la colonne est insérée à la place de `NULL`.
## insert\_quorum
Ce paramètre ne s’applique pas à SharedMergeTree, voir [la cohérence de SharedMergeTree](/fr/products/cloud/features/infrastructure/shared-merge-tree#consistency) pour plus d’informations.
Active les écritures avec quorum.
* Si `insert_quorum < 2`, les écritures avec quorum sont désactivées.
* Si `insert_quorum >= 2`, les écritures avec quorum sont activées.
* Si `insert_quorum = 'auto'`, utilise la majorité (`number_of_replicas / 2 + 1`) comme nombre de quorum.
Écritures avec quorum
`INSERT` réussit uniquement lorsque ClickHouse parvient à écrire correctement les données sur `insert_quorum` répliques pendant `insert_quorum_timeout`. Si, pour une raison quelconque, le nombre de répliques sur lesquelles l’écriture a réussi n’atteint pas `insert_quorum`, l’écriture est considérée comme ayant échoué et ClickHouse supprimera le bloc inséré de toutes les répliques où les données ont déjà été écrites.
Lorsque `insert_quorum_parallel` est désactivé, toutes les répliques du quorum sont cohérentes, c’est-à-dire qu’elles contiennent les données de toutes les requêtes `INSERT` précédentes (la séquence `INSERT` est linéarisée). Lors de la lecture de données écrites à l’aide de `insert_quorum` et lorsque `insert_quorum_parallel` est désactivé, vous pouvez activer la cohérence séquentielle pour les requêtes `SELECT` à l’aide de [select\_sequential\_consistency](#select_sequential_consistency).
ClickHouse génère une exception :
* Si le nombre de répliques disponibles au moment de la requête est inférieur à `insert_quorum`.
* Lorsque `insert_quorum_parallel` est désactivé et qu’une tentative d’écriture de données est effectuée alors que le bloc précédent n’a pas encore été inséré sur `insert_quorum` répliques. Cette situation peut se produire si l’utilisateur essaie d’exécuter une autre requête `INSERT` sur la même table avant que la précédente avec `insert_quorum` ne soit terminée.
Voir aussi :
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_quorum\_parallel
Ce paramètre ne s'applique pas à SharedMergeTree. Pour plus d'informations, voir [cohérence de SharedMergeTree](/fr/products/cloud/features/infrastructure/shared-merge-tree#consistency).
Active ou désactive le parallélisme pour les requêtes `INSERT` avec quorum. S'il est activé, des requêtes `INSERT` supplémentaires peuvent être envoyées avant la fin des requêtes précédentes. S'il est désactivé, les écritures supplémentaires dans la même table seront rejetées.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Voir aussi :
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_quorum\_timeout
Délai d’écriture avec quorum, en millisecondes. Si ce délai est dépassé et qu’aucune écriture n’a encore eu lieu, ClickHouse génère une exception et le client doit répéter la query pour écrire le même block sur la même replica ou sur une autre replica.
Voir aussi :
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_shard\_id
S’il est différent de `0`, spécifie le shard de la table [Distributed](/fr/reference/engines/table-engines/special/distributed) dans lequel les données seront insérées de façon synchrone.
Si la valeur de `insert_shard_id` est incorrecte, le serveur lèvera une exception.
Pour obtenir le nombre de shards dans `requested_cluster`, vous pouvez consulter la configuration du serveur ou utiliser cette requête :
```sql theme={null}
SELECT uniq(shard_num) FROM system.clusters WHERE cluster = 'requested_cluster';
```
Valeurs possibles :
* 0 — Désactivé.
* Un nombre quelconque de `1` à `shards_num` de la table [Distributed](/fr/reference/engines/table-engines/special/distributed) correspondante.
**Exemple**
Requête :
```sql theme={null}
CREATE TABLE x AS system.numbers ENGINE = MergeTree ORDER BY number;
CREATE TABLE x_dist AS x ENGINE = Distributed('test_cluster_two_shards_localhost', currentDatabase(), x);
INSERT INTO x_dist SELECT * FROM numbers(5) SETTINGS insert_shard_id = 1;
SELECT * FROM x_dist ORDER BY number ASC;
```
Résultat :
```text theme={null}
┌─number─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
│ 3 │
│ 3 │
│ 4 │
│ 4 │
└────────┘
```
## interactive\_delay
Intervalle, en microsecondes, auquel le système vérifie si l’exécution de la requête a été annulée et envoie la progression.
## intersect\_default\_mode
Définit le mode par défaut dans la requête INTERSECT. Valeurs possibles : chaîne vide, 'ALL', 'DISTINCT'. Si elle est vide, une requête sans mode lèvera une exception.
## jemalloc\_collect\_profile\_samples\_in\_trace\_log
Collecter les échantillons d’allocation et de désallocation de jemalloc dans le journal de trace.
## jemalloc\_enable\_profiler
Active le profileur jemalloc pour la requête. Jemalloc échantillonne les allocations ainsi que toutes les désallocations des allocations échantillonnées.
Les profils peuvent être vidés à l’aide de SYSTEM JEMALLOC FLUSH PROFILE, qui peut servir à l’analyse des allocations.
Les échantillons peuvent également être stockés dans system.trace\_log à l’aide de la config jemalloc\_collect\_global\_profile\_samples\_in\_trace\_log ou du paramètre de requête jemalloc\_collect\_profile\_samples\_in\_trace\_log.
Voir [le profilage des allocations](/fr/concepts/features/performance/allocation-profiling)
## jemalloc\_profile\_text\_collapsed\_use\_count
Lors de l’utilisation du format de sortie « collapsed » pour le heap profile jemalloc, agrège par nombre d’allocations plutôt que par octets. Lorsque false (par défaut), chaque pile est pondérée par le nombre d’octets actuellement alloués ; lorsque true, par le nombre d’allocations actives.
## jemalloc\_profile\_text\_output\_format
Format de sortie du heap profile jemalloc dans la table system.jemalloc\_profile\_text. Peut être : 'raw' (profil brut), 'symbolized' (format jeprof avec symboles) ou 'collapsed' (format FlameGraph).
## jemalloc\_profile\_text\_symbolize\_with\_inline
Indique s’il faut inclure les frames inline lors de la symbolisation du heap profile jemalloc. Lorsqu’il est activé, les frames inline sont incluses, ce qui peut ralentir considérablement le processus de symbolisation ; lorsqu’il est désactivé, elles sont ignorées. N’affecte que les formats de sortie 'symbolized' et 'collapsed'.
## join\_algorithm
Spécifie l'algorithme de [JOIN](/fr/reference/statements/select/join) utilisé.
Plusieurs algorithmes peuvent être spécifiés, et un algorithme disponible sera choisi pour une requête donnée en fonction du type, de la strictness et du moteur de table.
Valeurs possibles :
* grace\_hash
Le [grace hash join](https://en.wikipedia.org/wiki/Hash_join#Grace_hash_join) est utilisé. Grace hash offre une option d'algorithme permettant d'exécuter des jointures complexes de façon performante tout en limitant l'utilisation de la mémoire.
La première phase d'un grace join lit la table de droite et la répartit dans N buckets selon la valeur de hachage des colonnes clés (initialement, N vaut `grace_hash_join_initial_buckets`). Cela est fait de manière à garantir que chaque bucket puisse être traité indépendamment. Les lignes du premier bucket sont ajoutées à une table de hachage en mémoire, tandis que les autres sont enregistrées sur disque. Si la table de hachage dépasse la limite mémoire (par exemple, telle que définie par [`max_bytes_in_join`](/fr/reference/settings/session-settings#max_bytes_in_join), le nombre de buckets est augmenté, ainsi que le bucket assigné à chaque ligne. Toutes les lignes qui n'appartiennent pas au bucket actuel sont vidées sur disque et réaffectées.
Prend en charge `INNER/LEFT/RIGHT/FULL ALL/ANY JOIN`.
* hash
L'[algorithme de hash join](https://en.wikipedia.org/wiki/Hash_join) est utilisé. C'est l'implémentation la plus générique : elle prend en charge toutes les combinaisons de type et de strictness, ainsi que plusieurs clés de jointure combinées avec `OR` dans la section `JOIN ON`.
Lors de l'utilisation de l'algorithme `hash`, la partie droite de `JOIN` est chargée en RAM.
* parallel\_hash
Une variante de `hash` join qui répartit les données dans des buckets et construit plusieurs tables de hachage au lieu d'une seule, de manière concurrente, afin d'accélérer ce processus.
Lors de l'utilisation de l'algorithme `parallel_hash`, la partie droite de `JOIN` est chargée en RAM.
* partial\_merge
Une variante de l'[algorithme sort-merge](https://en.wikipedia.org/wiki/Sort-merge_join), dans laquelle seule la table de droite est entièrement triée.
Les `RIGHT JOIN` et `FULL JOIN` ne sont pris en charge qu'avec la strictness `ALL` (`SEMI`, `ANTI`, `ANY` et `ASOF` ne sont pas pris en charge).
Lors de l'utilisation de l'algorithme `partial_merge`, ClickHouse trie les données et les écrit sur disque. L'algorithme `partial_merge` dans ClickHouse diffère légèrement de l'implémentation classique. D'abord, ClickHouse trie la table de droite par clés de jointure en blocs et crée un index min-max pour les blocs triés. Ensuite, il trie des parties de la table de gauche par `join key` et les joint à la table de droite. L'index min-max est également utilisé pour ignorer les blocs inutiles de la table de droite.
* direct
L'algorithme `direct` (également appelé nested loop) effectue une recherche dans la table de droite en utilisant les lignes de la table de gauche comme clés.
Il est pris en charge par des moteurs de stockage spéciaux tels que [Dictionary](/fr/reference/engines/table-engines/special/dictionary), [EmbeddedRocksDB](/fr/reference/engines/table-engines/integrations/embedded-rocksdb) et les tables [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree).
Pour les tables MergeTree, l'algorithme pousse les filtres sur les clés de jointure directement vers la couche de stockage. Cela peut être plus efficace lorsque la clé peut utiliser l'index de clé primaire de la table pour les recherches ; sinon, il effectue des parcours complets de la table de droite pour chaque bloc de la table de gauche.
Prend en charge les jointures `INNER` et `LEFT`, et uniquement les clés de jointure d'égalité sur une seule colonne, sans autres conditions.
* auto
Lorsqu'il est défini sur `auto`, `hash` join est d'abord essayé, puis l'algorithme bascule à la volée vers un autre algorithme si la limite mémoire est dépassée.
* full\_sorting\_merge
[Algorithme sort-merge](https://en.wikipedia.org/wiki/Sort-merge_join) avec tri complet des tables jointes avant la jointure.
* prefer\_partial\_merge
ClickHouse essaie toujours d'utiliser `partial_merge` join si possible, sinon il utilise `hash`. *Déprécié*, identique à `partial_merge,hash`.
* default (déprécié)
Valeur héritée, veuillez ne plus l'utiliser.
Identique à `direct,hash`, c.-à-d. essayer d'utiliser direct join puis hash join (dans cet ordre).
## join\_any\_take\_last\_row
Modifie le comportement des opérations de jointure avec la strictness `ANY`.
Ce paramètre s’applique uniquement aux opérations `JOIN` avec des tables utilisant le moteur [Join](/fr/reference/engines/table-engines/special/join).
Valeurs possibles :
* 0 — Si la table de droite comporte plus d’une ligne correspondante, seule la première trouvée est utilisée pour la jointure.
* 1 — Si la table de droite comporte plus d’une ligne correspondante, seule la dernière trouvée est utilisée pour la jointure.
Voir aussi :
* [Clause JOIN](/fr/reference/statements/select/join)
* [Moteur de table Join](/fr/reference/engines/table-engines/special/join)
* [join\_default\_strictness](#join_default_strictness)
## join\_default\_strictness
Définit la strictness par défaut des [clauses JOIN](/fr/reference/statements/select/join).
Valeurs possibles :
* `ALL` — Si la table de droite comporte plusieurs lignes correspondantes, ClickHouse crée un [produit cartésien](https://en.wikipedia.org/wiki/Cartesian_product) à partir de ces lignes. Il s'agit du comportement `JOIN` normal en SQL standard.
* `ANY` — Si la table de droite comporte plusieurs lignes correspondantes, seule la première trouvée est utilisée pour la jointure. Si la table de droite n'a qu'une seule ligne correspondante, les résultats de `ANY` et `ALL` sont identiques.
* `ASOF` — Pour joindre des séquences avec une correspondance incertaine.
* `Chaîne vide` — Si `ALL` ou `ANY` n'est pas spécifié dans la requête, ClickHouse lève une exception.
## join\_on\_disk\_max\_files\_to\_merge
Limite le nombre de fichiers autorisés pour le tri parallèle lors des opérations MergeJoin exécutées sur disque.
Plus la valeur du paramètre est élevée, plus la RAM utilisée augmente et moins les E/S disque sont nécessaires.
Valeurs possibles :
* Tout entier positif à partir de 2.
## join\_output\_by\_rowlist\_perkey\_rows\_threshold
Seuil inférieur du nombre moyen de lignes par clé dans la table de droite permettant de déterminer s’il faut générer la sortie sous forme de liste de lignes dans un hash join.
## join\_overflow\_mode
Définit l’action que ClickHouse effectue lorsqu’une jointure atteint l’une des limites suivantes :
* [max\_bytes\_in\_join](/fr/reference/settings/session-settings#max_bytes_in_join)
* [max\_rows\_in\_join](/fr/reference/settings/session-settings#max_rows_in_join)
Ce paramètre n’est pris en compte que pour les valeurs `hash` et `parallel_hash` de
[`join_algorithm`](/fr/reference/settings/session-settings#join_algorithm). Les autres
algorithmes (par exemple, `partial_merge`, `grace_hash`, `auto`) gèrent ces
limites différemment — en déversant sur disque, en repartitionnant ou en changeant
de stratégie — voir
[`join_algorithm`](/fr/reference/settings/session-settings#join_algorithm).
Valeurs possibles :
* `THROW` — ClickHouse lève une exception et arrête la requête.
* `BREAK` — ClickHouse arrête la requête sans lever d’exception.
Valeur par défaut : `THROW`.
**Voir aussi**
* [clause JOIN](/fr/reference/statements/select/join)
* [moteur de table Join](/fr/reference/engines/table-engines/special/join)
## join\_runtime\_bloom\_filter\_bytes
Taille, en octets, du filtre de Bloom utilisé comme filtre d’exécution pour JOIN (voir le paramètre enable\_join\_runtime\_filters).
## join\_runtime\_bloom\_filter\_hash\_functions
Nombre de fonctions de hachage dans un filtre de Bloom utilisé comme filtre d’exécution de JOIN (voir le paramètre enable\_join\_runtime\_filters).
## join\_runtime\_bloom\_filter\_max\_ratio\_of\_set\_bits
Si la proportion de bits à 1 dans un filtre de Bloom d’exécution dépasse ce ratio, le filtre est entièrement désactivé afin de réduire la surcharge.
## join\_runtime\_filter\_blocks\_to\_skip\_before\_reenabling
Nombre de blocs ignorés avant de tenter de réactiver dynamiquement un filtre d’exécution précédemment désactivé en raison d’un taux de filtrage insuffisant.
## join\_runtime\_filter\_exact\_values\_limit
Nombre maximal d’éléments du filtre d’exécution stockés tels quels dans un ensemble ; au-delà de ce seuil, il passe à un filtre de Bloom.
## join\_runtime\_filter\_from\_fixed\_hash\_table
Lorsque le côté build du hash join est converti en FixedHashMap (voir `enable_join_fixed_hash_table_conversion`), cette table de hachage est utilisée directement comme filtre d’exécution.
## join\_runtime\_filter\_pass\_ratio\_threshold\_for\_disabling
Si le ratio entre le nombre de lignes retenues et le nombre de lignes vérifiées dépasse ce seuil, le filtre d’exécution est considéré comme peu performant et est désactivé pour les `join_runtime_filter_blocks_to_skip_before_reenabling` blocs suivants afin de réduire la surcharge.
## join\_to\_sort\_maximum\_table\_rows
Le nombre maximal de lignes de la table de droite permettant de déterminer s'il faut réordonner la table de droite par clé dans un LEFT JOIN ou un INNER JOIN.
## join\_to\_sort\_minimum\_perkey\_rows
Le seuil minimal du nombre moyen de lignes par clé dans la table de droite pour déterminer s’il faut réordonner la table de droite par clé dans un LEFT JOIN ou un INNER JOIN. Ce paramètre garantit que l’optimisation n’est pas appliquée aux clés de table peu denses
## join\_use\_nulls
Définit le comportement de [JOIN](/fr/reference/statements/select/join). Lors de la fusion de tables, des cellules vides peuvent apparaître. ClickHouse les remplit différemment selon ce paramètre.
Valeurs possibles :
* 0 — Les cellules vides sont remplies avec la valeur par défaut du type du champ correspondant.
* 1 — `JOIN` se comporte comme en SQL standard. Le type du champ correspondant est converti en [Nullable](/fr/reference/data-types/nullable), et les cellules vides sont remplies avec [NULL](/fr/reference/syntax).
## joined\_block\_split\_single\_row
Permet de découper le résultat du hash join en groupes de lignes correspondant chacune à une seule ligne de la table de gauche.
Cela peut réduire la consommation mémoire lorsqu’une ligne a de nombreuses correspondances dans la table de droite, mais peut augmenter l’utilisation du CPU.
Notez que `max_joined_block_size_rows != 0` est obligatoire pour que ce paramètre prenne effet.
Combiné à ce paramètre, `max_joined_block_size_bytes` est utile pour éviter une consommation mémoire excessive en cas de données déséquilibrées, lorsque certaines lignes volumineuses ont de nombreuses correspondances dans la table de droite.
## joined\_subquery\_requires\_alias
Exige que les sous-requêtes jointes et les fonctions de table aient des alias afin de garantir une qualification correcte des noms.
## kafka\_disable\_num\_consumers\_limit
Désactive la limite de kafka\_num\_consumers, qui dépend du nombre de cœurs CPU disponibles.
## kafka\_max\_wait\_ms
Le temps d’attente, en millisecondes, avant nouvelle tentative de lecture des messages depuis [Kafka](/fr/reference/engines/table-engines/integrations/kafka).
Valeurs possibles :
* Entier positif.
* 0 — Délai d’attente infini.
Voir aussi :
* [Apache Kafka](https://kafka.apache.org/)
## keeper\_map\_strict\_mode
Active des vérifications supplémentaires lors des opérations sur KeeperMap. Par exemple, déclenche une exception lors d'une insertion pour une clé déjà existante
## keeper\_max\_retries
Nombre maximal de tentatives pour les opérations générales de Keeper
## keeper\_retry\_initial\_backoff\_ms
Délai initial de backoff pour les opérations générales de Keeper
## keeper\_retry\_max\_backoff\_ms
Délai maximal de backoff pour les opérations générales de Keeper
## least\_greatest\_legacy\_null\_behavior
Si ce paramètre est activé, les fonctions 'least' et 'greatest' renvoient NULL si l'un de leurs arguments est NULL.
## legacy\_column\_name\_of\_tuple\_literal
Utilise tous les noms des éléments des grands littéraux de tuple comme noms de colonne au lieu d'un hash. Ce paramètre existe uniquement pour des raisons de compatibilité. Il est pertinent de le définir sur 'true' lors d'une mise à jour progressive du cluster depuis une version antérieure à 21.7 vers une version supérieure.
## lightweight\_delete\_mode
Mode de la requête interne de mise à jour exécutée dans le cadre d'une suppression légère.
Valeurs possibles :
* `alter_update` - exécute la requête `ALTER UPDATE`, qui crée une mutation lourde.
* `lightweight_update` - exécute une mise à jour légère si possible, sinon exécute `ALTER UPDATE`.
* `lightweight_update_force` - exécute une mise à jour légère si possible, sinon lève une exception.
## lightweight\_deletes\_sync
Identique à [`mutations_sync`](#mutations_sync), mais contrôle uniquement l'exécution des suppressions légères.
Valeurs possibles :
| Valeur | Description |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `0` | Les mutations s'exécutent de manière asynchrone. |
| `1` | La requête attend que les suppressions légères soient terminées sur le serveur actuel. |
| `2` | La requête attend que les suppressions légères soient terminées sur toutes les répliques (si elles existent). |
| `3` | La requête attend uniquement les répliques actives. Pris en charge uniquement pour `SharedMergeTree`. Pour `ReplicatedMergeTree`, le comportement est le même que `mutations_sync = 2`. |
**Voir aussi**
* [Synchronisation des requêtes ALTER](/fr/reference/statements/alter/index#synchronicity-of-alter-queries)
* [Mutations](/fr/reference/statements/alter/index#mutations)
Valeur par défaut dans Cloud : `1`.
## limit
Définit le nombre maximal de lignes à renvoyer dans le résultat de la requête. Cette valeur ajuste celle définie par la clause [LIMIT](/fr/reference/statements/select/limit), de sorte que la limite spécifiée dans la requête ne puisse pas dépasser celle définie par ce paramètre.
Valeurs possibles :
* 0 — Le nombre de lignes n'est pas limité.
* Entier positif.
## load\_balancing
Spécifie l'algorithme de sélection des répliques utilisé pour le traitement des requêtes distribuées.
ClickHouse prend en charge les algorithmes suivants pour sélectionner les répliques :
* [Random](#load_balancing-random) (par défaut)
* [Nearest hostname](#load_balancing-nearest_hostname)
* [Hostname levenshtein distance](#load_balancing-hostname_levenshtein_distance)
* [Hostname longest common prefix](#load_balancing-hostname_longest_common_prefix)
* [Hostname longest common suffix](#load_balancing-hostname_longest_common_suffix)
* [In order](#load_balancing-in_order)
* [First or random](#load_balancing-first_or_random)
* [Round robin](#load_balancing-round_robin)
Voir aussi :
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
### Random (par défaut)
```sql theme={null}
load_balancing = random
```
Le nombre d’erreurs est comptabilisé pour chaque réplique. La requête est envoyée à la réplique qui a le moins d’erreurs et, s’il y en a plusieurs, à n’importe laquelle d’entre elles.
Inconvénients : la proximité du serveur n’est pas prise en compte ; si les répliques contiennent des données différentes, vous obtiendrez également des données différentes.
### Nom d’hôte le plus proche
```sql theme={null}
load_balancing = nearest_hostname
```
Le nombre d’erreurs est compté pour chaque réplique. Toutes les 5 minutes, le nombre d’erreurs est divisé par 2 avec troncature à l’entier. Ainsi, le nombre d’erreurs est calculé sur une période récente avec un lissage exponentiel. S’il existe une réplique avec un nombre minimal d’erreurs (c.-à-d. que des erreurs se sont produites récemment sur les autres répliques), la requête lui est envoyée. S’il existe plusieurs répliques avec le même nombre minimal d’erreurs, la requête est envoyée à la réplique dont le nom d’hôte est le plus proche de celui du serveur dans le fichier de configuration (selon le nombre de caractères différents aux mêmes positions, jusqu’à la longueur minimale des deux noms d’hôte).
Par exemple, example01-01-1 et example01-01-2 diffèrent à une position, tandis que example01-01-1 et example01-02-2 diffèrent à deux positions.
Cette méthode peut sembler rudimentaire, mais elle ne nécessite pas de données externes sur la topologie du réseau et elle ne compare pas les adresses IP, ce qui serait compliqué avec nos adresses IPv6.
Ainsi, s’il existe des répliques équivalentes, celle dont le nom est le plus proche est privilégiée.
Nous pouvons également supposer que, lorsqu’une requête est envoyée au même serveur, en l’absence de défaillances, une requête distribuée ira elle aussi aux mêmes serveurs. Ainsi, même si les répliques contiennent des données différentes, la requête renverra globalement les mêmes résultats.
### Distance de Levenshtein du nom d’hôte
```sql theme={null}
load_balancing = hostname_levenshtein_distance
```
Comme `nearest_hostname`, mais compare le nom d’hôte à l’aide de la [distance de Levenshtein](https://en.wikipedia.org/wiki/Levenshtein_distance). Par exemple :
```text theme={null}
example-clickhouse-0-0 ample-clickhouse-0-0
1
example-clickhouse-0-0 example-clickhouse-1-10
2
example-clickhouse-0-0 example-clickhouse-12-0
3
```
### Plus long préfixe commun du nom d’hôte
```sql theme={null}
load_balancing = hostname_longest_common_prefix
```
Comme `nearest_hostname`, mais la réplique dont le nom d’hôte partage le préfixe commun le plus long avec le nom d’hôte local est privilégiée (plus le préfixe commun est long, plus la priorité est élevée). Contrairement à `nearest_hostname`, qui compare les caractères différents position par position, cette stratégie n'est pas trompée par des noms d’hôte dont les segments numériques ont des longueurs différentes. Par exemple, pour le nom d’hôte local `sfe301` :
```text theme={null}
sfe301 sde301
1
sfe301 sfe10101
3
sfe301 sde505
1
```
Ici, `sfe10101` est préféré, car il partage avec `sfe301` le préfixe commun le plus long (`sfe`, longueur 3).
Les répliques ayant la même longueur de préfixe commun sont choisies aléatoirement. En particulier, lorsqu’aucune réplique ne partage de préfixe avec le nom d’hôte local (toutes les longueurs de préfixe commun sont égales à zéro), cette stratégie se comporte exactement comme `random`.
### Plus long suffixe commun du nom d’hôte
```sql theme={null}
load_balancing = hostname_longest_common_suffix
```
Comme `hostname_longest_common_prefix`, mais on compare le plus long *suffixe* commun au lieu du préfixe. Cela est utile lorsque l’identité du centre de données est encodée dans le suffixe du nom d’hôte. Par exemple, pour le nom d’hôte local `et46gtghn.qc.localdomain` :
```text theme={null}
et46gtghn.qc.localdomain tr676ddgh.td.localdomain
12
et46gtghn.qc.localdomain ab999.qc.localdomain
15
```
Ici, `ab999.qc.localdomain` est privilégié, car il partage avec `et46gtghn.qc.localdomain` le suffixe commun le plus long (`.qc.localdomain`, longueur 15).
Les répliques ayant une longueur de suffixe commun identique sont choisies aléatoirement. En particulier, lorsqu’aucune réplique ne partage de suffixe avec le nom d’hôte local (toutes les longueurs de suffixe commun sont nulles), cette stratégie se comporte exactement comme `random`.
### Dans l’ordre
```sql theme={null}
load_balancing = in_order
```
Les répliques présentant le même nombre d'erreurs sont consultées dans le même ordre que celui dans lequel elles sont définies dans la configuration.
Cette méthode convient lorsque vous savez exactement quelle réplique privilégier.
### First or Random
```sql theme={null}
load_balancing = first_or_random
```
Cet algorithme choisit la première réplique de l’ensemble, ou une réplique aléatoire si la première n’est pas disponible. Il est efficace dans les topologies de réplication croisée, mais inutile dans les autres configurations.
L’algorithme `first_or_random` résout le problème de l’algorithme `in_order`. Avec `in_order`, si une réplique tombe en panne, la suivante reçoit une charge doublée, tandis que les autres répliques continuent de gérer le volume de trafic habituel. Avec l’algorithme `first_or_random`, la charge est répartie uniformément entre les répliques encore disponibles.
Il est possible de définir explicitement quelle est la première réplique à l’aide du paramètre `load_balancing_first_offset`. Cela permet de mieux contrôler le rééquilibrage de la charge des requêtes entre les répliques.
### Round Robin
```sql theme={null}
load_balancing = round_robin
```
Cet algorithme utilise une stratégie round-robin entre les répliques ayant le même nombre d’erreurs (seules les requêtes utilisant la stratégie `round_robin` sont prises en compte).
## load\_balancing\_first\_offset
Réplique à laquelle envoyer de préférence une query lorsque la stratégie de load balancing FIRST\_OR\_RANDOM est utilisée.
## load\_marks\_asynchronously
Charger les marks MergeTree de façon asynchrone
Valeur par défaut dans Cloud : `1`.
## local\_filesystem\_read\_method
Méthode de lecture des données depuis le système de fichiers local, parmi : read, pread, mmap, io\_uring, pread\_threadpool.
La méthode 'io\_uring' est expérimentale et ne fonctionne pas pour Log, TinyLog, StripeLog, File, Set et Join, ni pour les autres tables avec des fichiers auxquels on peut ajouter des données, en présence de lectures et d’écritures concurrentes.
Si vous lisez divers articles sur 'io\_uring' sur Internet, ne vous laissez pas aveugler par eux. Ce n’est pas une meilleure méthode de lecture des fichiers, sauf dans le cas d’un grand nombre de petites opérations d’E/S, ce qui n’est pas le cas dans ClickHouse. Il n’y a aucune raison d’activer 'io\_uring'.
## local\_filesystem\_read\_prefetch
Indique s’il faut utiliser le préchargement lors de la lecture de données à partir du système de fichiers local.
## lock\_acquire\_timeout
Définit le nombre de secondes pendant lesquelles une demande de verrouillage attend avant d’échouer.
Le délai d’expiration du verrouillage est utilisé pour se prémunir contre les deadlocks lors de l’exécution d’opérations de lecture/écriture sur des tables. Lorsque ce délai expire et que la demande de verrouillage échoue, le serveur ClickHouse lève une exception « Locking attempt timed out! Possible deadlock avoided. Client should retry. » avec le code d’erreur `DEADLOCK_AVOIDED`.
Valeurs possibles :
* Entier positif (en secondes).
* 0 — Aucun délai d’expiration du verrouillage.
Spécifie la valeur du champ `log_comment` de la table [system.query\_log](/fr/reference/system-tables/query_log), ainsi que le texte de commentaire du journal du serveur.
Il peut être utilisé pour améliorer la lisibilité des journaux du serveur. En outre, il permet de sélectionner les requêtes liées au test dans `system.query_log` après l’exécution de [clickhouse-test](/fr/resources/develop-contribute/contribute/tests).
Valeurs possibles :
* Toute chaîne de longueur inférieure ou égale à [max\_query\_size](#max_query_size). Si la valeur dépasse max\_query\_size, le serveur lève une exception.
**Exemple**
Requête :
```sql theme={null}
SET log_comment = 'log_comment test', log_queries = 1;
SELECT 1;
SYSTEM FLUSH LOGS;
SELECT type, query FROM system.query_log WHERE log_comment = 'log_comment test' AND event_date >= yesterday() ORDER BY event_time DESC LIMIT 2;
```
Résultat :
```text theme={null}
┌─type────────┬─query─────┐
│ QueryStart │ SELECT 1; │
│ QueryFinish │ SELECT 1; │
└─────────────┴───────────┘
```
## log\_formatted\_queries
Permet d’enregistrer les requêtes formatées dans la table système [system.query\_log](/fr/reference/system-tables/query_log) (renseigne la colonne `formatted_query` de [system.query\_log](/fr/reference/system-tables/query_log)).
Valeurs possibles :
* 0 — Les requêtes formatées ne sont pas enregistrées dans la table système.
* 1 — Les requêtes formatées sont enregistrées dans la table système.
## log\_processors\_profiles
Écrit dans la table `system.processors_profile_log` le temps passé par le processeur à s'exécuter ou à attendre des données.
Voir aussi :
* [`system.processors_profile_log`](/fr/reference/system-tables/processors_profile_log)
* [`EXPLAIN PIPELINE`](/fr/reference/statements/explain#explain-pipeline)
## log\_profile\_events
Consigne les statistiques de performance des requêtes dans query\_log, query\_thread\_log et query\_views\_log.
## log\_queries
Active la journalisation des requêtes.
Les requêtes envoyées à ClickHouse avec ce paramètre sont journalisées conformément aux règles du paramètre de configuration du serveur [query\_log](/fr/reference/settings/server-settings/settings#query_log).
Exemple :
```text theme={null}
log_queries=1
```
## log\_queries\_cut\_to\_length
Si la longueur de la requête dépasse le seuil spécifié (en octets), la requête est tronquée lors de son écriture dans le journal des requêtes. La longueur de la requête affichée dans le journal texte ordinaire est également limitée.
## log\_queries\_min\_query\_duration\_ms
Si ce paramètre est activé (non nul), les requêtes dont la durée est inférieure à la valeur définie ne seront pas journalisées (vous pouvez voir cela comme un `long_query_time` pour le [journal des requêtes lentes de MySQL](https://dev.mysql.com/doc/refman/5.7/slow-query-log.html)), ce qui signifie, en pratique, que vous ne les trouverez pas dans les tables suivantes :
* `system.query_log`
* `system.query_thread_log`
Seules les requêtes du type suivant seront consignées dans le journal :
* `QUERY_FINISH`
* `EXCEPTION_WHILE_PROCESSING`
* Type : millisecondes
* Valeur par défaut : 0 (toute requête)
## log\_queries\_min\_type
Type minimal à journaliser dans `query_log`.
Valeurs possibles :
* `QUERY_START` (`=1`)
* `QUERY_FINISH` (`=2`)
* `EXCEPTION_BEFORE_START` (`=3`)
* `EXCEPTION_WHILE_PROCESSING` (`=4`)
Peut être utilisé pour limiter les entités qui seront consignées dans `query_log` ; par exemple, si vous ne vous intéressez qu’aux erreurs, vous pouvez utiliser `EXCEPTION_WHILE_PROCESSING` :
```text theme={null}
log_queries_min_type='EXCEPTION_WHILE_PROCESSING'
```
## log\_queries\_probability
Permet d’enregistrer dans les tables système [query\_log](/fr/reference/system-tables/query_log), [query\_thread\_log](/fr/reference/system-tables/query_thread_log) et [query\_views\_log](/fr/reference/system-tables/query_views_log) uniquement un échantillon de requêtes sélectionnées aléatoirement selon la probabilité spécifiée. Cela permet de réduire la charge lorsqu’il y a un grand volume de requêtes par seconde.
Valeurs possibles :
* 0 — Les requêtes ne sont pas enregistrées dans les tables système.
* Nombre à virgule flottante positif compris dans l’intervalle \[0..1]. Par exemple, si la valeur du paramètre est `0.5`, environ la moitié des requêtes sont enregistrées dans les tables système.
* 1 — Toutes les requêtes sont enregistrées dans les tables système.
## log\_query\_settings
Enregistre les paramètres de la requête dans `query_log` et dans le journal des spans OpenTelemetry.
## log\_query\_threads
Active la journalisation des threads de requête.
Les threads de requête sont journalisés dans la table [system.query\_thread\_log](/fr/reference/system-tables/query_thread_log). Ce paramètre ne prend effet que lorsque [log\_queries](#log_queries) vaut `true`. Les threads des requêtes exécutées par ClickHouse lorsque ce paramètre est activé sont journalisés selon les règles définies par le paramètre de configuration du serveur [query\_thread\_log](/fr/reference/settings/server-settings/settings#query_thread_log).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
**Exemple**
```text theme={null}
log_query_threads=1
```
## log\_query\_views
Active la journalisation des vues de requête.
Lorsqu’une requête exécutée par ClickHouse avec ce paramètre activé est associée à des vues (vues matérialisées ou live views), celles-ci sont journalisées dans le paramètre de configuration du serveur [query\_views\_log](/fr/reference/settings/server-settings/settings#query_views_log).
Exemple :
```text theme={null}
log_query_views=1
```
## low\_cardinality\_allow\_in\_native\_format
Autorise ou limite l’utilisation du type de données [LowCardinality](/fr/reference/data-types/lowcardinality) avec le format [Native](/fr/reference/formats/Native).
Si l’utilisation de `LowCardinality` est limitée, serveur ClickHouse convertit les colonnes `LowCardinality` en colonnes ordinaires pour les requêtes `SELECT`, et les colonnes ordinaires en colonnes `LowCardinality` pour les requêtes `INSERT`.
Ce paramètre est principalement nécessaire pour les clients tiers qui ne prennent pas en charge le type de données `LowCardinality`.
Valeurs possibles :
* 1 — L’utilisation de `LowCardinality` n’est pas limitée.
* 0 — L’utilisation de `LowCardinality` est limitée.
## low\_cardinality\_max\_dictionary\_size
Définit le nombre maximal de lignes d’un dictionnaire global partagé pour le type de données [LowCardinality](/fr/reference/data-types/lowcardinality) pouvant être écrit dans le système de fichiers de stockage. Ce paramètre permet d’éviter les problèmes de RAM en cas de croissance illimitée du dictionnaire. Toutes les données qui ne peuvent pas être encodées en raison de cette limite de taille du dictionnaire sont écrites par ClickHouse de façon classique.
Valeurs possibles :
* Tout entier positif.
## low\_cardinality\_use\_single\_dictionary\_for\_part
Active ou désactive l’utilisation d’un dictionnaire unique pour une partie de données.
Par défaut, le serveur ClickHouse surveille la taille des dictionnaires et, si un dictionnaire dépasse sa limite, le serveur commence à écrire le suivant. Pour empêcher la création de plusieurs dictionnaires, définissez `low_cardinality_use_single_dictionary_for_part = 1`.
Valeurs possibles :
* 1 — La création de plusieurs dictionnaires pour la partie de données est interdite.
* 0 — La création de plusieurs dictionnaires pour la partie de données n’est pas interdite.
## low\_priority\_query\_wait\_time\_ms
Lorsque le mécanisme de priorisation des requêtes est utilisé (voir le paramètre `priority`), les requêtes de faible priorité attendent la fin des requêtes de priorité plus élevée. Ce paramètre définit cette durée d'attente.
## make\_distributed\_plan
Génère un plan de requête distribuée.
## materialize\_skip\_indexes\_on\_insert
Définit si les INSERT créent et stockent des index de saut. Si cette option est désactivée, les index de saut ne seront créés et stockés que [lors des fusions](/fr/reference/settings/merge-tree-settings#materialize_skip_indexes_on_merge) ou via un [MATERIALIZE INDEX](/fr/reference/statements/alter/skipping-index#materialize-index) explicite.
Voir aussi [exclude\_materialize\_skip\_indexes\_on\_insert](#exclude_materialize_skip_indexes_on_insert).
## materialize\_statistics\_on\_insert
Indique si les INSERT créent et insèrent des statistiques. Si cette option est désactivée, les statistiques seront créées et stockées lors des fusions ou via un MATERIALIZE STATISTICS explicite
## materialize\_ttl\_after\_modify
Appliquer le TTL aux anciennes données après la requête ALTER MODIFY TTL
## materialized\_views\_ignore\_errors
Si ce paramètre est activé, les exceptions levées lors de l'envoi de données vers une vue matérialisée dépendante (dans son `SELECT` ou dans le sink de la table interne) sont consignées comme avertissement, et l'instruction `INSERT` réussit. S'il est désactivé (par défaut), une telle exception se propage et l'instruction `INSERT` échoue.
Ce paramètre contrôle uniquement le signalement des erreurs. Il n'annule pas une écriture dans la table source et ne garantit pas non plus que le block d'origine ait déjà été validé dans la table source lorsqu'une erreur survient dans le pipeline d'une vue dépendante. Lorsqu'il est désactivé (par défaut), l'`INSERT` échoue en cas d'erreur sur une vue — relancez-le avec la déduplication d'insertion (`insert_deduplicate`, `deduplicate_blocks_in_dependent_materialized_views`) pour une livraison exactly-once vers la table source et toutes les vues dépendantes. Lorsqu'il est activé, l'`INSERT` est signalé comme réussi malgré une livraison partielle aux vues en échec et à leurs chaînes en aval ; n'utilisez ce mode que lorsque les écritures dans la table source ne doivent pas être bloquées par des problèmes côté vue (par exemple, les tables `system.*_log`). Consultez la documentation `CREATE VIEW` pour obtenir la sémantique complète.
## materialized\_views\_squash\_parallel\_inserts
Fusionne les inserts parallèles d'une même requête INSERT vers la table de destination des vues matérialisées afin de réduire le nombre de parts générées.
Si cette valeur est définie sur false et que `parallel_view_processing` est activé, la requête INSERT générera une part dans la table de destination pour chaque `max_insert_thread`.
## max\_analyze\_depth
Nombre maximal d’analyses réalisées par l’interpréteur.
## max\_ast\_depth
La profondeur maximale d’imbrication de l’arbre syntaxique d’une requête. Si cette limite est dépassée, une exception est levée.
À l’heure actuelle, cette profondeur n’est pas contrôlée lors de l’analyse syntaxique, mais seulement après l’analyse de la requête.
Cela signifie qu’un arbre syntaxique trop profond peut être créé pendant l’analyse syntaxique,
mais la requête échouera.
## max\_ast\_elements
Le nombre maximal d’éléments dans l’arbre syntaxique d’une requête. Si cette limite est dépassée, une exception est levée.
À l’heure actuelle, cette limite n’est pas vérifiée lors de l’analyse syntaxique, mais seulement après l’analyse de la requête.
Cela signifie qu’un arbre syntaxique trop profond peut être créé pendant l’analyse syntaxique,
mais que la requête échouera.
## max\_autoincrement\_series
Limite du nombre de séries créées par la fonction `generateSerialID`.
Chaque série représentant un nœud dans Keeper, il est recommandé de ne pas en avoir plus de quelques millions.
## bande\_passante\_max\_backup
La vitesse de lecture maximale, en octets par seconde, pour une sauvegarde donnée sur le serveur. Zéro signifie qu'il n'y a pas de limite.
## max\_block\_size
Dans ClickHouse, les données sont traitées par blocs, qui sont des ensembles de fragments de colonnes. Les cycles de traitement internes d’un bloc unique sont efficaces, mais le traitement de chaque bloc entraîne des surcoûts notables.
Le paramètre `max_block_size` indique le nombre maximal recommandé de lignes à inclure dans un bloc unique lors du chargement de données à partir de tables. Des blocs de la taille de `max_block_size` ne sont pas toujours chargés depuis la table : si ClickHouse détermine qu’il faut récupérer moins de données, un bloc plus petit est traité.
La taille du bloc ne doit pas être trop petite, afin d’éviter des surcoûts notables lors du traitement de chaque bloc. Elle ne doit pas non plus être trop grande, afin de garantir que les requêtes avec une clause LIMIT s’exécutent rapidement après le traitement du premier bloc. Lors du paramétrage de `max_block_size`, l’objectif est d’éviter une consommation excessive de mémoire lors de l’extraction d’un grand nombre de colonnes dans plusieurs threads, tout en préservant au moins un certain degré de localité de cache.
## max\_bytes\_before\_external\_group\_by
Valeur par défaut dans Cloud : la moitié de la mémoire disponible par réplique.
Active ou désactive l'exécution des clauses `GROUP BY` en mémoire externe.
(Voir [GROUP BY en mémoire externe](/fr/reference/statements/select/group-by#group-by-in-external-memory))
Valeurs possibles :
* Volume maximal de RAM (en octets) pouvant être utilisé par une seule opération [GROUP BY](/fr/reference/statements/select/group-by).
* `0` — `GROUP BY` en mémoire externe désactivé.
Si l'utilisation de la mémoire lors des opérations GROUP BY dépasse ce seuil en octets,
activez le mode d'« agrégation externe » (écriture des données intermédiaires sur le disque).
La valeur recommandée est la moitié de la mémoire système disponible.
## max\_bytes\_before\_external\_join
Si une valeur non nulle est définie et que `join_algorithm` vaut `hash`, `parallel_hash`, `default` ou `auto`, le hash join sera automatiquement converti en grace hash join afin d'autoriser le spilling sur disque lorsque les données du côté droit dépassent ce nombre d'octets. Lorsqu'il est défini sur 0 (valeur par défaut), ce seuil absolu en octets est désactivé, mais le spilling automatique peut toujours se produire via `max_bytes_ratio_before_external_join` (qui vaut par défaut `0.5`) ; définissez les deux sur `0` pour désactiver complètement le spilling automatique. Cela empêche l'optimisation de lecture ordonnée via join.
## max\_bytes\_before\_external\_sort
Valeur par défaut dans Cloud : la moitié de la mémoire par réplique.
Active ou désactive l’exécution des clauses `ORDER BY` en mémoire externe. Voir [Détails d’implémentation de ORDER BY](/fr/reference/statements/select/order-by#implementation-details)
Si l’utilisation de la mémoire pendant l’opération `ORDER BY` dépasse ce seuil en octets, le mode de « tri externe » (écriture des données sur disque) est activé.
Valeurs possibles :
* Volume maximal de RAM (en octets) pouvant être utilisé par une seule opération [ORDER BY](/fr/reference/statements/select/order-by).
La valeur recommandée est la moitié de la mémoire système disponible.
* `0` — `ORDER BY` en mémoire externe désactivé.
## max\_bytes\_before\_remerge\_sort
Dans le cas d’un ORDER BY avec LIMIT, lorsque l’utilisation de la mémoire dépasse le seuil spécifié, des étapes supplémentaires de fusion de blocs sont effectuées avant la fusion finale afin de ne conserver que les LIMIT lignes en tête.
## max\_bytes\_for\_lazy\_final
Nombre maximal d’octets de l’ensemble pour l’optimisation lazy de FINAL. Si cette valeur est dépassée, le système revient à FINAL normal.
## max\_bytes\_in\_distinct
Le nombre maximal d’octets de l’état (en octets non compressés) en mémoire utilisé
par une table de hachage lors de l’utilisation de DISTINCT.
## max\_bytes\_in\_join
La taille maximale, en octets, de la structure de données du côté droit (généralement une table de hachage) utilisée pour les jointures de tables.
Ce paramètre s’applique aux opérations [SELECT ... JOIN](/fr/reference/statements/select/join) et au [moteur de table Join](/fr/reference/engines/table-engines/special/join).
Si une requête contient plusieurs jointures, ClickHouse vérifie ce paramètre pour chaque résultat intermédiaire. Lorsque la limite est atteinte, l’action dépend de l’algorithme [`join_algorithm`](/fr/reference/settings/session-settings#join_algorithm) choisi — consultez ce paramètre pour connaître le comportement propre à chaque algorithme (spill, repartitionnement, switch, ou throw/break selon [`join_overflow_mode`](/fr/reference/settings/session-settings#join_overflow_mode)).
Valeurs possibles :
* Entier positif.
* 0 — Le contrôle de la mémoire est désactivé.
## max\_bytes\_in\_set
Le nombre maximal d’octets (de données non compressées) utilisés par un ensemble de la clause IN
créé à partir d’une sous-requête.
## max\_bytes\_ratio\_before\_external\_group\_by
Part de la mémoire disponible pouvant être utilisée pour `GROUP BY`. Une fois cette limite atteinte,
la mémoire externe est utilisée pour l’agrégation.
Par exemple, si elle est définie sur `0.6`, `GROUP BY` pourra utiliser 60 % de la mémoire disponible
(pour server/user/merges) au début de l’exécution, puis il
commencera à utiliser l’agrégation externe.
## max\_bytes\_ratio\_before\_external\_join
Le ratio de mémoire disponible autorisé pour `JOIN`. Une fois ce seuil atteint, le hash join est converti en grace hash join afin de décharger sur disque les données du côté droit.
Par exemple, si la valeur est définie sur `0.6`, `JOIN` autorisera l'utilisation de `60%` de la mémoire disponible (pour server/user/merges) pour la table de hachage du côté droit au début de l'exécution ; au-delà, le spilling sur disque commence.
Si `max_bytes_before_external_join` et `max_bytes_ratio_before_external_join` sont tous deux définis, le plus petit seuil obtenu est utilisé. Si le ratio est `0`, seul le paramètre absolu s'applique.
N'a d'effet que lorsque `join_algorithm` vaut `hash`, `parallel_hash`, `default` ou `auto`, et qu'un chemin de données temporaires est configuré.
## max\_bytes\_ratio\_before\_external\_sort
La part de mémoire disponible pouvant être utilisée par `ORDER BY`. Une fois cette limite atteinte, un tri externe est utilisé.
Par exemple, si cette valeur est définie sur `0.6`, `ORDER BY` pourra utiliser `60%` de la mémoire disponible (pour le serveur/l’utilisateur/les fusions) au début de l’exécution ; ensuite, il commencera à utiliser un tri externe.
Notez que `max_bytes_before_external_sort` est toujours respecté : le spilling sur disque n’a lieu que si le bloc de tri est plus grand que `max_bytes_before_external_sort`.
## max\_bytes\_to\_read
Le nombre maximal d’octets (de données non compressées) pouvant être lus à partir d’une table lors de l’exécution d’une requête.
La restriction est vérifiée pour chaque fragment de données traité, s’applique uniquement à l’expression de table
la plus interne et, lors d’une lecture depuis un serveur distant, n’est vérifiée que sur
le serveur distant.
## max\_bytes\_to\_read\_leaf
Le nombre maximal d’octets (de données non compressées) pouvant être lus depuis une
table locale sur un nœud feuille lors de l’exécution d’une requête distribuée. Bien que les requêtes distribuées
puissent envoyer plusieurs sous-requêtes à chaque shard (feuille), cette limite ne sera
vérifiée qu’à l’étape de lecture sur les nœuds feuille et sera ignorée lors de
la fusion des résultats sur le nœud racine.
Par exemple, un cluster se compose de 2 shards et chaque shard contient une table avec
100 octets de données. Une requête distribuée censée lire toutes les données
des deux tables avec le paramètre `max_bytes_to_read=150` échouera, car le total
sera de 200 octets. Une requête avec `max_bytes_to_read_leaf=150` réussira, puisque les
nœuds feuille liront au maximum 100 octets.
La restriction est vérifiée pour chaque fragment de données traité.
Ce paramètre est instable avec `prefer_localhost_replica=1`.
## max\_bytes\_to\_sort
Le nombre maximal d’octets avant le tri. Si plus que la quantité spécifiée
d’octets non compressés doit être traitée pour l’opération ORDER BY, le comportement sera
déterminé par `sort_overflow_mode`, qui est défini par défaut sur `throw`.
## max\_bytes\_to\_transfer
Le nombre maximal d’octets (données non compressées) pouvant être transmis à un server distant
ou enregistrés dans une table temporaire lors de l’exécution de la section GLOBAL IN/JOIN.
## max\_columns\_to\_read
Le nombre maximal de colonnes pouvant être lues dans une table lors d'une seule requête.
Si une requête nécessite de lire plus de colonnes que le nombre spécifié, une exception
est levée.
Ce paramètre est utile pour éviter les requêtes trop complexes.
La valeur `0` signifie qu'il n'y a pas de limite.
## max\_compress\_block\_size
La taille maximale des blocs de données non compressées avant leur compression pour l’écriture dans une table. Par défaut, 1 048 576 (1 MiB). Indiquer une taille de bloc plus petite entraîne généralement une légère baisse du taux de compression ; la vitesse de compression et de décompression augmente légèrement grâce à une meilleure localité du cache, et la consommation de mémoire diminue.
Il s’agit d’un paramètre de niveau expert, et vous ne devriez pas le modifier si vous débutez avec ClickHouse.
Ne confondez pas les blocs utilisés pour la compression (un fragment de mémoire constitué d’octets) avec les blocs utilisés pour le traitement des requêtes (un ensemble de lignes d’une table).
## max\_concurrent\_queries\_for\_all\_users
Déclenche une exception si la valeur de ce paramètre est inférieure ou égale au nombre actuel de requêtes traitées simultanément.
Exemple : `max_concurrent_queries_for_all_users` peut être défini sur 99 pour tous les utilisateurs, et l’administrateur de la base de données peut le définir sur 100 pour lui-même afin de pouvoir exécuter des requêtes d’investigation même lorsque le serveur est surchargé.
La modification de ce paramètre pour une requête ou un utilisateur n’affecte pas les autres requêtes.
Valeurs possibles :
* Entier positif.
* 0 — Aucune limite.
**Exemple**
```xml theme={null}
99
```
**Voir aussi**
* [max\_concurrent\_queries](/fr/reference/settings/server-settings/settings#max_concurrent_queries)
valeur par défaut dans Cloud : `1000`.
## max\_concurrent\_queries\_for\_user
Nombre maximal de requêtes traitées simultanément par utilisateur.
Valeurs possibles :
* Entier positif.
* 0 — Aucune limite.
**Exemple**
```xml theme={null}
5
```
## max\_consume\_snapshots
Nombre maximal de snapshots Paimon à consommer lors d'une lecture incrémentielle. 0 signifie qu'il n'y a pas de limite.
## max\_distributed\_connections
Le nombre maximal de connexions simultanées aux serveurs distants pour le traitement distribué d’une seule requête sur une seule table Distributed. Nous recommandons de définir une valeur au moins égale au nombre de serveurs du cluster.
Les paramètres suivants ne sont utilisés que lors de la création de tables Distributed (et au démarrage d’un serveur) ; il n’y a donc aucune raison de les modifier à l’exécution.
## max\_distributed\_depth
Limite la profondeur maximale des requêtes récursives pour les tables [Distributed](/fr/reference/engines/table-engines/special/distributed).
Si cette valeur est dépassée, le serveur lève une exception.
Valeurs possibles :
* Entier positif.
* 0 — Profondeur illimitée.
## max\_download\_buffer\_size
La taille maximale du tampon de téléchargement parallèle (par exemple pour le moteur URL) pour chaque thread.
## max\_download\_threads
Le nombre maximal de threads pour le téléchargement de données (par exemple avec le moteur URL).
## max\_estimated\_execution\_time
Temps d’exécution estimé maximal de la requête, en secondes. Contrôlé sur chaque bloc de données
à l’expiration de [`timeout_before_checking_execution_speed`](/fr/reference/settings/session-settings#timeout_before_checking_execution_speed).
## max\_execution\_speed
Le nombre maximal de lignes exécutées par seconde. Cette valeur est vérifiée sur chaque bloc de données lorsque
[`timeout_before_checking_execution_speed`](/fr/reference/settings/session-settings#timeout_before_checking_execution_speed)
expire. Si la vitesse d’exécution est trop élevée, elle sera réduite.
## max\_execution\_speed\_bytes
Nombre maximal d’octets traités par seconde. Cette limite est vérifiée sur chaque bloc de données lorsque
[`timeout_before_checking_execution_speed`](/fr/reference/settings/session-settings#timeout_before_checking_execution_speed)
expire. Si la vitesse d’exécution est trop élevée, elle sera réduite.
## max\_execution\_time
Le temps d’exécution maximal de la requête, en secondes.
Le paramètre `max_execution_time` peut être un peu délicat à comprendre.
Il fonctionne à partir d’une interpolation relative à la vitesse d’exécution actuelle de la requête
(ce comportement est contrôlé par [`timeout_before_checking_execution_speed`](/fr/reference/settings/session-settings#timeout_before_checking_execution_speed)).
ClickHouse interrompt une requête si le temps d’exécution estimé dépasse la valeur
de `max_execution_time` spécifiée. Par défaut, `timeout_before_checking_execution_speed`
est défini sur 10 secondes. Cela signifie qu’après 10 secondes d’exécution de la requête, ClickHouse
commence à estimer le temps d’exécution total. Si, par exemple, `max_execution_time`
est défini sur 3600 secondes (1 heure), ClickHouse arrête la requête si la durée estimée
dépasse cette limite de 3600 secondes. Si vous définissez `timeout_before_checking_execution_speed`
sur 0, ClickHouse utilisera le temps écoulé comme base pour `max_execution_time`.
Si le temps d’exécution de la requête dépasse le nombre de secondes spécifié, le comportement est
déterminé par `timeout_overflow_mode`, qui est défini par défaut sur `throw`.
Le délai d’expiration n’est vérifié, et la requête ne peut donc s’arrêter, qu’à certains points précis du traitement des données.
Actuellement, elle ne peut pas s’arrêter pendant la fusion des états d’agrégation ni pendant l’analyse de la requête,
et le temps d’exécution réel sera supérieur à la valeur de ce paramètre.
## max\_execution\_time\_leaf
Sémantiquement similaire à [`max_execution_time`](#max_execution_time), mais
s’applique uniquement aux nœuds feuilles pour les requêtes distribuées ou distantes.
Par exemple, si nous voulons limiter le temps d’exécution sur un nœud feuille à `10s` sans
imposer de limite sur le nœud initial, au lieu de définir `max_execution_time` dans les
paramètres de la sous-requête imbriquée :
```sql theme={null}
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t SETTINGS max_execution_time = 10));
```
Nous pouvons utiliser `max_execution_time_leaf` dans les paramètres de la requête :
```sql theme={null}
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t)) SETTINGS max_execution_time_leaf = 10;
```
## max\_expanded\_ast\_elements
Taille maximale de l’arbre syntaxique de la requête, en nombre de nœuds, après développement des alias et de l’astérisque.
## max\_fetch\_partition\_retries\_count
Nombre de tentatives pour récupérer une partition depuis un autre hôte.
## max\_final\_threads
Définit le nombre maximal de threads parallèles pour la phase de lecture des données de la requête `SELECT` avec le modificateur [FINAL](/fr/reference/statements/select/from#final-modifier).
Valeurs possibles :
* Entier positif.
* 0 ou 1 — Désactivé. Les requêtes `SELECT` sont exécutées sur un seul thread.
## max\_http\_get\_redirects
Nombre maximal de sauts de redirection HTTP GET autorisés. Garantit la mise en place de mesures de sécurité supplémentaires pour empêcher un serveur malveillant de rediriger vos requêtes vers des services inattendus.\n\nCela se produit lorsqu’un serveur externe redirige vers une autre adresse, mais que cette adresse semble appartenir à l’infrastructure interne de l’entreprise. En envoyant une requête HTTP à un serveur interne, vous pourriez alors appeler une API interne depuis le réseau interne, contourner l’authentification, voire interroger d’autres services, tels que Redis ou Memcached. Si vous n’avez pas d’infrastructure interne (y compris un service exécuté sur votre localhost) ou si vous faites confiance au serveur, vous pouvez autoriser les redirections sans risque. Gardez toutefois à l’esprit que, si l’URL utilise HTTP plutôt que HTTPS, vous devrez faire confiance non seulement au serveur distant, mais aussi à votre FAI et à tous les réseaux intermédiaires.
valeur par défaut dans Cloud : `10`.
## max\_hyperscan\_regexp\_length
Définit la longueur maximale autorisée pour chaque expression régulière dans les [fonctions hyperscan multi-match](/fr/reference/functions/regular-functions/string-search-functions#multiMatchAny).
Valeurs possibles :
* Entier positif.
* 0 - La longueur n'est pas limitée.
**Exemple**
Requête :
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 3;
```
Résultat :
```text theme={null}
┌─multiMatchAny('abcd', ['ab', 'bcd', 'c', 'd'])─┐
│ 1 │
└────────────────────────────────────────────────┘
```
Requête :
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 2;
```
Résultat :
```text theme={null}
Exception: Regexp length too large.
```
**Voir aussi**
* [max\_hyperscan\_regexp\_total\_length](#max_hyperscan_regexp_total_length)
## max\_hyperscan\_regexp\_total\_length
Définit la longueur totale maximale de toutes les expressions régulières pour chaque [fonction hyperscan multi-match](/fr/reference/functions/regular-functions/string-search-functions#multiMatchAny).
Valeurs possibles :
* Entier positif.
* 0 - La longueur n'est pas limitée.
**Exemple**
Requête :
```sql theme={null}
SELECT multiMatchAny('abcd', ['a','b','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
```
Résultat :
```text theme={null}
┌─multiMatchAny('abcd', ['a', 'b', 'c', 'd'])─┐
│ 1 │
└─────────────────────────────────────────────┘
```
Requête :
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bc','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
```
Résultat :
```text theme={null}
Exception: Total regexp lengths too large.
```
**Voir aussi**
* [max\_hyperscan\_regexp\_length](#max_hyperscan_regexp_length)
## max\_insert\_block\_size
**Alias** : `max_insert_block_size_rows`
La taille maximale des blocs (en nombre de lignes) à former pour l'insertion dans une table.
Ce paramètre contrôle la formation des blocs dans deux contextes :
1. Analyse des formats : lorsque le serveur analyse des formats d'entrée basés sur les lignes (CSV, TSV, JSONEachRow, etc.) depuis n'importe quelle interface (HTTP, clickhouse-client avec des données intégrées, gRPC, protocole wire PostgreSQL), les blocs sont émis lorsque :
* Les deux seuils min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes sont atteints, OR
* L'un des seuils max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes est atteint
Remarque : lors de l'utilisation de clickhouse-client ou clickhouse-local pour lire depuis un fichier, le client analyse lui-même les données, et ce paramètre s'applique côté client.
2. Opérations INSERT : pendant les requêtes INSERT et lorsque les données transitent par des vues matérialisées, le comportement de ce paramètre dépend de `use_strict_insert_block_limits` :
* Lorsqu'il est activé : les blocs sont émis lorsque :
* Seuils minimums (AND) : les deux seuils min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes sont atteints
* Seuils maximums (OR) : l'un des seuils max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes est atteint
* Lorsqu'il est désactivé : les blocs sont émis lorsque min\_insert\_block\_size\_rows OR min\_insert\_block\_size\_bytes est atteint. Les paramètres max\_insert\_block\_size ne sont pas appliqués.
Valeurs possibles :
* Entier positif.
## max\_insert\_block\_size\_bytes
Taille maximale, en octets, des blocs à former pour l’insertion dans une table.
Ce paramètre fonctionne de concert avec max\_insert\_block\_size\_rows et contrôle la formation des blocs dans le même contexte. Voir max\_insert\_block\_size\_rows pour des informations détaillées sur le moment et la manière dont ces paramètres sont appliqués.
Valeurs possibles :
* Entier positif.
* 0 — le paramètre ne participe pas à la formation des blocs.
## max\_insert\_delayed\_streams\_for\_parallel\_write
Le nombre maximal de flux (colonnes) pour lesquels retarder le flush final de la part. Valeur par défaut : auto (100 si le stockage sous-jacent prend en charge l’écriture parallèle, par exemple S3, et désactivé sinon)
Valeur par défaut Cloud : `50`.
## max\_insert\_threads
Le nombre maximal de threads pour exécuter la requête `INSERT SELECT`.
Valeurs possibles :
* 0 (ou 1) — aucune exécution en parallèle de `INSERT SELECT`.
* Entier positif, supérieur à 1.
Valeur par défaut dans Cloud :
* `1` pour les nœuds disposant de 8 Gio de mémoire
* `2` pour les nœuds disposant de 16 Gio de mémoire
* `4` pour les nœuds plus grands
L’exécution en parallèle de `INSERT SELECT` n’a d’effet que si la partie `SELECT` est elle aussi exécutée en parallèle ; voir le paramètre [`max_threads`](#max_threads).
Des valeurs plus élevées entraînent une utilisation de la mémoire plus importante.
## max\_insert\_threads\_min\_free\_memory\_per\_thread
Identique à `max_threads_min_free_memory_per_thread`, mais appliqué à `max_insert_threads` au lieu de `max_threads`. La valeur par défaut est plus élevée, car les pipelines d’insertion utilisent généralement des tampons par thread plus volumineux (parties MergeTree, blocs de compression) que les pipelines de lecture.
Si la quantité de mémoire libre est inférieure à `max_insert_threads` multiplié par cette valeur, `max_insert_threads` est réduit en conséquence, avec un minimum de `1`.
Définissez cette valeur sur `0` pour désactiver cette limite.
## max\_joined\_block\_size\_bytes
Taille maximale du bloc, en octets, pour le résultat du JOIN (si l'algorithme de jointure le prend en charge). 0 signifie sans limite.
## max\_joined\_block\_size\_rows
Taille maximale du bloc pour le résultat du JOIN (si l'algorithme de jointure le prend en charge). 0 signifie sans limite.
## max\_limit\_for\_vector\_search\_queries
Les requêtes SELECT dont le LIMIT est supérieur à ce paramètre ne peuvent pas utiliser les index de similarité vectorielle. Cela permet d'éviter les dépassements de capacité mémoire dans les index de similarité vectorielle.
## max\_local\_read\_bandwidth
Le débit maximal de lecture locale en octets par seconde.
## max\_local\_write\_bandwidth
Le débit maximal des écritures locales, en octets par seconde.
## max\_memory\_usage
Valeur par défaut dans Cloud : dépend de la quantité de RAM sur la réplique.
Quantité maximale de RAM pouvant être utilisée pour exécuter une requête sur un seul serveur.
Une valeur de `0` signifie qu'il n'y a pas de limite.
Ce paramètre ne tient pas compte de la quantité de mémoire disponible ni de la quantité totale
de mémoire sur la machine. La restriction s'applique à une seule requête sur un
seul serveur.
Vous pouvez utiliser `SHOW PROCESSLIST` pour voir la consommation de mémoire actuelle de chaque requête.
Le pic de consommation mémoire est suivi pour chaque requête et consigné dans le journal.
L'utilisation de la mémoire n'est pas entièrement suivie pour les états des fonctions d'agrégation suivantes
lorsque leurs arguments sont de type `String` et `Array` :
* `min`
* `max`
* `any`
* `anyLast`
* `argMin`
* `argMax`
La consommation de mémoire est également limitée par les paramètres [`max_memory_usage_for_user`](/fr/reference/settings/session-settings#max_memory_usage_for_user)
et [`max_server_memory_usage`](/fr/reference/settings/server-settings/settings#max_server_memory_usage).
## max\_memory\_usage\_for\_user
La quantité maximale de RAM pouvant être utilisée pour exécuter les requêtes d’un utilisateur sur un seul serveur. Zéro signifie illimité.
Par défaut, cette quantité n’est pas limitée (`max_memory_usage_for_user = 0`).
Voir aussi la description de [`max_memory_usage`](/fr/reference/settings/session-settings#max_memory_usage).
Par exemple, si vous souhaitez définir `max_memory_usage_for_user` à 1000 octets pour un utilisateur nommé `clickhouse_read`, vous pouvez utiliser l’instruction
```sql theme={null}
ALTER USER clickhouse_read SETTINGS max_memory_usage_for_user = 1000;
```
Vous pouvez vérifier que cela a bien fonctionné en vous déconnectant de votre client, en vous reconnectant, puis en utilisant la fonction `getSetting` :
```sql theme={null}
SELECT getSetting('max_memory_usage_for_user');
```
## max\_network\_bandwidth
Limite le débit des échanges de données sur le réseau en octets par seconde. Ce paramètre s’applique à chaque requête.
Valeurs possibles :
* Entier positif.
* 0 — Le contrôle de la bande passante est désactivé.
## max\_network\_bandwidth\_for\_all\_users
Limite le débit d'échange des données sur le réseau, en octets par seconde. Ce paramètre s'applique à toutes les requêtes exécutées simultanément sur le serveur.
Valeurs possibles :
* Entier positif.
* 0 — Le contrôle du débit des données est désactivé.
## max\_network\_bandwidth\_for\_user
Limite le débit du transfert de données sur le réseau en octets par seconde. Ce paramètre s’applique à toutes les requêtes exécutées simultanément par un seul utilisateur.
Valeurs possibles :
* Entier positif.
* 0 — Le contrôle du débit des données est désactivé.
## max\_network\_bytes
Limite le volume de données (en octets) reçu ou transmis sur le réseau lors de l'exécution d'une requête. Ce paramètre s'applique à chaque requête prise individuellement.
Valeurs possibles :
* Entier positif.
* 0 — Le contrôle du volume de données est désactivé.
## max\_number\_of\_partitions\_for\_independent\_aggregation
Nombre maximal de partitions de la table pour appliquer l'optimisatio
## max\_os\_cpu\_wait\_time\_ratio\_to\_throw
Rapport maximal entre les temps d’attente CPU du système d’exploitation (métrique OSCPUWaitMicroseconds) et d’activité (métrique OSCPUVirtualTimeMicroseconds), au-delà duquel des requêtes peuvent être rejetées. Une interpolation linéaire entre les rapports minimal et maximal est utilisée pour calculer la probabilité ; à ce point, elle est égale à 1.
## max\_parallel\_replicas
Le nombre maximal de répliques pour chaque shard lors de l’exécution d’une requête.
Valeurs possibles :
* Entier positif.
**Informations supplémentaires**
Cette option peut produire des résultats différents selon les paramètres utilisés.
### Traitement parallèle avec la clé `SAMPLE`
Une requête peut être traitée plus rapidement si elle est exécutée en parallèle sur plusieurs serveurs. Mais les performances des requêtes peuvent se dégrader dans les cas suivants :
* La position de la clé d’échantillonnage dans la clé de partitionnement ne permet pas d’effectuer efficacement des parcours de plages.
* L’ajout d’une clé d’échantillonnage à la table rend moins efficace le filtrage sur d’autres colonnes.
* La clé d’échantillonnage est une expression coûteuse à calculer.
* La distribution de la latence du cluster a une longue traîne, de sorte qu’interroger davantage de serveurs augmente la latence globale de la requête.
### Traitement parallèle avec [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key)
Ce paramètre est utile pour toute table répliquée.
## max\_parser\_backtracks
Nombre maximal de retours en arrière du parseur syntaxique (nombre de fois où il essaie différentes alternatives au cours du processus d’analyse descendante récursive).
## max\_parser\_depth
Limite la profondeur de récursion maximale du parseur à descente récursive. Permet de contrôler la taille de la pile.
Valeurs possibles :
* Entier positif.
* 0 — La profondeur de récursion est illimitée.
## max\_parsing\_threads
Le nombre maximal de threads utilisés pour analyser les données dans les formats d’entrée prenant en charge l’analyse en parallèle. Par défaut, cette valeur est déterminée automatiquement.
## max\_partition\_size\_to\_drop
Limitation de la suppression de partitions à l'exécution de la requête. La valeur `0` signifie que vous pouvez supprimer des partitions sans aucune restriction.
Valeur par défaut Cloud : 1 TB.
Ce paramètre de requête remplace le paramètre serveur équivalent, voir [max\_partition\_size\_to\_drop](/fr/reference/settings/server-settings/settings#max_partition_size_to_drop)
## max\_partitions\_per\_insert\_block
Limite le nombre maximal de partitions dans un seul bloc inséré
et une exception est levée si le bloc contient trop de partitions.
* Entier positif.
* `0` — Nombre illimité de partitions.
**Détails**
Lors de l’insertion de données, ClickHouse calcule le nombre de partitions dans le
bloc inséré. Si le nombre de partitions dépasse
`max_partitions_per_insert_block`, ClickHouse consigne soit un avertissement, soit lève une
exception selon `throw_on_max_partitions_per_insert_block`. Les exceptions ont
le texte suivant :
> "Trop de partitions pour un seul bloc INSERT (`partitions_count` partitions, la limite est " + toString(max\_partitions) + ").
> La limite est contrôlée par le paramètre 'max\_partitions\_per\_insert\_block'.
> Un grand nombre de partitions est une erreur de conception fréquente. Cela entraînera un
> fort impact négatif sur les performances, notamment un démarrage lent du serveur, des requêtes
> INSERT lentes et des requêtes SELECT lentes. Le nombre total recommandé de partitions pour une table est
> inférieur à 1000..10000. Veuillez noter que le partitionnement n’est pas destiné à accélérer
> les requêtes SELECT (la clé ORDER BY suffit à rendre les requêtes par plage rapides).
> Les partitions sont destinées à la manipulation des données (DROP PARTITION, etc.)."
Ce paramètre constitue un seuil de sécurité, car l’utilisation d’un grand nombre de partitions est une erreur de conception fréquente.
## max\_partitions\_to\_read
Limite le nombre maximal de partitions accessibles dans une seule requête.
La valeur du paramètre spécifiée lors de la création de la table peut être remplacée par un paramètre défini au niveau de la requête.
Valeurs possibles :
* Entier positif
* `-1` - illimité (par défaut)
Vous pouvez également spécifier le paramètre MergeTree [`max_partitions_to_read`](/fr/reference/settings/session-settings#max_partitions_to_read) dans les paramètres de la table.
## max\_parts\_to\_move
Limite le nombre de parties pouvant être déplacées en une seule requête. Zéro signifie qu'il n'y a pas de limite.
## max\_projection\_rows\_to\_use\_projection\_index
Si le nombre de lignes à lire depuis l’index de projection est inférieur ou égal à ce seuil, ClickHouse essaiera d’utiliser l’index de projection lors de l’exécution de la requête.
## max\_query\_size
Nombre maximal d’octets d’une query string analysée par le parseur SQL.
Les données de la clause VALUES des requêtes INSERT sont traitées par un parseur de flux distinct (qui consomme O(1) de RAM) et ne sont pas affectées par cette restriction.
`max_query_size` ne peut pas être défini dans une requête SQL (par ex., `SELECT now() SETTINGS max_query_size=10000`) car ClickHouse doit allouer un buffer pour analyser la requête, et la taille de ce buffer est déterminée par le paramètre `max_query_size`, qui doit être configuré avant l’exécution de la requête.
## max\_rand\_distribution\_parameter
Valeur maximale des paramètres de forme des distributions dans les fonctions de distribution aléatoire telles que `randChiSquared`, `randStudentT` et `randFisherF`. Cela évite des temps de calcul excessivement longs avec des valeurs de paramètres extrêmes.
## max\_rand\_distribution\_trials
Nombre maximal d'essais autorisés pour les fonctions de distribution aléatoire telles que `randBinomial` et `randNegativeBinomial`. Cela évite des temps de calcul extrêmement longs lorsque le nombre d'essais est très élevé.
## max\_read\_buffer\_size
La taille maximale du tampon de lecture depuis le système de fichiers.
## max\_read\_buffer\_size\_local\_fs
La taille maximale du tampon de lecture à partir du système de fichiers local. Si elle est définie sur 0, `max_read_buffer_size` sera utilisé.
## max\_read\_buffer\_size\_remote\_fs
La taille maximale du tampon de lecture depuis le système de fichiers distant. Si elle est définie sur 0, `max_read_buffer_size` sera utilisé.
## max\_recursive\_cte\_evaluation\_depth
Profondeur maximale d’évaluation des CTE récursives
## max\_remote\_read\_network\_bandwidth
Le débit maximal de transfert de données sur le réseau, en octets par seconde, pour la lecture.
## max\_remote\_write\_network\_bandwidth
La vitesse maximale d’échange de données sur le réseau, en octets par seconde, pour l’écriture.
## max\_replica\_delay\_for\_distributed\_queries
Exclut les répliques en retard des requêtes distribuées. Voir [Réplication](/fr/reference/engines/table-engines/mergetree-family/replication).
Définit une durée en secondes. Si le retard d'une réplique est supérieur ou égal à la valeur définie, cette réplique n'est pas utilisée.
Valeurs possibles :
* Entier positif.
* 0 — Le retard des répliques n'est pas vérifié.
Pour empêcher l'utilisation de toute réplique avec un retard non nul, définissez ce paramètre sur 1.
Utilisé lors de l'exécution d'un `SELECT` sur une table distribuée pointant vers des tables répliquées.
## max\_result\_bytes
Limite la taille du résultat en octets (non compressés). La requête s'arrête après le traitement d'un bloc de données si le seuil est atteint,
mais elle ne tronque pas le dernier bloc du résultat ; la taille du résultat peut donc être supérieure au seuil.
**Points à noter**
La taille du résultat en mémoire est prise en compte pour ce seuil.
Même si la taille du résultat est faible, il peut faire référence à des structures de données plus volumineuses en mémoire,
comme des dictionnaires de colonnes LowCardinality et des Arenas de colonnes AggregateFunction ;
le seuil peut donc être dépassé malgré la faible taille du résultat.
Ce paramètre est de bas niveau et doit être utilisé avec précaution
## max\_result\_rows
Valeur par défaut dans Cloud : `0`.
Limite le nombre de lignes du résultat. Cette limite est également vérifiée pour les sous-requêtes, ainsi que sur les serveurs distants lors de l’exécution de parties d’une requête distribuée.
Aucune limite n’est appliquée lorsque la valeur est `0`.
La requête s’arrête après le traitement d’un bloc de données si le seuil est atteint, mais
le dernier bloc du résultat n’est pas tronqué. La taille du résultat peut donc être
supérieure au seuil.
## max\_reverse\_dictionary\_lookup\_cache\_size\_bytes
Taille maximale, en octets, du cache de lookup inverse du dictionnaire par requête utilisé par la fonction `dictGetKeys`. Le cache stocke des tuples de clés sérialisés par valeur d’attribut afin d’éviter de parcourir à nouveau le dictionnaire au sein d’une même requête. Lorsque la limite est atteinte, les entrées sont évacuées selon la politique LRU. Définissez cette valeur sur 0 pour désactiver la mise en cache.
## max\_rows\_for\_lazy\_final
Nombre maximal de lignes dans l’ensemble pour l’optimisation lazy FINAL. En cas de dépassement, bascule sur FINAL normal.
## max\_rows\_in\_distinct
Le nombre maximal de lignes distinctes lors de l’utilisation de DISTINCT.
## max\_rows\_in\_join
Limite le nombre de lignes dans la structure de données du côté droit (généralement une table de hachage) utilisée lors de la jointure de tables.
Ce paramètre s’applique aux opérations [SELECT ... JOIN](/fr/reference/statements/select/join) ainsi qu’au moteur de table [Join](/fr/reference/engines/table-engines/special/join).
Si une query contient plusieurs jointures, ClickHouse vérifie ce paramètre pour chaque résultat intermédiaire. Lorsque la limite est atteinte, l’action dépend du [`join_algorithm`](/fr/reference/settings/session-settings#join_algorithm) choisi — voir ce paramètre pour le comportement propre à chaque algorithme (spill, repartitionnement, basculement ou throw/break selon [`join_overflow_mode`](/fr/reference/settings/session-settings#join_overflow_mode)).
Valeurs possibles :
* Entier positif.
* `0` — Nombre de lignes illimité.
## max\_rows\_in\_set
Nombre maximal de lignes d'un ensemble de données dans la clause IN créée à partir d'une sous-requête.
## max\_rows\_in\_set\_to\_optimize\_join
Taille maximale de l’ensemble utilisé pour filtrer les tables jointes à partir des ensembles de lignes de chacune avant la jointure.
Valeurs possibles :
* 0 — Désactiver.
* Tout entier positif.
## max\_rows\_to\_group\_by
Le nombre maximal de clés uniques reçues lors de l’agrégation. Ce paramètre
vous permet de limiter la consommation de mémoire lors de l’agrégation.
Si l’agrégation pendant GROUP BY génère plus que le nombre spécifié de
lignes (clés GROUP BY uniques), le comportement sera déterminé par
'group\_by\_overflow\_mode', qui vaut par défaut `throw`, mais peut aussi être basculé
vers un mode GROUP BY approximatif.
## max\_rows\_to\_read
Le nombre maximal de lignes pouvant être lues depuis une table lors de l’exécution d’une requête.
La restriction est vérifiée pour chaque fragment de données traité, s’applique uniquement à
l’expression de table la plus profonde et, lors de la lecture depuis un serveur distant, n’est vérifiée que sur
le serveur distant.
## max\_rows\_to\_read\_leaf
Nombre maximal de lignes pouvant être lues depuis une table locale sur un nœud feuille lors de l’exécution d’une requête distribuée. Bien que les requêtes distribuées puissent envoyer plusieurs sous-requêtes à chaque shard (feuille), cette limite n’est vérifiée qu’à l’étape de lecture sur les nœuds feuille, et elle est ignorée lors de l’étape de fusion des résultats sur le nœud racine.
Par exemple, un cluster se compose de 2 shards, et chaque shard contient une table de 100 lignes. La requête distribuée destinée à lire toutes les données des deux tables avec le paramètre `max_rows_to_read=150` échouera, car le total sera de 200 lignes. Une requête avec `max_rows_to_read_leaf=150` aboutira, puisque les nœuds feuille liront au maximum 100 lignes.
La restriction est vérifiée pour chaque fragment de données traité.
Ce paramètre est instable avec `prefer_localhost_replica=1`.
## max\_rows\_to\_sort
Le nombre maximal de lignes avant tri. Cela permet de limiter la consommation de mémoire lors du tri.
Si le nombre d'enregistrements à traiter pour l'opération ORDER BY dépasse la valeur spécifiée,
le comportement sera déterminé par `sort_overflow_mode`, qui est défini par défaut sur `throw`.
## max\_rows\_to\_transfer
Nombre maximal de lignes pouvant être transmises à un serveur distant ou enregistrées dans une
table temporaire lors de l’exécution de la section GLOBAL IN/JOIN.
## max\_sessions\_for\_user
Nombre maximal de sessions simultanées pour chaque utilisateur authentifié sur le serveur ClickHouse.
Exemple :
```xml theme={null}
1
2
0
single_session_user
two_sessions_profile
unlimited_sessions_profile
```
Valeurs possibles :
* Entier positif
* `0` - nombre illimité de sessions simultanées (par défaut)
## max\_size\_to\_preallocate\_for\_aggregation
Nombre d’éléments pour lesquels il est permis de préallouer de l’espace dans l’ensemble des tables de hachage avant l’agrégatio
## max\_size\_to\_preallocate\_for\_joins
Nombre d’éléments pour lesquels il est permis de préallouer de l’espace, au total, dans toutes les tables de hachage avant joi
## max\_skip\_unavailable\_shards\_num
Lorsque `skip_unavailable_shards` est activé, ce paramètre limite le nombre maximal de shards pouvant être ignorés silencieusement.
Si le nombre de shards indisponibles dépasse cette valeur, une exception est levée au lieu de les ignorer silencieusement.
Une valeur de 0 signifie qu’il n’y a pas de limite (comportement par défaut — tous les shards indisponibles peuvent être ignorés).
## max\_skip\_unavailable\_shards\_ratio
Lorsque `skip_unavailable_shards` est activé, limite la proportion maximale (de 0 à 1) de shards pouvant être ignorés silencieusement.
Si la proportion de shards indisponibles par rapport au nombre total de shards dépasse cette valeur, une exception est levée au lieu de les ignorer silencieusement.
Une valeur de 0 signifie qu'il n'y a pas de limite (comportement par défaut — tous les shards indisponibles peuvent être ignorés).
## max\_streams\_for\_files\_processing\_in\_cluster\_functions
S’il n’est pas nul, limite le nombre de threads qui lisent des données depuis des fichiers dans les *fonctions de table cluster*.
## max\_streams\_for\_merge\_tree\_reading
Si cette valeur n’est pas nulle, elle limite le nombre de flux de lecture pour la table MergeTree.
## max\_streams\_for\_union\_step
Limite le nombre de flux de données actifs simultanément dans une étape `UNION` (s’applique à la fois à `UNION ALL` et à `UNION DISTINCT`, car `UNION DISTINCT` est implémenté via une étape `UNION ALL` suivie d’une étape `DISTINCT`). Lorsqu’une requête `UNION` comporte de nombreuses sous-requêtes, elles ouvrent toutes leurs tampons de lecture en même temps, ce qui entraîne une utilisation de la mémoire proportionnelle au nombre de sous-requêtes. Ce paramètre insère des processeurs `Concat` pour resserrer le pipeline afin qu’au plus ce nombre de flux soit actif à un instant donné, réduisant ainsi fortement le pic de mémoire. La limite réelle est le minimum entre cette valeur et `max_threads * max_streams_for_union_step_to_max_threads_ratio` (si l’une ou l’autre vaut 0, elle est ignorée). Lorsque les deux valent 0, aucun resserrement n’est appliqué. La limite n’est pas non plus appliquée lorsque le plan de requête exige que chaque flux de sortie du `UNION` reste trié individuellement (par exemple, lorsque l’optimisation de lecture dans l’ordre est appliquée au `UNION`) ; dans ce cas, le respect de l’ordre prévaut et le resserrement est ignoré.
## max\_streams\_for\_union\_step\_to\_max\_threads\_ratio
Ce ratio, multiplié par `max_threads`, détermine une limite du nombre de flux actifs simultanément dans une étape `UNION` (s’applique à la fois à `UNION ALL` et à `UNION DISTINCT`). La limite réelle est le minimum entre cette valeur calculée et `max_streams_for_union_step` (si l’un des deux vaut 0, il est ignoré). Par exemple, avec `max_threads = 8` et ce ratio défini sur 1, au plus 8 flux seront actifs. Définissez-le sur 0 pour désactiver cette limite basée sur le ratio. Comme pour `max_streams_for_union_step`, la limite n’est pas appliquée lorsque le plan de requête exige que chaque flux de sortie du `UNION` reste trié individuellement.
## max\_streams\_multiplier\_for\_merge\_tables
Demande un plus grand nombre de flux lors de la lecture depuis une Merge table. Les flux seront répartis entre les tables utilisées par la Merge table. Cela permet de mieux équilibrer la charge de travail entre les threads et s’avère particulièrement utile lorsque les tables sous-jacentes n’ont pas la même taille.
## max\_streams\_to\_max\_threads\_ratio
Permet d’utiliser plus de sources que de threads afin de répartir le travail plus uniformément entre eux. Il s’agit vraisemblablement d’une solution temporaire, car il sera possible à l’avenir de faire en sorte que le nombre de sources soit égal au nombre de threads, tout en permettant à chaque source de sélectionner dynamiquement le travail disponible.
## max\_subquery\_depth
Si une requête comporte plus que le nombre spécifié de sous-requêtes imbriquées, une
exception est levée.
Cela permet d’effectuer une vérification de cohérence afin d’empêcher les utilisateurs de votre
cluster d’écrire des requêtes excessivement complexes.
## max\_table\_size\_to\_drop
Restriction sur la suppression de tables au moment de l’exécution de la requête. La valeur `0` signifie que vous pouvez supprimer toutes les tables sans aucune restriction.
Valeur par défaut dans Cloud : 1 TB.
Ce paramètre de requête remplace le paramètre de serveur équivalent. Voir [max\_table\_size\_to\_drop](/fr/reference/settings/server-settings/settings#max_table_size_to_drop)
## max\_temporary\_columns
Le nombre maximal de colonnes temporaires qui peuvent être conservées simultanément en RAM
lors de l'exécution d'une requête, y compris les colonnes constantes. Si une requête génère en mémoire plus
de colonnes temporaires que le nombre spécifié à la suite d'un calcul
intermédiaire, une exception est levée.
Ce paramètre est utile pour éviter les requêtes trop complexes.
La valeur `0` signifie qu'il n'y a pas de limite.
## max\_temporary\_data\_on\_disk\_size\_for\_query
La quantité maximale de données utilisée par les fichiers temporaires sur le disque, en octets, pour l'ensemble des requêtes exécutées simultanément.
Valeurs possibles :
* Entier positif.
* `0` — illimité (par défaut)
## max\_temporary\_data\_on\_disk\_size\_for\_user
La quantité maximale de données consommées, en octets, par les fichiers temporaires sur le disque pour l'ensemble des
requêtes utilisateur exécutées simultanément.
Valeurs possibles :
* Entier positif.
* `0` — illimité (par défaut)
## max\_temporary\_non\_const\_columns
Comme `max_temporary_columns`, il s'agit du nombre maximal de colonnes temporaires à conserver simultanément en RAM lors de l'exécution d'une requête, sans compter les colonnes constantes.
Des colonnes constantes sont assez fréquemment générées lors de l'exécution d'une requête, mais elles ne nécessitent pratiquement aucune ressource de calcul.
## max\_threads
Le nombre maximal de threads de traitement des requêtes, à l'exclusion des threads utilisés pour récupérer des données depuis des serveurs distants (voir le paramètre ['max\_distributed\_connections'](/fr/reference/settings/session-settings#max_distributed_connections)).
Ce paramètre s'applique aux threads qui exécutent en parallèle les mêmes étapes du pipeline de traitement des requêtes.
Par exemple, lors de la lecture d'une table, s'il est possible d'évaluer en parallèle des expressions avec des fonctions, de filtrer avec `WHERE` et de pré-agréger pour `GROUP BY` en utilisant au moins 'max\_threads' threads, alors 'max\_threads' threads sont utilisés.
Pour les requêtes qui se terminent rapidement à cause d'un LIMIT, vous pouvez définir une valeur plus faible pour 'max\_threads'.
Par exemple, si le nombre nécessaire d'entrées se trouve dans chaque bloc et que max\_threads = 8, alors 8 blocs sont récupérés, alors qu'il aurait suffi d'en lire un seul.
Plus la valeur de `max_threads` est faible, moins la mémoire consommée est importante.
Par défaut, le paramètre `max_threads` correspond au nombre de threads matériels (nombre de cœurs CPU) disponibles pour ClickHouse.
Cas particulier : pour les processeurs x86 disposant de moins de 32 cœurs CPU et du SMT (par ex. Intel HyperThreading), ClickHouse utilise par défaut le nombre de cœurs logiques (= 2 x le nombre de cœurs physiques).
Sans SMT (par ex. Intel HyperThreading), cela correspond au nombre de cœurs CPU.
Pour les utilisateurs de ClickHouse Cloud, la valeur par défaut s'affiche sous la forme `auto(N)`, où N correspond à la taille vCPU de votre service, par ex. 2vCPU/8GiB, 4vCPU/16GiB, etc.
Consultez l'onglet Settings dans la Cloud Console pour obtenir la liste de toutes les tailles de service.
## max\_threads\_for\_indexes
Le nombre maximal de threads utilisés pour traiter les index.
## max\_threads\_min\_free\_memory\_per\_thread
Réduit `max_threads` lorsque le serveur est sous pression mémoire, afin d'éviter de lancer des requêtes fortement parallèles susceptibles d'atteindre la limite de mémoire.
La mémoire libre est calculée comme `max_server_memory_usage` du serveur moins la mémoire actuellement suivie par le memory tracker global. Si cette mémoire libre est inférieure à `max_threads` multiplié par cette valeur, `max_threads` est réduit au plus grand N tel que `N * value <= free_memory`, avec un minimum de `1`.
Définissez cette valeur sur `0` pour désactiver cette limite.
Par exemple, avec la valeur par défaut de 1 GiB et 32 GiB de mémoire libre, `max_threads` est plafonné à 32 ; avec 1 GiB de mémoire libre, il retombe à 1.
Ce paramètre s'applique au parallélisme côté lecture (`SELECT`, `UNION`, `INTERSECT`/`EXCEPT` et la partie `SELECT` de `INSERT ... SELECT`). Pour le côté écriture, voir `max_insert_threads_min_free_memory_per_thread`.
## max\_untracked\_memory
Les petites allocations et désallocations sont regroupées dans une variable locale de thread et suivies ou profilées uniquement lorsqu'une quantité (en valeur absolue) devient supérieure à la valeur spécifiée. Si la valeur est supérieure à 'memory\_profiler\_step', elle sera effectivement ramenée à 'memory\_profiler\_step'.
## max\_wkb\_geometry\_elements
Nombre maximal de points, d’anneaux ou de polygones autorisés dans un même élément de géométrie WKB lors de l’analyse par `readWKB` et les fonctions associées. Cela protège contre des allocations mémoire excessives causées par des données WKB malformées. Définissez cette valeur sur 0 pour utiliser la limite codée en dur (100 millions).
## memory\_overcommit\_ratio\_denominator
Il représente la limite souple de mémoire lorsque la limite stricte est atteinte au niveau global.
Cette valeur est utilisée pour calculer le ratio de surallocation pour la requête.
Zéro signifie ignorer la requête.
Pour en savoir plus, consultez [la surallocation de mémoire](/fr/concepts/features/configuration/settings/memory-overcommit).
## memory\_overcommit\_ratio\_denominator\_for\_user
Il représente la limite de mémoire souple lorsque la limite stricte est atteinte au niveau de l’utilisateur.
Cette valeur est utilisée pour calculer le ratio de surallocation pour la requête.
Zéro signifie que la requête est ignorée.
Pour en savoir plus, consultez [la surallocation de mémoire](/fr/concepts/features/configuration/settings/memory-overcommit).
## memory\_profiler\_sample\_max\_allocation\_size
Collecte des allocations aléatoires d’une taille inférieure ou égale à la valeur spécifiée, avec une probabilité égale à `memory_profiler_sample_probability`. 0 signifie que le paramètre est désactivé. Vous pouvez définir `max_untracked_memory` sur 0 pour que ce seuil fonctionne comme prévu.
## memory\_profiler\_sample\_min\_allocation\_size
Collecte les allocations aléatoires d’une taille supérieure ou égale à la valeur spécifiée, avec une probabilité égale à `memory_profiler_sample_probability`. 0 signifie que le paramètre est désactivé. Vous pouvez définir 'max\_untracked\_memory' sur 0 afin que ce seuil fonctionne comme prévu.
## memory\_profiler\_sample\_probability
Collecte des allocations et désallocations aléatoires et les écrit dans system.trace\_log avec le trace\_type 'MemorySample'. La probabilité s'applique à chaque alloc/free, quelle que soit la taille de l'allocation (elle peut être modifiée avec `memory_profiler_sample_min_allocation_size` et `memory_profiler_sample_max_allocation_size`). Notez que l'échantillonnage n'a lieu que lorsque la quantité de mémoire non suivie dépasse 'max\_untracked\_memory'. Vous pouvez définir 'max\_untracked\_memory' sur 0 pour obtenir un échantillonnage encore plus fin.
## memory\_profiler\_step
Définit le pas du profileur mémoire. Chaque fois que l’utilisation mémoire de la requête dépasse le palier suivant, exprimé en nombre d’octets, le profileur mémoire collecte la stacktrace d’allocation et l’écrit dans [trace\_log](/fr/reference/system-tables/trace_log).
Valeurs possibles :
* Un nombre entier positif d’octets.
* 0 pour désactiver le profileur mémoire.
## memory\_tracker\_fault\_probability
Pour tester `exception safety`, lever une exception chaque fois que vous allouez de la mémoire, selon la probabilité spécifiée.
## memory\_usage\_overcommit\_max\_wait\_microseconds
Temps maximal pendant lequel un thread attend que de la mémoire soit libérée en cas de surallocation mémoire au niveau utilisateur.
Si le délai d'attente est atteint et que la mémoire n'est pas libérée, une exception est levée.
Pour en savoir plus sur la [surallocation mémoire](/fr/concepts/features/configuration/settings/memory-overcommit).
## merge\_table\_max\_tables\_to\_look\_for\_schema\_inference
Lors de la création d’une table `Merge` sans schéma explicite, ou lors de l’utilisation de la fonction de table `merge`, le schéma est déduit comme l’union d’au plus le nombre spécifié de tables correspondantes.
Si le nombre de tables est supérieur, le schéma sera déduit à partir des premières tables, dans la limite du nombre spécifié.
## merge\_tree\_coarse\_index\_granularity
Lors de la recherche de données, ClickHouse vérifie les marques de données dans le fichier d’index. Si ClickHouse constate que les clés recherchées se trouvent dans une plage donnée, il divise cette plage en `merge_tree_coarse_index_granularity` sous-plages et y recherche récursivement les clés recherchées.
Valeurs possibles :
* Tout entier pair positif.
## merge\_tree\_compact\_parts\_min\_granules\_to\_multibuffer\_read
N'a d'effet que dans ClickHouse Cloud. Nombre de granules dans une stripe d'une part compacte de tables MergeTree à partir duquel le lecteur multitampon est utilisé, ce qui permet la lecture parallèle et la prélecture. En cas de lecture depuis un système de fichiers distant, l'utilisation du lecteur multitampon augmente le nombre de requêtes de lecture.
## merge\_tree\_determine\_task\_size\_by\_prewhere\_columns
Indique s’il faut utiliser uniquement la taille des colonnes prewhere pour déterminer la taille de la tâche de lecture.
## merge\_tree\_max\_bytes\_to\_use\_cache
Si ClickHouse doit lire plus de `merge_tree_max_bytes_to_use_cache` octets au cours d’une requête, il n’utilise pas le cache des blocs non compressés.
Le cache des blocs non compressés stocke les données extraites pour les requêtes. ClickHouse utilise ce cache pour accélérer les réponses aux petites requêtes répétées. Ce paramètre évite que le cache soit pollué par des requêtes qui lisent un grand volume de données. Le paramètre serveur [uncompressed\_cache\_size](/fr/reference/settings/server-settings/settings#uncompressed_cache_size) définit la taille du cache des blocs non compressés.
Valeurs possibles :
* Tout entier positif.
## merge\_tree\_max\_rows\_to\_use\_cache
Si ClickHouse doit lire plus de `merge_tree_max_rows_to_use_cache` lignes dans une seule requête, il n’utilise pas le cache des blocs non compressés.
Le cache des blocs non compressés stocke les données extraites pour les requêtes. ClickHouse utilise ce cache pour accélérer les réponses aux petites requêtes répétées. Ce paramètre évite que le cache soit perturbé par des requêtes qui lisent un grand volume de données. Le paramètre de serveur [uncompressed\_cache\_size](/fr/reference/settings/server-settings/settings#uncompressed_cache_size) définit la taille du cache des blocs non compressés.
Valeurs possibles :
* Tout entier positif.
## merge\_tree\_min\_bytes\_for\_concurrent\_read
Si le nombre d’octets à lire à partir d’un fichier d’une table utilisant le moteur [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) dépasse `merge_tree_min_bytes_for_concurrent_read`, ClickHouse tente alors de lire ce fichier de manière concurrente à l’aide de plusieurs threads.
Valeur possible :
* Entier positif.
## merge\_tree\_min\_bytes\_for\_concurrent\_read\_for\_remote\_filesystem
Le nombre minimal d’octets à lire dans un fichier avant que le moteur [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) puisse paralléliser la lecture lors d’une lecture depuis un système de fichiers distant. Nous ne recommandons pas d’utiliser ce paramètre.
Valeurs possibles :
* Entier positif.
## merge\_tree\_min\_bytes\_for\_seek
Si la distance entre deux blocs de données à lire dans un fichier est inférieure à `merge_tree_min_bytes_for_seek` octets, ClickHouse lit alors séquentiellement une plage du fichier contenant les deux blocs, évitant ainsi une opération de `seek` supplémentaire.
Valeurs possibles :
* Tout entier positif.
## merge\_tree\_min\_bytes\_per\_task\_for\_remote\_reading
**Alias** : `filesystem_prefetch_min_bytes_for_single_read_task`
Nombre minimal d’octets à lire par tâche.
## merge\_tree\_min\_read\_task\_size
Limite inférieure absolue de la taille des tâches (même lorsque le nombre de granules est faible et que le nombre de threads disponibles est élevé, nous n'allouerons pas de tâches plus petites
## merge\_tree\_min\_rows\_for\_concurrent\_read
Si le nombre de lignes à lire dans un fichier d’une table [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) dépasse `merge_tree_min_rows_for_concurrent_read`, ClickHouse tente alors d’effectuer une lecture concurrente de ce fichier sur plusieurs threads.
Valeurs possibles :
* Entier positif.
## merge\_tree\_min\_rows\_for\_concurrent\_read\_for\_remote\_filesystem
Nombre minimal de lignes à lire dans un fichier avant que le moteur [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) puisse paralléliser la lecture lors d’une lecture depuis un système de fichiers distant. Nous déconseillons d’utiliser ce paramètre.
Valeurs possibles :
* Entier positif.
## merge\_tree\_min\_rows\_for\_seek
Si l’écart entre deux blocs de données à lire dans un même fichier est inférieur à `merge_tree_min_rows_for_seek` lignes, ClickHouse n’effectue pas de seek dans le fichier, mais lit les données de manière séquentielle.
Valeurs possibles :
* Tout entier positif.
## merge\_tree\_read\_split\_ranges\_into\_intersecting\_and\_non\_intersecting\_injection\_probability
Pour tester `PartsSplitter` : scinde les plages de lecture en plages qui se chevauchent et en plages qui ne se chevauchent pas à chaque lecture depuis MergeTree, selon la probabilité spécifiée.
## merge\_tree\_storage\_snapshot\_sleep\_ms
Introduit un délai artificiel (en millisecondes) lors de la création d’un instantané de stockage pour les tables MergeTree.
À utiliser uniquement à des fins de test et de débogage.
Valeurs possibles :
* 0 - Aucun délai (par défaut)
* N - Délai en millisecondes
## merge\_tree\_use\_const\_size\_tasks\_for\_remote\_reading
Indique s’il faut utiliser des tâches de taille constante pour la lecture depuis une table distante.
## merge\_tree\_use\_deserialization\_prefixes\_cache
Active la mise en cache des métadonnées de colonnes à partir des préfixes de fichier lors de la lecture depuis des disques distants dans MergeTree.
## merge\_tree\_use\_prefixes\_deserialization\_thread\_pool
Active l’utilisation du pool de threads pour la lecture parallèle des préfixes dans les wide parts de MergeTree. La taille de ce pool de threads est contrôlée par le paramètre serveur `max_prefixes_deserialization_thread_pool_size`.
## merge\_tree\_use\_v1\_object\_and\_dynamic\_serialization
Lorsqu’il est activé, la version de sérialisation V1 des types JSON et Dynamic sera utilisée dans MergeTree à la place de V2. La modification de ce paramètre ne prend effet qu’après le redémarrage du serveur.
## metrics\_perf\_events\_enabled
Si cette option est activée, certains événements perf seront mesurés tout au long de l’exécution des requêtes.
## metrics\_perf\_events\_list
Liste de métriques perf séparées par des virgules, qui seront mesurées pendant l’exécution des requêtes. Si vide, tous les événements sont pris en compte. Voir PerfEventInfo dans les sources pour la liste des événements disponibles.
## min\_bytes\_to\_use\_direct\_io
Le volume minimal de données nécessaire pour utiliser l’accès direct au disque de stockage en E/S.
ClickHouse utilise ce paramètre lors de la lecture des données depuis des tables. Si le volume total sur le disque de toutes les données à lire dépasse `min_bytes_to_use_direct_io` octets, ClickHouse lit alors les données depuis le disque de stockage avec l’option `O_DIRECT`.
Valeurs possibles :
* 0 — Les E/S directes sont désactivées.
* Entier positif.
## min\_bytes\_to\_use\_mmap\_io
Il s’agit d’un paramètre expérimental. Il définit le volume minimal de mémoire à partir duquel les gros fichiers sont lus sans copier les données du noyau vers l’espace utilisateur. Le seuil recommandé est d’environ 64 Mo, car [mmap/munmap](https://en.wikipedia.org/wiki/Mmap) est lent. Ce paramètre n’est utile que pour les gros fichiers et n’apporte un bénéfice que si les données résident dans le cache de pages.
Valeurs possibles :
* Entier positif.
* 0 — Les gros fichiers sont lus uniquement en copiant les données du noyau vers l’espace utilisateur.
## min\_chunk\_bytes\_for\_parallel\_parsing
* Type : entier non signé
* Valeur par défaut : 1 MiB
Taille minimale, en octets, du fragment que chaque thread analysera en parallèle.
## min\_compress\_block\_size
Pour les tables [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree). Afin de réduire la latence du traitement des requêtes, un bloc est compressé lors de l’écriture du repère suivant si sa taille est au moins égale à `min_compress_block_size`. Par défaut, 65 536.
La taille réelle du bloc, si les données non compressées sont inférieures à `max_compress_block_size`, n’est inférieure ni à cette valeur, ni au volume de données correspondant à un repère.
Prenons un exemple. Supposons que `index_granularity` ait été défini sur 8192 lors de la création de la table.
Nous écrivons une colonne de type UInt32 (4 octets par valeur). Lors de l’écriture de 8192 lignes, cela représente un total de 32 Ko de données. Comme min\_compress\_block\_size = 65 536, un bloc compressé sera formé tous les deux repères.
Nous écrivons une colonne URL de type String (taille moyenne de 60 octets par valeur). Lors de l’écriture de 8192 lignes, cela représente en moyenne un peu moins de 500 Ko de données. Comme cette valeur dépasse 65 536, un bloc compressé sera formé pour chaque repère. Dans ce cas, lors de la lecture des données sur le disque dans la plage d’un seul repère, aucune donnée supplémentaire ne devra être décompressée.
Il s’agit d’un paramètre destiné aux utilisateurs expérimentés, et vous ne devriez pas le modifier si vous débutez avec ClickHouse.
## min\_count\_to\_compile\_aggregate\_expression
Nombre minimal d'expressions d'agrégation identiques à partir duquel la compilation JIT commence. Fonctionne uniquement si le paramètre [compile\_aggregate\_expressions](#compile_aggregate_expressions) est activé.
Valeurs possibles :
* Entier positif.
* 0 — Les expressions d'agrégation identiques sont toujours compilées en JIT.
## min\_count\_to\_compile\_expression
Nombre minimal d'exécutions d'une même expression avant qu'elle soit compilée.
## min\_count\_to\_compile\_sort\_description
Le nombre de descriptions de tri identiques avant leur compilation en JIT
## min\_execution\_speed
Vitesse d'exécution minimale en lignes par seconde. Vérifiée pour chaque bloc de données lorsque
[`timeout_before_checking_execution_speed`](/fr/reference/settings/session-settings#timeout_before_checking_execution_speed)
expire. Si la vitesse d'exécution est inférieure, une exception est levée.
## min\_execution\_speed\_bytes
Le nombre minimal d’octets exécutés par seconde. Vérifié pour chaque bloc de données lorsque
[`timeout_before_checking_execution_speed`](/fr/reference/settings/session-settings#timeout_before_checking_execution_speed)
expire. Si la vitesse d’exécution est inférieure, une exception est levée.
## min\_external\_table\_block\_size\_bytes
Fusionne les blocs transmis à la table externe pour atteindre la taille spécifiée en octets, s’ils ne sont pas assez volumineux.
## min\_external\_table\_block\_size\_rows
Regroupe les blocs transmis à la table externe afin d'atteindre le nombre de lignes spécifié, si les blocs ne sont pas assez volumineux.
## min\_filtered\_ratio\_for\_lazy\_final
Ratio minimal de marks filtrées par l’analyse des index pour l’optimisation lazy FINAL. Si une fraction inférieure à ce seuil de marks est filtrée, le système revient au mode FINAL normal. La valeur 0 désactive cette vérification.
## min\_free\_disk\_bytes\_to\_perform\_insert
Nombre minimal d’octets d’espace disque libre requis pour effectuer une insertion.
## min\_free\_disk\_ratio\_to\_perform\_insert
Ratio minimal d’espace disque libre requis pour effectuer une insertion.
## min\_free\_disk\_space\_for\_temporary\_data
Espace disque minimal à conserver lors de l’écriture de données temporaires utilisées pour le tri externe et l’agrégation.
## min\_hit\_rate\_to\_use\_consecutive\_keys\_optimization
Taux de succès minimal d’un cache utilisé pour l’optimisation des clés consécutives dans l’agrégation, afin de la maintenir activée
## min\_insert\_block\_size\_bytes
Taille minimale des blocs (en octets) à former pour l'insertion dans une table.
Ce paramètre fonctionne avec min\_insert\_block\_size\_rows et contrôle la formation des blocs dans les mêmes contextes (analyse du format et opérations INSERT). Consultez min\_insert\_block\_size\_rows pour plus de détails sur le moment et la manière dont ces paramètres sont appliqués.
Valeurs possibles :
* Entier positif.
* 0 — le paramètre n'intervient pas dans la formation des blocs.
## min\_insert\_block\_size\_bytes\_for\_materialized\_views
Définit le nombre minimal d’octets qu’un bloc doit contenir pour pouvoir être inséré dans une table par une requête `INSERT`. Les blocs plus petits sont regroupés en blocs plus grands. Ce paramètre s’applique uniquement aux blocs insérés dans une [vue matérialisée](/fr/reference/statements/create/view). En ajustant ce paramètre, vous contrôlez le regroupement des blocs lors de l’envoi vers la vue matérialisée et évitez une utilisation excessive de la mémoire.
Valeurs possibles :
* Tout entier positif.
* 0 — Regroupement désactivé.
**Voir aussi**
* [min\_insert\_block\_size\_bytes](#min_insert_block_size_bytes)
## min\_insert\_block\_size\_rows
La taille minimale des blocs (en lignes) à former pour l'insertion dans une table.
Ce paramètre contrôle la formation des blocs dans deux contextes :
1. Analyse des formats d'entrée : lorsque le serveur analyse des formats d'entrée orientés lignes (CSV, TSV, JSONEachRow, etc.) depuis n'importe quelle interface (HTTP, clickhouse-client avec des données intégrées, gRPC, PostgreSQL wire protocol), les blocs sont émis lorsque :
* Les deux seuils min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes sont atteints, OR
* L'un des deux seuils max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes est atteint
Remarque : lorsque vous utilisez clickhouse-client ou clickhouse-local pour lire depuis un fichier, c'est le client lui-même qui analyse les données, et ce paramètre s'applique côté client.
2. Opérations INSERT : pendant les requêtes INSERT et lorsque les données transitent par des vues matérialisées, le comportement de ce paramètre dépend de `use_strict_insert_block_limits` :
* Lorsqu'il est activé : les blocs sont émis lorsque :
* Seuils min (AND) : les deux seuils min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes sont atteints
* Seuils max (OR) : l'un des deux seuils max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes est atteint
* Lorsqu'il est désactivé (par défaut) : les blocs sont émis lorsque min\_insert\_block\_size\_rows OR min\_insert\_block\_size\_bytes est atteint. Les paramètres max\_insert\_block\_size ne sont pas pris en compte.
Valeurs possibles :
* Entier positif.
* 0 — le paramètre ne participe pas à la formation des blocs.
## min\_insert\_block\_size\_rows\_for\_materialized\_views
Définit le nombre minimal de lignes qu’un bloc doit contenir pour pouvoir être inséré dans une table par une requête `INSERT`. Les blocs plus petits sont fusionnés en blocs plus grands. Ce paramètre s’applique uniquement aux blocs insérés dans une [vue matérialisée](/fr/reference/statements/create/view). En ajustant ce paramètre, vous contrôlez la fusion des blocs lors de l’alimentation d’une vue matérialisée et évitez une utilisation excessive de la mémoire.
Valeurs possibles :
* Tout entier positif.
* 0 — Fusion désactivée.
**Voir aussi**
* [min\_insert\_block\_size\_rows](#min_insert_block_size_rows)
## min\_joined\_block\_size\_bytes
Taille minimale du bloc, en octets, pour les blocs d'entrée et de sortie de JOIN (si l'algorithme JOIN le prend en charge). Les petits blocs seront regroupés. 0 signifie sans limite.
## min\_joined\_block\_size\_rows
Nombre minimal de lignes par bloc pour les blocs d’entrée et de sortie de JOIN (si l’algorithme de jointure le prend en charge). Les petits blocs seront regroupés. 0 signifie sans limite.
## min\_os\_cpu\_wait\_time\_ratio\_to\_throw
Rapport minimal entre les temps d’attente du CPU au niveau du système d’exploitation (métrique OSCPUWaitMicroseconds) et les temps d’activité (métrique OSCPUVirtualTimeMicroseconds) à partir duquel le rejet de requêtes peut être envisagé. Une interpolation linéaire entre le rapport minimal et le rapport maximal est utilisée pour calculer la probabilité ; à ce seuil, cette probabilité est nulle.
## min\_outstreams\_per\_resize\_after\_split
Spécifie le nombre minimal de flux de sortie d’un processeur `Resize` ou `StrictResize` après l’exécution d’un fractionnement lors de la génération du pipeline. Si le nombre de flux résultant est inférieur à cette valeur, l’opération de fractionnement n’a pas lieu.
### Qu’est-ce qu’un nœud Resize
Un nœud `Resize` est un processeur du pipeline de requête qui ajuste le nombre de flux de données qui y circulent. Il peut augmenter ou diminuer le nombre de flux afin d’équilibrer la charge de travail entre plusieurs threads ou processeurs. Par exemple, si une requête nécessite davantage de parallélisme, le nœud `Resize` peut scinder un flux unique en plusieurs flux. À l’inverse, il peut fusionner plusieurs flux pour en réduire le nombre et regrouper le traitement des données.
Le nœud `Resize` garantit une répartition uniforme des données entre les flux, tout en préservant la structure des blocs de données. Cela permet d’optimiser l’utilisation des ressources et d’améliorer les performances des requêtes.
### Pourquoi le nœud Resize doit être fractionné
Pendant l’exécution du pipeline, le `status_mutex` de `ExecutingGraph::Node` du nœud `Resize`, qui sert de point central, est fortement sujet à la contention, en particulier dans les environnements comportant un grand nombre de cœurs, ce qui entraîne :
1. Une latence accrue pour `ExecutingGraph::updateNode`, ce qui affecte directement les performances des requêtes.
2. Un gaspillage excessif de cycles CPU dans la contention sur le spin-lock (`native_queued_spin_lock_slowpath`), ce qui dégrade l’efficacité.
3. Une utilisation réduite du CPU, ce qui limite le parallélisme et le débit.
### Comment le nœud Resize est fractionné
1. Le nombre de flux de sortie est vérifié afin de s’assurer que le fractionnement peut être effectué : les flux de sortie de chaque processeur issu du fractionnement atteignent ou dépassent le seuil `min_outstreams_per_resize_after_split`.
2. Le nœud `Resize` est divisé en nœuds `Resize` plus petits, avec un nombre égal de ports, chacun gérant un sous-ensemble des flux d’entrée et de sortie.
3. Chaque groupe est traité indépendamment, ce qui réduit la contention sur les verrous.
### Fractionnement d’un nœud Resize avec des entrées/sorties arbitraires
Dans certains cas, lorsque le nombre d’entrées/sorties n’est pas divisible par le nombre de nœuds `Resize` après fractionnement, certaines entrées sont reliées à des `NullSource` et certaines sorties à des `NullSink`. Cela permet d’effectuer le fractionnement sans affecter le flux global de données.
### Objectif du paramètre
Le paramètre `min_outstreams_per_resize_after_split` garantit que le fractionnement des nœuds `Resize` a du sens et évite de créer trop peu de flux, ce qui pourrait nuire à l'efficacité du traitement parallèle. En imposant un nombre minimal de flux de sortie, ce paramètre aide à maintenir un équilibre entre le parallélisme et le surcoût, afin d'optimiser l'exécution des requêtes dans les scénarios impliquant le fractionnement et la fusion de flux.
### Désactivation du paramètre
Pour désactiver le fractionnement des nœuds `Resize`, définissez ce paramètre sur 0. Cela empêchera le fractionnement des nœuds `Resize` lors de la génération du pipeline, ce qui leur permettra de conserver leur structure d’origine sans être fractionnés en nœuds plus petits.
## min\_table\_rows\_to\_use\_projection\_index
Si le nombre estimé de lignes à lire dans la table est supérieur ou égal à ce seuil, ClickHouse essaiera d'utiliser l'index de projection lors de l'exécution de la requête.
## mongodb\_throw\_on\_unsupported\_query
Si ce paramètre est activé, les tables MongoDB renverront une erreur lorsqu'une requête MongoDB ne peut pas être générée. Sinon, ClickHouse lit l'intégralité de la table et la traite localement. Cette option ne s'applique pas lorsque 'allow\_experimental\_analyzer=0'.
## move\_all\_conditions\_to\_prewhere
Déplacer toutes les conditions pouvant l’être de WHERE vers PREWHERE
## move\_primary\_key\_columns\_to\_end\_of\_prewhere
Déplace les conditions PREWHERE contenant des colonnes de clé primaire à la fin de la chaîne d’opérations AND. Il est probable que ces conditions soient déjà prises en compte lors de l’analyse de la clé primaire et qu’elles n’apportent donc pas grand-chose au filtrage PREWHERE.
## multiple\_joins\_try\_to\_keep\_original\_names
Ne pas ajouter d'alias à la liste d'expressions de premier niveau lors de la réécriture de jointures multiples
## mutations\_execute\_nondeterministic\_on\_initiator
Si la valeur est `true`, les fonctions constantes non déterministes (par ex. la fonction `now()`) sont exécutées sur le nœud initiateur puis remplacées par des littéraux dans les requêtes `UPDATE` et `DELETE`. Cela permet de maintenir la synchronisation des données entre les répliques lors de l’exécution de mutations avec des fonctions constantes non déterministes. Valeur par défaut : `false`.
## mutations\_execute\_subqueries\_on\_initiator
Si `true`, les sous-requêtes scalaires sont exécutées sur l’initiateur, puis remplacées par des littéraux dans les requêtes `UPDATE` et `DELETE`. Valeur par défaut : `false`.
## mutations\_max\_literal\_size\_to\_replace
La taille maximale, en octets, du littéral sérialisé à remplacer dans les requêtes `UPDATE` et `DELETE`. Ne prend effet que si au moins l’un des deux paramètres ci-dessus est activé. Valeur par défaut : 16384 (16 KiB).
## mutations\_sync
Permet d’exécuter de manière synchrone les requêtes `ALTER TABLE ... UPDATE|DELETE|MATERIALIZE INDEX|MATERIALIZE PROJECTION|MATERIALIZE COLUMN|MATERIALIZE STATISTICS` ([mutations](/fr/reference/statements/alter/index#mutations)).
Valeurs possibles :
| Valeur | Description |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `0` | Les mutations s’exécutent de manière asynchrone. |
| `1` | La requête attend que toutes les mutations se terminent sur le serveur actuel. |
| `2` | La requête attend que toutes les mutations se terminent sur toutes les répliques (si elles existent). |
| `3` | La requête attend uniquement les répliques actives. Pris en charge uniquement pour `SharedMergeTree`. Pour `ReplicatedMergeTree`, le comportement est identique à `mutations_sync = 2`. |
## mysql\_datatypes\_support\_level
Définit comment les types MySQL sont convertis en types ClickHouse correspondants. Liste de valeurs séparées par des virgules, dans n'importe quelle combinaison de `decimal`, `datetime64`, `date2Date32` ou `date2String`. Toutes les correspondances modernes (`decimal`, `datetime64`, `date2Date32`) sont activées par défaut.
* `decimal` : convertit les types `NUMERIC` et `DECIMAL` en `Decimal` lorsque la précision le permet.
* `datetime64` : convertit les types `DATETIME` et `TIMESTAMP` en `DateTime64` au lieu de `DateTime` lorsque la précision n'est pas `0`.
* `date2Date32` : convertit `DATE` en `Date32` au lieu de `Date`. Prend le pas sur `date2String`.
* `date2String` : convertit `DATE` en `String` au lieu de `Date`. Est surchargé par `datetime64`.
## mysql\_map\_fixed\_string\_to\_text\_in\_show\_columns
Lorsque ce paramètre est activé, le type de données ClickHouse [FixedString](/fr/reference/data-types/fixedstring) est affiché en `TEXT` dans [SHOW COLUMNS](/fr/reference/statements/show#show_columns).
N'a d'effet que lorsque la connexion est établie via le MySQL wire protocol.
* 0 - Utiliser `BLOB`.
* 1 - Utiliser `TEXT`.
## mysql\_map\_string\_to\_text\_in\_show\_columns
Lorsqu'il est activé, le type de données ClickHouse [String](/fr/reference/data-types/string) est affiché sous la forme `TEXT` dans [SHOW COLUMNS](/fr/reference/statements/show#show_columns).
N'a d'effet que lorsque la connexion est établie via le MySQL wire protocol.
* 0 - Utiliser `BLOB`.
* 1 - Utiliser `TEXT`.
## mysql\_max\_rows\_to\_insert
Nombre maximal de lignes lors d’une insertion MySQL par lot avec le moteur de stockage MySQL
## network\_compression\_method
Le codec utilisé pour la compression des communications client/serveur et serveur/serveur.
Valeurs possibles :
* `NONE` — aucune compression.
* `LZ4` — utilise le codec LZ4.
* `LZ4HC` — utilise le codec LZ4HC.
* `ZSTD` — utilise le codec ZSTD.
**Voir aussi**
* [network\_zstd\_compression\_level](#network_zstd_compression_level)
## network\_zstd\_compression\_level
Définit le niveau de compression ZSTD. Utilisé uniquement lorsque [network\_compression\_method](#network_compression_method) est défini sur `ZSTD`.
Valeurs possibles :
* Entier positif compris entre 1 et 15.
## normalize\_function\_names
Normaliser les noms de fonction en leurs noms canoniques
## number\_of\_mutations\_to\_delay
Si la table contient au moins ce nombre de mutations non terminées, ralentissez artificiellement les mutations de la table. 0 - désactivé
## number\_of\_mutations\_to\_throw
Si la table mutée contient au moins ce nombre de mutations non terminées, déclencher l'exception 'Too many mutations ...'. 0 - désactivé
## odbc\_bridge\_connection\_pool\_size
Taille du pool de connexions pour chaque chaîne de paramètres de connexion de l’ODBC bridge.
## odbc\_bridge\_use\_connection\_pooling
Active le pool de connexions dans ODBC bridge. Si cette option est définie sur false, une nouvelle connexion est créée à chaque fois.
## offset
Définit le nombre de lignes à ignorer avant de commencer à renvoyer les lignes de la requête. Ce paramètre ajuste le décalage défini par la clause [OFFSET](/fr/reference/statements/select/offset), de sorte que ces deux valeurs s'additionnent.
Valeurs possibles :
* 0 — Aucune ligne n'est ignorée.
* Entier positif.
**Exemple**
Table d'entrée :
```sql theme={null}
CREATE TABLE test (i UInt64) ENGINE = MergeTree() ORDER BY i;
INSERT INTO test SELECT number FROM numbers(500);
```
Requête :
```sql theme={null}
SET limit = 5;
SET offset = 7;
SELECT * FROM test LIMIT 10 OFFSET 100;
```
Résultat :
```text theme={null}
┌───i─┐
│ 107 │
│ 108 │
│ 109 │
└─────┘
```
## opentelemetry\_start\_keeper\_trace\_probability
Probabilité d’initier une trace pour une requête ZooKeeper, qu’une trace parente existe ou non.
Valeurs possibles :
* 'auto' - Équivaut au paramètre opentelemetry\_start\_trace\_probability
* 0 — Le traçage est désactivé
* 0 à 1 — Probabilité (par ex. : 1.0 = toujours activé)
## opentelemetry\_start\_trace\_probability
Définit la probabilité que ClickHouse démarre une trace pour les requêtes exécutées (si aucun [contexte de trace](https://www.w3.org/TR/trace-context/) parent n'est fourni).
Valeurs possibles :
* 0 — La trace est désactivée pour toutes les requêtes exécutées (si aucun contexte de trace parent n'est fourni).
* Nombre à virgule flottante positif dans l'intervalle \[0..1]. Par exemple, si la valeur du paramètre est `0,5`, ClickHouse peut démarrer une trace en moyenne pour la moitié des requêtes.
* 1 — La trace est activée pour toutes les requêtes exécutées.
## opentelemetry\_trace\_cpu\_scheduling
Collecte les spans OpenTelemetry pour l’ordonnancement préemptif du CPU des workloads.
## opentelemetry\_trace\_processors
Collecte les spans OpenTelemetry pour les processeurs.
## optimize\_aggregation\_in\_order
Active l’optimisation de [GROUP BY](/fr/reference/statements/select/group-by) dans les requêtes [SELECT](/fr/reference/statements/select/index) afin d’agréger les données selon l’ordre correspondant dans les tables [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree).
Valeurs possibles :
* 0 — l’optimisation de `GROUP BY` est désactivée.
* 1 — l’optimisation de `GROUP BY` est activée.
**Voir aussi**
* [Optimisation de GROUP BY](/fr/reference/statements/select/group-by#group-by-optimization-depending-on-table-sorting-key)
## optimize\_aggregators\_of\_group\_by\_keys
Élimine les agrégateurs min/max/any/anyLast des clés GROUP BY dans la section SELECT
## optimize\_and\_compare\_chain
Propage les comparaisons avec des constantes dans les chaînes AND afin d'améliorer les capacités de filtrage. Prend en charge les opérateurs `<`, `<=`, `>`, `>=`, `=` ainsi que leurs combinaisons. Par exemple, `(a < b) AND (b < c) AND (c < 5)` deviendrait `(a < b) AND (b < c) AND (c < 5) AND (b < 5) AND (a < 5)`.
## optimize\_append\_index
Utilisez les [contraintes](/fr/reference/statements/create/table#constraints) pour ajouter une condition d’index. La valeur par défaut est `false`.
Valeurs possibles :
* true, false
## optimize\_arithmetic\_operations\_in\_aggregate\_functions
Déplace les opérations arithmétiques en dehors des fonctions d’agrégation
## optimize\_const\_name\_size
Remplacer par une valeur scalaire et utiliser un hash comme nom pour les grandes constantes (la taille est estimée en fonction de la longueur du nom).
Valeurs possibles :
* entier positif - longueur maximale du nom,
* 0 — toujours,
* entier négatif - jamais.
## optimize\_count\_from\_files
Active ou désactive l’optimisation du comptage du nombre de lignes dans des fichiers de différents formats d’entrée. Elle s’applique aux fonctions de table/moteurs `file`/`s3`/`url`/`hdfs`/`azureBlobStorage`.
Valeurs possibles :
* 0 — Optimisation désactivée.
* 1 — Optimisation activée.
## optimize\_dictget\_tuple\_element
Réécrit `tupleElement(dictGet('dict', ('a', 'b', 'c'), key), 2)` en `dictGet('dict', 'b', key)` afin d'éviter de récupérer des attributs de dictionnaire inutiles. Prend en charge l'accès positionnel (`.1`, `.2`, ...) et l'accès nommé (`.b`), et s'applique également à `dictGetOrDefault` lorsque l'argument par défaut est un tuple constant ou un `tuple(...)` de constantes.
## optimize\_distinct\_in\_order
Active l’optimisation de DISTINCT si certaines colonnes de DISTINCT constituent un préfixe de tri. Par exemple, un préfixe de la clé de tri dans MergeTree ou de l’instruction ORDER BY
## optimize\_distributed\_group\_by\_sharding\_key
Optimise les requêtes `GROUP BY sharding_key` en évitant une agrégation coûteuse sur le serveur initiateur (ce qui réduira la consommation mémoire de la requête sur ce serveur).
Les types de requêtes suivants sont pris en charge (ainsi que toutes leurs combinaisons) :
* `SELECT DISTINCT [..., ]sharding_key[, ...] FROM dist`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...]`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] ORDER BY x`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1 BY x`
Les types de requêtes suivants ne sont pas pris en charge (la prise en charge de certains pourra être ajoutée ultérieurement) :
* `SELECT ... GROUP BY sharding_key[, ...] WITH TOTALS`
* `SELECT ... GROUP BY sharding_key[, ...] WITH ROLLUP`
* `SELECT ... GROUP BY sharding_key[, ...] WITH CUBE`
* `SELECT ... GROUP BY sharding_key[, ...] SETTINGS extremes=1`
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Voir aussi :
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge)
* [distributed\_push\_down\_limit](#distributed_push_down_limit)
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards)
À l’heure actuelle, ce réglage nécessite `optimize_skip_unused_shards` (la raison est qu’il pourrait un jour être activé par défaut et ne fonctionner correctement que si les données ont été insérées via une table Distributed, c’est-à-dire si elles sont distribuées selon `sharding_key`).
## optimize\_dry\_run\_check\_part
Lorsqu’il est activé, `OPTIMIZE ... DRY RUN` valide la part fusionnée obtenue à l’aide de `checkDataPart`. Si la vérification échoue, une exception est levée.
## optimize\_empty\_string\_comparisons
Convertit les expressions telles que col = '' ou '' = col en empty(col), et col != '' ou '' != col en notEmpty(col),
uniquement lorsque col est de type String ou FixedString.
Autorise l’extraction des expressions communes des disjonctions dans les expressions WHERE, PREWHERE, ON, HAVING et QUALIFY. Une expression logique comme `(A AND B) OR (A AND C)` peut être réécrite en `A AND (B OR C)`, ce qui peut aider à exploiter :
* les index dans des expressions de filtrage simples
* l’optimisation de CROSS JOIN en INNER JOIN
## optimize\_functions\_to\_subcolumns
Active ou désactive l’optimisation qui consiste à réécrire certaines fonctions pour lire des sous-colonnes. Cela réduit la quantité de données à lire.
Ces fonctions peuvent être réécrites :
* [length](/fr/reference/functions/regular-functions/array-functions#length) pour lire la sous-colonne [size0](/fr/reference/data-types/array#array-size).
* [empty](/fr/reference/functions/regular-functions/array-functions#empty) pour lire la sous-colonne [size0](/fr/reference/data-types/array#array-size).
* [notEmpty](/fr/reference/functions/regular-functions/array-functions#notEmpty) pour lire la sous-colonne [size0](/fr/reference/data-types/array#array-size).
* [isNull](/fr/reference/functions/regular-functions/functions-for-nulls#isNull) pour lire la sous-colonne [null](/fr/reference/data-types/nullable#finding-null).
* [isNotNull](/fr/reference/functions/regular-functions/functions-for-nulls#isNotNull) pour lire la sous-colonne [null](/fr/reference/data-types/nullable#finding-null).
* [count](/fr/reference/functions/aggregate-functions/count) pour lire la sous-colonne [null](/fr/reference/data-types/nullable#finding-null).
* [mapKeys](/fr/reference/functions/regular-functions/tuple-map-functions#mapKeys) pour lire la sous-colonne [keys](/fr/reference/data-types/map#reading-subcolumns-of-map).
* [mapValues](/fr/reference/functions/regular-functions/tuple-map-functions#mapValues) pour lire la sous-colonne [values](/fr/reference/data-types/map#reading-subcolumns-of-map).
Valeurs possibles :
* 0 — Optimisation désactivée.
* 1 — Optimisation activée.
## optimize\_group\_by\_constant\_keys
Optimiser GROUP BY lorsque toutes les clés du bloc sont constantes
## optimize\_group\_by\_function\_keys
Élimine les fonctions appliquées aux autres clés dans la clause GROUP BY
## optimize\_if\_chain\_to\_multiif
Remplace les enchaînements `if(cond1, then1, if(cond2, ...))` par `multiIf`. Actuellement, cela n'est pas avantageux pour les types numériques.
## optimize\_if\_transform\_strings\_to\_enum
Remplace les arguments de type String dans If et Transform par des enum. Désactivé par défaut, car cela pourrait entraîner une modification incohérente dans une requête distribuée, ce qui provoquerait son échec.
## optimize\_injective\_functions\_in\_group\_by
Remplace les fonctions injectives par leurs arguments dans la clause GROUP BY
## optimize\_injective\_functions\_in\_limit\_by
Remplace les fonctions injectives par leurs arguments dans la clause LIMIT BY.
Exemple : `LIMIT 5 BY toString(x)` devient `LIMIT 5 BY x`.
## optimize\_injective\_functions\_inside\_uniq
Supprime les fonctions injectives à un seul argument à l'intérieur des fonctions uniq\*().
## optimize\_inverse\_dictionary\_lookup
Évite les recherches inverses répétées dans le dictionnaire en effectuant des recherches plus rapides dans un ensemble précalculé de valeurs de clé possibles.
## optimize\_limit\_by\_function\_keys
Supprime, dans la clause LIMIT BY, les clés qui sont des fonctions d’autres clés.
Exemple : `LIMIT 5 BY x, f(x)` devient `LIMIT 5 BY x`.
## optimize\_limit\_by\_in\_order
Optimise les requêtes `SELECT ... LIMIT N BY ` lorsque `` (dans n’importe quel ordre) constituent un préfixe de la clé de tri de la table, ou le deviennent après que `WHERE col = const` a fixé les premières colonnes. Lorsque ce paramètre est activé, la source lit les données dans l’ordre de la clé primaire, de sorte que les lignes ayant les mêmes valeurs pour les colonnes `BY` arrivent de façon contiguë dans chaque flux. Lorsque les données arrivent dans un seul flux trié, `LIMIT BY` les filtre en mode streaming avec une mémoire O(1), au lieu de construire une table de hachage pour chaque combinaison distincte de colonnes `BY` rencontrée. Lorsque les données triées arrivent dans plusieurs flux et que les mêmes valeurs `BY` peuvent apparaître dans plusieurs d’entre eux, chaque flux est d’abord préfiltré en mode streaming jusqu’à un maximum de `LIMIT + OFFSET` lignes par groupe, puis les flux sont combinés et un `LIMIT BY` final, basé sur une table de hachage, déduplique les groupes qui s’étendent sur plusieurs flux. Cette passe finale conserve malgré tout une entrée pour chaque combinaison distincte de colonnes `BY`, mais elle ne traite que les lignes préfiltrées.
## optimize\_min\_equality\_disjunction\_chain\_length
Longueur minimale de l’expression `expr = x1 OR ... expr = xN` pour l’optimisation
## optimize\_min\_inequality\_conjunction\_chain\_length
Longueur minimale de l’expression `expr <> x1 AND ... expr <> xN` pour l’optimisatio
## optimize\_move\_to\_prewhere
Active ou désactive l’optimisation automatique de [PREWHERE](/fr/reference/statements/select/prewhere) pour les requêtes [SELECT](/fr/reference/statements/select/index).
Fonctionne uniquement avec les tables [\*MergeTree](/fr/reference/engines/table-engines/mergetree-family/index).
Valeurs possibles :
* 0 — L’optimisation automatique de `PREWHERE` est désactivée.
* 1 — L’optimisation automatique de `PREWHERE` est activée.
## optimize\_move\_to\_prewhere\_if\_final
Active ou désactive l’optimisation automatique de [PREWHERE](/fr/reference/statements/select/prewhere) dans les requêtes [SELECT](/fr/reference/statements/select/index) avec le modificateur [FINAL](/fr/reference/statements/select/from#final-modifier).
Fonctionne uniquement pour les tables [\*MergeTree](/fr/reference/engines/table-engines/mergetree-family/index).
Valeurs possibles :
* 0 — L’optimisation automatique de `PREWHERE` dans les requêtes `SELECT` avec le modificateur `FINAL` est désactivée.
* 1 — L’optimisation automatique de `PREWHERE` dans les requêtes `SELECT` avec le modificateur `FINAL` est activée.
**Voir aussi**
* paramètre [optimize\_move\_to\_prewhere](#optimize_move_to_prewhere)
## optimize\_multiif\_to\_if
Remplace « multiIf » par « if » lorsqu'il n'y a qu'une seule condition.
## optimize\_normalize\_count\_variants
Réécrire les fonctions d’agrégation équivalentes à count() sur le plan sémantique en count().
## optimize\_on\_insert
Active ou désactive la transformation des données avant l’insertion, comme si une fusion avait été effectuée sur ce bloc (selon le moteur de table).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
**Exemple**
Différence entre activé et désactivé :
Requête :
```sql theme={null}
SET optimize_on_insert = 1;
CREATE TABLE test1 (`FirstTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY FirstTable;
INSERT INTO test1 SELECT number % 2 FROM numbers(5);
SELECT * FROM test1;
SET optimize_on_insert = 0;
CREATE TABLE test2 (`SecondTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY SecondTable;
INSERT INTO test2 SELECT number % 2 FROM numbers(5);
SELECT * FROM test2;
```
Résultat :
```text theme={null}
┌─FirstTable─┐
│ 0 │
│ 1 │
└────────────┘
┌─SecondTable─┐
│ 0 │
│ 0 │
│ 0 │
│ 1 │
│ 1 │
└─────────────┘
```
Notez que ce paramètre influe sur le comportement des [vues matérialisées](/fr/reference/statements/create/view#materialized-view).
## optimize\_or\_like\_chain
Optimise plusieurs expressions OR LIKE en multiMatchAny. Cette optimisation ne doit pas être activée par défaut, car dans certains cas, elle empêche l’analyse des index.
## optimize\_prewhere\_after\_pushdown
Exécute une seconde passe de promotion de `PREWHERE` après que des optimisations ultérieures du plan de requête ont pu
ajouter des filtres supplémentaires au-dessus d’une étape de lecture `MergeTree` (par ex. pushdown de prédicats via
`JOIN`, réécritures de projection). Lorsqu’un `PREWHERE` existe déjà, le nouveau
filtre y est fusionné avec `AND` au lieu de rester une étape de filtrage distincte.
## optimize\_qbit\_distance\_function\_reads
Remplace les fonctions de distance sur le type de données `QBit` par des fonctions équivalentes qui ne lisent dans le stockage que les colonnes nécessaires au calcul.
## optimize\_read\_in\_order
Active l’optimisation de [ORDER BY](/fr/reference/statements/select/order-by#optimization-of-data-reading) dans les requêtes [SELECT](/fr/reference/statements/select/index) lors de la lecture de données à partir des tables [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree).
Valeurs possibles :
* 0 — l’optimisation `ORDER BY` est désactivée.
* 1 — l’optimisation `ORDER BY` est activée.
**Voir aussi**
* [Clause ORDER BY](/fr/reference/statements/select/order-by#optimization-of-data-reading)
## optimize\_redundant\_functions\_in\_order\_by
Supprime les fonctions de ORDER BY lorsque leur argument figure également dans ORDER BY
## optimize\_respect\_aliases
Si ce paramètre est défini sur true, les alias seront pris en compte dans WHERE/GROUP BY/ORDER BY, ce qui contribuera à l’élagage des partitions, aux index secondaires, à optimize\_aggregation\_in\_order, à optimize\_read\_in\_order et à optimize\_trivial\_count
## optimize\_rewrite\_aggregate\_function\_with\_if
Réécrit les fonctions d’agrégation dont l’argument est une expression if, lorsqu’elles sont logiquement équivalentes.
Par exemple, `avg(if(cond, col, null))` peut être réécrit en `avgOrNullIf(cond, col)`. Cela peut améliorer les performances.
Pris en charge uniquement avec l’analyseur (`enable_analyzer = 1`).
## optimize\_rewrite\_array\_exists\_to\_has
Réécrit les fonctions arrayExists() en has() lorsqu’elles sont logiquement équivalentes. Par exemple, arrayExists(x -> x = 1, arr) peut être réécrit en has(arr, 1)
## optimize\_rewrite\_has\_to\_in
Réécrit les fonctions `has` en `IN` lorsque le premier argument est un Array constant. Par exemple, `has([1, 2, 3], x)` peut être réécrit en `x IN [1, 2, 3]` pour de meilleures performances avec des Array constants
## optimize\_rewrite\_like\_perfect\_affix
Réécrit les expressions LIKE avec un préfixe ou un suffixe exact (par ex. `col LIKE 'ClickHouse%'`) en appels aux fonctions startsWith ou endsWith (par ex. `startsWith(col, 'ClickHouse')`).
## optimize\_rewrite\_regexp\_functions
Réécrit les fonctions liées aux expressions régulières sous des formes plus simples et plus performantes
## optimize\_rewrite\_sum\_if\_to\_count\_if
Réécrit les fonctions sumIf() et sum(if()) en countIf() lorsqu’elles sont logiquement équivalentes
## optimize\_skip\_merged\_partitions
Active ou désactive l’optimisation de la requête [OPTIMIZE TABLE ... FINAL](/fr/reference/statements/optimize) lorsqu’il n’existe qu’une seule partie avec un niveau > 0 et qu’elle n’a pas de TTL expiré.
* `OPTIMIZE TABLE ... FINAL SETTINGS optimize_skip_merged_partitions=1`
Par défaut, la requête `OPTIMIZE TABLE ... FINAL` réécrit cette partie même s’il n’en existe qu’une seule.
Valeurs possibles :
* 1 - Activer l’optimisation.
* 0 - Désactiver l’optimisation.
## optimize\_skip\_unused\_shards
Active ou désactive l’omission des shards inutilisés pour les requêtes [SELECT](/fr/reference/statements/select/index) qui comportent une condition sur la clé de sharding dans `WHERE/PREWHERE`, et active les optimisations associées pour les requêtes distribuées (par exemple, l’agrégation par clé de sharding).
Suppose que les données sont distribuées selon la clé de sharding ; sinon, la requête renvoie un résultat incorrect.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## optimize\_skip\_unused\_shards\_limit
Limite du nombre de valeurs de la clé de sharding ; désactive `optimize_skip_unused_shards` si cette limite est atteinte.
Un trop grand nombre de valeurs peut nécessiter beaucoup de ressources de traitement, pour un bénéfice incertain, car si vous avez un très grand nombre de valeurs dans `IN (...)`, la requête sera très probablement envoyée à tous les shards de toute façon.
## optimize\_skip\_unused\_shards\_nesting
Contrôle le comportement de [`optimize_skip_unused_shards`](#optimize_skip_unused_shards) en fonction du niveau d'imbrication de la requête distribuée (cela nécessite donc toujours [`optimize_skip_unused_shards`](#optimize_skip_unused_shards)). Cela correspond au cas où une table `Distributed` interroge une autre table `Distributed`.
Valeurs possibles :
* 0 — Désactivé, `optimize_skip_unused_shards` fonctionne toujours.
* 1 — Active `optimize_skip_unused_shards` uniquement pour le premier niveau.
* 2 — Active `optimize_skip_unused_shards` jusqu'au deuxième niveau.
## optimize\_skip\_unused\_shards\_rewrite\_in
Réécrit l'expression IN de la requête pour les shards distants afin d'exclure les valeurs qui n'appartiennent pas au shard (nécessite optimize\_skip\_unused\_shards).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## optimize\_sorting\_by\_input\_stream\_properties
Optimise le tri en fonction des propriétés de tri du flux d’entrée
## optimize\_substitute\_columns
Utilisez les [contraintes](/fr/reference/statements/create/table#constraints) pour substituer des colonnes. La valeur par défaut est `false`.
Valeurs possibles :
* true, false
## optimize\_syntax\_fuse\_functions
Active la fusion des fonctions d’agrégation ayant le même argument. Réécrit les requêtes contenant au moins deux fonctions d’agrégation parmi [sum](/fr/reference/functions/aggregate-functions/sum), [count](/fr/reference/functions/aggregate-functions/count) ou [avg](/fr/reference/functions/aggregate-functions/avg) avec le même argument en [sumCount](/fr/reference/functions/aggregate-functions/sumCount).
Valeurs possibles :
* 0 — Les fonctions ayant le même argument ne sont pas fusionnées.
* 1 — Les fonctions ayant le même argument sont fusionnées.
**Exemple**
Requête :
```sql theme={null}
CREATE TABLE fuse_tbl(a Int8, b Int8) Engine = Log;
SET optimize_syntax_fuse_functions = 1;
EXPLAIN SYNTAX run_query_tree_passes = 1 SELECT sum(a), sum(b), count(b), avg(b) from fuse_tbl FORMAT TSV;
```
Résultat :
```text theme={null}
SELECT
sum(__table1.a) AS `sum(a)`,
tupleElement(sumCount(__table1.b), 1) AS `sum(b)`,
tupleElement(sumCount(__table1.b), 2) AS `count(b)`,
divide(tupleElement(sumCount(__table1.b), 1), toFloat64(tupleElement(sumCount(__table1.b), 2))) AS `avg(b)`
FROM default.fuse_tbl AS __table1
```
## optimize\_throw\_if\_noop
Active ou désactive le déclenchement d’une exception si une requête [OPTIMIZE](/fr/reference/statements/optimize) n’a effectué aucune fusion.
Par défaut, `OPTIMIZE` se termine avec succès même s’il n’a rien fait. Ce paramètre vous permet de distinguer ces situations et d’obtenir la raison dans un message d’exception.
Valeurs possibles :
* 1 — Le déclenchement d’une exception est activé.
* 0 — Le déclenchement d’une exception est désactivé.
## optimize\_time\_filter\_with\_preimage
col >= '2023-01-01' AND col <= '2023-12-31')"}]}]} />
Optimiser les prédicats Date et DateTime en convertissant les fonctions en comparaisons équivalentes, sans conversion (par ex. `toYear(col) = 2023 -> col >= '2023-01-01' AND col <= '2023-12-31'`)
## optimize\_trivial\_approximate\_count\_query
Utilise une valeur approximative pour l’optimisation des requêtes count triviales sur les moteurs de stockage qui prennent en charge ce type d’estimation, par exemple EmbeddedRocksDB.
Valeurs possibles :
* 0 — Optimisation désactivée.
* 1 — Optimisation activée.
## optimize\_trivial\_count\_query
Active ou désactive l’optimisation de la requête triviale `SELECT count() FROM table` à l’aide des métadonnées de MergeTree. Si vous devez utiliser la sécurité au niveau des lignes, désactivez ce paramètre.
Valeurs possibles :
* 0 — Optimisation désactivée.
* 1 — Optimisation activée.
Voir aussi :
* [optimize\_functions\_to\_subcolumns](#optimize_functions_to_subcolumns)
## optimize\_trivial\_group\_by\_limit\_query
Active ou désactive l’optimisation d’une requête triviale `SELECT key_expr FROM table GROUP BY key_expr LIMIT n` (sans fonctions d’agrégation dans la projection, sans clauses `HAVING`/`ORDER BY`/`LIMIT BY`/window, et sans modificateurs `GROUP BY`) en définissant `max_rows_to_group_by = n + offset` avec `group_by_overflow_mode = 'any'`. L’agrégation s’arrête dès que `n + offset` clés distinctes ont été produites.
L’optimisation est désactivée lorsque l’utilisateur a explicitement défini `group_by_overflow_mode` sur une valeur autre que `any` (afin de préserver le comportement explicite `throw`/`break`), ainsi que lorsque l’utilisateur a déjà défini un `max_rows_to_group_by` plus restrictif (l’optimisation serait alors sans effet).
Valeurs possibles :
* 0 — Optimisation désactivée.
* 1 — Optimisation activée.
## optimize\_trivial\_insert\_select
Optimiser la requête triviale `INSERT INTO table SELECT ... FROM TABLES`
## optimize\_truncate\_order\_by\_after\_group\_by\_keys
Supprime les éléments ORDER BY finaux une fois que toutes les clés du GROUP BY sont incluses dans le préfixe ORDER BY.
## optimize\_uniq\_to\_count
Réécrit uniq et ses variantes (sauf uniqUpTo) en count si la sous-requête contient DISTINCT ou une clause GROUP BY.
## optimize\_use\_implicit\_projections
Sélectionne automatiquement les projections implicites pour exécuter la requête SELECT
## optimize\_use\_projection\_filtering
Permet d’utiliser les projections pour filtrer les plages de parts, même lorsque les projections ne sont pas sélectionnées pour exécuter la requête SELECT.
## optimize\_use\_projections
**Alias** : `allow_experimental_projection_optimization`
Active ou désactive l’optimisation des [projections](/fr/reference/engines/table-engines/mergetree-family/mergetree#projections) pendant le traitement des requêtes `SELECT`.
Valeurs possibles :
* 0 — Optimisation des projections désactivée.
* 1 — Optimisation des projections activée.
## optimize\_using\_constraints
Utilisez les [contraintes](/fr/reference/statements/create/table#constraints) pour optimiser les requêtes. La valeur par défaut est `false`.
Valeurs possibles :
* true, false
## os\_threads\_nice\_value\_materialized\_view
Valeur nice Linux pour les threads des vues matérialisées. Plus la valeur est faible, plus la priorité CPU est élevée.
Nécessite la capacité CAP\_SYS\_NICE, sinon aucun effet.
Valeurs possibles : -20 à 19.
## os\_threads\_nice\_value\_query
**Alias** : `os_thread_priority`
Valeur nice Linux pour les threads de traitement des requêtes. Plus la valeur est faible, plus la priorité CPU est élevée.
Nécessite la capacité CAP\_SYS\_NICE, sinon aucun effet.
Valeurs possibles : -20 à 19.
## page\_cache\_block\_size
Taille des fragments de fichier à stocker dans le cache de pages en espace utilisateur, en octets. Toutes les lectures qui passent par le cache seront arrondies au multiple supérieur de cette taille.
Ce paramètre peut être ajusté au niveau de chaque requête, mais les entrées de cache avec des tailles de bloc différentes ne peuvent pas être réutilisées. Modifier ce paramètre invalide de fait les entrées existantes du cache.
Une valeur plus élevée, comme 1 MiB, convient bien aux requêtes à haut débit, tandis qu'une valeur plus faible, comme 64 KiB, convient bien aux requêtes ponctuelles à faible latence.
## page\_cache\_inject\_eviction
Le cache de pages en espace utilisateur invalide parfois certaines pages de façon aléatoire. Destiné aux tests.
## page\_cache\_lookahead\_blocks
Lorsqu'il y a un défaut dans le cache de pages en espace utilisateur, jusqu'à ce nombre de blocs consécutifs sont lus en une seule fois depuis le stockage sous-jacent, s'ils ne se trouvent pas non plus dans le cache. Chaque bloc fait page\_cache\_block\_size octets.
Une valeur plus élevée est bénéfique pour les requêtes à haut débit, tandis que les requêtes ponctuelles à faible latence fonctionneront mieux sans prélecture.
## page\_cache\_max\_coalesced\_bytes
Lorsque `readBigAt` alimente le cache de pages en espace utilisateur, les défauts de cache consécutifs sont regroupés en une seule lecture depuis le stockage sous-jacent. Ce paramètre limite la taille, en octets, d'une lecture coalescée ; les séries de défauts plus longues sont divisées en plusieurs lectures. Il limite l'utilisation transitoire de la mémoire du tampon temporaire lors de lectures à froid parallèles.
Une valeur plus élevée réduit le nombre de requêtes HTTP lors de scans à froid sur le stockage objet ; une valeur plus faible réduit le pic de mémoire transitoire.
## paimon\_target\_snapshot\_id
Lecture ciblée d’un instantané au niveau de la requête pour le mode incrémental de Paimon. Lorsque >0, le lecteur récupère uniquement le delta
pour le snapshot\_id spécifié sans faire avancer le watermark validé.
Par défaut : -1 (désactivé)
## parallel\_distributed\_insert\_select
Active l’exécution parallèle des requêtes distribuées `INSERT ... SELECT`.
Si l’on exécute des requêtes `INSERT INTO distributed_table_a SELECT ... FROM distributed_table_b`, que les deux tables utilisent le même cluster et qu’elles sont toutes deux soit [répliquées](/fr/reference/engines/table-engines/mergetree-family/replication), soit non répliquées, alors la requête est traitée localement sur chaque shard.
Valeurs possibles :
* `0` — Désactivé.
* `1` — `SELECT` sera exécuté sur chaque shard à partir de la table sous-jacente du moteur Distributed.
* `2` — `SELECT` et `INSERT` seront exécutés sur chaque shard, à partir de/vers la table sous-jacente du moteur Distributed.
Depuis la version 25.4, `INSERT ... SELECT` à partir d’une source `ReplicatedMergeTree` ou `SharedMergeTree` peut également être parallélisé entre les répliques. Pour l’activer :
* `parallel_distributed_insert_select = 2`
* `enable_parallel_replicas = 1`
## parallel\_hash\_join\_threshold
Lorsque l'algorithme de jointure fondé sur le hachage est utilisé, ce seuil aide à déterminer s'il faut utiliser `hash` ou `parallel_hash` (uniquement si une estimation de la taille de la table de droite est disponible).
Le premier est utilisé lorsque nous savons que la taille de la table de droite est inférieure au seuil.
## parallel\_non\_joined\_rows\_processing
Autorise plusieurs threads à traiter en parallèle les lignes non jointes de la table de droite lors des JOIN RIGHT et FULL.
Cela peut accélérer la phase de traitement des lignes non jointes lors de l'utilisation de l'algorithme de jointure `parallel_hash` avec de grandes tables.
Lorsqu'il est désactivé, les lignes non jointes sont traitées par un seul thread.
## parallel\_replica\_offset
Il s'agit d'un paramètre interne qui ne doit pas être utilisé directement et qui correspond à un détail d'implémentation du mode « répliques parallèles ». Ce paramètre sera automatiquement défini par le serveur initiateur, pour les requêtes distribuées, sur l'index de la réplique participant au traitement de la requête parmi les répliques parallèles.
## parallel\_replicas\_allow\_in\_with\_subquery
Si la valeur est true, la sous-requête de IN sera exécutée sur chaque réplique suiveuse.
## parallel\_replicas\_allow\_materialized\_views
Autoriser l’utilisation des vues matérialisées avec les répliques parallèles
## parallel\_replicas\_allow\_view\_over\_mergetree
Autorise les répliques parallèles à exécuter la requête externe d’une vue simple sur des tables `MergeTree` (au lieu de la requête interne de la vue), ce qui améliore la parallélisation entre les nœuds. S’applique également aux vues `UNION ALL` dont toutes les branches lisent chacune dans des tables `MergeTree` différentes.
## parallel\_replicas\_connect\_timeout\_ms
Le délai d’attente, en millisecondes, pour établir une connexion à une réplique distante lors de l’exécution d’une requête avec des répliques parallèles. Si le délai d’attente expire, la réplique correspondante n’est pas utilisée pour l’exécutio
## parallel\_replicas\_count
Ce paramètre interne ne doit pas être utilisé directement et correspond à un détail d’implémentation du mode « répliques parallèles ». Il sera automatiquement défini par le serveur initiateur, pour les requêtes distribuées, sur le nombre de répliques parallèles participant au traitement de la requête.
## parallel\_replicas\_custom\_key
Expression entière arbitraire pouvant être utilisée pour répartir la charge entre les répliques d’une table donnée.
La valeur peut être n’importe quelle expression entière.
Il est préférable d’utiliser des expressions simples basées sur les clés primaires.
Si ce paramètre est utilisé sur un cluster composé d’un seul shard avec plusieurs répliques, ces répliques seront converties en shards virtuels.
Sinon, il se comportera de la même manière que pour la clé `SAMPLE` : il utilisera plusieurs répliques de chaque shard.
## parallel\_replicas\_custom\_key\_range\_lower
Permet au filtre de type `range` de répartir uniformément le travail entre les répliques en fonction de la plage personnalisée `[parallel_replicas_custom_key_range_lower, INT_MAX]`.
Lorsqu’il est utilisé conjointement avec [parallel\_replicas\_custom\_key\_range\_upper](#parallel_replicas_custom_key_range_upper), il permet au filtre de répartir uniformément le travail entre les répliques pour la plage `[parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper]`.
Remarque : ce paramètre n’entraîne pas le filtrage de données supplémentaires pendant le traitement des requêtes ; il modifie plutôt les points auxquels le filtre de plage découpe la plage `[0, INT_MAX]` pour le traitement parallèle.
## parallel\_replicas\_custom\_key\_range\_upper
Permet au filtre de type `range` de répartir uniformément le travail entre les répliques en fonction de la plage personnalisée `[0, parallel_replicas_custom_key_range_upper]`. Une valeur de 0 désactive la borne supérieure et la définit sur la valeur maximale de l’expression de clé personnalisée.
Lorsqu’il est utilisé conjointement avec [parallel\_replicas\_custom\_key\_range\_lower](#parallel_replicas_custom_key_range_lower), il permet au filtre de répartir uniformément le travail entre les répliques sur la plage `[parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper]`.
Remarque : ce paramètre n’entraîne pas le filtrage de données supplémentaires pendant le traitement des requêtes ; il modifie plutôt les points auxquels le filtre de plage découpe la plage `[0, INT_MAX]` pour le traitement parallèle
## parallel\_replicas\_filter\_pushdown
Permet de pousser les filtres vers la partie de la requête exécutée par les répliques parallèles
## parallel\_replicas\_for\_cluster\_engines
Remplacer les moteurs de fonctions de table par leurs équivalents -Cluster
## parallel\_replicas\_for\_non\_replicated\_merge\_tree
Si la valeur est true, ClickHouse utilisera également l’algorithme des répliques parallèles pour les tables MergeTree non répliquées
## parallel\_replicas\_index\_analysis\_only\_on\_coordinator
Analyse des index effectuée uniquement sur la réplique coordinatrice et ignorée sur les autres répliques. Prend effet uniquement lorsque parallel\_replicas\_local\_pla est activé
## parallel\_replicas\_insert\_select\_local\_pipeline
Utiliser le pipeline local pour un INSERT SELECT distribué avec des répliques parallèles
## parallel\_replicas\_local\_plan
Construire un plan local pour la réplique locale
## parallel\_replicas\_mark\_segment\_size
Les parts sont virtuellement divisées en segments afin d'être réparties entre les répliques pour une lecture parallèle. Ce paramètre contrôle la taille de ces segments. Il n'est pas recommandé de le modifier tant que vous n'êtes pas absolument certain de ce que vous faites. La valeur doit être comprise dans l'intervalle \[128; 16384]
## parallel\_replicas\_min\_number\_of\_rows\_per\_replica
Limite le nombre de répliques utilisées dans une requête à (nombre estimé de lignes à lire / min\_number\_of\_rows\_per\_replica). Le maximum reste toutefois limité par 'max\_parallel\_replicas'
## parallel\_replicas\_mode
Type de filtre à utiliser avec une clé personnalisée pour les répliques parallèles. default - utilise l'opération modulo sur la clé personnalisée, range - utilise un filtre de plage sur la clé personnalisée en se servant de toutes les valeurs possibles du type de valeur de la clé personnalisée.
## parallel\_replicas\_only\_with\_analyzer
L’analyseur doit être activé pour utiliser les répliques parallèles. Lorsque l’analyseur est désactivé, l’exécution de la requête revient à une exécution locale, même si la lecture parallèle depuis les répliques est activée. L’utilisation des répliques parallèles sans l’analyseur activé n’est pas prise en charge
## parallel\_replicas\_prefer\_local\_join
Si cette valeur est true, que JOIN peut être exécuté avec l’algorithme de réplique parallèle et que tous les moteurs de stockage de la partie droite du JOIN sont de type \*MergeTree, un JOIN local sera utilisé au lieu de GLOBAL JOIN.
## parallel\_replicas\_prefer\_local\_replica
Lorsqu’elle est activée (par défaut), la réplique locale est toujours incluse dans l’ensemble des répliques utilisées pour la lecture parallèle.
Lorsqu’elle est désactivée, la réplique locale ne bénéficie d’aucune préférence et les répliques sont sélectionnées uniquement par l’algorithme d’équilibrage de charge.
Cela permet d’acheminer les requêtes avec `max_parallel_replicas = 1` vers un autre hôte, ce qui peut améliorer la localité de cache lorsque de nombreuses requêtes courtes sont réparties sur un cluster.
## parallel\_replicas\_support\_projection
L’optimisation des projections peut être appliquée sur des répliques parallèles. N’a d’effet que si parallel\_replicas\_local\_plan est activé et que aggregation\_in\_order est inactif.
## parallel\_view\_processing
Active l’envoi vers les vues attachées en parallèle plutôt que de façon séquentielle.
## parallelize\_output\_from\_storages
Parallélise la sortie à l’étape de lecture depuis le stockage. Cela permet de paralléliser le traitement des requêtes immédiatement après la lecture depuis le stockage, lorsque c’est possible
## parsedatetime\_e\_requires\_space\_padding
Le spécificateur de format '%e' dans la fonction 'parseDateTime' exige que les jours sur un seul chiffre soient complétés par des espaces. Par exemple, ' 2' est accepté, mais '2' génère une erreur.
## parsedatetime\_parse\_without\_leading\_zeros
Les spécificateurs de format '%c', '%l' et '%k' de la fonction 'parseDateTime' analysent les mois et les heures sans zéro non significatif.
## partial\_merge\_join\_left\_table\_buffer\_bytes
Si cette valeur n’est pas 0, regroupe les blocs de la table de gauche en blocs plus volumineux pour la table de gauche dans la jointure par fusion partielle. Utilise jusqu’à 2x la mémoire spécifiée par thread de jointure.
## partial\_merge\_join\_rows\_in\_right\_blocks
Limite la taille des blocs de données de la partie droite de la jointure dans l’algorithme de jointure par fusion partielle pour les requêtes [JOIN](/fr/reference/statements/select/join).
Le serveur ClickHouse :
1. Divise les données de la partie droite de la jointure en blocs contenant jusqu’au nombre de lignes spécifié.
2. Indexe chaque bloc avec ses valeurs minimale et maximale.
3. Décharge les blocs préparés sur le disk si possible.
Valeurs possibles :
* Tout entier positif. Plage de valeurs recommandée : \[1000, 100000].
## partial\_result\_on\_first\_cancel
Permet à une requête de renvoyer un résultat partiel après annulation.
## parts\_to\_delay\_insert
Si la table de destination contient au moins ce nombre de parts actives dans une seule partition, les insertions dans la table sont artificiellement ralenties.
## parts\_to\_throw\_insert
Si le nombre de parts actives dans une même partition de la table de destination dépasse cette valeur, l'exception 'Too many parts ...' est levée.
## per\_part\_index\_stats
Consigne les statistiques d’index pour chaque part
## poll\_interval
Bloque la boucle d’attente des requêtes sur le serveur pendant le nombre de secondes spécifié.
## polyglot\_dialect
Dialecte SQL source du transpileur polyglotte (par exemple, 'sqlite', 'mysql', 'postgresql', 'snowflake', 'duckdb').
## postgresql\_connection\_attempt\_timeout
Délai d’expiration, en secondes, d’une tentative unique de connexion au point de terminaison PostgreSQL.
La valeur est transmise comme paramètre `connect_timeout` dans l’URL de connexion.
## postgresql\_connection\_pool\_auto\_close\_connection
Fermer la connexion avant de la renvoyer au pool de connexions.
## postgresql\_connection\_pool\_retries
Nombre de tentatives push/pop du pool de connexions pour le moteur de table et le moteur de base de données PostgreSQL.
## postgresql\_connection\_pool\_size
Taille du pool de connexions pour le moteur de table PostgreSQL et le moteur de base de données.
## postgresql\_connection\_pool\_wait\_timeout
Délai d’expiration des opérations push/pop du pool de connexions lorsque celui-ci est vide, pour le moteur de table PostgreSQL et le moteur de base de données. Par défaut, l’opération reste bloquante lorsque le pool est vide.
## postgresql\_fault\_injection\_probability
Probabilité approximative d’échec des requêtes PostgreSQL internes (utilisées pour la réplication). La valeur valide se situe dans l’intervalle \[0.0f, 1.0f]
## predicate\_statistics\_sample\_rate
Collecte les statistiques de sélectivité des prédicats dans `system.predicate_statistics_log`. Lorsqu’il est défini sur N > 0, environ 1/N des requêtes sont échantillonnées (selon l’ID de requête). 0 signifie que cette fonctionnalité est désactivée.
## prefer\_column\_name\_to\_alias
Active ou désactive l’utilisation des noms de colonnes d’origine à la place des alias dans les expressions et les clauses de requête. Cela est particulièrement important lorsque l’alias est identique au nom de la colonne, voir [Expression Aliases](/fr/reference/syntax#notes-on-usage). Activez ce paramètre pour rendre les règles de syntaxe des alias dans ClickHouse plus compatibles avec celles de la plupart des autres moteurs de base de données.
Valeurs possibles :
* 0 — Le nom de la colonne est remplacé par l’alias.
* 1 — Le nom de la colonne n’est pas remplacé par l’alias.
**Exemple**
Différence entre l’option activée et désactivée :
Requête :
```sql theme={null}
SET prefer_column_name_to_alias = 0;
SELECT avg(number) AS number, max(number) FROM numbers(10);
```
Résultat :
```text theme={null}
Received exception from server (version 21.5.1):
Code: 184. DB::Exception: Received from localhost:9000. DB::Exception: Aggregate function avg(number) is found inside another aggregate function in query: While processing avg(number) AS number.
```
Requête :
```sql theme={null}
SET prefer_column_name_to_alias = 1;
SELECT avg(number) AS number, max(number) FROM numbers(10);
```
Résultat :
```text theme={null}
┌─number─┬─max(number)─┐
│ 4.5 │ 9 │
└────────┴─────────────┘
```
## prefer\_external\_sort\_block\_bytes
Préférer la taille de bloc maximale pour le tri externe afin de réduire l’utilisation de la mémoire lors de la fusion.
## prefer\_global\_in\_and\_join
Active le remplacement des opérateurs `IN`/`JOIN` par `GLOBAL IN`/`GLOBAL JOIN`.
Valeurs possibles :
* 0 — Désactivé. Les opérateurs `IN`/`JOIN` ne sont pas remplacés par `GLOBAL IN`/`GLOBAL JOIN`.
* 1 — Activé. Les opérateurs `IN`/`JOIN` sont remplacés par `GLOBAL IN`/`GLOBAL JOIN`.
**Utilisation**
Bien que `SET distributed_product_mode=global` puisse modifier le comportement des requêtes sur les tables distribuées, cela ne convient pas aux tables locales ni aux tables issues de ressources externes. C’est là que le paramètre `prefer_global_in_and_join` entre en jeu.
Par exemple, nous pouvons avoir des nœuds qui traitent les requêtes et contiennent des tables locales, qui ne se prêtent pas à une distribution. Nous devons répartir leurs données à la volée pendant le traitement distribué à l’aide du mot-clé `GLOBAL` — `GLOBAL IN`/`GLOBAL JOIN`.
Un autre cas d’usage de `prefer_global_in_and_join` est l’accès à des tables créées par des moteurs externes. Ce paramètre permet de réduire le nombre d’appels aux sources externes lors de la jointure de telles tables : un seul appel par requête.
**Voir aussi :**
* [Sous-requêtes distribuées](/fr/reference/statements/in#distributed-subqueries) pour plus d’informations sur l’utilisation de `GLOBAL IN`/`GLOBAL JOIN`
## prefer\_localhost\_replica
Active ou désactive l’utilisation préférentielle de la réplique localhost lors du traitement des requêtes distribuées.
Valeurs possibles :
* 1 — ClickHouse envoie toujours une requête à la réplique localhost si elle existe.
* 0 — ClickHouse utilise la stratégie d’équilibrage spécifiée par le paramètre [load\_balancing](#load_balancing).
Désactivez ce paramètre si vous utilisez [max\_parallel\_replicas](#max_parallel_replicas) sans [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key).
Si [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key) est défini, désactivez ce paramètre uniquement s’il est utilisé sur un cluster comportant plusieurs shards avec plusieurs répliques.
S’il est utilisé sur un cluster comportant un seul shard et plusieurs répliques, la désactivation de ce paramètre aura des effets négatifs.
## prefer\_warmed\_unmerged\_parts\_seconds
N’a d’effet que dans ClickHouse Cloud. Si une part fusionnée date de moins de ce nombre de secondes et n’est pas préchauffée (voir [cache\_populated\_by\_fetch](/fr/reference/settings/merge-tree-settings#cache_populated_by_fetch)), mais que toutes ses parts sources sont disponibles et préchauffées, les requêtes SELECT liront ces parts à la place. Uniquement pour Replicated-/SharedMergeTree. Notez que cela vérifie uniquement si CacheWarmer a traité la part ; si la part a été mise en cache par un autre mécanisme, elle sera quand même considérée comme froide jusqu’à ce que CacheWarmer la traite ; si elle a été préchauffée puis évincée du cache, elle sera quand même considérée comme chaude.
## preferred\_block\_size\_bytes
Ce paramètre ajuste la taille du bloc de données pour le traitement des requêtes et affine le paramètre plus grossier 'max\_block\_size'. Si les colonnes sont volumineuses et que, avec 'max\_block\_size' lignes, la taille du bloc risque de dépasser le nombre d'octets spécifié, elle sera réduite afin d'améliorer la localité du cache CPU.
## preferred\_max\_column\_in\_block\_size\_bytes
Limite de la taille maximale d’une colonne dans un bloc lors de la lecture. Permet de réduire le nombre de défauts de cache. Elle doit être proche de la taille du cache L2.
## preferred\_optimize\_projection\_name
S’il est défini sur une chaîne de caractères non vide, ClickHouse essaiera d’appliquer la projection spécifiée dans la requête.
Valeurs possibles :
* String : nom de la projectio préférée
## prefetch\_buffer\_size
La taille maximale du tampon de prélecture pour la lecture depuis le système de fichiers.
## print\_pretty\_type\_names
Permet d’afficher de façon lisible les noms de types profondément imbriqués, avec indentation, dans la query `DESCRIBE` et dans la fonction `toTypeName()`.
Exemple :
```sql theme={null}
CREATE TABLE test (a Tuple(b String, c Tuple(d Nullable(UInt64), e Array(UInt32), f Array(Tuple(g String, h Map(String, Array(Tuple(i String, j UInt64))))), k Date), l Nullable(String))) ENGINE=Memory;
DESCRIBE TABLE test FORMAT TSVRaw SETTINGS print_pretty_type_names=1;
```
```
a Tuple(
b String,
c Tuple(
d Nullable(UInt64),
e Array(UInt32),
f Array(Tuple(
g String,
h Map(
String,
Array(Tuple(
i String,
j UInt64
))
)
)),
k Date
),
l Nullable(String)
)
```
## priority
Priorité de la requête. 1 - la plus élevée, plus la valeur est grande, plus la priorité est faible ; 0 - ne pas utiliser de priorités.
## promql\_database
Spécifie le nom de la base de données utilisé par le dialecte 'promql'. Une chaîne vide désigne la base de données actuelle.
## promql\_evaluation\_time
**Alias** : `evaluation_time`
Définit l’heure d’évaluation à utiliser pour le dialecte promql. 'auto' signifie l’heure actuelle.
## promql\_table
Indique le nom d'une table TimeSeries utilisée par le dialecte 'promql'.
## push\_external\_roles\_in\_interserver\_queries
Active la propagation des rôles utilisateur du nœud initiateur vers les autres nœuds lors de l’exécution d’une requête.
## query\_cache\_compress\_entries
Compresse les entrées du [cache de requêtes](/fr/concepts/features/performance/caches/query-cache). Réduit la consommation mémoire du cache de requêtes, au prix d'insertions et de lectures plus lentes.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## query\_cache\_for\_subqueries
Lorsqu'elle est activée, les résultats des sous-requêtes peuvent être écrits dans le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache) et lus depuis celui-ci. Cela permet de propager `use_query_cache` à toutes les sous-requêtes.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## query\_cache\_max\_entries
Le nombre maximal de résultats de requête que l’utilisateur courant peut stocker dans le [cache de requête](/fr/concepts/features/performance/caches/query-cache). 0 signifie qu’il n’y a pas de limite.
Valeurs possibles :
* Entier positif >= 0.
## query\_cache\_max\_size\_in\_bytes
La quantité maximale de mémoire (en octets) que l’utilisateur courant peut allouer dans le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache). 0 signifie qu’il n’y a pas de limite.
Valeurs possibles :
* Entier supérieur ou égal à 0.
## query\_cache\_min\_query\_duration
Durée minimale, en millisecondes, pendant laquelle une requête doit s’exécuter pour que son résultat soit stocké dans le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache).
Valeurs possibles :
* Entier >= 0.
## query\_cache\_min\_query\_runs
Nombre minimum d'exécutions d'une requête `SELECT` avant que son résultat ne soit stocké dans le [cache des requêtes](/fr/concepts/features/performance/caches/query-cache).
Valeurs possibles :
* Entier >= 0.
## query\_cache\_nondeterministic\_function\_handling
Contrôle la façon dont le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache) gère les requêtes `SELECT` contenant des fonctions non déterministes comme `rand()` ou `now()`.
Valeurs possibles :
* `'throw'` - Déclenche une exception et ne met pas en cache le résultat de la requête.
* `'save'` - Met en cache le résultat de la requête.
* `'ignore'` - Ne met pas en cache le résultat de la requête et ne déclenche pas d'exception.
## query\_cache\_share\_between\_users
Si cette option est activée, le résultat des requêtes `SELECT` mis en cache dans le [cache de requête](/fr/concepts/features/performance/caches/query-cache) peut être consulté par d'autres utilisateurs.
Il n'est pas recommandé d'activer ce paramètre pour des raisons de sécurité.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## query\_cache\_squash\_partial\_results
Regroupe les blocs de résultats partiels en blocs de taille [max\_block\_size](#max_block_size). Réduit les performances lors des insertions dans le [cache de requête](/fr/concepts/features/performance/caches/query-cache), mais améliore la compressibilité des entrées du cache (voir [query\_cache\_compress-entries](#query_cache_compress_entries)).
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## query\_cache\_system\_table\_handling
Contrôle la façon dont le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache) gère les requêtes `SELECT` sur les tables système, c’est-à-dire les tables des bases de données `system.*` et `information_schema.*`.
Valeurs possibles :
* `'throw'` - Lever une exception et ne pas mettre en cache le résultat de la requête.
* `'save'` - Mettre en cache le résultat de la requête.
* `'ignore'` - Ne pas mettre en cache le résultat de la requête et ne pas lever d’exception.
## query\_cache\_tag
Une chaîne de caractères servant d’étiquette pour les entrées du [cache de requêtes](/fr/concepts/features/performance/caches/query-cache).
Les mêmes requêtes avec des étiquettes différentes sont considérées comme différentes par le cache de requêtes.
Valeurs possibles :
* Toute chaîne de caractères
## query\_cache\_ttl
Après ce délai, en secondes, les entrées du [cache de requête](/fr/concepts/features/performance/caches/query-cache) deviennent obsolètes.
Valeurs possibles :
* Entier positif >= 0.
## query\_metric\_log\_interval
L’intervalle, en millisecondes, auquel le [query\_metric\_log](/fr/reference/system-tables/query_metric_log) est collecté pour chaque requête.
S’il est défini sur une valeur négative, il prendra la valeur `collect_interval_milliseconds` du [paramètre query\_metric\_log](/fr/reference/settings/server-settings/settings#query_metric_log), ou 1000 par défaut si celle-ci n’est pas définie.
Pour désactiver la collecte pour une requête unique, définissez `query_metric_log_interval` sur 0.
Valeur par défaut : -1
## query\_plan\_aggregation\_in\_order
Active ou désactive l’optimisation d’agrégation en ordre au niveau du plan de requête.
Ne prend effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) vaut 1.
Il s’agit d’un paramètre de niveau expert qui ne doit être utilisé par les développeurs qu’à des fins de débogage. Ce paramètre peut évoluer ultérieurement de manière non rétrocompatible, ou être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_convert\_any\_join\_to\_semi\_or\_anti\_join
Permet de convertir ANY JOIN en SEMI ou ANTI JOIN si le filtre appliqué après le JOIN s’évalue toujours à false pour les lignes correspondantes ou non correspondantes
## query\_plan\_convert\_join\_to\_in
Permet de convertir un `JOIN` en sous-requête avec `IN` si les colonnes de sortie ne dépendent que de la table de gauche. Peut produire des résultats incorrects avec des jointures autres que `ANY JOIN` (par exemple les `ALL JOIN`, qui constituent le comportement par défaut).
## query\_plan\_convert\_outer\_join\_to\_inner\_join
Permet de convertir un `OUTER JOIN` en `INNER JOIN` si le filtre appliqué après le `JOIN` exclut toujours les valeurs par défaut
## query\_plan\_direct\_read\_from\_text\_index
Permet d’effectuer le filtrage de recherche plein texte en n’utilisant que l’index de texte inversé dans le plan de requête.
## query\_plan\_display\_internal\_aliases
Afficher les alias internes (tels que \_\_table1) dans EXPLAIN PLAN au lieu de ceux spécifiés dans la requête d'origine.
## query\_plan\_enable\_multithreading\_after\_window\_functions
Activer le multithreading une fois les fonctions de fenêtre évaluées afin de permettre le traitement parallèle des flux
## query\_plan\_enable\_optimizations
Active ou désactive l’optimisation des requêtes au niveau du plan de requête.
Il s’agit d’un paramètre réservé aux experts, qui ne doit être utilisé par les développeurs qu’à des fins de débogage. Ce paramètre pourra, à l’avenir, être modifié de manière non rétrocompatible ou supprimé.
Valeurs possibles :
* 0 - Désactiver toutes les optimisations au niveau du plan de requête
* 1 - Activer les optimisations au niveau du plan de requête (mais certaines optimisations peuvent toujours être désactivées via leurs propres paramètres)
## query\_plan\_execute\_functions\_after\_sorting
Active ou désactive une optimisation au niveau du plan de requête qui déplace les expressions après les opérations de tri.
N’a d’effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) est défini sur 1.
Il s’agit d’un paramètre destiné aux experts, qui ne doit être utilisé pour le débogage que par les développeurs. Ce paramètre pourra évoluer ultérieurement de manière non rétrocompatible, voire être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_filter\_push\_down
Active ou désactive une optimisation au niveau du plan de requête qui pousse les filtres vers le bas dans le plan d'exécution.
N'a d'effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Il s'agit d'un paramètre destiné aux experts, qui ne doit être utilisé par les développeurs qu'à des fins de débogage. Ce paramètre peut être modifié ultérieurement de manière non rétrocompatible, voire supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_join\_shard\_by\_pk\_ranges
Applique le sharding aux JOIN si les clés de jointure contiennent un préfixe de PRIMARY KEY dans les deux tables. Pris en charge avec les algorithmes hash, parallel\_hash et full\_sorting\_merge. En général, cela n’accélère pas les requêtes, mais peut réduire la consommation de mémoire.
## query\_plan\_join\_swap\_table
Détermine quel côté de la jointure doit servir de table de build (également appelée table interne, c'est-à-dire celle insérée dans la table de hachage pour une jointure par hachage) dans le plan de requête. Ce paramètre n'est pris en charge que pour la strictness de jointure `ALL` avec la clause `JOIN ON`. Les valeurs possibles sont :
* 'auto' : laisser le planificateur décider quelle table utiliser comme table de build.
* 'false' : ne jamais permuter les tables (la table de droite est la table de build).
* 'true' : toujours permuter les tables (la table de gauche est la table de build).
## query\_plan\_lift\_up\_array\_join
Active ou désactive une optimisation au niveau du plan de requête qui remonte les ARRAY JOIN dans le plan d’exécution.
Ne prend effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Il s’agit d’un paramètre de niveau expert qui ne doit être utilisé à des fins de débogage que par les développeurs. Ce paramètre pourra, à l’avenir, changer de manière incompatible avec les versions précédentes ou être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_lift\_up\_union
Active ou désactive une optimisation au niveau du plan de requête qui déplace des sous-arbres plus importants du plan de requête vers union afin de permettre d’autres optimisations.
Ne prend effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) vaut 1.
Il s’agit d’un paramètre réservé aux experts, qui ne doit être utilisé par les développeurs qu’à des fins de débogage. Ce paramètre peut évoluer ultérieurement de manière non rétrocompatible, voire être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_max\_limit\_for\_join\_lazy\_indexing
Contrôle la valeur maximale de limite permettant d’utiliser le plan de requête pour l’optimisation d’indexation paresseuse des JOIN. Si cette valeur est égale à zéro, il n’y a pas de limite.
## query\_plan\_max\_limit\_for\_lazy\_materialization
Contrôle la valeur maximale de LIMIT autorisant l’utilisation du plan de requête pour l’optimisation de la matérialisation paresseuse. Si elle est égale à zéro, il n’y a pas de limite.
## query\_plan\_max\_limit\_for\_top\_k\_optimization
Définit la valeur maximale de LIMIT permettant d’évaluer le plan de requête pour l’optimisation TopK à l’aide de l’index de saut minmax et du filtrage dynamique par seuil. Si cette valeur est égale à zéro, aucune limite n’est appliquée.
## query\_plan\_max\_optimizations\_to\_apply
Limite le nombre total d’optimisations appliquées au plan de requête ; voir le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations).
Utile pour éviter des temps d’optimisation trop longs pour les requêtes complexes.
Avec la requête EXPLAIN PLAN, l’application des optimisations s’arrête une fois cette limite atteinte et le plan est renvoyé tel quel.
Lors de l’exécution normale d’une requête, si le nombre réel d’optimisations dépasse ce paramètre, une exception est levée.
Il s’agit d’un paramètre destiné aux experts, qui ne doit être utilisé pour le débogage que par les développeurs. Ce paramètre peut évoluer à l’avenir de manière non rétrocompatible, voire être supprimé.
## query\_plan\_max\_set\_size\_for\_projection\_match
Nombre maximal de lignes dans un ensemble de clause `IN` pour lequel le mécanisme de correspondance des projections calcule et compare des hachages de contenu afin de déterminer si deux ensembles sont égaux. Les ensembles plus grands que cette limite sont considérés comme non correspondants et n'utilisent pas la projection. La valeur zéro désactive entièrement la comparaison par hachage de contenu : une correspondance de projection ne réussit jamais pour les nœuds contenant des ensembles de clause `IN`.
Utilisé par le mécanisme de correspondance des projections d'agrégation (ainsi que par tout futur mécanisme de correspondance des projections devant comparer des ensembles de clause `IN`). Le calcul du hachage de contenu est en `O(N log N)` en fonction du nombre d'éléments de l'ensemble ; ce paramètre limite le coût de la planification lorsque de nombreuses clauses `IN` apparaissent dans la requête ou la projection.
## query\_plan\_max\_step\_description\_length
Longueur maximale de la description d'une étape dans EXPLAIN PLAN.
## query\_plan\_merge\_expressions
Active une optimisation au niveau du plan de requête qui fusionne les filtres consécutifs.
N'a d'effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Il s'agit d'un paramètre réservé aux experts, qui ne doit être utilisé à des fins de débogage que par les développeurs. Ce paramètre pourra, à l'avenir, être modifié de manière incompatible avec les versions précédentes ou être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_merge\_filter\_into\_join\_condition
Permet de fusionner le filtre dans la condition de `JOIN` et de convertir `CROSS JOIN` en `INNER`.
## query\_plan\_merge\_filters
Permet de fusionner les filtres dans le plan de requête.
## query\_plan\_min\_columns\_for\_join\_lazy\_indexing
Contrôle le nombre minimal de colonnes de payload du côté gauche nécessaire pour activer l’optimisation d’indexation paresseuse dans JOIN. 0 signifie que l’optimisation est désactivée.
## query\_plan\_optimize\_join\_order\_algorithm
Spécifie quels algorithmes d’ordre des jointures des JOIN essayer lors de l’optimisation du plan de requête. Les algorithmes suivants sont disponibles :
* `greedy` - algorithme glouton simple - fonctionne rapidement, mais peut ne pas produire le meilleur ordre de jointure
* `dpsize` - implémente l’algorithme DPsize, actuellement uniquement pour les jointures internes - examine tous les ordres de jointure possibles et trouve le meilleur, mais peut être lent pour les requêtes comportant de nombreuses tables et de nombreux prédicats de jointure
* `dphyp` - implémente l’algorithme DPhyp (programmation dynamique via partitionnement d’hypergraphe), actuellement uniquement pour les jointures internes - explore le même espace de recherche que `dpsize`, mais n’énumère que les paires de sous-graphes connectés, ce qui génère moins de jointures intermédiaires sur des graphes de jointure clairsemés, au prix de ne pas prendre en compte les produits cartésiens
Plusieurs algorithmes peuvent être spécifiés sous forme de liste séparée par des virgules, par exemple `dphyp,greedy`. Ils sont essayés dans l’ordre ; si un algorithme ne peut pas traiter la requête (par exemple en raison de jointures externes ou de composants déconnectés), le suivant est utilisé comme solution de repli.
## query\_plan\_optimize\_join\_order\_limit
Optimise l’ordre des jointures au sein d’une même sous-requête. Cette optimisation n’est actuellement prise en charge que dans des cas très limités.
La valeur correspond au nombre maximal de tables à optimiser.
## query\_plan\_optimize\_join\_order\_max\_searched\_plans
Nombre maximal de plans partiels que l’optimiseur d’ordre des jointures peut énumérer avant d’abandonner et de passer à l’algorithme suivant dans `query_plan_optimize_join_order_algorithm`.
Cela limite de manière déterministe le temps d’optimisation (indépendamment du temps écoulé) sur des graphes de jointure denses, tels que des cliques ou des étoiles, où l’espace de recherche croît de façon exponentielle.
Définissez cette valeur sur 0 pour désactiver la limite. Cela n’a aucun effet avec la valeur par défaut de `query_plan_optimize_join_order_limit`, pour laquelle la recherche reste toujours bien en dessous de cette borne.
## query\_plan\_optimize\_join\_order\_randomize
Lorsqu’il est non nul, l’optimiseur d’ordre des jointures utilise des cardinalités et des NDV générées aléatoirement au lieu de statistiques réelles.
Lorsqu’il est défini sur 1, une graine aléatoire est générée ; lorsqu’il est défini sur une valeur > 1, cette valeur est utilisée directement comme graine.
Ce paramètre est destiné aux tests afin de détecter les erreurs causées par différents ordres de jointure.
## query\_plan\_optimize\_lazy\_final
Optimise la lecture avec FINAL de ReplacingMergeTree en construisant un ensemble de clés primaires, puis en l’utilisant pour l’analyse des index.
## query\_plan\_optimize\_lazy\_materialization
Utiliser le plan de requête pour l’optimisation de la matérialisation paresseuse.
## query\_plan\_optimize\_prewhere
Autoriser le déplacement du filtre vers l'expression PREWHERE pour les moteurs de stockage pris en charge
## query\_plan\_push\_down\_limit
Active ou désactive une optimisation au niveau du plan de requête qui pousse les clauses LIMIT vers le bas dans le plan d’exécution.
N’a d’effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Il s’agit d’un paramètre de niveau expert, qui ne doit être utilisé par les développeurs qu’à des fins de débogage. Ce paramètre peut évoluer à l’avenir de manière non rétrocompatible, voire être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_push\_limit\_by\_into\_sort
Active ou désactive une optimisation au niveau du plan de requête pour les requêtes `ORDER BY ... LIMIT BY`. Lorsque les colonnes de `LIMIT BY` sont un préfixe de la clause `ORDER BY`, chaque flux trié en parallèle applique `LIMIT BY` avant que les flux ne soient fusionnés en un seul, ce qui réduit le nombre de lignes traitées lors de la fusion finale et dans les étapes ultérieures du pipeline. Accélère les requêtes où `LIMIT BY` élimine une grande partie des lignes.
Ne prend effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_read\_in\_order
Active ou désactive l’optimisation de lecture dans l’ordre au niveau du plan de requête.
Ne prend effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) est défini à 1.
Il s’agit d’un paramètre réservé aux experts, qui ne doit être utilisé par les développeurs que pour le débogage. Ce paramètre pourra à l’avenir être modifié de manière non rétrocompatible ou supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_read\_in\_order\_through\_join
Préserve la lecture dans l’ordre depuis la table de gauche dans les opérations JOIN, afin qu’elle puisse être exploitée par les étapes suivantes.
## query\_plan\_remove\_redundant\_distinct
Active ou désactive une optimisation au niveau du plan de requête qui supprime les étapes DISTINCT redondantes.
Ne prend effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) vaut 1.
Il s’agit d’un paramètre de niveau expert qui ne devrait être utilisé par les développeurs qu’à des fins de débogage. Ce paramètre pourra à l’avenir évoluer de manière non rétrocompatible ou être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_remove\_redundant\_sorting
Active ou désactive une optimisation au niveau du plan de requête qui supprime les étapes de tri redondantes, par exemple dans les sous-requêtes.
Ne prend effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) vaut 1.
Il s'agit d'un paramètre destiné aux experts, qui ne doit être utilisé par les développeurs que pour le débogage. Ce paramètre pourra changer ultérieurement de manière non rétrocompatible ou être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_remove\_unused\_columns
Active ou désactive une optimisation au niveau du plan de requête visant à supprimer les colonnes inutilisées (colonnes d’entrée comme de sortie) des étapes du plan de requête.
N’a d’effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Il s’agit d’un paramètre réservé aux experts, qui ne doit être utilisé par les développeurs qu’à des fins de débogage. Ce paramètre peut changer ultérieurement de manière non rétrocompatible, voire être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_reuse\_storage\_ordering\_for\_window\_functions
**Aliases** : `optimize_read_in_window_order`
Active ou désactive une optimisation au niveau du plan de requête qui s'appuie sur l'ordre de tri du stockage lors du tri pour les fonctions de fenêtre.
Ne prend effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) vaut 1.
Il s'agit d'un paramètre de niveau expert qui ne doit être utilisé par les développeurs qu'à des fins de débogage. Ce paramètre pourra évoluer à l'avenir de manière non rétrocompatible, voire être supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_split\_filter
Il s'agit d'un paramètre réservé aux experts, qui ne doit être utilisé par les développeurs qu'à des fins de débogage. Ce paramètre peut être modifié ultérieurement de façon non rétrocompatible, voire supprimé.
Active ou désactive une optimisation au niveau du plan de requête qui scinde les filtres en expressions.
N'a d'effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_text\_index\_add\_hint
Permet d’ajouter une indication (prédicat supplémentaire) au filtrage généré à partir de l’index de texte inversé dans le plan de requête.
## query\_plan\_top\_k\_through\_join
Active ou désactive une optimisation au niveau du plan de requête qui propage `ORDER BY ... LIMIT n` à travers une jointure lorsque la clé de tri ne référence que les colonnes du côté préservé par la jointure (LEFT/RIGHT). Limite le nombre de lignes que l’entrée du côté préservé doit produire avant la jointure.
Ne prend effet que si le paramètre [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) vaut 1.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_plan\_try\_use\_vector\_search
Active ou désactive une optimisation au niveau du plan de requête qui tente d'utiliser l'index de similarité vectorielle.
N'a d'effet que si le paramètre [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) vaut 1.
Il s'agit d'un paramètre de niveau expert qui ne doit être utilisé que par les développeurs à des fins de débogage. Ce paramètre pourra, à l'avenir, être modifié de manière non rétrocompatible ou supprimé.
Valeurs possibles :
* 0 - Désactiver
* 1 - Activer
## query\_profiler\_cpu\_time\_period\_ns
Définit la période du minuteur d’horloge CPU du [profileur de requêtes](/fr/concepts/features/performance/troubleshoot/sampling-query-profiler). Ce minuteur comptabilise uniquement le temps CPU.
Valeurs possibles :
* Un entier positif correspondant à un nombre de nanosecondes.
Valeurs recommandées :
* 10000000 (100 fois par seconde) nanosecondes et plus pour les requêtes individuelles.
* 1000000000 (une fois par seconde) pour le profilage à l’échelle du cluster.
* 0 pour désactiver le minuteur.
Voir aussi :
* Table système [trace\_log](/fr/reference/system-tables/trace_log)
## query\_profiler\_real\_time\_period\_ns
Définit la période d’un minuteur basé sur l’horloge réelle du [profileur de requêtes](/fr/concepts/features/performance/troubleshoot/sampling-query-profiler). Ce minuteur mesure le temps réel écoulé.
Valeurs possibles :
* Nombre entier positif, en nanosecondes.
Valeurs recommandées :
* 10000000 (100 fois par seconde) nanosecondes et moins pour les requêtes individuelles.
* 1000000000 (une fois par seconde) pour le profilage à l’échelle du cluster.
* 0 pour désactiver le minuteur.
Voir aussi :
* Table système [trace\_log](/fr/reference/system-tables/trace_log)
Valeur par défaut Cloud : `3000000000`.
## queue\_max\_wait\_ms
Temps d'attente dans la file de requêtes si le nombre de requêtes concurrentes dépasse le maximum autorisé.
## rabbitmq\_max\_wait\_ms
Le délai d'attente avant nouvelle tentative de lecture depuis RabbitMQ.
## read\_backoff\_max\_throughput
Paramètre permettant de réduire le nombre de threads en cas de lectures lentes. Les événements sont comptabilisés lorsque le débit de lecture est inférieur à ce nombre d’octets par seconde.
## read\_backoff\_min\_concurrency
Paramètre visant à conserver un nombre minimal de threads en cas de lectures lentes.
## read\_backoff\_min\_events
Paramètre permettant de réduire le nombre de threads en cas de lectures lentes. Nombre d'événements à partir duquel le nombre de threads sera réduit.
## read\_backoff\_min\_interval\_between\_events\_ms
Paramètre permettant de réduire le nombre de threads en cas de lectures lentes. Ne tenez pas compte de l’événement si le précédent s’est produit il y a moins d’un certain intervalle de temps.
## read\_backoff\_min\_latency\_ms
Paramètre permettant de réduire le nombre de threads en cas de lectures lentes. Ne tient compte que des lectures ayant pris au moins ce temps.
## read\_from\_distributed\_cache\_if\_exists\_otherwise\_bypass\_cache
N'a d'effet que dans ClickHouse Cloud. Identique à read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache, mais pour le cache distribué.
## read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache
Permet d’utiliser le cache du système de fichiers en mode passif : tirer parti des entrées de cache existantes, sans en ajouter de nouvelles. Si vous activez ce paramètre pour des requêtes ad hoc lourdes et le laissez désactivé pour des requêtes courtes en temps réel, cela permet d’éviter que des requêtes trop lourdes ne saturent le cache et d’améliorer l’efficacité globale du système.
## read\_from\_page\_cache\_if\_exists\_otherwise\_bypass\_cache
Utiliser le cache de pages en espace utilisateur en mode passif, comme pour read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache.
## read\_in\_order\_two\_level\_merge\_threshold
Nombre minimal de parts à lire pour exécuter l’étape de fusion préliminaire lors d’une lecture multithread suivant l’ordre de la clé primaire.
## read\_in\_order\_use\_buffering
Utilise la mise en mémoire tampon avant la fusion lors de la lecture selon l’ordre de la clé primaire. Cela augmente le parallélisme de l’exécution des requêtes
## read\_in\_order\_use\_virtual\_row
Utiliser une ligne virtuelle lors de la lecture en suivant l'ordre de la clé primaire ou d'une de ses fonctions monotones. Cela est utile lors de la recherche sur plusieurs parts, car seules les parts pertinentes sont parcourues.
## read\_in\_order\_use\_virtual\_row\_per\_block
Lorsque ce paramètre est activé avec `read_in_order_use_virtual_row`, une ligne virtuelle est émise après chaque bloc lu (et pas seulement au début de chaque part).
Cela permet à `MergingSortedTransform` de reprioriser les sources plus fréquemment, ce qui est utile lorsque les filtres en aval écartent de nombreuses lignes et que les données sont réparties de façon inégale entre les parts.
Notez que cela désactive l’optimisation `read_in_order_use_buffering` ainsi que la fusion préliminaire (`read_in_order_two_level_merge_threshold`) pour la lecture.
## read\_overflow\_mode
Que faire lorsque la limite est atteinte.
## read\_overflow\_mode\_leaf
Définit ce qui se passe lorsque le volume de données lues dépasse l'une des limites au niveau des nœuds feuille.
Options possibles :
* `throw` : lever une exception (par défaut).
* `break` : arrêter l'exécution de la requête et renvoyer un résultat partiel.
## priorité\_de\_lecture
Priorité de lecture des données depuis le système de fichiers local ou distant. Pris en charge uniquement avec la méthode 'pread\_threadpool' pour le système de fichiers local et la méthode `threadpool` pour le système de fichiers distant.
## read\_through\_distributed\_cache
N’a d’effet que dans ClickHouse Cloud. Autorise la lecture à partir du cache distribué
## readonly
0 - aucune restriction en mode lecture seule. 1 - uniquement les requêtes de lecture, ainsi que la modification des paramètres explicitement autorisés. 2 - uniquement les requêtes de lecture, ainsi que la modification des paramètres, à l'exception du paramètre 'readonly'.
## receive\_data\_timeout\_ms
Délai d’attente de connexion pour la réception du premier paquet de données ou d’un paquet indiquant une progression positive provenant d’une réplique
## receive\_timeout
Délai d'attente de réception des données via le réseau, en secondes. Si aucun octet n'est reçu pendant cet intervalle, une exception est levée. Si vous définissez ce paramètre côté client, le `send_timeout` du socket sera également défini sur l'extrémité correspondante de la connexion côté serveur.
## recursive\_cte\_max\_steps\_in\_type\_inference
Nombre maximal d'itérations pour inférer les types de colonnes dans les CTE récursives. Les types de colonnes sont déterminés en appliquant `getLeastSupertype` de manière itérative aux branches non récursive et récursive de l'UNION ALL jusqu'à convergence. Définissez cette valeur sur 0 pour désactiver l'élargissement des types et utiliser uniquement les types de la partie non récursive.
## regexp\_dict\_allow\_hyperscan
Autorise le dictionnaire regexp\_tree à utiliser la bibliothèque Hyperscan.
## regexp\_dict\_flag\_case\_insensitive
Utilise une correspondance insensible à la casse pour un dictionnaire regexp\_tree. Ce paramètre peut être remplacé dans des expressions individuelles avec (?i) et (?-i).
## regexp\_dict\_flag\_dotall
Permet à « . » de correspondre aux sauts de ligne pour un dictionnaire regexp\_tree.
## regexp\_max\_matches\_per\_row
Définit le nombre maximal de correspondances d'une même expression régulière par ligne. Utilisez ce paramètre pour éviter une surcharge de mémoire lors de l'utilisation d'une expression régulière gourmande dans la fonction [extractAllGroupsHorizontal](/fr/reference/functions/regular-functions/string-search-functions#extractAllGroupsHorizontal).
Valeurs possibles :
* Entier positif.
## reject\_expensive\_hyperscan\_regexps
Rejette les motifs dont l’évaluation avec hyperscan sera probablement coûteuse (en raison d’une explosion du nombre d’états du NFA)
## remerge\_sort\_lowered\_memory\_bytes\_ratio
Si l’utilisation de la mémoire après le remerge n’est pas réduite d’au moins ce ratio, le remerge sera désactivé.
## remote\_filesystem\_read\_method
Méthode de lecture des données sur le système de fichiers distant, au choix : read, threadpool.
## remote\_filesystem\_read\_prefetch
Indique s'il faut utiliser la prélecture lors de la lecture de données depuis un système de fichiers distant.
## remote\_fs\_read\_backoff\_max\_tries
Nombre maximal de tentatives de lecture avec délai progressif
## remote\_fs\_read\_max\_backoff\_ms
Temps d’attente maximal lors d’une tentative de lecture de données depuis le disque distant
## remote\_read\_min\_bytes\_for\_seek
Nombre minimal d’octets requis pour qu’une lecture distante (URL, S3) effectue un seek plutôt qu’une lecture avec ignore.
## rename\_files\_after\_processing
* **Type:** String
* **Valeur par défaut :** Chaîne vide
Ce paramètre permet de spécifier un motif de renommage pour les fichiers traités par la fonction de table `file`. Lorsque cette option est définie, tous les fichiers lus par la fonction de table `file` sont renommés selon le motif indiqué avec des marqueurs de substitution, uniquement si leur traitement a réussi.
### Espaces réservés
* `%a` — Nom complet du fichier d’origine (par ex. : "sample.csv").
* `%f` — Nom du fichier d’origine sans extension (par ex. : "sample").
* `%e` — Extension du fichier d’origine, point compris (par ex. : ".csv").
* `%t` — Horodatage (en microsecondes).
* `%%` — Signe de pourcentage ("%").
### Exemple
* Option : `--rename_files_after_processing="processed_%f_%t%e"`
* Requête : `SELECT * FROM file('sample.csv')`
Si la lecture de `sample.csv` réussit, le fichier sera renommé `processed_sample_1683473210851438.csv`
## replace\_running\_query
Lors de l'utilisation de l'interface HTTP, vous pouvez transmettre le paramètre 'query\_id'. Il s'agit d'une chaîne quelconque servant d'identifiant de requête.
Si une requête du même utilisateur avec le même 'query\_id' existe déjà à ce moment-là, le comportement dépend du paramètre 'replace\_running\_query'.
`0` (par défaut) – Lever une exception (ne pas autoriser l'exécution de la requête si une requête avec le même 'query\_id' est déjà en cours d'exécution).
`1` – Annuler l'ancienne requête et lancer la nouvelle.
Définissez ce paramètre sur 1 pour implémenter des suggestions de conditions de segmentation. Après la saisie du caractère suivant, si l'ancienne requête n'est pas encore terminée, elle doit être annulée.
## replace\_running\_query\_max\_wait\_ms
Le temps d'attente pour que la requête en cours avec le même `query_id` se termine, lorsque le paramètre [replace\_running\_query](#replace_running_query) est actif.
Valeurs possibles :
* Entier positif.
* 0 — Levée d'une exception qui empêche d'exécuter une nouvelle requête si le serveur exécute déjà une requête avec le même `query_id`.
## replication\_wait\_for\_inactive\_replica\_timeout
Indique combien de temps (en secondes) il faut attendre pour que les répliques inactives exécutent les requêtes [`ALTER`](/fr/reference/statements/alter/index), [`OPTIMIZE`](/fr/reference/statements/optimize) ou [`TRUNCATE`](/fr/reference/statements/truncate).
Valeurs possibles :
* `0` — Ne pas attendre.
* Entier négatif — Attendre indéfiniment.
* Entier positif — Nombre de secondes à attendre.
## restore\_replace\_external\_dictionary\_source\_to\_null
Remplace les sources de dictionnaire externes par Null lors de la restauration. Utile pour les tests
## restore\_replace\_external\_engines\_to\_null
Pour les tests. Remplace tous les moteurs externes par Null afin de ne pas établir de connexions externes.
## restore\_replace\_external\_table\_functions\_to\_null
À utiliser à des fins de test. Remplace toutes les fonctions de table externes par Null afin d’éviter d’établir des connexions externes.
## restore\_replicated\_merge\_tree\_to\_shared\_merge\_tree
Remplace le moteur de table Replicated*MergeTree par Shared*MergeTree lors de RESTORE.
Valeur par défaut dans Cloud : `1`.
## result\_overflow\_mode
Valeur par défaut dans Cloud : `throw`
Définit ce qu'il faut faire si le volume du résultat dépasse l'une des limites.
Valeurs possibles :
* `throw` : lever une exception (par défaut).
* `break` : arrêter l'exécution de la requête et renvoyer le résultat partiel, comme si les
données source étaient épuisées.
L'utilisation de 'break' est similaire à l'utilisation de LIMIT. `Break` interrompt l'exécution uniquement au
niveau du bloc. Cela signifie que le nombre de lignes renvoyées est supérieur à
[`max_result_rows`](/fr/reference/settings/session-settings#max_result_rows), est un multiple de [`max_block_size`](/fr/reference/settings/session-settings#max_block_size)
et dépend de [`max_threads`](/fr/reference/settings/session-settings#max_threads).
**Exemple**
```sql title="Query" theme={null}
SET max_threads = 3, max_block_size = 3333;
SET max_result_rows = 3334, result_overflow_mode = 'break';
SELECT *
FROM numbers_mt(100000)
FORMAT Null;
```
```text title="Result" theme={null}
6666 rows in set. ...
```
## rewrite\_count\_distinct\_if\_with\_count\_distinct\_implementation
Permet de réécrire `countDistcintIf` à l’aide du paramètre [count\_distinct\_implementation](#count_distinct_implementation).
Valeurs possibles :
* true — Autoriser.
* false — Interdire.
## rewrite\_in\_to\_join
Réécrire des expressions du type 'x IN subquery' en JOIN. Cela peut être utile pour optimiser l’ensemble de la requête via le réordonnancement des jointures.
## rows\_before\_aggregation
Lorsqu’il est activé, ClickHouse fournit la valeur exacte de la statistique rows\_before\_aggregation, qui représente le nombre de lignes lues avant l’agrégatio
## s3\_allow\_multipart\_copy
Autorise la copie en plusieurs parties dans S3.
## s3\_allow\_parallel\_part\_upload
Utilise plusieurs threads pour les téléversements multipart S3. Cela peut entraîner une utilisation de la mémoire légèrement plus élevée
## s3\_check\_objects\_after\_upload
Vérifie chaque objet téléversé vers S3 à l'aide d'une requête head afin de s'assurer que le téléversement s'est bien déroulé
## s3\_connect\_timeout\_ms
Délai d’expiration de la connexion à l’hôte pour les disques S3.
## s3\_create\_new\_file\_on\_insert
Active ou désactive la création d’un nouveau fichier à chaque insertion dans les tables utilisant le moteur S3. Si cette option est activée, un nouvel objet S3 est créé à chaque insertion avec la clé, selon un schéma semblable à celui-ci :
initial : `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
Valeurs possibles :
* 0 — la requête `INSERT` crée un nouveau fichier, ou échoue si le fichier existe et que s3\_truncate\_on\_insert n’est pas défini.
* 1 — la requête `INSERT` crée un nouveau fichier à chaque insertion en utilisant un suffixe (à partir du deuxième) si s3\_truncate\_on\_insert n’est pas défini.
Pour plus de détails, voir [ici](/fr/integrations/connectors/data-ingestion/AWS/integrating-s3-with-clickhouse#inserting-data).
## s3\_disable\_checksum
N’effectue pas de somme de contrôle lors de l’envoi d’un fichier vers S3. Cela accélère les écritures en évitant des traitements excessifs sur le fichier. C’est généralement sûr, car les données des tables MergeTree sont de toute façon déjà protégées par des sommes de contrôle dans ClickHouse, et lorsque S3 est accessible via HTTPS, la couche TLS garantit déjà l’intégrité des données pendant leur transfert sur le réseau. Des sommes de contrôle supplémentaires sur S3 apportent toutefois une défense en profondeur.
## s3\_ignore\_file\_doesnt\_exist
Ignore l'absence d'un fichier lors de la lecture de certaines clés s'il n'existe pas.
Valeurs possibles :
* 1 — `SELECT` renvoie un résultat vide.
* 0 — `SELECT` lève une exception.
## s3\_list\_object\_keys\_size
Nombre maximal de fichiers pouvant être renvoyés par la requête ListObject en lot
## s3\_max\_connections
Le nombre maximal de connexions par serveur.
## s3\_max\_get\_burst
Nombre maximal de requêtes pouvant être envoyées simultanément avant d’atteindre la limite de requêtes par seconde. Par défaut (0), cette valeur est égale à `s3_max_get_rps`
## s3\_max\_get\_rps
Limite du nombre de requêtes GET vers S3 par seconde avant l’activation du throttling. Zéro signifie illimité.
## s3\_max\_inflight\_parts\_for\_one\_file
Le nombre maximal de parties pouvant être chargées simultanément dans une requête de téléversement multipart. 0 signifie qu'il n'y a pas de limite.
## s3\_max\_part\_number
Numéro maximal de part pour le téléversement vers S3.
## s3\_max\_put\_burst
Nombre maximal de requêtes pouvant être envoyées simultanément avant d'atteindre la limite de requêtes par seconde. Par défaut (0), est égal à `s3_max_put_rps`
## s3\_max\_put\_rps
Limite du nombre de requêtes PUT vers S3 par seconde avant l’application d’un throttling. Zéro signifie illimité.
## s3\_max\_single\_operation\_copy\_size
Taille maximale pour une copie en une seule opération dans S3. Ce paramètre n'est utilisé que si s3\_allow\_multipart\_copy est true.
## s3\_max\_single\_part\_upload\_size
La taille maximale d’un objet à téléverser vers S3 en un seul envoi.
## s3\_max\_single\_read\_retries
Le nombre maximal de tentatives lors d’une lecture unique depuis S3.
## s3\_max\_unexpected\_write\_error\_retries
Le nombre maximal de tentatives en cas d’erreurs inattendues lors de l’écriture dans S3.
## s3\_max\_upload\_part\_size
La taille maximale d'une part à téléverser lors d'un téléversement multipart vers S3.
## s3\_min\_upload\_part\_size
La taille minimale d’une partie à téléverser lors d’un téléversement multipart vers S3.
## s3\_path\_filter\_limit
Nombre maximal de valeurs `_path` pouvant être extraites des filtres de requête afin d’être utilisées pour l’itération sur les fichiers
au lieu d’un parcours par motif glob. 0 signifie désactivé.
## s3\_request\_timeout\_ms
Délai d’inactivité maximal pour l’envoi et la réception de données vers/depuis S3. Échec si un seul appel de lecture ou d’écriture TCP reste bloqué pendant cette durée.
## s3\_skip\_empty\_files
Active ou désactive le fait d’ignorer les fichiers vides dans les tables du moteur [S3](/fr/reference/engines/table-engines/integrations/s3).
Valeurs possibles :
* 0 — `SELECT` lève une exception si le fichier vide n’est pas compatible avec le format demandé.
* 1 — `SELECT` renvoie un résultat vide pour un fichier vide.
## s3\_slow\_all\_threads\_after\_network\_error
Lorsque ce paramètre est défini sur `true`, tous les threads exécutant des requêtes S3 vers le même endpoint de sauvegarde sont ralentis
dès qu'une seule requête S3 rencontre une erreur réseau pouvant donner lieu à une nouvelle tentative, comme un timeout de socket.
Lorsque ce paramètre est défini sur `false`, chaque thread gère le délai progressif des requêtes S3 indépendamment des autres.
## s3\_strict\_upload\_part\_size
La taille exacte de la partie à téléverser lors d'un téléversement multipart vers S3 (certaines implémentations ne prennent pas en charge les parties de taille variable).
## s3\_throw\_on\_zero\_files\_match
Déclenche une erreur lorsque la requête ListObjects ne trouve aucun fichier correspondant
## s3\_truncate\_on\_insert
Active ou désactive la troncature avant les insertions dans les tables utilisant le moteur S3. Si cette option est désactivée, une exception est levée lors d'une tentative d'insertion si un objet S3 existe déjà.
Valeurs possibles :
* 0 — la requête `INSERT` crée un nouveau fichier, ou échoue si le fichier existe et que s3\_create\_new\_file\_on\_insert n'est pas défini.
* 1 — la requête `INSERT` remplace le contenu existant du fichier par les nouvelles données.
Voir plus de détails [ici](/fr/integrations/connectors/data-ingestion/AWS/integrating-s3-with-clickhouse#inserting-data).
## s3\_upload\_part\_size\_multiply\_factor
Multiplie `s3_min_upload_part_size` par ce facteur chaque fois que `s3_multiply_parts_count_threshold` parts ont été téléversées vers S3 lors d’une seule écriture.
## s3\_upload\_part\_size\_multiply\_parts\_count\_threshold
Chaque fois que ce nombre de parties a été téléversé vers S3, s3\_min\_upload\_part\_size est multiplié par s3\_upload\_part\_size\_multiply\_factor.
## s3\_uri\_style
Impose le style de l’endpoint S3. Valeurs possibles : auto, virtual\_hosted, path.
## s3\_use\_adaptive\_timeouts
Lorsqu’il est défini sur `true`, les deux premières tentatives de toutes les requêtes S3 sont effectuées avec des délais d’envoi et de réception courts.
Lorsqu’il est défini sur `false`, toutes les tentatives sont effectuées avec les mêmes délais.
## s3\_validate\_request\_settings
Active la validation des paramètres de requête S3.
Valeurs possibles :
* 1 — valide les paramètres.
* 0 — ne valide pas les paramètres.
## s3queue\_default\_zookeeper\_path
Préfixe de chemin ZooKeeper par défaut pour le moteur S3Queue
## s3queue\_enable\_logging\_to\_s3queue\_log
Active l’écriture dans system.s3queue\_log. La valeur peut être redéfinie pour chaque table via les paramètres de table
## s3queue\_keeper\_fault\_injection\_probability
Probabilité d’injection de pannes de Keeper pour S3Queue.
## s3queue\_migrate\_old\_metadata\_to\_buckets
Migrer l’ancienne structure de métadonnées de la table S3Queue vers une nouvelle structure
## schema\_inference\_cache\_require\_modification\_time\_for\_url
Utiliser le schéma en cache pour l’URL avec validation de la date de dernière modification (pour les URL avec l’en-tête Last-Modified)
## schema\_inference\_use\_cache\_for\_azure
Utiliser le cache pour l’inférence de schéma lors de l’utilisation de la fonction de table Azure
## schema\_inference\_use\_cache\_for\_file
Utiliser le cache dans l’inférence de schéma lors de l’utilisation de la fonction de table file
## schema\_inference\_use\_cache\_for\_hdfs
Utiliser le cache pour l’inférence de schéma lors de l’utilisation de la fonction de table hdfs
## schema\_inference\_use\_cache\_for\_s3
Utiliser le cache pour l'inférence de schéma lors de l'utilisation de la fonction de table S3
## schema\_inference\_use\_cache\_for\_url
Utilise le cache pour l’inférence de schéma lors de l’utilisation de la fonction de table url
## secondary\_indices\_enable\_bulk\_filtering
Active l’algorithme de filtrage en bloc pour les indices. Il est supposé être systématiquement plus performant, mais ce paramètre est conservé pour des raisons de compatibilité et de contrôle.
## select\_sequential\_consistency
Ce paramètre n’a pas le même comportement avec SharedMergeTree et ReplicatedMergeTree. Voir [SharedMergeTree consistency](/fr/products/cloud/features/infrastructure/shared-merge-tree#consistency) pour plus d’informations sur le comportement de `select_sequential_consistency` dans SharedMergeTree.
Active ou désactive la cohérence séquentielle pour les requêtes `SELECT`. Nécessite que `insert_quorum_parallel` soit désactivé (il est activé par défaut).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Utilisation
Lorsque la cohérence séquentielle est activée, ClickHouse n’autorise le client à exécuter la requête `SELECT` que sur les répliques qui contiennent les données de toutes les requêtes `INSERT` précédentes exécutées avec `insert_quorum`. Si le client interroge une réplique partielle, ClickHouse génère une exception. La requête `SELECT` n’inclura pas les données qui n’ont pas encore été écrites sur le quorum de répliques.
Lorsque `insert_quorum_parallel` est activé (par défaut), `select_sequential_consistency` ne fonctionne pas. En effet, des requêtes `INSERT` parallèles peuvent être écrites sur différents groupes de répliques formant le quorum, sans garantie qu’une seule réplique ait reçu toutes les écritures.
Voir aussi :
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
## send\_logs\_level
Envoyer au client les logs texte du serveur à partir du niveau minimal spécifié. Valeurs valides : 'trace', 'debug', 'information', 'warning', 'error', 'fatal', 'none'
## send\_logs\_source\_regexp
Envoyer les logs texte du serveur avec l’expression régulière spécifiée pour faire correspondre le nom de la source des logs. Si vide, toutes les sources sont prises en compte.
## send\_profile\_events
Active ou désactive l'envoi de paquets [ProfileEvents](/fr/resources/develop-contribute/native-protocol/server#profile-events) aux clients.
Ce paramètre peut être désactivé afin de réduire le trafic réseau pour les clients qui n'ont pas besoin des événements de profil.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
Active ou désactive les en-têtes HTTP de réponse `X-ClickHouse-Progress` dans les réponses de `clickhouse-server`.
Pour plus d’informations, consultez la [description de l’interface HTTP](/fr/concepts/features/interfaces/http).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## send\_table\_structure\_on\_insert\_with\_inline\_data
S'il est désactivé et que la requête INSERT contient des données intégrées, le serveur n'enverra pas au client, via le protocole natif, la structure de la table ni les valeurs par défaut des colonnes. À la place, le serveur analysera lui-même les données intégrées. Cela peut améliorer les performances pour de nombreuses petites insertions via le protocole natif.
## send\_timeout
Délai d’expiration pour l’envoi de données sur le réseau, en secondes. Si un client doit envoyer des données mais ne parvient pas à envoyer le moindre octet pendant cet intervalle, une exception est levée. Si vous définissez ce paramètre côté client, le `receive_timeout` du socket sera également défini du côté correspondant de la connexion sur le serveur.
## serialize\_query\_plan
Sérialise le plan de requête pour le traitement distribué
## serialize\_string\_in\_memory\_with\_zero\_byte
Sérialise les valeurs String lors de l’agrégation en ajoutant un octet nul à la fin. Activez ce paramètre pour préserver la compatibilité lors de l’exécution de requêtes sur un cluster composé de versions incompatibles.
## session\_timezone
Définit le fuseau horaire implicite de la session ou de la requête actuelle.
Le fuseau horaire implicite est celui appliqué aux valeurs de type DateTime/DateTime64 qui n’ont pas de fuseau horaire explicitement défini.
Ce paramètre prévaut sur le fuseau horaire implicite configuré globalement (au niveau du serveur).
Une valeur de '' (chaîne vide) signifie que le fuseau horaire implicite de la session ou de la requête actuelle est identique au [fuseau horaire du serveur](/fr/reference/settings/server-settings/settings#timezone).
Vous pouvez utiliser les fonctions `timeZone()` et `serverTimeZone()` pour obtenir le fuseau horaire de la session et celui du serveur.
Valeurs possibles :
* Tout nom de fuseau horaire issu de `system.time_zones`, par exemple `Europe/Berlin`, `UTC` ou `Zulu`
Exemples :
```sql theme={null}
SELECT timeZone(), serverTimeZone() FORMAT CSV
"Europe/Berlin","Europe/Berlin"
```
```sql theme={null}
SELECT timeZone(), serverTimeZone() SETTINGS session_timezone = 'Asia/Novosibirsk' FORMAT CSV
"Asia/Novosibirsk","Europe/Berlin"
```
Attribuez au DateTime interne le fuseau horaire de la session 'America/Denver', sans spécifier explicitement de fuseau horaire :
```sql theme={null}
SELECT toDateTime64(toDateTime64('1999-12-12 23:23:23.123', 3), 3, 'Europe/Zurich') SETTINGS session_timezone = 'America/Denver' FORMAT TSV
1999-12-13 07:23:23.123
```
Certaines fonctions qui analysent DateTime/DateTime64 ne respectent pas `session_timezone`. Cela peut entraîner des erreurs subtiles.
Voir l'exemple et l'explication ci-dessous.
```sql theme={null}
CREATE TABLE test_tz (`d` DateTime('UTC')) ENGINE = Memory AS SELECT toDateTime('2000-01-01 00:00:00', 'UTC');
SELECT *, timeZone() FROM test_tz WHERE d = toDateTime('2000-01-01 00:00:00') SETTINGS session_timezone = 'Asia/Novosibirsk'
0 rows in set.
SELECT *, timeZone() FROM test_tz WHERE d = '2000-01-01 00:00:00' SETTINGS session_timezone = 'Asia/Novosibirsk'
┌───────────────────d─┬─timeZone()───────┐
│ 2000-01-01 00:00:00 │ Asia/Novosibirsk │
└─────────────────────┴──────────────────┘
```
Cela est dû à des pipelines d’analyse différents :
* `toDateTime()`, utilisé sans fuseau horaire explicitement indiqué dans la première requête `SELECT`, tient compte du paramètre `session_timezone` et du fuseau horaire global.
* Dans la deuxième requête, une valeur DateTime est analysée à partir d’une String et hérite du type et du fuseau horaire de la colonne existante `d`. Par conséquent, le paramètre `session_timezone` et le fuseau horaire global ne sont pas pris en compte.
**Voir aussi**
* [timezone](/fr/reference/settings/server-settings/settings#timezone)
## set\_overflow\_mode
Définit le comportement à adopter lorsque la quantité de données dépasse l'une des limites.
Valeurs possibles :
* `throw` : lever une exception (par défaut).
* `break` : arrêter l'exécution de la requête et renvoyer un résultat partiel, comme si les données source étaient épuisées.
## shared\_merge\_tree\_sequential\_consistency\_initial\_parts\_update\_backoff\_ms
Backoff initial, en millisecondes, pour la mise à jour des parts lors de l'utilisation de `select_sequential_consistency` avec `SharedMergeTree`. Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_sequential\_consistency\_max\_parts\_update\_backoff\_ms
Backoff maximal, en millisecondes, pour la mise à jour des parts lors de l'utilisation de `select_sequential_consistency` avec `SharedMergeTree`. Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_sequential\_consistency\_parts\_update\_max\_retries
Nombre maximal de tentatives de mise à jour des parts lors de l'utilisation de `select_sequential_consistency` avec `SharedMergeTree`. Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_sync\_parts\_on\_partition\_operations
Synchronise automatiquement l’ensemble des parts de données après les opérations de partition MOVE|REPLACE|ATTACH dans les tables SMT. Cloud uniquement
## short\_circuit\_function\_evaluation
Permet d’évaluer les fonctions [if](/fr/reference/functions/regular-functions/conditional-functions#if), [multiIf](/fr/reference/functions/regular-functions/conditional-functions#multiIf), [and](/fr/reference/functions/regular-functions/logical-functions#and) et [or](/fr/reference/functions/regular-functions/logical-functions#or) avec une [évaluation en court-circuit](https://en.wikipedia.org/wiki/Short-circuit_evaluation). Cela permet d’optimiser l’exécution des expressions complexes dans ces fonctions et d’éviter d’éventuelles exceptions (comme une division par zéro lorsqu’elle n’est pas attendue).
Valeurs possibles :
* `enable` — Active l’évaluation en court-circuit pour les fonctions qui s’y prêtent (celles qui peuvent lever une exception ou sont coûteuses en calcul).
* `force_enable` — Active l’évaluation en court-circuit pour toutes les fonctions.
* `disable` — Désactive l’évaluation en court-circuit.
## short\_circuit\_function\_evaluation\_for\_nulls
Optimise l’évaluation des fonctions qui renvoient NULL dès qu’un argument est NULL. Lorsque le pourcentage de valeurs NULL dans les arguments de la fonction dépasse le seuil short\_circuit\_function\_evaluation\_for\_nulls\_threshold, le système n’évalue plus la fonction ligne par ligne. Il renvoie à la place immédiatement NULL pour toutes les lignes, ce qui évite des calculs inutiles.
## short\_circuit\_function\_evaluation\_for\_nulls\_threshold
Seuil du ratio de valeurs NULL à partir duquel les fonctions avec des arguments Nullable sont exécutées uniquement sur les lignes dont tous les arguments ont des valeurs non-NULL. S’applique lorsque le paramètre short\_circuit\_function\_evaluation\_for\_nulls est activé.
Lorsque le ratio de lignes contenant des valeurs NULL par rapport au nombre total de lignes dépasse ce seuil, ces lignes ne seront pas évaluées.
## show\_processlist\_include\_internal
Afficher les processus auxiliaires internes dans le résultat de la requête `SHOW PROCESSLIST`.
Les processus internes comprennent les rechargements de dictionnaires, les rechargements de vues matérialisées actualisables, les `SELECT` auxiliaires exécutés dans les requêtes `SHOW ...`, les requêtes auxiliaires `CREATE DATABASE ...` exécutées en interne pour gérer les tables défectueuses, etc.
## show\_remote\_databases\_in\_system\_tables
**Alias** : `show_data_lake_catalogs_in_system_tables`
Active l’affichage des bases de données distantes (catalogues de data lake, MySQL, PostgreSQL) dans les tables système.
## show\_table\_uuid\_in\_table\_create\_query\_if\_not\_nil
Définit l’affichage de la requête `SHOW TABLE`.
Valeurs possibles :
* 0 — La requête sera affichée sans l’UUID de la table.
* 1 — La requête sera affichée avec l’UUID de la table.
## single\_join\_prefer\_left\_table
Pour un seul JOIN, en cas d'ambiguïté de l'identifiant, privilégier la table de gauche
## skip\_redundant\_aliases\_in\_udf
Les alias redondants ne sont pas utilisés (substitués) dans les fonctions définies par l’utilisateur afin d’en simplifier l’utilisation.
Valeurs possibles :
* 1 — Les alias sont ignorés (substitués) dans les UDF.
* 0 — Les alias ne sont pas ignorés (substitués) dans les UDF.
**Exemple**
Différence entre l’état activé et désactivé :
Requête :
```sql theme={null}
SET skip_redundant_aliases_in_udf = 0;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
```
Résultat :
```text theme={null}
SELECT ((4 + 2) + 1 AS y, y + 2)
```
Requête :
```sql theme={null}
SET skip_redundant_aliases_in_udf = 1;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
```
Résultat :
```text theme={null}
SELECT ((4 + 2) + 1, ((4 + 2) + 1) + 2)
```
## skip\_unavailable\_shards
Active ou désactive l’ignorance silencieuse des shards indisponibles.
Un shard est considéré comme indisponible si toutes ses répliques sont indisponibles. Une réplique est indisponible dans les cas suivants :
* ClickHouse ne peut pas se connecter à la réplique, quelle qu’en soit la raison.
Lors de la connexion à une réplique, ClickHouse effectue plusieurs tentatives. Si elles échouent toutes, la réplique est considérée comme indisponible.
* La réplique ne peut pas être résolue via DNS.
Si le nom d’hôte de la réplique ne peut pas être résolu via DNS, cela peut indiquer les situations suivantes :
* L’hôte de la réplique n’a pas d’enregistrement DNS. Cela peut se produire dans des systèmes utilisant un DNS dynamique, par exemple [Kubernetes](https://kubernetes.io), où les nœuds peuvent être temporairement impossibles à résoudre pendant une période d’indisponibilité, sans que cela constitue une erreur.
* Erreur de configuration. Le fichier de configuration de ClickHouse contient un nom d’hôte incorrect.
Valeurs possibles :
* 1 — ignorance activée.
Si un shard est indisponible, ClickHouse renvoie un résultat basé sur des données partielles et ne signale pas les problèmes de disponibilité des nœuds.
* 0 — ignorance désactivée.
Si un shard est indisponible, ClickHouse lève une exception.
## sleep\_after\_receiving\_query\_ms
Temps d’attente après réception d’une requête dans TCPHandler
## sleep\_in\_send\_data\_ms
Temps d’attente lors de l’envoi de données dans TCPHandler
## sleep\_in\_send\_tables\_status\_ms
Délai d’attente lors de l’envoi de la réponse de statut des tables dans TCPHandler
## sort\_overflow\_mode
Définit le comportement à adopter si le nombre de lignes reçues avant le tri dépasse l'une des limites.
Valeurs possibles :
* `throw` : lever une exception.
* `break` : arrêter l'exécution de la requête et renvoyer un résultat partiel.
## split\_intersecting\_parts\_ranges\_into\_layers\_final
Diviser les plages de parts chevauchantes en couches pendant l’optimisation FINAL
## split\_parts\_ranges\_into\_intersecting\_and\_non\_intersecting\_final
Scinder les plages de parts en plages qui se chevauchent et plages qui ne se chevauchent pas lors de l'optimisation FINAL
## splitby\_max\_substrings\_includes\_remaining\_string
Contrôle si la fonction [splitBy\*()](/fr/reference/functions/regular-functions/splitting-merging-functions) avec l'argument `max_substrings` > 0 inclut la chaîne restante dans le dernier élément du tableau résultant.
Valeurs possibles :
* `0` - La chaîne restante ne sera pas incluse dans le dernier élément du tableau résultant.
* `1` - La chaîne restante sera incluse dans le dernier élément du tableau résultant. Il s'agit du comportement de la fonction [`split()`](https://spark.apache.org/docs/3.1.2/api/python/reference/api/pyspark.sql.functions.split.html) de Spark et de la méthode ['string.split()'](https://docs.python.org/3/library/stdtypes.html#str.split) de Python.
## stop\_refreshable\_materialized\_views\_on\_startup
Au démarrage du serveur, empêche la planification des vues matérialisées actualisables, comme avec SYSTEM STOP VIEWS. Vous pouvez ensuite les démarrer manuellement avec `SYSTEM START VIEWS` ou `SYSTEM START VIEW `. S’applique également aux vues nouvellement créées. N’a aucun effet sur les vues matérialisées non actualisables.
## storage\_file\_read\_method
Méthode de lecture des données à partir du fichier de stockage, parmi : `read`, `pread`, `mmap`. La méthode `mmap` ne s'applique pas à clickhouse-server (elle est destinée à clickhouse-local).
## storage\_system\_stack\_trace\_pipe\_read\_timeout\_ms
Temps maximal de lecture depuis un pipe pour recevoir des informations des threads lors de l’interrogation de la table `system.stack_trace`. Ce paramètre est utilisé à des fins de test et n’est pas destiné à être modifié par les utilisateurs.
## stream\_flush\_interval\_ms
S'applique aux tables en streaming en cas de délai d'attente, ou lorsqu'un thread génère [max\_insert\_block\_size](#max_insert_block_size) lignes.
La valeur par défaut est 7500.
Plus la valeur est faible, plus les données sont vidées fréquemment dans la table. Définir une valeur trop faible entraîne de mauvaises performances.
## stream\_like\_engine\_allow\_direct\_select
Autorise les requêtes SELECT directes pour les moteurs Kafka, RabbitMQ, FileLog, Redis Streams, S3Queue, AzureQueue et NATS. S'il existe des vues matérialisées attachées, la requête SELECT n'est pas autorisée, même si ce paramètre est activé.
S'il n'existe pas de vues matérialisées attachées, l'activation de ce paramètre permet de lire les données. Gardez à l'esprit qu'en général, les données lues sont supprimées de la file d'attente. Pour éviter leur suppression, les paramètres du moteur concerné doivent être configurés correctement.
## stream\_like\_engine\_insert\_queue
Lorsqu'un moteur de type stream lit à partir de plusieurs files d'attente, l'utilisateur doit en sélectionner une pour y effectuer un insert lors de l'écriture. Utilisé par Redis Streams et NATS.
## stream\_poll\_timeout\_ms
Délai d’expiration pour l’interrogation des données depuis/vers les stockages en streaming.
## system\_events\_show\_zero\_values
Permet de sélectionner les événements de valeur nulle dans [`system.events`](/fr/reference/system-tables/events).
Certains systèmes de supervision exigent que toutes les valeurs de métriques leur soient transmises à chaque relevé, même si la valeur de la métrique est nulle.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
**Exemples**
Requête
```sql theme={null}
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
```
Résultat
```text theme={null}
Ok.
```
Requête
```sql theme={null}
SET system_events_show_zero_values = 1;
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
```
Résultat
```text theme={null}
┌─event────────────────────┬─value─┬─description───────────────────────────────────────────┐
│ QueryMemoryLimitExceeded │ 0 │ Number of times when memory limit exceeded for query. │
└──────────────────────────┴───────┴───────────────────────────────────────────────────────┘
```
## system\_metric\_log\_show\_zero\_values\_in\_histograms
Contrôle si les données d’histogramme de valeur nulle sont écrites dans la colonne imbriquée `histograms` de `system.metric_log`.
Par défaut, les histogrammes dont le `count` total d’observations est nul sont ignorés et, dans chaque histogramme émis, les entrées de bucket sans observation sont également omises de la map `histogram`. Activez ce paramètre pour écrire chaque histogramme et chaque bucket, quel que soit le `count` — utile pour les systèmes de monitoring qui exigent que chaque métrique apparaisse à chaque point de contrôle.
Valeurs possibles :
* 0 — Désactivé. Les histogrammes avec `count = 0` ne sont pas émis ; les histogrammes émis incluent uniquement les buckets ayant reçu au moins une observation.
* 1 — Activé. Tous les histogrammes sont écrits et chaque limite de bucket apparaît dans `histogram`.
## table\_engine\_read\_through\_distributed\_cache
N'a d'effet que dans ClickHouse Cloud. Autorise la lecture à partir du distributed cache via les moteurs de table / fonctions de table (s3, azure, etc.)
## table\_function\_remote\_max\_addresses
Définit le nombre maximal d’adresses générées à partir de motifs pour la fonction [remote](/fr/reference/functions/table-functions/remote).
Valeurs possibles :
* Entier positif.
## tcp\_keep\_alive\_timeout
Durée, en secondes, pendant laquelle la connexion doit rester inactive avant que TCP ne commence à envoyer des sondes de keepalive
## temporary\_data\_in\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Temps d’attente pour verrouiller le cache lors de la réservation d’espace pour les données temporaires dans le cache du système de fichiers
## temporary\_files\_buffer\_size
Taille du tampon des processus d’écriture des fichiers temporaires. Une taille de tampon plus élevée réduit le nombre d’appels système, mais augmente la consommation de mémoire.
## temporary\_files\_codec
Définit le codec de compression des fichiers temporaires utilisés pour les opérations de tri et de jointure sur disque.
Valeurs possibles :
* LZ4 — La compression [LZ4](https://en.wikipedia.org/wiki/LZ4_\(compression_algorithm\)) est appliquée.
* NONE — Aucune compression n’est appliquée.
## text\_index\_density\_threshold
Seuil de densité pour la sélection de l’algorithme en mode lazy posting list.
En dessous du seuil : intersection leapfrog. À partir du seuil : bitmap par force brute.
## text\_index\_hint\_max\_selectivity
Sélectivité maximale du filtre permettant d'utiliser l'indice construit à partir de l'index de texte inversé.
## text\_index\_like\_max\_postings\_to\_read
Nombre maximal de grandes listes de postings à lire lorsque l’évaluation de LIKE sur l’index de texte via le balayage du dictionnaire est activée.
Nécessite que `use_text_index_like_evaluation_by_dictionary_scan` soit activé.
## text\_index\_like\_min\_pattern\_length
Longueur minimale de la chaîne alphanumérique recherchée dans un motif LIKE/ILIKE, requise pour utiliser l’évaluation LIKE de l’index de texte via le balayage du dictionnaire.
Les motifs plus courts que ce seuil correspondent à trop de tokens du dictionnaire et sont ignorés afin d’éviter des analyses coûteuses.
Nécessite que `use_text_index_like_evaluation_by_dictionary_scan` soit activé.
## text\_index\_posting\_list\_apply\_mode
Contrôle la façon dont les posting lists sont appliquées lors des requêtes sur l’index de texte.
'materialize' (par défaut) décode immédiatement les posting lists en Roaring Bitmaps.
'lazy' utilise un décodage à la demande basé sur un curseur (nécessite le format d’index V2 et allow\_experimental\_text\_index\_lazy\_apply).
## throw\_if\_no\_data\_to\_insert
Autorise ou interdit les INSERTs vides. Ce paramètre est activé par défaut (une erreur est générée en cas d’insert vide). S’applique uniquement aux INSERTs effectués avec [`clickhouse-client`](/fr/concepts/features/interfaces/cli) ou via l’[interface gRPC](/fr/concepts/features/interfaces/grpc).
## throw\_on\_error\_from\_cache\_on\_write\_operations
Ignorer les erreurs du cache lors de la mise en cache pendant les opérations d’écriture (INSERT, merges)
## throw\_on\_max\_partitions\_per\_insert\_block
Permet de contrôler le comportement lorsque `max_partitions_per_insert_block` est atteint.
Valeurs possibles :
* `true` - Lorsqu’un bloc d’insertion atteint `max_partitions_per_insert_block`, une exception est levée.
* `false` - Consigne un avertissement lorsque `max_partitions_per_insert_block` est atteint.
Cela peut être utile si vous cherchez à comprendre l’impact sur les utilisateurs lors de la modification de [`max_partitions_per_insert_block`](/fr/reference/settings/session-settings#max_partitions_per_insert_block).
## throw\_on\_unsupported\_query\_inside\_transaction
Lever une exception si une requête non prise en charge est exécutée dans une transactio
## timeout\_before\_checking\_execution\_speed
Vérifie que la vitesse d'exécution n'est pas trop faible (pas inférieure à `min_execution_speed`),
une fois le délai spécifié, en secondes, écoulé.
## timeout\_overflow\_mode
Définit ce qu'il faut faire si la requête s'exécute plus longtemps que `max_execution_time` ou si la
durée d'exécution estimée dépasse `max_estimated_execution_time`.
Valeurs possibles :
* `throw` : lever une exception (par défaut).
* `break` : arrêter l'exécution de la requête et renvoyer le résultat partiel, comme si les
données source étaient épuisées.
## timeout\_overflow\_mode\_leaf
Définit ce qui se produit lorsque la requête exécutée sur un nœud feuille dépasse `max_execution_time_leaf`.
Valeurs possibles :
* `throw` : déclencher une exception (par défaut).
* `break` : arrêter l’exécution de la requête et renvoyer un résultat partiel, comme si les
données sources étaient épuisées.
## totals\_auto\_threshold
Le seuil de `totals_mode = 'auto'`.
Voir la section « modificateur WITH TOTALS ».
## totals\_mode
Comment calculer TOTALS en présence de HAVING, ainsi que de max\_rows\_to\_group\_by et de group\_by\_overflow\_mode = 'any'.
Voir la section « modificateur WITH TOTALS ».
## trace\_profile\_events
Active ou désactive la collecte de stacktraces à chaque mise à jour des événements de profil, ainsi que l’envoi dans [trace\_log](/fr/reference/system-tables/trace_log) du nom de l’événement de profil et de la valeur de l’incrément.
Valeurs possibles :
* 1 — Traçage des événements de profil activé.
* 0 — Traçage des événements de profil désactivé.
## trace\_profile\_events\_list
Lorsque le paramètre `trace_profile_events` est activé, limitez les événements tracés à la liste spécifiée de noms séparés par des virgules.
Si `trace_profile_events_list` est une chaîne vide (par défaut), tracez tous les événements de profil.
Valeur d'exemple : 'DiskS3ReadMicroseconds,DiskS3ReadRequestsCount,SelectQueryTimeMicroseconds,ReadBufferFromS3Bytes'
L'utilisation de ce paramètre permet de collecter plus précisément les données pour un grand nombre de requêtes, car sinon, le volume considérable d'événements peut saturer la file d'attente interne du journal système, et une partie d'entre eux sera perdue.
## transfer\_overflow\_mode
Détermine ce qui se passe lorsque la quantité de données dépasse l'une des limites.
Valeurs possibles :
* `throw` : lever une exception (par défaut).
* `break` : arrêter l'exécution de la requête et renvoyer un résultat partiel, comme si la
source de données était épuisée.
## transform\_null\_in
Permet de considérer comme égales les valeurs [NULL](/fr/reference/syntax#null) pour l’opérateur [IN](/fr/reference/statements/in).
Par défaut, les valeurs `NULL` ne peuvent pas être comparées, car `NULL` représente une valeur indéfinie. Ainsi, la comparaison `expr = NULL` doit toujours renvoyer `false`. Avec ce paramètre, `NULL = NULL` renvoie `true` pour l’opérateur `IN`.
Valeurs possibles :
* 0 — La comparaison de valeurs `NULL` avec l’opérateur `IN` renvoie `false`.
* 1 — La comparaison de valeurs `NULL` avec l’opérateur `IN` renvoie `true`.
**Exemple**
Considérez la table `null_in` :
```text theme={null}
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
│ 3 │ 3 │
└──────┴───────┘
```
Requête :
```sql theme={null}
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 0;
```
Résultat :
```text theme={null}
┌──idx─┬────i─┐
│ 1 │ 1 │
└──────┴──────┘
```
Requête :
```sql theme={null}
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 1;
```
Résultat :
```text theme={null}
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
└──────┴───────┘
```
**Voir aussi**
* [Traitement de NULL dans les opérateurs IN](/fr/reference/statements/in#null-processing)
## traverse\_shadow\_remote\_data\_paths
Parcourt les données figées (répertoire shadow) en plus des données réelles de la table lors d’une requête sur system.remote\_data\_paths
## union\_default\_mode
Définit le mode de combinaison des résultats de requêtes `SELECT`. Ce paramètre n'est utilisé qu'avec [UNION](/fr/reference/statements/select/union) lorsque `UNION ALL` ou `UNION DISTINCT` n'est pas explicitement indiqué.
Valeurs possibles :
* `'DISTINCT'` — ClickHouse renvoie les lignes issues de la combinaison des requêtes en supprimant les doublons.
* `'ALL'` — ClickHouse renvoie toutes les lignes issues de la combinaison des requêtes, y compris les doublons.
* `''` — ClickHouse génère une exception lorsqu'il est utilisé avec `UNION`.
Voir des exemples dans [UNION](/fr/reference/statements/select/union).
## unique\_key\_max\_encoded\_size
Taille maximale (en octets) de l’encodage binaire préservant l’ordre d’une seule ligne `UNIQUE KEY`.
## unknown\_packet\_in\_send\_data
Envoyer un paquet inconnu à la place du n-ième paquet de données
## update\_parallel\_mode
Détermine le comportement des requêtes `UPDATE` concurrentes.
Valeurs possibles :
* `sync` - exécute toutes les requêtes `UPDATE` de manière séquentielle.
* `auto` - exécute de manière séquentielle uniquement les requêtes `UPDATE` pour lesquelles il existe des dépendances entre les colonnes mises à jour dans une requête et les colonnes utilisées dans les expressions d’une autre requête.
* `async` - ne synchronise pas les requêtes `UPDATE`.
## update\_sequential\_consistency
Si la valeur est true, l’ensemble des parts est mis à jour vers la dernière version avant l’exécution de la mise à jour.
## url\_base
L’URL de base utilisée pour résoudre les URL relatives dans la fonction de table [url](/fr/reference/functions/table-functions/url) et le moteur de table [URL](/fr/reference/engines/table-engines/special/url).
Lorsqu’elle est définie, les URL relatives sont résolues comme suit :
* URL relative au chemin (par ex. `data.csv`) : fusionnée avec le chemin de l’URL de base conformément à la RFC 3986. Tout ce qui suit le dernier `/` dans le chemin de base est remplacé par l’URL relative ; la barre oblique finale est donc importante : `https://example.com/dir/` + `data.csv` = `https://example.com/dir/data.csv`, mais `https://example.com/dir` + `data.csv` = `https://example.com/data.csv`. Si l’URL de base n’a pas de chemin (par ex. `https://example.com`), un `/` est inséré : `https://example.com/data.csv`. Les segments de point (`./` et `../`) dans l’URL relative sont normalisés : `https://example.com/dir/` + `../a.csv` = `https://example.com/a.csv`.
* URL relative à l’hôte (par ex. `/test/data.csv`) : résolue à partir du schéma et de l’hôte de l’URL de base.
* URL relative au schéma (par ex. `//other.com/test/data.csv`) : résolue à l’aide du schéma de l’URL de base.
* Référence contenant uniquement une query string (par ex. `?x=1`) : ajoutée au chemin de l’URL de base (en remplaçant toute requête ou tout fragment existant).
* Référence contenant uniquement un fragment (par ex. `#frag`) : ajoutée à l’URL de base, en conservant toute query string (en remplaçant tout fragment existant).
* Référence vide : renvoie l’URL de base sans fragment.
Par exemple, si `url_base` vaut `https://example.com/def/`, alors :
* `data.csv` est résolu en `https://example.com/def/data.csv`
* `/test/data.csv` est résolu en `https://example.com/test/data.csv`
* `//other.com/test/data.csv` est résolu en `https://other.com/test/data.csv`
## use\_async\_executor\_for\_materialized\_views
Utilise une exécution asynchrone, et potentiellement multithreadée, de la requête de vue matérialisée, ce qui peut accélérer le traitement des vues lors d'INSERT, mais aussi consommer davantage de mémoire.
## use\_cache\_for\_count\_from\_files
Active la mise en cache du nombre de lignes lors du comptage dans des fichiers avec les fonctions de table `file`/`s3`/`url`/`hdfs`/`azureBlobStorage`.
Activé par défaut.
## use\_client\_time\_zone
Utilise le fuseau horaire du client pour interpréter les valeurs de chaîne DateTime, au lieu d'utiliser le fuseau horaire du serveur.
## use\_compact\_format\_in\_distributed\_parts\_names
Utilise le format compact pour stocker les blocks des INSERT en arrière-plan (`distributed_foreground_insert`) dans les tables utilisant le moteur `Distributed`.
Valeurs possibles :
* 0 — Utilise le format de répertoire `user[:password]@host:port#default_database`.
* 1 — Utilise le format de répertoire `[shard{shard_index}[_replica{replica_index}]]`.
- avec `use_compact_format_in_distributed_parts_names=0`, les modifications de la définition du cluster ne seront pas appliquées aux INSERT en arrière-plan.
- avec `use_compact_format_in_distributed_parts_names=1`, modifier l’ordre des nœuds dans la définition du cluster changera `shard_index`/`replica_index` ; soyez donc vigilant.
## use\_concurrency\_control
Tient compte du contrôle de la concurrence du serveur (voir les paramètres globaux du serveur `concurrent_threads_soft_limit_num` et `concurrent_threads_soft_limit_ratio_to_cores`). S'il est désactivé, cela permet d'utiliser un plus grand nombre de threads même si le serveur est surchargé (non recommandé en usage normal, et surtout nécessaire pour les tests).
Valeur par défaut dans Cloud : `0`.
## use\_hash\_table\_stats\_for\_join\_reordering
Active l’utilisation des statistiques collectées sur les tables de hachage pour estimer la cardinalité lors du réordonnancement des jointures
## use\_hedged\_requests
Active le mécanisme de hedged requests pour les requêtes distantes. Cela permet d’établir plusieurs connexions vers différentes répliques pour une requête.
Une nouvelle connexion est ouverte si la ou les connexions existantes avec la ou les répliques n’ont pas été établies dans le délai `hedged_connection_timeout`
ou si aucune donnée n’a été reçue dans le délai `receive_data_timeout`. La requête utilise la première connexion qui envoie un paquet Progress non vide (ou un paquet Data, si `allow_changing_replica_until_first_data_packet`) ;
les autres connexions sont annulées. Les requêtes avec `max_parallel_replicas > 1` sont prises en charge.
Activé par défaut.
Valeur par défaut dans Cloud : `0`.
## use\_hive\_partitioning
Lorsqu’il est activé, ClickHouse détecte le partitionnement de style Hive dans le chemin (`/name=value/`) des moteurs de table de type fichier [File](/fr/reference/functions/table-functions/file#hive-style-partitioning)/[S3](/fr/reference/functions/table-functions/s3#hive-style-partitioning)/[URL](/fr/reference/functions/table-functions/url#hive-style-partitioning)/[HDFS](/fr/reference/functions/table-functions/hdfs#hive-style-partitioning)/[AzureBlobStorage](/fr/reference/functions/table-functions/azureBlobStorage#hive-style-partitioning), et permet d’utiliser les colonnes de partition comme colonnes virtuelles dans la requête. Ces colonnes virtuelles auront les mêmes noms que dans le chemin partitionné, mais commenceront par `_`.
## use\_iceberg\_metadata\_files\_cache
Si cette option est activée, la fonction de table Iceberg et le moteur de stockage Iceberg peuvent utiliser le cache des fichiers de métadonnées Iceberg.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## use\_iceberg\_partition\_pruning
Utilise l’élagage des partitions pour les tables Iceberg
## use\_index\_for\_in\_with\_subqueries
Tente d’utiliser un index lorsqu’il y a une sous-requête ou une expression de table à droite de l’opérateur IN.
## use\_index\_for\_in\_with\_subqueries\_max\_values
Taille maximale de l’ensemble situé dans la partie droite de l’opérateur IN pour utiliser l’index de la table lors du filtrage. Cela permet d’éviter une dégradation des performances et une consommation mémoire accrue due à la préparation de structures de données supplémentaires pour les requêtes volumineuses. Zéro signifie qu’il n’y a pas de limite.
## use\_join\_disjunctions\_push\_down
Active le pushdown vers les côtés d'entrée correspondants des parties de conditions de JOIN reliées par OR (« pushdown partiel »).
Cela permet aux moteurs de stockage de filtrer plus tôt, ce qui peut réduire la quantité de données lues.
L'optimisation préserve la sémantique et n'est appliquée que lorsque chaque branche OR de niveau supérieur apporte au moins un
prédicat déterministe pour le côté cible.
## use\_legacy\_to\_time
Lorsqu'il est activé, ce paramètre permet d'utiliser l'ancienne fonction toTime, qui convertit une date avec heure en une date fixe donnée, tout en conservant l'heure.
Sinon, une nouvelle fonction toTime est utilisée, qui convertit différents types de données en type Time.
L'ancienne fonction legacy reste également accessible sans condition sous le nom toTimeWithFixedDate.
## use\_lightweight\_primary\_key\_index\_analysis
Optimise l'analyse de l'index de clé primaire pour les tables `MergeTree` avec des clés primaires longues.
Lorsqu'il est activé, la durée d'exécution de l'analyse de l'index dépend principalement de la complexité du filtre de la requête (c'est-à-dire des colonnes clés réellement utilisées), et non de la longueur de la clé primaire. Par conséquent, l'extension de la clé de tri n'ajoute qu'un surcoût négligeable à l'analyse de l'index pour les requêtes qui ne filtrent que sur quelques-unes de ses colonnes.
Valeurs possibles :
* 0 — Désactivé. Toutes les colonnes de la clé primaire sont traitées lors de l'analyse de l'index.
* 1 — Activé.
## use\_page\_cache\_for\_disks\_without\_file\_cache
Utilisez le cache de pages en espace utilisateur pour les disques distants sur lesquels le cache du système de fichiers n'est pas activé.
## use\_page\_cache\_for\_local\_disks
Utilise le cache de pages en espace utilisateur lors de la lecture à partir de disques locaux. Utilisé pour les tests, il est peu probable qu’il améliore réellement les performances en pratique. Nécessite local\_filesystem\_read\_method = 'pread' ou 'read'. Ne désactive pas le cache de pages du système d’exploitation ; min\_bytes\_to\_use\_direct\_io peut être utilisé à cette fin. Affecte uniquement les tables ordinaires, pas la fonction de table file() ni le moteur de table File().
## use\_page\_cache\_for\_object\_storage
Utilise le cache de pages en espace utilisateur lors de la lecture depuis les fonctions de table du stockage objet (s3, azure, hdfs) et les moteurs de table (S3, Azure, HDFS).
## use\_page\_cache\_with\_distributed\_cache
Utiliser le cache de pages en espace utilisateur lorsque le distributed cache est utilisé.
## use\_paimon\_partition\_pruning
Utiliser l’élagage des partitions de Paimon pour les fonctions de table Paimon
## use\_parquet\_metadata\_cache
Lorsqu'il est activé, le format Parquet peut utiliser le cache des métadonnées Parquet.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## use\_partition\_pruning
**Alias** : `use_partition_key`
Utilise la clé de partition pour réduire le nombre de partitions analysées lors de l’exécution des requêtes sur les tables MergeTree.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_primary\_key
Utilise la clé primaire pour élaguer les granules lors de l’exécution des requêtes sur les tables MergeTree.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_query\_cache
Si cette option est activée, les requêtes `SELECT` peuvent utiliser le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache). Les paramètres [enable\_reads\_from\_query\_cache](#enable_reads_from_query_cache)
et [enable\_writes\_to\_query\_cache](#enable_writes_to_query_cache) contrôlent plus précisément l’utilisation du cache.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## use\_query\_condition\_cache
Active le [cache des conditions de requête](/fr/concepts/features/performance/caches/query-condition-cache). Ce cache stocke les plages de granules dans les data parts qui ne satisfont pas la condition de la clause `WHERE`,
et réutilise ces informations comme index éphémère pour les requêtes suivantes.
Valeurs possibles :
* 0 - Désactivé
* 1 - Activé
## use\_reader\_executor
Expérimental. Fait passer les lectures par le nouveau pipeline `ReaderExecutor` au lieu de l’empilement legacy de tampons de lecture. Revient au chemin legacy pour les configurations que l’executor ne prend pas encore en charge.
## use\_roaring\_bitmap\_iceberg\_positional\_deletes
Utiliser un bitmap roaring pour les suppressions positionnelles dans Iceberg.
## use\_skip\_indexes
Utiliser les index de saut de données lors de l'exécution des requêtes.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_skip\_indexes\_for\_disjunctions
Évalue les filtres WHERE comportant des conditions AND et OR mixtes à l’aide des skip indexes. Exemple : WHERE A = 5 AND (B = 5 OR C = 5).
S’il est désactivé, les skip indexes sont toujours utilisés pour évaluer les conditions WHERE, mais celles-ci ne doivent contenir que des clauses reliées par AND.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_skip\_indexes\_for\_top\_k
Active l’utilisation des index de saut de données pour le filtrage TopK.
Lorsque ce paramètre est activé, si un index MinMax existe sur la colonne dans une requête `ORDER BY LIMIT n`, l’optimiseur tentera d’utiliser cet index MinMax pour ignorer les granules non pertinentes pour le résultat final. Cela peut réduire la latence des requêtes.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_skip\_indexes\_if\_final
Détermine si les index de saut sont utilisés lors de l’exécution d’une requête avec le modificateur FINAL.
Les index de saut peuvent exclure des lignes (granules) contenant les données les plus récentes, ce qui peut entraîner des résultats incorrects pour une requête avec le modificateur FINAL. Lorsque ce paramètre est activé, les index de saut sont appliqués même avec le modificateur FINAL, ce qui peut améliorer les performances, mais au risque d’omettre des mises à jour récentes. Ce paramètre doit être activé en même temps que le paramètre use\_skip\_indexes\_if\_final\_exact\_mode (activé par défaut).
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_skip\_indexes\_if\_final\_exact\_mode
Détermine si les granules renvoyés par un skip index sont étendus dans les parts les plus récentes afin de garantir des résultats corrects lors de l'exécution d'une requête avec le modificateur FINAL.
L'utilisation de skip indexes peut exclure des lignes (granules) contenant les données les plus récentes, ce qui peut entraîner des résultats incorrects. Ce paramètre permet de garantir des résultats corrects en analysant les parts les plus récentes qui chevauchent les plages renvoyées par le skip index. Ce paramètre ne doit être désactivé que si des résultats approximatifs basés sur la consultation du skip index conviennent à l'application.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_skip\_indexes\_on\_data\_read
Active l’utilisation des index de saut de données pendant la lecture des données.
Lorsque cette option est activée, les index de saut sont évalués dynamiquement au moment de la lecture de chaque granule de données, plutôt que d’être analysés à l’avance avant le début de l’exécution de la requête. Cela peut réduire la latence au démarrage de la requête.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_statistics
/// à préférer à 'allow\_statistics\_optimize' pour rester cohérent avec 'use\_primary\_key' et 'use\_skip\_indexes'
Permet d'utiliser les statistiques pour optimiser les requêtes
## use\_statistics\_cache
Utiliser le cache de statistiques dans une requête pour éviter la surcharge liée au chargement des statistiques pour chaque part
## use\_statistics\_for\_part\_pruning
Utilise des statistiques pour filtrer les parts pendant l'exécution des requêtes.
Lorsqu'il est activé, l'élagage dans les requêtes SELECT utilise les statistiques de colonnes (par ex. les statistiques MinMax) pour éliminer, avant toute lecture de données, les parts qui ne peuvent pas contenir les données recherchées.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_strict\_insert\_block\_limits
Lorsqu'il est activé, ce paramètre applique strictement les limites minimale et maximale de taille des blocs d'insertion.
Un bloc est émis lorsque :
* Seuils min (AND) : min\_insert\_block\_size\_rows ET min\_insert\_block\_size\_bytes sont tous deux atteints.
* Seuils max (OR) : soit max\_insert\_block\_size\_rows, soit max\_insert\_block\_size\_bytes est atteint.
Lorsqu'il est désactivé, un bloc est émis lorsque :
* Seuils min (OR) : min\_insert\_block\_size\_rows OU min\_insert\_block\_size\_bytes est atteint.
**Remarque** : si les paramètres max sont inférieurs aux paramètres min, les limites max priment et les blocs seront émis avant que les seuils min ne soient atteints.
**Remarque** : ce paramètre est automatiquement désactivé pour les insertions asynchrones, car celles-ci attachent des tokens de déduplication par entrée incompatibles avec le fractionnement des blocs nécessaire à l'application stricte de ces limites.
Désactivé par défaut.
## use\_structure\_from\_insertion\_table\_in\_table\_functions
Utilise la structure de la table d’insertion au lieu de l’inférence de schéma à partir des données. Valeurs possibles : 0 - désactivé, 1 - activé, 2 - auto
Indique s’il faut utiliser un cache de l’en-tête désérialisé de l’index de texte.
L’utilisation du cache de l’en-tête de l’index de texte peut réduire considérablement la latence et augmenter le débit lors du traitement d’un grand nombre de requêtes sur l’index de texte.
## use\_text\_index\_like\_evaluation\_by\_dictionary\_scan
Permet d’évaluer les requêtes LIKE/ILIKE en analysant le dictionnaire de l’index de texte inversé.
## use\_text\_index\_postings\_cache
Indique s’il faut utiliser un cache des listes de postings désérialisées de l’index de texte.
L’utilisation du cache des listes de postings de l’index de texte peut réduire considérablement la latence et augmenter le débit lors de l’exécution d’un grand nombre de requêtes sur l’index de texte.
## use\_text\_index\_tokens\_cache
Indique s’il faut utiliser un cache d’informations désérialisées sur les jetons de l’index de texte.
L’utilisation du cache des jetons de l’index de texte peut réduire considérablement la latence et augmenter le débit lors de l’exécution d’un grand nombre de requêtes sur l’index de texte.
## use\_top\_k\_dynamic\_filtering
Active l’optimisation du filtrage dynamique lors de l’exécution d’une requête `ORDER BY LIMIT n`.
Lorsqu’elle est activée, le moteur d’exécution de la requête tente d’ignorer les granules et les lignes qui ne feront pas partie des `top N` lignes finales du jeu de résultats. Cette optimisation est de nature dynamique, et les gains de latence dépendent de la distribution des données et de la présence d’autres prédicats dans la requête.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_top\_k\_dynamic\_filtering\_for\_variable\_length\_types
Permet à `use_top_k_dynamic_filtering` de s’appliquer lorsque la colonne de tri a un type de données de longueur variable (par ex. `String`, `Array`, `Map`, `Tuple` contenant des éléments de longueur variable).
Pour de tels types, la comparaison du seuil ligne par ligne effectuée par le filtre dynamique peut coûter plus qu’elle ne rapporte lorsque le minimum lexicographique de la colonne prédomine (par ex. des chaînes majoritairement vides) et que peu de granules peuvent être ignorés. Dans ce cas, le filtre dynamique dégrade la latence des requêtes au lieu de l’améliorer.
Lorsque ce paramètre vaut `0`, le filtrage dynamique est limité aux colonnes dont les valeurs ont une taille maximale fixe en mémoire (nombres, `Date`, `DateTime`, `FixedString`, `Enum`, `Nullable` de tels types, `Tuple` de tels types). Lorsqu’il vaut `1`, le filtrage dynamique s’applique aussi aux types de longueur variable.
Valeurs possibles :
* 0 — Désactivé.
* 1 — Activé.
## use\_uncompressed\_cache
Indique s’il faut utiliser un cache de blocs non compressés. Accepte 0 ou 1. Par défaut : 0 (désactivé).
L’utilisation du cache non compressé (uniquement pour les tables de la famille MergeTree) peut réduire considérablement la latence et augmenter le débit lors du traitement d’un grand nombre de requêtes courtes. Activez ce paramètre pour les utilisateurs qui envoient fréquemment de courtes requêtes. Tenez également compte du paramètre de configuration [uncompressed\_cache\_size](/fr/reference/settings/server-settings/settings#uncompressed_cache_size) (défini uniquement dans le fichier de configuration), qui correspond à la taille des blocs du cache non compressé. Par défaut, elle est de 8 GiB. Le cache non compressé se remplit selon les besoins, et les données les moins utilisées sont automatiquement supprimées.
Pour les requêtes qui lisent un volume de données au moins relativement important (un million de lignes ou plus), le cache non compressé est désactivé automatiquement afin de réserver l’espace aux requêtes réellement petites. Cela signifie que vous pouvez laisser le paramètre 'use\_uncompressed\_cache' toujours défini sur 1.
## use\_variant\_as\_common\_type
Permet d’utiliser le type `Variant` comme type de résultat pour les fonctions [if](/fr/reference/functions/regular-functions/conditional-functions#if)/[multiIf](/fr/reference/functions/regular-functions/conditional-functions#multiIf)/[array](/fr/reference/functions/regular-functions/array-functions)/[map](/fr/reference/functions/regular-functions/tuple-map-functions) lorsqu’il n’existe aucun type commun entre les types d’arguments.
Exemple :
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(if(number % 2, number, range(number))) as variant_type FROM numbers(1);
SELECT if(number % 2, number, range(number)) as variant FROM numbers(5);
```
```text theme={null}
┌─variant_type───────────────────┐
│ Variant(Array(UInt64), UInt64) │
└────────────────────────────────┘
┌─variant───┐
│ [] │
│ 1 │
│ [0,1] │
│ 3 │
│ [0,1,2,3] │
└───────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL)) AS variant_type FROM numbers(1);
SELECT multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL) AS variant FROM numbers(4);
```
```text theme={null}
─variant_type─────────────────────────┐
│ Variant(Array(UInt8), String, UInt8) │
└──────────────────────────────────────┘
┌─variant───────┐
│ 42 │
│ [1,2,3] │
│ Hello, World! │
│ ᴺᵁᴸᴸ │
└───────────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(array(range(number), number, 'str_' || toString(number))) as array_of_variants_type from numbers(1);
SELECT array(range(number), number, 'str_' || toString(number)) as array_of_variants FROM numbers(3);
```
```text theme={null}
┌─array_of_variants_type────────────────────────┐
│ Array(Variant(Array(UInt64), String, UInt64)) │
└───────────────────────────────────────────────┘
┌─array_of_variants─┐
│ [[],0,'str_0'] │
│ [[0],1,'str_1'] │
│ [[0,1],2,'str_2'] │
└───────────────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(map('a', range(number), 'b', number, 'c', 'str_' || toString(number))) as map_of_variants_type from numbers(1);
SELECT map('a', range(number), 'b', number, 'c', 'str_' || toString(number)) as map_of_variants FROM numbers(3);
```
```text theme={null}
┌─map_of_variants_type────────────────────────────────┐
│ Map(String, Variant(Array(UInt64), String, UInt64)) │
└─────────────────────────────────────────────────────┘
┌─map_of_variants───────────────┐
│ {'a':[],'b':0,'c':'str_0'} │
│ {'a':[0],'b':1,'c':'str_1'} │
│ {'a':[0,1],'b':2,'c':'str_2'} │
└───────────────────────────────┘
```
## use\_variant\_default\_implementation\_for\_comparisons
Active ou désactive l’implémentation par défaut pour le type Variant dans les fonctions de comparaison.
## use\_with\_fill\_by\_sorting\_prefix
Les colonnes qui précèdent les colonnes WITH FILL dans la clause ORDER BY constituent le préfixe de tri. Les lignes ayant des valeurs différentes dans ce préfixe de tri sont remplies indépendamment
## validate\_enum\_literals\_in\_operators
Si cette option est activée, les littéraux d’enum utilisés dans des opérateurs tels que `IN`, `NOT IN`, `==`, `!=` sont validés par rapport au type enum, et une exception est levée si le littéral ne correspond pas à une valeur enum valide.
## validate\_mutation\_query
Valider les requêtes de mutation avant de les accepter. Les mutations sont exécutées en arrière-plan, et l’exécution d’une requête non valide peut les bloquer, ce qui nécessite une intervention manuelle.
Ne modifiez ce paramètre que si vous rencontrez un bogue de rupture de rétrocompatibilité.
## validate\_polygons
Active ou désactive le déclenchement d'une exception dans la fonction [pointInPolygon](/fr/reference/functions/regular-functions/geo/coordinates#pointinpolygon) si le polygone s'auto-intersecte ou est auto-tangent.
Valeurs possibles :
* 0 — Le déclenchement d'une exception est désactivé. `pointInPolygon` accepte les polygones invalides et peut renvoyer des résultats incorrects.
* 1 — Le déclenchement d'une exception est activé.
## variant\_throw\_on\_type\_mismatch
Lorsqu’une fonction est appliquée à une colonne [Variant](/fr/reference/data-types/variant) à l’aide de l’implémentation par défaut,
ce paramètre contrôle ce qui se passe pour les lignes dont le type réel est incompatible avec la fonction :
* `true` (par défaut) — génère une exception.
* `false` — renvoie `NULL` pour ces lignes à la place.
## vector\_search\_filter\_strategy
Si une requête de recherche vectorielle comporte une clause WHERE, ce paramètre détermine si elle est évaluée en premier (pre-filtering) ou si l’index de similarité vectorielle est consulté en premier (post-filtrage). Valeurs possibles :
* 'auto' - Postfiltering (la sémantique exacte peut changer à l’avenir).
* 'postfilter' - Utilise l’index de similarité vectorielle pour identifier les plus proches voisins, puis applique les autres filtres
* 'prefilter' - Évalue d’abord les autres filtres, puis effectue une recherche brute-force pour identifier les voisins.
## vector\_search\_index\_fetch\_multiplier
**Alias** : `vector_search_postfilter_multiplier`
Multiplie par cette valeur le nombre de plus proches voisins récupérés depuis l’index de similarité vectorielle. S’applique uniquement lors d’un post-filtrage avec d’autres prédicats ou si le paramètre 'vector\_search\_with\_rescoring = 1'.
## vector\_search\_with\_rescoring
Indique si ClickHouse effectue un rescoring pour les requêtes qui utilisent l’index de similarité vectorielle.
Sans rescoring, l’index de similarité vectorielle renvoie directement les lignes contenant les meilleures correspondances.
Avec rescoring, les lignes sont extrapolées au niveau de la granule et toutes les lignes de cette granule sont à nouveau vérifiées.
Dans la plupart des cas, le rescoring n’améliore la précision qu’à la marge, mais dégrade significativement les performances des requêtes de recherche vectorielle.
Remarque : une requête exécutée sans rescoring, avec les répliques parallèles activées, peut basculer automatiquement vers le rescoring.
## wait\_changes\_become\_visible\_after\_commit\_mode
Attendre que les modifications validées deviennent réellement visibles dans l’instantané le plus récent
## wait\_for\_async\_insert
Si true, attend la fin du traitement de l'insertion asynchrone
## wait\_for\_async\_insert\_timeout
Délai d’attente du traitement de l’insertion asynchrone
## wait\_for\_part\_commit\_in\_dependent\_materialized\_views
Contrôle si chaque sink valide la part qu’il vient d’écrire avant que sa propre cascade de vues matérialisées dépendantes ne s’exécute, afin qu’une cascade qui relit depuis la source via `JOIN` voie la part écrite par ce sink.
La garantie s’applique à chaque instance de sink individuellement — les parts écrites par d’autres threads de sink du même `INSERT` peuvent ne pas encore être visibles. Ce paramètre ne garantit pas d’ordre de validation entre les threads.
N’a aucun effet sur les insertions dans des tables sans vues matérialisées dépendantes.
## wait\_for\_window\_view\_fire\_signal\_timeout
Délai d’attente du signal de déclenchement de la window view en traitement par temps d’événement
## webassembly\_udf\_max\_fuel
Limite de fuel par exécution d’une instance de WebAssembly UDF. Chaque instruction WebAssembly consomme une certaine quantité de fuel. La valeur est multipliée par 1024 avant d’être transmise à l’environnement d’exécution, donc `webassembly_udf_max_fuel = 1` correspond à environ 1024 unités de fuel. Définissez-la sur 0 pour supprimer toute limite finie. S’applique uniquement aux fonctions dont le paramètre propre à la fonction `webassembly_udf_enable_fuel` est défini sur true, ce qui est la valeur par défaut.
## webassembly\_udf\_max\_input\_block\_size
Nombre maximal de lignes transmises à une UDF WebAssembly dans un même bloc. Définissez cette valeur sur 0 pour traiter toutes les lignes en une seule fois.
## webassembly\_udf\_max\_instances
Nombre maximal d'instances WebAssembly UDF pouvant s'exécuter en parallèle pour chaque fonction.
## webassembly\_udf\_max\_memory
Limite de mémoire en octets pour chaque instance de WebAssembly UDF.
## window\_view\_clean\_interval
L’intervalle de nettoyage de la window view, en secondes, pour supprimer les données obsolètes.
## window\_view\_heartbeat\_interval
L’intervalle du signal de pulsation, en secondes, indiquant que la requête watch est active.
## charge de travail
Nom de la charge de travail utilisée pour accéder aux ressources
## write\_full\_path\_in\_iceberg\_metadata
Écrire les chemins complets (y compris s3://) dans les fichiers de métadonnées Iceberg.
## write\_through\_distributed\_cache
N'a d'effet que dans ClickHouse Cloud. Autorise l'écriture dans le cache distribué (l'écriture vers S3 sera également effectuée par le cache distribué)
## write\_through\_distributed\_cache\_buffer\_size
N'a d'effet que dans ClickHouse Cloud. Définit la taille du tampon du cache distribué en écriture directe. Si la valeur est 0, utilise la taille de tampon qui aurait été utilisée en l'absence de cache distribué.
## zstd\_window\_log\_max
Permet de sélectionner le log de fenêtre maximal de ZSTD (il ne sera pas utilisé pour la famille MergeTree)