Autres paramètres de table MergeTree - ClickHouse Documentation

Ces paramètres sont disponibles dans system.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 :

Codec de compression défini pour la colonne dans la définition de la table
Codec de compression défini dans default_compression_codec (ce paramètre)
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, 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

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

non_replicated_deduplication_window

Le nombre de blocs insérés les plus récents dans la table 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) : 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. 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. 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

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_<name>.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 :

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 :

SELECT table, name, data_compressed_bytes, data_uncompressed_bytes FROM system.columns
WHERE table LIKE 'my_%_table';

┌─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 :

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 :

┌─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.

Dernière modification le 24 juillet 2026

Paramètres des formatsParamètres contrôlant les formats d’entrée et de sortie.

​adaptive_write_buffer_initial_size

​add_implicit_sign_column_constraint_for_collapsing_engine

​alter_column_secondary_index_mode

​apply_patches_on_merge

​assign_part_uuids

​auto_statistics_types

​background_task_preferred_step_execution_time_ms

​clean_deleted_rows

​clone_replica_zookeeper_create_get_part_batch_size

​compatibility_allow_sampling_expression_not_in_primary_key

​compute_exact_num_defaults_for_sparse_columns

​deduplicate_merge_projection_mode

​deduplication_hashes_cache_update_wait_ms

​default_compression_codec

​disk

​dynamic_serialization_version

​enforce_index_structure_match_on_partition_manipulation

​execute_merges_on_single_replica_time_threshold

​finished_mutations_to_keep

​force_read_through_cache_for_merges

​initialization_retry_period

​kill_threads

​lightweight_mutation_projection_mode

​load_existing_rows_count_for_old_parts

​lock_acquire_timeout_for_background_operations

​mutation_workload

​non_replicated_deduplication_window

​notify_newest_block_number

​nullable_serialization_version

​object_serialization_version

​old_parts_lifetime

​optimize_row_order

​packed_skip_index_max_bytes

​part_minmax_index_columns

​propagate_types_serialization_versions_to_nested_types

​ratio_of_defaults_for_sparse_serialization

​reduce_blocking_parts_sleep_ms

​replace_long_file_name_to_hash

​replicated_can_become_leader

​search_orphaned_parts_disks

​serialization_info_version

​share_nested_offsets

​simultaneous_parts_removal_limit

​storage_policy

​string_serialization_version

​temporary_directories_lifetime

​try_fetch_recompressed_part_timeout

​ttl_only_drop_parts

​wait_for_unique_parts_send_before_shutdown_ms

​zookeeper_session_expiration_check_period