Ces paramètres sont générés automatiquement à partir du code source.
allow_special_bool_values_inside_variant
bool_false_representation
true dans les formats TSV/CSV/Vertical/Pretty.
check_conversion_from_numbers_to_enum
- 0 — Désactivé.
- 1 — Activé.
Exemple
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
-
'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. Par exemple, '2018-06-08T01:02:03.000Z'.
-
'best_effort_us' — Semblable à best_effort (voir la différence avec 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 :
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 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. Par exemple, 1566285536.
Voir aussi :
date_time_overflow_behavior
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.
Méthode d’écriture des erreurs dans la sortie texte.
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).
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.
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).
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.
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).
Pour le format AvroConfluent : URL de Confluent Schema Registry.
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
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
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
Comment faire correspondre les Enum ClickHouse et CapnProto
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.
Utilise le schéma CapnProto généré automatiquement lorsque format_schema n’est pas défini
S’il est défini sur true, autorise les chaînes de caractères entre guillemets doubles.
S’il est défini sur true, autorise les chaînes entre guillemets simples.
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.
Représentation personnalisée de NULL au format CSV
Règle d’échappement des champs (pour le format CustomSeparated)
Délimiteur entre les champs (format CustomSeparated)
Suffixe après le jeu de résultats (pour le format CustomSeparated)
Préfixe précédant le jeu de résultats (pour le format CustomSeparated)
Délimiteur après le champ de la dernière colonne (format CustomSeparated)
Délimiteur avant le champ de la première colonne (format CustomSeparated)
Délimiteur entre les lignes (pour le format CustomSeparated)
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
activé et disposer du
displaySecretsInShowAndSelect privilège.
Valeurs possibles :
- 0 — Désactivé.
- 1 — Activé.
Nom de la colonne utilisée pour stocker/écrire les noms d’objet au format 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.
Utiliser un Protobuf autogénéré lorsque format_schema n’est pas défini
Expression régulière (pour le format Regexp)
Règle d’échappement du champ (pour le format Regexp)
Ignorer les lignes ne correspondant pas à l’expression régulière (pour le format Regexp)
Ce paramètre est utile lorsque vous utilisez des formats qui nécessitent une définition de schéma, comme Cap’n Proto ou Protobuf. Sa valeur dépend du format.
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.
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.
Chemin d’accès au fichier contenant la chaîne de format du jeu de résultats (pour le format Template)
Chaîne de format du jeu de résultats (pour le format Template)
Chemin du fichier contenant la chaîne de format des lignes (pour le format Template)
Chaîne de format pour les lignes (pour le format Template)
Délimiteur entre les lignes (format Template)
Représentation NULL personnalisée pour le format TSV
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.
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.
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.
Autoriser les colonnes manquantes lors de la lecture des formats d’entrée Arrow
Ignore la casse lors de la correspondance entre les colonnes Arrow et les colonnes CH.
Ignorer les colonnes de types non pris en charge lors de l’inférence du schéma pour le format Arrow
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
Pour le format Avro/AvroConfluent : insérer la valeur par défaut en cas de NULL dans une colonne non Nullable
Lire les types de données au format binaire au lieu des noms de type dans le format d’entrée RowBinaryWithNamesAndTypes
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é.
Lit les valeurs du type de données JSON comme des valeurs String JSON dans le format d’entrée RowBinary.
Ignore les champs dont les types ne sont pas pris en charge lors de l’inférence du schéma pour le format BSON.
Ignorer les colonnes dont les types ne sont pas pris en charge lors de l’inférence du schéma pour le format CapnProto
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.
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
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 (et autres formats JSON), CSV, TabSeparated, TSKV, Parquet, Arrow, Avro, ORC, 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.
- 0 — Désactivé.
- 1 — Activé.
Forcer l’initialisation des champs omis avec des valeurs NULL
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
input_format_hive_text_collection_items_delimiter
input_format_hive_text_fields_delimiter
input_format_hive_text_map_keys_delimiter
- 0 — Désactivé.
- 1 — Activé.
Voir aussi :
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.
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.
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.
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.
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é.
Ignorer les clés inconnues dans les objets JSON pour les tuples nommés.
Activé par défaut.
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
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 :
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=1;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');
┌─name─┬─type───────────┐
│ a │ Array(Dynamic) │
└──────┴────────────────┘
SET input_format_json_infer_array_of_dynamic_from_array_of_different_types=0;
DESC format(JSONEachRow, '{"a" : [42, "hello", [1, 2, 3]]}');
┌─name─┬─type─────────────────────────────────────────────────────────────┐
│ a │ Tuple(Nullable(Int64), Nullable(String), Array(Nullable(Int64))) │
└──────┴──────────────────────────────────────────────────────────────────┘
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 :
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" : []}}');
┌─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,'{}',[]) │
└────────────────────────────────┘
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]]}');
┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String │ [1,2,3] │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘
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;
┌─id─┬─obj──────────────────────┬───────date─┐
│ 1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │
└────┴──────────────────────────┴────────────┘
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}}}')
┌─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))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
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.
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
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.
Autoriser les colonnes manquantes lors de la lecture du format d’entrée ORC
Ignore la casse lors de la mise en correspondance des colonnes ORC avec les colonnes CH.
Traiter les colonnes encodées à l’aide du dictionnaire ORC comme des colonnes LowCardinality lors de la lecture de fichiers ORC.
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.
Nom du fuseau horaire du lecteur de lignes ORC ; le fuseau horaire par défaut du lecteur de lignes ORC est GMT.
Taille du lot pour la lecture des stripes ORC.
Ignorer les colonnes dont les types ne sont pas pris en charge lors de l’inférence du schéma pour le format ORC
Utilise une implémentation plus rapide du décodeur ORC.
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), TSKV, CSV et JSONEachRow.
Valeurs possibles :
- 1 — Activé.
- 0 — Désactivé.
Utilise l’analyseur de colonnes géo pour convertir Array(UInt8) en types Point/Linestring/Polygon/MultiLineString/MultiPolygon
Autoriser les colonnes manquantes lors de la lecture de formats d’entrée Parquet
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.
Ignorer la casse lors de la mise en correspondance des colonnes Parquet avec les colonnes CH.
Lors de la lecture de fichiers Parquet, interpréter les colonnes JSON comme des colonnes JSON ClickHouse.
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.
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.
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
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.
Taille maximale des blocs pour le lecteur Parquet.
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.
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
ORDER BY _row_number.
Ignorer les colonnes dont les types ne sont pas pris en charge lors de l’inférence de schéma pour le format Parquet
Ajustement mineur de la façon dont les pages sont lues à partir d’un fichier Parquet lorsqu’aucun filtrage de page n’est appliqué.
Vérifie les sommes de contrôle des pages lors de la lecture des fichiers Parquet.
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
Indique quel champ du oneof Protobuf a été trouvé en définissant une valeur enum dans une colonne spéciale
Ignorer les champs dont les types ne sont pas pris en charge lors de l’inférence de schéma pour le format Protobuf
Chemin du fichier utilisé pour consigner les erreurs lors de la lecture de formats texte (CSV, TSV).
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 :
Valeurs possibles :
- 0 — Désactivé.
- 1 — Activé.
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.
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.
Lorsque input_format_try_infer_datetimes est activé, n’inférer que le type DateTime64, et non les types DateTime
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)
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.
Si cette option est activée, ClickHouse tentera d’inférer le type 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é.
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
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.
Détecte automatiquement l’en-tête avec les noms et les types au format TSV
Traite les champs vides dans l’entrée TSV comme des valeurs par défaut.
Traite les valeurs d’enum insérées dans les formats TSV comme des indices d’enum.
Ignore le nombre spécifié de lignes au début des données au format TSV
Ignorer les lignes vides finales au format TSV
Utilise certains ajustements et heuristiques pour inférer le schéma au format TSV
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.
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.
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.
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 :
Valeurs possibles :
- 0 — Désactivé.
- 1 — Activé.
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 :
Valeurs possibles :
- 0 — Désactivé.
- 1 — Activé.
insert_distributed_one_random_shard
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.
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. 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 :
into_outfile_create_parent_directories
json_type_escape_dots_in_keys
max_dynamic_subcolumns_in_json_type_parsing
1. au lieu de 1.
Désactivé par défaut.
Méthode de compression du format de sortie Arrow. Codecs pris en charge : lz4_frame, zstd, none (sans compression)
É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).
Utilise le type Arrow FIXED_SIZE_BINARY au lieu de Binary pour les colonnes FixedString.
Active la sortie du type LowCardinality sous forme de type Arrow Dictionary
Utiliser le type String d’Arrow au lieu de Binary pour les colonnes String
Renvoie les types sans conversion sous forme de données binaires brutes. Si false, ces types lèvent une exception UNKNOWN_TYPE.
Toujours utiliser des entiers 64 bits pour les index de dictionnaire au format Arrow
Utiliser des entiers signés pour les index de dictionnaire au format Arrow
Codec de compression utilisé en sortie. Valeurs possibles : ‘null’, ‘deflate’, ‘snappy’, ‘zstd’.
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.
Nombre maximal de lignes dans un fichier (si le stockage le permet)
Pour le format Avro : expression régulière des colonnes de type String à sélectionner en tant que chaîne AVRO.
Intervalle de synchronisation, en octets.
Écrire les types de données au format binaire plutôt que les noms de type dans le format de sortie RowBinaryWithNamesAndTypes
Écrit les valeurs de type JSON sous forme de valeurs JSON String dans le format de sortie RowBinary.
Utilise le type BSON String au lieu de Binary pour les colonnes de type String.
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
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).
Si ce paramètre est défini sur true, la fin de ligne au format CSV sera \r\n au lieu de \n.
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)
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.
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.
Hauteur, en pixels, de l’image de sortie pour les formats de sortie d’image tels que PNG.
Valeur par défaut : 1024.
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).
Largeur, en pixels, de l’image de sortie pour les formats de sortie d’image tels que PNG.
Valeur par défaut : 1024.
Permet de générer toutes les lignes sous la forme d’un tableau JSON au format 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 :
SET output_format_json_array_of_rows = 1;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
[
{"number":"0"},
{"number":"1"},
{"number":"2"}
]
SET output_format_json_array_of_rows = 0;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
{"number":"0"}
{"number":"1"}
{"number":"2"}
/ 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.
Sérialise les colonnes Map sous forme de tableaux JSON de tuples.
Désactivé par défaut.
Sérialise les colonnes de tuples nommés sous forme d’objets JSON.
Activé par défaut.
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 :
"data":
[
{
"tuple": {"a":1,"b":2,"c":3},
"array": [1,2,3],
"map": {"a":1,"b":2,"c":3}
}
],
"data":
[
{
"tuple": {
"a": 1,
"b": 2,
"c": 3
},
"array": [
1,
2,
3
],
"map": {
"a": 1,
"b": 2,
"c": 3
}
}
],
UInt64 ou Int128) lorsqu’ils sont affichés au format 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.
Contrôle la mise entre guillemets des valeurs décimales dans les formats de sortie JSON.
Désactivé par défaut.
Permet d’inclure les valeurs +nan, -nan, +inf, -inf dans le format de sortie JSON.
Valeurs possibles :
- 0 — Désactivé.
- 1 — Activé.
Exemple
Considérez la table account_orders suivante :
┌─id─┬─name───┬─duration─┬─period─┬─area─┐
│ 1 │ Andrew │ 20 │ 0 │ 400 │
│ 2 │ John │ 40 │ 0 │ 0 │
│ 3 │ Bob │ 15 │ 0 │ -100 │
└────┴────────┴──────────┴────────┴──────┘
output_format_json_quote_denormals = 0, la requête renvoie des valeurs null dans la sortie :
SELECT area/period FROM account_orders FORMAT JSON;
{
"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
}
}
output_format_json_quote_denormals = 1, la requête renvoie :
{
"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
}
}
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
- 0 — Désactivé.
- 1 — Activé.
Définit la manière dont un UUID est généré au format MsgPack.
Écrit les types de données au format binaire au lieu des noms de type dans le format de sortie Native
Écrit les données des colonnes JSON et Dynamic dans un format aplati (tous les types/chemins sous forme de sous-colonnes distinctes).
Écrit les données d’une colonne JSON sous forme de colonne String contenant des chaînes JSON, au lieu de la sérialisation JSON native par défaut.
Taille, en octets, du bloc de compression pour le format de sortie ORC.
Méthode de compression pour le format de sortie ORC. Codecs pris en charge : lz4, snappy, zlib, zstd, none (non compressé)
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é
Pas cible de l’index de ligne dans le format de sortie ORC
Utiliser le type String d’ORC au lieu de Binary pour les colonnes String
Nom du fuseau horaire du writer ORC ; le fuseau horaire par défaut du writer ORC est GMT.
Active ou désactive la mise en forme parallèle des données. Pris en charge uniquement pour les formats TSV, TSKV, CSV et JSONEachRow.
Valeurs possibles :
- 1 — Activé.
- 0 — Désactivé.
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.
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%
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.
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
output_format_parquet_write_page_index
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 1000);
┌─number─┬─toTypeName(number)─┐
1. │ 0 │ UInt64 │
2. │ 1 │ UInt64 │
3. │ 2 │ UInt64 │
...
999. │ 998 │ UInt64 │
1000. │ 999 │ UInt64 │
└─number─┴─toTypeName(number)─┘
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Largeur maximale du remplissage appliqué à toutes les valeurs d’une colonne dans les formats Pretty.
Limite du nombre de lignes pour les formats Pretty.
Largeur maximale de la valeur affichée dans les formats Pretty. Au-delà, elle sera tronquée.
La valeur 0 signifie : ne jamais tronquer.
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.
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).
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.
Ajouter les numéros de ligne avant chaque ligne pour le format de sortie Pretty
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)
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.
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.
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.
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
Chemin du fichier dans lequel le schéma généré automatiquement sera enregistré aux formats Cap’n Proto ou Protobuf.
Inclut les noms de colonnes dans la requête INSERT
Le nombre maximal de lignes dans une seule instruction INSERT.
Met les noms de colonnes entre apostrophes inversées (« ` »)
Le nom de la table dans la requête INSERT en sortie
Utiliser l’instruction REPLACE au lieu d’INSERT
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.
Si cette option est définie sur true, la fin de ligne au format TSV sera \r\n au lieu de \n.
Si true, échapper ’ en ”, sinon avec \‘
Écrit des statistiques concernant les lignes lues, les octets et le temps écoulé dans les formats de sortie compatibles.
Activé par défaut
Privilégier un algorithme d’analyse des nombres à virgule flottante plus précis (mais plus lent)
La liste des noms de colonnes et des types à utiliser comme indications lors de l’inférence de schéma pour les formats sans schéma.
Exemple :
Requête :
desc format(JSONEachRow, '{"x" : 1, "y" : "String", "z" : "0.0.0.0" }') settings schema_inference_hints='x UInt8, z IPv4';
x UInt8
y Nullable(String)
z IPv4
Si schema_inference_hints n’est pas correctement formaté, ou s’il contient une faute de frappe, un type de données erroné, etc., l’intégralité de schema_inference_hints sera ignorée.
schema_inference_make_columns_nullable
Nullable lors de l’inférence de schéma.
Valeurs possibles :
- 0 - le type inféré ne sera jamais
Nullable (utilisez input_format_null_as_default pour définir le comportement à adopter avec les valeurs nulles dans ce cas),
- 1 - tous les types inférés seront
Nullable,
- 2 ou
auto - le type inféré sera Nullable uniquement si la colonne contient NULL dans un échantillon analysé lors de l’inférence de schéma, ou si les métadonnées du fichier contiennent des informations sur la nullabilité de la colonne,
- 3 - la nullabilité du type inféré correspondra aux métadonnées du fichier si le format la prend en charge (par ex. Parquet) ; sinon, il sera toujours
Nullable (par ex. CSV).
schema_inference_make_json_columns_nullable
Nullable lors de l’inférence de schéma.
Si ce paramètre est activé avec schema_inference_make_columns_nullable, le type JSON inféré sera Nullable.
Mode d’inférence de schéma. ‘default’ - suppose que tous les fichiers ont le même schéma et que celui-ci peut être inféré à partir de n’importe quel fichier, ‘union’ - les fichiers peuvent avoir des schémas différents et le schéma résultant doit être l’union des schémas de tous les fichiers
show_create_query_identifier_quoting_rule
show_create_query_identifier_quoting_style
type_json_allow_duplicated_key_with_literal_and_nested_object
{"a" : 42, "a" : {"b" : 42}}, dans lesquels une clé est dupliquée mais où l’une des occurrences est un objet imbriqué.
type_json_skip_duplicated_paths
type_json_skip_invalid_typed_paths
- 0 — Désactiver (générer une erreur en cas d’incompatibilité de type).
- 1 — Activer (ignorer le champ en cas d’incompatibilité de type).
type_json_use_partial_match_to_skip_paths_by_regexp
validate_experimental_and_suspicious_types_inside_nested_types
