Autres paramètres de session

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

Nombre de clés à partir duquel l’agrégateur adaptatif fige la table de hachage locale d’un thread (voir enable_adaptive_aggregator). Des valeurs plus faibles maintiennent les tables figées dans le cache, tandis que des valeurs plus élevées leur permettent d’absorber davantage de clés fréquentes. La valeur 0 fige les tables dès que possible, ce qui fait que l’algorithme se comporte de manière similaire à l’agrégateur partitionné (enable_sharding_aggregator) : chaque clé est routée selon son hash et agrégée par un seul propriétaire, mais l’opération est reportée à la phase de fusion au lieu d’être échangée entre les threads pendant le parcours.

Taille de mémoire à partir de laquelle l’agrégateur adaptatif fige la table de hachage locale d’un thread (voir enable_adaptive_aggregator). Une table est figée lorsque cette valeur ou adaptive_aggregator_freeze_threshold est atteinte en premier. La taille correspond aux octets effectivement alloués par la table locale (son tampon de table de hachage et ses arènes), vérifiés entre les blocs. La limite en octets est importante lorsque les clés ou les états d’agrégation sont volumineux : le seul seuil du nombre de clés permettrait à ces tables de dépasser la capacité des caches CPU. Avec la valeur par défaut, les tables dont les clés et les états sont de taille habituelle continuent d’être figées en fonction du nombre de clés. 0 désactive la limite en octets ; seul le seuil du nombre de clés s’applique alors.

Écrit un en-tête CORS HTTP supplémentaire.

Si une table possède une courbe de remplissage de l’espace dans son index, par exemple ORDER BY mortonEncode(x, y) ou ORDER BY hilbertEncode(x, y), et que la requête comporte des conditions sur ses arguments, par exemple x >= 10 AND x <= 20 AND y >= 20 AND y <= 30, utilisez la courbe de remplissage de l’espace pour l’analyse de l’index.

Lorsqu’il est activé, l’analyseur remplace les vues ordinaires (non matérialisées et non paramétrées) par les sous-requêtes qui les définissent, ce qui permet des optimisations transversales telles que le pushdown des prédicats et l’élagage des colonnes.

Active le comportement legacy du serveur ClickHouse pour les opérations ANY INNER|LEFT JOIN.

Lorsque le comportement legacy est activé :

• Les résultats des opérations t1 ANY LEFT JOIN t2 et t2 ANY RIGHT JOIN t1 ne sont pas identiques, car ClickHouse utilise une logique de correspondance des clés entre les tables, de gauche à droite, de plusieurs à un.
• Les résultats des opérations ANY INNER JOIN contiennent toutes les lignes de la table de gauche, comme c’est le cas pour les opérations SEMI LEFT JOIN.

Lorsque le comportement legacy est désactivé :

• Les résultats des opérations t1 ANY LEFT JOIN t2 et t2 ANY RIGHT JOIN t1 sont identiques, car ClickHouse utilise une logique qui permet une correspondance des clés de un à plusieurs dans les opérations ANY RIGHT JOIN.
• Les résultats des opérations ANY INNER JOIN contiennent une ligne par clé provenant des tables de gauche et de droite.

Valeurs possibles :

• 0 — Le comportement legacy est désactivé.
• 1 — Le comportement legacy est activé.

Voir aussi :

• strictness des JOIN

Limite la taille maximale du tampon adaptatif utilisé pour l’écriture dans des fichiers d’archive (par exemple, des archives tar

Type de descripteur à utiliser pour les requêtes Arrow Flight. 'path' envoie le nom du jeu de données sous forme de descripteur de chemin. 'command' envoie une requête SQL sous forme de descripteur de commande (requis pour Dremio).

Valeurs possibles :

• 'path' — Utilise FlightDescriptor::Path (par défaut, fonctionne avec la plupart des serveurs Arrow Flight)
• 'command' — Utilise FlightDescriptor::Command avec une requête SELECT (requis pour Dremio)

Lorsqu'il est défini sur true, tous les threads exécutant des requêtes S3 vers le même endpoint de sauvegarde sont ralentis dès qu'une requête S3 rencontre une erreur S3 pouvant donner lieu à un réessai, telle que 'Slow Down'. Lorsqu'il est défini sur false, chaque thread gère le backoff des requêtes S3 indépendamment des autres.

N’a d’effet que dans ClickHouse Cloud. Nombre de threads d’arrière-plan utilisés pour télécharger de manière spéculative de nouvelles parts de données dans le cache du système de fichiers lorsque cache_populated_by_fetch est activé. Zéro pour désactiver.

Calcule une stack trace textuelle en cas d'exception pendant l'exécution des requêtes. Il s'agit du comportement par défaut. Cela nécessite des recherches de symboles, ce qui peut ralentir les tests de fuzzing lorsqu'un très grand nombre de requêtes erronées sont exécutées. Dans des conditions normales, vous ne devriez pas désactiver cette option.

Annule les requêtes HTTP en lecture seule (par ex. SELECT) lorsqu’un client ferme la connexion sans attendre de réponse.

Valeur par défaut dans Cloud : 1.

Valide les sommes de contrôle lors de la lecture. Ce paramètre est activé par défaut et doit toujours l’être en production. N’attendez aucun bénéfice de la désactivation de ce paramètre. Il ne doit être utilisé que pour des expérimentations et des benchmarks. Ce paramètre s’applique uniquement aux tables de la famille MergeTree. Les sommes de contrôle sont toujours validées pour les autres moteurs de table et lors de la réception de données sur le réseau.

Applique une compression générique au corps de la réponse, par exemple compression=gz. Notez que ce paramètre est indépendant de Content-Encoding (compression HTTP) et de l’ancien paramètre compress (compression native de ClickHouse). Indiquer une extension de fichier compressé dans le chemin d’URL produit le même effet.

Il s’agit d’un paramètre de l’interface HTTP qui définit la forme de la réponse : il est pris en compte avant l’exécution de la requête (les tampons de réponse sont configurés à l’avance). Il doit donc être fourni via le paramètre d’URL HTTP, l’extension de fichier du chemin d’URL ou un profil utilisateur, et non via une clause SETTINGS dans la requête (où il n’a aucun effet et est rejeté).

Temps d’attente, en millisecondes, pour obtenir une connexion lorsque le pool de connexions est plein.

Valeurs possibles :

• Entier positif.
• 0 — Délai d’attente infini.

Le nombre maximal de tentatives de connexion à effectuer avec chaque réplique pour le moteur de table Distributed.

Lorsqu'elle est définie sur true, une requête SELECT est convertie en forme normale conjonctive (CNF). Dans certains cas, réécrire une requête en CNF peut accélérer son exécution (voir cette issue GitHub pour plus d'explications).

Par exemple, notez que la requête SELECT suivante n'est pas modifiée (comportement par défaut) :

EXPLAIN SYNTAX
SELECT *
FROM
(
    SELECT number AS x
    FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = false;

Le résultat est :

┌─explain────────────────────────────────────────────────────────┐
│ SELECT x                                                       │
│ FROM                                                           │
│ (                                                              │
│     SELECT number AS x                                         │
│     FROM numbers(20)                                           │
│     WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ ) AS a                                                         │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))     │
│ SETTINGS convert_query_to_cnf = 0                              │
└────────────────────────────────────────────────────────────────┘

Définissons convert_query_to_cnf à true et voyons ce qui change :

EXPLAIN SYNTAX
SELECT *
FROM
(
    SELECT number AS x
    FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = true;

Notez que la clause WHERE est réécrite en CNF, mais le jeu de résultats reste identique : la logique booléenne est inchangée.

┌─explain───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ SELECT x                                                                                                              │
│ FROM                                                                                                                  │
│ (                                                                                                                     │
│     SELECT number AS x                                                                                                │
│     FROM numbers(20)                                                                                                  │
│     WHERE ((x <= 15) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x >= 10) OR (x >= 1)) │
│ ) AS a                                                                                                                │
│ WHERE ((x >= 10) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x <= 15) OR (x <= 5))     │
│ SETTINGS convert_query_to_cnf = 1                                                                                     │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Valeurs possibles : true, false

Arrête le comptage dès qu’un motif produit une correspondance de longueur nulle dans la fonction countMatches.

Utilisez INNER JOIN au lieu d'une jointure par virgule/CROSS JOIN s'il existe des expressions de jointure dans la clause WHERE. Valeurs : 0 - aucune réécriture, 1 - appliquer si possible aux jointures par virgule/CROSS JOIN, 2 - forcer la réécriture de toutes les jointures par virgule, cross - si possible

Permet aux types de données sans modificateurs explicites NULL or NOT NULL dans les définitions de colonnes d’être Nullable.

Valeurs possibles :

• 1 — Les types de données dans les définitions de colonnes sont Nullable par défaut.
• 0 — Les types de données dans les définitions de colonnes ne sont pas Nullable par défaut.

Vérifie les dépassements de capacité des opérations arithmétiques et de comparaison sur les nombres décimaux

Active ou désactive la vérification de déduplication pour les vues matérialisées qui reçoivent des données de tables Replicated*.

Valeurs possibles :

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

Lorsqu’il est activé, ClickHouse effectue la déduplication des blocs dans les vues matérialisées qui dépendent de tables Replicated*. Ce paramètre est utile pour garantir que les vues matérialisées ne contiennent pas de données dupliquées lorsque l’opération d’insertion est réessayée à la suite d’une défaillance.

Voir aussi

• Traitement de NULL dans les opérateurs IN

Lorsqu'il est activé (par défaut), l'élagage des partitions est ignoré pour les requêtes FINAL sur les tables dont les colonnes de clé de partition ne font pas partie de la clé de tri. Il s'agit du comportement sûr du point de vue de la validité des résultats, introduit en 26.3 : FINAL peut devoir dédupliquer des lignes qui partagent une clé primaire mais se trouvent dans des partitions différentes, et l'élagage des partitions exclurait silencieusement ces lignes de l'ensemble d'entrée de la déduplication.

Lorsqu'il est désactivé, l'élagage des partitions s'applique même avec FINAL, ce qui rétablit le comportement antérieur à 26.3. Cela peut être nettement plus rapide pour les requêtes avec des prédicats WHERE sur la colonne de partition, mais n'est correct que lorsque des lignes ayant la même clé primaire ne peuvent pas exister dans des partitions différentes — par exemple, des tables de journaux d'événements dont la colonne de partition est définie au moment de l'insert et ne change jamais.

Ce paramètre n'affecte que les tables partitionnées dont les colonnes de clé de partition ne sont pas incluses dans la clé de tri ; pour les autres tables, l'élagage des partitions est toujours appliqué.

Valeurs possibles :

• 0 — Appliquer l'élagage des partitions avant FINAL (comportement antérieur à 26.3, plus rapide mais non sûr dans le cas général).
• 1 — Différer l'élagage des partitions après FINAL (par défaut, sûr du point de vue de la validité des résultats).

Si cette valeur est définie sur true, inclut uniquement les noms de colonnes et les types dans le résultat de la requête DESCRIBE

Détermine le dialecte utilisé pour analyser la requête.

Valeurs prises en charge :

• clickhouse (par défaut) — ClickHouse SQL standard.
• kusto — Kusto Query Language. Nécessite le paramètre expérimental allow_experimental_kusto_dialect.
• prql — PRQL. Nécessite le paramètre expérimental allow_experimental_prql_dialect.
• polyglot — convertit le SQL provenant d'autres dialectes (MySQL, PostgreSQL, etc.) en ClickHouse SQL. Nécessite le paramètre expérimental allow_experimental_polyglot_dialect.
• promql — PromQL (langage de requêtes Prometheus) évalué sur une table TimeSeries, configurée à l'aide des paramètres promql_database, promql_table et promql_evaluation_time.
• clickhouse_json — au lieu d'un texte SQL, la requête est interprétée comme un AST JSON (la sortie de parseQueryToJSON). La requête SET reste reconnue sous sa forme habituelle afin de pouvoir rétablir le dialecte. Nécessite le paramètre expérimental enable_json_ast_dialect.

S’il est activé, le serveur n’envoie pas au client les lignes du résultat de la requête. La requête est toujours exécutée et intégralement journalisée sur le serveur, et le client reçoit toujours les paquets restants.

Utilisé pour le trafic miroir, les benchmarks et le fuzzing.

N’a aucun effet sur les requêtes secondaires.

Affecte uniquement le protocole TCP natif.

Définit ce qui se produit lorsque la quantité de données dépasse l’une des limites.

Valeurs possibles :

• throw : lever une exception (par défaut).
• break : arrêter l’exécution de la requête et renvoyer le résultat partiel, comme si les données source étaient épuisées.

Améliore les requêtes FINAL en évitant les fusions entre partitions différentes.

Lorsqu’il est activé, lors des requêtes SELECT FINAL, les parts provenant de partitions différentes ne sont pas fusionnées entre elles. La fusion s’effectue uniquement au sein de chaque partition. Cela peut considérablement améliorer les performances des requêtes sur les tables partitionnées.

Lorsqu’une fonction est appliquée à une colonne Dynamic à l’aide de l’implémentation par défaut, ce paramètre contrôle ce qui se passe pour les lignes dont le type réel est incompatible avec la fonction :

• true (par défaut) — lever une exception.
• false — renvoyer NULL pour ces lignes à la place.

Si cette option est activée, n’autoriser que les identifiants contenant des caractères alphanumériques et des traits de soulignement.

Permet d’ignorer ou non les fichiers vides dans les tables du moteur URL.

Valeurs possibles :

• 0 — SELECT lève une exception si le fichier vide n’est pas compatible avec le format demandé.
• 1 — SELECT renvoie un résultat vide pour un fichier vide.

Lorsqu’il est activé, ClickHouse fournit la valeur exacte de la statistique rows_before_limit_at_least, mais au prix d’une lecture complète des données avant la limite.

Définit le mode par défaut de la requête EXCEPT. Valeurs possibles : chaîne vide, 'ALL', 'DISTINCT'. Si elle est vide, une requête sans mode lèvera une exception.

Exclut les index de saut spécifiés afin qu’ils ne soient ni construits ni stockés lors des INSERT. Les index de saut exclus seront toutefois toujours construits et stockés lors des fusions ou par une requête MATERIALIZE INDEX explicite.

N’a aucun effet si materialize_skip_indexes_on_insert vaut false.

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();

SET exclude_materialize_skip_indexes_on_insert='idx_a'; -- idx_a will be not be updated upon insert
--SET exclude_materialize_skip_indexes_on_insert='idx_a, idx_b'; -- neither index would be updated on insert

INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- only idx_b is updated

-- since it is a session setting it can be set on a per-query level
INSERT INTO tab SELECT number, number / 50 FROM numbers(100, 100) SETTINGS exclude_materialize_skip_indexes_on_insert='idx_b';

ALTER TABLE tab MATERIALIZE INDEX idx_a; -- this query can be used to explicitly materialize the index

SET exclude_materialize_skip_indexes_on_insert = DEFAULT; -- reset setting to default

Exécute les sous-requêtes EXISTS non corrélées sous forme de sous-requêtes scalaires. Comme pour les sous-requêtes scalaires, le cache est utilisé et le constant folding s'applique au résultat.

Valeur par défaut dans Cloud : 0.

Format par défaut utilisé par EXPLAIN PLAN.

Valeurs possibles :

• pretty (par défaut depuis la version 26.7) — actions, compact et pretty valent par défaut true, ce qui produit un plan compact, pretty et annoté avec les actions.
• legacy — sortie antérieure à la version 26.7.

Si vous spécifiez explicitement les options actions, compact ou pretty dans l’instruction EXPLAIN (par exemple, EXPLAIN actions = 0, compact = 0, pretty = 0 SELECT ...), cela prévaut toujours sur ce paramètre.

EXPLAIN PLAN avec json = 1 ou distributed = 1 conserve les valeurs par défaut legacy (antérieures à la version 26.7), indépendamment de ce paramètre, sauf si actions, compact ou pretty sont définis explicitement. La sortie pretty ne peut pas représenter des résultats JSON ni des plans distribués par shard ; ces modes ne sont donc correctement rendus qu’au format legacy.

Renvoie la sortie de EXPLAIN SYNTAX sous la forme d’un seul enregistrement (avec des retours à la ligne intégrés), au lieu d’un enregistrement par ligne, de sorte que le résultat ne comporte qu’une seule ligne récupérable (par exemple, SELECT count() FROM (EXPLAIN SYNTAX ...) renvoie 1).

La spécification explicite de l’option single_record dans l’instruction EXPLAIN SYNTAX (par exemple, EXPLAIN SYNTAX single_record = 0 SELECT ...) prévaut toujours sur ce paramètre.

Définissez cette valeur sur false pour rétablir la sortie antérieure à la version 26.8, avec un enregistrement par ligne, ou définissez compatibility sur une version antérieure à 26.8.

Alias: extract_kvp_max_pairs_per_row

Nombre maximal de paires que la fonction extractKeyValuePairs peut produire. Sert de garde-fou pour éviter une consommation excessive de mémoire.

Indique s’il faut prendre en compte les valeurs extrêmes (les valeurs minimales et maximales des colonnes dans le résultat de la requête). Accepte 0 ou 1. La valeur par défaut est 0 (désactivé). Pour plus d’informations, consultez la section « Valeurs extrêmes ».

Force une requête vers une réplique obsolète si des données à jour ne sont pas disponibles. Voir Replication.

ClickHouse sélectionne la réplique la plus pertinente parmi les répliques obsolètes de la table.

Utilisé lors de l’exécution d’un SELECT depuis une table distribuée pointant vers des tables répliquées.

Par défaut, 1 (activé).

Stratégie de partitionnement par défaut pour les moteurs de type fichier. S’applique uniquement aux requêtes CREATE dont le chemin ne contient ni glob ni espace réservé {_partition_id}. Un chemin contenant {_partition_id} utilise toujours wildcard. Un chemin contenant un autre glob n’utilise aucune stratégie de partitionnement et ignore PARTITION BY. Si ce paramètre est défini sur wildcard, mais que le chemin ne contient pas {_partition_id}, aucune stratégie de partitionnement n’est utilisée ; les moteurs de table qui ne peuvent pas conserver cette décision dans les arguments de leur moteur (par ex. HDFS) rejettent alors ce CREATE.

Nombre maximal de prefetches. Zéro signifie qu'il n'y a pas de limite. Il est toutefois recommandé d'utiliser le paramètre filesystem_prefetches_max_memory_usage si vous souhaitez limiter le nombre de prefetches.

Ajoute une clause WHERE à la requête en l’enveloppant dans une sous-requête. Plusieurs filtres sont combinés avec AND. L’interface HTTP autorise plusieurs paramètres d’URL filter, combinés avec AND dans l’ordre, ainsi qu’avec la valeur de ce paramètre.

Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’enveloppant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause SETTINGS dans la requête ou un profil utilisateur.

Il s’applique aux requêtes SELECT / UNION qui produisent des résultats. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que si le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — comme pour tout autre paramètre.

Applique automatiquement le modificateur FINAL à toutes les tables d'une requête auxquelles FINAL s'applique, y compris les tables jointes, les tables dans les sous-requêtes et les tables distribuées.

Valeurs possibles :

• 0 - désactivé
• 1 - activé

Exemple :

CREATE TABLE test
(
    key Int64,
    some String
)
ENGINE = ReplacingMergeTree
ORDER BY key;

INSERT INTO test FORMAT Values (1, 'first');
INSERT INTO test FORMAT Values (1, 'second');

SELECT * FROM test;
┌

Lorsqu’il est activé, les parties de projection sont finalisées de manière synchrone pendant INSERT, ce qui réduit l’utilisation mémoire maximale au prix d’un parallélisme de téléversement vers S3 moindre. Par défaut, le flux de sortie de chaque projection est maintenu actif jusqu’à la finalisation de l’intégralité de la part (y compris toutes les projections), ce qui permet de faire se chevaucher les téléversements vers S3, mais augmente l’utilisation mémoire maximale proportionnellement au nombre de projections. Ce paramètre n’affecte que le processus d’INSERT ; merge et mutation finalisent déjà les projections de manière synchrone.

Définit le format des données des colonnes Nested.

Valeurs possibles :

• 1 — La colonne Nested est aplatie en tableaux distincts.
• 0 — La colonne Nested reste un tableau unique de tuples.

Utilisation

Si ce paramètre est défini sur 0, il est possible d'utiliser un niveau d'imbrication quelconque.

Exemples

Requête :

SET flatten_nested = 1;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();

SHOW CREATE TABLE t_nest;

Résultat :

┌─statement───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
    `n.a` Array(UInt32),
    `n.b` Array(UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Requête :

SET flatten_nested = 0;

CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();

SHOW CREATE TABLE t_nest;

Résultat :

┌─statement──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
    `n` Nested(a UInt32, b UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Remplace le FORMAT de la requête, tant en entrée qu'en sortie. Prévaut sur le format spécifié dans la requête et dans l’extension du fichier. Les paramètres plus spécifiques input_format et output_format prévalent sur ce paramètre générique format dans leur sens respectif.

Permet de multiplexer différentes parties de la réponse à une requête dans un flux unique : fragments de données, totaux et extrêmes, paquets de progression, événements de profilage (métriques) et journaux du serveur — tout ce que prend en charge le protocole natif.

Les formats de tramage sont indépendants des formats de sortie : ils encapsulent les octets produits par n’importe quel format de sortie, en séparant et, éventuellement, en encodant ces fragments d’octets. La concaténation des charges utiles de tous les paquets data, totals et extremes correspond exactement à ce que le format de sortie aurait produit sans tramage. Les paquets auxiliaires (progression, journaux, événements de profilage, exceptions) sont représentés en JSON.

Une exception délibérée : un format de sortie qui omet les totaux et les extrêmes de sa sortie brute parce qu’il ne peut pas les représenter (la famille JSONCompactEachRow) les émet malgré tout avec le tramage, dans les paquets totals et extremes. Pour ces formats, la concaténation des seuls paquets data correspond exactement à la sortie sans tramage, tandis que les paquets totals et extremes contiennent des lignes supplémentaires absentes de cette sortie.

Les journaux du serveur sont inclus si le paramètre send_logs_level est défini, et les événements de profilage si le paramètre send_profile_events est activé (ils sont envoyés au plus une fois toutes les interactive_delay microsecondes, et les paquets de progression sont également limités par interactive_delay).

Un flux réussi se termine par un paquet progress final contenant les compteurs finaux (result_rows, result_bytes, memory_usage), écrit après les paquets log et profile_events de fin émis par la journalisation de fin de requête, à l’instar du paquet de progression final du protocole natif. En cas d’échec, le paquet exception est le dernier paquet — à une exception près : lorsque l’échec survient après qu’une partie du flux de paquets a déjà été produite dans la réponse et ne peut plus être supprimée (l’écriture d’un paquet échoue en cours de route, la transmission du paquet exception lui-même échoue, ou le flux de réponse échoue lors de son vidage ou de sa fermeture), le tramage échoue de manière sécurisée : le flux est interrompu sans paquet exception terminal, et le client observe une réponse tronquée ainsi qu’une connexion HTTP interrompue au lieu d’un paquet terminal analysable. Rien n’est jamais ajouté après un flux de paquets partiel ; un corps d’erreur HTTP brut n’y est donc jamais mélangé.

Tout ce qu’une requête active uniquement via sa propre clause SETTINGS — un format de tramage, send_logs_level ou send_profile_events — n’est connu qu’après l’analyse de la requête ; les journaux et événements de profilage correspondants ne sont donc capturés qu’à partir de l’exécution de la requête. Les journaux et événements de profilage des phases d’analyse syntaxique, de planification et d’analyse sont capturés uniquement lorsque le paramètre provient de la session ou de l’URL. Par exemple, une requête qui échoue pendant l’analyse (par exemple, en raison d’une référence à une table inconnue) et n’active send_logs_level que dans sa clause SETTINGS ne transmet que le paquet exception, et non les journaux de la phase d’analyse ; définissez send_logs_level dans la session ou l’URL pour les capturer.

La même réserve liée à la découverte tardive s’applique à send_logs_source_regexp : la file de journaux filtre les entrées par source au moment où chacune est capturée, de sorte qu’une expression régulière définie uniquement dans la clause SETTINGS de la requête ne prend effet qu’à partir de l’exécution de la requête. Les paquets log des phases d’analyse syntaxique, de planification et d’analyse sont filtrés selon la valeur du paramètre définie dans la session ou l’URL (ils ne sont pas filtrés si elle n’y est pas définie) ; ils peuvent donc inclure des sources qui ne correspondent pas à l’expression régulière définie au niveau de la requête. Inversement, les entrées ignorées par une expression régulière plus restrictive définie dans la session ou l’URL ne sont pas récupérées par une expression régulière plus large définie au niveau de la requête. Définissez send_logs_source_regexp dans la session ou l’URL pour filtrer l’ensemble du cycle de vie de la requête.

Le paramètre s’applique actuellement au protocole HTTP et est ignoré par les autres interfaces.

Valeurs possibles :

• None - achemine de manière transparente tous les éléments applicables (données, totaux, extrêmes, progression) vers le format de sortie et ignore ceux qui ne le sont pas (métriques, journaux), de sorte que tout fonctionne comme par défaut.
• EventStream - encapsule les paquets sous forme d’événements HTTP envoyés par le serveur (text/event-stream). Chaque paquet est envoyé comme un événement portant le nom correspondant : data, totals, extremes, progress, log, profile_events, exception. La progression et les autres paquets auxiliaires sont envoyés au format JSON. Comme les événements envoyés par le serveur constituent un protocole texte qui traite les sauts de ligne (y compris les retours chariot, \r) comme des délimiteurs, un bloc de données formatées est encodé en base64 dans un unique champ data de l’événement. Ce champ se décode en payload entièrement formaté, avec tous ses sauts de ligne ; le Content-Type contient un paramètre payload=base64 pour l’indiquer. Tout format de sortie peut ainsi être transporté exactement octet pour octet, qu’il soit textuel ou binaire.
• JSONEachPacketBase64 - chaque paquet est un objet JSON sur une ligne distincte et les données formatées sont encodées en base64, par exemple {"packet":"data","data":"eyJ4IjoxfQo="}. Convient aux formats de sortie binaires.
• JSONEachPacketString - chaque paquet est un objet JSON sur une ligne distincte et les données formatées sont placées dans une chaîne, par exemple {"packet":"data","data":"{\"x\":1}\n"}.

JSONEachPacketString place les octets du payload dans une chaîne JSON sans les valider ni les réencoder. Les colonnes String et FixedString peuvent contenir des octets arbitraires ; les formats de sortie textuels (tels que JSONEachRow, TSV ou CSV) peuvent donc émettre des valeurs UTF-8 non valides, tout comme le JSONEachRow natif de ClickHouse avec la valeur par défaut output_format_json_validate_utf8 = 0. Le flux NDJSON résultant n’est alors pas garanti comme étant en UTF-8 valide. Utilisez JSONEachPacketBase64 pour transporter des octets arbitraires exactement octet pour octet.

Exemple :

curl "http://localhost:8123/?framing_output_format=JSONEachPacketString" -d "SELECT number FROM numbers(3) FORMAT JSONEachRow"

Résultat :

{"packet":"data","data":"{\"number\":\"0\"}\n{\"number\":\"1\"}\n{\"number\":\"2\"}\n"}
{"packet":"profile_events","profile_events":[{"host_name":"localhost","current_time":"2026-07-11 00:00:00","thread_id":"0","type":"increment","name":"SelectedRows","value":"3"}]}
{"packet":"progress","progress":{"read_rows":"3","read_bytes":"24","total_rows_to_read":"3","result_rows":"3","result_bytes":"24","elapsed_ns":"1265958"}}

Active ou désactive fsync lors de l’écriture de fichiers .sql. Activé par défaut.

Il peut être judicieux de le désactiver si le serveur possède des millions de petites tables constamment créées et supprimées.

Si false, les fonctions h3, par exemple h3CellAreaM2, génèrent une exception si l’entrée n’est pas valide. Si true, elles renvoient 0 ou la valeur par défaut.

Si les quatre arguments des fonctions geoDistance, greatCircleDistance et greatCircleAngle sont de type Float64, celles-ci renvoient un Float64 et utilisent la double précision pour les calculs internes. Dans les versions précédentes de ClickHouse, ces fonctions renvoyaient toujours un Float32.

La fonction geoToH3 accepte (lon, lat) si le paramètre est réglé sur lon_lat, et (lat, lon) s'il est réglé sur lat_lon.

Nombre maximal d’adresses autorisées (pour les stockages externes, les fonctions table, etc.).

La fonction 'h3ToGeo' renvoie (lon, lat) si la valeur est true, sinon (lat, lon).

Délai d’expiration, en millisecondes, pour la réception du paquet Hello des répliques lors de la négociation initiale.

Délai d'expiration pour établir une connexion avec une réplique dans le cadre des requêtes hedged

Définit le nombre maximal de correspondances de surlignage par ligne dans la fonction highlight. Utilisez-le pour éviter une consommation excessive de mémoire lors du surlignage de motifs très répétitifs dans de longs textes.

Valeurs possibles :

• Entier positif.

Taille de la liste dynamique des candidats lors de la recherche dans l’index de similarité vectorielle, également appelée « ef_search ».

Durée d’expiration du HSTS. 0 signifie que le HSTS est désactivé.

Délai d’expiration avant la fermeture des connexions TCP inactives après le nombre de secondes spécifié.

Valeurs possibles :

• Entier positif (0 : fermeture immédiate, après 0 seconde).

Si ce paramètre est activé, 'ORDER BY rand()' est injecté dans les requêtes SELECT sans clause ORDER BY. S'applique uniquement à une profondeur de sous-requête = 0. Les sous-requêtes et INSERT INTO … SELECT ne sont pas affectés. Si la structure de premier niveau est UNION, 'ORDER BY rand()' est injecté indépendamment dans chacune des branches. Utile uniquement pour les tests et le développement (l'absence de ORDER BY est une source de résultats de requête non déterministes).

Remplace le format d'entrée de la requête. Prévaut sur le format spécifié dans la requête.

L’intervalle, en microsecondes, entre les vérifications de l’annulation de l’exécution de la requête et l’envoi de la progression.

Définit le mode par défaut de la requête INTERSECT. Valeurs possibles : chaîne vide, 'ALL', 'DISTINCT'. Si cette valeur est vide, une requête sans mode générera une exception.

S'il est activé, les fonctions 'least' et 'greatest' renvoient NULL si l'un de leurs arguments est NULL.

Répertorie tous les noms des éléments des grands littéraux tuple dans leurs noms de colonne au lieu d’un hachage. Ce paramètre n’existe que pour des raisons de compatibilité. Il est pertinent de le définir sur 'true' lors d’une mise à jour progressive du cluster d’une version inférieure à 21.7 vers une version supérieure.

Définit le nombre maximal de lignes à renvoyer dans le résultat de la requête. Ajuste la valeur définie par la clause LIMIT. La valeur est transmise à LIMIT et accepte tout ce que LIMIT accepte, y compris les valeurs négatives (comptées à partir de la fin du résultat) et les fractions dans (0, 1) (interprétées comme une proportion du résultat).

Valeurs possibles :

• 0 — Le nombre de lignes n’est pas limité.
• Entier positif — nombre exact de lignes.
• Entier négatif — renvoie les N dernières lignes.
• Nombre réel dans l’intervalle ouvert (0, 1) — renvoie cette fraction du résultat.

Ce paramètre détermine la forme des requêtes SELECT / UNION produisant un résultat. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que si le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — comme pour tout autre paramètre.

Charger les marks MergeTree de façon asynchrone

Valeur par défaut dans Cloud : 1.

Définit le nombre de secondes pendant lequel une demande de verrouillage attend avant d’échouer.

Le délai d’expiration du verrouillage est utilisé pour éviter les interblocages lors de l’exécution d’opérations de lecture/écriture sur des tables. Lorsque ce délai expire et que la demande de verrouillage échoue, le serveur ClickHouse lève une exception "Locking attempt timed out! Possible deadlock avoided. Client should retry." avec le code d’erreur DEADLOCK_AVOIDED.

Valeurs possibles :

• Entier positif (en secondes).
• 0 — Aucun délai d’expiration du verrouillage.

Lorsque le mécanisme de priorisation des requêtes est utilisé (voir le paramètre priority), les requêtes à faible priorité attendent la fin des requêtes de priorité plus élevée. Ce paramètre définit cette durée d'attente.

Créer un plan de requête distribuée.

Son activation ajuste automatiquement les paramètres qui contrôlent les fonctionnalités pas encore prises en charge par les plans de requêtes distribuées :

• enable_parallel_replicas = 0 et automatic_parallel_replicas_mode = 0 — le plan distribué assure sa propre répartition du travail ;
• correlated_subqueries_use_in_memory_buffer = 0 ;
• use_skip_indexes_on_data_read = 0 ;
• compile_expressions = 0 ;
• query_plan_direct_read_from_text_index = 0.

Lors de la création d'une table Merge sans schéma explicite ou lors de l'utilisation de la fonction de table merge, le schéma est inféré comme l'union d'au plus le nombre spécifié de tables correspondantes. S'il y a davantage de tables, le schéma sera inféré à partir des premières tables, jusqu'au nombre spécifié.

Si ce paramètre est activé, les tables MongoDB renverront une erreur lorsqu'une requête MongoDB ne peut pas être générée. Sinon, ClickHouse lit l'intégralité de la table et la traite localement. Cette option ne s'applique pas lorsque 'allow_experimental_analyzer=0'.

Ne pas ajouter d’alias à la liste des expressions de premier niveau lors de la réécriture de plusieurs JOIN

Ramener les noms de fonctions à leur forme canonique

Définit le nombre de lignes à ignorer avant de commencer à renvoyer les lignes de la requête. Ajuste le décalage défini par la clause OFFSET. La valeur est transmise à OFFSET et accepte tout ce que OFFSET accepte, y compris les valeurs négatives et les fractions dans (0, 1).

Valeurs possibles :

• 0 — Aucune ligne n’est ignorée.
• Entier positif.
• Entier négatif.
• Nombre réel dans la plage ouverte (0, 1) — ignore cette fraction du résultat.

Exemple

Table d’entrée :

CREATE TABLE test (i UInt64) ENGINE = MergeTree() ORDER BY i;
INSERT INTO test SELECT number FROM numbers(500);

Requête :

SET limit = 5;
SET offset = 7;
SELECT * FROM test LIMIT 10 OFFSET 100;

Résultat :

┌───i─┐
│ 107 │
│ 108 │
│ 109 │
└─────┘

Ce paramètre s’applique aux requêtes SELECT / UNION qui produisent des résultats. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que si le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — comme pour tout autre paramètre.

Ajoute une clause ORDER BY à la requête en l’enveloppant dans une sous-requête. Accepte une liste arbitraire d’expressions.

Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’enveloppant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause SETTINGS dans la requête ou un profil utilisateur.

Il s’applique aux requêtes SELECT / UNION produisant des résultats. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que lorsque le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — conformément à la règle de non-propagation qui s’applique à tout autre paramètre.

Surcharge le format de sortie de la requête. Prend le pas sur le format spécifié dans la requête, dans l’extension de fichier ou via default_format.

Définit le numéro de page des résultats paginés. Équivalent à offset = limit * (page - 1). Ne peut être spécifié que si limit est défini et que offset ne l’est pas. Les pages sont indexées à partir de 1. Prend en charge les mêmes valeurs négatives et fractionnaires que limit et offset.

Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’enveloppant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause SETTINGS dans la requête ou un profil utilisateur.

Il s’applique aux requêtes SELECT / UNION qui produisent des résultats. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que lorsque le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie dans l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — conformément à la règle de non-propagation applicable à tout autre paramètre.

Lecture ciblée d’un snapshot au niveau de la requête pour le mode incrémental de Paimon. Lorsque >0, le lecteur récupère uniquement le delta pour le snapshot_id spécifié sans faire progresser le watermark validé. Par défaut : -1 (désactivé)

Parallélise la sortie à l’étape de lecture depuis les stockages. Cela permet, lorsque c’est possible, de paralléliser le traitement des requêtes immédiatement après la lecture depuis les stockages.

Permet à la requête de renvoyer un résultat partiel après son annulation.

Enregistre les statistiques d’index pour chaque partie

Bloque dans la boucle d’attente des requêtes sur le serveur pendant le nombre de secondes spécifié.

Dialecte SQL source du transpileur polyglotte (par ex. 'sqlite', 'mysql', 'postgresql', 'snowflake', 'duckdb').

Probabilité approximative d’échec des requêtes PostgreSQL internes (utilisées pour la réplication). La valeur valide se situe dans l’intervalle [0.0f, 1.0f]

Collecte des statistiques sur la sélectivité des prédicats dans system.predicate_statistics_log. Lorsqu’il est défini sur N > 0, environ 1/N des requêtes sont échantillonnées (en fonction de l’identifiant de requête). 0 signifie désactivé.

La taille maximale du tampon de prélecture pour la lecture à partir du système de fichiers. Les valeurs supérieures à 256 MiB sont limitées à 256 MiB, car un tampon de lecture n’a jamais besoin d’être plus grand.

Permet d'afficher de façon lisible, avec des retraits, les noms de types profondément imbriqués dans la requête DESCRIBE et la fonction toTypeName().

Exemple :

CREATE TABLE test (a Tuple(b String, c Tuple(d Nullable(UInt64), e Array(UInt32), f Array(Tuple(g String, h Map(String, Array(Tuple(i String, j UInt64))))), k Date), l Nullable(String))) ENGINE=Memory;
DESCRIBE TABLE test FORMAT TSVRaw SETTINGS print_pretty_type_names=1;

a   Tuple(
    b String,
    c Tuple(
        d Nullable(UInt64),
        e Array(UInt32),
        f Array(Tuple(
            g String,
            h Map(
                String,
                Array(Tuple(
                    i String,
                    j UInt64
                ))
            )
        )),
        k Date
    ),
    l Nullable(String)
)

Priorité de la requête. 1 - la plus élevée ; plus la valeur est grande, plus la priorité est faible ; 0 - ne pas utiliser de priorités.

Active la transmission des rôles utilisateur de l’initiateur aux autres nœuds lors de l’exécution d’une requête.

Intervalle, en millisecondes, de collecte du query_metric_log pour les requêtes individuelles.

S'il est défini sur une valeur négative, il prendra la valeur collect_interval_milliseconds du paramètre query_metric_log ou utilisera 1000 par défaut si ce paramètre n'est pas présent.

Pour désactiver la collecte pour une requête donnée, définissez query_metric_log_interval sur 0.

Valeur par défaut : -1

Le temps d’attente dans la file de requêtes si le nombre de requêtes simultanées dépasse le maximum autorisé.

Le délai d’attente avant une nouvelle tentative de lecture depuis RabbitMQ.

0 - aucune restriction en mode lecture seule. 1 - uniquement les requêtes de lecture, ainsi que la modification des paramètres explicitement autorisés. 2 - uniquement les requêtes de lecture, ainsi que la modification des paramètres, à l'exception du paramètre 'readonly'.

Nombre maximal d’itérations pour déduire les types de colonnes dans les CTE récursives. Les types de colonnes sont déterminés en appliquant de manière itérative getLeastSupertype aux parties non récursive et récursive de l’UNION ALL jusqu’à convergence. Définissez cette valeur sur 0 pour désactiver l’élargissement des types et utiliser uniquement les types de la partie non récursive.

Définit le nombre maximal de correspondances d’une même expression régulière par ligne. Utilisez ce paramètre pour éviter une surcharge de mémoire lors de l’utilisation d’une expression régulière gourmande dans la fonction extractAllGroupsHorizontal.

Valeurs possibles :

• Entier positif.

Rejette les motifs dont l’évaluation avec hyperscan est susceptible d’être coûteuse (en raison d’une explosion du nombre d’états de l’AFN)

Si l’utilisation de la mémoire après une nouvelle fusion n’est pas réduite dans cette proportion, cette nouvelle fusion sera désactivée.

Nombre minimal d’octets requis pour qu’une lecture distante (URL, S3) effectue un seek, plutôt qu’une lecture avec ignore.

• Type: String

• Valeur par défaut : Chaîne vide

Ce paramètre permet de spécifier un modèle de renommage pour les fichiers traités par la fonction de table file. Lorsque cette option est définie, tous les fichiers lus par la fonction de table file sont renommés selon le modèle spécifié et ses espaces réservés, uniquement si leur traitement a réussi.

• %a — Nom de fichier d’origine complet (p. ex., "sample.csv").
• %f — Nom de fichier d’origine sans extension (p. ex., "sample").
• %e — Extension du fichier d’origine avec le point (p. ex., ".csv").
• %t — Horodatage (en microsecondes).
• %% — Signe de pourcentage ("%").

• Option : --rename_files_after_processing="processed_%f_%t%e"

• Requête : SELECT * FROM file('sample.csv')

Si sample.csv est lu avec succès, le fichier sera renommé en processed_sample_1683473210851438.csv

Indique combien de temps (en secondes) attendre que les répliques inactives exécutent les requêtes ALTER, OPTIMIZE ou TRUNCATE.

Valeurs possibles :

• 0 — Ne pas attendre.
• Entier négatif — Attendre indéfiniment.
• Entier positif — Nombre de secondes à attendre.

Utilisé dans la planification des charges de travail. Quantité minimale de RAM réservée à l’exécution d’une requête sur un seul serveur. La réservation s’effectue via la hiérarchie WORKLOAD à l’aide de la valeur du paramètre de requête workload. Si la charge de travail ne dispose pas de suffisamment de mémoire, une requête ne peut pas démarrer et reste en attente jusqu’à ce que la réservation puisse être honorée. Une valeur de 0 signifie qu’il n’y a pas de réservation. Ce paramètre ne prend effet que si la ressource MEMORY RESERVATION est créée.

Remplace le moteur de table ReplicatedMergeTree par SharedMergeTree lors de RESTORE.

Valeur par défaut Cloud : 1.

Définit le comportement à adopter si le volume du résultat dépasse l'une des limites.

Valeurs possibles :

• throw : lever une exception (par défaut).
• break : arrêter l'exécution de la requête et renvoyer un résultat partiel, comme si les données source étaient épuisées.

L'utilisation de 'break' est similaire à celle de LIMIT. Break interrompt l'exécution uniquement au niveau du block. Cela signifie que le nombre de lignes renvoyées est supérieur à max_result_rows, est un multiple de max_block_size et dépend de max_threads.

Exemple

SET max_threads = 3, max_block_size = 3333;
SET max_result_rows = 3334, result_overflow_mode = 'break';

SELECT *
FROM numbers_mt(100000)
FORMAT Null;

6666 rows in set. ...

Active la reprise de BACKUP FROM SNAPSHOT : une tentative ayant échoué peut être relancée sans recopier les entrées des lots déjà terminés. Disponible uniquement dans ClickHouse Cloud, pour les destinations S3 et AzureBlobStorage de type répertoire. L'activer dans les builds open source de ClickHouse, où BACKUP FROM SNAPSHOT n'est pas disponible, entraîne l'échec de BACKUP avec WRONG_BACKUP_SETTINGS.

Lorsqu’il est activé, ClickHouse fournit la valeur exacte de la statistique rows_before_aggregation, qui correspond au nombre de lignes lues avant l’agrégatio

S’il est activé, le serveur planifie la requête en arrière-plan, renvoie immédiatement un résultat vide indiquant la réussite, puis exécute la requête jusqu’à son terme, indépendamment de ce qui arrive à la connexion.

Une requête en arrière-plan ne survit pas à un redémarrage du serveur. Lors de l’arrêt, elle respecte les mêmes paramètres du serveur qu’une requête au premier plan : shutdown_wait_unfinished_queries détermine s’il faut l’annuler ou attendre qu’elle se termine (les entrées en file d’attente sont supprimées dans les deux cas, sans entrée dans system.query_log), et shutdown_wait_unfinished limite la durée pendant laquelle le serveur attend.

Suivez la requête à l’aide de son query_id : dans system.processes pendant son exécution et dans system.query_log après sa fin et l’écriture de l’entrée dans le journal des requêtes.

S’applique aux requêtes reçues via les protocoles TCP natif et HTTP. Via HTTP, transmettez le paramètre en tant que paramètre d’URL. Il ne peut pas être modifié avec SET ; activez-le par requête ou au niveau de l’utilisateur ou du profil.

Le principal cas d’utilisation est un long INSERT ... SELECT qui ne doit pas être perdu lorsque la connexion client est interrompue.

Active l’algorithme de filtrage groupé pour les indices. Il devrait toujours offrir de meilleures performances, mais ce paramètre est conservé pour des raisons de compatibilité et de contrôle.

Encapsule la requête dans une sous-requête avec une liste d’expressions SELECT explicite. Lorsqu’elle n’est pas vide, la requête qui produit des résultats est encapsulée dans SELECT <expr_list> FROM (<query>).

Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’encapsulant dans une table dérivée). Il se combine avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via un paramètre d’URL HTTP, une clause SETTINGS dans la requête ou un profil utilisateur.

Il détermine la forme des requêtes SELECT / UNION produisant des résultats. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que lorsque le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie dans l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — conformément à la règle de non-propagation applicable à tout autre paramètre.

Active ou désactive la cohérence séquentielle pour les requêtes SELECT. Nécessite que insert_quorum_parallel soit désactivé (activé par défaut).

Valeurs possibles :

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

Utilisation

Lorsque la cohérence séquentielle est activée, ClickHouse n’autorise l’exécution de la requête SELECT par le client que sur les répliques qui contiennent les données de toutes les requêtes INSERT précédentes exécutées avec insert_quorum. Si le client pointe vers une réplique incomplète, ClickHouse génère une exception. La requête SELECT n’inclura pas les données qui n’ont pas encore été écrites sur le quorum de répliques.

Lorsque insert_quorum_parallel est activé (par défaut), select_sequential_consistency ne fonctionne pas. En effet, les requêtes INSERT parallèles peuvent être écrites sur différents ensembles de répliques de quorum, sans garantie qu’une seule réplique ait reçu toutes les écritures.

Voir aussi :

• insert_quorum
• insert_quorum_timeout
• insert_quorum_parallel

Définit le fuseau horaire implicite de la session ou de la requête actuelle. Le fuseau horaire implicite est celui appliqué aux valeurs de type DateTime/DateTime64 pour lesquelles aucun fuseau horaire n’est explicitement spécifié. Ce paramètre a préséance sur le fuseau horaire implicite configuré globalement (au niveau du serveur). Une valeur de '' (chaîne vide) signifie que le fuseau horaire implicite de la session ou de la requête actuelle est celui du fuseau horaire du serveur.

Vous pouvez utiliser les fonctions timeZone() et serverTimeZone() pour obtenir le fuseau horaire de la session et celui du serveur.

Valeurs possibles :

• N’importe quel nom de fuseau horaire de system.time_zones, par exemple Europe/Berlin, UTC ou Zulu

Exemples :

SELECT timeZone(), serverTimeZone() FORMAT CSV

"Europe/Berlin","Europe/Berlin"

SELECT timeZone(), serverTimeZone() SETTINGS session_timezone = 'Asia/Novosibirsk' FORMAT CSV

"Asia/Novosibirsk","Europe/Berlin"

Attribuez au DateTime interne le fuseau horaire de session 'America/Denver', sans fuseau horaire explicitement spécifié :

SELECT toDateTime64(toDateTime64('1999-12-12 23:23:23.123', 3), 3, 'Europe/Zurich') SETTINGS session_timezone = 'America/Denver' FORMAT TSV

1999-12-13 07:23:23.123

CREATE TABLE test_tz (`d` DateTime('UTC')) ENGINE = Memory AS SELECT toDateTime('2000-01-01 00:00:00', 'UTC');

SELECT *, timeZone() FROM test_tz WHERE d = toDateTime('2000-01-01 00:00:00') SETTINGS session_timezone = 'Asia/Novosibirsk'
0 rows in set.

SELECT *, timeZone() FROM test_tz WHERE d = '2000-01-01 00:00:00' SETTINGS session_timezone = 'Asia/Novosibirsk'
┌

Cela s’explique par l’utilisation de chaînes d’analyse différentes :

• toDateTime() sans fuseau horaire explicitement indiqué, utilisé dans la première requête SELECT, respecte le paramètre session_timezone et le fuseau horaire global.
• Dans la deuxième requête, une valeur DateTime est analysée à partir d’une String et hérite du type et du fuseau horaire de la colonne existante d. Ainsi, le paramètre session_timezone et le fuseau horaire global ne sont pas pris en compte.

Voir aussi

• timezone

Définit ce qui se produit lorsque la quantité de données dépasse l’une des limites.

Valeurs possibles :

• throw : lever une exception (par défaut).
• break : arrêter l’exécution de la requête et renvoyer le résultat partiel, comme si les données source étaient épuisées.

Pour un seul JOIN, en cas d’ambiguïté d’identifiant, privilégier la table de gauche

Les alias redondants ne sont pas utilisés (substitués) dans les fonctions définies par l’utilisateur afin d’en simplifier l’utilisation.

Valeurs possibles :

• 1 — Les alias sont ignorés (substitués) dans les UDFs.
• 0 — Les alias ne sont pas ignorés (substitués) dans les UDFs.

Exemple

Différence entre l’état activé et désactivé :

Requête :

SET skip_redundant_aliases_in_udf = 0;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));

EXPLAIN SYNTAX SELECT test_03274(4 + 2);

Résultat :

SELECT ((4 + 2) + 1 AS y, y + 2)

Requête :

SET skip_redundant_aliases_in_udf = 1;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));

EXPLAIN SYNTAX SELECT test_03274(4 + 2);

Résultat :

SELECT ((4 + 2) + 1, ((4 + 2) + 1) + 2)

Durée d’attente après réception d’une requête dans TCPHandler

Contrôle le format binaire de transmission utilisé pour la compression snappy sur les chemins d’E/S de fichiers génériques tels que file et url. HTTP Content-Encoding: snappy utilise toujours le format de tramage et ignore ce paramètre.

Notez que le format brut de bloc snappy produit par un seul appel à snappy::Compress (par exemple, les charges utiles du protocole distant Prometheus gérées par SnappyBasicReadBuffer) est un format binaire de transmission distinct, propre au protocole, et n’est pas contrôlé par ce paramètre.

Valeurs possibles :

• basic — format de bloc Hadoop snappy. Compatible avec les fichiers lus et écrits par Hadoop. Prend en charge la lecture et l’écriture.
• framed — format de tramage Snappy, le format de streaming standard défini par Google. Prend en charge la lecture et l’écriture.

Ajoute une clause ORDER BY simple à la requête en l’enveloppant dans une sous-requête. Accepte une liste d’identifiants ou de références positionnelles à des colonnes (entiers positifs), séparées par des virgules, avec un préfixe facultatif + (ASC) ou - (DESC). Exemple : sort=a,-b trie selon a par ordre croissant et b par ordre décroissant ; sort=1,-2 trie selon la première colonne par ordre croissant et la deuxième par ordre décroissant. Ne peut pas être combiné avec order.

Il s’agit d’un paramètre de construction de requête appliqué par le moteur à la requête analysée (en l’encapsulant dans une table dérivée). Il se combine donc avec la requête existante et fonctionne avec tous les protocoles : il peut être fourni via le paramètre d’URL HTTP, une clause SETTINGS dans la requête ou un profil utilisateur.

Il s’applique aux requêtes SELECT / UNION produisant des résultats. Pour une requête d’écriture (INSERT … SELECT, CREATE … AS SELECT), il ne prend effet que si le SELECT source l’inclut dans sa propre clause SETTINGS ; une valeur héritée d’un profil ou d’une session, ou définie sur l’instruction INSERT / CREATE elle-même, ne se propage pas au SELECT source — conformément à la règle de non-propagation qui s’applique à tout autre paramètre.

Définit ce qui se produit si le nombre de lignes reçues avant le tri dépasse l'une des limites.

Valeurs possibles :

• throw : lever une exception.
• break : arrêter l'exécution de la requête et renvoyer un résultat partiel.

Contrôle si la fonction splitBy*(), avec l'argument max_substrings > 0, inclut la chaîne restante dans le dernier élément du tableau résultant.

Valeurs possibles :

• 0 - La chaîne restante ne sera pas incluse dans le dernier élément du tableau résultant.
• 1 - La chaîne restante sera incluse dans le dernier élément du tableau résultant. Il s'agit du comportement de la fonction split() de Spark et de la méthode 'string.split()' de Python.

La taille maximale de l'ensemble situé à droite de l'opérateur IN pour laquelle l'estimateur de sélectivité détermine les plages exactes couvertes par l'ensemble. Cette opération nécessite un Field par élément, un tri et une sonde de statistiques par élément, ce qui, pour un grand ensemble, représente la majeure partie de la planification de la requête. Au-delà de cette limite, l'estimateur détermine plutôt la sélectivité à partir de la taille de l'ensemble et de sa plage englobante, en un seul parcours linéaire de l'ensemble, sans tri ni sondes de statistiques par élément. Zéro signifie qu'il n'y a pas de limite.

Au démarrage du serveur, empêche la programmation des vues matérialisées actualisables, comme avec SYSTEM STOP VIEWS. Vous pouvez ensuite les démarrer manuellement avec SYSTEM START VIEWS ou SYSTEM START VIEW <name>. S’applique également aux vues nouvellement créées. N’a aucun effet sur les vues matérialisées non actualisables.

Le temps, en secondes, pendant lequel la connexion doit rester inactive avant que TCP ne commence à envoyer des sondes keepalive

Délai d'attente pour verrouiller le cache lors de la réservation d'espace pour les données temporaires dans le cache du système de fichiers

Autorise ou interdit les INSERT vides. Ce paramètre est activé par défaut (et déclenche une erreur en cas d'insert vide). S'applique uniquement aux INSERT effectués avec clickhouse-client ou via l'interface gRPC.

Lit dans la table d’échantillons récents d’une table TimeSeries plutôt que dans la table d’échantillons principale lorsque l’intervalle de temps demandé est entièrement inclus dans la fenêtre TTL de la table d’échantillons récents (voir le paramètre recent_samples_ttl_seconds du moteur de table TimeSeries).

Vérifie que la vitesse d'exécution n'est pas trop faible (pas inférieure à min_execution_speed), une fois le délai spécifié en secondes écoulé.

Détermine ce qui se passe lorsque la quantité de données dépasse l'une des limites.

Valeurs possibles :

• throw : lever une exception (par défaut).
• break : arrêter l'exécution de la requête et renvoyer un résultat partiel, comme si les données source étaient épuisées.

Active l'égalité des valeurs NULL pour l'opérateur IN.

Par défaut, les valeurs NULL ne peuvent pas être comparées, car NULL désigne une valeur indéfinie. Ainsi, la comparaison expr = NULL doit toujours renvoyer false. Avec ce paramètre, NULL = NULL renvoie true pour l'opérateur IN.

Valeurs possibles :

• 0 — La comparaison des valeurs NULL avec l'opérateur IN renvoie false.
• 1 — La comparaison des valeurs NULL avec l'opérateur IN renvoie true.

Exemple

Considérez la table null_in :

┌──idx─┬─────i─┐
│    1 │     1 │
│    2 │  NULL │
│    3 │     3 │
└──────┴───────┘

Requête :

SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 0;

Résultat :

┌──idx─┬────i─┐
│    1 │    1 │
└──────┴──────┘

Requête :

SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 1;

Résultat :

┌──idx─┬─────i─┐
│    1 │     1 │
│    2 │  NULL │
└──────┴───────┘

Voir aussi

• Traitement de NULL dans les opérateurs IN

Parcourir les données gelées (répertoire shadow) en plus des données réelles de la table lors de l'interrogation de system.remote_data_paths

Définit un mode de combinaison des résultats des requêtes SELECT. Ce paramètre n'est utilisé que lorsqu'il est employé avec UNION sans préciser explicitement UNION ALL ou UNION DISTINCT.

Valeurs possibles :

• 'DISTINCT' — ClickHouse renvoie les lignes issues de la combinaison de requêtes en supprimant les lignes dupliquées.
• 'ALL' — ClickHouse renvoie toutes les lignes issues de la combinaison de requêtes, y compris les lignes dupliquées.
• '' — ClickHouse génère une exception lorsqu'il est utilisé avec UNION.

Voir des exemples dans UNION.

Envoyer un paquet inconnu à la place du n-ième paquet de données

Lorsqu'une fonction est appliquée à une colonne Variant à l'aide de l'implémentation par défaut, contrôle ce qui se passe pour les lignes dont le type réel est incompatible avec la fonction :

• true (par défaut) — lever une exception.
• false — renvoyer NULL pour ces lignes à la place.

Attendre que les modifications validées deviennent réellement visibles dans le snapshot le plus récent

Nom de la charge de travail à utiliser pour accéder aux ressources

Écrit les chemins complets (y compris s3://) dans les fichiers de métadonnées Iceberg.

Permet de définir la taille maximale du journal de fenêtre de ZSTD (ne sera pas utilisé pour la famille MergeTree)