> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-detect-table-modification.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Autres paramètres de session > Paramètres de session ClickHouse du groupe généré « Autres ». export const CloudOnlyBadge = () => { return
{'Uniquement sur ClickHouse Cloud'}
; }; export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => { if (link) { return Beta ; } return Fonctionnalité en bêta ; }; export const ExperimentalBadge = () => { return
Fonctionnalité expérimentale ; }; export const VersionHistory = ({rows = []}) => { if (rows.length === 0) { return null; } const headers = ["Version", "Valeur par défaut", "Commentaire"]; const border = "1px solid rgba(128, 128, 128, 0.3)"; const cell = { border, padding: "0.25rem 0.5rem", textAlign: "start", verticalAlign: "top" }; return
Historique des versions {headers.map(header => )} {rows.map((row, row_index) => {(row.items ?? []).map((item, item_index) => )} )}
{header}
{item?.label}
; }; export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => { return
Type
{type}
Par défaut
{default_value}
{changeable_without_restart &&
Modifiable sans redémarrage
} {changeable_without_restart &&
{changeable_without_restart}
}
; }; Ces paramètres sont disponibles dans [system.settings](/fr/reference/system-tables/settings) et sont générés automatiquement à partir du [code source](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/Settings.cpp).
## adaptive\_aggregator\_freeze\_threshold
Nombre de clés à partir duquel l’agrégateur adaptatif fige la table de hachage locale d’un thread (voir `enable_adaptive_aggregator`). Des valeurs plus faibles maintiennent les tables figées dans le cache, tandis que des valeurs plus élevées leur permettent d’absorber davantage de clés fréquentes. La valeur 0 fige les tables dès que possible, ce qui fait que l’algorithme se comporte de manière similaire à l’agrégateur partitionné (`enable_sharding_aggregator`) : chaque clé est routée selon son hash et agrégée par un seul propriétaire, mais l’opération est reportée à la phase de fusion au lieu d’être échangée entre les threads pendant le parcours.
## add\_http\_cors\_header
Écrit un en-tête CORS HTTP supplémentaire.
## 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 que la requête comporte des conditions sur ses arguments, par exemple `x >= 10 AND x <= 20 AND y >= 20 AND y <= 30`, utilisez la courbe de remplissage de l’espace pour l’analyse de l’index.
## analyzer\_inline\_views
Lorsqu’il est activé, l’analyseur remplace les vues ordinaires (non matérialisées et non paramétrées) par les sous-requêtes qui les définissent, ce qui permet des optimisations transversales telles que le pushdown des 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 assurer 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 entre les tables, de gauche à droite, de plusieurs à un. * Les résultats des opérations `ANY INNER JOIN` contiennent toutes les lignes de la table de gauche, comme c’est le cas pour 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 permet une correspondance des clés de un à 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 des JOIN](/fr/reference/statements/select/join#settings)
## archive\_adaptive\_buffer\_max\_size\_bytes
Limite la taille maximale du tampon adaptatif utilisé pour l’écriture dans 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 (requis 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 (requis pour Dremio)
## 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 requête S3 rencontre une erreur S3 pouvant donner lieu à un réessai, 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 d’arrière-plan utilisés pour télécharger de manière spéculative de nouvelles parts 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#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 des requêtes. Il s'agit du comportement par défaut. Cela nécessite des recherches 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. Dans des conditions normales, 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`.
## checksum\_on\_read
Valide les sommes de contrôle lors de la lecture. Ce paramètre est activé par défaut et doit toujours l’être en production. N’attendez aucun bénéfice de la désactivation de ce paramètre. Il ne doit être utilisé que pour des expérimentations et des benchmarks. Ce paramètre s’applique uniquement aux tables de la famille MergeTree. Les sommes de contrôle sont toujours validées pour les autres moteurs de table et lors de la réception de données sur le réseau.
## compression
Applique une compression générique au corps de la réponse, par exemple `compression=gz`. Notez que ce paramètre est indépendant de `Content-Encoding` (compression HTTP) et de l’ancien paramètre `compress` (compression native de ClickHouse). Indiquer une extension de fichier compressé dans le chemin d’URL produit le même effet. Il s’agit d’un paramètre de l’interface HTTP qui définit la forme de la réponse : il est pris en compte avant l’exécution de la requête (les tampons de réponse sont configurés à l’avance). Il doit donc être fourni via le paramètre d’URL HTTP, l’extension de fichier du chemin d’URL ou un profil utilisateur, et non via une clause `SETTINGS` dans la requête (où il n’a aucun effet et est rejeté).
## connection\_pool\_max\_wait\_ms
Temps d’attente, en millisecondes, pour obtenir une connexion lorsque le pool de connexions est plein. Valeurs possibles : * Entier positif. * 0 — Délai d’attente infini.
## connections\_with\_failover\_max\_tries
Le nombre maximal de tentatives de connexion à effectuer avec chaque réplique pour le moteur de table Distributed.
## convert\_query\_to\_cnf
Lorsqu'elle est définie sur `true`, une requête `SELECT` est convertie en forme normale conjonctive (CNF). Dans certains cas, réécrire une requête en CNF peut accélérer son exécution (voir 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 CNF, 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
## count\_matches\_stop\_at\_empty\_match
Arrête le comptage dès qu’un motif produit une correspondance de longueur nulle dans la fonction `countMatches`.
## cross\_to\_inner\_join\_rewrite
Utilisez 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 les définitions de colonnes 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.
## decimal\_check\_overflow
Vérifie les dépassements de capacité 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 données dupliquées lorsque l’opération d’insertion est réessayée à la suite d’une défaillance. **Voir aussi** * [Traitement de NULL dans les opérateurs IN](/fr/concepts/features/operations/insert/deduplicating-inserts-on-retries#insert-deduplication-with-materialized-views)
## 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 sûr du point de vue de la validité des résultats, introduit en 26.3 : `FINAL` peut devoir dédupliquer des lignes qui partagent une clé primaire mais se trouvent dans des partitions différentes, et l'élagage des partitions exclurait silencieusement ces lignes de l'ensemble d'entrée de la déduplication. Lorsqu'il est désactivé, l'élagage des partitions s'applique 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 n'est correct que lorsque des lignes ayant la même clé primaire ne peuvent pas exister dans des partitions différentes — par exemple, des tables de journaux d'événements dont la colonne de partition est définie au moment de l'insert 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 — Différer l'élagage des partitions après `FINAL` (par défaut, sûr du point de vue de la validité des résultats).
## describe\_compact\_output
Si cette valeur est définie sur true, inclut uniquement les noms de colonnes et les types dans le résultat de la requête DESCRIBE
## dialecte
Détermine le dialecte utilisé pour analyser la requête. Valeurs prises en charge : * `clickhouse` (par défaut) — ClickHouse SQL standard. * `kusto` — Kusto Query Language. Nécessite le paramètre expérimental `allow_experimental_kusto_dialect`. * `prql` — PRQL. Nécessite le paramètre expérimental `allow_experimental_prql_dialect`. * `polyglot` — convertit le SQL provenant d'autres dialectes (MySQL, PostgreSQL, etc.) en ClickHouse SQL. Nécessite le paramètre expérimental `allow_experimental_polyglot_dialect`. * `promql` — PromQL (langage de requêtes Prometheus) évalué sur une table TimeSeries, configurée à l'aide des paramètres `promql_database`, `promql_table` et `promql_evaluation_time`. * `clickhouse_json` — au lieu d'un texte SQL, la requête est interprétée comme un AST JSON (la sortie de `parseQueryToJSON`). La requête `SET` reste reconnue sous sa forme habituelle afin de pouvoir rétablir le dialecte. Nécessite le paramètre expérimental `enable_json_ast_dialect`.
## discard\_query\_data
S’il est activé, le serveur n’envoie pas au client les lignes du résultat de la requête. La requête est toujours exécutée et intégralement journalisée sur le serveur, et le client reçoit toujours les paquets restants. Utilisé pour le trafic miroir, les benchmarks et le fuzzing. N’a aucun effet sur les requêtes secondaires. Affecte uniquement le protocole TCP natif.
## distinct\_overflow\_mode
Définit ce qui se produit 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 le résultat partiel, comme si les données source étaient épuisées.
## 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 fusion s’effectue uniquement au sein de chaque partition. Cela peut considérablement améliorer les performances des requêtes sur les tables partitionnées.
## 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.
## enforce\_strict\_identifier\_format
Si cette option est activée, n’autoriser que les identifiants contenant des caractères alphanumériques et des traits de soulignement.
## engine\_url\_skip\_empty\_files
Permet d’ignorer ou non les 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 lèvera une exception.
## exclude\_materialize\_skip\_indexes\_on\_insert
Exclut les index de saut spécifiés afin qu’ils ne soient ni construits ni stockés lors des INSERT. Les index de saut exclus seront toutefois toujours construits et stockés [lors des fusions](/fr/reference/settings/merge-tree-settings/materialize#materialize_skip_indexes_on_merge) ou par une requête [MATERIALIZE INDEX](/fr/reference/statements/alter/skipping-index#materialize-index) explicite. N’a aucun effet si [materialize\_skip\_indexes\_on\_insert](/fr/reference/settings/session-settings/materialize#materialize_skip_indexes_on_insert) vaut 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 sous forme de sous-requêtes scalaires. Comme pour les sous-requêtes scalaires, le cache est utilisé et le constant folding s'applique au résultat. Valeur par défaut dans Cloud : `0`.
## explain\_query\_plan\_default
Format par défaut utilisé par `EXPLAIN PLAN`. Valeurs possibles : * `pretty` (par défaut depuis la version 26.7) — `actions`, `compact` et `pretty` valent par défaut `true`, ce qui produit un plan compact, pretty et annoté avec les actions. * `legacy` — sortie antérieure à la version 26.7. Si vous spécifiez explicitement les options `actions`, `compact` ou `pretty` dans l’instruction `EXPLAIN` (par exemple, `EXPLAIN actions = 0, compact = 0, pretty = 0 SELECT ...`), cela prévaut toujours sur ce paramètre. `EXPLAIN PLAN` avec `json = 1` ou `distributed = 1` conserve les valeurs par défaut legacy (antérieures à la version 26.7), indépendamment de ce paramètre, sauf si `actions`, `compact` ou `pretty` sont définis explicitement. La sortie pretty ne peut pas représenter des résultats JSON ni des plans distribués par shard ; ces modes ne sont donc correctement rendus qu’au format legacy.
## extract\_key\_value\_pairs\_max\_pairs\_per\_row
**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 prendre en compte les valeurs extrêmes (les valeurs minimales et maximales des colonnes dans le résultat de la requête). Accepte 0 ou 1. La valeur par défaut est 0 (désactivé). Pour plus d’informations, consultez la section « Valeurs extrêmes ».
## fallback\_to\_stale\_replicas\_for\_distributed\_queries
Force une requête vers une réplique obsolète si des données à jour ne sont pas disponibles. Voir [Replication](/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` depuis 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 partitionnement par défaut pour les moteurs de type fichier. S’applique uniquement lorsque le chemin ne contient pas d’espace réservé `{_partition_id}` : un tel chemin n’est compatible qu’avec la stratégie `wildcard` et implique donc toujours `wildcard`.
## filesystem\_prefetches\_limit
Nombre maximal de prefetches. Zéro signifie qu'il n'y a pas de limite. Il est toutefois recommandé d'utiliser le paramètre `filesystem_prefetches_max_memory_usage` si vous souhaitez limiter le nombre de prefetches.
## filter
Ajoute une clause `WHERE` à la requête en l’enveloppant dans une sous-requête. Plusieurs filtres sont combinés avec AND. L’interface HTTP autorise plusieurs paramètres d’URL `filter`, combinés avec AND dans l’ordre, ainsi qu’avec la valeur de ce paramètre. Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’enveloppant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause `SETTINGS` dans la requête ou un profil utilisateur. Il s’applique aux requêtes `SELECT` / `UNION` qui produisent des résultats. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que si le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — comme pour tout autre paramètre. `filter` n’est **pas** un mécanisme de contrôle d’accès et ne doit pas être utilisé à la place des [politiques de sécurité au niveau des lignes](/fr/concepts/features/security/access-rights#row-policy-management) ou du paramètre `additional_table_filters`. Il ajoute uniquement une clause `WHERE` à la sous-requête enveloppante ; les données sous-jacentes sont donc toujours lues et traitées avant l’application du filtre — une requête peut observer les lignes exclues par le filtre pendant leur traitement (par exemple, avec `throwIf` afin de divulguer des informations par le biais du chemin d’erreur). Utilisez la sécurité au niveau des lignes ou `additional_table_filters` pour restreindre les lignes auxquelles un utilisateur peut accéder.
## 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 dans les 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 INSERT, ce qui réduit l’utilisation mémoire maximale au prix d’un parallélisme de téléversement vers S3 moindre. Par défaut, le flux de sortie de chaque projection est maintenu actif jusqu’à la finalisation de l’intégralité de la part (y compris toutes les projections), ce qui permet de faire se chevaucher les téléversements vers S3, mais augmente l’utilisation mémoire maximale proportionnellement au nombre de projections. Ce paramètre n’affecte que le processus d’INSERT ; merge et 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 aplatie en tableaux distincts. * 0 — La colonne Nested reste un tableau unique de tuples. **Utilisation** Si ce paramètre est défini sur `0`, il est possible d'utiliser un niveau d'imbrication quelconque. **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 │ └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ ```
## format
Remplace le `FORMAT` de la requête, tant en entrée qu'en sortie. Prévaut sur le format spécifié dans la requête et dans l’extension du fichier. Les paramètres plus spécifiques `input_format` et `output_format` prévalent sur ce paramètre générique `format` dans leur sens respectif.
## framing\_output\_format
Permet de multiplexer différentes parties de la réponse à une requête dans un flux unique : fragments de données, totaux et extrêmes, paquets de progression, événements de profilage (métriques) et journaux du serveur — tout ce que prend en charge le protocole natif. Les formats de tramage sont indépendants des formats de sortie : ils encapsulent les octets produits par n’importe quel format de sortie, en séparant et, éventuellement, en encodant ces fragments d’octets. La concaténation des charges utiles de tous les paquets `data`, `totals` et `extremes` correspond exactement à ce que le format de sortie aurait produit sans tramage. Les paquets auxiliaires (progression, journaux, événements de profilage, exceptions) sont représentés en JSON. Une exception délibérée : un format de sortie qui omet les totaux et les extrêmes de sa sortie brute parce qu’il ne peut pas les représenter (la famille `JSONCompactEachRow`) les émet malgré tout avec le tramage, dans les paquets `totals` et `extremes`. Pour ces formats, la concaténation des seuls paquets `data` correspond exactement à la sortie sans tramage, tandis que les paquets `totals` et `extremes` contiennent des lignes supplémentaires absentes de cette sortie. Les journaux du serveur sont inclus si le paramètre `send_logs_level` est défini, et les événements de profilage si le paramètre `send_profile_events` est activé (ils sont envoyés au plus une fois toutes les `interactive_delay` microsecondes, et les paquets de progression sont également limités par `interactive_delay`). Un flux réussi se termine par un paquet `progress` final contenant les compteurs finaux (`result_rows`, `result_bytes`, `memory_usage`), écrit après les paquets `log` et `profile_events` de fin émis par la journalisation de fin de requête, à l’instar du paquet de progression final du protocole natif. En cas d’échec, le paquet `exception` est le dernier paquet — à une exception près : lorsque l’échec survient après qu’une partie du flux de paquets a déjà été produite dans la réponse et ne peut plus être supprimée (l’écriture d’un paquet échoue en cours de route, la transmission du paquet `exception` lui-même échoue, ou le flux de réponse échoue lors de son vidage ou de sa fermeture), le tramage échoue de manière sécurisée : le flux est interrompu sans paquet `exception` terminal, et le client observe une réponse tronquée ainsi qu’une connexion HTTP interrompue au lieu d’un paquet terminal analysable. Rien n’est jamais ajouté après un flux de paquets partiel ; un corps d’erreur HTTP brut n’y est donc jamais mélangé. Tout ce qu’une requête active uniquement via sa propre clause `SETTINGS` — un format de tramage, `send_logs_level` ou `send_profile_events` — n’est connu qu’après l’analyse de la requête ; les journaux et événements de profilage correspondants ne sont donc capturés qu’à partir de l’exécution de la requête. Les journaux et événements de profilage des phases d’analyse syntaxique, de planification et d’analyse sont capturés uniquement lorsque le paramètre provient de la session ou de l’URL. Par exemple, une requête qui échoue pendant l’analyse (par exemple, en raison d’une référence à une table inconnue) et n’active `send_logs_level` que dans sa clause `SETTINGS` ne transmet que le paquet `exception`, et non les journaux de la phase d’analyse ; définissez `send_logs_level` dans la session ou l’URL pour les capturer. La même réserve liée à la découverte tardive s’applique à `send_logs_source_regexp` : la file de journaux filtre les entrées par source au moment où chacune est capturée, de sorte qu’une expression régulière définie uniquement dans la clause `SETTINGS` de la requête ne prend effet qu’à partir de l’exécution de la requête. Les paquets `log` des phases d’analyse syntaxique, de planification et d’analyse sont filtrés selon la valeur du paramètre définie dans la session ou l’URL (ils ne sont pas filtrés si elle n’y est pas définie) ; ils peuvent donc inclure des sources qui ne correspondent pas à l’expression régulière définie au niveau de la requête. Inversement, les entrées ignorées par une expression régulière plus restrictive définie dans la session ou l’URL ne sont pas récupérées par une expression régulière plus large définie au niveau de la requête. Définissez `send_logs_source_regexp` dans la session ou l’URL pour filtrer l’ensemble du cycle de vie de la requête. Le paramètre s’applique actuellement au protocole HTTP et est ignoré par les autres interfaces. Valeurs possibles : * `None` - achemine de manière transparente tous les éléments applicables (données, totaux, extrêmes, progression) vers le format de sortie et ignore ceux qui ne le sont pas (métriques, journaux), de sorte que tout fonctionne comme par défaut. * `EventStream` - encapsule les paquets sous forme d’événements HTTP envoyés par le serveur (`text/event-stream`). Chaque paquet est envoyé comme un événement portant le nom correspondant : `data`, `totals`, `extremes`, `progress`, `log`, `profile_events`, `exception`. La progression et les autres paquets auxiliaires sont envoyés au format JSON. Comme les événements envoyés par le serveur constituent un protocole texte qui traite les sauts de ligne (y compris les retours chariot, `\r`) comme des délimiteurs, un bloc de données formatées est encodé en base64 dans un unique champ `data` de l’événement. Ce champ se décode en payload entièrement formaté, avec tous ses sauts de ligne ; le `Content-Type` contient un paramètre `payload=base64` pour l’indiquer. Tout format de sortie peut ainsi être transporté exactement octet pour octet, qu’il soit textuel ou binaire. * `JSONEachPacketBase64` - chaque paquet est un objet JSON sur une ligne distincte et les données formatées sont encodées en base64, par exemple `{"packet":"data","data":"eyJ4IjoxfQo="}`. Convient aux formats de sortie binaires. * `JSONEachPacketString` - chaque paquet est un objet JSON sur une ligne distincte et les données formatées sont placées dans une chaîne, par exemple `{"packet":"data","data":"{\"x\":1}\n"}`. `JSONEachPacketString` place les octets du payload dans une chaîne JSON sans les valider ni les réencoder. Les colonnes `String` et `FixedString` peuvent contenir des octets arbitraires ; les formats de sortie textuels (tels que `JSONEachRow`, `TSV` ou `CSV`) peuvent donc émettre des valeurs UTF-8 non valides, tout comme le `JSONEachRow` natif de ClickHouse avec la valeur par défaut `output_format_json_validate_utf8 = 0`. Le flux NDJSON résultant n’est alors pas garanti comme étant en UTF-8 valide. Utilisez `JSONEachPacketBase64` pour transporter des octets arbitraires exactement octet pour octet. Exemple : ```bash theme={null} curl "http://localhost:8123/?framing_output_format=JSONEachPacketString" -d "SELECT number FROM numbers(3) FORMAT JSONEachRow" ``` Résultat : ```text theme={null} {"packet":"data","data":"{\"number\":\"0\"}\n{\"number\":\"1\"}\n{\"number\":\"2\"}\n"} {"packet":"profile_events","profile_events":[{"host_name":"localhost","current_time":"2026-07-11 00:00:00","thread_id":"0","type":"increment","name":"SelectedRows","value":"3"}]} {"packet":"progress","progress":{"read_rows":"3","read_bytes":"24","total_rows_to_read":"3","result_rows":"3","result_bytes":"24","elapsed_ns":"1265958"}} ```
## fsync\_metadata
Active ou désactive [fsync](http://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html) lors de l’écriture de fichiers `.sql`. Activé par défaut. Il peut être judicieux de le désactiver si le serveur possède des millions de petites tables constamment créées et supprimées.
## functions\_h3\_default\_if\_invalid
Si false, les fonctions h3, par exemple h3CellAreaM2, génèrent une exception si l’entrée n’est pas valide. 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, celles-ci renvoient un Float64 et utilisent la double précision pour les calculs internes. Dans les versions précédentes de ClickHouse, ces fonctions renvoyaient toujours un Float32.
## geotoh3\_argument\_order
La fonction `geoToH3` accepte (lon, lat) si le paramètre est réglé sur `lon_lat`, et (lat, lon) s'il est réglé sur `lat_lon`.
## glob\_expansion\_max\_elements
Nombre maximal d’adresses autorisées (pour les stockages externes, les fonctions table, etc.).
## h3togeo\_lon\_lat\_result\_order
La fonction 'h3ToGeo' renvoie (lon, lat) si la valeur est true, sinon (lat, lon).
## handshake\_timeout\_ms
Délai d’expiration, en millisecondes, pour la réception du paquet Hello des répliques lors de la négociation initiale.
## hedged\_connection\_timeout\_ms
Délai d'expiration pour établir une connexion avec une réplique dans le cadre des requêtes hedged
## highlight\_max\_matches\_per\_row
Définit le nombre maximal de correspondances de surlignage par ligne dans la fonction [highlight](/fr/reference/functions/regular-functions/string-search-functions#highlight). Utilisez-le pour éviter une consommation excessive de mémoire lors du surlignage de motifs très répétitifs dans de longs textes. Valeurs possibles : * Entier positif. Taille de la liste dynamique des 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é.
## idle\_connection\_timeout
Délai d’expiration 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).
## 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 structure de premier niveau est UNION, 'ORDER BY rand()' est injecté indépendamment dans chacune des 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).
## input\_format
Remplace le format d'entrée de la requête. Prévaut sur le format spécifié dans la requête.
## interactive\_delay
L’intervalle, en microsecondes, entre les vérifications de l’annulation de l’exécution de la requête et l’envoi de la progression.
## intersect\_default\_mode
Définit le mode par défaut de la requête INTERSECT. Valeurs possibles : chaîne vide, 'ALL', 'DISTINCT'. Si cette valeur est vide, une requête sans mode générera une exception.
## least\_greatest\_legacy\_null\_behavior
S'il est activé, les fonctions 'least' et 'greatest' renvoient NULL si l'un de leurs arguments est NULL.
## legacy\_column\_name\_of\_tuple\_literal
Répertorie tous les noms des éléments des grands littéraux tuple dans leurs noms de colonne au lieu d’un hachage. Ce paramètre n’existe que pour des raisons de compatibilité. Il est pertinent de le définir sur 'true' lors d’une mise à jour progressive du cluster d’une version inférieure à 21.7 vers une version supérieure.
## limit
Définit le nombre maximal de lignes à renvoyer dans le résultat de la requête. Ajuste la valeur définie par la clause [LIMIT](/fr/reference/statements/select/limit). La valeur est transmise à `LIMIT` et accepte tout ce que `LIMIT` accepte, y compris les valeurs négatives (comptées à partir de la fin du résultat) et les fractions dans `(0, 1)` (interprétées comme une proportion du résultat). Valeurs possibles : * 0 — Le nombre de lignes n’est pas limité. * Entier positif — nombre exact de lignes. * Entier négatif — renvoie les N dernières lignes. * Nombre réel dans l’intervalle ouvert `(0, 1)` — renvoie cette fraction du résultat. Ce paramètre détermine la forme des requêtes `SELECT` / `UNION` produisant un résultat. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que si le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — comme pour tout autre paramètre.
## load\_marks\_asynchronously
Charger les marks MergeTree de façon asynchrone Valeur par défaut dans Cloud : `1`.
## lock\_acquire\_timeout
Définit le nombre de secondes pendant lequel une demande de verrouillage attend avant d’échouer. Le délai d’expiration du verrouillage est utilisé pour éviter les interblocages 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.
## 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 à 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
Créer un plan de requête distribuée. Son activation ajuste automatiquement les paramètres qui contrôlent les fonctionnalités pas encore prises en charge par les plans de requêtes distribuées : * `enable_parallel_replicas = 0` et `automatic_parallel_replicas_mode = 0` — le plan distribué assure sa propre répartition du travail ; * `correlated_subqueries_use_in_memory_buffer = 0` ; * `use_skip_indexes_on_data_read = 0` ; * `compile_expressions = 0` ; * `query_plan_direct_read_from_text_index = 0`.
## 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 inféré comme l'union d'au plus le nombre spécifié de tables correspondantes. S'il y a davantage de tables, le schéma sera inféré à partir des premières tables, jusqu'au nombre spécifié.
## 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'.
## multiple\_joins\_try\_to\_keep\_original\_names
Ne pas ajouter d’alias à la liste des expressions de premier niveau lors de la réécriture de plusieurs JOIN
## normalize\_function\_names
Ramener les noms de fonctions à leur forme canonique
## offset
Définit le nombre de lignes à ignorer avant de commencer à renvoyer les lignes de la requête. Ajuste le décalage défini par la clause [OFFSET](/fr/reference/statements/select/offset). La valeur est transmise à `OFFSET` et accepte tout ce que `OFFSET` accepte, y compris les valeurs négatives et les fractions dans `(0, 1)`. Valeurs possibles : * 0 — Aucune ligne n’est ignorée. * Entier positif. * Entier négatif. * Nombre réel dans la plage ouverte `(0, 1)` — ignore cette fraction du résultat. **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 │ └─────┘ ``` Ce paramètre s’applique aux requêtes `SELECT` / `UNION` qui produisent des résultats. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que si le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — comme pour tout autre paramètre.
## order
Ajoute une clause `ORDER BY` à la requête en l’enveloppant dans une sous-requête. Accepte une liste arbitraire d’expressions. Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’enveloppant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause `SETTINGS` dans la requête ou un profil utilisateur. Il s’applique aux requêtes `SELECT` / `UNION` produisant des résultats. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que lorsque le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — conformément à la règle de non-propagation qui s’applique à tout autre paramètre.
## output\_format
Surcharge le format de sortie de la requête. Prend le pas sur le format spécifié dans la requête, dans l’extension de fichier ou via `default_format`.
## page
Définit le numéro de page des résultats paginés. Équivalent à `offset = limit * (page - 1)`. Ne peut être spécifié que si `limit` est défini et que `offset` ne l’est pas. Les pages sont indexées à partir de 1. Prend en charge les mêmes valeurs négatives et fractionnaires que `limit` et `offset`. Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’enveloppant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause `SETTINGS` dans la requête ou un profil utilisateur. Il s’applique aux requêtes `SELECT` / `UNION` qui produisent des résultats. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que lorsque le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie dans l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — conformément à la règle de non-propagation applicable à tout autre paramètre.
## paimon\_target\_snapshot\_id
Lecture ciblée d’un snapshot 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 progresser le watermark validé. Par défaut : -1 (désactivé)
## parallelize\_output\_from\_storages
Parallélise la sortie à l’étape de lecture depuis les stockages. Cela permet, lorsque c’est possible, de paralléliser le traitement des requêtes immédiatement après la lecture depuis les stockages.
## partial\_result\_on\_first\_cancel
Permet à la requête de renvoyer un résultat partiel après son annulation.
## per\_part\_index\_stats
Enregistre les statistiques d’index pour chaque partie
## poll\_interval
Bloque dans 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 ex. 'sqlite', 'mysql', 'postgresql', 'snowflake', 'duckdb').
## 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 des statistiques sur la 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 (en fonction de l’identifiant de requête). 0 signifie désactivé.
## prefetch\_buffer\_size
La taille maximale du tampon de prélecture pour la lecture à partir du système de fichiers. Les valeurs supérieures à 256 MiB sont limitées à 256 MiB, car un tampon de lecture n’a jamais besoin d’être plus grand. Permet d'afficher de façon lisible, avec des retraits, les noms de types profondément imbriqués dans la requête `DESCRIBE` et 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.
## push\_external\_roles\_in\_interserver\_queries
Active la transmission des rôles utilisateur de l’initiateur aux autres nœuds lors de l’exécution d’une requête.
## query\_metric\_log\_interval
Intervalle, en millisecondes, de collecte du [query\_metric\_log](/fr/reference/system-tables/query_metric_log) pour les requêtes individuelles. 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#query_metric_log) ou utilisera 1000 par défaut si ce paramètre n'est pas présent. Pour désactiver la collecte pour une requête donnée, définissez `query_metric_log_interval` sur 0. Valeur par défaut : -1
## queue\_max\_wait\_ms
Le temps d’attente dans la file de requêtes si le nombre de requêtes simultanées dépasse le maximum autorisé.
## rabbitmq\_max\_wait\_ms
Le délai d’attente avant une nouvelle tentative de lecture depuis RabbitMQ.
## 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'.
## recursive\_cte\_max\_steps\_in\_type\_inference
Nombre maximal d’itérations pour déduire les types de colonnes dans les CTE récursives. Les types de colonnes sont déterminés en appliquant de manière itérative `getLeastSupertype` aux parties 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\_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 est susceptible d’être coûteuse (en raison d’une explosion du nombre d’états de l’AFN)
## remerge\_sort\_lowered\_memory\_bytes\_ratio
Si l’utilisation de la mémoire après une nouvelle fusion n’est pas réduite dans cette proportion, cette nouvelle fusion sera désactivée.
## 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 modèle 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 modèle spécifié et ses espaces réservés, uniquement si leur traitement a réussi.
### Marqueurs de substitution
* `%a` — Nom de fichier d’origine complet (p. ex., "sample.csv"). * `%f` — Nom de fichier d’origine sans extension (p. ex., "sample"). * `%e` — Extension du fichier d’origine avec le point (p. 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 `sample.csv` est lu avec succès, le fichier sera renommé en `processed_sample_1683473210851438.csv`
## replication\_wait\_for\_inactive\_replica\_timeout
Indique combien de temps (en secondes) attendre 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.
## reserve\_memory
Utilisé dans la planification des charges de travail. Quantité minimale de RAM réservée à l’exécution d’une requête sur un seul serveur. La réservation s’effectue via la hiérarchie WORKLOAD à l’aide de la valeur du paramètre de requête `workload`. Si la charge de travail ne dispose pas de suffisamment de mémoire, une requête ne peut pas démarrer et reste en attente jusqu’à ce que la réservation puisse être honorée. Une valeur de `0` signifie qu’il n’y a pas de réservation. Ce paramètre ne prend effet que si la ressource MEMORY RESERVATION est créée.
## 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 Cloud : `1`.
## result\_overflow\_mode
Définit le comportement à adopter 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 un résultat partiel, comme si les données source étaient épuisées. L'utilisation de 'break' est similaire à celle de LIMIT. `Break` interrompt l'exécution uniquement au niveau du block. Cela signifie que le nombre de lignes renvoyées est supérieur à [`max_result_rows`](/fr/reference/settings/session-settings/max-result#max_result_rows), est un multiple de [`max_block_size`](/fr/reference/settings/session-settings/max#max_block_size) et dépend de [`max_threads`](/fr/reference/settings/session-settings/max-threads#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. ... ```
## rows\_before\_aggregation
Lorsqu’il est activé, ClickHouse fournit la valeur exacte de la statistique rows\_before\_aggregation, qui correspond au nombre de lignes lues avant l’agrégatio
## secondary\_indices\_enable\_bulk\_filtering
Active l’algorithme de filtrage groupé pour les indices. Il devrait toujours offrir de meilleures performances, mais ce paramètre est conservé pour des raisons de compatibilité et de contrôle.
## select
FROM ()`."}]}]} /> Encapsule la requête dans une sous-requête avec une liste d’expressions `SELECT` explicite. Lorsqu’elle n’est pas vide, la requête qui produit des résultats est encapsulée dans `SELECT FROM ()`. Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’encapsulant dans une table dérivée). Il se combine avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via un paramètre d’URL HTTP, une clause `SETTINGS` dans la requête ou un profil utilisateur. Il détermine la forme des requêtes `SELECT` / `UNION` produisant des résultats. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que lorsque le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie dans l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — conformément à la règle de non-propagation applicable à tout autre paramètre.
## select\_sequential\_consistency
Le comportement de ce paramètre diffère entre SharedMergeTree et ReplicatedMergeTree. Voir [la cohérence de SharedMergeTree](/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é (activé par défaut). Valeurs possibles : * 0 — Désactivé. * 1 — Activé. Utilisation Lorsque la cohérence séquentielle est activée, ClickHouse n’autorise l’exécution de la requête `SELECT` par le client 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 pointe vers une réplique incomplète, 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, les requêtes `INSERT` parallèles peuvent être écrites sur différents ensembles de répliques de quorum, sans garantie qu’une seule réplique ait reçu toutes les écritures. Voir aussi : * [insert\_quorum](/fr/reference/settings/session-settings/insert-quorum#insert_quorum) * [insert\_quorum\_timeout](/fr/reference/settings/session-settings/insert-quorum#insert_quorum_timeout) * [insert\_quorum\_parallel](/fr/reference/settings/session-settings/insert-quorum#insert_quorum_parallel)
## 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 pour lesquelles aucun fuseau horaire n’est explicitement spécifié. Ce paramètre a préséance 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 celui du [fuseau horaire du serveur](/fr/reference/settings/server-settings/settings/other#timezone). Vous pouvez utiliser les fonctions `timeZone()` et `serverTimeZone()` pour obtenir le fuseau horaire de la session et celui du serveur. Valeurs possibles : * N’importe quel nom de fuseau horaire 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 session 'America/Denver', sans fuseau horaire explicitement spécifié : ```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 ``` Toutes les fonctions qui analysent des valeurs 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 s’explique par l’utilisation de chaînes d’analyse différentes : * `toDateTime()` sans fuseau horaire explicitement indiqué, utilisé dans la première requête `SELECT`, respecte le paramètre `session_timezone` et le 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`. Ainsi, 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/other#timezone)
## set\_overflow\_mode
Définit ce qui se produit 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 le résultat partiel, comme si les données source étaient épuisées.
## single\_join\_prefer\_left\_table
Pour un seul JOIN, en cas d’ambiguïté d’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 UDFs. * 0 — Les alias ne sont pas ignorés (substitués) dans les UDFs. **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) ```
## sleep\_after\_receiving\_query\_ms
Durée d’attente après réception d’une requête dans TCPHandler
## snappy\_mode
Contrôle le format binaire de transmission utilisé pour la compression snappy sur les chemins d’E/S de fichiers génériques tels que `file` et `url`. HTTP `Content-Encoding: snappy` utilise toujours le format de tramage et ignore ce paramètre. Notez que le format brut de bloc snappy produit par un seul appel à `snappy::Compress` (par exemple, les charges utiles du protocole distant Prometheus gérées par `SnappyBasicReadBuffer`) est un format binaire de transmission distinct, propre au protocole, et n’est pas contrôlé par ce paramètre. Valeurs possibles : * `basic` — format de bloc Hadoop snappy. Compatible avec les fichiers lus et écrits par Hadoop. Prend en charge la lecture et l’écriture. * `framed` — format de tramage Snappy, le format de streaming standard défini par Google. Prend en charge la lecture et l’écriture.
## sort
Ajoute une clause `ORDER BY` simple à la requête en l’enveloppant dans une sous-requête. Accepte une liste d’identifiants ou de références positionnelles à des colonnes (entiers positifs), séparées par des virgules, avec un préfixe facultatif `+` (ASC) ou `-` (DESC). Exemple : `sort=a,-b` trie selon `a` par ordre croissant et `b` par ordre décroissant ; `sort=1,-2` trie selon la première colonne par ordre croissant et la deuxième par ordre décroissant. Ne peut pas être combiné avec `order`. Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’encapsulant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause `SETTINGS` dans la requête ou un profil utilisateur. Il s’applique aux requêtes `SELECT` / `UNION` produisant des résultats. Pour une requête d’écriture (`INSERT … SELECT`, `CREATE … AS SELECT`), il ne prend effet que si le `SELECT` source l’inclut dans sa propre clause `SETTINGS` ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction `INSERT` / `CREATE` elle-même, ne se propage pas au `SELECT` source — conformément à la règle de non-propagation qui s’applique à tout autre paramètre.
## sort\_overflow\_mode
Définit ce qui se produit 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.
## 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/latest/api/python/reference/pyspark.sql/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 programmation 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.
## tcp\_keep\_alive\_timeout
Le temps, en secondes, pendant lequel la connexion doit rester inactive avant que TCP ne commence à envoyer des sondes keepalive
## temporary\_data\_in\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Délai 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
## throw\_if\_no\_data\_to\_insert
Autorise ou interdit les `INSERT` vides. Ce paramètre est activé par défaut (et déclenche une erreur en cas d'insert vide). S'applique uniquement aux `INSERT` effectués avec [`clickhouse-client`](/fr/concepts/features/interfaces/cli) ou via l'[interface gRPC](/fr/concepts/features/interfaces/grpc).
## 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é.
## 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 les données source étaient épuisées.
## transform\_null\_in
Active l'égalité des 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` désigne 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 des valeurs `NULL` avec l'opérateur `IN` renvoie `false`. * 1 — La comparaison des 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
Parcourir les données gelées (répertoire shadow) en plus des données réelles de la table lors de l'interrogation de system.remote\_data\_paths
## union\_default\_mode
Définit un mode de combinaison des résultats des requêtes `SELECT`. Ce paramètre n'est utilisé que lorsqu'il est employé avec [UNION](/fr/reference/statements/select/union) sans préciser explicitement `UNION ALL` ou `UNION DISTINCT`. Valeurs possibles : * `'DISTINCT'` — ClickHouse renvoie les lignes issues de la combinaison de requêtes en supprimant les lignes dupliquées. * `'ALL'` — ClickHouse renvoie toutes les lignes issues de la combinaison de requêtes, y compris les lignes dupliquées. * `''` — ClickHouse génère une exception lorsqu'il est utilisé avec `UNION`. Voir des exemples dans [UNION](/fr/reference/statements/select/union).
## unknown\_packet\_in\_send\_data
Envoyer un paquet inconnu à la place du n-ième paquet de données
## 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, 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.
## wait\_changes\_become\_visible\_after\_commit\_mode
Attendre que les modifications validées deviennent réellement visibles dans le snapshot le plus récent
## workload
Nom de la charge de travail à utiliser pour accéder aux ressources
## write\_full\_path\_in\_iceberg\_metadata
Écrit les chemins complets (y compris s3://) dans les fichiers de métadonnées Iceberg.
## zstd\_window\_log\_max
Permet de définir la taille maximale du journal de fenêtre de ZSTD (ne sera pas utilisé pour la famille MergeTree)