> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Autres paramètres de table MergeTree
> Paramètres des tables MergeTree de ClickHouse dans le groupe généré « Autres ».
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
return
Type
{type}
Par défaut
{default_value}
{changeable_without_restart &&
Modifiable sans redémarrage
}
{changeable_without_restart &&
{changeable_without_restart}
}
;
};
export const ExperimentalBadge = () => {
return ;
};
Ces paramètres sont disponibles dans [system.merge\_tree\_settings](/docs/fr/reference/system-tables/merge_tree_settings) et sont générés automatiquement à partir du code source de ClickHouse.
## adaptive\_write\_buffer\_initial\_size
Taille initiale d’un tampon d’écriture adaptatif
## add\_implicit\_sign\_column\_constraint\_for\_collapsing\_engine
Si la 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`).
## alter\_column\_secondary\_index\_mode
Définit s’il faut autoriser les commandes `ALTER` qui modifient des colonnes couvertes par des indices secondaires, ainsi que l’action à entreprendre si elles sont autorisées. Par défaut, ces commandes `ALTER` sont autorisées et les indices sont reconstruits.
Valeurs possibles :
* `rebuild` (par défaut) : Reconstruit tous les indices secondaires affectés par la colonne dans la commande `ALTER`.
* `throw` : Empêche tout `ALTER` de colonnes couvertes par des indices secondaires **explicites** en levant une exception. Les indices implicites ne sont pas soumis à cette restriction et seront reconstruits.
* `drop` : Supprime les indices secondaires dépendants. Les nouvelles parts n’auront pas ces indices, et il faudra exécuter `MATERIALIZE INDEX` pour les recréer.
* `compatibility` : Reproduit le comportement d’origine : `throw` sur `ALTER ... MODIFY COLUMN` et `rebuild` sur `ALTER ... UPDATE/DELETE`.
* `ignore` : Destiné à un usage expert. Laisse les indices dans un état incohérent, ce qui peut entraîner des résultats de la requête incorrects.
## apply\_patches\_on\_merge
Si true, les patch parts sont appliquées lors des fusions
## assign\_part\_uuids
Lorsqu’il est activé, un identifiant unique de part est attribué à chaque nouvelle part.
Avant de l’activer, vérifiez que toutes les répliques prennent en charge les UUID de version 4.
## auto\_statistics\_types
Liste de types de statistiques séparés par des virgules, à calculer automatiquement sur toutes les colonnes appropriées.
Types de statistiques pris en charge : basic, tdigest, countmin, uniq, uniq\_v2.
Le type de statistiques `minmax` est obsolète : il s'agit d'un sous-ensemble de `basic`, qu'il convient d'utiliser à la place.
## background\_task\_preferred\_step\_execution\_time\_ms
Temps cible d’exécution d’une étape de fusion ou de mutation. Peut être dépassé si
une étape prend plus de temps
## clean\_deleted\_rows
Paramètre obsolète, sans effet
## clone\_replica\_zookeeper\_create\_get\_part\_batch\_size
Taille du lot pour les requêtes multi-create get-part de ZooKeeper lors du clonage d'une réplique.
## compatibility\_allow\_sampling\_expression\_not\_in\_primary\_key
Autorise la création d’une table dont l’expression d’échantillonnage ne figure pas dans la clé primaire. Cela n’est nécessaire que pour autoriser temporairement l’exécution du serveur avec des tables incorrectes, à des fins de rétrocompatibilité.
## compute\_exact\_num\_defaults\_for\_sparse\_columns
Calcule le nombre exact de valeurs par défaut pour chaque colonne lors des insertions et
des fusions, au lieu de l’estimation par échantillonnage, moins coûteuse, utilisée pour choisir la
sérialisation creuse. Ce paramètre est requis par `optimize_trivial_count_with_sparsity_filter`,
qui utilise le compteur `num_defaults` persisté (les colonnes `Nullable`
nécessitent également `nullable_serialization_version = 'allow_sparse'`).
Le laisser désactivé permet de conserver des insertions/fusions aussi rapides qu’auparavant ; l’activer
ajoute un parcours en O(rows) pour chaque colonne éligible à la sparsité.
## deduplicate\_merge\_projection\_mode
Indique s’il faut autoriser la création de projections pour une table utilisant
un MergeTree non classique, c’est-à-dire autre que (Replicated, Shared)
MergeTree. L’option `ignore` est uniquement prévue pour des raisons de
compatibilité et peut entraîner des résultats incorrects. Sinon, si cela est
autorisé, ce paramètre définit l’action à effectuer lors de la fusion des
projections : les supprimer ou les reconstruire. Le MergeTree classique ignore
donc ce paramètre. Ce paramètre contrôle également `OPTIMIZE DEDUPLICATE`, mais
il s’applique à tous les membres de la famille MergeTree. Comme l’option
`lightweight_mutation_projection_mode`, il s’agit également d’un paramètre au
niveau des parts.
Valeurs possibles :
* `ignore`
* `throw`
* `drop`
* `rebuild`
## deduplication\_hashes\_cache\_update\_wait\_ms
Durée pendant laquelle chaque itération d’insertion attend que le cache en mémoire `deduplication_hashes` soit actualisé vers une
version plus récente avant de vérifier à nouveau s’il contient des blocs déjà insérés. Le cache reflète le
répertoire `deduplication_hashes` dans ClickHouse Keeper afin que les insertions puissent détecter les doublons sans
aller-retour vers Keeper.
## default\_compression\_codec
Indique le codec de compression par défaut à utiliser si aucun n’est défini pour une colonne donnée dans la définition de la table.
Ordre de sélection du codec de compression pour une colonne :
1. Codec de compression défini pour la colonne dans la définition de la 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éfinie).
## disk
Nom du disque de stockage. Peut être indiqué à la place de la storage policy.
## dynamic\_serialization\_version
Version de sérialisation du type de données Dynamic. Requise pour la compatibilité.
Valeurs possibles :
* `v1`
* `v2`
* `v3`
## 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 entre la table source et la table de destination. Sinon, la table de destination
peut contenir un surensemble des index et projections de la table source.
## 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, tandis que les autres répliques attendent pendant cette durée maximale pour
télécharger le résultat au lieu d'effectuer les fusions localement. Si la réplique choisie
ne termine pas la fusion dans ce délai, le comportement standard est rétabli.
Valeurs possibles :
* Tout entier positif.
## finished\_mutations\_to\_keep
Nombre d’enregistrements sur les mutations terminées à conserver. Si la valeur est zéro, les
conserver tous.
## force\_read\_through\_cache\_for\_merges
Forcer la lecture via le cache du système de fichiers pour les opérations de fusion
## initialization\_retry\_period
Délai avant une nouvelle tentative d'initialisation de la table, en secondes.
## kill\_threads
Paramètre obsolète, sans effet
## lightweight\_mutation\_projection\_mode
Par défaut, le `DELETE` lightweight 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 deletes 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 puisqu'aucune projection n'est attachée. `rebuild` reconstruira la
projection, ce qui peut affecter les performances de la requête en cours, mais
peut 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 dans la part 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](/docs/fr/reference/settings/merge-tree-settings/exclude#exclude_deleted_rows_for_part_size_in_merge),
le nombre de lignes supprimées dans les data parts existantes sera calculé lors du 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](/docs/fr/reference/settings/merge-tree-settings/exclude#exclude_deleted_rows_for_part_size_in_merge)
## lock\_acquire\_timeout\_for\_background\_operations
Pour les opérations en arrière-plan telles que les fusions, les mutations, etc. Nombre de secondes à attendre avant l'échec de l'acquisition des verrous de table.
## mutation\_workload
Utilisé pour réguler l’utilisation et le partage des ressources entre les mutations et
d’autres workloads. La valeur spécifiée est utilisée comme valeur du paramètre `workload` pour les
mutations d’arrière-plan de cette table. Si elle n’est pas spécifiée (chaîne vide), le
paramètre du serveur `mutation_workload` est utilisé à la place.
**Voir aussi**
* [Planification des workloads](/docs/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](/docs/fr/reference/engines/table-engines/mergetree-family/mergetree) non répliquée
pour lesquels les sommes de hachage sont stockées afin de détecter les doublons.
Valeurs possibles :
* Tout entier positif.
* `0` (désactive la déduplication).
Un mécanisme de déduplication est utilisé, similaire à celui des tables répliquées (voir
le paramètre [replicated\_deduplication\_window](/docs/fr/reference/settings/merge-tree-settings/replicated-deduplication-window#replicated_deduplication_window)) : la somme de hachage de déduplication
couvre l’intégralité du bloc inséré. Les sommes de hachage sont écrites dans
un fichier local sur un disque plutôt que dans ClickHouse Keeper.
## notify\_newest\_block\_number
Notifie le numéro du bloc le plus récent à SharedJoin ou SharedSet. Disponible 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 — Autorise `Nullable(T)` à utiliser un encodage clairsemé.
## object\_serialization\_version
Version de sérialisation pour le type de données JSON. Requise pour la compatibilité.
Valeurs possibles :
* `v1`
* `v2`
* `v3`
Seule la version `v3` permet de modifier la version de sérialisation des données partagées.
## 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 inopiné 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. Pendant un certain temps, celles-ci n'existent donc que
dans la RAM du serveur (cache de l'OS). Si le serveur redémarre inopiné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 de nouveau plus tard. 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 (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 les tests,
une valeur de 480 secondes a été retenue pour `old_parts_lifetime`, durée pendant laquelle il est
garanti qu'une nouvelle part sera écrite sur disque.
## optimize\_row\_order
Détermine si l’ordre des lignes doit être optimisé lors des insertions afin d’améliorer la
compressibilité de la nouvelle part de la table.
N’a d’effet que pour les tables ordinaires à moteur MergeTree. N’a aucun effet pour les
tables spécialisées de la famille MergeTree (par ex. CollapsingMergeTree).
Les tables MergeTree sont (facultativement) compressées à l’aide de [codecs de compression](/docs/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 lorsque les données présentent des motifs. De longues séries 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 séries de valeurs égales
dans les colonnes de la nouvelle part de la table.
Autrement dit, un petit nombre de séries de valeurs égales signifie que les séries individuelles
sont longues et se compressent bien.
Trouver l’ordre optimal des lignes est irréalisable 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 qu’une même table (ou part de table) reste équivalente même si l’ordre des lignes diffère.
Cette liberté de réorganiser les lignes est limitée 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 par les colonnes `C1`, `C2`, ... `Cn` ([index clusterisé](https://en.wikipedia.org/wiki/Database_index#Clustered)).
Par conséquent, les lignes ne peuvent être réorganisées qu’au sein de « classes d’équivalence »,
c’est-à-dire d’ensembles de lignes qui ont les mêmes valeurs dans leurs colonnes de clé primaire.
L’idée est que les clés primaires à cardinalité élevée, 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
grandes classes d’équivalence. Une table sans clé primaire représente le cas extrême
d’une seule classe d’équivalence qui couvre toutes les lignes.
Moins les classes d’équivalence sont nombreuses et plus elles sont grandes, plus la marge
de manœuvre pour réordonner les lignes est importante.
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 de chaque classe d’équivalence par cardinalité croissante
des colonnes ne faisant pas partie de la clé primaire.
Elle comporte 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 (ou, le plus souvent, 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 ce paramètre est activé, les opérations d’insert entraînent des coûts CPU supplémentaires pour analyser et
optimiser l’ordre des lignes des nouvelles données. Les INSERTs 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 mieux pour les tables sans clé primaire ou avec une clé primaire à faible cardinalité,
c’est-à-dire une table avec seulement quelques valeurs distinctes de clé primaire.
Les clés primaires à cardinalité élevée, par ex. celles impliquant des colonnes d’horodatage de type
`DateTime64`, ne devraient pas tirer parti de ce paramètre.
## packed\_skip\_index\_max\_bytes
.idx2 \/ .mrk2. La décision est prise pour chaque sous-flux au moment de l’écriture."}]}]} />
Seuil (en octets sérialisés sur disque, c.-à-d. après la compression et la chaîne de hachage
du sous-flux) en dessous duquel un sous-flux d’index de saut est regroupé dans une
archive unique `skp_idx.packed` par part au lieu d’être écrit dans un fichier
`skp_idx_.idx2` / `.mrk2` distinct. Les sous-flux plus volumineux conservent le
schéma legacy, avec un fichier par sous-flux. 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 indices
(par ex. `minmax`) empaquetés et de plus gros (par ex. un `bloom_filter` volumineux) stockés
dans des fichiers distincts. Définissez cette valeur sur 0 pour désactiver entièrement l’empaquetage
(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 ; les deux sont mis en mémoire tampon jusqu’au seuil avant qu’il soit
décidé ou non de les déverser sur disque. Ainsi, le pic de mémoire pendant l’écriture évolue selon
`2 * packed_skip_index_max_bytes * (nombre de sous-flux qui restent
en dessous du seuil)`.
Les indices full-text ne sont pas pris en charge par ce paramètre et ne sont jamais empaquetés.
L’empaquetage réduit la pression sur les inodes lorsque de nombreux indices 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 de manière transparente les sous-flux empaquetés qu’il contient. La modification
de ce paramètre n’affecte que les parts nouvellement écrites ; les parts existantes
conservent le schéma qu’elles avaient au moment de l’écriture.
## part\_minmax\_index\_columns
Sélectionne les colonnes couvertes par l’index min-max de chaque part. Chaque valeur active un groupe supplémentaire de colonnes par rapport à la précédente.
Valeurs possibles :
* `partition_key_only` — seules les colonnes de la clé de partition sont suivies.
* `with_block_number_offset` — les colonnes de la clé de partition, ainsi que les colonnes virtuelles persistées `_block_number` et `_block_offset`. Permet un élagage au niveau des parts à l’aide de ces colonnes.
## 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 premier niveau 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 entraîne le stockage de la colonne à l’aide de sérialisations
creuses.
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
creuse, 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 en utilisant la sérialisation complète ordinaire.
Valeurs possibles :
* Float entre `0` et `1` pour activer la sérialisation creuse
* `1.0` (ou plus) si vous ne souhaitez pas utiliser la sérialisation creuse
**Exemple**
Notez que la colonne `s` de la table suivante contient une chaîne vide dans 95 % des
lignes. Dans `my_regular_table`, nous n’utilisons pas de sérialisation creuse, 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 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 affichant 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 parties de `s` ont été stockées avec 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 d'attente minimal avant de tenter à nouveau de
réduire les parts bloquantes lorsqu'aucune plage n'a été supprimée ni remplacée. Une
valeur 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
## replace\_long\_file\_name\_to\_hash
Si le nom du fichier de la colonne est trop long (plus de 'max\_file\_name\_length'
octets), le remplacer 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`
## search\_orphaned\_parts\_disks
ClickHouse parcourt tous les disques à la recherche de parts orphelines lors de toute opération ATTACH ou CREATE table
afin d’éviter de passer à côté de data parts sur des disques non définis (non inclus dans la storage policy).
Les parts orphelines résultent d’une reconfiguration du stockage potentiellement non sûre, par exemple si un disque a été exclu de la storage policy.
Ce paramètre limite le périmètre des disques à parcourir 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`, permettant des versions de sérialisation par type.
Cela permet à des paramètres comme `string_serialization_version` de prendre effet.
Lors de mises à niveau progressives, définissez cette valeur sur `basic` afin que les nouveaux serveurs produisent des
data parts compatibles avec les anciens serveurs. Une fois la mise à niveau terminée,
basculez vers `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 comportent des points et 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 disque (par ex. `n.size0`),
et la taille de leurs tableaux est vérifiée pour s’assurer qu’elle est identique lors de l’INSERT.
Lorsqu’il est désactivé, chaque colonne Array dispose de son propre fichier d’offsets, les noms comportant des points n’ont pas de
sémantique particulière, et une colonne scalaire peut coexister avec des colonnes Array dont les noms comportent des points et 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.
## 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.
`simultaneous_parts_removal_limit` défini sur `0` signifie qu'il n'y a pas de limite.
## storage\_policy
Nom de la politique de stockage sur disque
## string\_serialization\_version
Contrôle le format de sérialisation des colonnes `String` de premier niveau.
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 premier niveau sont sérialisées avec une
sous-colonne `.size` distincte qui stocke les longueurs des chaînes, au lieu de les inclure inline. 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 exemple, dans `Nullable`, `LowCardinality`, `Array` ou `Map`)
ne sont pas affectés, sauf lorsqu'ils apparaissent dans un `Tuple`.
Valeurs possibles :
* `single_stream` — Format de sérialisation standard avec tailles inline.
* `with_size_stream` — Flux de tailles distinct pour les colonnes `String` de premier niveau.
## temporary\_directories\_lifetime
Nombre de secondes pendant lesquelles conserver les répertoires tmp\_. Vous ne devez pas réduire cette valeur,
car les fusions et les mutations risquent de ne pas pouvoir fonctionner avec une valeur trop faible de ce
paramètre.
## 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 part recompressée auprès de la réplique à laquelle
cette fusion avec recompression a été attribuée.
Comme la recompression est lente dans la plupart des cas, nous ne lançons pas de fusion avec
recompression avant l’expiration de ce délai et essayons de récupérer la part recompressée auprès de la
réplique à laquelle cette fusion avec recompression a été attribuée.
Valeurs possibles :
* Tout entier positif.
## ttl\_only\_drop\_parts
Détermine si les parts de données 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 ayant
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`.
## wait\_for\_unique\_parts\_send\_before\_shutdown\_ms
Avant l’arrêt, la table attendra pendant le temps nécessaire à la récupération, par d’autres répliques, des parts uniques
(présentes uniquement sur la réplique actuelle) (0 signifie
désactivé).
## zookeeper\_session\_expiration\_check\_period
Période de vérification de l’expiration de la session ZooKeeper, en secondes.
Valeurs possibles :
* Tout entier positif.