> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Paramètres des tables MergeTree dans `system.merge_tree_settings`
# Paramètres des tables MergeTree
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
const cells = [["Type", {type}], ["Valeur par défaut", {default_value}]];
if (changeable_without_restart) {
const isYes = String(changeable_without_restart).trim().toLowerCase() === "yes";
const badge = isYes ? Oui : Non;
cells.push(["Modifiable sans redémarrage", badge]);
}
return
{cells.map(([h]) => | {h} | )}
{cells.map(([h, v]) => | {v} | )}
;
};
export const galaxyOnClick = eventName => () => {
try {
if (typeof window !== "undefined" && window.galaxy && eventName) {
window.galaxy.track(eventName, {
interaction: "click"
});
}
} catch (e) {}
};
export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => {
if (link) {
return
Beta
;
}
return ;
};
export const ExperimentalBadge = () => {
return ;
};
La table système `system.merge_tree_settings` affiche les paramètres MergeTree définis au niveau global.
Les paramètres MergeTree peuvent être définis dans la section `merge_tree` du fichier de configuration du serveur, ou spécifiés individuellement pour chaque table `MergeTree` dans
la clause `SETTINGS` de l’instruction `CREATE TABLE`.
Exemple de personnalisation du paramètre `max_suspicious_broken_parts` :
Configurez la valeur par défaut pour toutes les tables `MergeTree` dans le fichier de configuration du serveur :
```text theme={null}
5
```
Pour une table donnée :
```sql theme={null}
CREATE TABLE tab
(
`A` Int64
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS max_suspicious_broken_parts = 500;
```
Modifiez les paramètres d'une table donnée à l'aide de `ALTER TABLE ... MODIFY SETTING` :
```sql theme={null}
ALTER TABLE tab MODIFY SETTING max_suspicious_broken_parts = 100;
-- reset to global default (value from system.merge_tree_settings)
ALTER TABLE tab RESET SETTING max_suspicious_broken_parts;
```
## Paramètres MergeTree
## adaptive\_write\_buffer\_initial\_size
Taille initiale d’un tampon d’écriture adaptatif
## add\_implicit\_sign\_column\_constraint\_for\_collapsing\_engine
Si cette valeur est true, ajoute une contrainte implicite à la colonne `sign` d’une table CollapsingMergeTree
ou VersionedCollapsingMergeTree afin de n’autoriser que des valeurs valides (`1` et `-1`).
## add\_minmax\_index\_for\_block\_number\_column
Lorsqu'il est activé, un index min-max implicite (skipping) est ajouté pour la colonne virtuelle persistante `_block_number`.
Nécessite `enable_block_number_column = 1` pour être pris en compte. L'index est construit uniquement lors des fusions,
pas lors des inserts : lors de l'insert, le numéro de bloc est provisoire et l'index porterait sur une constante.
## add\_minmax\_index\_for\_block\_offset\_column
Lorsqu'il est activé, un index min-max implicite (skipping) est ajouté à la colonne virtuelle persistante `_block_offset`.
Nécessite `enable_block_offset_column = 1` pour être pris en compte. L'index est construit uniquement lors des fusions,
pas lors des insertions.
## add\_minmax\_index\_for\_numeric\_columns
Lorsqu’il est activé, des index min-max (skipping) sont ajoutés à toutes les colonnes numériques
de la table.
## add\_minmax\_index\_for\_string\_columns
Lorsqu’il est activé, des index min-max (skipping) sont ajoutés pour toutes les colonnes de type chaîne de la table.
## add\_minmax\_index\_for\_temporal\_columns
Lorsqu'il est activé, des index min-max (skipping) sont ajoutés à toutes les colonnes Date, Date32, Time, Time64, DateTime et DateTime64 de la table
## allow\_coalescing\_columns\_in\_partition\_or\_order\_key
Lorsqu’il est activé, ce paramètre autorise l’utilisation de colonnes coalescentes d’une table CoalescingMergeTree dans
la partition ou la clé de tri.
## allow\_commit\_order\_projection
Active les projections par ordre de commit, qui stockent les colonnes virtuelles `_block_number` et `_block_offset`, tout en préservant l’ordre d’insertion d’origine lors des fusions.
Nécessite l’activation de `enable_block_number_column` et de `enable_block_offset_column`.
## allow\_experimental\_replacing\_merge\_with\_cleanup
Autorise les fusions CLEANUP expérimentales pour ReplacingMergeTree avec la
colonne `is_deleted`. Lorsqu’il est activé, ce paramètre permet d’utiliser `OPTIMIZE ... FINAL CLEANUP` pour
fusionner manuellement toutes les parts d’une partition en une seule et supprimer
toutes les lignes supprimées.
Il permet également d’activer ces fusions afin qu’elles s’exécutent automatiquement en arrière-plan
avec les paramètres `min_age_to_force_merge_seconds`,
`min_age_to_force_merge_on_partition_only` et
`enable_replacing_merge_with_cleanup_for_min_age_to_force_merge`.
## allow\_experimental\_reverse\_key
Paramètre obsolète, sans effet.
## allow\_floating\_point\_partition\_key
Permet d’utiliser un nombre à virgule flottante comme clé de partition.
Valeurs possibles :
* `0` — Les clés de partition à virgule flottante ne sont pas autorisées.
* `1` — Les clés de partition à virgule flottante sont autorisées.
## allow\_nullable\_key
Permet d’utiliser des types Nullable comme clés primaires.
## allow\_part\_offset\_column\_in\_projections
Autorise l'utilisation de la colonne '\_part\_offset' dans la requête SELECT des projections.
## allow\_reduce\_blocking\_parts\_task
Tâche d'arrière-plan qui réduit les parts bloquantes pour les tables shared merge tree.
Uniquement dans ClickHouse Cloud
## allow\_remote\_fs\_zero\_copy\_replication
N'utilisez pas ce paramètre en production, car il n'est pas encore prêt.
## allow\_summing\_columns\_in\_partition\_or\_order\_key
Lorsqu’il est activé, ce paramètre permet d’utiliser des colonnes de sommation d’une table SummingMergeTree
dans la partition ou la clé de tri.
## allow\_suspicious\_indices
Rejette les index primaires/secondaires et les clés de tri dont les expressions sont identiques
## allow\_tuple\_element\_aggregation
Lorsqu’elle est activée, cette option permet aux éléments des colonnes Tuple de participer individuellement à l’agrégation lors de la fusion dans SummingMergeTree, AggregatingMergeTree et CoalescingMergeTree. Les Tuple imbriqués sont dépliqués récursivement afin que tous les éléments terminaux soient agrégés indépendamment. Ce paramètre est immuable et doit être spécifié lors de la création de la table.
## allow\_vertical\_merges\_from\_compact\_to\_wide\_parts
Autorise les fusions verticales des parts compactes vers les parts wide. Ce paramètre doit avoir
la même valeur sur toutes les répliques.
## alter\_column\_secondary\_index\_mode
Définit s’il faut autoriser les commandes `ALTER` qui modifient des colonnes couvertes par des index secondaires, ainsi que l’action à effectuer si
elles sont autorisées. Par défaut, ces commandes `ALTER` sont autorisées et les index sont reconstruits.
Valeurs possibles :
* `rebuild` (par défaut) : Reconstruit tous les index secondaires affectés par la colonne dans la commande `ALTER`.
* `throw` : Empêche tout `ALTER` de colonnes couvertes par des index secondaires **explicites** en levant une exception. Les index implicites ne sont pas soumis à cette restriction et seront reconstruits.
* `drop` : Supprime les index secondaires dépendants. Les nouvelles parts n’auront pas ces index, et il faudra exécuter `MATERIALIZE INDEX` pour les recréer.
* `compatibility` : Reproduit le comportement d’origine : `throw` pour `ALTER ... MODIFY COLUMN` et `rebuild` pour `ALTER ... UPDATE/DELETE`.
* `ignore` : Destiné à un usage expert. Cette option laisse les index dans un état incohérent, ce qui peut entraîner des résultats de requête incorrects.
## always\_fetch\_merged\_part
Si la valeur est définie sur true, cette réplique ne fusionne jamais les parts et télécharge toujours les parts fusionnées
depuis d'autres répliques.
Valeurs possibles :
* true, false
## always\_use\_copy\_instead\_of\_hardlinks
Toujours copier les données au lieu de créer des liens physiques lors des mutations, remplacements, détachements,
etc.
## apply\_patches\_on\_merge
Si la valeur est true, les patch parts sont appliquées lors des fusions
## assign\_part\_uuids
Lorsqu’il est activé, un identifiant unique de part sera attribué à chaque nouvelle part.
Avant de l’activer, vérifiez que toutes les répliques prennent en charge les UUID de version 4.
## async\_block\_ids\_cache\_update\_wait\_ms
Temps d’attente de chaque itération d’insert pour la mise à jour d’async\_block\_ids\_cache
## async\_insert
Si cette valeur est true, les données de la requête INSERT sont stockées dans une file d'attente, puis insérées ultérieurement dans la table en arrière-plan.
## auto\_statistics\_types
Liste de types de statistiques, séparés par des virgules, à calculer automatiquement pour toutes les colonnes compatibles.
Types de statistiques pris en charge : basic, tdigest, countmin, minmax, uniq.
## background\_task\_preferred\_step\_execution\_time\_ms
Temps cible pour l'exécution d'une étape de fusion ou de mutation. Peut être dépassé si
une étape prend davantage de temps
## cache\_populated\_by\_fetch
Ce paramètre s’applique uniquement à ClickHouse Cloud.
Lorsque `cache_populated_by_fetch` est désactivé (paramètre par défaut), les nouvelles
parts de données ne sont chargées dans le cache du système de fichiers que lorsqu’une requête est exécutée et qu’elle nécessite
ces parts.
S’il est activé, `cache_populated_by_fetch` amène au contraire tous les nœuds à charger
les nouvelles parts de données depuis le stockage dans leur cache du système de fichiers, sans qu’une requête
soit nécessaire pour déclencher une telle action.
**Voir aussi**
* [ignore\_cold\_parts\_seconds](/fr/reference/settings/session-settings#ignore_cold_parts_seconds)
* [prefer\_warmed\_unmerged\_parts\_seconds](/fr/reference/settings/session-settings#prefer_warmed_unmerged_parts_seconds)
* [cache\_warmer\_threads](/fr/reference/settings/session-settings#cache_warmer_threads)
## cache\_populated\_by\_fetch\_filename\_regexp
Ce paramètre s’applique uniquement à ClickHouse Cloud.
S’il n’est pas vide, seuls les fichiers correspondant à cette expression régulière seront préchargés dans le cache après la récupération (si `cache_populated_by_fetch` est activé).
## check\_delay\_period
Paramètre obsolète, sans effet.
## check\_sample\_column\_is\_correct
Active la vérification, lors de la création de la table, que le type de données d'une colonne utilisée pour l'échantillonnage ou d'une expression d'échantillonnage est correct. Le type de données doit être l'un des types [entiers non signés](/fr/reference/data-types/int-uint) : `UInt8`, `UInt16`,
`UInt32`, `UInt64`.
Valeurs possibles :
* `true` — La vérification est activée.
* `false` — La vérification est désactivée lors de la création de la table.
Valeur par défaut : `true`.
Par défaut, le serveur ClickHouse vérifie, lors de la création de la table, le type de données d'une colonne utilisée pour l'échantillonnage ou d'une expression d'échantillonnage. Si vous avez déjà des tables avec une expression d'échantillonnage incorrecte et que vous ne voulez pas que le serveur lève une exception au démarrage, définissez `check_sample_column_is_correct` sur `false`.
## clean\_deleted\_rows
Paramètre obsolète, sans effet.
## cleanup\_delay\_period
Période minimale avant le nettoyage des anciens logs de la file d'attente, des hachages de blocs et des parties.
## cleanup\_delay\_period\_random\_add
Ajoute une valeur répartie uniformément de 0 à x secondes à cleanup\_delay\_period
afin d'éviter l'effet de troupeau ainsi que le DoS de ZooKeeper qui peut en résulter en cas de
très grand nombre de tables.
## cleanup\_thread\_preferred\_points\_per\_iteration
Taille de lot recommandée pour le nettoyage en arrière-plan (les points sont abstraits, mais 1 point
équivaut approximativement à 1 bloc inséré).
## cleanup\_threads
Paramètre obsolète, sans effet.
## clone\_replica\_zookeeper\_create\_get\_part\_batch\_size
Taille du lot pour les requêtes ZooKeeper multi-create get-part lors du clonage d'une réplique.
## columns\_and\_secondary\_indices\_sizes\_lazy\_calculation
Calcule à la demande la taille des colonnes et des index secondaires lors de la première requête, plutôt qu'à l'initialisation de la table.
## columns\_to\_prewarm\_mark\_cache
Liste des colonnes dont le cache de marques doit être préchauffé (s'il est activé). Une valeur vide signifie toutes les colonnes
## compact\_parts\_max\_bytes\_to\_buffer
Disponible uniquement dans ClickHouse Cloud. Nombre maximal d’octets pouvant être écrits dans une seule stripe des compact parts
## compact\_parts\_max\_granules\_to\_buffer
Disponible uniquement dans ClickHouse Cloud. Nombre maximal de granules pouvant être écrites dans une
seule stripe au sein des compact parts
## compact\_parts\_merge\_max\_bytes\_to\_prefetch\_part
Disponible uniquement dans ClickHouse Cloud. Taille maximale d'une part compacte pouvant être lue
entièrement en mémoire lors d'une fusion.
## compatibility\_allow\_sampling\_expression\_not\_in\_primary\_key
Permet de créer une table avec une expression d’échantillonnage qui ne figure pas dans la clé primaire. Cela n’est nécessaire que pour permettre temporairement l’exécution du server avec des tables incorrectes, afin d’assurer la rétrocompatibilité.
## compress\_marks
Les marks prennent en charge la compression, ce qui réduit la taille du fichier de marks et accélère la transmission sur le réseau.
## compress\_per\_column\_in\_compact\_parts
Contrôle la disposition physique des parts compactes. Si true (par défaut), chaque colonne d’une granule
commence dans un nouveau bloc compressé, ce qui permet à ClickHouse d’éviter de lire des colonnes inutiles
sur disque. Si false, toutes les colonnes d’une granule sont regroupées dans le même bloc compressé,
ce qui améliore le taux de compression, mais nécessite de décompresser davantage de données lors des lectures.
Ce réglage est avantageux pour les charges de travail qui lisent toujours toutes les colonnes (par ex. les projections).
## compress\_primary\_key
Prend en charge la compression de la clé primaire, ce qui réduit la taille du fichier de clé primaire et accélère
la transmission sur le réseau.
## concurrent\_part\_removal\_threshold
Activez la suppression concurrente des parts (voir `max_part_removal_threads`) uniquement si
le nombre de parts de données inactives atteint au moins ce seuil.
## concurrent\_part\_removal\_threshold\_for\_remote\_disk
Identique à `concurrent_part_removal_threshold`, mais utilisé lorsqu’au moins une
partie à supprimer est stockée sur un disque distant. La valeur par défaut est plus faible
car chaque suppression de part sur un stockage distant nécessite généralement un aller-retour
réseau (par exemple, une requête HTTP `DELETE` par part sur le stockage objet), de sorte qu’une
suppression séquentielle de seulement 100 parts peut bloquer un `DROP TABLE` pendant des dizaines de
secondes.
## deduplicate\_merge\_projection\_mode
Indique s’il faut autoriser la création d’une projection pour une table utilisant
un MergeTree non classique, c’est-à-dire un MergeTree autre que (Replicated,
Shared) MergeTree. L’option ignore est purement destinée à la compatibilité et
peut produire des résultats incorrects. Sinon, si cela est autorisé, elle
définit l’action à effectuer lors de la fusion des projections : soit les
supprimer, soit les reconstruire. Le MergeTree classique ignorera donc ce
paramètre. Il contrôle également `OPTIMIZE DEDUPLICATE`, mais s’applique à tous
les membres de la famille MergeTree. Comme l’option
`lightweight_mutation_projection_mode`, il s’applique également au niveau des parts.
Valeurs possibles :
* `ignore`
* `throw`
* `drop`
* `rebuild`
## default\_compression\_codec
Spécifie le codec de compression par défaut à utiliser si aucun n’est défini pour une colonne donnée dans la déclaration de table.
Ordre de sélection du codec de compression pour une colonne :
1. Codec de compression défini pour la colonne dans la déclaration de table
2. Codec de compression défini dans `default_compression_codec` (ce paramètre)
3. Codec de compression par défaut défini dans les paramètres `compression`
Valeur par défaut : une chaîne vide (non défini).
## detach\_not\_byte\_identical\_parts
Active ou désactive le détachement d’une partie de données sur une réplique après une fusion ou une
mutation, si elle n’est pas identique octet pour octet aux parts de données des autres répliques. Si
ce paramètre est désactivé, la partie de données est supprimée. Activez ce paramètre si vous souhaitez
analyser ces parts ultérieurement.
Ce paramètre s’applique aux tables `MergeTree` avec la
[réplication des données](/fr/reference/engines/table-engines/mergetree-family/replacingmergetree).
Valeurs possibles :
* `0` — Les parts sont supprimées.
* `1` — Les parts sont détachées.
## detach\_old\_local\_parts\_when\_cloning\_replica
Ne pas supprimer les anciennes parts locales lors de la réparation d'une réplique perdue.
Valeurs possibles :
* `true`
* `false`
## disable\_detach\_partition\_for\_zero\_copy\_replication
Désactive la requête DETACH PARTITION pour la réplication zero copy.
## disable\_fetch\_partition\_for\_zero\_copy\_replication
Désactive la requête FETCH PARTITION pour le zero copy.
## disable\_freeze\_partition\_for\_zero\_copy\_replication
Désactive la requête FREEZE PARTITION en cas de réplication zero copy.
## disk
Nom du disque de stockage. Peut être indiqué à la place de la storage policy.
## distributed\_index\_analysis\_min\_indexes\_bytes\_to\_activate
Tailles minimales, sur disque et non compressées, des index (de data skipping et de clé primaire) pour activer l'analyse d'index distribuée
## distributed\_index\_analysis\_min\_parts\_to\_activate
Nombre minimal de parts pour activer l'analyse distribuée des index
## dynamic\_serialization\_version
Version de sérialisation du type de données Dynamic. Requise pour la compatibilité.
Valeurs possibles :
* `v1`
* `v2`
* `v3`
## enable\_block\_number\_column
Active la conservation de la colonne \_block\_number pour chaque ligne.
## enable\_block\_offset\_column
Conserve la colonne virtuelle `_block_offset` lors des opérations de fusion.
## enable\_index\_granularity\_compression
Compresse en mémoire les valeurs de granularité de l’index lorsque cela est possible
## enable\_max\_bytes\_limit\_for\_min\_age\_to\_force\_merge
Détermine si les paramètres `min_age_to_force_merge_seconds` et
`min_age_to_force_merge_on_partition_only` doivent respecter le paramètre
`max_bytes_to_merge_at_max_space_in_pool`.
Valeurs possibles :
* `true`
* `false`
## enable\_mixed\_granularity\_parts
Active ou désactive l’utilisation du paramètre `index_granularity_bytes` pour contrôler la taille des granules. Avant la version 19.11, seul le
paramètre `index_granularity` permettait de limiter la taille des granules. Le
paramètre `index_granularity_bytes` améliore les performances de ClickHouse lors de la
lecture de données à partir de tables contenant de grandes lignes (de plusieurs dizaines, voire centaines, de mégaoctets).
Si vos tables contiennent de grandes lignes, vous pouvez activer ce paramètre pour améliorer
l’efficacité des requêtes `SELECT`.
## enable\_replacing\_merge\_with\_cleanup\_for\_min\_age\_to\_force\_merge
Indique s’il faut utiliser des fusions `CLEANUP` pour ReplacingMergeTree lors de la fusion de partitions
en une seule partie. Nécessite que `allow_experimental_replacing_merge_with_cleanup`,
`min_age_to_force_merge_seconds` et `min_age_to_force_merge_on_partition_only`
soient activés.
Valeurs possibles :
* `true`
* `false`
## enable\_the\_endpoint\_id\_with\_zookeeper\_name\_prefix
Active l’identifiant d’endpoint avec le préfixe de nom ZooKeeper pour la table ReplicatedMerge
Tree.
## enable\_vertical\_merge\_algorithm
Active l’utilisation de l’algorithme de fusion verticale.
## enforce\_index\_structure\_match\_on\_partition\_manipulation
Si ce paramètre est activé pour la table de destination d’une requête de
manipulation de partition (`ATTACH/MOVE/REPLACE PARTITION`), les index et les projections doivent être
identiques dans les tables source et de destination. Sinon, la table de destination
peut avoir un ensemble d’index et de projections plus large que celui de la table source.
## escape\_index\_filenames
Avant la version 26.1, nous n’échappions pas les caractères spéciaux dans les noms de fichiers créés pour les index secondaires, ce qui pouvait poser problème : certains caractères dans les noms d’index pouvaient produire des parts corrompues. Ce paramètre a été ajouté uniquement pour des raisons de compatibilité. Il ne doit pas être modifié, sauf si vous lisez d’anciennes parts avec des index dont les noms contiennent des caractères non ASCII.
## escape\_variant\_subcolumn\_filenames
Échappe les caractères spéciaux dans les noms de fichiers créés pour les sous-colonnes du type Variant dans les Wide parts d'une table MergeTree. Nécessaire pour la compatibilité.
## exclude\_deleted\_rows\_for\_part\_size\_in\_merge
Si ce paramètre est activé, la taille réelle estimée des parts de données (c.-à-d. hors lignes
supprimées via `DELETE FROM`) sera utilisée lors de la sélection des
parts à fusionner. Notez que ce comportement ne s’applique qu’aux parts de données
affectées par des instructions `DELETE FROM` exécutées après l’activation de ce paramètre.
Valeurs possibles :
* `true`
* `false`
**Voir aussi**
* [load\_existing\_rows\_count\_for\_old\_parts](#load_existing_rows_count_for_old_parts)
paramètre
## exclude\_materialize\_skip\_indexes\_on\_merge
Exclut de la construction et du stockage lors des fusions la liste d’index de saut fournie, séparée par des virgules. N’a aucun effet si
[materialize\_skip\_indexes\_on\_merge](#materialize_skip_indexes_on_merge) est false.
Les index de saut exclus seront tout de même construits et stockés par une requête
[MATERIALIZE INDEX](/fr/reference/statements/alter/skipping-index#materialize-index) explicite ou lors des INSERT, selon
le paramètre de session [materialize\_skip\_indexes\_on\_insert](/fr/reference/settings/session-settings#materialize_skip_indexes_on_insert).
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() SETTINGS exclude_materialize_skip_indexes_on_merge = 'idx_a';
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- setting has no effect on INSERTs
-- idx_a will be excluded from update during background or explicit merge via OPTIMIZE TABLE FINAL
-- can exclude multiple indexes by providing a list
ALTER TABLE tab MODIFY SETTING exclude_materialize_skip_indexes_on_merge = 'idx_a, idx_b';
-- default setting, no indexes excluded from being updated during merge
ALTER TABLE tab MODIFY SETTING exclude_materialize_skip_indexes_on_merge = '';
```
## execute\_merges\_on\_single\_replica\_time\_threshold
Lorsque ce paramètre est supérieur à zéro, une seule réplique lance
immédiatement la fusion, tandis que les autres répliques attendent pendant ce délai afin de
télécharger le résultat au lieu d'effectuer la fusion localement. Si la réplique
choisie ne termine pas la fusion dans ce délai, le système revient au comportement
standard.
Valeurs possibles :
* Tout entier positif.
## fault\_probability\_after\_part\_commit
Pour les tests. Ne le modifiez pas.
## fault\_probability\_before\_part\_commit
À des fins de test. Ne le modifiez pas.
## finished\_mutations\_to\_keep
Nombre d'enregistrements sur les mutations terminées à conserver. Si la valeur est zéro, ils sont
tous conservés.
## force\_read\_through\_cache\_for\_merges
Forcer les fusions à lire via le cache du système de fichiers
## fsync\_after\_insert
Effectue un fsync pour chaque part insérée. Réduit considérablement les performances des
insertions ; son utilisation avec des wide parts n'est pas recommandée.
## fsync\_part\_directory
Effectue un fsync sur le répertoire de la part après toutes les opérations sur celle-ci (écritures, renommages, etc.).
## in\_memory\_parts\_enable\_wal
Paramètre obsolète, sans effet.
## in\_memory\_parts\_insert\_sync
Paramètre obsolète, sans effet.
## inactive\_parts\_to\_delay\_insert
Si le nombre de parts inactives dans une seule partition de la table dépasse
la valeur `inactive_parts_to_delay_insert`, un `INSERT` est artificiellement
ralenti.
Cela est utile lorsqu’un serveur ne parvient pas à nettoyer les parts assez rapidement.
Valeurs possibles :
* Tout entier positif.
## inactive\_parts\_to\_throw\_insert
Si le nombre de parts inactives dans une même partition dépasse la
valeur `inactive_parts_to_throw_insert`, `INSERT` est interrompu avec
l'erreur suivante :
> "Too many inactive parts (N). Parts cleaning are processing significantly
> slower than inserts" exception."
Valeurs possibles :
* Tout entier positif.
## index\_granularity
Nombre maximal de lignes entre les marques d’un index. Autrement dit, le nombre de lignes
correspondant à une valeur de clé primaire.
## index\_granularity\_bytes
Taille maximale des granules de données, en octets.
Pour limiter la taille des granules uniquement par le nombre de lignes, définissez cette valeur sur `0` (non recommandé).
## initialization\_retry\_period
Période entre les nouvelles tentatives d'initialisation de la table, en secondes.
## kill\_delay\_period
Paramètre obsolète, n’a aucun effet.
## kill\_delay\_period\_random\_add
Paramètre obsolète, sans effet.
## kill\_threads
Paramètre obsolète, sans effet.
## lightweight\_mutation\_projection\_mode
Par défaut, le lightweight delete `DELETE` ne fonctionne pas pour les tables avec
des projections. Cela s'explique par le fait que des lignes d'une projection peuvent être affectées par une
opération `DELETE`. La valeur par défaut est donc `throw`. Cependant, cette
option peut modifier ce comportement. Avec la valeur `drop` ou `rebuild`,
les suppressions fonctionneront avec les projections. `drop` supprimera la projection, ce qui
peut être rapide pour la requête en cours puisque la projection est supprimée, mais plus lent pour les
requêtes futures, car aucune projection n'est attachée. `rebuild` reconstruira la
projection, ce qui peut affecter les performances de la requête en cours, mais
pourrait accélérer les requêtes futures. L'avantage est que ces options
ne fonctionnent qu'au niveau des parts, ce qui signifie que les projections des parts qui ne sont
pas touchées resteront intactes au lieu de déclencher une action comme
drop ou rebuild.
Valeurs possibles :
* `throw`
* `drop`
* `rebuild`
## load\_existing\_rows\_count\_for\_old\_parts
Si ce paramètre est activé avec [exclude\_deleted\_rows\_for\_part\_size\_in\_merge](#exclude_deleted_rows_for_part_size_in_merge),
le nombre de lignes supprimées pour les data parts existantes sera calculé au
démarrage de la table. Notez que cela peut ralentir le chargement de la table au démarrage.
Valeurs possibles :
* `true`
* `false`
**Voir aussi**
* paramètre [exclude\_deleted\_rows\_for\_part\_size\_in\_merge](#exclude_deleted_rows_for_part_size_in_merge)
## lock\_acquire\_timeout\_for\_background\_operations
Pour les opérations en arrière-plan comme les merges, les mutations, etc. Nombre de secondes avant
l'échec de l'acquisition des verrous de table.
## map\_buckets\_coefficient
Coefficient utilisé dans les stratégies [map\_buckets\_strategy](#map_buckets_strategy) `sqrt` et `linear` pour calculer le nombre de buckets à partir de la taille moyenne de la map.
Pour la stratégie `sqrt` : `round(map_buckets_coefficient * sqrt(avg_map_size))`.
Pour la stratégie `linear` : `round(map_buckets_coefficient * avg_map_size)`.
Ignoré lorsque `map_buckets_strategy` est défini sur `constant`.
## map\_buckets\_min\_avg\_size
La taille moyenne minimale des maps (nombre de clés par ligne) requise pour appliquer la sérialisation `with_buckets`.
Si la taille moyenne des maps est inférieure à cette valeur, un seul bucket est utilisé, quels que soient les autres paramètres de bucket.
Une valeur de `0` désactive ce seuil et applique toujours la stratégie de bucketing.
Ce paramètre est utile pour éviter le surcoût de la sérialisation en buckets pour les petites maps, lorsque le bénéfice est négligeable.
## map\_buckets\_strategy
Contrôle la stratégie de sélection du nombre de buckets dans la sérialisation `with_buckets` de `Map`, en fonction de la taille moyenne de la map.
Valeurs possibles :
* constant — Utilise toujours [max\_buckets\_in\_map](#max_buckets_in_map) comme nombre de buckets, quelle que soit la taille moyenne de la map.
* sqrt — Utilise `round(map_buckets_coefficient * sqrt(avg_map_size))` comme nombre de buckets, borné à `[1, max_buckets_in_map]`.
* linear — Utilise `round(map_buckets_coefficient * avg_map_size)` comme nombre de buckets, borné à `[1, max_buckets_in_map]`.
## map\_serialization\_version
Contrôle la méthode de sérialisation utilisée pour les colonnes `Map`.
Valeurs possibles :
* basic — Utiliser la sérialisation standard pour `Map`.
* with\_buckets — Répartir les clés dans des buckets lors de la sérialisation. L'utilisation de buckets améliore la lecture de clés individuelles dans `Map`.
Le nombre de buckets dans la sérialisation `with_buckets` est déterminé par [max\_buckets\_in\_map](#max_buckets_in_map) et [map\_buckets\_strategy](#map_buckets_strategy).
## map\_serialization\_version\_for\_zero\_level\_parts
Ce paramètre permet de définir une version de sérialisation différente des
colonnes `Map` pour les parts de niveau zéro créées lors des insertions.
Il peut être utile de conserver la sérialisation `basic` pour les parts de niveau zéro afin d’éviter
une baisse des performances lors des insertions, tout en utilisant `with_buckets` pour les parts fusionnées.
## marks\_compress\_block\_size
Taille du bloc de compression des marks, c’est-à-dire la taille effective du bloc à compresser.
## marks\_compression\_codec
Codec de compression utilisé pour les marks ; les marks étant suffisamment petits et mis en cache,
la compression par défaut est ZSTD(3).
## materialize\_projections\_on\_insert
Lorsqu’il est activé, les INSERT créent de nouvelles parts avec des projections.
Sinon, celles-ci peuvent être créées explicitement avec [MATERIALIZE PROJECTION](/fr/reference/statements/alter/projection#materialize-projection)
ou lors des fusions avec [materialize\_projections\_on\_merge](/fr/reference/settings/merge-tree-settings#materialize_projections_on_merge).
## materialize\_projections\_on\_merge
Lorsqu’il est activé, une fusion reconstruit une projection absente de l’ensemble de ses parts sources (par exemple parce qu’elles ont été
insérées avec `materialize_projections_on_insert = 0`), afin que la part fusionnée contienne la projection.
Les fusions ne combinent toujours que les parts qui partagent le même ensemble de projections. Pour ajouter rétroactivement une projection à toutes les parts existantes,
utilisez une instruction explicite [MATERIALIZE PROJECTION](/fr/reference/statements/alter/projection#materialize-projection). Les projections
sont également créées lors des INSERT avec [materialize\_projections\_on\_insert](/fr/reference/settings/merge-tree-settings#materialize_projections_on_insert).
## materialize\_skip\_indexes\_on\_merge
Lorsqu’elle est activée, les fusions créent et stockent les index de saut pour les nouvelles parts.
Sinon, ils peuvent être créés et stockés explicitement avec [MATERIALIZE INDEX](/fr/reference/statements/alter/skipping-index#materialize-index)
ou [lors des INSERT](/fr/reference/settings/session-settings#materialize_skip_indexes_on_insert).
Voir aussi [exclude\_materialize\_skip\_indexes\_on\_merge](#exclude_materialize_skip_indexes_on_merge) pour un contrôle plus précis.
## materialize\_statistics\_on\_merge
Lorsqu'il est activé, les fusions génèrent et stockent des statistiques pour les nouvelles parts.
Sinon, elles peuvent être créées/stockées explicitement avec [MATERIALIZE STATISTICS](/fr/reference/statements/alter/statistics)
ou [lors des INSERTs](/fr/reference/settings/session-settings#materialize_statistics_on_insert)
## materialize\_ttl\_recalculate\_only
Recalcule les informations TTL uniquement lors de MATERIALIZE TTL
## max\_avg\_part\_size\_for\_too\_many\_parts
La vérification « too many parts » selon 'parts\_to\_delay\_insert' et
'parts\_to\_throw\_insert' ne sera active que si la taille moyenne des parts (dans la
partition concernée) ne dépasse pas le seuil spécifié. Si elle est
supérieure à ce seuil, les INSERT ne seront ni retardés ni
rejetés. Cela permet d'avoir des centaines de téraoctets dans une seule table sur un
seul serveur si les parts sont fusionnées avec succès en parts plus grandes. Cela
n'affecte pas les seuils relatifs aux parts inactives ni au nombre total de parts.
## max\_buckets\_in\_map
Nombre maximal de buckets pour la sérialisation `Map`. S'applique à la sérialisation `Map` `with_buckets`.
Le nombre réel de buckets est déterminé par [map\_buckets\_strategy](#map_buckets_strategy).
La valeur maximale autorisée est 256.
## max\_bytes\_to\_merge\_at\_max\_space\_in\_pool
La taille totale maximale des parts (en octets) pouvant être fusionnées en une seule part, s'il y a suffisamment de ressources disponibles. Cela correspond approximativement à la taille maximale possible d'une part créée par une fusion automatique en arrière-plan. (0 signifie que les fusions seront désactivées)
Valeurs possibles :
* Tout entier non négatif.
Le planificateur de fusion analyse périodiquement la taille et le nombre de parts dans les partitions et, s'il y a suffisamment de ressources libres dans le pool, lance des fusions en arrière-plan. Les fusions se poursuivent jusqu'à ce que la taille totale des parts sources dépasse `max_bytes_to_merge_at_max_space_in_pool`.
Les fusions lancées par [OPTIMIZE FINAL](/fr/reference/statements/optimize) ignorent `max_bytes_to_merge_at_max_space_in_pool` (seul l'espace disque libre est pris en compte).
## max\_bytes\_to\_merge\_at\_min\_space\_in\_pool
La taille totale maximale des parts (en octets) pouvant être fusionnées en une seule part, lorsque
les ressources disponibles dans le pool d’arrière-plan sont au minimum.
Valeurs possibles :
* Tout entier positif.
`max_bytes_to_merge_at_min_space_in_pool` définit la taille totale maximale des
parts pouvant être fusionnées malgré le manque d’espace disque disponible (dans le pool).
Cela est nécessaire pour réduire le nombre de petites parts et le risque
d’erreurs `Too many parts`.
Les fusions réservent de l’espace disque en comptant le double de la taille totale des parts fusionnées.
Ainsi, lorsqu’il reste peu d’espace disque libre, il peut arriver qu’il y ait
encore de l’espace libre, mais que cet espace soit déjà réservé par de grosses fusions en cours ;
d’autres fusions ne peuvent alors pas démarrer, et le nombre de petites parts augmente
à chaque insert.
## max\_cleanup\_delay\_period
Période maximale avant le nettoyage des anciens logs de file d’attente, des hachages de blocs et des parts.
## max\_compress\_block\_size
Taille maximale des blocs de données non compressées avant leur compression en vue de l'écriture
dans une table. Vous pouvez également spécifier ce paramètre dans les paramètres globaux
(voir le paramètre [max\_compress\_block\_size](/fr/reference/settings/merge-tree-settings#max_compress_block_size)
). La valeur spécifiée lors de la création de la table remplace la
valeur globale de ce paramètre.
## max\_concurrent\_queries
Nombre maximal de requêtes exécutées simultanément liées à la table MergeTree.
Les requêtes restent soumises à d'autres paramètres `max_concurrent_queries`.
Valeurs possibles :
* Entier positif.
* `0` — Aucune limite.
Valeur par défaut : `0` (aucune limite).
**Exemple**
```xml theme={null}
50
```
## max\_delay\_to\_insert
Valeur en secondes utilisée pour calculer le délai d’`INSERT` si le
nombre de parts actives dans une même partition dépasse la
valeur [parts\_to\_delay\_insert](#parts_to_delay_insert).
Valeurs possibles :
* Tout entier positif.
Le délai (en millisecondes) d’`INSERT` est calculé selon la formule :
```code theme={null}
max_k = parts_to_throw_insert - parts_to_delay_insert
k = 1 + parts_count_in_partition - parts_to_delay_insert
delay_milliseconds = pow(max_delay_to_insert * 1000, k / max_k)
```
Par exemple, si une partition compte 299 parts actives et parts\_to\_throw\_insert
\= 300, parts\_to\_delay\_insert = 150, max\_delay\_to\_insert = 1, `INSERT` est
retardé de `pow( 1 * 1000, (1 + 299 - 150) / (300 - 150) ) = 1000`
millisecondes.
À partir de la version 23.1, la formule a été modifiée comme suit :
```code theme={null}
allowed_parts_over_threshold = parts_to_throw_insert - parts_to_delay_insert
parts_over_threshold = parts_count_in_partition - parts_to_delay_insert + 1
delay_milliseconds = max(min_delay_to_insert_ms, (max_delay_to_insert * 1000)
* parts_over_threshold / allowed_parts_over_threshold)
```
Par exemple, si une partition comporte 224 parts actives et parts\_to\_throw\_insert
\= 300, parts\_to\_delay\_insert = 150, max\_delay\_to\_insert = 1,
min\_delay\_to\_insert\_ms = 10, `INSERT` est retardé de `max( 10, 1 * 1000 *
(224 - 150 + 1) / (300 - 150) ) = 500` millisecondes.
## max\_delay\_to\_mutate\_ms
Délai maximal pour la mutation d'une table MergeTree, en millisecondes, s'il y a beaucoup de
mutations inachevées
## max\_digestion\_size\_per\_segment
Paramètre obsolète, sans effet.
## max\_file\_name\_length
Longueur maximale du nom de fichier pour qu'il soit conservé tel quel, sans hachage.
N'a d'effet que si le paramètre `replace_long_file_name_to_hash` est activé.
La valeur de ce paramètre n'inclut pas la longueur de l'extension du fichier. Il
est donc recommandé de la définir en dessous de la longueur maximale d'un nom de fichier (généralement 255
octets), avec une certaine marge afin d'éviter les erreurs du système de fichiers.
## max\_files\_to\_modify\_in\_alter\_columns
N’appliquez pas ALTER si le nombre de fichiers à modifier (suppression, ajout)
dépasse cette valeur.
Valeurs possibles :
* Tout entier positif.
Valeur par défaut : 75
## max\_files\_to\_remove\_in\_alter\_columns
Ne pas appliquer `ALTER` si le nombre de fichiers à supprimer dépasse ce
paramètre.
Valeurs possibles :
* Tout entier positif.
## max\_merge\_delayed\_streams\_for\_parallel\_write
Le nombre maximal de flux (colonnes) pouvant être vidés en parallèle
(équivalent de max\_insert\_delayed\_streams\_for\_parallel\_write pour les fusions). Fonctionne
uniquement pour les fusions verticales.
## max\_merge\_selecting\_sleep\_ms
Temps d’attente maximal avant de tenter à nouveau de sélectionner des parts à fusionner lorsqu’aucune
part n’a été sélectionnée. Un paramètre plus faible déclenchera fréquemment la sélection de tâches dans
background\_schedule\_pool, ce qui entraîne un grand nombre de
requêtes vers ZooKeeper dans les clusters de grande taille
## max\_number\_of\_merges\_with\_ttl\_in\_pool
Lorsqu'il y a
plus que le nombre spécifié de fusions avec TTL dans le pool, n'affectez pas de
nouvelle fusion avec TTL. Cela permet de laisser des threads libres pour les fusions normales et
d'éviter « Too many parts »
## max\_number\_of\_mutations\_for\_replica
Limite le nombre de mutations de parts par réplique à la valeur spécifiée.
Zéro signifie qu'il n'y a pas de limite au nombre de mutations par réplique (l'exécution peut
toujours être limitée par d'autres paramètres).
## max\_part\_loading\_threads
Paramètre obsolète, sans effet.
## max\_part\_removal\_threads
Paramètre obsolète, sans effet.
## max\_partitions\_to\_read
Limite le nombre maximal de partitions accessibles dans une même requête.
La valeur du paramètre spécifiée lors de la création de la table peut être surchargée via
un paramètre défini au niveau de la requête.
Valeurs possibles :
* Tout entier positif.
Vous pouvez également définir un paramètre de complexité de requête [max\_partitions\_to\_read](/fr/reference/settings/session-settings#max_partitions_to_read)
au niveau de la requête, de la session ou du profil.
## max\_parts\_in\_total
Si le nombre total de parts actives dans toutes les partitions d'une table dépasse la
valeur `max_parts_in_total`, l'opération `INSERT` est interrompue avec l'exception `Too many parts
(N)`.
Valeurs possibles :
* Tout entier positif.
Un grand nombre de parts dans une table réduit les performances des requêtes ClickHouse
et augmente le temps de démarrage de ClickHouse. Le plus souvent, cela résulte d'une
mauvaise conception (erreurs dans le choix d'une stratégie de partitionnement — partitions
trop petites).
## max\_parts\_to\_merge\_at\_once
Nombre maximal de parts pouvant être fusionnées simultanément (0 : désactivé). N'affecte pas la requête
OPTIMIZE FINAL.
## max\_postpone\_time\_for\_failed\_mutations\_ms
Le délai maximal de report des mutations en échec.
## max\_postpone\_time\_for\_failed\_replicated\_fetches\_ms
Temps maximal de report des fetches répliqués ayant échoué.
## max\_postpone\_time\_for\_failed\_replicated\_merges\_ms
Temps maximal de report des fusions répliquées ayant échoué.
## max\_postpone\_time\_for\_failed\_replicated\_tasks\_ms
Délai maximal de report pour une tâche répliquée en échec. Cette valeur est utilisée si la tâche n’est ni une récupération, ni une fusion, ni une mutation.
## max\_projections
Le nombre maximal de projections pour MergeTree.
## max\_replicated\_fetches\_network\_bandwidth
Limite la vitesse maximale d'échange de données sur le réseau, en octets par
seconde, pour les fetches [répliqués](/fr/reference/engines/table-engines/mergetree-family/replication).
Ce paramètre s'applique à une table particulière, contrairement au paramètre
[`max_replicated_fetches_network_bandwidth_for_server`](/fr/reference/settings/merge-tree-settings#max_replicated_fetches_network_bandwidth),
qui s'applique au serveur.
Vous pouvez limiter à la fois le réseau du serveur et celui d'une table
particulière, mais dans ce cas, la valeur du paramètre au niveau de la table doit être
inférieure à celle du paramètre au niveau du serveur. Sinon, le serveur ne prend en compte que le
paramètre `max_replicated_fetches_network_bandwidth_for_server`.
Le paramètre n'est pas appliqué avec une précision parfaite.
Valeurs possibles :
* Entier positif.
* `0` — Illimité.
Valeur par défaut : `0`.
**Utilisation**
Peut être utilisé pour limiter la vitesse lors de la réplication de données afin d'ajouter ou de remplacer
de nouveaux nœuds.
## max\_replicated\_logs\_to\_keep
Nombre d'enregistrements pouvant se trouver dans le log de ClickHouse Keeper s'il existe une replica inactive. Une replica inactive est considérée comme perdue lorsque ce nombre est dépassé.
Valeurs possibles :
* Tout entier positif.
## max\_replicated\_merges\_in\_queue
Nombre de tâches de fusion et de mutation de parts autorisées simultanément dans la file d’attente de ReplicatedMergeTree.
## max\_replicated\_merges\_with\_ttl\_in\_queue
Nombre de tâches de fusion de parts avec TTL autorisées simultanément dans la file d’attente de ReplicatedMergeTree.
## max\_replicated\_mutations\_in\_queue
Nombre de tâches sur des parts en cours de mutation autorisées simultanément dans la
file d’attente ReplicatedMergeTree.
## max\_replicated\_sends\_network\_bandwidth
Limite la vitesse maximale du transfert de données sur le réseau, en octets par
seconde, pour les envois [répliqués](/fr/reference/engines/table-engines/mergetree-family/replacingmergetree).
Ce paramètre s’applique à une table particulière, contrairement au paramètre
[`max_replicated_sends_network_bandwidth_for_server`](/fr/reference/settings/merge-tree-settings#max_replicated_sends_network_bandwidth),
qui s’applique au serveur.
Vous pouvez limiter à la fois le trafic réseau du serveur et celui d’une table
particulière, mais dans ce cas, la valeur du paramètre au niveau de la table doit être inférieure à
celle définie au niveau du serveur. Sinon, le serveur ne prend en compte que le
paramètre `max_replicated_sends_network_bandwidth_for_server`.
Ce paramètre n’est pas appliqué avec une précision parfaite.
Valeurs possibles :
* Entier positif.
* `0` — Illimité.
**Utilisation**
Peut être utilisé pour limiter le débit lors de la réplication des données afin d’ajouter ou de remplacer
de nouveaux nœuds.
## max\_suspicious\_broken\_parts
Si le nombre de parts corrompues dans une même partition dépasse la valeur
`max_suspicious_broken_parts`, la suppression automatique est interdite.
Valeurs possibles :
* Tout entier positif.
## max\_suspicious\_broken\_parts\_bytes
Taille maximale totale de toutes les parts endommagées ; au-delà, la suppression automatique est interdite.
Valeurs possibles :
* Tout entier positif.
## max\_uncompressed\_bytes\_in\_patches
Taille maximale non compressée des données, en octets, dans l'ensemble des patch parts.
Si la quantité de données dans l'ensemble des patch parts dépasse cette valeur, les lightweight updates seront rejetées.
0 - illimité.
## merge\_max\_block\_size
Le nombre de lignes lues en mémoire à partir des parts fusionnées.
Valeurs possibles :
* Tout entier positif.
La fusion lit les lignes des parts par blocs de `merge_max_block_size` lignes, puis
fusionne et écrit le résultat dans une nouvelle part. Le bloc lu est chargé en RAM,
donc `merge_max_block_size` a une incidence sur la quantité de RAM nécessaire à la fusion.
Par conséquent, les fusions peuvent consommer une grande quantité de RAM pour les tables dont les lignes sont très larges
(si la taille moyenne d'une ligne est de 100kb, alors lors de la fusion de 10 parts,
(100kb \* 10 \* 8192) = \~ 8GB de RAM). En diminuant `merge_max_block_size`,
vous pouvez réduire la quantité de RAM nécessaire à une fusion, mais au prix d'une fusion plus lente.
## merge\_max\_block\_size\_bytes
Nombre d’octets que doivent contenir les blocs formés pour les opérations de fusion. Par défaut,
a la même valeur que `index_granularity_bytes`.
## merge\_max\_bytes\_to\_prewarm\_cache
Disponible uniquement dans ClickHouse Cloud. Taille maximale de la part (compact ou packed)
à préchauffer dans le cache lors de la fusion.
## merge\_max\_dynamic\_subcolumns\_in\_compact\_part
Nombre maximal de sous-colonnes dynamiques pouvant être créées dans chaque colonne d’une partie de données au format Compact après fusion.
Il permet de contrôler le nombre de sous-colonnes dynamiques dans une partie au format Compact, indépendamment des paramètres dynamiques spécifiés dans le type de données.
Par exemple, si la table comporte une colonne de type `JSON(max_dynamic_paths=1024)` et que le paramètre `merge_max_dynamic_subcolumns_in_compact_part` est défini sur 128,
après fusion dans une partie de données au format Compact, le nombre de chemins dynamiques sera ramené à 128 dans cette partie, et seuls 128 chemins seront écrits sous forme de sous-colonnes dynamiques.
## merge\_max\_dynamic\_subcolumns\_in\_wide\_part
Nombre maximal de sous-colonnes dynamiques pouvant être créées dans chaque colonne d'une Wide part après fusion.
Ce paramètre permet de réduire le nombre de fichiers créés dans une Wide part, quels que soient les paramètres dynamiques spécifiés dans le type de données.
Par exemple, si la table comporte une colonne de type JSON(max\_dynamic\_paths=1024) et que le paramètre merge\_max\_dynamic\_subcolumns\_in\_wide\_part est défini sur 128,
après fusion dans la Wide part, le nombre de chemins dynamiques sera réduit à 128 dans cette part et seuls 128 chemins seront écrits sous forme de sous-colonnes dynamiques.
## merge\_selecting\_sleep\_ms
Temps d’attente minimal avant de réessayer de sélectionner des parts à
fusionner lorsqu’aucune part n’a été sélectionnée. Une valeur plus faible
déclenchera fréquemment des tâches de sélection dans
background\_schedule\_pool, ce qui entraînera un grand nombre de requêtes vers
ZooKeeper dans les clusters de grande taille
## merge\_selecting\_sleep\_slowdown\_factor
Le temps de pause de la tâche de sélection des fusions est multiplié par ce facteur lorsqu'il
n'y a rien à fusionner, et divisé lorsqu'une fusion a été assignée
## merge\_selector\_algorithm
L’algorithme de sélection des parts à affecter aux fusions
## merge\_selector\_base
Influe sur l’amplification d’écriture des
fusions concernées (paramètre de niveau expert, ne le modifiez pas si vous ne comprenez pas
ce qu’il fait). Fonctionne avec les sélecteurs de fusion Simple et StochasticSimple
## merge\_selector\_blurry\_base\_scale\_factor
Contrôle le moment où cette logique s'active en fonction du nombre de parts dans la
partition. Plus le facteur est élevé, plus la réaction sera tardive.
## merge\_selector\_enable\_heuristic\_to\_lower\_max\_parts\_to\_merge\_at\_once
Active une heuristique pour le sélecteur de fusion simple, afin d’abaisser la limite maximale pour la sélection des fusions.
Cela augmente le nombre de fusions concurrentes, ce qui peut aider à atténuer les erreurs
TOO\_MANY\_PARTS, mais augmente en même temps l’amplification d’écriture.
## merge\_selector\_enable\_heuristic\_to\_remove\_small\_parts\_at\_right
Active l’heuristique de sélection des parts à fusionner, qui supprime les parts situées à droite
de la plage si leur taille est inférieure au ratio spécifié (0.01) de sum\_size.
Fonctionne avec les sélecteurs de fusion Simple et StochasticSimple
## merge\_selector\_heuristic\_to\_lower\_max\_parts\_to\_merge\_at\_once\_exponent
Contrôle la valeur de l’exposant utilisée dans les formules qui définissent la courbe de réduction. Réduire l’exposant
réduira la largeur des fusions, ce qui augmentera l’amplification d’écriture. L’inverse est également vrai.
## merge\_selector\_window\_size
Nombre de parts à examiner simultanément.
## merge\_total\_max\_bytes\_to\_prewarm\_cache
Disponible uniquement dans ClickHouse Cloud. Taille totale maximale des parts à
préchauffer dans le cache lors de la fusion.
## merge\_tree\_clear\_old\_broken\_detached\_parts\_ttl\_timeout\_seconds
Paramètre obsolète, n'a aucun effet.
## merge\_tree\_clear\_old\_parts\_interval\_seconds
Définit l’intervalle, en secondes, auquel ClickHouse effectue le nettoyage des anciennes
parts, des WAL et des mutations.
Valeurs possibles :
* Tout entier positif.
## merge\_tree\_clear\_old\_temporary\_directories\_interval\_seconds
Définit l’intervalle, en secondes, auquel ClickHouse effectue le nettoyage des anciens
répertoires temporaires.
Valeurs possibles :
* Tout entier positif.
## merge\_tree\_enable\_clear\_old\_broken\_detached
Paramètre obsolète, sans effet.
## merge\_with\_recompression\_ttl\_timeout
Délai minimal, en secondes, avant de relancer une fusion avec TTL de recompression.
## merge\_with\_ttl\_timeout
Délai minimal, en secondes, avant de relancer une fusion avec TTL de suppression.
## merge\_workload
Utilisé pour contrôler l'utilisation et le partage des ressources entre les opérations de fusion et
d'autres charges de travail. La valeur spécifiée est utilisée comme valeur du paramètre `workload` pour les
fusions en arrière-plan de cette table. Si elle n'est pas spécifiée (chaîne vide),
le paramètre du serveur `merge_workload` est utilisé à la place.
**Voir aussi**
* [Ordonnancement des charges de travail](/fr/concepts/features/configuration/server-config/workload-scheduling)
## min\_absolute\_delay\_to\_close
Délai absolu minimal avant la fermeture, l’arrêt du traitement des requêtes et l’absence de retour de Ok lors de la vérification d’état.
## min\_age\_to\_force\_merge\_on\_partition\_only
Indique si `min_age_to_force_merge_seconds` doit s’appliquer uniquement à l’ensemble de la
partition, et non à un sous-ensemble.
Par défaut, ce paramètre ignore `max_bytes_to_merge_at_max_space_in_pool` (voir
`enable_max_bytes_limit_for_min_age_to_force_merge`).
Valeurs possibles :
* true, false
## min\_age\_to\_force\_merge\_seconds
Fusionne les parts si chaque part de la plage est plus ancienne que la valeur de
`min_age_to_force_merge_seconds`.
Par défaut, ce paramètre ignore `max_bytes_to_merge_at_max_space_in_pool`
(voir `enable_max_bytes_limit_for_min_age_to_force_merge`).
Valeurs possibles :
* Entier positif.
## min\_bytes\_for\_compact\_part
Paramètre obsolète, n’a aucun effet.
## min\_bytes\_for\_full\_part\_storage
Disponible uniquement dans ClickHouse Cloud. Taille minimale non compressée, en octets, à partir de laquelle utiliser le type de stockage full pour la data part au lieu de packed
## min\_bytes\_for\_wide\_part
Nombre minimal d’octets ou de lignes dans une data part pouvant être stockée au format `Wide`. Vous pouvez définir un seul, les deux ou aucun de ces paramètres.
## min\_bytes\_to\_prewarm\_caches
Taille minimale (en octets non compressés) pour préchauffer le cache des marks et le cache de l’index primaire
pour les nouvelles parts
## min\_bytes\_to\_rebalance\_partition\_over\_jbod
Définit le nombre minimal d’octets nécessaire pour activer l’équilibrage lors de la répartition de nouvelles grandes
parts entre les disques du volume [JBOD](https://en.wikipedia.org/wiki/Non-RAID_drive_architectures).
Valeurs possibles :
* Entier positif.
* `0` — L’équilibrage est désactivé.
**Utilisation**
La valeur du paramètre `min_bytes_to_rebalance_partition_over_jbod` ne doit
pas être inférieure à la valeur de
[max\_bytes\_to\_merge\_at\_max\_space\_in\_pool](/fr/reference/settings/merge-tree-settings#max_bytes_to_merge_at_max_space_in_pool)
/ 1024. Sinon, ClickHouse lève une exception.
## min\_columns\_to\_activate\_adaptive\_write\_buffer
Permet de réduire la consommation de mémoire des tables comportant de nombreuses colonnes grâce à des tampons d’écriture adaptatifs.
Valeurs possibles :
* 0 - illimité
* 1 - toujours activé
## min\_compress\_block\_size
Taille minimale des blocs de données non compressées requise pour la compression lors de
l'écriture de la marque suivante. Vous pouvez également spécifier ce paramètre dans les paramètres globaux
(voir le paramètre [min\_compress\_block\_size](/fr/reference/settings/merge-tree-settings#min_compress_block_size)).
La valeur spécifiée lors de la création de la table remplace la valeur globale
de ce paramètre.
## min\_compressed\_bytes\_to\_fsync\_after\_fetch
Nombre minimal d’octets compressés à partir duquel effectuer `fsync` sur la part après récupération (0 - désactivé)
## min\_compressed\_bytes\_to\_fsync\_after\_merge
Nombre minimal d’octets compressés pour effectuer un fsync sur une partie après une fusion (0 - désactivé)
## min\_delay\_to\_insert\_ms
Délai minimal d’insertion des données dans une table MergeTree, en millisecondes, lorsqu’il y a beaucoup de parts non fusionnées dans une même partition.
## min\_delay\_to\_mutate\_ms
Délai minimal avant la mutation d'une table MergeTree, en millisecondes, lorsqu'un grand nombre de mutations sont inachevées
## min\_free\_disk\_bytes\_to\_perform\_insert
Le nombre minimal d'octets qui doivent être disponibles sur le disque pour
pouvoir insérer des données. Si le nombre d'octets libres disponibles est inférieur à
`min_free_disk_bytes_to_perform_insert`, une exception est levée et l'insertion
n'est pas exécutée. Notez que ce paramètre :
* prend en compte le paramètre `keep_free_space_bytes`.
* ne prend pas en compte la quantité de données qui sera écrite par l'opération
`INSERT`.
* n'est vérifié que si un nombre d'octets positif (non nul) est spécifié
Valeurs possibles :
* Tout entier positif.
Si `min_free_disk_bytes_to_perform_insert` et `min_free_disk_ratio_to_perform_insert`
sont tous deux spécifiés, ClickHouse se basera sur la valeur qui permettra
d'effectuer des insertions avec la plus grande quantité de mémoire libre.
## min\_free\_disk\_ratio\_to\_perform\_insert
Le ratio minimal entre l’espace disque libre et l’espace disque total requis pour effectuer un `INSERT`. Il doit s’agir d’une
valeur à virgule flottante comprise entre 0 et 1. Notez que ce paramètre :
* prend en compte le paramètre `keep_free_space_bytes`.
* ne prend pas en compte la quantité de données qui sera écrite par l’opération
`INSERT`.
* n’est vérifié que si un ratio positif (non nul) est spécifié
Valeurs possibles :
* Float, 0.0 - 1.0
Notez que si `min_free_disk_ratio_to_perform_insert` et
`min_free_disk_bytes_to_perform_insert` sont tous deux spécifiés, ClickHouse se basera
sur la valeur qui permettra d’effectuer des inserts avec une plus grande quantité d’espace
disque libre.
## min\_index\_granularity\_bytes
Taille minimale autorisée des granules de données, en octets.
Permet d'éviter la création accidentelle de tables avec une
valeur très faible de `index_granularity_bytes`.
## min\_level\_for\_full\_part\_storage
Disponible uniquement dans ClickHouse Cloud. Niveau minimal de part pour
utiliser le mode de stockage complet pour la partie de données au lieu du mode compact
## min\_level\_for\_wide\_part
Niveau minimal d'une partie de données pour la créer au format `Wide` plutôt qu'au format `Compact`.
## min\_marks\_to\_honor\_max\_concurrent\_queries
Le nombre minimal de marks lus par la requête pour appliquer le paramètre [max\_concurrent\_queries](#max_concurrent_queries).
Les requêtes seront toujours limitées par d'autres paramètres `max_concurrent_queries`.
Valeurs possibles :
* Entier positif.
* `0` — Désactivé (la limite `max_concurrent_queries` ne s'applique à aucune requête).
**Exemple**
```xml theme={null}
10
```
## min\_merge\_bytes\_to\_use\_direct\_io
Le volume minimal de données pour une opération de fusion nécessaire à l’utilisation
des E/S directes sur le disque de stockage. Lors de la fusion de data parts, ClickHouse calcule
le volume total de stockage de toutes les données à fusionner. Si ce volume dépasse
`min_merge_bytes_to_use_direct_io` octets, ClickHouse lit et écrit les
données sur le disque de stockage à l’aide de l’interface d’E/S directes (option `O_DIRECT`).
Si `min_merge_bytes_to_use_direct_io = 0`, les E/S directes sont désactivées.
## min\_parts\_to\_merge\_at\_once
Nombre minimal de parts de données que le sélecteur de fusion peut choisir de fusionner en une seule fois
(paramètre de niveau expert, ne le modifiez pas si vous ne comprenez pas ce qu'il fait).
0 - désactivé. Fonctionne avec les sélecteurs de fusion Simple et StochasticSimple.
## min\_relative\_delay\_to\_close
Délai minimal d’écart avec les autres répliques avant de se fermer, de cesser de servir les
requêtes et de ne plus renvoyer Ok lors de la vérification d’état.
## min\_relative\_delay\_to\_measure
Calcule le retard relatif de la réplique uniquement si le retard absolu n'est pas inférieur à cette valeur.
## min\_relative\_delay\_to\_yield\_leadership
Paramètre obsolète, sans effet.
## min\_replicated\_logs\_to\_keep
Conserve environ ce nombre des derniers enregistrements dans le log ZooKeeper, même s'ils sont
obsolètes. Cela n'affecte pas le fonctionnement des tables : ce paramètre est utilisé uniquement pour diagnostiquer le log ZooKeeper
avant son nettoyage.
Valeurs possibles :
* Tout entier positif.
## min\_rows\_for\_compact\_part
Paramètre obsolète, sans effet.
## min\_rows\_for\_full\_part\_storage
Disponible uniquement dans ClickHouse Cloud. Nombre minimal de lignes pour utiliser le format
de stockage complet pour la partie de données au lieu du format compact
## min\_rows\_for\_wide\_part
Nombre minimal de lignes pour créer une partie de données au format `Wide` plutôt qu’au format `Compact`.
## min\_rows\_to\_fsync\_after\_merge
Nombre minimal de lignes à partir duquel exécuter `fsync` sur la part après la fusion (0 - désactivé)
## mutation\_workload
Permet de réguler l'utilisation et le partage des ressources entre les mutations et les
autres workloads. La valeur spécifiée est utilisée comme valeur du paramètre `workload` pour les
mutations en arrière-plan de cette table. Si elle n'est pas spécifiée (chaîne vide), le
paramètre serveur `mutation_workload` est utilisé à la place.
**Voir aussi**
* [Planification des workloads](/fr/concepts/features/configuration/server-config/workload-scheduling)
## non\_replicated\_deduplication\_window
Le nombre de blocs insérés les plus récents dans la table
[MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) non répliquée
dont les sommes de hachage sont stockées afin de vérifier la présence de doublons.
Valeurs possibles :
* Tout entier positif.
* `0` (désactive la déduplication).
Un mécanisme de déduplication, similaire à celui des tables répliquées (voir le
paramètre [replicated\_deduplication\_window](#replicated_deduplication_window)), est utilisé.
Les sommes de hachage des parts créées sont écrites dans un fichier local sur disque.
## notify\_newest\_block\_number
Notifier SharedJoin ou SharedSet du numéro de bloc le plus récent. Uniquement dans ClickHouse Cloud.
## nullable\_serialization\_version
Contrôle la méthode de sérialisation utilisée pour les colonnes `Nullable(T)`.
Valeurs possibles :
* basic — Utilise la sérialisation standard pour `Nullable(T)`.
* allow\_sparse — Permet à `Nullable(T)` d’utiliser un encodage clairsemé.
## number\_of\_free\_entries\_in\_pool\_to\_execute\_mutation
Lorsque le nombre d’entrées libres dans le pool est inférieur au nombre spécifié, n’exécutez pas
les mutations de parts. Cela permet de laisser des threads libres pour les fusions régulières et
d’éviter les erreurs « Too many parts ».
Valeurs possibles :
* Tout entier positif.
**Utilisation**
La valeur du paramètre `number_of_free_entries_in_pool_to_execute_mutation`
doit être inférieure à la valeur de [background\_pool\_size](/fr/reference/settings/server-settings/settings#background_pool_size)
* [background\_merges\_mutations\_concurrency\_ratio](/fr/reference/settings/server-settings/settings#background_merges_mutations_concurrency_ratio).
Sinon, ClickHouse lèvera une exception.
## number\_of\_free\_entries\_in\_pool\_to\_execute\_optimize\_entire\_partition
Lorsqu’il y a moins d’entrées libres dans le pool que le nombre spécifié, ne
pas exécuter l’optimisation d’une partition entière en arrière-plan (cette tâche est générée
lorsque `min_age_to_force_merge_seconds` est défini et que
`min_age_to_force_merge_on_partition_only` est activé). Cela permet de laisser des threads libres
pour les merges habituels et d’éviter « Too many parts ».
Valeurs possibles :
* Entier positif.
La valeur du paramètre `number_of_free_entries_in_pool_to_execute_optimize_entire_partition`
doit être inférieure à celle de
[background\_pool\_size](/fr/reference/settings/server-settings/settings#background_pool_size)
* [background\_merges\_mutations\_concurrency\_ratio](/fr/reference/settings/server-settings/settings#background_merges_mutations_concurrency_ratio).
Sinon, ClickHouse lève une exception.
## number\_of\_free\_entries\_in\_pool\_to\_lower\_max\_size\_of\_merge
Lorsqu’il y a moins que le nombre spécifié d’entrées libres dans le pool
(ou la file d’attente répliquée), commencez à réduire la taille maximale de fusion à traiter
(ou à placer dans la file d’attente).
Cela permet de traiter les petites fusions, sans saturer le pool avec des fusions
de longue durée.
Valeurs possibles :
* Tout entier positif.
## number\_of\_mutations\_to\_delay
Si la table comporte au moins
ce nombre de mutations inachevées, les mutations de la table sont artificiellement ralenties.
Désactivé si défini sur 0
## number\_of\_mutations\_to\_throw
Si la table comporte au moins ce nombre de mutations non terminées, l'exception 'Too many mutations'
est levée. Désactivé si défini sur 0
## number\_of\_partitions\_to\_consider\_for\_merge
Disponible uniquement dans ClickHouse Cloud. Jusqu'à N partitions peuvent être
prises en compte pour la fusion. Les partitions sont sélectionnées de façon
aléatoire pondérée, le poids correspondant au nombre de data parts
fusionnables dans cette partition.
## object\_serialization\_version
Version de sérialisation du type de données JSON. Nécessaire pour la compatibilité.
Valeurs possibles :
* `v1`
* `v2`
* `v3`
Seule la version `v3` prend en charge la modification de la version de sérialisation des données partagées.
## object\_shared\_data\_buckets\_for\_compact\_part
Nombre de buckets utilisés pour la sérialisation JSON des données partagées dans les parties compactes. Fonctionne avec les sérialisations de données partagées `map_with_buckets` et `advanced`.
La valeur maximale autorisée est 256.
## object\_shared\_data\_buckets\_for\_wide\_part
Nombre de buckets pour la sérialisation JSON des données partagées dans les Wide parts. Fonctionne avec les sérialisations de données partagées `map_with_buckets` et `advanced`.
La valeur maximale autorisée est de 256.
## object\_shared\_data\_serialization\_version
Version de sérialisation des données partagées dans le type de données JSON.
Valeurs possibles :
* `map` - stocke les données partagées sous forme de `Map(String, String)`
* `map_with_buckets` - stocke les données partagées dans plusieurs colonnes `Map(String, String)` distinctes. L’utilisation de buckets améliore la lecture de chemins individuels à partir des données partagées.
* `advanced` - sérialisation spéciale des données partagées conçue pour améliorer considérablement la lecture de chemins individuels à partir des données partagées.
Notez que cette sérialisation augmente la taille de stockage sur disque des données partagées, car nous stockons beaucoup d’informations supplémentaires.
Le nombre de buckets pour les sérialisations `map_with_buckets` et `advanced` est déterminé par les paramètres
[object\_shared\_data\_buckets\_for\_compact\_part](#object_shared_data_buckets_for_compact_part)/[object\_shared\_data\_buckets\_for\_wide\_part](#object_shared_data_buckets_for_wide_part).
## object\_shared\_data\_serialization\_version\_for\_zero\_level\_parts
Ce paramètre permet de spécifier une version de sérialisation différente pour les
données partagées du type JSON dans les parts de niveau zéro créées lors des insertions.
Il est recommandé de ne pas utiliser la sérialisation des données partagées `advanced` pour les parts de niveau zéro, car cela peut augmenter
considérablement le temps d’insertion.
## old\_parts\_lifetime
Durée (en secondes) de conservation des parts inactives afin de prévenir toute perte de données
en cas de redémarrage spontané du serveur.
Valeurs possibles :
* Tout entier positif.
Après la fusion de plusieurs parts en une nouvelle part, ClickHouse marque les
parts d'origine comme inactives et ne les supprime qu'au bout de `old_parts_lifetime` secondes.
Les parts inactives sont supprimées si elles ne sont pas utilisées par les requêtes
en cours, c'est-à-dire si le `refcount` de la part est égal à 1.
`fsync` n'est pas appelé pour les nouvelles parts, si bien que, pendant un certain temps, les nouvelles parts n'existent
que dans la RAM du serveur (cache de l'OS). Si le serveur redémarre spontanément, les nouvelles
parts peuvent être perdues ou endommagées. Pour protéger les données, les parts inactives ne sont pas supprimées
immédiatement.
Au démarrage, ClickHouse vérifie l'intégrité des parts. Si la part fusionnée
est endommagée, ClickHouse rétablit les parts inactives dans la liste des parts actives,
puis les fusionne à nouveau ultérieurement. La part endommagée est alors renommée (le préfixe `broken_`
est ajouté) et déplacée vers le dossier `detached`. Si la part fusionnée n'est
pas endommagée, les parts inactives d'origine sont alors renommées (le préfixe `ignored_`
est ajouté) et déplacées vers le dossier `detached`.
La valeur par défaut de `dirty_expire_centisecs` (un paramètre du noyau Linux) est de 30
secondes (la durée maximale pendant laquelle les données écrites sont conservées uniquement en RAM), mais sous
forte charge du système de disque, les données peuvent être écrites bien plus tard. D'après des essais expérimentaux,
une valeur de 480 secondes a été retenue pour `old_parts_lifetime`, durée pendant laquelle
l'écriture d'une nouvelle part sur disque est garantie.
## optimize\_row\_order
Contrôle si l'ordre des lignes doit être optimisé lors des insertions afin d'améliorer la
compressibilité de la nouvelle part de table insérée.
N'a d'effet que pour les tables ordinaires utilisant un moteur MergeTree. N'a aucun effet sur les
tables spécialisées utilisant un moteur MergeTree (par ex. CollapsingMergeTree).
Les tables MergeTree sont (éventuellement) compressées à l'aide de [codecs de compression](/fr/reference/statements/create/table#column_compression_codec).
Les codecs de compression génériques tels que LZ4 et ZSTD atteignent des taux de compression
maximaux si les données présentent des motifs. De longues suites d'une même valeur se
compressent généralement très bien.
Si ce paramètre est activé, ClickHouse tente de stocker les données dans les nouvelles
parts insérées selon un ordre des lignes qui minimise le nombre de suites de valeurs égales
dans les colonnes de la nouvelle part de table.
Autrement dit, un faible nombre de suites de valeurs égales signifie que les suites
individuelles sont longues et se compressent bien.
Trouver l'ordre optimal des lignes est irréalisable en pratique d'un point de vue calculatoire (NP-difficile).
Par conséquent, ClickHouse utilise une heuristique pour trouver rapidement un ordre des lignes qui
améliore malgré tout les taux de compression par rapport à l'ordre initial des lignes.
Heuristique de recherche d'un ordre des lignes
Il est généralement possible de réordonner librement les lignes d'une table (ou d'une part de table),
car SQL considère comme équivalentes une même table (ou part de table) avec un ordre des lignes différent.
Cette liberté de réordonner les lignes est restreinte lorsqu'une clé primaire est définie
pour la table. Dans ClickHouse, une clé primaire `C1, C2, ..., CN` impose que
les lignes de la table soient triées selon les colonnes `C1`, `C2`, ... `Cn` ([index clusterisé](https://en.wikipedia.org/wiki/Database_index#Clustered)).
Par conséquent, les lignes ne peuvent être réordonnées qu'au sein de « classes d'équivalence »,
c'est-à-dire de groupes de lignes qui ont les mêmes valeurs dans leurs colonnes de clé primaire.
L'idée est que les clés primaires à forte cardinalité, par ex. les clés primaires
incluant une colonne d'horodatage `DateTime64`, conduisent à de nombreuses petites classes
d'équivalence. De même, les tables avec une clé primaire à faible cardinalité créent peu de
classes d'équivalence, mais de grande taille. Une table sans clé primaire représente le cas
extrême d'une seule classe d'équivalence couvrant toutes les lignes.
Moins les classes d'équivalence sont nombreuses et plus elles sont grandes, plus le degré
de liberté lors du réordonnancement des lignes est élevé.
L'heuristique appliquée pour trouver le meilleur ordre des lignes au sein de chaque classe
d'équivalence est proposée par D. Lemire et O. Kaser dans
[Reordering columns for smaller indexes](https://doi.org/10.1016/j.ins.2011.02.002)
et repose sur le tri des lignes, au sein de chaque classe d'équivalence, par cardinalité
croissante des colonnes hors clé primaire.
Elle s'exécute en trois étapes :
1. Trouver toutes les classes d'équivalence à partir des valeurs des lignes dans les colonnes de clé primaire.
2. Pour chaque classe d'équivalence, calculer (généralement estimer) les cardinalités
des colonnes hors clé primaire.
3. Pour chaque classe d'équivalence, trier les lignes par ordre croissant de
cardinalité des colonnes hors clé primaire.
Si cette option est activée, les opérations d'insertion entraînent un surcoût CPU pour analyser et
optimiser l'ordre des lignes des nouvelles données. Les INSERT devraient prendre 30 à 50 %
de temps en plus selon les caractéristiques des données.
Les taux de compression de LZ4 ou ZSTD s'améliorent en moyenne de 20 à 40 %.
Ce paramètre fonctionne le mieux pour les tables sans clé primaire ou avec une clé primaire à faible cardinalité,
c'est-à-dire une table avec peu de valeurs distinctes de clé primaire.
Les clés primaires à forte cardinalité, par ex. incluant des colonnes d'horodatage de type
`DateTime64`, ne devraient pas bénéficier de ce paramètre.
## packed\_skip\_index\_max\_bytes
.idx2 / .mrk2. La décision est prise par sous-flux au moment de l’écriture."}]}]} />
Seuil (en octets sérialisés sur disque, c’est-à-dire après la chaîne de compression et de hachage
du sous-flux) en dessous duquel un sous-flux d’index de saut est regroupé dans une seule archive
`skp_idx.packed` par part au lieu d’être écrit dans un fichier `skp_idx_.idx2` / `.mrk2`
distinct. Les sous-flux plus volumineux conservent la disposition legacy, fichier par fichier. La décision
est prise indépendamment pour chaque sous-flux au moment de l’écriture, de sorte qu’une même part peut contenir de petits index
(par ex. `minmax`) regroupés et de gros index (par ex. un `bloom_filter` volumineux) stockés par fichier. Définissez 0
pour désactiver complètement le regroupement (valeur par défaut).
Chaque sous-flux d’index de saut se compose en réalité d’un fichier de données et d’un fichier de marks ; tous deux sont mis en tampon
en mémoire jusqu’au seuil avant que la décision de spill ne soit prise. Ainsi, le pic de mémoire pendant
l’écriture évolue avec `2 * packed_skip_index_max_bytes * (number of substreams that stay
below the threshold)`.
Les index de texte intégral ne sont pas pris en charge par ce paramètre et ne sont jamais regroupés.
Le regroupement réduit la pression sur les inodes lorsque de nombreux index de saut sont définis sur une table (par exemple
avec `add_minmax_index_for_numeric_columns`).
Le format sur disque est auto-descriptif : les lecteurs détectent `skp_idx.packed` et servent les
sous-flux regroupés qu’il contient de manière transparente. La modification de ce paramètre n’affecte que les nouvelles parts écrites
; les parts existantes conservent la disposition qu’elles avaient au moment de l’écriture.
Limitation connue : `system.data_skipping_indices.data_uncompressed_bytes` et
`system.parts.secondary_indices_uncompressed_bytes` indiquent la taille compressée pour les sous-flux regroupés
(l’index de l’archive ne stocke pas les tailles non compressées). Cet écart est purement cosmétique dans le
monitoring, avec une conséquence fonctionnelle :
`distributed_index_analysis_min_indexes_bytes_to_activate` compare avec
`data_uncompressed`, donc un index regroupé qui se compresse bien (`set` ou `bloom_filter` sur
des chaînes) peut ne pas franchir le seuil d’activation, même si sa taille réelle non compressée le ferait.
Le fallback est le query plan normal, et non un résultat erroné.
## part\_minmax\_index\_columns
Détermine quelles colonnes sont couvertes par l’index min-max de chaque part. Chaque valeur active un groupe supplémentaire de colonnes, en plus du précédent.
Valeurs possibles :
* `partition_key_only` — seules les colonnes de la clé de partition sont prises en compte.
* `with_block_number_offset` — colonnes de la clé de partition, ainsi que les colonnes virtuelles persistées `_block_number` et `_block_offset`. Active l’élagage au niveau des parts à l’aide de ces colonnes.
## part\_moves\_between\_shards\_delay\_seconds
Délai d'attente avant/après le déplacement de parts d'un shard à l'autre.
## part\_moves\_between\_shards\_enable
Fonctionnalité expérimentale/incomplète permettant de déplacer des parts entre shards. Ne prend pas en compte les expressions de sharding.
## parts\_to\_delay\_insert
Si le nombre de parts actives dans une même partition dépasse la
valeur `parts_to_delay_insert`, un `INSERT` est artificiellement ralenti.
Valeurs possibles :
* Tout entier positif.
ClickHouse ralentit artificiellement l'exécution de `INSERT` (en ajoutant un « sleep ») afin que le
processus de fusion en arrière-plan puisse fusionner les parts plus vite qu'elles ne sont ajoutées.
## parts\_to\_throw\_insert
Si le nombre de parts actives dans une seule partition dépasse la
valeur `parts_to_throw_insert`, `INSERT` est interrompu avec l’exception `Too many
parts (N). Merges are processing significantly slower than inserts`.
Valeurs possibles :
* Tout entier positif.
Pour obtenir des performances maximales pour les requêtes `SELECT`, il est nécessaire de
réduire au minimum le nombre de parts traitées, voir [Merge Tree](/fr/resources/develop-contribute/introduction/architecture#merge-tree).
Avant la version 23.6, ce paramètre était défini sur 300. Vous pouvez définir une
valeur plus élevée, ce qui réduira la probabilité de l’erreur `Too many parts`,
mais les performances de `SELECT` risquent alors de se dégrader. De plus, en cas
de problème de fusion (par exemple, en raison d’un espace disque insuffisant), vous le
remarquerez plus tard qu’avec la valeur initiale de 300.
## prefer\_fetch\_merged\_part\_size\_threshold
Si la somme de la taille des parts dépasse ce seuil et que le temps écoulé depuis la création d'une
entrée du journal de réplication est supérieur à
`prefer_fetch_merged_part_time_threshold`, il est préférable de récupérer une part fusionnée
auprès d'une réplique plutôt que d'effectuer la fusion localement. Cela permet d'accélérer les
fusions très longues.
Valeurs possibles :
* Tout entier positif.
## prefer\_fetch\_merged\_part\_time\_threshold
Si le temps écoulé depuis la création d’une entrée du journal de réplication (ClickHouse Keeper ou ZooKeeper)
dépasse ce seuil, et que la somme de la taille des parts est
supérieure à `prefer_fetch_merged_part_size_threshold`, alors il est préférable de récupérer
une part fusionnée depuis une réplique plutôt que d’effectuer la fusion localement. Cela permet d’accélérer
les fusions très longues.
Valeurs possibles :
* Tout entier positif.
## prewarm\_mark\_cache
Si la valeur est true, le cache des marks sera
préchargé en enregistrant les marks dans le cache des marks lors des insertions, des fusions, des récupérations et au
démarrage du serveur
## prewarm\_primary\_key\_cache
Si cette option est activée, le cache de l’index primaire
sera préchargé en enregistrant les marks dans le cache des marks lors des insertions, des fusions,
des récupérations et au démarrage du serveur
## primary\_key\_compress\_block\_size
Taille du bloc de compression de la clé primaire, c’est-à-dire la taille réelle du bloc à compresser.
## primary\_key\_compression\_codec
Codec de compression utilisé pour la clé primaire ; la clé primaire est suffisamment petite et mise en cache,
la compression par défaut est donc ZSTD(3).
## primary\_key\_lazy\_load
Charge la clé primaire en mémoire lors de la
première utilisation plutôt qu’à l’initialisation de la table. Cela peut permettre d’économiser de la mémoire en
présence d’un grand nombre de tables.
## primary\_key\_ratio\_of\_unique\_prefix\_values\_to\_skip\_suffix\_columns
Si la valeur d’une colonne de la clé primaire d’une part de données change au moins dans cette proportion de cas, ignorez le chargement en mémoire des colonnes suivantes. Cela permet d’économiser de la mémoire en ne chargeant pas les colonnes inutiles de la clé primaire.
## propagate\_types\_serialization\_versions\_to\_nested\_types
Si la valeur est true, les versions de sérialisation comme string\_serialization\_version seront propagées au sein des types imbriqués comme Array/Map/Nullable/JSON/etc. Si cette option est désactivée, la version de sérialisation ne s’appliquera qu’aux colonnes de niveau supérieur de ce type et Tuple el
## ratio\_of\_defaults\_for\_sparse\_serialization
Ratio minimal entre le nombre de valeurs *par défaut* et le nombre *total* de valeurs
dans une colonne. Définir cette valeur permet de stocker la colonne à l’aide de
sérialisations sparse.
Si une colonne est sparse (contient principalement des zéros), ClickHouse peut l’encoder dans
un format sparse et optimiser automatiquement les calculs ; les données ne nécessitent pas
de décompression complète pendant les requêtes. Pour activer cette sérialisation sparse,
définissez le paramètre `ratio_of_defaults_for_sparse_serialization`
sur une valeur inférieure à 1.0. Si la valeur est supérieure ou égale à 1.0,
les colonnes seront toujours écrites avec la sérialisation complète normale.
Valeurs possibles :
* Float entre `0` et `1` pour activer la sérialisation sparse
* `1.0` (ou plus) si vous ne souhaitez pas utiliser la sérialisation sparse
**Exemple**
Notez que la colonne `s` dans la table suivante est une chaîne vide dans 95 % des
lignes. Dans `my_regular_table`, nous n’utilisons pas de sérialisation sparse, et dans
`my_sparse_table`, nous définissons `ratio_of_defaults_for_sparse_serialization` sur
0.95 :
```sql theme={null}
CREATE TABLE my_regular_table
(
`id` UInt64,
`s` String
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO my_regular_table
SELECT
number AS id,
number % 20 = 0 ? toString(number): '' AS s
FROM
numbers(10000000);
CREATE TABLE my_sparse_table
(
`id` UInt64,
`s` String
)
ENGINE = MergeTree
ORDER BY id
SETTINGS ratio_of_defaults_for_sparse_serialization = 0.95;
INSERT INTO my_sparse_table
SELECT
number,
number % 20 = 0 ? toString(number): ''
FROM
numbers(10000000);
```
Notez que la colonne `s` de `my_sparse_table` occupe moins d’espace de stockage sur le disque :
```sql theme={null}
SELECT table, name, data_compressed_bytes, data_uncompressed_bytes FROM system.columns
WHERE table LIKE 'my_%_table';
```
```response theme={null}
┌─table────────────┬─name─┬─data_compressed_bytes─┬─data_uncompressed_bytes─┐
│ my_regular_table │ id │ 37790741 │ 75488328 │
│ my_regular_table │ s │ 2451377 │ 12683106 │
│ my_sparse_table │ id │ 37790741 │ 75488328 │
│ my_sparse_table │ s │ 2283454 │ 9855751 │
└──────────────────┴──────┴───────────────────────┴─────────────────────────┘
```
Vous pouvez vérifier si une colonne utilise l’encodage sparse en consultant la
colonne `serialization_kind` de la table `system.parts_columns` :
```sql theme={null}
SELECT column, serialization_kind FROM system.parts_columns
WHERE table LIKE 'my_sparse_table';
```
Vous pouvez voir quelles parts de `s` ont été stockées à l’aide de la sérialisation creuse :
```response theme={null}
┌─column─┬─serialization_kind─┐
│ id │ Default │
│ s │ Default │
│ id │ Default │
│ s │ Default │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
└────────┴────────────────────┘
```
## reduce\_blocking\_parts\_sleep\_ms
Disponible uniquement dans ClickHouse Cloud. Temps minimal d'attente avant de
tenter à nouveau de réduire les parts bloquantes lorsqu'aucune plage n'a été supprimée/remplacée. Un paramètre plus
faible déclenchera fréquemment des tâches dans background\_schedule\_pool, ce qui
entraînera un grand nombre de requêtes vers ZooKeeper dans les clusters de grande taille
## refresh\_parts\_interval
S'il est supérieur à zéro, actualise la liste des parts de données depuis le système de fichiers sous-jacent afin de vérifier si les données ont été mises à jour en interne.
Il ne peut être défini que si la table se trouve sur des disques en lecture seule (ce qui signifie qu'il s'agit d'une réplique en lecture seule, tandis que les données sont écrites par une autre réplique).
## refresh\_statistics\_interval
Intervalle d’actualisation du cache des statistiques, en secondes. S’il est défini à zéro, l’actualisation est désactivée.
## remote\_fs\_execute\_merges\_on\_single\_replica\_time\_threshold
Lorsque ce paramètre est supérieur à zéro, une seule réplique démarre
immédiatement la fusion si la part fusionnée se trouve sur un stockage partagé.
La réplication zero-copy n’est pas prête pour un usage en production
La réplication zero-copy est désactivée par défaut dans ClickHouse 22.8 et
les versions ultérieures.
Cette fonctionnalité n’est pas recommandée pour une utilisation en production.
Valeurs possibles :
* Tout entier positif.
## remote\_fs\_zero\_copy\_path\_compatible\_mode
Exécutez zero-copy en mode compatible pendant le processus de conversion.
## remote\_fs\_zero\_copy\_zookeeper\_path
Chemin ZooKeeper des informations zero-copy non liées aux tables.
## remove\_empty\_parts
Supprime les parts vides après qu’elles ont été éliminées par TTL, une mutation ou l’algorithme de fusion par collapsing.
## remove\_rolled\_back\_parts\_immediately
Paramètre d’une fonctionnalité expérimentale incomplète.
## remove\_unused\_patch\_parts
Supprime en arrière-plan les patch parts appliquées à toutes les parties actives.
## replace\_long\_file\_name\_to\_hash
Si le nom de fichier d’une colonne est trop long (plus de 'max\_file\_name\_length'
octets), il est remplacé par SipHash128
## replicated\_can\_become\_leader
Si `true`, les répliques des tables répliquées sur ce nœud tenteront de devenir
leader.
Valeurs possibles :
* `true`
* `false`
## replicated\_deduplication\_window
Nombre de blocs insérés les plus récents pour lesquels ClickHouse Keeper stocke
les sommes de hachage afin de détecter les doublons.
Valeurs possibles :
* Tout entier positif.
* 0 (désactive la déduplication)
La commande `Insert` crée une ou plusieurs blocs (parts). Pour la
[déduplication des insertions](/fr/reference/engines/table-engines/mergetree-family/replication),
lors de l'écriture dans des tables répliquées, ClickHouse écrit les sommes de hachage des
parts créées dans ClickHouse Keeper. Les sommes de hachage ne sont conservées que pour les
`replicated_deduplication_window` blocs les plus récents. Les plus anciennes sont
supprimées de ClickHouse Keeper.
Une valeur élevée pour `replicated_deduplication_window` ralentit les `Inserts`,
car davantage d'entrées doivent être comparées. La somme de hachage est calculée à partir
de la composition des noms et types de champs, ainsi que des données de la
part insérée (flux d'octets).
## replicated\_deduplication\_window\_for\_async\_inserts
Le nombre de blocs insérés de manière asynchrone les plus récents pour lesquels ClickHouse Keeper
stocke des sommes de hachage afin de détecter les doublons.
Valeurs possibles :
* Tout entier positif.
* 0 (désactive la déduplication pour async\_inserts)
La commande [Async Insert](/fr/reference/settings/session-settings#async_insert) est
mise en cache dans un ou plusieurs blocs (parts). Pour la [déduplication des insertions](/fr/reference/engines/table-engines/mergetree-family/replication),
lors de l’écriture dans des tables répliquées, ClickHouse écrit les sommes de hachage de chaque
insert dans ClickHouse Keeper. Les sommes de hachage ne sont stockées que pour les
`replicated_deduplication_window_for_async_inserts` blocs les plus récents. Les sommes de hachage
les plus anciennes sont supprimées de ClickHouse Keeper.
Une valeur élevée de `replicated_deduplication_window_for_async_inserts` ralentit
les `Async Inserts`, car il faut comparer davantage d’entrées.
La somme de hachage est calculée à partir de la composition des noms et des types de champs
ainsi que des données de l’insert (flux d’octets).
## replicated\_deduplication\_window\_seconds
Le nombre de secondes au terme duquel les sommes de hachage des blocs insérés
sont supprimées de ClickHouse Keeper.
Valeurs possibles :
* Tout entier positif.
À l'instar de [replicated\_deduplication\_window](#replicated_deduplication_window),
`replicated_deduplication_window_seconds` indique pendant combien de temps conserver les sommes de hachage
des blocs pour la déduplication des insertions. Les sommes de hachage plus anciennes que
`replicated_deduplication_window_seconds` sont supprimées de ClickHouse Keeper,
même si elles sont inférieures à ` replicated_deduplication_window`.
Le temps est calculé par rapport à l'horodatage de l'enregistrement le plus récent, et non à l'heure
réelle. S'il s'agit du seul enregistrement, il sera conservé indéfiniment.
## replicated\_deduplication\_window\_seconds\_for\_async\_inserts
Le nombre de secondes après lequel les sommes de hachage des insertions asynchrones sont
supprimées de ClickHouse Keeper.
Valeurs possibles :
* Tout entier positif.
Comme [replicated\_deduplication\_window\_for\_async\_inserts](#replicated_deduplication_window_for_async_inserts),
`replicated_deduplication_window_seconds_for_async_inserts` indique pendant combien de temps
conserver les sommes de hachage des blocs pour la déduplication des insertions asynchrones. Les sommes de hachage
plus anciennes que `replicated_deduplication_window_seconds_for_async_inserts` sont
supprimées de ClickHouse Keeper, même si leur nombre reste inférieur à
`replicated_deduplication_window_for_async_inserts`.
Le temps est calculé par rapport à celui de l'enregistrement le plus récent, et non au temps d'horloge.
S'il s'agit du seul enregistrement, il sera conservé indéfiniment.
## replicated\_fetches\_http\_connection\_timeout
Paramètre obsolète, sans effet.
## replicated\_fetches\_http\_receive\_timeout
Paramètre obsolète, sans effet.
## replicated\_fetches\_http\_send\_timeout
Paramètre obsolète, sans effet.
## replicated\_fetches\_min\_part\_level
Niveau minimal de part à récupérer depuis d'autres répliques. Les parts dont le niveau est inférieur à ce seuil sont reportées
(conservées dans la file de réplication et réévaluées à chaque cycle de planification, et non ignorées définitivement).
Utilisez 1 pour reporter la récupération des parts de niveau 0 (non fusionnées), afin de réduire la surcharge de réplication en cas de forte ingestion.
Par défaut : 0 (récupérer toutes les parts, quel que soit leur niveau).
## replicated\_fetches\_min\_part\_level\_timeout\_seconds
Délai d’expiration, en secondes, au-delà duquel une part située sous replicated\_fetches\_min\_part\_level sera tout de même récupérée.
Utilisez 0 pour désactiver ce délai d’expiration (les parts sous le niveau minimal sont reportées indéfiniment jusqu’à leur fusion).
Par défaut : 300 (récupération forcée après 5 minutes).
## replicated\_max\_mutations\_in\_one\_entry
Nombre maximal de commandes de mutation pouvant être regroupées et exécutées dans
une seule entrée MUTATE\_PART (0 signifie sans limite)
## replicated\_max\_parallel\_fetches
Paramètre obsolète, n’a aucun effet.
## replicated\_max\_parallel\_fetches\_for\_host
Paramètre obsolète, sans effet.
## replicated\_max\_parallel\_fetches\_for\_table
Paramètre obsolète, n’a aucun effet.
## replicated\_max\_parallel\_sends
Paramètre obsolète, n’a aucun effet.
## replicated\_max\_parallel\_sends\_for\_table
Paramètre obsolète, sans effet.
## replicated\_max\_ratio\_of\_wrong\_parts
Si le ratio de parts incorrectes sur le nombre total de parts est inférieur à cette valeur, le démarrage est autorisé.
Valeurs possibles :
* Float, 0.0 - 1.0
## search\_orphaned\_parts\_disks
ClickHouse analyse tous les disques à la recherche de parts orphelines lors de toute opération ATTACH ou CREATE de table
afin d'éviter de passer à côté de parts de données sur des disques non définis (non inclus dans la politique de stockage).
Les parts orphelines résultent d'une reconfiguration du stockage potentiellement dangereuse, par exemple si un disque a été exclu de la politique de stockage.
Ce paramètre limite le périmètre de recherche des disques en fonction de leurs caractéristiques.
Valeurs possibles :
* any - le périmètre n'est pas limité.
* local - le périmètre est limité aux disques locaux.
* none - périmètre vide, ne pas rechercher
## serialization\_info\_version
Version des informations de sérialisation utilisée lors de l'écriture de `serialization.json`.
Ce paramètre est nécessaire pour assurer la compatibilité lors des mises à niveau du cluster.
Valeurs possibles :
* `basic` - Format de base.
* `with_types` - Format avec le champ supplémentaire `types_serialization_versions`, autorisant des versions de sérialisation par type.
Cela permet à des paramètres comme `string_serialization_version` de prendre effet.
Lors des mises à niveau progressives, définissez ce paramètre sur `basic` afin que les nouveaux serveurs produisent des parts de données compatibles avec les anciens serveurs. Une fois la mise à niveau terminée,
passez à `WITH_TYPES` pour activer les versions de sérialisation par type.
## share\_nested\_offsets
Lorsqu’il est activé (par défaut), les colonnes Array dont les noms, avec des points, partagent un préfixe commun (par ex. n.a et n.b)
sont traitées comme faisant partie d’une structure Nested : elles partagent un unique fichier d’offsets sur le disk (par ex. n.size0),
et l’égalité de la taille de leurs tableaux est vérifiée lors de l’INSERT.
Lorsqu’il est désactivé, chaque colonne Array reçoit son propre fichier d’offsets indépendant, les noms avec des points n’ont pas de sémantique
particulière, et une colonne scalaire peut coexister avec des colonnes Array dont les noms, avec des points, partagent le même préfixe
(par ex. n UInt32 aux côtés de n.a Array(String)). Ce paramètre est immuable après la création de la table.
## shared\_merge\_tree\_activate\_coordinated\_merges\_tasks
Active la replanification des tâches de fusions coordonnées. Cela peut être utile même lorsque
shared\_merge\_tree\_enable\_coordinated\_merges=0, car cela alimentera les statistiques du coordinateur de fusions
et facilitera le démarrage à froid.
## shared\_merge\_tree\_create\_per\_replica\_metadata\_nodes
Permet de créer des nœuds /metadata et /columns pour chaque réplique dans ZooKeeper.
Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_disable\_merges\_and\_mutations\_assignment
Désactive l’attribution des fusions pour shared merge tree. Disponible uniquement dans ClickHouse
Cloud
## shared\_merge\_tree\_empty\_partition\_lifetime
Nombre de secondes pendant lesquelles une partition sera conservée dans Keeper si elle ne contient aucune part.
## shared\_merge\_tree\_enable\_automatic\_empty\_partitions\_cleanup
Active le nettoyage des entrées de Keeper associées aux partitions vides.
## shared\_merge\_tree\_enable\_coordinated\_merges
Active la stratégie de fusions coordonnées
Permet d'écrire des attributs dans les parties virtuelles et de valider les blocs dans Keeper
## shared\_merge\_tree\_enable\_outdated\_parts\_check
Active la vérification des parties obsolètes. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_idle\_parts\_update\_seconds
Intervalle, en secondes, de mise à jour des parts sans déclenchement par un watch ZooKeeper
dans le shared merge tree. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_initial\_parts\_update\_backoff\_ms
Délai initial avant nouvelle tentative pour la mise à jour des parts. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_interserver\_http\_connection\_timeout\_ms
Délai d’expiration pour la connexion HTTP interserveur. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_interserver\_http\_timeout\_ms
Délais d’expiration des communications HTTP entre serveurs. Disponible uniquement dans ClickHouse
Cloud
## shared\_merge\_tree\_leader\_update\_period\_random\_add\_seconds
Ajoute à shared\_merge\_tree\_leader\_update\_period une valeur
uniformément répartie entre 0 et x secondes afin d’éviter
l’effet de troupeau. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_leader\_update\_period\_seconds
Période maximale avant de vérifier à nouveau le rôle de leader pour la mise à jour des parties de données. Disponible uniquement dans
ClickHouse Cloud
## shared\_merge\_tree\_max\_outdated\_parts\_to\_process\_at\_once
Nombre maximal de parties obsolètes que le leader tentera de confirmer pour suppression en
une seule requête HTTP. Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_max\_parts\_update\_backoff\_ms
Délai de backoff maximal pour la mise à jour des parts. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_max\_parts\_update\_leaders\_in\_total
Nombre maximal de leaders de mise à jour des parts. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_max\_parts\_update\_leaders\_per\_az
Nombre maximal de leaders pour la mise à jour des parts. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_max\_replicas\_for\_parts\_deletion
Nombre maximal de répliques pouvant participer à la suppression des parts (thread killer). Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_max\_replicas\_to\_merge\_parts\_for\_each\_parts\_range
Nombre maximal de répliques qui tenteront d’attribuer des fusions potentiellement
conflictuelles (permet d’éviter les conflits redondants lors de l’attribution des fusions). 0 signifie désactivé. Disponible
uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_max\_suspicious\_broken\_parts
Nombre maximal de parties corrompues pour SMT ; au-delà, interdire le détachement automatique.
## shared\_merge\_tree\_max\_suspicious\_broken\_parts\_bytes
Taille totale maximale des parties endommagées pour SMT ; au-delà, le détachement automatique est refusé.
## shared\_merge\_tree\_memo\_ids\_remove\_timeout\_seconds
Durée de conservation des identifiants de mémoïsation d’insert afin d’éviter des actions incorrectes lors des
nouvelles tentatives d’insert. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_merge\_coordinator\_election\_check\_period\_ms
Intervalle entre deux exécutions du thread d'élection du coordinateur de fusion
## shared\_merge\_tree\_merge\_coordinator\_factor
Facteur de variation du délai du thread du coordinateur de fusion
## shared\_merge\_tree\_merge\_coordinator\_fetch\_fresh\_metadata\_period\_ms
Fréquence à laquelle le coordinateur de fusion doit se synchroniser avec ZooKeeper pour récupérer les métadonnées les plus récentes
## shared\_merge\_tree\_merge\_coordinator\_max\_merge\_request\_size
Nombre de fusions que le coordinateur de fusion peut demander à MergerMutator en une seule fois
## shared\_merge\_tree\_merge\_coordinator\_max\_period\_ms
Temps maximal entre deux exécutions du thread du coordinateur de fusion
## shared\_merge\_tree\_merge\_coordinator\_merges\_prepare\_count
Nombre d'entrées de fusion que le coordinateur de fusion doit préparer et distribuer entre les workers.
Lorsqu'il est défini sur 'auto', il est égal au nombre maximal de tâches de fusion autorisées sur une seule réplique, multiplié par le nombre de répliques actives.
## shared\_merge\_tree\_merge\_coordinator\_min\_period\_ms
Temps minimal entre deux exécutions du thread du coordinateur de fusion
## shared\_merge\_tree\_merge\_worker\_fast\_timeout\_ms
Délai d’expiration utilisé par le thread de merge worker s’il doit mettre à jour son état après une action immédiate
## shared\_merge\_tree\_merge\_worker\_regular\_timeout\_ms
Délai entre deux exécutions du thread de merge worker
## shared\_merge\_tree\_outdated\_parts\_group\_size
Nombre de répliques appartenant au même groupe de hachage rendezvous pour le nettoyage des parts obsolètes.
Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_partitions\_hint\_ratio\_to\_reload\_merge\_pred\_for\_mutations
Recharge le prédicat de fusion dans la tâche de sélection de merge/mutate lorsque le ratio `/` est supérieur à ce paramètre. Disponible uniquement
dans ClickHouse Cloud
## shared\_merge\_tree\_parts\_load\_batch\_size
Nombre de tâches de récupération des métadonnées des parts à planifier simultanément. Disponible uniquement dans
ClickHouse Cloud
## shared\_merge\_tree\_postpone\_next\_merge\_for\_locally\_merged\_parts\_ms
Durée pendant laquelle une partie fusionnée localement est conservée sans lancer une nouvelle fusion l'incluant.
Cela donne aux autres répliques le temps de récupérer la partie et de lancer cette fusion.
Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_postpone\_next\_merge\_for\_locally\_merged\_parts\_rows\_threshold
Taille minimale d’une part (en lignes) à partir de laquelle l’attribution de la fusion suivante est reportée juste après une fusion locale. Disponible uniquement dans ClickHouse Cloud.
## shared\_merge\_tree\_range\_for\_merge\_window\_size
Durée de conservation d’une partie fusionnée localement avant de lancer une nouvelle fusion incluant
cette partie. Cela laisse aux autres répliques le temps de récupérer la partie et de lancer cette fusion.
Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_read\_virtual\_parts\_from\_leader
Lire les parties virtuelles depuis le leader lorsque cela est possible. Disponible uniquement dans ClickHouse
Cloud
## shared\_merge\_tree\_replica\_set\_max\_lifetime\_seconds
Fréquence à laquelle les répliques essaient de mettre à jour l’ensemble de répliques en arrière-plan. L’exécution suivante est décalée
de manière uniforme dans l’intervalle \[0, value] secondes. Exception : value = 0 ne respecte pas cette règle ;
l’implémentation applique un minimum de 200 ms, donc l’exécution suivante est décalée dans l’intervalle \[0, 200] ms.
## shared\_merge\_tree\_try\_fetch\_part\_in\_memory\_data\_from\_replicas
Si ce paramètre est activé, toutes les répliques tentent de récupérer depuis d'autres répliques les données en mémoire associées à la part (comme la clé primaire, les informations de partition, etc.) lorsqu'elles y sont déjà présentes.
## shared\_merge\_tree\_try\_fetch\_part\_in\_memory\_data\_from\_replicas\_on\_startup
Si ce paramètre est activé, toutes les répliques essaient, au démarrage, de récupérer depuis d’autres répliques où elles existent déjà les données en mémoire des parts (comme la clé primaire, les informations de partition, etc.).
## shared\_merge\_tree\_update\_replica\_flags\_delay\_ms
Fréquence à laquelle la réplique tentera de recharger ses indicateurs selon la planification en arrière-plan.
## shared\_merge\_tree\_use\_metadata\_hints\_cache
Permet de demander des indications de cache FS à partir du cache en mémoire
d’autres répliques. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_use\_outdated\_parts\_compact\_format
Utilise le format compact pour les parties obsolètes : réduit la charge de Keeper et améliore
le traitement des parties obsolètes. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_use\_too\_many\_parts\_count\_from\_virtual\_parts
Si cette option est activée, le compteur « too many parts » s’appuie sur les données partagées dans Keeper, plutôt que sur
l’état local de la réplique. Disponible uniquement dans ClickHouse Cloud
## shared\_merge\_tree\_use\_zookeeper\_connection\_pool
Si ce paramètre est activé, SharedMergeTree utilise l’une des sessions ZooKeeper mises en pool au niveau du serveur.
## shared\_merge\_tree\_virtual\_parts\_discovery\_batch
Nombre de découvertes de partitions à regrouper dans un lot
## simultaneous\_parts\_removal\_limit
S'il y a beaucoup de parts obsolètes, le thread de nettoyage tentera d'en supprimer jusqu'à
`simultaneous_parts_removal_limit` au cours d'une itération.
Une valeur de `0` pour `simultaneous_parts_removal_limit` signifie qu'il n'y a pas de limite.
## sleep\_before\_commit\_local\_part\_in\_replicated\_table\_ms
À des fins de test. Ne le modifiez pas.
## sleep\_before\_loading\_outdated\_parts\_ms
À des fins de test. Ne modifiez pas ce paramètre.
## storage\_policy
Nom de la politique de stockage sur disque
## string\_serialization\_version
Contrôle le format de sérialisation des colonnes `String` de niveau supérieur.
Ce paramètre ne prend effet que lorsque `serialization_info_version` est défini sur "with\_types".
Lorsqu’il est défini sur `with_size_stream`, les colonnes `String` de niveau supérieur sont sérialisées avec une
sous-colonne `.size` distincte qui stocke les longueurs des chaînes, plutôt qu’en ligne. Cela permet d’avoir de véritables sous-colonnes `.size`
et peut améliorer l’efficacité de la compression.
Les types `String` imbriqués (par ex. à l’intérieur de `Nullable`, `LowCardinality`, `Array` ou `Map`)
ne sont pas affectés, sauf lorsqu’ils apparaissent dans un `Tuple`.
Valeurs possibles :
* `single_stream` — Utilise le format de sérialisation standard avec les tailles en ligne.
* `with_size_stream` — Utilise un flux de tailles distinct pour les colonnes `String` de niveau supérieur.
## table\_disk
Il s’agit du disque de la table : le chemin/l’endpoint doit pointer vers les données de la table, et non vers
les données de la base de données. Ne peut être défini que pour s3\_plain/s3\_plain\_rewritable/web.
## table\_readonly
Si ce paramètre est défini sur true, la table est en mode lecture seule. Toute tentative d’insérer des données ou de modifier la table échouera.
## temporary\_directories\_lifetime
Nombre de secondes pendant lesquelles conserver les répertoires tmp\_-. Il est déconseillé de réduire cette valeur,
car les merges et les mutations risquent de ne pas pouvoir fonctionner avec une valeur trop faible de ce
paramètre.
## text\_index\_dictionary\_block\_frontcoding\_compression
Compression par front-coding par défaut pour les blocs de dictionnaire de l’index de texte.
Peut être redéfinie à l’aide de l’argument d’index explicite `dictionary_block_frontcoding_compression`.
## text\_index\_dictionary\_block\_size
Taille de bloc par défaut du dictionnaire pour les index de texte.
Peut être redéfinie via l'argument d'index explicite `dictionary_block_size`.
## text\_index\_posting\_list\_block\_size
Taille de bloc par défaut de la posting list pour les index textuels (lignes).
Peut être surchargée par l’argument d’index explicite `posting_list_block_size`.
## text\_index\_posting\_list\_codec
Codec par défaut de la liste d’occurrences pour les index de texte.
Peut être surchargé via l’argument d’index explicite `posting_list_codec`.
## try\_fetch\_recompressed\_part\_timeout
Délai d'attente (en secondes) avant de lancer une fusion avec recompression. Pendant ce
temps, ClickHouse tente de récupérer la partie recompressée depuis la réplique à laquelle cette
fusion avec recompression a été assignée.
La recompression est lente dans la plupart des cas. Nous ne lançons donc pas de fusion avec
recompression avant l'expiration de ce délai d'attente et tentons de récupérer la partie recompressée depuis la
réplique à laquelle cette fusion avec recompression a été assignée.
Valeurs possibles :
* Tout entier positif.
## ttl\_only\_drop\_parts
Détermine si les data parts sont entièrement supprimées dans les tables MergeTree lorsque toutes
les lignes de cette part ont expiré conformément à leurs paramètres `TTL`.
Lorsque `ttl_only_drop_parts` est désactivé (par défaut), seules les lignes qui ont
expiré selon leurs paramètres `TTL` sont supprimées.
Lorsque `ttl_only_drop_parts` est activé, la part entière est supprimée si toutes
les lignes de cette part ont expiré conformément à leurs paramètres `TTL`.
## use\_adaptive\_write\_buffer\_for\_dynamic\_subcolumns
Permet d’utiliser des tampons d’écriture adaptatifs lors de l’écriture de sous-colonnes Dynamic afin de
réduire l’utilisation de la mémoire
## use\_async\_block\_ids\_cache
Si `true`, les sommes de hachage des insertions asynchrones sont mises en cache.
Valeurs possibles :
* `true`
* `false`
Un bloc contenant plusieurs insertions asynchrones générera plusieurs sommes de hachage.
Lorsque certaines insertions sont dupliquées, Keeper ne renverra qu'une seule
somme de hachage dupliquée dans un RPC, ce qui entraînera des tentatives RPC inutiles.
Ce cache surveillera le chemin des sommes de hachage dans Keeper. Si des mises à jour sont détectées
dans Keeper, le cache se mettra à jour dès que possible afin que nous puissions
filtrer en mémoire les insertions dupliquées.
## use\_compact\_variant\_discriminators\_serialization
Active le mode compact pour la sérialisation binaire des discriminateurs du
type de données Variant.
Ce mode permet d'utiliser beaucoup moins de mémoire pour stocker les discriminateurs
dans les parts lorsqu'il n'y a le plus souvent qu'une seule variante ou beaucoup de valeurs NULL.
## use\_const\_adaptive\_granularity
Utilise toujours une granularité constante sur l’ensemble de la part de données. Cela permet de compresser en mémoire les valeurs de la granularité d’index. Cela peut être utile pour des workloads extrêmement volumineux avec des tables étroites.
## use\_metadata\_cache
Paramètre obsolète, sans effet.
## use\_minimalistic\_checksums\_in\_zookeeper
Utilisez le format compact (quelques dizaines d’octets) pour les checksums des parts dans ZooKeeper au lieu
du format ordinaire (quelques dizaines de Ko). Avant de l’activer, vérifiez que toutes les répliques prennent en charge
ce nouveau format.
Méthode de stockage des en-têtes des data parts dans ZooKeeper. Si cette option est activée, ZooKeeper
stocke moins de données. Pour plus de détails, voir [ici](/fr/reference/settings/server-settings/settings#use_minimalistic_part_header_in_zookeeper).
## use\_primary\_key\_cache
Utilise le cache pour l’index primaire
au lieu de conserver tous les index en mémoire. Peut être utile pour de très grandes tables
## vertical\_merge\_algorithm\_min\_bytes\_to\_activate
Taille minimale (approximative), en octets, des parts en cours de fusion, non compressées, pour activer l’algorithme de fusion verticale.
## vertical\_merge\_algorithm\_min\_columns\_to\_activate
Nombre minimal de colonnes non PK pour activer l’algorithme de fusion verticale.
## vertical\_merge\_algorithm\_min\_rows\_to\_activate
Somme minimale (approximative) de lignes dans les
parties en cours de fusion pour activer l’algorithme de fusion verticale.
## vertical\_merge\_optimize\_lightweight\_delete
Si cette valeur est true, le lightweight delete est optimisé lors d’une fusion verticale.
## vertical\_merge\_optimize\_ttl\_delete
Si la valeur est true, la suppression des lignes expirées par TTL est optimisée lors de la fusion verticale. Au lieu de forcer
une fusion horizontale, le filtre TTL est évalué et transmis à l’algorithme de fusion, qui définit des indicateurs d’omission dans les sources de lignes.
## vertical\_merge\_remote\_filesystem\_prefetch
Si cette option est activée, le préchargement des données depuis le système de fichiers distant est utilisé pour la colonne suivante lors de la fusion
## wait\_for\_unique\_parts\_send\_before\_shutdown\_ms
Avant l'arrêt, la table attendra pendant la durée requise que les parties uniques
(qui n'existent que sur la réplique actuelle) soient récupérées par d'autres répliques (0 signifie
désactivé).
## write\_ahead\_log\_bytes\_to\_fsync
Paramètre obsolète, sans effet.
## write\_ahead\_log\_interval\_ms\_to\_fsync
Paramètre obsolète, sans effet.
## write\_ahead\_log\_max\_bytes
Paramètre obsolète, sans effet.
## write\_final\_mark
Réglage obsolète, sans effet.
## write\_marks\_for\_substreams\_in\_compact\_parts
Active l’écriture de marques pour chaque sous-flux au lieu d’une marque par colonne dans les parties compactes.
Cela permet de lire efficacement des sous-colonnes individuelles à partir de la partie de données.
Par exemple, la colonne `t Tuple(a String, b UInt32, c Array(Nullable(UInt32)))` est sérialisée dans les sous-flux suivants :
* `t.a` pour les données String de l’élément de tuple `a`
* `t.b` pour les données UInt32 de l’élément de tuple `b`
* `t.c.size0` pour les tailles de tableau de l’élément de tuple `c`
* `t.c.null` pour la carte de nullité des éléments du tableau imbriqué de l’élément de tuple `c`
* `t.c` pour les données UInt32 des éléments du tableau imbriqué de l’élément de tuple `c`
Lorsque ce paramètre est activé, une marque est écrite pour chacun de ces 5 sous-flux, ce qui signifie qu’il sera possible de lire
séparément les données de chaque sous-flux depuis le granule si nécessaire. Par exemple, si nous voulons lire la sous-colonne `t.c`, nous ne lirons que les données des
sous-flux `t.c.size0`, `t.c.null` et `t.c`, et non celles des sous-flux `t.a` et `t.b`. Lorsque ce paramètre est désactivé,
une marque est écrite uniquement pour la colonne de niveau supérieur `t`, ce qui signifie que nous lirons toujours l’ensemble des données de la colonne depuis le granule, même si nous n’avons besoin que des données de certains sous-flux.
## zero\_copy\_concurrent\_part\_removal\_max\_postpone\_ratio
Pourcentage maximal de parts de premier niveau dont la suppression peut être différée afin d'obtenir
des plages indépendantes plus petites. Il est recommandé de ne pas modifier ce paramètre.
## zero\_copy\_concurrent\_part\_removal\_max\_split\_times
Profondeur maximale de récursion pour scinder les plages indépendantes de parts obsolètes en
sous-plages plus petites. Il est recommandé de ne pas la modifier.
## zero\_copy\_merge\_mutation\_min\_parts\_size\_sleep\_before\_lock
Si la réplication zero copy est activée, attendre un délai aléatoire avant de tenter
de verrouiller, en fonction de la taille des parts pour une fusion ou une mutation
## zero\_copy\_merge\_mutation\_min\_parts\_size\_sleep\_no\_scale\_before\_lock
Si la réplication zero copy est activée, attendre un délai aléatoire pouvant aller jusqu’à 500 ms
avant de tenter d’acquérir le verrou pour une fusion ou une mutation.
## zookeeper\_session\_expiration\_check\_period
Période de vérification de l’expiration d’une session ZooKeeper, en secondes.
Valeurs possibles :
* Tout entier positif.