> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Format Settings
> Settings which control input and output formats.
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
const cells = [["Type", {type}], ["Default value", {default_value}]];
if (changeable_without_restart) {
const isYes = String(changeable_without_restart).trim().toLowerCase() === "yes";
const badge = isYes ? Yes : No;
cells.push(["Changeable without restart", badge]);
}
return
{cells.map(([h]) => | {h} | )}
{cells.map(([h, v]) => | {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 ;
};
export const ExperimentalBadge = () => {
return ;
};
These settings are autogenerated from [source](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/FormatFactorySettings.h).
allow\_special\_bool\_values\_inside\_variant
Allows to parse Bool values inside Variant type from special text bool values like "on", "off", "enable", "disable", etc.
bool\_false\_representation
Text to represent false bool value in TSV/CSV/Vertical/Pretty formats.
bool\_true\_representation
Text to represent true bool value in TSV/CSV/Vertical/Pretty formats.
check\_conversion\_from\_numbers\_to\_enum
Throw an exception during Numbers to Enum conversion if the value does not exist in Enum.
Possible values:
* 0 — Disabled.
* 1 — Enabled.
**Example**
```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
The list of column names to use in schema inference for formats without column names. The format: 'column1,column2,column3,...'
Dynamically trim the trailing zeros of datetime64 values to adjust the output scale to \[0, 3, 6],
corresponding to 'seconds', 'milliseconds', and 'microseconds'
Allows choosing a parser of the text representation of date and time.
The setting does not apply to [date and time functions](/reference/functions/regular-functions/date-time-functions).
Possible values:
* `'best_effort'` — Enables extended parsing.
ClickHouse can parse the basic `YYYY-MM-DD HH:MM:SS` format and all [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time formats. For example, `'2018-06-08T01:02:03.000Z'`.
* `'best_effort_us'` — Similar to `best_effort` (see the difference in [parseDateTimeBestEffortUS](/reference/functions/regular-functions/type-conversion-functions#parseDateTimeBestEffortUS)
* `'basic'` — Use basic parser.
ClickHouse can parse only the basic `YYYY-MM-DD HH:MM:SS` or `YYYY-MM-DD` format. For example, `2019-08-20 10:18:56` or `2019-08-20`.
See also:
* [DateTime data type.](/reference/data-types/datetime)
* [Functions for working with dates and times.](/reference/functions/regular-functions/date-time-functions)
Allows choosing different output formats of the text representation of date and time.
Possible values:
* `simple` - Simple output format.
ClickHouse output date and time `YYYY-MM-DD hh:mm:ss` format. For example, `2019-08-20 10:18:56`. The calculation is performed according to the data type's time zone (if present) or server time zone.
* `iso` - ISO output format.
ClickHouse output date and time in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) `YYYY-MM-DDThh:mm:ssZ` format. For example, `2019-08-20T10:18:56Z`. Note that output is in UTC (`Z` means UTC).
* `unix_timestamp` - Unix timestamp output format.
ClickHouse output date and time in [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time) format. For example `1566285536`.
See also:
* [DateTime data type.](/reference/data-types/datetime)
* [Functions for working with dates and times.](/reference/functions/regular-functions/date-time-functions)
date\_time\_overflow\_behavior
Defines the behavior when [Date](/reference/data-types/date), [Date32](/reference/data-types/date32), [DateTime](/reference/data-types/datetime), [DateTime64](/reference/data-types/datetime64) or integers are converted into Date, Date32, DateTime or DateTime64 but the value cannot be represented in the result type.
Possible values:
* `ignore` — Silently ignore overflows. Result are undefined.
* `throw` — Throw an exception in case of overflow.
* `saturate` — Saturate the result. If the value is smaller than the smallest value that can be represented by the target type, the result is chosen as the smallest representable value. If the value is bigger than the largest value that can be represented by the target type, the result is chosen as the largest representable value.
Default value: `ignore`.
Method to write Errors to text output.
For AvroConfluent format: connection timeout in seconds for the Confluent Schema Registry HTTP client. Used by both schema fetch and schema registration. Must be greater than 0 and less than 600 (10 minutes).
For AvroConfluent format: receive timeout in seconds for the Confluent Schema Registry HTTP client. Used by both schema fetch and schema registration. Must be greater than 0 and less than 600 (10 minutes).
For AvroConfluent format: send timeout in seconds for the Confluent Schema Registry HTTP client. Used by both schema fetch and schema registration. Must be greater than 0 and less than 600 (10 minutes).
For AvroConfluent format: Confluent Schema Registry URL.
The maximum allowed size for Array in RowBinary format. It prevents allocating large amount of memory in case of corrupted data. 0 means there is no limit
The maximum allowed number of paths in a single Object for JSON type RowBinary format. It prevents allocating large amount of memory in case of corrupted data. 0 means there is no limit
The maximum allowed size for String in RowBinary format. It prevents allocating large amount of memory in case of corrupted data. 0 means there is no limit
How to map ClickHouse Enum and CapnProto Enum
Maximum size of a single CapnProto message in bytes. This protects against malformed or corrupted data causing excessive memory allocation. Default is 1 GiB.
Use autogenerated CapnProto schema when format\_schema is not set
If it is set to true, allow strings in double quotes.
If it is set to true, allow strings in single quotes.
The character to be considered as a delimiter in CSV data. If setting with a string, a string has to have a length of 1.
Custom NULL representation in CSV format
Field escaping rule (for CustomSeparated format)
Delimiter between fields (for CustomSeparated format)
Suffix after result set (for CustomSeparated format)
Prefix before result set (for CustomSeparated format)
Delimiter after field of the last column (for CustomSeparated format)
Delimiter before field of the first column (for CustomSeparated format)
Delimiter between rows (for CustomSeparated format)
Enables or disables showing secrets in `SHOW` and `SELECT` queries for tables, databases,
table functions, and dictionaries.
User wishing to see secrets must also have
[`display_secrets_in_show_and_select` server setting](/reference/settings/server-settings/settings#display_secrets_in_show_and_select)
turned on and a
[`displaySecretsInShowAndSelect`](/reference/statements/grant#displaysecretsinshowandselect) privilege.
Possible values:
* 0 — Disabled.
* 1 — Enabled.
The name of column that will be used for storing/writing object names in [JSONObjectEachRow](/reference/formats/JSON/JSONObjectEachRow) format.
Column type should be String. If value is empty, default names `row_{i}`will be used for object names.
Use autogenerated Protobuf when format\_schema is not set
Regular expression (for Regexp format)
Field escaping rule (for Regexp format)
Skip lines unmatched by regular expression (for Regexp format)
This parameter is useful when you are using formats that require a schema definition, such as [Cap'n Proto](https://capnproto.org/) or [Protobuf](https://developers.google.com/protocol-buffers/). The value depends on the format.
Define the name of the required message in the schema defined in `format_schema`.
To maintain compatibility with the legacy format\_schema format (`file_name:message_name`):
* If `format_schema_message_name` is not specified, the message name is inferred from the `message_name` part of the legacy `format_schema` value.
* If `format_schema_message_name` is specified while using the legacy format, an error will be raised.
Define the source of `format_schema`.
Possible values:
* 'file' (default): The `format_schema` is the name of a schema file located in the `format_schemas` directory.
* 'string': The `format_schema` is the literal content of the schema.
* 'query': The `format_schema` is a query to retrieve the schema.
When `format_schema_source` is set to 'query', the following conditions apply:
* The query must return exactly one value: a single row with a single string column.
* The result of the query is treated as the schema content.
* This result is cached locally in the `format_schemas` directory.
* You can clear the local cache using the command: `SYSTEM DROP FORMAT SCHEMA CACHE FOR Files`.
* Once cached, identical queries are not executed to fetch the schema again until the cache is explicitly cleared
* In addition to local cache files, Protobuf messages are also cached in memory. Even after clearing the local cache files, the in-memory cache must be cleared using `SYSTEM DROP FORMAT SCHEMA CACHE [FOR Protobuf]` to fully refresh the schema.
* Run the query `SYSTEM DROP FORMAT SCHEMA CACHE` to clear the cache for both cache files and Protobuf messages schemas at once.
Path to file which contains format string for result set (for Template format)
Format string for result set (for Template format)
Path to file which contains format string for rows (for Template format)
Format string for rows (for Template format)
Delimiter between rows (for Template format)
Custom NULL representation in TSV format
Sets the maximum number of acceptable errors when reading from text formats (CSV, TSV, etc.).
The default value is 0.
Always pair it with `input_format_allow_errors_ratio`.
If an error occurred while reading rows but the error counter is still less than `input_format_allow_errors_num`, ClickHouse ignores the row and moves on to the next one.
If both `input_format_allow_errors_num` and `input_format_allow_errors_ratio` are exceeded, ClickHouse throws an exception.
Sets the maximum percentage of errors allowed when reading from text formats (CSV, TSV, etc.).
The percentage of errors is set as a floating-point number between 0 and 1.
The default value is 0.
Always pair it with `input_format_allow_errors_num`.
If an error occurred while reading rows but the error counter is still less than `input_format_allow_errors_ratio`, ClickHouse ignores the row and moves on to the next one.
If both `input_format_allow_errors_num` and `input_format_allow_errors_ratio` are exceeded, ClickHouse throws an exception.
Allow seeks (or range reads) while reading ORC, Parquet, and Arrow input formats.
When enabled and the source supports it (e.g. local file, S3, HTTP with range support and known size),
ClickHouse can read only the needed byte ranges and use less memory.
When disabled, or when the source does not support seeks (e.g. no file size, or stream not seekable),
some readers may fall back to loading the full file into memory.
Enabled by default.
Allow missing columns while reading Arrow input formats
Ignore case when matching Arrow columns with CH columns.
Skip columns with unsupported types while schema inference for format Arrow
For Avro/AvroConfluent format: when field is not found in schema use default value instead of error
For Avro/AvroConfluent format: insert default in case of null and non Nullable colum
Read data types in binary format instead of type names in RowBinaryWithNamesAndTypes input format
Max type nodes when decoding binary types (not depth, but total count). `Map(String, UInt32)` = 3 nodes. Protects against malicious inputs. 0 = unlimited.
Read values of [JSON](/reference/data-types/newjson) data type as JSON [String](/reference/data-types/string) values in RowBinary input format.
Skip fields with unsupported types while schema inference for format BSON.
Skip columns with unsupported types while schema inference for format CapnProto
Defines the column name matching mode when ingesting data through various formats (including but not limited to JSONEachRow, CSVWithNames, JSONColumns, BSONEachRow, RowBinaryWithNames).
Supported modes:
* match\_case: match case-sensitively
* ignore\_case: match case-insensitively
* auto: first tries to match case-sensitively, if fails, tries to match case-insensitively.
When this option is enabled, if the connection closes unexpectedly, any remaining data in the buffer will be parsed and processed instead of being treated as an error
Enabling this option disables parallel parsing and makes deduplication impossible
If it is set true, \r will be allowed at end of line not followed by
Ignore extra columns in CSV input (if file has more columns than expected) and treat missing fields in CSV input as default values
Allow to use spaces and tabs(\t) as field delimiter in the CSV strings
When reading Array from CSV, expect that its elements were serialized in nested CSV and then put into string. Example: "\[""Hello"", ""world"", ""42"""" TV""]". Braces around array can be omitted.
If it set to true, then separate columns written in CSV format can be deserialized to Tuple column.
Automatically detect header with names and types in CSV format
Treat empty fields in CSV input as default values.
Treat inserted enum values in CSV formats as enum indices
Skip specified number of lines at the beginning of data in CSV format
Skip trailing empty lines in CSV format
Trims spaces and tabs (\t) characters at the beginning and end in CSV strings
If enabled, during schema inference ClickHouse will try to infer numbers from string fields.
It can be useful if CSV data contains quoted UInt64 numbers.
Disabled by default.
Interpret quoted tuples in the input data as a value of type String.
Use some tweaks and heuristics to infer schema in CSV format
Allow to set default value to column when CSV field deserialization failed on bad value
Ignore extra columns in CustomSeparated input (if file has more columns than expected) and treat missing fields in CustomSeparated input as default values
Automatically detect header with names and types in CustomSeparated format
Skip trailing empty lines in CustomSeparated format
When performing `INSERT` queries, replace omitted input column values with default values of the respective columns. This option applies to [JSONEachRow](/reference/formats/JSON/JSONEachRow) (and other JSON formats), [CSV](/reference/formats/CSV/CSV), [TabSeparated](/reference/formats/TabSeparated/TabSeparated), [TSKV](/reference/formats/TabSeparated/TSKV), [Parquet](/reference/formats/Parquet/Parquet), [Arrow](/reference/formats/Arrow/Arrow), [Avro](/reference/formats/Avro/Avro), [ORC](/reference/formats/ORC), [Native](/reference/formats/Native) formats and formats with `WithNames`/`WithNamesAndTypes` suffixes.
When this option is enabled, extended table metadata are sent from server to client. It consumes additional computing resources on the server and can reduce performance.
Possible values:
* 0 — Disabled.
* 1 — Enabled.
Force initialize omitted fields with null values
input\_format\_hive\_text\_allow\_variable\_number\_of\_columns
Ignore extra columns in Hive Text input (if file has more columns than expected) and treat missing fields in Hive Text input as default values
input\_format\_hive\_text\_collection\_items\_delimiter
Delimiter between collection(array or map) items in Hive Text File
input\_format\_hive\_text\_fields\_delimiter
Delimiter between fields in Hive Text File
input\_format\_hive\_text\_map\_keys\_delimiter
Delimiter between a pair of map key/values in Hive Text File
Enables or disables the insertion of JSON data with nested objects.
Supported formats:
* [JSONEachRow](/reference/formats/JSON/JSONEachRow)
Possible values:
* 0 — Disabled.
* 1 — Enabled.
See also:
* [Usage of Nested Structures](/guides/clickhouse/data-formats/json/formats#accessing-nested-json-objects) with the `JSONEachRow` format.
Deserialization of IPv4 will use default values instead of throwing exception on conversion error.
Disabled by default.
Deserialization of IPV6 will use default values instead of throwing exception on conversion error.
Disabled by default.
Allow variable number of columns in rows in JSONCompact/JSONCompactEachRow input formats.
Ignore extra columns in rows with more columns than expected and treat missing columns as default values.
Disabled by default.
Insert default values for missing elements in JSON object while parsing named tuple.
This setting works only when setting `input_format_json_named_tuples_as_objects` is enabled.
Enabled by default.
When enabled, replace empty input fields in JSON with default values. For complex default expressions `input_format_defaults_for_omitted_fields` must be enabled too.
Possible values:
* 0 — Disable.
* 1 — Enable.
Ignore unknown keys in json object for named tuples.
Enabled by default.
Ignore unnecessary fields and not parse them. Enabling this may not throw exceptions on json strings of invalid format or with duplicated fields
If enabled, during schema inference ClickHouse will use Array(Dynamic) type for JSON arrays with values of different data types.
Example:
```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))) │
└──────┴──────────────────────────────────────────────────────────────────┘
```
Enabled by default.
Allow to use String type for JSON keys that contain only `Null`/`{}`/`[]` in data sample during schema inference.
In JSON formats any value can be read as String, and we can avoid errors like `Cannot determine type for column 'column_name' by first 25000 rows of data, most likely this column contains only Nulls or empty Arrays/Maps` during schema inference
by using String type for keys with unknown types.
Example:
```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" : []}}');
```
Result:
```
┌─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,'{}',[]) │
└────────────────────────────────┘
```
Enabled by default.
Deserialize maps columns as JSON arrays of tuples.
Disabled by default.
Maximum depth of a field in JSON. This is not a strict limit, it does not have to be applied precisely.
Parse named tuple columns as JSON objects.
Enabled by default.
Allow parsing JSON arrays as strings in JSON input formats.
Example:
```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]]}');
```
Result:
```
┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String │ [1,2,3] │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘
```
Enabled by default.
Allow parsing bools as numbers in JSON input formats.
Enabled by default.
Allow parsing bools as strings in JSON input formats.
Enabled by default.
Allow parsing numbers as strings in JSON input formats.
Enabled by default.
Allow parsing JSON objects as strings in JSON input formats.
Example:
```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;
```
Result:
```
┌─id─┬─obj──────────────────────┬───────date─┐
│ 1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │
└────┴──────────────────────────┴────────────┘
```
Enabled by default.
Throw an exception if JSON string contains bad escape sequence in JSON input formats. If disabled, bad escape sequences will remain as is in the data.
Enabled by default.
If enabled, during schema inference ClickHouse will try to infer named Tuple from JSON objects.
The resulting named Tuple will contain all elements from all corresponding JSON objects from sample data.
Example:
```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}}}')
```
Result:
```
┌─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))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
```
Enabled by default.
If enabled, during schema inference ClickHouse will try to infer numbers from string fields.
It can be useful if JSON data contains quoted UInt64 numbers.
Disabled by default.
Use String type instead of an exception in case of ambiguous paths in JSON objects during named tuples inference
For JSON/JSONCompact/JSONColumnsWithMetadata input formats, if this setting is set to 1,
the types from metadata in input data will be compared with the types of the corresponding columns from the table.
Enabled by default.
Limits the size of the blocks formed during data parsing in input formats in bytes. Used in row based input formats when block is formed on ClickHouse side.
0 means no limit in bytes.
Limits the maximum time in milliseconds to wait before emitting a block during parsing in row-based input formats. 0 means no limit.
This option only works if `input_format_connection_handling` is enabled. Setting a value also disables parallel parsing and makes deduplication impossible.
For streaming inserts, you must also set `min_insert_block_size_rows=0` and `min_insert_block_size_bytes=0`. Otherwise, parsed blocks may still be accumulated in memory by the block squashing stage until those thresholds are reached, preventing timely inserts.
**Example: streaming Wikipedia recent changes into 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
```
The maximum amount of data in bytes to read for automatic schema inference.
The maximum rows of data to read for automatic schema inference.
The number of columns in inserted MsgPack data. Used for automatic schema inference from data.
Match columns from table in MySQL dump and columns from ClickHouse table by names
Name of the table in MySQL dump from which to read data
Allow data types conversion in Native input format
Read data types in binary format instead of type names in Native input format
Enables or disables the initialization of [NULL](/reference/syntax#literals) fields with [default values](/reference/statements/create/table#default_values), if data type of these fields is not [nullable](/reference/data-types/nullable).
If column type is not nullable and this setting is disabled, then inserting `NULL` causes an exception. If column type is nullable, then `NULL` values are inserted as is, regardless of this setting.
This setting is applicable for most input formats.
For complex default expressions `input_format_defaults_for_omitted_fields` must be enabled too.
Possible values:
* 0 — Inserting `NULL` into a not nullable column causes an exception.
* 1 — `NULL` fields are initialized with default column values.
Allow missing columns while reading ORC input formats
Ignore case when matching ORC columns with CH columns.
Treat ORC dictionary encoded columns as LowCardinality columns while reading ORC files.
When reading ORC files, skip whole stripes or row groups based on the WHERE/PREWHERE expressions, min/max statistics or bloom filter in the ORC metadata.
The time zone name for ORC row reader, the default ORC row reader's time zone is GMT.
Batch size when reading ORC stripes.
Skip columns with unsupported types while schema inference for format ORC
Use a faster ORC decoder implementation.
Enables or disables order-preserving parallel parsing of data formats. Supported only for [TabSeparated (TSV)](/reference/formats/TabSeparated/TabSeparated), [TSKV](/reference/formats/TabSeparated/TSKV), [CSV](/reference/formats/CSV/CSV) and [JSONEachRow](/reference/formats/JSON/JSONEachRow) formats.
Possible values:
* 1 — Enabled.
* 0 — Disabled.
Use geo column parser to convert Array(UInt8) into Point/Linestring/Polygon/MultiLineString/MultiPolygon types
Allow missing columns while reading Parquet input formats
When reading Parquet files, skip whole row groups based on the WHERE expressions and bloom filter in the Parquet metadata.
Ignore case when matching Parquet columns with CH columns.
When reading Parquet files, parse JSON columns as ClickHouse JSON Column.
Enable row group prefetching during parquet parsing. Currently, only single-threaded parsing can prefetch.
When reading Parquet files, skip whole row groups based on the WHERE/PREWHERE expressions and min/max statistics in the Parquet metadata.
Min bytes required for local read (file) to do seek, instead of read with ignore in Parquet input format
Determines the data type used by schema inference for Parquet timestamps with isAdjustedToUTC=false. If true: DateTime64(..., 'UTC'), if false: DateTime64(...). Neither behavior is fully correct as ClickHouse doesn't have a data type for local wall-clock time. Counterintuitively, 'true' is probably the less incorrect option, because formatting the 'UTC' timestamp as String will produce representation of the correct local time.
Max block size for parquet reader.
Approximate memory limit for Parquet reader v3. Limits how many row groups or columns can be read in parallel. When reading multiple files in one query, the limit is on total memory usage across those files.
Schedule prefetches more aggressively if memory usage is below than threshold. Potentially useful e.g. if there are many small bloom filters to read over network.
input\_format\_parquet\_page\_filter\_push\_down
Skip pages using min/max values from column index.
Average block bytes output by parquet reader
Avoid reordering rows when reading from Parquet files. Not recommended as row ordering is generally not guaranteed, and other parts of query pipeline may break it. Use `ORDER BY _row_number` instead.
Skip columns with unsupported types while schema inference for format Parquet
Minor tweak to how pages are read from parquet file when no page filtering is used.
Verify page checksums when reading parquet files.
Enable Google wrappers for regular non-nested columns, e.g. google.protobuf.StringValue 'str' for String column 'str'. For Nullable columns empty wrappers are recognized as defaults, and missing as nulls
Indicate which field of protobuf oneof was found by means of setting enum value in a special colum
Skip fields with unsupported types while schema inference for format Protobuf
Path of the file used to record errors while reading text formats (CSV, TSV).
Enables or disables skipping insertion of extra data.
When writing data, ClickHouse throws an exception if input data contain columns that do not exist in the target table. If skipping is enabled, ClickHouse does not insert extra data and does not throw an exception.
Supported formats:
* [JSONEachRow](/reference/formats/JSON/JSONEachRow) (and other JSON formats)
* [BSONEachRow](/reference/formats/BSONEachRow) (and other JSON formats)
* [TSKV](/reference/formats/TabSeparated/TSKV)
* All formats with suffixes WithNames/WithNamesAndTypes
* [MySQLDump](/reference/formats/MySQLDump)
* [Native](/reference/formats/Native)
Possible values:
* 0 — Disabled.
* 1 — Enabled.
If enabled, ClickHouse will try to infer type `Date` from string fields in schema inference for text formats. If all fields from a column in input data were successfully parsed as dates, the result type will be `Date`, if at least one field was not parsed as date, the result type will be `String`.
Enabled by default.
If enabled, ClickHouse will try to infer type `DateTime64` from string fields in schema inference for text formats. If all fields from a column in input data were successfully parsed as datetimes, the result type will be `DateTime64`, if at least one field was not parsed as datetime, the result type will be `String`.
Enabled by default.
When input\_format\_try\_infer\_datetimes is enabled, infer only DateTime64 but not DateTime types
Try to infer floats in exponential notation while schema inference in text formats (except JSON, where exponent numbers are always inferred)
If enabled, ClickHouse will try to infer integers instead of floats in schema inference for text formats. If all numbers in the column from input data are integers, the result type will be `Int64`, if at least one number is float, the result type will be `Float64`.
Enabled by default.
If enabled, ClickHouse will try to infer type [`Variant`](/reference/data-types/variant) in schema inference for text formats when there is more than one possible type for column/array elements.
Possible values:
* 0 — Disabled.
* 1 — Enabled.
Ignore extra columns in TSV input (if file has more columns than expected) and treat missing fields in TSV input as default values
If it is set true, file function will read TSV format with \r\n instead of \n.
Automatically detect header with names and types in TSV format
Treat empty fields in TSV input as default values.
Treat inserted enum values in TSV formats as enum indices.
Skip specified number of lines at the beginning of data in TSV format
Skip trailing empty lines in TSV format
Use some tweaks and heuristics to infer schema in TSV format
For Values format: when parsing and interpreting expressions using template, check actual type of literal to avoid possible overflow and precision issues.
For Values format: if the field could not be parsed by streaming parser, run SQL parser, deduce template of the SQL expression, try to parse all rows using template and then interpret expression for all rows.
For Values format: if the field could not be parsed by streaming parser, run SQL parser and try to interpret it as SQL expression.
Enables or disables checking the column order when inserting data.
To improve insert performance, we recommend disabling this check if you are sure that the column order of the input data is the same as in the target table.
Supported formats:
* [CSVWithNames](/reference/formats/CSV/CSVWithNames)
* [CSVWithNamesAndTypes](/reference/formats/CSV/CSVWithNamesAndTypes)
* [TabSeparatedWithNames](/reference/formats/TabSeparated/TabSeparatedWithNames)
* [TabSeparatedWithNamesAndTypes](/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes)
* [JSONCompactEachRowWithNames](/reference/formats/JSON/JSONCompactEachRowWithNames)
* [JSONCompactEachRowWithNamesAndTypes](/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes)
* [JSONCompactStringsEachRowWithNames](/reference/formats/JSON/JSONCompactStringsEachRowWithNames)
* [JSONCompactStringsEachRowWithNamesAndTypes](/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes)
* [RowBinaryWithNames](/reference/formats/RowBinary/RowBinaryWithNames)
* [RowBinaryWithNamesAndTypes](/reference/formats/RowBinary/RowBinaryWithNamesAndTypes)
* [CustomSeparatedWithNames](/reference/formats/CustomSeparated/CustomSeparatedWithNames)
* [CustomSeparatedWithNamesAndTypes](/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes)
Possible values:
* 0 — Disabled.
* 1 — Enabled.
Controls whether format parser should check if data types from the input data match data types from the target table.
Supported formats:
* [CSVWithNamesAndTypes](/reference/formats/CSV/CSVWithNamesAndTypes)
* [TabSeparatedWithNamesAndTypes](/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes)
* [JSONCompactEachRowWithNamesAndTypes](/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes)
* [JSONCompactStringsEachRowWithNamesAndTypes](/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes)
* [RowBinaryWithNamesAndTypes](/reference/formats/RowBinary/RowBinaryWithNamesAndTypes)
* [CustomSeparatedWithNamesAndTypes](/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes)
Possible values:
* 0 — Disabled.
* 1 — Enabled.
insert\_distributed\_one\_random\_shard
Enables or disables random shard insertion into a [Distributed](/reference/engines/table-engines/special/distributed) table when there is no distributed key.
By default, when inserting data into a `Distributed` table with more than one shard, the ClickHouse server will reject any insertion request if there is no distributed key. When `insert_distributed_one_random_shard = 1`, insertions are allowed and data is forwarded randomly among all shards.
Possible values:
* 0 — Insertion is rejected if there are multiple shards and no distributed key is given.
* 1 — Insertion is done randomly among all available shards when no distributed key is given.
Allows choosing different output formats of the text representation of interval types.
Possible values:
* `kusto` - KQL-style output format.
ClickHouse outputs intervals in [KQL format](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings#the-constant-c-format-specifier). For example, `toIntervalDay(2)` would be formatted as `2.00:00:00`. Please note that for interval types of varying length (ie. `IntervalMonth` and `IntervalYear`) the average number of seconds per interval is taken into account.
* `numeric` - Numeric output format.
ClickHouse outputs intervals as their underlying numeric representation. For example, `toIntervalDay(2)` would be formatted as `2`.
See also:
* [Interval](/reference/data-types/special-data-types/interval)
into\_outfile\_create\_parent\_directories
Automatically create parent directories when using INTO OUTFILE if they do not already exists.
json\_type\_escape\_dots\_in\_keys
When enabled, dots in JSON keys will be escaped during parsing.
max\_dynamic\_subcolumns\_in\_json\_type\_parsing
The maximum number of dynamic subcolumns that can be created in every column during parsing of JSON column.
It allows to control the number of dynamic subcolumns during parsing regardless of dynamic parameters specified in the data type.
Compression method for Arrow output format. Supported codecs: lz4\_frame, zstd, none (uncompressed)
Write Date values as plain 16-bit numbers (read back as UInt16), instead of converting to a 32-bit Arrow DATE32 type (read back as Date32).
Use Arrow FIXED\_SIZE\_BINARY type instead of Binary for FixedString columns.
Enable output LowCardinality type as Dictionary Arrow type
Use Arrow String type instead of Binary for String columns
Output types having no conversion as raw binary data. If false - such types would raise UNKNOWN\_TYPE exception.
Always use 64 bit integers for dictionary indexes in Arrow format
Use signed integers for dictionary indexes in Arrow format
Compression codec used for output. Possible values: 'null', 'deflate', 'snappy', 'zstd'.
For AvroConfluent output format: the subject name under which the schema is registered in the Confluent Schema Registry. Required when writing AvroConfluent output.
Max rows in a file (if permitted by storage)
For Avro format: regexp of String columns to select as AVRO string.
Sync interval in bytes.
Write data types in binary format instead of type names in RowBinaryWithNamesAndTypes output format
Write values of [JSON](/reference/data-types/newjson) data type as JSON [String](/reference/data-types/string) values in RowBinary output format.
Use BSON String type instead of Binary for String columns.
Default compression level if query output is compressed. The setting is applied when `SELECT` query has `INTO OUTFILE` or when writing to table functions `file`, `url`, `hdfs`, `s3`, or `azureBlobStorage`.
Possible values: from `1` to `22`
Can be used when the output compression method is `zstd`. If greater than `0`, this setting explicitly sets compression window size (power of `2`) and enables a long-range mode for zstd compression. This can help to achieve a better compression ratio.
Possible values: non-negative numbers. Note that if the value is too small or too big, `zstdlib` will throw an exception. Typical values are from `20` (window size = `1MB`) to `30` (window size = `1GB`).
If it is set true, end of line in CSV format will be \r\n instead of \n.
If it set to true, then Tuples in CSV format are serialized as separate columns (that is, their nesting in the tuple is lost)
Output trailing zeros when printing Decimal values. E.g. 1.230000 instead of 1.23.
Disabled by default.
Enables the ability to output all rows as a JSON array in the [JSONEachRow](/reference/formats/JSON/JSONEachRow) format.
Possible values:
* 1 — ClickHouse outputs all rows as an array, each row in the `JSONEachRow` format.
* 0 — ClickHouse outputs each row separately in the `JSONEachRow` format.
**Example of a query with the enabled setting**
Query:
```sql theme={null}
SET output_format_json_array_of_rows = 1;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
```
Result:
```text theme={null}
[
{"number":"0"},
{"number":"1"},
{"number":"2"}
]
```
**Example of a query with the disabled setting**
Query:
```sql theme={null}
SET output_format_json_array_of_rows = 0;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
```
Result:
```text theme={null}
{"number":"0"}
{"number":"1"}
{"number":"2"}
```
Controls escaping forward slashes for string outputs in JSON output format. This is intended for compatibility with JavaScript. Don't confuse with backslashes that are always escaped.
Enabled by default.
Serialize maps columns as JSON arrays of tuples.
Disabled by default.
Serialize named tuple columns as JSON objects.
Enabled by default.
This setting determines how nested structures such as Tuples, Maps, and Arrays are displayed within the `data` array when using the JSON output format.
For example, instead of output:
```json theme={null}
"data":
[
{
"tuple": {"a":1,"b":2,"c":3},
"array": [1,2,3],
"map": {"a":1,"b":2,"c":3}
}
],
```
The output will be formatted as:
```json theme={null}
"data":
[
{
"tuple": {
"a": 1,
"b": 2,
"c": 3
},
"array": [
1,
2,
3
],
"map": {
"a": 1,
"b": 2,
"c": 3
}
}
],
```
Enabled by default.
Controls quoting of 64-bit [floats](/reference/data-types/float) when they are output in JSON\* formats.
Disabled by default.
Controls quoting of 64-bit or bigger [integers](/reference/data-types/int-uint) (like `UInt64` or `Int128`) when they are output in a [JSON](/reference/formats/JSON/JSON) format.
Such integers are enclosed in quotes by default. This behavior is compatible with most JavaScript implementations.
Possible values:
* 0 — Integers are output without quotes.
* 1 — Integers are enclosed in quotes.
Controls quoting of decimals in JSON output formats.
Disabled by default.
Enables `+nan`, `-nan`, `+inf`, `-inf` outputs in [JSON](/reference/formats/JSON/JSON) output format.
Possible values:
* 0 — Disabled.
* 1 — Enabled.
**Example**
Consider the following table `account_orders`:
```text theme={null}
┌─id─┬─name───┬─duration─┬─period─┬─area─┐
│ 1 │ Andrew │ 20 │ 0 │ 400 │
│ 2 │ John │ 40 │ 0 │ 0 │
│ 3 │ Bob │ 15 │ 0 │ -100 │
└────┴────────┴──────────┴────────┴──────┘
```
When `output_format_json_quote_denormals = 0`, the query returns `null` values in output:
```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
}
}
```
When `output_format_json_quote_denormals = 1`, the query returns:
```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
}
}
```
Skip key value pairs with null value when serialize named tuple columns as JSON objects. It is only valid when output\_format\_json\_named\_tuples\_as\_objects is true.
Controls validation of UTF-8 sequences in JSON output formats, doesn't impact formats JSON/JSONCompact/JSONColumnsWithMetadata, they always validate UTF-8.
Disabled by default.
When enabled, escape special characters in Markdown.
[Common Mark](https://spec.commonmark.org/0.30/#example-12) defines the following special characters that can be escaped by :
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Possible values:
* 0 — Disable.
* 1 — Enable.
The way how to output UUID in MsgPack format.
Write data types in binary format instead of type names in Native output format
Write data of [JSON](/reference/data-types/newjson) and [Dynamic](/reference/data-types/dynamic) columns in a flattened format (all types/paths as separate subcolumns).
Write data of [JSON](/reference/data-types/newjson) column as [String](/reference/data-types/string) column containing JSON strings instead of default native JSON serialization.
The size of the compression block in bytes for ORC output format.
Compression method for ORC output format. Supported codecs: lz4, snappy, zlib, zstd, none (uncompressed)
For a string column in ORC output format, if the number of distinct values is greater than this fraction of the total number of non-null rows, turn off dictionary encoding. Otherwise dictionary encoding is enabled
Target row index stride in ORC output format
Use ORC String type instead of Binary for String columns
The time zone name for ORC writer, the default ORC writer's time zone is GMT.
Enables or disables parallel formatting of data formats. Supported only for [TSV](/reference/formats/TabSeparated/TabSeparated), [TSKV](/reference/formats/TabSeparated/TSKV), [CSV](/reference/formats/CSV/CSV) and [JSONEachRow](/reference/formats/JSON/JSONEachRow) formats.
Possible values:
* 1 — Enabled.
* 0 — Disabled.
Check page size every this many rows. Consider decreasing if you have columns with average values size above a few KBs.
Approximate number of bits to use for each distinct value in parquet bloom filters. Estimated false positive rates:
* 6 bits - 10%
* 10.5 bits - 1%
* 16.9 bits - 0.1%
* 26.4 bits - 0.01%
* 41 bits - 0.001%
Where in the parquet file to place the bloom filters. Bloom filters will be written in groups of approximately this size. In particular:
* if 0, each row group's bloom filters are written immediately after the row group,
* if greater than the total size of all bloom filters, bloom filters for all row groups will be accumulated in memory, then written together near the end of the file,
* otherwise, bloom filters will be accumulated in memory and written out whenever their total size goes above this value.
Compression method for Parquet output format. Supported codecs: snappy, lz4, brotli, zstd, gzip, none (uncompressed)
output\_format\_parquet\_data\_page\_size
Target page size in bytes, before compression.
Write Date values as plain 16-bit numbers (read back as UInt16), instead of converting to a 32-bit parquet DATE type (read back as Date32).
Write DateTime values as raw unix timestamp (read back as UInt32), instead of converting to milliseconds (read back as DateTime64(3)).
Write enum using parquet physical type: BYTE\_ARRAY and logical type: ENUM
Use Parquet FIXED\_LEN\_BYTE\_ARRAY type instead of Binary for FixedString columns.
Allow to write information about geo columns in parquet metadata and encode columns in WKB format.
If dictionary size grows bigger than this many bytes, switch to encoding without dictionary. Set to 0 to disable dictionary encoding.
Do Parquet encoding in multiple threads.
Target row group size in rows.
Target row group size in bytes, before compression.
Use Parquet String type instead of Binary for String columns.
Write bloom filters in parquet files.
Put crc32 checksums in parquet page headers.
output\_format\_parquet\_write\_page\_index
Write column index and offset index (i.e. statistics about each data page, which may be used for filter pushdown on read) into parquet files.
Use ANSI escape sequences in Pretty formats. 0 - disabled, 1 - enabled, 'auto' - enabled if a terminal.
Display column names in the footer if there are many table rows.
Possible values:
* 0 — No column names are displayed in the footer.
* 1 — Column names are displayed in the footer if row count is greater than or equal to the threshold value set by [output\_format\_pretty\_display\_footer\_column\_names\_min\_rows](#output_format_pretty_display_footer_column_names_min_rows) (50 by default).
**Example**
Query:
```sql theme={null}
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 1000);
```
Result:
```response theme={null}
┌─number─┬─toTypeName(number)─┐
1. │ 0 │ UInt64 │
2. │ 1 │ UInt64 │
3. │ 2 │ UInt64 │
...
999. │ 998 │ UInt64 │
1000. │ 999 │ UInt64 │
└─number─┴─toTypeName(number)─┘
```
Sets the minimum number of rows for which a footer with column names will be displayed if setting [output\_format\_pretty\_display\_footer\_column\_names](#output_format_pretty_display_footer_column_names) is enabled.
If enabled, and the table is wide but short, the Pretty format will output it as the Vertical format does.
See `output_format_pretty_fallback_to_vertical_max_rows_per_chunk` and `output_format_pretty_fallback_to_vertical_min_table_width` for detailed tuning of this behavior.
The fallback to Vertical format (see `output_format_pretty_fallback_to_vertical`) will be activated only if the number of records in a chunk is not more than the specified value.
The fallback to Vertical format (see `output_format_pretty_fallback_to_vertical`) will be activated only if the number of columns is greater than the specified value.
The fallback to Vertical format (see `output_format_pretty_fallback_to_vertical`) will be activated only if the sum of lengths of columns in a table is at least the specified value, or if at least one value contains a newline character.
If the data rendered in Pretty formats arrived in multiple chunks, even after a delay, but the next chunk has the same column widths as the previous, use ANSI escape sequences to move back to the previous line and overwrite the footer of the previous chunk to continue it with the data of the new chunk. This makes the result more visually pleasant.
0 - disabled, 1 - enabled, 'auto' - enabled if a terminal.
Charset for printing grid borders. Available charsets: ASCII, UTF-8 (default).
If enabled and if output is a terminal, highlight every digit corresponding to the number of thousands, millions, etc. with underline.
If enabled and if output is a terminal, highlight trailing spaces with a gray color and underline.
If the column name is too long, cut it to this length.
The column will be cut if it is longer than `output_format_pretty_max_column_name_width_cut_to` plus `output_format_pretty_max_column_name_width_min_chars_to_cut`.
Minimum characters to cut if the column name is too long.
The column will be cut if it is longer than `output_format_pretty_max_column_name_width_cut_to` plus `output_format_pretty_max_column_name_width_min_chars_to_cut`.
Maximum width to pad all values in a column in Pretty formats.
Rows limit for Pretty formats.
Maximum width of value to display in Pretty formats. If greater - it will be cut.
The value 0 means - never cut.
Only cut values (see the `output_format_pretty_max_value_width` setting) when it is not a single value in a block. Otherwise output it entirely, which is useful for the `SHOW CREATE TABLE` query.
If enabled, Pretty formats will render multi-line fields inside table cell, so the table's outline will be preserved.
If not, they will be rendered as is, potentially deforming the table (one upside of keeping it off is that copy-pasting multi-line values will be easier).
Controls whether named tuples in Pretty format are output as pretty-printed JSON objects.
Add row numbers before each row for pretty output format
Print a readable number tip on the right side of the table if the block consists of a single number which exceeds this value (except 0)
Wait for the next block for up to specified number of milliseconds and squash it to the previous before writing.
This avoids frequent output of too small blocks, but still allows to display data in a streaming fashion.
Output the pending block in pretty formats if more than the specified number of milliseconds has passed since the previous output.
When serializing Nullable columns with Google wrappers, serialize default values as empty wrappers. If turned off, default and null values are not serialized
The path to the file where the automatically generated schema will be saved in [Cap'n Proto](/reference/formats/CapnProto) or [Protobuf](/reference/formats/Protobuf/Protobuf) formats.
Include column names in INSERT query
The maximum number of rows in one INSERT statement.
Quote column names with '\`' characters
The name of table in the output INSERT query
Use REPLACE statement instead of INSERT
Trim trailing null bytes from FixedString values in text output formats. E.g. `toFixedString('John', 8)` is printed as `John` instead of `John\0\0\0\0`.
If it is set true, end of line in TSV format will be \r\n instead of \n.
If true escape ' with '', otherwise quoted with \\'
Write statistics about read rows, bytes, time elapsed in suitable output formats.
Enabled by default
precise\_float\_parsing
Prefer more precise (but slower) float parsing algorithm
schema\_inference\_hints
The list of column names and types to use as hints in schema inference for formats without schema.
Example:
Query:
```sql theme={null}
desc format(JSONEachRow, '{"x" : 1, "y" : "String", "z" : "0.0.0.0" }') settings schema_inference_hints='x UInt8, z IPv4';
```
Result:
```sql theme={null}
x UInt8
y Nullable(String)
z IPv4
```
If the `schema_inference_hints` is not formatted properly, or if there is a typo or a wrong datatype, etc... the whole schema\_inference\_hints will be ignored.
schema\_inference\_make\_columns\_nullable
Controls making inferred types `Nullable` in schema inference.
Possible values:
* 0 - the inferred type will never be `Nullable` (use input\_format\_null\_as\_default to control what do do with null values in this case),
* 1 - all inferred types will be `Nullable`,
* 2 or `auto` - the inferred type will be `Nullable` only if the column contains `NULL` in a sample that is parsed during schema inference or file metadata contains information about column nullability,
* 3 - the inferred type nullability will match file metadata if the format has it (e.g. Parquet), always Nullable otherwise (e.g. CSV).
schema\_inference\_make\_json\_columns\_nullable
Controls making inferred JSON types `Nullable` in schema inference.
If this setting is enabled together with schema\_inference\_make\_columns\_nullable, inferred JSON type will be `Nullable`.
schema\_inference\_mode
Mode of schema inference. 'default' - assume that all files have the same schema and schema can be inferred from any file, 'union' - files can have different schemas and the resulting schema should be the a union of schemas of all files
show\_create\_query\_identifier\_quoting\_rule
Set the quoting rule for identifiers in SHOW CREATE query
show\_create\_query\_identifier\_quoting\_style
Set the quoting style for identifiers in SHOW CREATE query
type\_json\_allow\_duplicated\_key\_with\_literal\_and\_nested\_object
When enabled, JSONs like `{"a" : 42, "a" : {"b" : 42}}` where some key is duplicated but one of them is a nested object are allowed to be parsed.
type\_json\_skip\_duplicated\_paths
When enabled, during parsing JSON object into JSON type duplicated paths will be ignored and only the first one will be inserted instead of an exceptio
type\_json\_skip\_invalid\_typed\_paths
When enabled, fields with values that cannot be coerced to their declared type in JSON type columns with typed paths are skipped instead of throwing an error. Skipped fields are treated as missing and will use default/null values based on the typed path definition.
This setting only applies to JSON type columns (e.g., JSON(a Int64, b String)) where specific paths have declared types. It does not apply to regular JSON input formats like JSONEachRow when inserting into regular typed columns.
Possible values:
* 0 — Disable (throw error on type mismatch).
* 1 — Enable (skip field on type mismatch).
type\_json\_use\_partial\_match\_to\_skip\_paths\_by\_regexp
When enabled, during parsing JSON object into JSON type regular expressions specified using SKIP REGEXP will require partial match to skip a path. When disabled, full match will be required.
validate\_experimental\_and\_suspicious\_types\_inside\_nested\_types
Validate usage of experimental and suspicious types inside nested types like Array/Map/Tuple