> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentation sur OPTIMIZE # Instruction OPTIMIZE Cette requête tente de lancer une fusion non planifiée de parts de données pour des tables. Notez que nous déconseillons généralement l'utilisation de `OPTIMIZE TABLE ... FINAL` (voir cette [documentation](/fr/concepts/best-practices/avoid-optimize-final)), car son usage relève de l'administration et non des opérations quotidiennes. `OPTIMIZE` ne peut pas corriger l'erreur `Too many parts`. **Syntaxe** ```sql theme={null} OPTIMIZE TABLE [db.]name [ON CLUSTER cluster] [PARTITION partition | PARTITION ID 'partition_id'] [FINAL | FORCE] [DEDUPLICATE [BY expression]] ``` ```sql theme={null} OPTIMIZE TABLE [db.]name DRY RUN PARTS 'part_name1', 'part_name2' [, ...] [DEDUPLICATE [BY expression]] [CLEANUP] ``` La requête `OPTIMIZE` est prise en charge pour la famille [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree) (y compris les [vues matérialisées](/fr/reference/statements/create/view#materialized-view)) ainsi que pour les moteurs [Buffer](/fr/reference/engines/table-engines/special/buffer). Les autres moteurs de table ne sont pas pris en charge. Lorsque `OPTIMIZE` est utilisé avec la famille de moteurs de table [ReplicatedMergeTree](/fr/reference/engines/table-engines/mergetree-family/replication), ClickHouse crée une tâche de fusion et attend son exécution sur toutes les répliques (si le paramètre [alter\_sync](/fr/reference/settings/session-settings#alter_sync) est défini sur `2`) ou sur la réplique actuelle (si le paramètre [alter\_sync](/fr/reference/settings/session-settings#alter_sync) est défini sur `1`). * Si `OPTIMIZE` n’effectue pas de fusion pour quelque raison que ce soit, il n’en informe pas le client. Pour activer les notifications, utilisez le paramètre [optimize\_throw\_if\_noop](/fr/reference/settings/session-settings#optimize_throw_if_noop). * Si vous spécifiez un `PARTITION`, seule la partition indiquée est optimisée. [Comment définir l’expression de partition](/fr/reference/statements/alter/partition#how-to-set-partition-expression). * Si vous spécifiez `FINAL` ou `FORCE`, l’optimisation est effectuée même lorsque toutes les données se trouvent déjà dans une seule part. Vous pouvez contrôler ce comportement avec [optimize\_skip\_merged\_partitions](/fr/reference/settings/session-settings#optimize_skip_merged_partitions). De plus, la fusion est forcée même si des fusions concurrentes sont en cours. * Si vous spécifiez `DEDUPLICATE`, les lignes complètement identiques (sauf si une clause BY est spécifiée) seront dédupliquées (toutes les colonnes sont comparées) ; cela n’a de sens que pour le moteur MergeTree. Vous pouvez définir combien de temps (en secondes) attendre que les répliques inactives exécutent les requêtes `OPTIMIZE` à l’aide du paramètre [replication\_wait\_for\_inactive\_replica\_timeout](/fr/reference/settings/session-settings#replication_wait_for_inactive_replica_timeout). Si `alter_sync` est défini sur `2` et que certaines répliques restent inactives au-delà du délai spécifié par le paramètre `replication_wait_for_inactive_replica_timeout`, une exception `UNFINISHED` est levée.
## DRY RUN
La clause `DRY RUN` simule une fusion des parts spécifiées sans enregistrer le résultat. La part fusionnée est écrite dans un emplacement temporaire, validée, puis supprimée. Les parts d’origine et les données de la table restent inchangées. Cela est utile pour : * Tester la validité des fusions entre différentes versions de ClickHouse. * Reproduire de manière déterministe des bogues liés aux fusions. * Évaluer les performances des fusions. `DRY RUN` n’est pris en charge que pour les tables de la famille [MergeTree](/fr/reference/engines/table-engines/mergetree-family/mergetree). Le mot-clé `PARTS`, accompagné d’une liste de noms de parts, est requis. Toutes les parts spécifiées doivent exister, être actives et appartenir à la même partition. `DRY RUN` est incompatible avec `FINAL` et `PARTITION`. Il peut être combiné avec `DEDUPLICATE` (avec spécification facultative des colonnes) et `CLEANUP` (pour les tables `ReplacingMergeTree`). **Syntaxe** ```sql theme={null} OPTIMIZE TABLE [db.]name DRY RUN PARTS 'part_name1', 'part_name2' [, ...] [DEDUPLICATE [BY expression]] [CLEANUP] ``` Par défaut, la part fusionnée obtenue est validée d'une manière similaire à la requête [`CHECK TABLE`](/fr/reference/statements/check-table). Ce comportement est contrôlé par le paramètre [optimize\_dry\_run\_check\_part](/fr/reference/settings/session-settings#optimize_dry_run_check_part) (activé par défaut). Le désactiver permet d'ignorer cette validation, ce qui peut être utile pour évaluer les performances de la fusion elle-même. **Exemple** ```sql theme={null} CREATE TABLE dry_run_example (key UInt64, value String) ENGINE = MergeTree ORDER BY key; INSERT INTO dry_run_example VALUES (1, 'a'), (2, 'b'); INSERT INTO dry_run_example VALUES (1, 'c'), (4, 'd'); -- Simulate merging using two parts OPTIMIZE TABLE dry_run_example DRY RUN PARTS 'all_1_1_0', 'all_2_2_0'; -- Simulate merging with deduplication OPTIMIZE TABLE dry_run_example DRY RUN PARTS 'all_1_1_0', 'all_2_2_0' DEDUPLICATE; -- Parts and data remain unchanged after DRY RUN SELECT name, rows FROM system.parts WHERE database = currentDatabase() AND table = 'dry_run_example' AND active ORDER BY name; ``` ```response theme={null} ┌─name────────┬─rows─┐ │ all_1_1_0 │ 2 │ │ all_2_2_0 │ 2 │ └─────────────┴──────┘ ```
## Expression BY
Si vous souhaitez effectuer une déduplication sur un ensemble personnalisé de colonnes plutôt que sur l’ensemble des colonnes, vous pouvez spécifier explicitement une liste de colonnes ou utiliser n’importe quelle combinaison d’expressions [`*`](/fr/reference/statements/select/index#asterisk), [`COLUMNS`](/fr/reference/statements/select/index#select-clause) ou [`EXCEPT`](/fr/reference/statements/select/except_modifier). La liste de colonnes, qu’elle soit explicitement écrite ou implicitement développée, doit inclure toutes les colonnes spécifiées dans l’expression d’ordonnancement des lignes (à la fois la clé primaire et la clé de tri), ainsi que dans l’expression de partitionnement (clé de partitionnement). Notez que `*` se comporte exactement comme dans `SELECT` : les colonnes [MATERIALIZED](/fr/reference/statements/create/view#materialized-view) et [ALIAS](/fr/reference/statements/create/table#alias) ne sont pas utilisées lors de l’expansion. De plus, spécifier une liste vide de colonnes, écrire une expression qui aboutit à une liste vide de colonnes ou effectuer une déduplication sur une colonne `ALIAS` constitue une erreur. **Syntaxe** ```sql theme={null} OPTIMIZE TABLE table DEDUPLICATE; -- all columns OPTIMIZE TABLE table DEDUPLICATE BY *; -- excludes MATERIALIZED and ALIAS columns OPTIMIZE TABLE table DEDUPLICATE BY colX,colY,colZ; OPTIMIZE TABLE table DEDUPLICATE BY * EXCEPT colX; OPTIMIZE TABLE table DEDUPLICATE BY * EXCEPT (colX, colY); OPTIMIZE TABLE table DEDUPLICATE BY COLUMNS('column-matched-by-regex'); OPTIMIZE TABLE table DEDUPLICATE BY COLUMNS('column-matched-by-regex') EXCEPT colX; OPTIMIZE TABLE table DEDUPLICATE BY COLUMNS('column-matched-by-regex') EXCEPT (colX, colY); ``` **Exemples** Prenons la table suivante : ```sql title="Query" theme={null} CREATE TABLE example ( primary_key Int32, secondary_key Int32, value UInt32, partition_key UInt32, materialized_value UInt32 MATERIALIZED 12345, aliased_value UInt32 ALIAS 2, PRIMARY KEY primary_key ) ENGINE=MergeTree PARTITION BY partition_key ORDER BY (primary_key, secondary_key); ``` ```sql title="Query" theme={null} INSERT INTO example (primary_key, secondary_key, value, partition_key) VALUES (0, 0, 0, 0), (0, 0, 0, 0), (1, 1, 2, 2), (1, 1, 2, 3), (1, 1, 3, 3); ``` ```sql title="Query" theme={null} SELECT * FROM example; ``` ```sql title="Response" theme={null} ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 0 │ 0 │ 0 │ 0 │ │ 0 │ 0 │ 0 │ 0 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 2 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 3 │ │ 1 │ 1 │ 3 │ 3 │ └─────────────┴───────────────┴───────┴───────────────┘ ``` Tous les exemples suivants sont exécutés à partir de cet état, qui comporte 5 lignes.
#### `DEDUPLICATE`
Lorsqu’aucune colonne de déduplication n’est spécifiée, elles sont toutes prises en compte. La ligne n’est supprimée que si toutes les valeurs de toutes les colonnes sont égales aux valeurs correspondantes de la ligne précédente : ```sql title="Query" theme={null} OPTIMIZE TABLE example FINAL DEDUPLICATE; ``` ```sql title="Query" theme={null} SELECT * FROM example; ``` ```response title="Response" theme={null} ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 2 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 0 │ 0 │ 0 │ 0 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 3 │ │ 1 │ 1 │ 3 │ 3 │ └─────────────┴───────────────┴───────┴───────────────┘ ```
#### `DEDUPLICATE BY *`
Lorsque les colonnes sont spécifiées de manière implicite, la table est dédupliquée sur toutes les colonnes qui ne sont ni `ALIAS` ni `MATERIALIZED`. Dans la table ci-dessus, il s’agit des colonnes `primary_key`, `secondary_key`, `value` et `partition_key` : ```sql title="Query" theme={null} OPTIMIZE TABLE example FINAL DEDUPLICATE BY *; ``` ```sql title="Query" theme={null} SELECT * FROM example; ``` ```response title="Response" theme={null} ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 2 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 0 │ 0 │ 0 │ 0 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 3 │ │ 1 │ 1 │ 3 │ 3 │ └─────────────┴───────────────┴───────┴───────────────┘ ```
#### `DEDUPLICATE BY * EXCEPT`
Déduplique sur toutes les colonnes qui ne sont ni `ALIAS` ni `MATERIALIZED`, à l’exclusion explicite de `value` : les colonnes `primary_key`, `secondary_key` et `partition_key`. ```sql title="Query" theme={null} OPTIMIZE TABLE example FINAL DEDUPLICATE BY * EXCEPT value; ``` ```sql title="Query" theme={null} SELECT * FROM example; ``` ```response title="Response" theme={null} ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 2 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 0 │ 0 │ 0 │ 0 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 3 │ └─────────────┴───────────────┴───────┴───────────────┘ ```
#### `DEDUPLICATE BY `
Dédupliquez explicitement à l’aide des colonnes `primary_key`, `secondary_key` et `partition_key` : ```sql title="Query" theme={null} OPTIMIZE TABLE example FINAL DEDUPLICATE BY primary_key, secondary_key, partition_key; ``` ```sql title="Query" theme={null} SELECT * FROM example; ``` ```response title="Response" theme={null} ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 2 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 0 │ 0 │ 0 │ 0 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 3 │ └─────────────┴───────────────┴───────┴───────────────┘ ```
#### `DEDUPLICATE BY COLUMNS()`
Dédupliquer selon toutes les colonnes correspondant à une expression régulière : les colonnes `primary_key`, `secondary_key` et `partition_key` : ```sql title="Query" theme={null} OPTIMIZE TABLE example FINAL DEDUPLICATE BY COLUMNS('.*_key'); ``` ```sql title="Query" theme={null} SELECT * FROM example; ``` ```response title="Response" theme={null} ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 0 │ 0 │ 0 │ 0 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 2 │ └─────────────┴───────────────┴───────┴───────────────┘ ┌─primary_key─┬─secondary_key─┬─value─┬─partition_key─┐ │ 1 │ 1 │ 2 │ 3 │ └─────────────┴───────────────┴───────┴───────────────┘ ```