paramètres de session optimize_*

Ces paramètres sont disponibles dans system.settings et sont générés automatiquement à partir du code source.

optimize_aggregators_of_group_by_keys

Élimine les agrégateurs min/max/any/anyLast des clés GROUP BY dans la clause SELECT

optimize_append_index

Utilisez les contraintes pour ajouter une condition d’index. La valeur par défaut est false. Valeurs possibles :

true, false

optimize_arithmetic_operations_in_aggregate_functions

Extraire les opérations arithmétiques des fonctions d’agrégation

optimize_const_name_size

Remplace les grandes constantes par un scalaire et utilise un hachage comme nom (la taille est estimée d’après la longueur du nom). Valeurs possibles :

entier positif - longueur maximale du nom,
0 — toujours,
entier négatif - jamais.

optimize_count_from_files

Active ou désactive l’optimisation du comptage du nombre de lignes dans des fichiers de différents formats d’entrée. Elle s’applique aux fonctions de table/moteurs file/s3/url/hdfs/azureBlobStorage. Valeurs possibles :

0 — Optimisation désactivée.
1 — Optimisation activée.

optimize_dictget_tuple_element

Réécrit tupleElement(dictGet('dict', ('a', 'b', 'c'), key), 2) en dictGet('dict', 'b', key) afin d’éviter de récupérer des attributs de dictionnaire inutiles. Prend en charge l’accès positionnel (.1, .2, …) et nommé (.b), et s’applique également à dictGetOrDefault lorsque l’argument par défaut est un tuple constant ou un tuple(...) de constantes.

optimize_distinct_in_order

Active l’optimisation de DISTINCT si certaines colonnes de DISTINCT constituent un préfixe du tri. Par exemple, un préfixe de la clé de tri dans MergeTree ou de l’instruction ORDER BY

optimize_distributed_group_by_sharding_key

Optimise les requêtes GROUP BY sharding_key en évitant une agrégation coûteuse sur le serveur initiateur (ce qui réduit la consommation mémoire de la requête sur ce serveur). Les types de requêtes suivants sont pris en charge (ainsi que toutes leurs combinaisons) :

SELECT DISTINCT [..., ]sharding_key[, ...] FROM dist
SELECT ... FROM dist GROUP BY sharding_key[, ...]
SELECT ... FROM dist GROUP BY sharding_key[, ...] ORDER BY x
SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1
SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1 BY x

Les types de requêtes suivants ne sont pas pris en charge (la prise en charge de certains d’entre eux pourra être ajoutée ultérieurement) :

SELECT ... GROUP BY sharding_key[, ...] WITH TOTALS
SELECT ... GROUP BY sharding_key[, ...] WITH ROLLUP
SELECT ... GROUP BY sharding_key[, ...] WITH CUBE
SELECT ... GROUP BY sharding_key[, ...] SETTINGS extremes=1

Valeurs possibles :

0 — Désactivé.
1 — Activé.

Voir aussi :

À l’heure actuelle, cela nécessite optimize_skip_unused_shards (la raison est qu’à terme, ce paramètre pourrait être activé par défaut, et il ne fonctionnera correctement que si les données ont été insérées via une table Distributed, c’est-à-dire si elles sont distribuées selon sharding_key).

optimize_dry_run_check_part

Lorsqu’il est activé, OPTIMIZE ... DRY RUN valide la partie fusionnée obtenue à l’aide de checkDataPart. Si cette vérification échoue, une exception est levée.

optimize_empty_string_comparisons

Convertit des expressions telles que col = ” ou ” = col en empty(col), et col != ” ou ” != col en notEmpty(col), uniquement lorsque col est de type String ou FixedString.

optimize_extract_common_expressions

Permet d’extraire des expressions communes de disjonctions dans les expressions WHERE, PREWHERE, ON, HAVING et QUALIFY. Une expression logique comme (A AND B) OR (A AND C) peut être réécrite en A AND (B OR C), ce qui peut aider à utiliser :

les indices dans des expressions de filtrage simples
l’optimisation des CROSS JOIN en INNER JOIN

optimize_functions_to_subcolumns

Active ou désactive l’optimisation qui consiste à transformer certaines fonctions en lecture de sous-colonnes. Cela réduit la quantité de données à lire. Ces fonctions peuvent être transformées :

length pour lire la sous-colonne size0.
empty pour lire la sous-colonne size0.
notEmpty pour lire la sous-colonne size0.
isNull pour lire la sous-colonne null.
isNotNull pour lire la sous-colonne null.
count pour lire la sous-colonne null.
mapKeys pour lire la sous-colonne keys.
mapValues pour lire la sous-colonne values.
has et notHas pour Map afin de lire la sous-colonne keys.
mapContainsKeyLike pour lire la sous-colonne keys.
mapContainsValueLike pour lire la sous-colonne values.

Valeurs possibles :

0 — Optimisation désactivée.
1 — Optimisation activée.

optimize_inverse_dictionary_lookup

Évite les recherches inverses répétées dans le dictionnaire en effectuant des recherches plus rapides dans un ensemble précalculé de valeurs possibles pour la clé.

optimize_multiif_to_if

Remplace « multiIf » comportant une seule condition par « if ».

optimize_mutations_with_partition_pruning

Lorsque ce paramètre est activé, ClickHouse détecte automatiquement les conditions portant sur la clé de partitionnement dans la clause WHERE des mutations ALTER TABLE UPDATE/DELETE et des instructions lightweight UPDATE/DELETE sur les tables de la famille ReplicatedMergeTree, et ne traite que les partitions concernées au lieu de toutes les partitions. Cet élagage automatique ne s’applique actuellement qu’aux tables répliquées. Sur les tables MergeTree non répliquées, utilisez une clause IN PARTITION explicite pour limiter une mutation à des partitions précises. Valeurs possibles :

0 — Désactivé. Les mutations et les lightweight updates traitent toutes les partitions.
1 — Activé. Les mutations et les lightweight updates ne traitent que les partitions correspondant à la condition WHERE.

optimize_normalize_count_variants

Réécrit par défaut en count() les fonctions d’agrégation sémantiquement équivalentes à count().

optimize_on_insert

Active ou désactive la transformation des données avant l’insertion, comme si une fusion avait été effectuée sur ce bloc (selon le moteur de table). Valeurs possibles :

0 — Désactivé.
1 — Activé.

Exemple Différence entre l’état activé et désactivé : Requête :

SET optimize_on_insert = 1;

CREATE TABLE test1 (`FirstTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY FirstTable;

INSERT INTO test1 SELECT number % 2 FROM numbers(5);

SELECT * FROM test1;

SET optimize_on_insert = 0;

CREATE TABLE test2 (`SecondTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY SecondTable;

INSERT INTO test2 SELECT number % 2 FROM numbers(5);

SELECT * FROM test2;

Résultat :

┌─FirstTable─┐
│          0 │
│          1 │
└────────────┘

┌─SecondTable─┐
│           0 │
│           0 │
│           0 │
│           1 │
│           1 │
└─────────────┘

Notez que ce paramètre influence le comportement des vues matérialisées.

optimize_prewhere_after_pushdown

Exécute un second passage de promotion de PREWHERE après que des optimisations ultérieures du plan de requête ont pu ajouter des filtres supplémentaires au-dessus d’une étape de lecture MergeTree (par ex. pushdown de prédicats via JOIN, réécritures de projection). Lorsqu’un PREWHERE existe déjà, le nouveau filtre y est fusionné avec AND au lieu de rester une étape de filtrage distincte.

optimize_qbit_distance_function_reads

Remplace les fonctions de distance appliquées au type de données QBit par des fonctions équivalentes qui ne lisent dans le stockage que les colonnes nécessaires au calcul.

optimize_read_in_order

Active l’optimisation ORDER BY dans les requêtes SELECT lors de la lecture des données à partir des tables MergeTree. Valeurs possibles :

0 — l’optimisation ORDER BY est désactivée.
1 — l’optimisation ORDER BY est activée.

Voir aussi

Clause ORDER BY

optimize_read_in_reverse_order_final

Active la lecture des données dans l’ordre inverse de la clé de tri dans les requêtes SELECT avec le modificateur FINAL à partir de tables ReplacingMergeTree. Ne prend effet que si optimize_read_in_order est également activé. Valeurs possibles :

0 — La lecture dans l’ordre inverse avec FINAL est désactivée.
1 — La lecture dans l’ordre inverse avec FINAL est activée.

optimize_respect_aliases

Si ce paramètre est défini sur true, les alias seront pris en compte dans WHERE/GROUP BY/ORDER BY, ce qui facilitera l’élagage des partitions, l’utilisation des index secondaires, ainsi que optimize_aggregation_in_order, optimize_read_in_order et optimize_trivial_count

optimize_sorting_by_input_stream_properties

Optimise le tri à l’aide des propriétés de tri du flux d’entrée

optimize_substitute_columns

Utilisez les contraintes pour remplacer des colonnes. La valeur par défaut est false. Valeurs possibles :

true, false

optimize_syntax_fuse_functions

Permet de fusionner des fonctions d’agrégation ayant un argument identique. Réécrit une requête contenant au moins deux fonctions d’agrégation parmi sum, count ou avg, ayant un argument identique, en sumCount. Valeurs possibles :

0 — Les fonctions ayant un argument identique ne sont pas fusionnées.
1 — Les fonctions ayant un argument identique sont fusionnées.

Exemple Requête :

CREATE TABLE fuse_tbl(a Int8, b Int8) Engine = Log;
SET optimize_syntax_fuse_functions = 1;
EXPLAIN SYNTAX run_query_tree_passes = 1 SELECT sum(a), sum(b), count(b), avg(b) from fuse_tbl FORMAT TSVRaw;

Résultat :

SELECT
    sum(__table1.a) AS `sum(a)`,
    tupleElement(sumCount(__table1.b), 1) AS `sum(b)`,
    tupleElement(sumCount(__table1.b), 2) AS `count(b)`,
    divide(tupleElement(sumCount(__table1.b), 1), toFloat64(tupleElement(sumCount(__table1.b), 2))) AS `avg(b)`
FROM default.fuse_tbl AS __table1

optimize_throw_if_noop

Active ou désactive le déclenchement d’une exception si une requête OPTIMIZE n’a effectué aucune fusion. Par défaut, OPTIMIZE se termine avec succès même s’il n’a rien fait. Ce paramètre vous permet de distinguer ces situations et d’obtenir la raison dans le message d’exception. Valeurs possibles :

1 — Le déclenchement d’une exception est activé.
0 — Le déclenchement d’une exception est désactivé.

optimize_time_filter_with_preimage

Optimise les prédicats Date et DateTime en transformant les fonctions en comparaisons équivalentes sans conversion (p. ex. toYear(col) = 2023 -> col >= '2023-01-01' AND col <= '2023-12-31')

optimize_truncate_order_by_after_group_by_keys

Supprime les éléments ORDER BY en fin de clause une fois que toutes les clés GROUP BY sont couvertes par le préfixe ORDER BY.

optimize_uniq_to_count

Réécrit uniq et ses variantes (sauf uniqUpTo) en count si la sous-requête contient distinct ou une clause GROUP BY.

optimize_using_constraints

Utilisez les contraintes pour optimiser les requêtes. La valeur par défaut est false. Valeurs possibles :

true, false

Référence SQL

Types de données

Moteurs

Fonctions

Formats

Paramètres

Tables système

Lacs de données

optimize_aggregators_of_group_by_keys

optimize_append_index

optimize_arithmetic_operations_in_aggregate_functions

optimize_const_name_size

optimize_count_from_files

optimize_dictget_tuple_element

optimize_distinct_in_order

optimize_distributed_group_by_sharding_key

optimize_dry_run_check_part

optimize_empty_string_comparisons

optimize_extract_common_expressions

optimize_functions_to_subcolumns

optimize_inverse_dictionary_lookup

optimize_multiif_to_if

optimize_mutations_with_partition_pruning

optimize_normalize_count_variants

optimize_on_insert

optimize_prewhere_after_pushdown

optimize_qbit_distance_function_reads

optimize_read_in_order

optimize_read_in_reverse_order_final

optimize_respect_aliases

optimize_sorting_by_input_stream_properties

optimize_substitute_columns

optimize_syntax_fuse_functions

optimize_throw_if_noop

optimize_time_filter_with_preimage

optimize_truncate_order_by_after_group_by_keys

optimize_uniq_to_count

optimize_using_constraints

​optimize_aggregators_of_group_by_keys

​optimize_append_index

​optimize_arithmetic_operations_in_aggregate_functions

​optimize_const_name_size

​optimize_count_from_files

​optimize_dictget_tuple_element

​optimize_distinct_in_order

​optimize_distributed_group_by_sharding_key

​optimize_dry_run_check_part

​optimize_empty_string_comparisons

​optimize_extract_common_expressions

​optimize_functions_to_subcolumns

​optimize_inverse_dictionary_lookup

​optimize_multiif_to_if

​optimize_mutations_with_partition_pruning

​optimize_normalize_count_variants

​optimize_on_insert

​optimize_prewhere_after_pushdown

​optimize_qbit_distance_function_reads

​optimize_read_in_order

​optimize_read_in_reverse_order_final

​optimize_respect_aliases

​optimize_sorting_by_input_stream_properties

​optimize_substitute_columns

​optimize_syntax_fuse_functions

​optimize_throw_if_noop

​optimize_time_filter_with_preimage

​optimize_truncate_order_by_after_group_by_keys

​optimize_uniq_to_count

​optimize_using_constraints

optimize_aggregators_of_group_by_keys

optimize_append_index

optimize_arithmetic_operations_in_aggregate_functions

optimize_const_name_size

optimize_count_from_files

optimize_dictget_tuple_element

optimize_distinct_in_order

optimize_distributed_group_by_sharding_key

optimize_dry_run_check_part

optimize_empty_string_comparisons

optimize_extract_common_expressions

optimize_functions_to_subcolumns

optimize_inverse_dictionary_lookup

optimize_multiif_to_if

optimize_mutations_with_partition_pruning

optimize_normalize_count_variants

optimize_on_insert

optimize_prewhere_after_pushdown

optimize_qbit_distance_function_reads

optimize_read_in_order

optimize_read_in_reverse_order_final

optimize_respect_aliases

optimize_sorting_by_input_stream_properties

optimize_substitute_columns

optimize_syntax_fuse_functions

optimize_throw_if_noop

optimize_time_filter_with_preimage

optimize_truncate_order_by_after_group_by_keys

optimize_uniq_to_count

optimize_using_constraints