Autres paramètres de session

Paramètres de session ClickHouse du groupe généré « Autres ».

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

​

adaptive_aggregator_freeze_threshold

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.

​

add_http_cors_header

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

​

analyze_index_with_space_filling_curves

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.

​

analyzer_inline_views

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.

​

any_join_distinct_right_table_keys

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

Utilisez ce paramètre uniquement pour assurer la rétrocompatibilité si vos cas d’usage dépendent du comportement legacy de 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

​

archive_adaptive_buffer_max_size_bytes

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

​

arrow_flight_request_descriptor_type

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)

​

backup_slow_all_threads_after_retryable_s3_error

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.

​

cache_warmer_threads

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.

​

calculate_text_stack_trace

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.

​

cancel_http_readonly_queries_on_client_close

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.

​

checksum_on_read

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.

​

compression

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é).

​

connection_pool_max_wait_ms

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.

​

connections_with_failover_max_tries

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

​

convert_query_to_cnf

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

​

count_matches_stop_at_empty_match

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

​

cross_to_inner_join_rewrite

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

​

data_type_default_nullable

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.

​

decimal_check_overflow

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

​

deduplicate_blocks_in_dependent_materialized_views

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

​

defer_partition_pruning_after_final

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).

​

describe_compact_output

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

​

dialecte

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.

​

discard_query_data

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.

​

distinct_overflow_mode

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.

​

do_not_merge_across_partitions_select_final

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.

​

dynamic_throw_on_type_mismatch

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.

​

enforce_strict_identifier_format

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

​

engine_url_skip_empty_files

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.

​

exact_rows_before_limit

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.

​

except_default_mode

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.

​

exclude_materialize_skip_indexes_on_insert

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

​

execute_exists_as_scalar_subquery

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.

​

explain_query_plan_default

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.

​

extract_key_value_pairs_max_pairs_per_row

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.

​

extremes

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 ».

​

fallback_to_stale_replicas_for_distributed_queries

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é).

​

file_like_engine_default_partition_strategy

Stratégie de partitionnement par défaut pour les moteurs de type fichier. S’applique uniquement lorsque le chemin ne contient pas d’espace réservé {_partition_id} : un tel chemin n’est compatible qu’avec la stratégie wildcard et implique donc toujours wildcard.

​

filesystem_prefetches_limit

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.

​

filter

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.

filter n’est pas un mécanisme de contrôle d’accès et ne doit pas être utilisé à la place des politiques de sécurité au niveau des lignes ou du paramètre additional_table_filters. Il ajoute uniquement une clause WHERE à la sous-requête enveloppante ; les données sous-jacentes sont donc toujours lues et traitées avant l’application du filtre — une requête peut observer les lignes exclues par le filtre pendant leur traitement (par exemple, avec throwIf afin de divulguer des informations par le biais du chemin d’erreur). Utilisez la sécurité au niveau des lignes ou additional_table_filters pour restreindre les lignes auxquelles un utilisateur peut accéder.

​

final

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;
┌─key─┬─some───┐
│   1 │ second │
└─────┴────────┘
┌─key─┬─some──┐
│   1 │ first │
└─────┴───────┘

SELECT * FROM test SETTINGS final = 1;
┌─key─┬─some───┐
│   1 │ second │
└─────┴────────┘

SET final = 1;
SELECT * FROM test;
┌─key─┬─some───┐
│   1 │ second │
└─────┴────────┘

​

finalize_projection_parts_synchronously

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.

​

flatten_nested

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 │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

​

format

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.

​

framing_output_format

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"}}

​

fsync_metadata

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.

​

functions_h3_default_if_invalid

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.

​

geo_distance_returns_float64_on_float64_arguments

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.

​

geotoh3_argument_order

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.

​

glob_expansion_max_elements

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

​

h3togeo_lon_lat_result_order

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

​

handshake_timeout_ms

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

​

hedged_connection_timeout_ms

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

​

highlight_max_matches_per_row

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.

​

hnsw_candidate_list_size_for_search

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

​

hsts_max_age

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

​

idle_connection_timeout

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).

​

inject_random_order_for_select_without_order_by

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).

​

input_format

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

​

interactive_delay

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.

​

intersect_default_mode

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.

​

least_greatest_legacy_null_behavior

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

​

legacy_column_name_of_tuple_literal

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.

​

limit

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.

​

load_marks_asynchronously

Charger les marks MergeTree de façon asynchrone

Valeur par défaut dans Cloud : 1.

​

lock_acquire_timeout

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.

​

low_priority_query_wait_time_ms

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.

​

make_distributed_plan

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.

​

merge_table_max_tables_to_look_for_schema_inference

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é.

​

mongodb_throw_on_unsupported_query

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’.

​

multiple_joins_try_to_keep_original_names

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

​

normalize_function_names

Ramener les noms de fonctions à leur forme canonique

​

offset

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.

​

order

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.

​

output_format

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.

​

page

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.

​

paimon_target_snapshot_id

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é)

​

parallelize_output_from_storages

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.

​

partial_result_on_first_cancel

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

​

per_part_index_stats

Enregistre les statistiques d’index pour chaque partie

​

poll_interval

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

​

polyglot_dialect

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

​

postgresql_fault_injection_probability

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]

​

predicate_statistics_sample_rate

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é.

​

prefetch_buffer_size

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.

​

print_pretty_type_names

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

​

priority

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.

​

push_external_roles_in_interserver_queries

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

​

query_metric_log_interval

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

​

queue_max_wait_ms

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

​

rabbitmq_max_wait_ms

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

​

readonly

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’.

​

recursive_cte_max_steps_in_type_inference

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.

​

regexp_max_matches_per_row

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.

​

reject_expensive_hyperscan_regexps

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)

​

remerge_sort_lowered_memory_bytes_ratio

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.

​

remote_read_min_bytes_for_seek

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

​

rename_files_after_processing

• 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.

​

Marqueurs de substitution

• %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 (”%”).

​

Exemple

• 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

​

replication_wait_for_inactive_replica_timeout

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.

​

reserve_memory

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.

​

restore_replicated_merge_tree_to_shared_merge_tree

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

Valeur par défaut Cloud : 1.

​

result_overflow_mode

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

Query

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

SELECT *
FROM numbers_mt(100000)
FORMAT Null;

Result

6666 rows in set. ...

​

rows_before_aggregation

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

​

secondary_indices_enable_bulk_filtering

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.

​

select

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.

​

select_sequential_consistency

Le comportement de ce paramètre diffère entre SharedMergeTree et ReplicatedMergeTree. Voir la cohérence de SharedMergeTree pour plus d’informations sur le comportement de select_sequential_consistency dans SharedMergeTree.

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

​

session_timezone

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

Toutes les fonctions qui analysent des valeurs DateTime/DateTime64 ne respectent pas session_timezone. Cela peut entraîner des erreurs subtiles. Voir l’exemple et l’explication ci-dessous.

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'
┌───────────────────d─┬─timeZone()───────┐
│ 2000-01-01 00:00:00 │ 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

​

set_overflow_mode

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.

​

single_join_prefer_left_table

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

​

skip_redundant_aliases_in_udf

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)

​

sleep_after_receiving_query_ms

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

​

snappy_mode

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.

​

sort

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.

​

sort_overflow_mode

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.

​

splitby_max_substrings_includes_remaining_string

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.

​

stop_refreshable_materialized_views_on_startup

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.

​

tcp_keep_alive_timeout

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

​

temporary_data_in_cache_reserve_space_wait_lock_timeout_milliseconds

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

​

throw_if_no_data_to_insert

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.

​

timeout_before_checking_execution_speed

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é.

​

transfer_overflow_mode

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.

​

transform_null_in

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

​

traverse_shadow_remote_data_paths

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

​

union_default_mode

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.

​

unknown_packet_in_send_data

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

​

variant_throw_on_type_mismatch

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.

​

wait_changes_become_visible_after_commit_mode

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

​

workload

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

​

write_full_path_in_iceberg_metadata

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

​

zstd_window_log_max

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