> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Paramètres des formats > Paramètres contrôlant les formats d’entrée et de sortie. export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => { const cells = [["Type", {type}], ["Valeur par défaut", {default_value}]]; if (changeable_without_restart) { const isYes = String(changeable_without_restart).trim().toLowerCase() === "yes"; const badge = isYes ? Oui : Non; cells.push(["Modifiable sans redémarrage", badge]); } return {cells.map(([h]) => )} {cells.map(([h, v]) => )}

{h}
{v}

; }; export const galaxyOnClick = eventName => () => { try { if (typeof window !== "undefined" && window.galaxy && eventName) { window.galaxy.track(eventName, { interaction: "click" }); } } catch (e) {} }; export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => { if (link) { return Beta ; } return

Fonctionnalité en bêta. En savoir plus.

; }; export const ExperimentalBadge = () => { return

Fonctionnalité expérimentale. En savoir plus.

; }; Ces paramètres sont générés automatiquement à partir du [code source](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/FormatFactorySettings.h).

## allow\_special\_bool\_values\_inside\_variant

Permet d'interpréter les valeurs Bool à l'intérieur du type Variant à partir de valeurs booléennes textuelles spéciales comme "on", "off", "enable", "disable", etc.

## bool\_false\_representation

Texte utilisé pour représenter la valeur booléenne false dans les formats TSV/CSV/Vertical/Pretty.

## bool\_true\_representation

Texte utilisé pour représenter la valeur booléenne `true` dans les formats TSV/CSV/Vertical/Pretty.

## check\_conversion\_from\_numbers\_to\_enum

Lève une exception lors de la conversion de Numbers en Enum si la valeur n'existe pas dans Enum. Valeurs possibles : * 0 — Désactivé. * 1 — Activé. **Exemple** ```text theme={null} CREATE TABLE tab ( val Enum('first' = 1, 'second' = 2, 'third' = 3) ) ENGINE = Memory; INSERT INTO tab SETTINGS check_conversion_from_numbers_to_enum = 1 VALUES (4); -- returns an error ```

## column\_names\_for\_schema\_inference

La liste des noms de colonnes à utiliser pour l’inférence du schéma dans les formats dépourvus de noms de colonnes. Format : 'column1,column2,column3,...'

## date\_time\_64\_output\_format\_cut\_trailing\_zeros\_align\_to\_groups\_of\_thousands

Supprime dynamiquement les zéros finaux des valeurs datetime64 afin d'ajuster l'échelle de sortie à \[0, 3, 6], correspondant à « secondes », « millisecondes » et « microsecondes »

## date\_time\_input\_format

Permet de choisir un parseur pour la représentation textuelle de la date et de l’heure. Ce paramètre ne s’applique pas aux [fonctions de date et d’heure](/fr/reference/functions/regular-functions/date-time-functions). Valeurs possibles : * `'best_effort'` — Active le parsing étendu. ClickHouse peut analyser le format de base `YYYY-MM-DD HH:MM:SS` ainsi que tous les formats de date et d’heure [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601). Par exemple, `'2018-06-08T01:02:03.000Z'`. * `'best_effort_us'` — Semblable à `best_effort` (voir la différence avec [parseDateTimeBestEffortUS](/fr/reference/functions/regular-functions/type-conversion-functions#parseDateTimeBestEffortUS) * `'basic'` — Utilise le parseur de base. ClickHouse peut analyser uniquement le format de base `YYYY-MM-DD HH:MM:SS` ou `YYYY-MM-DD`. Par exemple, `2019-08-20 10:18:56` ou `2019-08-20`. Voir aussi : * [Type de données DateTime.](/fr/reference/data-types/datetime) * [Fonctions de manipulation des dates et heures.](/fr/reference/functions/regular-functions/date-time-functions)

## date\_time\_output\_format

Permet de choisir différents formats de sortie pour la représentation textuelle de la date et de l’heure. Valeurs possibles : * `simple` - Format de sortie simple. ClickHouse affiche la date et l’heure au format `YYYY-MM-DD hh:mm:ss`. Par exemple, `2019-08-20 10:18:56`. Le calcul est effectué selon le fuseau horaire du type de données (s’il est présent) ou celui du serveur. * `iso` - Format de sortie ISO. ClickHouse affiche la date et l’heure au format [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) `YYYY-MM-DDThh:mm:ssZ`. Par exemple, `2019-08-20T10:18:56Z`. Notez que la sortie est en UTC (`Z` signifie UTC). * `unix_timestamp` - Format de sortie Unix timestamp. ClickHouse affiche la date et l’heure au format [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time). Par exemple, `1566285536`. Voir aussi : * [Type de données DateTime.](/fr/reference/data-types/datetime) * [Fonctions pour manipuler les dates et les heures.](/fr/reference/functions/regular-functions/date-time-functions)

## date\_time\_overflow\_behavior

Définit le comportement lorsque [Date](/fr/reference/data-types/date), [Date32](/fr/reference/data-types/date32), [DateTime](/fr/reference/data-types/datetime), [DateTime64](/fr/reference/data-types/datetime64) ou des entiers sont convertis en Date, Date32, DateTime ou DateTime64, mais que la valeur ne peut pas être représentée dans le type de résultat. Valeurs possibles : * `ignore` — Ignore les dépassements sans signaler d'erreur. Les résultats sont indéfinis. * `throw` — Lève une exception en cas de dépassement. * `saturate` — Sature le résultat. Si la valeur est inférieure à la plus petite valeur pouvant être représentée par le type cible, le résultat retenu est la plus petite valeur représentable. Si la valeur est supérieure à la plus grande valeur pouvant être représentée par le type cible, le résultat retenu est la plus grande valeur représentable. Valeur par défaut : `ignore`.

## errors\_output\_format

Méthode d’écriture des erreurs dans la sortie texte.

## format\_avro\_schema\_registry\_connection\_timeout

Pour le format AvroConfluent : délai d’expiration de connexion, en secondes, du client HTTP Confluent Schema Registry. Utilisé à la fois pour la récupération du schéma et son enregistrement. Doit être supérieur à 0 et inférieur à 600 (10 minutes).

## format\_avro\_schema\_registry\_max\_retries

Pour le format AvroConfluent : nombre maximal de réessais en cas d'échecs transitoires lors de la communication avec le Confluent Schema Registry (dépassements de délai de transport, connexion refusée, erreurs DNS, HTTP 5xx/408/429). Définissez la valeur sur 0 pour désactiver les réessais. La valeur maximale autorisée est 20. Les erreurs de validation du schéma (HTTP 409, JSON Avro mal formé) ne font pas l'objet de réessais.

## format\_avro\_schema\_registry\_receive\_timeout

Pour le format AvroConfluent : délai d’attente de réception, en secondes, du client HTTP de Confluent Schema Registry. Utilisé à la fois pour la récupération du schéma et l’enregistrement du schéma. Doit être supérieur à 0 et inférieur à 600 (10 minutes).

## format\_avro\_schema\_registry\_retry\_initial\_backoff\_ms

Pour le format AvroConfluent : backoff initial, en millisecondes, avant de réessayer une requête Confluent Schema Registry qui a échoué. Le backoff double à chaque nouvelle tentative, avec un plafond de 10 secondes. Doit être supérieur à 0 et inférieur ou égal à 60000.

## format\_avro\_schema\_registry\_send\_timeout

Pour le format AvroConfluent : délai d'expiration d'envoi, en secondes, du client HTTP Confluent Schema Registry. Utilisé à la fois pour la récupération du schéma et l'enregistrement du schéma. Doit être supérieur à 0 et inférieur à 600 (10 minutes).

## format\_avro\_schema\_registry\_url

Pour le format AvroConfluent : URL de Confluent Schema Registry.

## format\_binary\_max\_array\_size

Taille maximale autorisée pour Array au format RowBinary. Cela évite d’allouer une grande quantité de mémoire en cas de données corrompues. 0 signifie qu’il n’y a pas de limite

## format\_binary\_max\_object\_size

Le nombre maximal de chemins autorisé dans un même objet pour le format RowBinary du type JSON. Cela évite d’allouer une grande quantité de mémoire en cas de données corrompues. 0 signifie qu’il n’y a pas de limite

## format\_binary\_max\_string\_size

Taille maximale autorisée pour String au format RowBinary. Ce paramètre empêche l'allocation d'une grande quantité de mémoire en cas de données corrompues. 0 signifie qu'il n'y a pas de limite

## format\_capn\_proto\_enum\_comparising\_mode

Comment faire correspondre les Enum ClickHouse et CapnProto

## format\_capn\_proto\_max\_message\_size

Taille maximale d’un message CapnProto unique, en octets. Cela protège contre des données mal formées ou corrompues pouvant entraîner une allocation excessive de mémoire. La valeur par défaut est de 1 GiB.

## format\_capn\_proto\_use\_autogenerated\_schema

Utilise le schéma CapnProto généré automatiquement lorsque format\_schema n’est pas défini

## format\_csv\_allow\_double\_quotes

S'il est défini sur true, autorise les chaînes de caractères entre guillemets doubles.

## format\_csv\_allow\_single\_quotes

S'il est défini sur true, autorise les chaînes entre guillemets simples.

## format\_csv\_delimiter

Caractère utilisé comme délimiteur dans les données CSV. Si ce paramètre est défini avec une chaîne, celle-ci doit avoir une longueur de 1.

## format\_csv\_null\_representation

Représentation personnalisée de NULL au format CSV

## format\_custom\_escaping\_rule

Règle d’échappement des champs (pour le format CustomSeparated)

## format\_custom\_field\_delimiter

Délimiteur entre les champs (format CustomSeparated)

## format\_custom\_result\_after\_delimiter

Suffixe après le jeu de résultats (pour le format CustomSeparated)

## format\_custom\_result\_before\_delimiter

Préfixe précédant le jeu de résultats (pour le format CustomSeparated)

## format\_custom\_row\_after\_delimiter

Délimiteur après le champ de la dernière colonne (format CustomSeparated)

## format\_custom\_row\_before\_delimiter

Délimiteur avant le champ de la première colonne (format CustomSeparated)

## format\_custom\_row\_between\_delimiter

Délimiteur entre les lignes (pour le format CustomSeparated)

## format\_display\_secrets\_in\_show\_and\_select

Active ou désactive l’affichage des secrets dans les requêtes `SHOW` et `SELECT` pour les tables, les bases de données, les fonctions de table et les dictionnaires. L’utilisateur qui souhaite voir les secrets doit également avoir le [`display_secrets_in_show_and_select` paramètre du serveur](/fr/reference/settings/server-settings/settings#display_secrets_in_show_and_select) activé et disposer du [`displaySecretsInShowAndSelect`](/fr/reference/statements/grant#displaysecretsinshowandselect) privilège. Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## format\_json\_object\_each\_row\_column\_for\_object\_name

Nom de la colonne utilisée pour stocker/écrire les noms d’objet au format [JSONObjectEachRow](/fr/reference/formats/JSON/JSONObjectEachRow). Le type de la colonne doit être String. Si la valeur est vide, les noms d’objet par défaut `row_{i}` seront utilisés.

## format\_protobuf\_use\_autogenerated\_schema

Utiliser un Protobuf autogénéré lorsque format\_schema n’est pas défini

## format\_regexp

Expression régulière (pour le format Regexp)

## format\_regexp\_escaping\_rule

Règle d'échappement du champ (pour le format Regexp)

## format\_regexp\_skip\_unmatched

Ignorer les lignes ne correspondant pas à l'expression régulière (pour le format Regexp)

## format\_schema

Ce paramètre est utile lorsque vous utilisez des formats qui nécessitent une définition de schéma, comme [Cap'n Proto](https://capnproto.org/) ou [Protobuf](https://developers.google.com/protocol-buffers/). Sa valeur dépend du format.

## format\_schema\_message\_name

Définit le nom du message requis dans le schéma défini par `format_schema`. Pour assurer la compatibilité avec le format `format_schema` legacy (`file_name:message_name`) : * Si `format_schema_message_name` n'est pas spécifié, le nom du message est déduit de la partie `message_name` de la valeur `format_schema` legacy. * Si `format_schema_message_name` est spécifié lors de l'utilisation du format legacy, une erreur est générée.

## format\_schema\_source

Définit la source de `format_schema`. Valeurs possibles : * 'file' (par défaut) : `format_schema` est le nom d’un fichier de schéma situé dans le répertoire `format_schemas`. * 'string' : `format_schema` correspond au contenu littéral du schéma. * 'query' : `format_schema` est une requête permettant de récupérer le schéma. Lorsque `format_schema_source` est défini sur 'query', les conditions suivantes s’appliquent : * La requête doit renvoyer exactement une valeur : une seule ligne avec une seule colonne de type chaîne. * Le résultat de la requête est traité comme le contenu du schéma. * Ce résultat est mis en cache localement dans le répertoire `format_schemas`. * Vous pouvez vider le cache local à l’aide de la commande : `SYSTEM DROP FORMAT SCHEMA CACHE FOR Files`. * Une fois mis en cache, les requêtes identiques ne sont plus exécutées pour récupérer à nouveau le schéma tant que le cache n’est pas explicitement vidé * En plus des fichiers du cache local, les messages Protobuf sont également mis en cache en mémoire. Même après avoir vidé les fichiers du cache local, le cache en mémoire doit être vidé à l’aide de `SYSTEM DROP FORMAT SCHEMA CACHE [FOR Protobuf]` pour actualiser complètement le schéma. * Exécutez la requête `SYSTEM DROP FORMAT SCHEMA CACHE` pour vider en une seule fois le cache des fichiers et celui des schémas des messages Protobuf.

## format\_template\_resultset

Chemin d’accès au fichier contenant la chaîne de format du jeu de résultats (pour le format Template)

## format\_template\_resultset\_format

Chaîne de format du jeu de résultats (pour le format Template)

## format\_template\_row

Chemin du fichier contenant la chaîne de format des lignes (pour le format Template)

## format\_template\_row\_format

Chaîne de format pour les lignes (pour le format Template)

## format\_template\_rows\_between\_delimiter

Délimiteur entre les lignes (format Template)

## format\_tsv\_null\_representation

Représentation NULL personnalisée pour le format TSV

## input\_format\_allow\_errors\_num

Définit le nombre maximal d’erreurs tolérées lors de la lecture de formats texte (CSV, TSV, etc.). La valeur par défaut est 0. Utilisez-le toujours avec `input_format_allow_errors_ratio`. Si une erreur se produit lors de la lecture de lignes, mais que le compteur d’erreurs reste inférieur à `input_format_allow_errors_num`, ClickHouse ignore la ligne et passe à la suivante. Si `input_format_allow_errors_num` et `input_format_allow_errors_ratio` sont tous deux dépassés, ClickHouse lève une exception.

## input\_format\_allow\_errors\_ratio

Définit le pourcentage maximal d’erreurs autorisées lors de la lecture de formats texte (CSV, TSV, etc.). Le pourcentage d’erreurs est exprimé sous la forme d’un nombre à virgule flottante compris entre 0 et 1. La valeur par défaut est 0. Utilisez-le toujours avec `input_format_allow_errors_num`. Si une erreur survient lors de la lecture des lignes, mais que le compteur d’erreurs reste inférieur à `input_format_allow_errors_ratio`, ClickHouse ignore la ligne et passe à la suivante. Si `input_format_allow_errors_num` et `input_format_allow_errors_ratio` sont tous deux dépassés, ClickHouse lève une exception.

## input\_format\_allow\_seeks

Autorise les accès directs (ou les lectures par plage) lors de la lecture des formats d’entrée ORC, Parquet et Arrow. Lorsqu’elle est activée et que la source le permet (par exemple un fichier local, S3, ou HTTP avec prise en charge des plages et taille connue), ClickHouse peut ne lire que les plages d’octets nécessaires et utiliser moins de mémoire. Lorsqu’elle est désactivée, ou lorsque la source ne permet pas les accès directs (par exemple si la taille du fichier est inconnue ou si le flux ne permet pas le repositionnement), certains lecteurs peuvent alors se rabattre sur le chargement du fichier entier en mémoire. Activée par défaut.

## input\_format\_arrow\_allow\_missing\_columns

Autoriser les colonnes manquantes lors de la lecture des formats d’entrée Arrow

## input\_format\_arrow\_case\_insensitive\_column\_matching

Ignore la casse lors de la correspondance entre les colonnes Arrow et les colonnes CH.

## input\_format\_arrow\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference

Ignorer les colonnes de types non pris en charge lors de l’inférence du schéma pour le format Arrow

## input\_format\_avro\_allow\_missing\_fields

Pour le format Avro/AvroConfluent : lorsqu’un champ est introuvable dans le schéma, utiliser la valeur par défaut au lieu de renvoyer une erreur

## input\_format\_avro\_null\_as\_default

Pour le format Avro/AvroConfluent : insérer la valeur par défaut en cas de NULL dans une colonne non Nullable

## input\_format\_binary\_decode\_types\_in\_binary\_format

Lire les types de données au format binaire au lieu des noms de type dans le format d'entrée RowBinaryWithNamesAndTypes

## input\_format\_binary\_max\_type\_complexity

Nombre maximal de nœuds de type lors du décodage des types binaires (il ne s'agit pas de la profondeur, mais du nombre total). `Map(String, UInt32)` = 3 nœuds. Protège contre les données malveillantes. 0 = illimité.

## input\_format\_binary\_read\_json\_as\_string

Lit les valeurs du type de données [JSON](/fr/reference/data-types/newjson) comme des valeurs [String](/fr/reference/data-types/string) JSON dans le format d’entrée RowBinary.

## input\_format\_bson\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference

Ignore les champs dont les types ne sont pas pris en charge lors de l’inférence du schéma pour le format BSON.

## input\_format\_capn\_proto\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference

Ignorer les colonnes dont les types ne sont pas pris en charge lors de l’inférence du schéma pour le format CapnProto

## input\_format\_column\_name\_matching\_mode

Définit le mode de correspondance des noms de colonnes lors de l’ingestion de données via différents formats (notamment JSONEachRow, CSVWithNames, JSONColumns, BSONEachRow et RowBinaryWithNames). Modes pris en charge : * match\_case : correspondance sensible à la casse * ignore\_case : correspondance insensible à la casse * auto : essaie d’abord une correspondance sensible à la casse ; en cas d’échec, essaie une correspondance insensible à la casse.

## input\_format\_connection\_handling

Lorsque cette option est activée, si la connexion se ferme de manière inattendue, les données restantes dans le tampon sont analysées et traitées au lieu d’être considérées comme une erreur L’activation de cette option désactive l’analyse parallèle et rend la déduplication impossible

## input\_format\_csv\_allow\_cr\_end\_of\_line

Si ce paramètre est défini sur true, \r sera autorisé en fin de ligne s'il n'est pas suivi de

## input\_format\_csv\_allow\_variable\_number\_of\_columns

Ignorer les colonnes supplémentaires dans l’entrée CSV (si le fichier contient plus de colonnes que prévu) et traiter les champs manquants dans l’entrée CSV comme des valeurs par défaut

## input\_format\_csv\_allow\_whitespace\_or\_tab\_as\_delimiter

Permet d'utiliser des espaces et des tabulations(\t) comme délimiteurs de champs dans les chaînes CSV

## input\_format\_csv\_arrays\_as\_nested\_csv

Lors de la lecture d’un Array à partir d’un CSV, on suppose que ses éléments ont été sérialisés au format CSV imbriqué, puis placés dans une chaîne. Exemple : "\[""Hello"", ""world"", ""42"""" TV""]". Les crochets entourant le tableau peuvent être omis.

## input\_format\_csv\_deserialize\_separate\_columns\_into\_tuple

Si cette option est définie sur true, des colonnes distinctes écrites au format CSV peuvent être désérialisées en colonne Tuple.

## input\_format\_csv\_detect\_header

Détecte automatiquement l’en-tête avec les noms et les types au format CSV

## input\_format\_csv\_empty\_as\_default

Traiter les champs vides d’une entrée CSV comme des valeurs par défaut.

## input\_format\_csv\_enum\_as\_number

Traiter les valeurs d'enum insérées au format CSV comme des indices d'enum

## input\_format\_csv\_skip\_first\_lines

Ignore le nombre de lignes spécifié au début des données au format CSV

## input\_format\_csv\_skip\_trailing\_empty\_lines

Ignorer les lignes vides finales au format CSV

## input\_format\_csv\_trim\_whitespaces

Supprime les espaces et les tabulations (\t) au début et à la fin des chaînes CSV

## input\_format\_csv\_try\_infer\_numbers\_from\_strings

Si ce paramètre est activé, lors de l’inférence du schéma, ClickHouse essaiera d’inférer les nombres à partir des champs de type String. Cela peut être utile si les données CSV contiennent des nombres UInt64 entre guillemets. Désactivé par défaut.

## input\_format\_csv\_try\_infer\_strings\_from\_quoted\_tuples

Interpréter les tuples entre guillemets dans les données d’entrée comme une valeur de type String.

## input\_format\_csv\_use\_best\_effort\_in\_schema\_inference

Utilise certains ajustements et certaines heuristiques pour inférer le schéma au format CSV

## input\_format\_csv\_use\_default\_on\_bad\_values

Permet de définir la valeur par défaut d’une colonne lorsque la désérialisation d’un champ CSV échoue à cause d’une valeur incorrecte

## input\_format\_custom\_allow\_variable\_number\_of\_columns

Ignorer les colonnes supplémentaires dans l’entrée CustomSeparated (si le fichier comporte plus de colonnes que prévu) et traiter les champs manquants dans l’entrée CustomSeparated comme des valeurs par défaut

## input\_format\_custom\_detect\_header

Détecte automatiquement l’en-tête avec les noms et les types dans le format CustomSeparated

## input\_format\_custom\_skip\_trailing\_empty\_lines

Ignorer les lignes vides finales dans le format CustomSeparated

## input\_format\_defaults\_for\_omitted\_fields

Pour les requêtes `INSERT`, remplace les valeurs des colonnes d’entrée omises par les valeurs par défaut des colonnes correspondantes. Cette option s’applique aux formats [JSONEachRow](/fr/reference/formats/JSON/JSONEachRow) (et autres formats JSON), [CSV](/fr/reference/formats/CSV/CSV), [TabSeparated](/fr/reference/formats/TabSeparated/TabSeparated), [TSKV](/fr/reference/formats/TabSeparated/TSKV), [Parquet](/fr/reference/formats/Parquet/Parquet), [Arrow](/fr/reference/formats/Arrow/Arrow), [Avro](/fr/reference/formats/Avro/Avro), [ORC](/fr/reference/formats/ORC), [Native](/fr/reference/formats/Native), ainsi qu’aux formats avec les suffixes `WithNames`/`WithNamesAndTypes`. Lorsque cette option est activée, des métadonnées de table supplémentaires sont transmises du serveur au client. Cela consomme des ressources de calcul supplémentaires sur le serveur et peut réduire les performances. Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## input\_format\_force\_null\_for\_omitted\_fields

Forcer l’initialisation des champs omis avec des valeurs NULL

## input\_format\_geojson\_unsupported\_geometry\_handling

Contrôle le comportement lorsqu’un type de géométrie `GeoJSON` valide qui ne peut pas être représenté par le type `Geometry` de ClickHouse (comme `GeometryCollection` ou `MultiPoint`) doit être stocké dans la colonne `geometry` lors de la lecture d’une entrée `GeoJSON`. Valeurs possibles : * `'throw'` (par défaut) — lever une exception. * `'null'` — insérer une valeur `NULL` dans la colonne `geometry` et poursuivre l’analyse. Cela s’applique uniquement lorsque la colonne `geometry` est matérialisée. Lorsqu’il ne s’agit pas d’une colonne de sortie demandée, une telle géométrie est validée pour s’assurer qu’elle est bien formée, mais ne déclenche pas ce traitement.

## input\_format\_hive\_text\_allow\_variable\_number\_of\_columns

Ignorer les colonnes supplémentaires dans l’entrée au format Hive Text (si le fichier comporte plus de colonnes que prévu) et traiter les champs manquants dans l’entrée au format Hive Text comme des valeurs par défaut

## input\_format\_hive\_text\_collection\_items\_delimiter

Délimiteur entre les éléments d’une collection (Array ou Map) dans Hive Text File

## input\_format\_hive\_text\_fields\_delimiter

Délimiteur des champs dans Hive Text File

## input\_format\_hive\_text\_map\_keys\_delimiter

Délimiteur entre la clé et la valeur d’une paire de map dans Hive Text File

## input\_format\_import\_nested\_json

Active ou désactive l’insertion de données JSON contenant des objets imbriqués. Formats pris en charge : * [JSONEachRow](/fr/reference/formats/JSON/JSONEachRow) Valeurs possibles : * 0 — Désactivé. * 1 — Activé. Voir aussi : * [Utilisation des structures Nested](/fr/guides/clickhouse/data-formats/json/formats#accessing-nested-json-objects) avec le format `JSONEachRow`.

## input\_format\_ipv4\_default\_on\_conversion\_error

La désérialisation d'IPv4 utilisera les valeurs par défaut au lieu de lever une exception en cas d'erreur de conversion. Désactivé par défaut.

## input\_format\_ipv6\_default\_on\_conversion\_error

La désérialisation d’IPV6 utilisera les valeurs par défaut au lieu de lever une exception en cas d’erreur de conversion. Désactivé par défaut.

## input\_format\_json\_compact\_allow\_variable\_number\_of\_columns

Autorise un nombre variable de colonnes par ligne dans les formats d’entrée JSONCompact/JSONCompactEachRow. Ignore les colonnes supplémentaires dans les lignes qui contiennent plus de colonnes que prévu et traite les colonnes manquantes comme des valeurs par défaut. Désactivé par défaut.

## input\_format\_json\_defaults\_for\_missing\_elements\_in\_named\_tuple

Insère les valeurs par défaut pour les éléments manquants d’un objet JSON lors de l’analyse d’un tuple nommé. Ce paramètre fonctionne uniquement lorsque le paramètre `input_format_json_named_tuples_as_objects` est activé. Activé par défaut.

## input\_format\_json\_empty\_as\_default

Lorsqu’il est activé, les champs vides de l’entrée JSON sont remplacés par des valeurs par défaut. Pour les expressions par défaut complexes, `input_format_defaults_for_omitted_fields` doit également être activé. Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## input\_format\_json\_ignore\_unknown\_keys\_in\_named\_tuple

Ignorer les clés inconnues dans les objets JSON pour les tuples nommés. Activé par défaut.

## input\_format\_json\_ignore\_unnecessary\_fields

Ignorer les champs inutiles sans les analyser. L’activation de ce paramètre peut ne pas lever d’exception pour des chaînes JSON au format invalide ou contenant des champs dupliqués

## input\_format\_json\_infer\_array\_of\_dynamic\_from\_array\_of\_different\_types

Si ce paramètre est activé, lors de l’inférence du schéma, ClickHouse utilisera le type Array(Dynamic) pour les tableaux JSON contenant des valeurs de différents types de données. Exemple : ```sql theme={null} SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=1; DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}'); ``` ```response theme={null} ┌─name─┬─type───────────┐ │ a │ Array(Dynamic) │ └──────┴────────────────┘ ``` ```sql theme={null} SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=0; DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}'); ``` ```response theme={null} ┌─name─┬─type─────────────────────────────────────────────────────────────┐ │ a │ Tuple(Nullable(Int64), Nullable(String), Array(Nullable(Int64))) │ └──────┴──────────────────────────────────────────────────────────────────┘ ``` Activé par défaut.

## input\_format\_json\_infer\_incomplete\_types\_as\_strings

Permet d'utiliser le type String pour les clés JSON qui ne contiennent que `Null`/`{}`/`[]` dans l'échantillon de données lors de l'inférence du schéma. Dans les formats JSON, toute valeur peut être lue comme String, ce qui permet d'éviter des erreurs telles que `Cannot determine type for column 'column_name' by first 25000 rows of data, most likely this column contains only Nulls or empty Arrays/Maps` lors de l'inférence du schéma, en utilisant le type String pour les clés dont le type est inconnu. Exemple : ```sql theme={null} SET input_format_json_infer_incomplete_types_as_strings = 1, input_format_json_try_infer_named_tuples_from_objects = 1; DESCRIBE format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}'); SELECT * FROM format(JSONEachRow, '{"obj" : {"a" : [1,2,3], "b" : "hello", "c" : null, "d" : {}, "e" : []}}'); ``` Résultat : ``` ┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐ │ obj │ Tuple(a Array(Nullable(Int64)), b Nullable(String), c Nullable(String), d Nullable(String), e Array(Nullable(String))) │ │ │ │ │ │ └──────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘ ┌─obj────────────────────────────┐ │ ([1,2,3],'hello',NULL,'{}',[]) │ └────────────────────────────────┘ ``` Activé par défaut.

## input\_format\_json\_map\_as\_array\_of\_tuples

Désérialise les colonnes de type Map sous forme de tableaux JSON de tuples. Désactivé par défaut.

## input\_format\_json\_max\_depth

Profondeur maximale d'un champ dans un JSON. Il ne s'agit pas d'une limite stricte et elle ne doit pas nécessairement être appliquée de manière précise.

## input\_format\_json\_named\_tuples\_as\_objects

Interpréter les colonnes de tuples nommés comme des objets JSON. Activé par défaut.

## input\_format\_json\_read\_arrays\_as\_strings

Permet d’interpréter les tableaux JSON comme des chaînes dans les formats d’entrée JSON. Exemple : ```sql theme={null} SET input_format_json_read_arrays_as_strings = 1; SELECT arr, toTypeName(arr), JSONExtractArrayRaw(arr)[3] from format(JSONEachRow, 'arr String', '{"arr" : [1, "Hello", [1,2,3]]}'); ``` Résultat : ``` ┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐ │ [1, "Hello", [1,2,3]] │ String │ [1,2,3] │ └───────────────────────┴─────────────────┴───────────────────────────────────────────┘ ``` Activé par défaut.

## input\_format\_json\_read\_bools\_as\_numbers

Autorise l'interprétation des booléens comme des nombres dans les formats d'entrée JSON. Activé par défaut.

## input\_format\_json\_read\_bools\_as\_strings

Autorise l’interprétation des booléens sous forme de chaînes dans les formats d’entrée JSON. Activé par défaut.

## input\_format\_json\_read\_numbers\_as\_strings

Permet d'interpréter les nombres sous forme de chaînes dans les formats d'entrée JSON. Activé par défaut.

## input\_format\_json\_read\_objects\_as\_strings

Autorise l’analyse des objets JSON sous forme de chaînes dans les formats d’entrée JSON. Exemple : ```sql theme={null} SET input_format_json_read_objects_as_strings = 1; CREATE TABLE test (id UInt64, obj String, date Date) ENGINE=Memory(); INSERT INTO test FORMAT JSONEachRow {"id" : 1, "obj" : {"a" : 1, "b" : "Hello"}, "date" : "2020-01-01"}; SELECT * FROM test; ``` Résultat : ``` ┌─id─┬─obj──────────────────────┬───────date─┐ │ 1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │ └────┴──────────────────────────┴────────────┘ ``` Activé par défaut.

## input\_format\_json\_throw\_on\_bad\_escape\_sequence

Lever une exception si une chaîne JSON contient une séquence d’échappement incorrecte dans les formats d’entrée JSON. Si cette option est désactivée, les séquences d’échappement incorrectes resteront telles quelles dans les données. Activé par défaut.

## input\_format\_json\_try\_infer\_named\_tuples\_from\_objects

Si ce paramètre est activé, lors de l’inférence du schéma, ClickHouse essaiera d’inférer un Tuple nommé à partir d’objets JSON. Le Tuple nommé résultant contiendra tous les éléments de tous les objets JSON correspondants de l’échantillon de données. Exemple : ```sql theme={null} SET input_format_json_try_infer_named_tuples_from_objects = 1; DESC format(JSONEachRow, '{"obj" : {"a" : 42, "b" : "Hello"}}, {"obj" : {"a" : 43, "c" : [1, 2, 3]}}, {"obj" : {"d" : {"e" : 42}}}') ``` Résultat : ``` ┌─name─┬─type───────────────────────────────────────────────────────────────────────────────────────────────┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┬─ttl_expression─┐ │ obj │ Tuple(a Nullable(Int64), b Nullable(String), c Array(Nullable(Int64)), d Tuple(e Nullable(Int64))) │ │ │ │ │ │ └──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘ ``` Activé par défaut.

## input\_format\_json\_try\_infer\_numbers\_from\_strings

Si cette option est activée, lors de l'inférence du schéma, ClickHouse essaiera d'inférer des nombres à partir de champs de type chaîne. Cela peut être utile si les données JSON contiennent des nombres UInt64 entre guillemets. Désactivé par défaut.

## input\_format\_json\_use\_string\_type\_for\_ambiguous\_paths\_in\_named\_tuples\_inference\_from\_objects

Utilise le type String au lieu de générer une exception en cas de chemins ambigus dans des objets JSON lors de l’inférence de tuples nommés

## input\_format\_json\_validate\_types\_from\_metadata

Pour les formats d'entrée JSON/JSONCompact/JSONColumnsWithMetadata, si ce paramètre est défini sur 1, les types des métadonnées des données d'entrée seront comparés aux types des colonnes correspondantes de la table. Activé par défaut.

## input\_format\_max\_block\_size\_bytes

Limite la taille, en octets, des blocs formés lors de l'analyse des données dans les formats d'entrée. Utilisé dans les formats d'entrée basés sur les lignes lorsque le bloc est formé côté ClickHouse. 0 signifie qu'il n'y a aucune limite en octets.

## input\_format\_max\_block\_wait\_ms

Limite le temps d'attente maximal, en millisecondes, avant l'émission d'un bloc lors de l'analyse dans les formats d'entrée basés sur des lignes. 0 signifie qu'il n'y a pas de limite. Cette option fonctionne uniquement si `input_format_connection_handling` est activé. Définir une valeur désactive également l'analyse parallèle et rend la déduplication impossible. Pour les insertions en streaming, vous devez également définir `min_insert_block_size_rows=0` et `min_insert_block_size_bytes=0`. Sinon, les blocs analysés peuvent encore s'accumuler en mémoire à l'étape de fusion des blocs jusqu'à ce que ces seuils soient atteints, ce qui empêche des insertions en temps voulu. **Exemple : diffusion en streaming des modifications récentes de Wikipedia dans ClickHouse** ```bash theme={null} clickhouse-client --query 'CREATE TABLE wikipedia_edits (data JSON)' curl -sS --globoff -H 'Accept: application/json' --no-buffer \ 'https://stream.wikimedia.org/v2/stream/recentchange' \ | clickhouse-client \ --query 'INSERT INTO wikipedia_edits FORMAT JSONAsObject' \ --input_format_max_block_wait_ms 1000 \ --input_format_connection_handling 1 \ --min_insert_block_size_rows 0 \ --min_insert_block_size_bytes 0 ```

## input\_format\_max\_bytes\_to\_read\_for\_schema\_inference

Quantité maximale de données, en octets, à lire pour l’inférence automatique du schéma.

## input\_format\_max\_rows\_to\_read\_for\_schema\_inference

Nombre maximal de lignes de données à lire pour l’inférence automatique du schéma.

## input\_format\_msgpack\_number\_of\_columns

Le nombre de colonnes dans les données MsgPack insérées. Utilisé pour l’inférence automatique du schéma à partir de ces données.

## input\_format\_mysql\_dump\_map\_column\_names

Faire correspondre les colonnes de la table du dump MySQL avec celles de la table ClickHouse, en fonction de leur nom

## input\_format\_mysql\_dump\_table\_name

Nom de la table du dump MySQL à partir de laquelle lire les données

## input\_format\_native\_allow\_types\_conversion

Autoriser la conversion des types de données dans le format d’entrée Native

## input\_format\_native\_decode\_types\_in\_binary\_format

Lire les types de données au format binaire plutôt que les noms de type dans le format d'entrée Native

## input\_format\_null\_as\_default

Active ou désactive l’initialisation des champs [NULL](/fr/reference/syntax#literals) avec des [valeurs par défaut](/fr/reference/statements/create/table#default_values), si le type de données de ces champs n’est pas [Nullable](/fr/reference/data-types/nullable). Si le type de la colonne n’est pas Nullable et que ce paramètre est désactivé, l’insertion de `NULL` provoque une exception. Si le type de la colonne est Nullable, les valeurs `NULL` sont insérées telles quelles, quel que soit ce paramètre. Ce paramètre s’applique à la plupart des formats d’entrée. Pour les expressions par défaut complexes, `input_format_defaults_for_omitted_fields` doit également être activé. Valeurs possibles : * 0 — L’insertion de `NULL` dans une colonne non Nullable provoque une exception. * 1 — Les champs `NULL` sont initialisés avec les valeurs par défaut de la colonne.

## input\_format\_orc\_allow\_missing\_columns

Autoriser les colonnes manquantes lors de la lecture du format d’entrée ORC

## input\_format\_orc\_case\_insensitive\_column\_matching

Ignore la casse lors de la mise en correspondance des colonnes ORC avec les colonnes CH.

## input\_format\_orc\_dictionary\_as\_low\_cardinality

Traiter les colonnes encodées à l’aide du dictionnaire ORC comme des colonnes LowCardinality lors de la lecture de fichiers ORC.

## input\_format\_orc\_filter\_push\_down

Lors de la lecture de fichiers ORC, ignore des stripes entières ou des groupes de lignes entiers en fonction des expressions WHERE/PREWHERE, des statistiques min/max ou du filtre de Bloom dans les métadonnées ORC.

## input\_format\_orc\_reader\_time\_zone\_name

Nom du fuseau horaire du lecteur de lignes ORC ; le fuseau horaire par défaut du lecteur de lignes ORC est GMT.

## input\_format\_orc\_row\_batch\_size

Taille du lot pour la lecture des stripes ORC.

## input\_format\_orc\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference

Ignorer les colonnes dont les types ne sont pas pris en charge lors de l’inférence du schéma pour le format ORC

## input\_format\_orc\_use\_fast\_decoder

Utilise une implémentation plus rapide du décodeur ORC.

## input\_format\_parallel\_parsing

Active ou désactive l’analyse parallèle des formats de données avec préservation de l’ordre. Pris en charge uniquement pour les formats [TabSeparated (TSV)](/fr/reference/formats/TabSeparated/TabSeparated), [TSKV](/fr/reference/formats/TabSeparated/TSKV), [CSV](/fr/reference/formats/CSV/CSV) et [JSONEachRow](/fr/reference/formats/JSON/JSONEachRow). Valeurs possibles : * 1 — Activé. * 0 — Désactivé.

## input\_format\_parquet\_allow\_geoparquet\_parser

Utilise l’analyseur de colonnes géo pour convertir Array(UInt8) en types Point/Linestring/Polygon/MultiLineString/MultiPolygon

## input\_format\_parquet\_allow\_missing\_columns

Autoriser les colonnes manquantes lors de la lecture de formats d’entrée Parquet

## input\_format\_parquet\_bloom\_filter\_push\_down

Lors de la lecture de fichiers Parquet, permet d'ignorer des groupes de lignes entiers en fonction des expressions WHERE et du filtre de Bloom dans les métadonnées Parquet.

## input\_format\_parquet\_case\_insensitive\_column\_matching

Ignorer la casse lors de la mise en correspondance des colonnes Parquet avec les colonnes CH.

## input\_format\_parquet\_enable\_json\_parsing

Lors de la lecture de fichiers Parquet, interpréter les colonnes JSON comme des colonnes JSON ClickHouse.

## input\_format\_parquet\_enable\_row\_group\_prefetch

Active la prélecture des groupes de lignes lors de l’analyse de Parquet. Actuellement, seule l’analyse en monothread peut effectuer cette prélecture.

## input\_format\_parquet\_filter\_push\_down

Lors de la lecture de fichiers Parquet, ignore des groupes de lignes entiers en fonction des expressions WHERE/PREWHERE et des statistiques min/max des métadonnées Parquet.

## input\_format\_parquet\_local\_file\_min\_bytes\_for\_seek

Nombre minimal d’octets requis pour qu’une lecture locale (fichier) effectue un seek plutôt qu’une lecture avec ignore dans le format d’entrée Parquet

## input\_format\_parquet\_local\_time\_as\_utc

Détermine le type de données utilisé par l’inférence de schéma pour les timestamps Parquet avec isAdjustedToUTC=false. Si true : DateTime64(..., 'UTC') ; si false : DateTime64(...). Aucun de ces deux comportements n’est entièrement correct, car ClickHouse ne dispose pas d’un type de données pour l’heure locale affichée. De façon contre-intuitive, 'true' est probablement l’option la moins incorrecte, car le formatage du timestamp 'UTC' en String produira une représentation de l’heure locale correcte.

## input\_format\_parquet\_max\_block\_size

Taille maximale des blocs pour le lecteur Parquet.

## input\_format\_parquet\_memory\_high\_watermark

Limite de mémoire approximative pour le lecteur Parquet v3. Limite le nombre de groupes de lignes ou de colonnes pouvant être lus en parallèle. Lors de la lecture de plusieurs fichiers dans une même requête, la limite porte sur l'utilisation mémoire totale de l'ensemble de ces fichiers.

## input\_format\_parquet\_memory\_low\_watermark

Planifie les prélectures plus agressivement si l’utilisation de la mémoire est inférieure au seuil. Cela peut être utile, par exemple, s’il y a de nombreux petits filtres de Bloom à lire sur le réseau.

## input\_format\_parquet\_page\_filter\_push\_down

Ignore les pages à l’aide des valeurs min/max de l’index de colonne.

## input\_format\_parquet\_prefer\_block\_bytes

Nombre moyen d’octets par bloc produits par le lecteur Parquet

## input\_format\_parquet\_preserve\_order

Évite de réordonner les lignes lors de la lecture de fichiers Parquet. Ce n’est pas recommandé, car l’ordre des lignes n’est généralement pas garanti et d’autres parties du pipeline d’exécution de la requête peuvent malgré tout le modifier. Utilisez plutôt `ORDER BY _row_number`.

## input\_format\_parquet\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference

Ignorer les colonnes dont les types ne sont pas pris en charge lors de l’inférence de schéma pour le format Parquet

## input\_format\_parquet\_use\_offset\_index

Ajustement mineur de la façon dont les pages sont lues à partir d’un fichier Parquet lorsqu’aucun filtrage de page n’est appliqué.

## input\_format\_parquet\_verify\_checksums

Vérifie les sommes de contrôle des pages lors de la lecture des fichiers Parquet.

## input\_format\_protobuf\_flatten\_google\_wrappers

Active les wrappers Google pour les colonnes ordinaires non imbriquées, par ex. google.protobuf.StringValue 'str' pour la colonne String 'str'. Pour les colonnes Nullable, les wrappers vides sont interprétés comme des valeurs par défaut, et les valeurs manquantes comme des nulls

## input\_format\_protobuf\_oneof\_presence

Indique quel champ du oneof Protobuf a été trouvé en définissant une valeur enum dans une colonne spéciale

## input\_format\_protobuf\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference

Ignorer les champs dont les types ne sont pas pris en charge lors de l’inférence de schéma pour le format Protobuf

## input\_format\_record\_errors\_file\_path

Chemin du fichier utilisé pour consigner les erreurs lors de la lecture de formats texte (CSV, TSV).

## input\_format\_skip\_unknown\_fields

Active ou désactive l’omission des données supplémentaires lors de l’insertion. Lors de l’écriture de données, ClickHouse lève une exception si les données d’entrée contiennent des colonnes qui n’existent pas dans la table cible. Si cette option est activée, ClickHouse n’insère pas les données supplémentaires et ne lève pas d’exception. Formats pris en charge : * [JSONEachRow](/fr/reference/formats/JSON/JSONEachRow) (et d’autres formats JSON) * [BSONEachRow](/fr/reference/formats/BSONEachRow) (et d’autres formats JSON) * [TSKV](/fr/reference/formats/TabSeparated/TSKV) * Tous les formats avec les suffixes WithNames/WithNamesAndTypes * [MySQLDump](/fr/reference/formats/MySQLDump) * [Native](/fr/reference/formats/Native) Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## input\_format\_try\_infer\_dates

Si ce paramètre est activé, ClickHouse essaiera d'inférer le type `Date` à partir des champs de type chaîne lors de l'inférence de schéma pour les formats texte. Si tous les champs d'une colonne dans les données d'entrée ont été correctement interprétés comme des dates, le type résultant sera `Date` ; si au moins un champ n'a pas été interprété comme une date, le type résultant sera `String`. Activé par défaut.

## input\_format\_try\_infer\_datetimes

Si cette option est activée, ClickHouse tentera d’inférer le type `DateTime64` à partir des champs de type chaîne lors de l’inférence de schéma pour les formats texte. Si tous les champs d’une colonne des données d’entrée sont correctement analysés comme des dates et heures, le type résultant sera `DateTime64` ; si au moins un champ n’est pas analysé comme une date et heure, le type résultant sera `String`. Activé par défaut.

## input\_format\_try\_infer\_datetimes\_only\_datetime64

Lorsque input\_format\_try\_infer\_datetimes est activé, n’inférer que le type DateTime64, et non les types DateTime

## input\_format\_try\_infer\_exponent\_floats

Tenter d’inférer les nombres flottants en notation exponentielle lors de l’inférence de schéma dans les formats texte (sauf JSON, où les nombres avec exposant sont toujours inférés)

## input\_format\_try\_infer\_integers

Si cette option est activée, ClickHouse tentera d'inférer des entiers plutôt que des nombres à virgule flottante lors de l'inférence de schéma pour les formats texte. Si tous les nombres d'une colonne dans les données d'entrée sont des entiers, le type résultant sera `Int64` ; si au moins un nombre est à virgule flottante, le type résultant sera `Float64`. Activé par défaut.

## input\_format\_try\_infer\_variants

Si cette option est activée, ClickHouse tentera d’inférer le type [`Variant`](/fr/reference/data-types/variant) lors de l’inférence de schéma pour les formats texte lorsqu’il existe plusieurs types possibles pour les éléments de colonne ou de tableau. Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## input\_format\_tsv\_allow\_variable\_number\_of\_columns

Ignorer les colonnes supplémentaires dans l’entrée TSV (si le fichier comporte plus de colonnes que prévu) et considérer les champs manquants dans l’entrée TSV comme des valeurs par défaut

## input\_format\_tsv\_crlf\_end\_of\_line

Si ce paramètre est défini sur true, la fonction file lira le format TSV avec des fins de ligne \r\n au lieu de \n.

## input\_format\_tsv\_detect\_header

Détecte automatiquement l’en-tête avec les noms et les types au format TSV

## input\_format\_tsv\_empty\_as\_default

Traite les champs vides dans l’entrée TSV comme des valeurs par défaut.

## input\_format\_tsv\_enum\_as\_number

Traite les valeurs d'enum insérées dans les formats TSV comme des indices d'enum.

## input\_format\_tsv\_skip\_first\_lines

Ignore le nombre spécifié de lignes au début des données au format TSV

## input\_format\_tsv\_skip\_trailing\_empty\_lines

Ignorer les lignes vides finales au format TSV

## input\_format\_tsv\_use\_best\_effort\_in\_schema\_inference

Utilise certains ajustements et heuristiques pour inférer le schéma au format TSV

## input\_format\_values\_accurate\_types\_of\_literals

Pour le format Values : lors de l’analyse et de l’interprétation des expressions à l’aide du modèle, vérifiez le type réel du littéral afin d’éviter d’éventuels problèmes de dépassement de capacité et de précision.

## input\_format\_values\_deduce\_templates\_of\_expressions

Pour le format Values : si le champ ne peut pas être analysé par le parseur en flux, l’analyseur SQL est exécuté, le modèle de l’expression SQL est déduit, toutes les lignes sont ensuite analysées à l’aide de ce modèle, puis l’expression est interprétée pour toutes les lignes.

## input\_format\_values\_interpret\_expressions

Pour le format Values : si le champ n’a pas pu être analysé par le parseur en flux, exécutez l’analyseur SQL et essayez de l’interpréter comme une expression SQL.

## input\_format\_with\_names\_use\_header

Active ou désactive la vérification de l'ordre des colonnes lors de l'insertion de données. Pour améliorer les performances d'insertion, nous recommandons de désactiver cette vérification si vous êtes sûr que l'ordre des colonnes dans les données d'entrée est le même que dans la table cible. Formats pris en charge : * [CSVWithNames](/fr/reference/formats/CSV/CSVWithNames) * [CSVWithNamesAndTypes](/fr/reference/formats/CSV/CSVWithNamesAndTypes) * [TabSeparatedWithNames](/fr/reference/formats/TabSeparated/TabSeparatedWithNames) * [TabSeparatedWithNamesAndTypes](/fr/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes) * [JSONCompactEachRowWithNames](/fr/reference/formats/JSON/JSONCompactEachRowWithNames) * [JSONCompactEachRowWithNamesAndTypes](/fr/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes) * [JSONCompactStringsEachRowWithNames](/fr/reference/formats/JSON/JSONCompactStringsEachRowWithNames) * [JSONCompactStringsEachRowWithNamesAndTypes](/fr/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes) * [RowBinaryWithNames](/fr/reference/formats/RowBinary/RowBinaryWithNames) * [RowBinaryWithNamesAndTypes](/fr/reference/formats/RowBinary/RowBinaryWithNamesAndTypes) * [CustomSeparatedWithNames](/fr/reference/formats/CustomSeparated/CustomSeparatedWithNames) * [CustomSeparatedWithNamesAndTypes](/fr/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes) Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## input\_format\_with\_types\_use\_header

Détermine si l’analyseur de format doit vérifier que les types de données des données d’entrée correspondent à ceux de la table cible. Formats pris en charge : * [CSVWithNamesAndTypes](/fr/reference/formats/CSV/CSVWithNamesAndTypes) * [TabSeparatedWithNamesAndTypes](/fr/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes) * [JSONCompactEachRowWithNamesAndTypes](/fr/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes) * [JSONCompactStringsEachRowWithNamesAndTypes](/fr/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes) * [RowBinaryWithNamesAndTypes](/fr/reference/formats/RowBinary/RowBinaryWithNamesAndTypes) * [CustomSeparatedWithNamesAndTypes](/fr/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes) Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## insert\_distributed\_one\_random\_shard

Active ou désactive l'insertion dans un shard choisi aléatoirement dans une table [Distributed](/fr/reference/engines/table-engines/special/distributed) lorsqu'aucune clé de distribution n'est définie. Par défaut, lors de l'insertion de données dans une table `Distributed` comportant plus d'un shard, le serveur ClickHouse rejette toute requête d'insertion si aucune clé de distribution n'est définie. Lorsque `insert_distributed_one_random_shard = 1`, les insertions sont autorisées et les données sont transmises aléatoirement à l'un des shards. Valeurs possibles : * 0 — L'insertion est rejetée s'il y a plusieurs shards et qu'aucune clé de distribution n'est définie. * 1 — L'insertion est effectuée aléatoirement parmi tous les shards disponibles lorsqu'aucune clé de distribution n'est définie.

## interval\_output\_format

Permet de choisir différents formats de sortie pour la représentation textuelle des types d'intervalle. Valeurs possibles : * `kusto` - Format de sortie de style KQL. ClickHouse affiche les intervalles au [format KQL](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings#the-constant-c-format-specifier). Par exemple, `toIntervalDay(2)` est formaté sous la forme `2.00:00:00`. Veuillez noter que, pour les types d'intervalle de longueur variable (c.-à-d. `IntervalMonth` et `IntervalYear`), le nombre moyen de secondes par intervalle est pris en compte. * `numeric` - Format de sortie numérique. ClickHouse affiche les intervalles selon leur représentation numérique sous-jacente. Par exemple, `toIntervalDay(2)` est formaté sous la forme `2`. Voir aussi : * [Interval](/fr/reference/data-types/special-data-types/interval)

## into\_outfile\_create\_parent\_directories

Crée automatiquement les répertoires parents lors de l’utilisation de INTO OUTFILE s’ils n’existent pas encore.

## json\_type\_escape\_dots\_in\_keys

Lorsqu’il est activé, les points dans les clés JSON sont échappés lors de l’analyse.

## max\_dynamic\_subcolumns\_in\_json\_type\_parsing

Nombre maximal de sous-colonnes dynamiques pouvant être créées dans chaque colonne lors de l'analyse d'une colonne JSON. Il permet de contrôler le nombre de sous-colonnes dynamiques lors de l'analyse, indépendamment des paramètres dynamiques spécifiés dans le type de données.

## output\_format\_always\_write\_decimal\_point\_in\_float\_and\_decimal

Afficher systématiquement un séparateur décimal pour les nombres à virgule flottante et les nombres Decimal dans les formats texte, même lorsque la valeur est un nombre entier. Par exemple, afficher `1.` au lieu de `1`. Désactivé par défaut.

## output\_format\_arrow\_compression\_method

Méthode de compression du format de sortie Arrow. Codecs pris en charge : lz4\_frame, zstd, none (sans compression)

## output\_format\_arrow\_date\_as\_uint16

Écrit les valeurs Date sous forme de nombres 16 bits bruts (relus comme UInt16), au lieu de les convertir en type DATE32 Arrow 32 bits (relu comme Date32).

## output\_format\_arrow\_fixed\_string\_as\_fixed\_byte\_array

Utilise le type Arrow FIXED\_SIZE\_BINARY au lieu de Binary pour les colonnes FixedString.

## output\_format\_arrow\_low\_cardinality\_as\_dictionary

Active la sortie du type LowCardinality sous forme de type Arrow Dictionary

## output\_format\_arrow\_string\_as\_string

Utiliser le type String d’Arrow au lieu de Binary pour les colonnes String

## output\_format\_arrow\_unsupported\_types\_as\_binary

Renvoie les types sans conversion sous forme de données binaires brutes. Si false, ces types lèvent une exception UNKNOWN\_TYPE.

## output\_format\_arrow\_use\_64\_bit\_indexes\_for\_dictionary

Toujours utiliser des entiers 64 bits pour les index de dictionnaire au format Arrow

## output\_format\_arrow\_use\_signed\_indexes\_for\_dictionary

Utiliser des entiers signés pour les index de dictionnaire au format Arrow

## output\_format\_avro\_codec

Codec de compression utilisé en sortie. Valeurs possibles : 'null', 'deflate', 'snappy', 'zstd'.

## output\_format\_avro\_confluent\_subject

Pour le format de sortie AvroConfluent : nom du subject sous lequel le schéma est enregistré dans Confluent Schema Registry. Obligatoire lors de l’écriture au format de sortie AvroConfluent.

## output\_format\_avro\_rows\_in\_file

Nombre maximal de lignes dans un fichier (si le stockage le permet)

## output\_format\_avro\_string\_column\_pattern

Pour le format Avro : expression régulière des colonnes de type String à sélectionner en tant que chaîne AVRO.

## output\_format\_avro\_sync\_interval

Intervalle de synchronisation, en octets.

## output\_format\_binary\_encode\_types\_in\_binary\_format

Écrire les types de données au format binaire plutôt que les noms de type dans le format de sortie RowBinaryWithNamesAndTypes

## output\_format\_binary\_write\_json\_as\_string

Écrit les valeurs de type [JSON](/fr/reference/data-types/newjson) sous forme de valeurs JSON [String](/fr/reference/data-types/string) dans le format de sortie RowBinary.

## output\_format\_bson\_string\_as\_string

Utilise le type BSON String au lieu de Binary pour les colonnes de type String.

## output\_format\_compression\_level

Niveau de compression par défaut lorsque la sortie de la requête est compressée. Ce paramètre s’applique lorsque la requête `SELECT` utilise `INTO OUTFILE` ou lors de l’écriture dans les fonctions de table `file`, `url`, `hdfs`, `s3` ou `azureBlobStorage`. Valeurs possibles : de `1` à `22`

## output\_format\_compression\_zstd\_window\_log

Peut être utilisé lorsque la méthode de compression de sortie est `zstd`. Si elle est supérieure à `0`, ce paramètre définit explicitement la taille de la fenêtre de compression (puissance de `2`) et active un mode longue portée pour la compression zstd. Cela peut aider à obtenir un meilleur taux de compression. Valeurs possibles : nombres non négatifs. Notez que si la valeur est trop petite ou trop grande, `zstdlib` lèvera une exception. Les valeurs typiques vont de `20` (taille de fenêtre = `1MB`) à `30` (taille de fenêtre = `1GB`).

## output\_format\_csv\_crlf\_end\_of\_line

Si ce paramètre est défini sur true, la fin de ligne au format CSV sera \r\n au lieu de \n.

## output\_format\_csv\_serialize\_tuple\_into\_separate\_columns

Si ce paramètre est défini sur true, les Tuples au format CSV sont sérialisés dans des colonnes distinctes (c’est-à-dire que leur imbrication dans le tuple est perdue)

## output\_format\_decimal\_trailing\_zeros

Afficher les zéros non significatifs lors de l’affichage des valeurs Decimal. Par exemple, 1.230000 au lieu de 1.23. Désactivé par défaut.

## output\_format\_float\_precision

Lorsque cette valeur est non nulle, la sortie des nombres à virgule flottante (`Float32`, `Float64`, `BFloat16`) est formatée avec au plus ce nombre de chiffres après la virgule (les zéros finaux sont supprimés). Lorsqu’elle vaut 0 (valeur par défaut), la représentation la plus courte permettant un aller-retour est utilisée. Les valeurs trop grandes pour la notation fixe, ainsi que les valeurs dont la valeur absolue est si faible qu’un arrondi à la précision demandée ferait perdre tous les chiffres significatifs (la mantisse deviendrait `±0`), sont émises en notation scientifique à la place. Dans ces cas, la mantisse peut comporter plus de chiffres fractionnaires que le nombre demandé. Plage valide : 0 à 100.

## output\_format\_image\_height

Hauteur, en pixels, de l’image de sortie pour les formats de sortie d’image tels que `PNG`. Valeur par défaut : 1024.

## output\_format\_image\_terminal\_mode

Pour les formats de sortie d’image tels que `PNG`, affiche l’image directement dans le terminal à l’aide d’un protocole d’image intégré au lieu d’écrire les octets bruts de l’image. Valeurs possibles : * \`\` (vide) — écrire les octets bruts de l’image (par défaut). * `iterm` — utiliser le protocole d’image intégré d’iTerm2. * `kitty` — utiliser le protocole graphique Kitty. * `sixel` — utiliser le protocole Sixel. * `auto` — si la sortie est un terminal, détecter ses capacités et utiliser `iterm`, `kitty` ou `sixel` (dans cet ordre) ; sinon, écrire les octets bruts de l’image. Valeur par défaut : \`\` (vide).

## output\_format\_image\_width

Largeur, en pixels, de l’image de sortie pour les formats de sortie d’image tels que `PNG`. Valeur par défaut : 1024.

## output\_format\_json\_array\_of\_rows

Permet de générer toutes les lignes sous la forme d’un tableau JSON au format [JSONEachRow](/fr/reference/formats/JSON/JSONEachRow). Valeurs possibles : * 1 — ClickHouse génère toutes les lignes sous la forme d’un tableau, chaque ligne étant au format `JSONEachRow`. * 0 — ClickHouse génère chaque ligne séparément au format `JSONEachRow`. **Exemple de requête avec ce paramètre activé** Requête : ```sql theme={null} SET output_format_json_array_of_rows = 1; SELECT number FROM numbers(3) FORMAT JSONEachRow; ``` Résultat : ```text theme={null} [ {"number":"0"}, {"number":"1"}, {"number":"2"} ] ``` **Exemple de requête avec le paramètre désactivé** Requête : ```sql theme={null} SET output_format_json_array_of_rows = 0; SELECT number FROM numbers(3) FORMAT JSONEachRow; ``` Résultat : ```text theme={null} {"number":"0"} {"number":"1"} {"number":"2"} ```

## output\_format\_json\_escape\_forward\_slashes

Contrôle l’échappement des barres obliques `/` dans les sorties de chaînes au format de sortie JSON. Ce paramètre vise à assurer la compatibilité avec JavaScript. Ne pas confondre avec les backslashes, qui sont toujours échappés. Activé par défaut.

## output\_format\_json\_map\_as\_array\_of\_tuples

Sérialise les colonnes Map sous forme de tableaux JSON de tuples. Désactivé par défaut.

## output\_format\_json\_named\_tuples\_as\_objects

Sérialise les colonnes de tuples nommés sous forme d’objets JSON. Activé par défaut.

## output\_format\_json\_pretty\_print

Ce paramètre détermine comment les structures imbriquées telles que les Tuples, les Maps et les Arrays sont affichées dans le tableau `data` lors de l’utilisation du format de sortie JSON. Par exemple, au lieu d’obtenir : ```json theme={null} "data": [ { "tuple": {"a":1,"b":2,"c":3}, "array": [1,2,3], "map": {"a":1,"b":2,"c":3} } ], ``` La sortie aura le format suivant : ```json theme={null} "data": [ { "tuple": { "a": 1, "b": 2, "c": 3 }, "array": [ 1, 2, 3 ], "map": { "a": 1, "b": 2, "c": 3 } } ], ``` Activé par défaut.

## output\_format\_json\_quote\_64bit\_floats

Contrôle la mise entre guillemets des [valeurs à virgule flottante](/fr/reference/data-types/float) 64 bits lors de leur sortie dans les formats JSON\*. Désactivé par défaut.

## output\_format\_json\_quote\_64bit\_integers

Contrôle la mise entre guillemets des [entiers](/fr/reference/data-types/int-uint) 64 bits ou supérieurs (comme `UInt64` ou `Int128`) lorsqu’ils sont affichés au format [JSON](/fr/reference/formats/JSON/JSON). Par défaut, ces entiers sont entourés de guillemets. Ce comportement est compatible avec la plupart des implémentations JavaScript. Valeurs possibles : * 0 — Les entiers sont affichés sans guillemets. * 1 — Les entiers sont entourés de guillemets.

## output\_format\_json\_quote\_decimals

Contrôle la mise entre guillemets des valeurs décimales dans les formats de sortie JSON. Désactivé par défaut.

## output\_format\_json\_quote\_denormals

Permet d’inclure les valeurs `+nan`, `-nan`, `+inf`, `-inf` dans le format de sortie [JSON](/fr/reference/formats/JSON/JSON). Valeurs possibles : * 0 — Désactivé. * 1 — Activé. **Exemple** Considérez la table `account_orders` suivante : ```text theme={null} ┌─id─┬─name───┬─duration─┬─period─┬─area─┐ │ 1 │ Andrew │ 20 │ 0 │ 400 │ │ 2 │ John │ 40 │ 0 │ 0 │ │ 3 │ Bob │ 15 │ 0 │ -100 │ └────┴────────┴──────────┴────────┴──────┘ ``` Lorsque `output_format_json_quote_denormals = 0`, la requête renvoie des valeurs `null` dans la sortie : ```sql theme={null} SELECT area/period FROM account_orders FORMAT JSON; ``` ```json theme={null} { "meta": [ { "name": "divide(area, period)", "type": "Float64" } ], "data": [ { "divide(area, period)": null }, { "divide(area, period)": null }, { "divide(area, period)": null } ], "rows": 3, "statistics": { "elapsed": 0.003648093, "rows_read": 3, "bytes_read": 24 } } ``` Lorsque `output_format_json_quote_denormals = 1`, la requête renvoie : ```json theme={null} { "meta": [ { "name": "divide(area, period)", "type": "Float64" } ], "data": [ { "divide(area, period)": "inf" }, { "divide(area, period)": "-nan" }, { "divide(area, period)": "-inf" } ], "rows": 3, "statistics": { "elapsed": 0.000070241, "rows_read": 3, "bytes_read": 24 } } ```

## output\_format\_json\_skip\_null\_value\_in\_named\_tuples

Ignorer les paires clé-valeur dont la valeur est NULL lors de la sérialisation des colonnes de tuples nommés en objets JSON. Ce paramètre n'est valide que lorsque output\_format\_json\_named\_tuples\_as\_objects est true.

## output\_format\_json\_validate\_utf8

Contrôle la validation des séquences UTF-8 dans les formats de sortie JSON ; n'affecte pas les formats JSON/JSONCompact/JSONColumnsWithMetadata, qui valident toujours l'UTF-8. Désactivé par défaut.

## output\_format\_markdown\_escape\_special\_characters

Lorsqu’il est activé, les caractères spéciaux dans Markdown sont échappés. [Common Mark](https://spec.commonmark.org/0.30/#example-12) définit les caractères spéciaux suivants, qui peuvent être échappés : ``` ! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~ ``` Valeurs possibles : * 0 — Désactivé. * 1 — Activé.

## output\_format\_msgpack\_uuid\_representation

Définit la manière dont un UUID est généré au format MsgPack.

## output\_format\_native\_encode\_types\_in\_binary\_format

Écrit les types de données au format binaire au lieu des noms de type dans le format de sortie Native

## output\_format\_native\_use\_flattened\_dynamic\_and\_json\_serialization

Écrit les données des colonnes [JSON](/fr/reference/data-types/newjson) et [Dynamic](/fr/reference/data-types/dynamic) dans un format aplati (tous les types/chemins sous forme de sous-colonnes distinctes).

## output\_format\_native\_write\_json\_as\_string

Écrit les données d’une colonne [JSON](/fr/reference/data-types/newjson) sous forme de colonne [String](/fr/reference/data-types/string) contenant des chaînes JSON, au lieu de la sérialisation JSON native par défaut.

## output\_format\_orc\_compression\_block\_size

Taille, en octets, du bloc de compression pour le format de sortie ORC.

## output\_format\_orc\_compression\_method

Méthode de compression pour le format de sortie ORC. Codecs pris en charge : lz4, snappy, zlib, zstd, none (non compressé)

## output\_format\_orc\_dictionary\_key\_size\_threshold

Pour une colonne de type chaîne de caractères au format de sortie ORC, si le nombre de valeurs distinctes dépasse cette fraction du nombre total de lignes non NULL, l’encodage par dictionnaire est désactivé. Sinon, l’encodage par dictionnaire est activé

## output\_format\_orc\_row\_index\_stride

Pas cible de l’index de ligne dans le format de sortie ORC

## output\_format\_orc\_string\_as\_string

Utiliser le type String d’ORC au lieu de Binary pour les colonnes String

## output\_format\_orc\_writer\_time\_zone\_name

Nom du fuseau horaire du writer ORC ; le fuseau horaire par défaut du writer ORC est GMT.

## output\_format\_parallel\_formatting

Active ou désactive la mise en forme parallèle des données. Pris en charge uniquement pour les formats [TSV](/fr/reference/formats/TabSeparated/TabSeparated), [TSKV](/fr/reference/formats/TabSeparated/TSKV), [CSV](/fr/reference/formats/CSV/CSV) et [JSONEachRow](/fr/reference/formats/JSON/JSONEachRow). Valeurs possibles : * 1 — Activé. * 0 — Désactivé.

## output\_format\_parquet\_batch\_size

Vérifie la taille de la page toutes les x lignes. Envisagez de la diminuer si vous avez des colonnes dont la taille moyenne des valeurs dépasse quelques Ko.

## output\_format\_parquet\_bloom\_filter\_bits\_per\_value

Nombre approximatif de bits à utiliser pour chaque valeur distincte dans les filtres de Bloom Parquet. Taux de faux positifs estimés : * 6 bits - 10% * 10.5 bits - 1% * 16.9 bits - 0.1% * 26.4 bits - 0.01% * 41 bits - 0.001%

## output\_format\_parquet\_bloom\_filter\_flush\_threshold\_bytes

Emplacement des filtres de Bloom dans le fichier Parquet. Les filtres de Bloom seront écrits par groupes d’environ cette taille. Plus précisément : * si 0, les filtres de Bloom de chaque groupe de lignes sont écrits immédiatement après le groupe de lignes, * si cette valeur est supérieure à la taille totale de tous les filtres de Bloom, les filtres de Bloom de tous les groupes de lignes seront accumulés en mémoire, puis écrits ensemble vers la fin du fichier, * sinon, les filtres de Bloom seront accumulés en mémoire et écrits dès que leur taille totale dépasse cette valeur.

## output\_format\_parquet\_compression\_method

Méthode de compression pour le format de sortie Parquet. Codecs pris en charge : snappy, lz4, brotli, zstd, gzip, none (non compressé)

## output\_format\_parquet\_data\_page\_size

Taille cible de la page, en octets, avant compression.

## output\_format\_parquet\_date\_as\_uint16

Écrit les valeurs Date sous forme de nombres 16 bits bruts (relus comme UInt16), au lieu de les convertir en type DATE Parquet 32 bits (relu comme Date32).

## output\_format\_parquet\_datetime\_as\_uint32

Écrit les valeurs DateTime sous forme de timestamp Unix brut (relues comme UInt32), au lieu de les convertir en millisecondes (relues comme DateTime64(3)).

## output\_format\_parquet\_enum\_as\_byte\_array

Écrire enum avec le type physique Parquet : BYTE\_ARRAY et le type logique : ENUM

## output\_format\_parquet\_fixed\_string\_as\_fixed\_byte\_array

Utiliser le type Parquet FIXED\_LEN\_BYTE\_ARRAY au lieu de Binary pour les colonnes FixedString.

## output\_format\_parquet\_geometadata

Permet d’écrire des informations sur les colonnes Geo dans les métadonnées Parquet et d’encoder les colonnes au format WKB.

## output\_format\_parquet\_max\_dictionary\_size

Si la taille du dictionnaire dépasse ce nombre d’octets, utilisez un encodage sans dictionnaire. Définissez cette valeur sur 0 pour désactiver l’encodage par dictionnaire.

## output\_format\_parquet\_parallel\_encoding

Effectue l’encodage Parquet en parallèle sur plusieurs threads.

## output\_format\_parquet\_row\_group\_size

Taille cible du groupe de lignes, en lignes.

## output\_format\_parquet\_row\_group\_size\_bytes

Taille cible du groupe de lignes, en octets, avant la compression.

## output\_format\_parquet\_string\_as\_string

Utiliser le type String de Parquet au lieu de Binary pour les colonnes String.

## output\_format\_parquet\_write\_bloom\_filter

Écrit des filtres de Bloom dans les fichiers Parquet.

## output\_format\_parquet\_write\_checksums

Ajoute des sommes de contrôle CRC32 aux en-têtes de page Parquet.

## output\_format\_parquet\_write\_page\_index

Écrit l’index de colonne et l’index d’offset (c.-à-d. des statistiques sur chaque page de données, qui peuvent être utilisées pour le pushdown des filtres lors de la lecture) dans des fichiers Parquet.

## output\_format\_pretty\_color

Utilise les séquences d’échappement ANSI dans les formats Pretty. 0 - désactivé, 1 - activé, 'auto' - activé si la sortie est un terminal.

## output\_format\_pretty\_display\_footer\_column\_names

Affiche les noms de colonnes dans le pied de page lorsqu'une table contient de nombreuses lignes. Valeurs possibles : * 0 — Aucun nom de colonne n'est affiché dans le pied de page. * 1 — Les noms de colonnes sont affichés dans le pied de page si le nombre de lignes est supérieur ou égal à la valeur seuil définie par [output\_format\_pretty\_display\_footer\_column\_names\_min\_rows](#output_format_pretty_display_footer_column_names_min_rows) (50 par défaut). **Exemple** Requête : ```sql theme={null} SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 1000); ``` Résultat : ```response theme={null} ┌─number─┬─toTypeName(number)─┐ 1. │ 0 │ UInt64 │ 2. │ 1 │ UInt64 │ 3. │ 2 │ UInt64 │ ... 999. │ 998 │ UInt64 │ 1000. │ 999 │ UInt64 │ └─number─┴─toTypeName(number)─┘ ```

## output\_format\_pretty\_display\_footer\_column\_names\_min\_rows

Définit le nombre minimal de lignes à partir duquel un pied de page contenant les noms des colonnes s’affiche si le paramètre [output\_format\_pretty\_display\_footer\_column\_names](#output_format_pretty_display_footer_column_names) est activé.

## output\_format\_pretty\_fallback\_to\_vertical

Si ce paramètre est activé et que la table est large mais peu haute, le format Pretty l’affiche comme le format Vertical. Consultez `output_format_pretty_fallback_to_vertical_max_rows_per_chunk` et `output_format_pretty_fallback_to_vertical_min_table_width` pour ajuster finement ce comportement.

## output\_format\_pretty\_fallback\_to\_vertical\_max\_rows\_per\_chunk

Le basculement vers le format Vertical (voir `output_format_pretty_fallback_to_vertical`) n'est activé que si le nombre de lignes dans un chunk ne dépasse pas la valeur spécifiée.

## output\_format\_pretty\_fallback\_to\_vertical\_min\_columns

Le basculement vers le format Vertical (voir `output_format_pretty_fallback_to_vertical`) ne s’active que si le nombre de colonnes est supérieur à la valeur spécifiée.

## output\_format\_pretty\_fallback\_to\_vertical\_min\_table\_width

Le passage au format Vertical (voir `output_format_pretty_fallback_to_vertical`) ne sera activé que si la somme des longueurs des colonnes d'une table est au moins égale à la valeur spécifiée, ou si au moins une valeur contient un caractère de saut de ligne.

## output\_format\_pretty\_glue\_chunks

Si les données affichées au format Pretty arrivent en plusieurs chunks, même avec un délai, mais que le chunk suivant a les mêmes largeurs de colonnes que le précédent, utilisez des séquences d’échappement ANSI pour revenir à la ligne précédente et écraser le pied de page du chunk précédent afin de le prolonger avec les données du nouveau chunk. Le résultat est ainsi plus agréable à l’œil. 0 - désactivé, 1 - activé, 'auto' - activé dans un terminal.

## output\_format\_pretty\_grid\_charset

Jeu de caractères utilisé pour l’affichage des bordures de la grille. Jeux de caractères disponibles : ASCII, UTF-8 (par défaut). En mode interactif, `clickhouse-client` bascule automatiquement vers `ASCII` si le terminal ne prend pas en charge UTF-8 (tel que déterminé par les variables d’environnement `LC_ALL`, `LC_CTYPE` et `LANG`), sauf si ce paramètre est explicitement défini.

## output\_format\_pretty\_highlight\_digit\_groups

Si cette option est activée et si la sortie est un terminal, chaque chiffre correspondant aux milliers, millions, etc. est mis en évidence par soulignement.

## output\_format\_pretty\_highlight\_trailing\_spaces

Si cette option est activée et que la sortie est un terminal, les espaces de fin de ligne sont mis en évidence en gris et soulignés.

## output\_format\_pretty\_max\_column\_name\_width\_cut\_to

Si le nom de la colonne est trop long, il est tronqué à cette longueur. La colonne est tronquée si sa longueur dépasse `output_format_pretty_max_column_name_width_cut_to` plus `output_format_pretty_max_column_name_width_min_chars_to_cut`.

## output\_format\_pretty\_max\_column\_name\_width\_min\_chars\_to\_cut

Nombre minimum de caractères à tronquer si le nom de la colonne est trop long. Le nom de la colonne sera tronqué s'il dépasse `output_format_pretty_max_column_name_width_cut_to` plus `output_format_pretty_max_column_name_width_min_chars_to_cut`.

## output\_format\_pretty\_max\_column\_pad\_width

Largeur maximale du remplissage appliqué à toutes les valeurs d’une colonne dans les formats Pretty.

## output\_format\_pretty\_max\_rows

Limite du nombre de lignes pour les formats Pretty.

## output\_format\_pretty\_max\_value\_width

Largeur maximale de la valeur affichée dans les formats Pretty. Au-delà, elle sera tronquée. La valeur 0 signifie : ne jamais tronquer.

## output\_format\_pretty\_max\_value\_width\_apply\_for\_single\_value

Ne tronquez les valeurs (voir le paramètre `output_format_pretty_max_value_width`) que lorsqu'il ne s'agit pas d'une valeur seule dans un bloc. Sinon, affichez-la en entier, ce qui est utile pour la requête `SHOW CREATE TABLE`.

## output\_format\_pretty\_multiline\_fields

Si cette option est activée, les formats Pretty afficheront les champs sur plusieurs lignes à l’intérieur des cellules du tableau, de sorte que les bordures du tableau soient préservées. Sinon, ils seront affichés tels quels, ce qui peut déformer le tableau (l’un des avantages de laisser cette option désactivée est qu’il sera plus facile de copier-coller des valeurs sur plusieurs lignes).

## output\_format\_pretty\_named\_tuples\_as\_json

Contrôle si les tuples nommés dans le format Pretty sont affichés sous forme d’objets JSON mis en forme de manière lisible.

## output\_format\_pretty\_row\_numbers

Ajouter les numéros de ligne avant chaque ligne pour le format de sortie Pretty

## output\_format\_pretty\_single\_large\_number\_tip\_threshold

Afficher une indication lisible du nombre sur le côté droit de la table si le bloc ne contient qu'un seul nombre dépassant cette valeur (hors 0)

## output\_format\_pretty\_squash\_consecutive\_ms

Attendre le bloc suivant pendant le nombre de millisecondes spécifié et le fusionner avec le précédent avant l’écriture. Cela évite d’émettre trop souvent des blocs trop petits, tout en permettant d’afficher les données en continu.

## output\_format\_pretty\_squash\_max\_wait\_ms

Affiche le bloc en attente dans les formats Pretty si le nombre de millisecondes écoulées depuis la sortie précédente dépasse la valeur spécifiée.

## output\_format\_pretty\_use\_nbsp\_for\_padding

S’il est activé, l’espacement de remplissage dans les formats de sortie `Pretty` est rendu avec `U+00A0` au lieu d’un espace ASCII. La sortie reste visuellement identique dans une police à chasse fixe, mais cet espacement de remplissage est préservé par les outils qui compressent ou suppriment les suites d’espaces ordinaires. Ne prend effet que lorsque `output_format_pretty_grid_charset` vaut `UTF-8`.

## output\_format\_protobuf\_nullables\_with\_google\_wrappers

Lors de la sérialisation de colonnes Nullable avec des wrappers Google, sérialisez les valeurs par défaut sous forme de wrappers vides. Si ce paramètre est désactivé, les valeurs par défaut et les valeurs NULL ne sont pas sérialisées

## output\_format\_schema

Chemin du fichier dans lequel le schéma généré automatiquement sera enregistré aux formats [Cap'n Proto](/fr/reference/formats/CapnProto) ou [Protobuf](/fr/reference/formats/Protobuf/Protobuf).

## output\_format\_sql\_insert\_include\_column\_names

Inclut les noms de colonnes dans la requête INSERT

## output\_format\_sql\_insert\_max\_batch\_size

Le nombre maximal de lignes dans une seule instruction INSERT.

## output\_format\_sql\_insert\_quote\_names

Met les noms de colonnes entre apostrophes inversées (« \` »)

## output\_format\_sql\_insert\_table\_name

Le nom de la table dans la requête INSERT en sortie

## output\_format\_sql\_insert\_use\_replace

Utiliser l’instruction REPLACE au lieu d’INSERT

## output\_format\_trim\_fixed\_string

Supprime les octets nuls de fin des valeurs FixedString dans les formats de sortie textuels. Par exemple, `toFixedString('John', 8)` s'affiche sous la forme `John` au lieu de `John\0\0\0\0`.

## output\_format\_tsv\_crlf\_end\_of\_line

Si cette option est définie sur true, la fin de ligne au format TSV sera \r\n au lieu de \n.

## output\_format\_values\_escape\_quote\_with\_quote

Si true, échapper ' en '', sinon avec \\'

## output\_format\_write\_statistics

Écrit des statistiques concernant les lignes lues, les octets et le temps écoulé dans les formats de sortie compatibles. Activé par défaut