> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-parallel-read-in-order-multi-part.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # paramètres de session enable_* > Paramètres de session ClickHouse du groupe généré enable_*. export const PrivatePreviewBadge = () => { return

{'Aperçu privé'}

; }; export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => { if (link) { return Beta ; } return Fonctionnalité en bêta ; }; export const ExperimentalBadge = () => { return

Fonctionnalité expérimentale ; }; export const VersionHistory = ({rows = []}) => { if (rows.length === 0) { return null; } const headers = ["Version", "Valeur par défaut", "Commentaire"]; const border = "1px solid rgba(128, 128, 128, 0.3)"; const cell = { border, padding: "0.25rem 0.5rem", textAlign: "start", verticalAlign: "top" }; return

Historique des versions

{headers.map(header => )} {rows.map((row, row_index) => {(row.items ?? []).map((item, item_index) => )} )}

{header}
{item?.label}

; }; export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => { return

Type

{type}

Par défaut

{default_value}

{changeable_without_restart &&

Modifiable sans redémarrage

} {changeable_without_restart &&

{changeable_without_restart}

}

; }; Ces paramètres sont disponibles dans [system.settings](/fr/reference/system-tables/settings) et sont générés automatiquement à partir du [source](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/Settings.cpp). ## enable\_adaptive\_aggregator Active l’algorithme `GROUP BY` adaptatif : chaque thread agrège dans sa table de hachage locale jusqu’à ce qu’elle atteigne `adaptive_aggregator_freeze_threshold` clés (ou `adaptive_aggregator_freeze_threshold_bytes` de mémoire), puis celle-ci est figée. Les lignes associées aux clés déjà rencontrées (fréquentes) continuent alors de la mettre à jour sur place, tandis que les nouvelles clés (rares) sont routées selon leur hash vers des files d’attente par bucket et agrégées exactement une fois lors de la fusion parallèle des buckets. Les clés fréquentes restent dans de petites tables tenant en cache, tandis que les clés rares ne sont stockées et traitées qu’une seule fois, au lieu d’une fois par thread. Les paramètres d’agrégation externe (`max_bytes_before_external_group_by`, `max_bytes_ratio_before_external_group_by`) sont respectés : au-delà du seuil, les files d’attente sont vidées de manière anticipée dans la table partagée et, si cela ne suffit pas à repasser sous ce seuil, la table partagée est déversée sur disque via l’agrégation externe ordinaire. ## enable\_adaptive\_memory\_spill\_scheduler Déclenche le processeur pour déverser de manière adaptative les données vers un stockage externe. Les jointures de hachage capables de déverser sont actuellement prises en charge, aussi bien `grace_hash` que le chemin adaptatif `hash` / `parallel_hash`. ## enable\_add\_distinct\_to\_in\_subqueries Active `DISTINCT` dans les sous-requêtes `IN`. Ce paramètre implique un compromis : son activation peut réduire considérablement la taille des tables temporaires transférées pour les sous-requêtes `IN` distribuées et accélérer nettement le transfert de données entre les shards, en garantissant que seules des valeurs uniques sont envoyées. Cependant, l’activation de ce paramètre ajoute des opérations de fusion supplémentaires sur chaque nœud, car la déduplication (`DISTINCT`) doit être effectuée. Utilisez ce paramètre lorsque le transfert réseau constitue un goulot d’étranglement et que le coût supplémentaire de fusion est acceptable. ## enable\_alp\_codec Active le codec de compression `ALP`. ## enable\_automatic\_decision\_for\_merging\_across\_partitions\_for\_final Si ce paramètre est activé, ClickHouse activera automatiquement cette optimisation lorsque l'expression de la clé de partition est déterministe et que toutes les colonnes utilisées dans cette expression sont incluses dans la clé primaire. Cette déduction automatique garantit que les lignes ayant les mêmes valeurs de clé primaire appartiendront toujours à la même partition, ce qui permet d'éviter en toute sécurité les fusions entre partitions. Les colonnes de clé à virgule flottante sont exclues de cette déduction. Le comparateur `FINAL` est moins fin que l'identité de valeur pour `Float32`, `Float64` et `BFloat16` : `-0.0` est considéré comme égal à `0.0`, et tout motif binaire `NaN` est considéré comme égal à n'importe quel autre. Une expression de partition, elle, distingue précisément ces valeurs : des lignes que le comparateur traite comme une seule et même clé peuvent donc se retrouver dans des partitions différentes, et ignorer la fusion entre partitions les renverrait toutes. Cette exclusion s'applique également lorsqu'un flottant est imbriqué dans une colonne de clé, par exemple `Tuple(Float64, UInt8)` ou `Array(Float64)`. ## enable\_cascades\_optimizer Active l’optimiseur Cascades basé sur les coûts pour les plans de requêtes distribuées. Ne prend effet qu’avec `make_distributed_plan = 1` : ce paramètre n’a à lui seul aucun effet sur la planification des requêtes sur un seul nœud. ## enable\_early\_constant\_folding Active une optimisation de requête qui analyse les résultats des fonctions et des sous-requêtes, puis réécrit la requête si elle contient des constantes ## enable\_extended\_results\_for\_datetime\_functions Active ou désactive le renvoi de résultats de type `Date32` avec une plage étendue (par rapport au type `Date`) ou de type `DateTime64` avec une plage étendue (par rapport au type `DateTime`). Valeurs possibles : * `0` — Les fonctions renvoient `Date` ou `DateTime` pour tous les types d'arguments. * `1` — Les fonctions renvoient `Date32` ou `DateTime64` pour les arguments `Date32` ou `DateTime64`, et `Date` ou `DateTime` dans les autres cas. Le tableau ci-dessous montre le comportement de ce paramètre pour différentes fonctions de date et heure. | Function | `enable_extended_results_for_datetime_functions = 0` | `enable_extended_results_for_datetime_functions = 1` | | - | - | - | | `toStartOfYear` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée `Date32`/`DateTime64` | | `toStartOfISOYear` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toStartOfQuarter` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée `Date32`/`DateTime64` | | `toStartOfMonth` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toStartOfWeek` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toLastDayOfWeek` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une valeur d’entrée `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une valeur d’entrée `Date32`/`DateTime64` | | `toLastDayOfMonth` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toMonday` | Renvoie `Date` ou `DateTime` | Renvoie `Date`/`DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `Date32`/`DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toStartOfDay` | Renvoie `DateTime`
*Remarque : résultats erronés pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toStartOfHour` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs en dehors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toStartOfFifteenMinutes` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée en `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée en `Date32`/`DateTime64` | | `toStartOfTenMinutes` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs en dehors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée de type `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée de type `Date32`/`DateTime64` | | `toStartOfFiveMinutes` | Renvoie `DateTime`
*Remarque : résultats incorrects pour des valeurs en dehors de la plage 1970-2149* | Renvoie `DateTime` pour une valeur d’entrée de type `Date`/`DateTime`
Renvoie `DateTime64` pour une valeur d’entrée de type `Date32`/`DateTime64` | | `toStartOfMinute` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour une entrée `Date`/`DateTime`
Renvoie `DateTime64` pour une entrée `Date32`/`DateTime64` | | `timeSlot` | Renvoie `DateTime`
*Remarque : résultats incorrects pour les valeurs hors de la plage 1970-2149* | Renvoie `DateTime` pour un argument `Date`/`DateTime`
Renvoie `DateTime64` pour un argument `Date32`/`DateTime64` | ## enable\_full\_text\_index **Alias** : `allow_experimental_full_text_index` Si cette option est définie sur true, l’utilisation de l’index de texte est autorisée. ## enable\_function\_early\_short\_circuit Active le repliement anticipé des constantes avec évaluation en court-circuit pour `and` et `or` lors de l’analyse des requêtes. Lorsqu’elle est activée, les branches inaccessibles admissibles des sous-requêtes scalaires sont analysées afin de préserver leurs types et de valider la sémantique des requêtes, mais elles ne sont pas exécutées. L’optimisation revient à une analyse ordinaire lorsque la cardinalité scalaire ou des valeurs d’exécution sont requises. ## enable\_funnel\_functions **Aliases** : `allow_experimental_funnel_functions` Active les fonctions d'analyse de funnel. ## enable\_global\_with\_statement Propage les instructions WITH aux requêtes UNION et à toutes les sous-requêtes ## enable\_group\_by\_top\_k\_optimization Active l'optimisation du filtrage TopK lors de l'agrégation dans les requêtes `GROUP BY keys ORDER BY LIMIT K`, ainsi que dans les requêtes `GROUP BY keys LIMIT K` sans `ORDER BY` (dans ce cas, n'importe quels `K` groupes constituent un résultat valide, un tri sur toutes les clés est donc généré). Lorsqu'elle est activée, l'agrégateur maintient un tas de taille limitée contenant les `K` clés les mieux classées rencontrées jusqu'à présent et n'insère pas de nouvelles lignes dans la table de hachage lorsque leur clé de regroupement ne peut pas figurer dans le résultat final. Cela évite d'agréger des lignes qui seraient écartées par le `ORDER BY ... LIMIT` ultérieur et, lorsque le tas classe la clé `GROUP BY` complète, supprime également les groupes évincés de la table de hachage intermédiaire, dont la taille est alors limitée par le `LIMIT` plutôt que par le nombre de clés distinctes. Lorsque le `ORDER BY` ne couvre qu'un préfixe strict des clés `GROUP BY`, le classement ne peut pas identifier un groupe complet ; seules des lignes sont donc ignorées : la table de hachage conserve chaque groupe admis et peut toujours croître en fonction de la cardinalité des colonnes de clés restantes. L'optimisation est désactivée lorsque le `LIMIT` demandé est supérieur à [query\_plan\_max\_limit\_for\_top\_k\_optimization](/fr/reference/settings/session-settings/query-plan#query_plan_max_limit_for_top_k_optimization) ou au plafond fixe de `100000`, car le coût du tas en mémoire et en CPU augmente avec le `LIMIT` demandé. L'optimisation est ignorée pour les formes de requêtes où la suppression de groupes pourrait modifier le résultat, notamment avec `WITH TOTALS`, `HAVING`, `QUALIFY`, les fonctions de fenêtre, `ROLLUP`/`CUBE`/`GROUPING SETS`, `LIMIT WITH TIES`, un `COLLATE` sur l'une des clés `GROUP BY` correspondantes (un `COLLATE` sur une colonne `ORDER BY` située après le préfixe de clé complet ne peut pas affecter les groupes retenus et ne désactive donc pas l'optimisation), un `ORDER BY` sur un agrégat ou sur tout élément qui n'est pas un préfixe initial des clés `GROUP BY`, ainsi que lorsque `max_rows_to_group_by` ou `exact_rows_before_limit` est défini. Valeurs possibles : * 0 — Désactivé. * 1 — Activé. ## enable\_hash\_join\_row\_store Active la transformation de la charge utile d'une jointure de hachage en stockage par lignes. ## enable\_hdfs\_pread Active ou désactive `pread` pour les fichiers HDFS. Par défaut, `hdfsPread` est utilisé. S'il est désactivé, `hdfsRead` et `hdfsSeek` sont utilisés pour lire les fichiers HDFS. ## enable\_http\_compression Active ou désactive la compression des données dans la réponse à une requête HTTP. Pour plus d'informations, consultez la [description de l'interface HTTP](/fr/concepts/features/interfaces/http). Valeurs possibles : * 0 — Désactivé. * 1 — Activé. ## enable\_identifier\_resolve\_cache Active le cache de résolution des identifiants dans l’analyseur de requêtes. Le cache partage les nœuds d’alias résolus afin d’éviter une explosion de l’AST lorsque le même alias est utilisé plusieurs fois. Définissez-la sur false pour désactiver la mise en cache si vous suspectez des résultats incorrects. ## enable\_job\_stack\_trace Affiche la trace de pile du créateur du job lorsque celui-ci entraîne une exception. Désactivé par défaut afin d’éviter toute surcharge de performances. ## enable\_json\_ast\_dialect Active la valeur `clickhouse_json` du paramètre `dialect`. Lorsque `dialect` est défini sur `clickhouse_json`, les requêtes sont interprétées comme des AST JSON (la sortie de `parseQueryToJSON`) plutôt que comme du texte SQL. La requête `SET` est toujours analysée comme du SQL standard afin de pouvoir revenir au dialecte précédent. Exemple : ```sql theme={null} SET enable_json_ast_dialect = 1; SET dialect = 'clickhouse_json'; -- Subsequent queries are parsed as JSON ASTs: {"type":"SelectWithUnionQuery", ...} ``` ## enable\_json\_lazy\_type\_hints **Aliases** : `allow_experimental_json_lazy_type_hints` Active les indications de type différées pour le type [JSON](/fr/reference/data-types/newjson). Lorsque ce paramètre est activé, une requête `ALTER TABLE ... MODIFY COLUMN json JSON(path TypeName)` qui se contente d'ajouter ou de modifier des indications de type constitue une opération limitée aux métadonnées : les indications de type sont appliquées au moment de la requête pour les parts existantes et matérialisés lors des insertions et des fusions en arrière-plan, plutôt que de réécrire les données historiques. ## enable\_lazy\_columns\_replication Active la réplication différée des colonnes dans `JOIN`, `ARRAY JOIN`, ainsi que dans les captures lambda de fonctions d’ordre supérieur (p. ex. `arrayMap`). Cela permet d'éviter de copier inutilement plusieurs fois les mêmes lignes en mémoire. ## enable\_materialized\_cte Active les expressions de table communes matérialisées (`WITH AS MATERIALIZED ()`). Lorsque ce paramètre est activé, une CTE déclarée comme `MATERIALIZED` et référencée plusieurs fois n'est exécutée qu'une seule fois, son résultat est stocké dans une table temporaire, et toutes les références lisent depuis cette table. Une CTE référencée une seule fois est intégrée comme une CTE ordinaire afin d'éviter ce surcoût. Lorsque ce paramètre est désactivé, le mot-clé `MATERIALIZED` est ignoré : la CTE est intégrée à chaque référence comme une CTE ordinaire, et un avertissement est journalisé. ## enable\_materialized\_postgresql\_table **Aliases** : `allow_experimental_materialized_postgresql_table` Permet d'utiliser le table engine `MaterializedPostgreSQL`. ## enable\_memory\_bound\_merging\_of\_aggregation\_results Active la stratégie de fusion des résultats d’agrégation limitée par la mémoire. ## enable\_multiple\_prewhere\_read\_steps Déplace davantage de conditions de WHERE vers PREWHERE, et effectue les lectures sur disque ainsi que le filtrage en plusieurs étapes s’il y a plusieurs conditions combinées avec AND ## enable\_named\_columns\_in\_function\_tuple Génère des tuples nommés dans la fonction tuple() lorsque tous les noms sont uniques et peuvent être considérés comme des identifiants non quotés. ## enable\_nullable\_tuple\_type **Aliases** : `allow_experimental_nullable_tuple_type` Autorise la création de colonnes [Nullable](/fr/reference/data-types/nullable) [Tuple](/fr/reference/data-types/tuple) dans les tables. Ce paramètre ne détermine pas si les sous-colonnes de type tuple extraites peuvent être `Nullable` (par exemple, depuis des colonnes Dynamic, Variant, JSON ou Tuple). Utilisez `allow_nullable_tuple_in_extracted_subcolumns` pour définir si les sous-colonnes de type tuple extraites peuvent être `Nullable`. ## enable\_order\_by\_all Active ou désactive le tri à l’aide de la syntaxe `ORDER BY ALL`, voir [ORDER BY](/fr/reference/statements/select/order-by). Valeurs possibles : * 0 — Désactive `ORDER BY ALL`. * 1 — Active `ORDER BY ALL`. **Exemple** Requête : ```sql theme={null} CREATE TABLE TAB(C1 Int, C2 Int, ALL Int) ENGINE=Memory(); INSERT INTO TAB VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20); SELECT * FROM TAB ORDER BY ALL; -- returns an error that ALL is ambiguous SELECT * FROM TAB ORDER BY ALL SETTINGS enable_order_by_all = 0; ``` Résultat : ```text theme={null} ┌─C1─┬─C2─┬─ALL─┐ │ 20 │ 20 │ 10 │ │ 30 │ 10 │ 20 │ │ 10 │ 20 │ 30 │ └────┴────┴─────┘ ``` ## enable\_packed\_string\_keys\_in\_aggregation Utilise une table de hachage indexée par des références de chaînes compactes de 16 octets (`PackedStringRef`) pour les `GROUP BY` comportant une seule clé `String` non nullable. Les clés d’au plus 11 octets sont stockées directement dans la référence compacte ; les clés plus longues sont référencées dans une arène. Cette méthode est plus rapide pour la plupart des workloads, mais peut être plus lente que la méthode legacy pour les `GROUP BY` avec très peu de clés distinctes de plus de 11 octets (en particulier de 12 à 24 octets), car la table de hachage legacy conserve les clés directement dans la cellule, tandis que la table compacte déréférence le pointeur vers l’arène à chaque recherche. Lorsqu’elle est désactivée, la méthode legacy basée sur `StringHashTable` (celle utilisée par défaut avant la version 26.8) est employée. Tous les serveurs participant à une requête distribuée doivent utiliser la même valeur : avec `distributed_aggregation_memory_efficient`, les numéros de buckets à deux niveaux dépendent du hash de la clé, qui diffère selon la méthode. Des serveurs utilisant des valeurs différentes pour ce paramètre peuvent donc répartir une même clé dans différents buckets et produire un résultat fusionné incorrect. Pour garantir cette cohérence, l’initiateur transmet toujours sa valeur effective avec les requêtes secondaires (même lorsqu’elle provient uniquement des valeurs par défaut du serveur ou du profil), en remplaçant les valeurs par défaut des serveurs distants. ## enable\_parsing\_to\_custom\_serialization Si la valeur est true, les données peuvent être analysées directement dans des colonnes avec une sérialisation personnalisée (par ex. Sparse), selon les indications de sérialisation obtenues depuis la table. ## enable\_producing\_buckets\_out\_of\_order\_in\_aggregation Permet à l'agrégation économe en mémoire (voir `distributed_aggregation_memory_efficient`) de produire des buckets dans le désordre. Cela peut améliorer les performances lorsque la taille des buckets d'agrégation est inégale, en permettant à une réplique d'envoyer à l'initiateur des buckets dont les ID sont plus élevés alors qu'elle traite encore des buckets volumineux avec des ID plus faibles. L'inconvénient est une consommation de mémoire potentiellement plus élevée. ## enable\_quantized\_codec Active le codec de compression `Quantized`. ## enable\_reads\_from\_query\_cache Si cette option est activée, les résultats des requêtes `SELECT` sont lus depuis le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache). Valeurs possibles : * 0 - Désactivé * 1 - Activé ## enable\_s3\_requests\_logging Active une journalisation très détaillée des requêtes S3. À utiliser uniquement pour le débogage. ## enable\_scalar\_subquery\_optimization Si ce paramètre est défini sur true, il empêche les sous-requêtes scalaires de (dé)sérialiser de grandes valeurs scalaires et peut éviter d’exécuter la même sous-requête plusieurs fois. ## enable\_scopes\_for\_with\_statement Si cette option est désactivée, les déclarations dans les clauses WITH parentes auront la même portée que si elles étaient déclarées dans la portée actuelle. Notez qu’il s’agit d’un paramètre de compatibilité de l’analyseur permettant d’exécuter certaines requêtes non valides que l’ancien analyseur pouvait exécuter. ## enable\_shared\_storage\_snapshot\_in\_query Si cette option est activée, toutes les sous-requêtes d’une même requête partageront le même StorageSnapshot pour chaque table. Cela garantit une vue cohérente des données dans l’ensemble de la requête, même si la même table est accédée plusieurs fois. Ce paramètre est nécessaire pour les requêtes où la cohérence interne des data parts est importante. Exemple : ```sql theme={null} SELECT count() FROM events WHERE (_part, _part_offset) IN ( SELECT _part, _part_offset FROM events WHERE user_id = 42 ) ``` Sans ce paramètre, la requête externe et la requête interne peuvent s’exécuter sur des instantanés de données différents, ce qui peut entraîner des résultats incorrects. Valeurs possibles : * 0 - Désactivé * 1 - Activé ## enable\_sharing\_sets\_for\_mutations Autorise le partage des objets Set créés pour les sous-requêtes IN entre différentes tâches d'une même mutation. Cela réduit l'utilisation de la mémoire et la consommation de CPU ## enable\_streaming\_queries Autorise les requêtes en continu `SELECT ... FROM t STREAM [CURSOR '{...}']`. Lorsqu’il est désactivé, toute expression de table utilisant le modificateur `STREAM` est rejetée lors de la construction du plan. Il s’agit du paramètre de contrôle global de la fonctionnalité de requêtes en continu ; des capacités supplémentaires peuvent être régies par leurs propres paramètres. ## enable\_sz3\_codec Active le codec de compression `SZ3`. ## enable\_time\_series\_aggregate\_functions **Aliases** : `allow_experimental_ts_to_grid_aggregate_function`, `allow_experimental_time_series_aggregate_functions` Active les fonctions d'agrégation `timeSeries*` permettant le rééchantillonnage de time series à la manière de Prometheus, ainsi que le calcul du rate et du delta. ## enable\_time\_series\_table **Aliases** : `allow_experimental_time_series_table` Autorise la création de tables utilisant le table engine [TimeSeries](/fr/reference/engines/table-engines/integrations/time-series). Valeurs possibles : * 0 — le table engine [TimeSeries](/fr/reference/engines/table-engines/integrations/time-series) est désactivé. * 1 — le table engine [TimeSeries](/fr/reference/engines/table-engines/integrations/time-series) est activé. ## enable\_time\_time64\_type **Alias** : `allow_experimental_time_time64_type` Permet de créer les types de données [Time](/fr/reference/data-types/time) et [Time64](/fr/reference/data-types/time64). ## enable\_trino\_dialect Active la valeur `trino` du paramètre `dialect`. Lorsque `dialect` vaut `trino`, les requêtes sont écrites en SQL Trino : la syntaxe propre à Trino (littéraux `ARRAY[...]`, `TRY_CAST`, `UNNEST`, types `ROW`, `OFFSET` avant `LIMIT`) est traduite en ClickHouse SQL, et les noms de fonctions Trino sont mis en correspondance avec leurs équivalents ClickHouse. La requête `SET` reste analysée comme du SQL ordinaire, ce qui permet de revenir au dialecte précédent. Le dialecte aligne également la sémantique des requêtes sur celle de Trino : `join_use_nulls` est activé, `use_variant_as_common_type` est désactivé et l'analyseur de requêtes est activé. Une clause `SETTINGS` explicite dans la requête conserve la préséance. ## enable\_unaligned\_array\_join Autorise ARRAY JOIN sur plusieurs tableaux de tailles différentes. Lorsque ce paramètre est activé, les tableaux sont redimensionnés à la longueur du plus long. ## enable\_unique\_key **Aliases** : `allow_experimental_unique_key` Autorise la création de tables comportant la clause `UNIQUE KEY` sur les moteurs de la famille MergeTree. ## enable\_url\_encoding Permet d’activer ou de désactiver le décodage/l’encodage du chemin dans l’URI des tables utilisant le moteur [URL](/fr/reference/engines/table-engines/special/url). Désactivé par défaut. ## enable\_vertical\_final Si cette option est activée, les lignes dupliquées sont supprimées pendant FINAL en marquant les lignes comme supprimées, puis en les filtrant ultérieurement au lieu de les fusionner ## enable\_writes\_to\_query\_cache Lorsqu'il est activé, les résultats des requêtes `SELECT` sont stockés dans le [cache de requêtes](/fr/concepts/features/performance/caches/query-cache). Valeurs possibles : * 0 - Désactivé * 1 - Activé ## enable\_zxc\_codec Active le codec de compression `ZXC`.