Moteur de table CoalescingMergeTree

Ce moteur hérite de MergeTree. La principale différence réside dans la manière dont les parties de données sont fusionnées : pour les tables CoalescingMergeTree, ClickHouse remplace toutes les lignes ayant la même clé primaire (ou, plus précisément, la même clé de tri) par une seule ligne contenant, pour chaque colonne, la dernière valeur non-NULL.

Cela permet des upserts au niveau des colonnes, ce qui signifie que vous pouvez mettre à jour uniquement certaines colonnes plutôt que des lignes entières.

CoalescingMergeTree est conçu pour être utilisé avec des types Nullable dans les colonnes qui ne font pas partie de la clé. Si les colonnes ne sont pas Nullable, le comportement est le même qu'avec ReplacingMergeTree.

CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
    name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1],
    name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2],
    ...
) ENGINE = CoalescingMergeTree([columns])
[PARTITION BY expr]
[ORDER BY expr]
[SAMPLE BY expr]
[SETTINGS name=value, ...]

Pour une description des paramètres de la requête, consultez la description de la requête.

columns - Facultatif. Un tuple contenant les noms des colonnes dont les valeurs seront fusionnées. Les colonnes fournies ne doivent pas figurer dans la partition ni dans la clé de tri. Si columns n’est pas spécifié, ClickHouse fusionne les valeurs de toutes les colonnes qui ne figurent pas dans la clé de tri.

Lors de la création d’une table CoalescingMergeTree, les mêmes clauses sont requises que pour la création d’une table MergeTree.

CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
    name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1],
    name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2],
    ...
) ENGINE [=] CoalescingMergeTree(date-column [, sampling_expression], (primary, key), index_granularity, [columns])

Prenons la table suivante :

CREATE TABLE test_table
(
    key UInt64,
    value_int Nullable(UInt32),
    value_string Nullable(String),
    value_date Nullable(Date)
)
ENGINE = CoalescingMergeTree()
ORDER BY key

Insérez-y des données :

INSERT INTO test_table VALUES(1, NULL, NULL, '2025-01-01'), (2, 10, 'test', NULL);
INSERT INTO test_table VALUES(1, 42, 'win', '2025-02-01');
INSERT INTO test_table(key, value_date) VALUES(2, '2025-02-01');

Le résultat ressemblera à ceci :

SELECT * FROM test_table ORDER BY key;

┌─key─┬─value_int─┬─value_string─┬─value_date─┐
│   1 │        42 │ win          │ 2025-02-01 │
│   1 │      ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ         │ 2025-01-01 │
│   2 │      ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ         │ 2025-02-01 │
│   2 │        10 │ test         │       ᴺᵁᴸᴸ │
└─────┴───────────┴──────────────┴────────────┘

Requête recommandée pour obtenir un résultat correct et définitif :

SELECT * FROM test_table FINAL ORDER BY key;

┌─key─┬─value_int─┬─value_string─┬─value_date─┐
│   1 │        42 │ win          │ 2025-02-01 │
│   2 │        10 │ test         │ 2025-02-01 │
└─────┴───────────┴──────────────┴────────────┘

L’utilisation du modificateur FINAL force ClickHouse à appliquer la logique de fusion à l’exécution de la requête, ce qui garantit l’obtention de la valeur « la plus récente », correcte et consolidée, pour chaque colonne. C’est la méthode la plus sûre et la plus précise pour interroger une table CoalescingMergeTree.

Lorsque le paramètre allow_tuple_element_aggregation est activé, les colonnes Tuple sont récursivement aplaties afin que chaque élément terminal participe indépendamment à la coalescence. Cela vous permet de stocker plusieurs champs dans une seule colonne Tuple et de les faire coalescer élément par élément lors des fusions — chaque sous-colonne Nullable conserve indépendamment la dernière valeur non-NULL.

Les mêmes règles s'appliquent aux sous-colonnes aplaties qu'aux colonnes ordinaires :

• Les sous-colonnes appartenant à un Tuple dans la clé de tri ou la clé de partition sont exclues de la coalescence.
• Si columns est spécifié, seules les sous-colonnes des colonnes Tuple répertoriées sont coalescées.

CREATE TABLE coalescing_tuples
(
    key UInt64,
    data Tuple(
        value_a Nullable(UInt64),
        value_b Nullable(String),
        nested Tuple(
            value_c Nullable(UInt64)
        )
    )
) ENGINE = CoalescingMergeTree()
ORDER BY key
SETTINGS allow_tuple_element_aggregation = 1;

INSERT INTO coalescing_tuples VALUES (1, (100, NULL, (NULL)));
INSERT INTO coalescing_tuples VALUES (1, (NULL, 'hello', (42)));

SELECT key, data.value_a, data.value_b, data.nested.value_c FROM coalescing_tuples FINAL;

┌─key─┬─data.value_a─┬─data.value_b─┬─data.nested.value_c─┐
│   1 │          100 │ hello        │                  42 │
└─────┴──────────────┴──────────────┴─────────────────────┘