Paramètres des tables MergeTree

Paramètres des tables MergeTree dans system.merge_tree_settings

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 :

<merge_tree>
    <max_suspicious_broken_parts>5</max_suspicious_broken_parts>
</merge_tree>

Pour une table donnée :

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 :

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
• prefer_warmed_unmerged_parts_seconds
• 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 : 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.

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 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 est false.

Les index de saut exclus seront tout de même construits et stockés par une requête MATERIALIZE INDEX explicite ou lors des INSERT, selon le paramètre de session materialize_skip_indexes_on_insert.

Exemple :

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, 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

​

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 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 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 et 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 ou lors des fusions avec 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. Les projections sont également créées lors des INSERT avec 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 ou lors des INSERT.

Voir aussi 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 ou lors des INSERTs

​

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. 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 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 ). 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

<max_concurrent_queries>50</max_concurrent_queries>

​

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.

Valeurs possibles :

• Tout entier positif.

Le délai (en millisecondes) d’INSERT est calculé selon la formule :

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 :

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 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. Ce paramètre s’applique à une table particulière, contrairement au paramètre max_replicated_fetches_network_bandwidth_for_server, 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. Ce paramètre s’applique à une table particulière, contrairement au paramètre max_replicated_sends_network_bandwidth_for_server, 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

​

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.

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 / 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). 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.

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

<min_marks_to_honor_max_concurrent_queries>10</min_marks_to_honor_max_concurrent_queries>

​

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

​

non_replicated_deduplication_window

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

• 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

• 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_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. 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.

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

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

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 :

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 :

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 consultant 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 parts de s ont été stockées à l’aide de 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 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, 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 est mise en cache dans un ou plusieurs blocs (parts). Pour la déduplication des insertions, 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_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_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

​

shared_merge_tree_enable_keeper_parts_extra_data

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 <candidate partitions for mutations only (partitions that cannot be merged)>/<candidate partitions for mutations> 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.

​

use_minimalistic_part_header_in_zookeeper

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.

​

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.