Estos ajustes se generan automáticamente a partir del código fuente.
allow_special_bool_values_inside_variant
bool_false_representation
check_conversion_from_numbers_to_enum
- 0 — Deshabilitado.
- 1 — Habilitado.
Ejemplo
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); -- devuelve un error
column_names_for_schema_inference
-
'best_effort' — Habilita el análisis extendido.
ClickHouse puede analizar el formato básico YYYY-MM-DD HH:MM:SS y todos los formatos de fecha y hora ISO 8601. Por ejemplo, '2018-06-08T01:02:03.000Z'.
-
'best_effort_us' — Similar a best_effort (consulte la diferencia en parseDateTimeBestEffortUS
-
'basic' — Usa el analizador básico.
ClickHouse puede analizar solo el formato básico YYYY-MM-DD HH:MM:SS o YYYY-MM-DD. Por ejemplo, 2019-08-20 10:18:56 o 2019-08-20.
Véase también:
Permite elegir distintos formatos de salida para la representación textual de la fecha y la hora.
Valores posibles:
-
simple - Formato de salida simple.
ClickHouse muestra la fecha y la hora en formato YYYY-MM-DD hh:mm:ss. Por ejemplo, 2019-08-20 10:18:56. El cálculo se realiza según la zona horaria del tipo de dato (si está presente) o la zona horaria del servidor.
-
iso - Formato de salida ISO.
ClickHouse muestra la fecha y la hora en formato ISO 8601 YYYY-MM-DDThh:mm:ssZ. Por ejemplo, 2019-08-20T10:18:56Z. Tenga en cuenta que la salida se muestra en UTC (Z significa UTC).
-
unix_timestamp - Formato de salida como Unix timestamp.
ClickHouse muestra la fecha y la hora en formato Unix timestamp. Por ejemplo, 1566285536.
Véase también:
date_time_overflow_behavior
ignore — Ignora silenciosamente los desbordamientos. El resultado es indefinido.throw — Lanza una excepción en caso de desbordamiento.saturate — Satura el resultado. Si el valor es menor que el valor mínimo que puede representar el tipo de destino, el resultado será el valor representable más pequeño. Si el valor es mayor que el valor máximo que puede representar el tipo de destino, el resultado será el valor representable más grande.
Valor predeterminado: ignore.
Método para escribir errores en la salida de texto.
Para el formato AvroConfluent: tiempo de espera de conexión en segundos del cliente HTTP de Confluent Schema Registry. Se usa tanto para la obtención como para el registro de esquemas. Debe ser mayor que 0 y menor que 600 (10 minutos).
Para el formato AvroConfluent: tiempo de espera de recepción en segundos del cliente HTTP de Confluent Schema Registry. Se utiliza tanto para la obtención de esquemas como para el registro de esquemas. Debe ser mayor que 0 y menor que 600 (10 minutos).
Para el formato AvroConfluent: tiempo de espera de envío, en segundos, para el cliente HTTP de Confluent Schema Registry. Se utiliza tanto para la obtención del esquema como para el registro del esquema. Debe ser mayor que 0 y menor que 600 (10 minutos).
Para el formato AvroConfluent: URL del Confluent Schema Registry.
El tamaño máximo permitido para Array en el formato RowBinary. Evita asignar una gran cantidad de memoria en caso de que los datos estén dañados. 0 significa que no hay límite
El número máximo permitido de rutas en un solo objeto para el formato RowBinary del tipo JSON. Esto evita asignar una gran cantidad de memoria en caso de datos corruptos. 0 significa que no hay límite
El tamaño máximo permitido de String en el formato RowBinary. Evita asignar grandes cantidades de memoria en caso de datos corruptos. 0 significa que no hay límite
Cómo asignar correspondencias entre Enum de ClickHouse y Enum de CapnProto
Tamaño máximo de un solo mensaje CapnProto, en bytes. Esto protege frente a datos malformados o corruptos que puedan provocar una asignación excesiva de memoria. El valor predeterminado es 1 GiB.
Usa el esquema de CapnProto autogenerado cuando no se haya establecido format_schema
Si se establece en true, permite cadenas entre comillas dobles.
Si se establece en true, permite cadenas entre comillas simples.
El carácter que se considera delimitador en los datos CSV. Si se configura como una cadena, esta debe tener una longitud de 1.
Representación personalizada de NULL en formato CSV
Regla de escape para campos (para el formato CustomSeparated)
Delimitador entre campos (para el formato CustomSeparated)
Sufijo tras el conjunto de resultados (para el formato CustomSeparated)
Prefijo antes del conjunto de resultados (para el formato CustomSeparated)
Delimitador después del campo de la última columna (para el formato CustomSeparated)
Delimitador antes del campo de la primera columna (en el formato CustomSeparated)
Delimitador entre filas (para el formato CustomSeparated)
Habilita o deshabilita la visualización de secretos en las consultas SHOW y SELECT de tablas, bases de datos,
funciones de tabla y diccionarios.
El usuario que desee ver secretos también debe tener
la configuración del servidor display_secrets_in_show_and_select
activada y el privilegio
displaySecretsInShowAndSelect.
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
El nombre de la columna que se utilizará para almacenar o escribir nombres de objetos en el formato JSONObjectEachRow.
El tipo de la columna debe ser String. Si el valor está vacío, se usarán los nombres predeterminados row_{i} como nombres de objeto.
Usa Protobuf autogenerado cuando no se configure format_schema
Expresión regular (para el formato Regexp)
Regla de escape de campo (para formato Regexp)
Omite las líneas que no coincidan con la expresión regular (para el formato Regexp)
Este parámetro resulta útil cuando se usan formatos que requieren una definición de esquema, como Cap’n Proto o Protobuf. El valor depende del formato.
Define el nombre del mensaje requerido en el esquema definido en format_schema.
Para mantener la compatibilidad con el formato heredado de format_schema (file_name:message_name):
- Si no se especifica
format_schema_message_name, el nombre del mensaje se deduce de la parte message_name del valor heredado de format_schema.
- Si se especifica
format_schema_message_name mientras se usa el formato heredado, se producirá un error.
Define el origen de format_schema.
Valores posibles:
- ‘file’ (por defecto):
format_schema es el nombre de un archivo de esquema ubicado en el directorio format_schemas.
- ‘string’:
format_schema es el contenido literal del esquema.
- ‘query’:
format_schema es una consulta para obtener el esquema.
Cuando format_schema_source se establece en ‘query’, se aplican las siguientes condiciones:
- La consulta debe devolver exactamente un valor: una sola fila con una sola columna de tipo cadena.
- El resultado de la consulta se trata como el contenido del esquema.
- Este resultado se almacena en caché localmente en el directorio
format_schemas.
- Puede borrar la caché local con el comando:
SYSTEM DROP FORMAT SCHEMA CACHE FOR Files.
- Una vez almacenadas en caché, las consultas idénticas no se vuelven a ejecutar para obtener el esquema hasta que la caché se borre explícitamente.
- Además de los archivos de caché locales, los mensajes de Protobuf también se almacenan en caché en memoria. Incluso después de borrar los archivos de caché locales, la caché en memoria debe borrarse con
SYSTEM DROP FORMAT SCHEMA CACHE [FOR Protobuf] para actualizar completamente el esquema.
- Ejecute la consulta
SYSTEM DROP FORMAT SCHEMA CACHE para borrar de una sola vez la caché tanto de los archivos de caché como de los esquemas de mensajes Protobuf.
Ruta del archivo que contiene la cadena de formato del conjunto de resultados (para el formato Template)
Cadena de formato para el conjunto de resultados (para el formato Template)
Ruta del archivo que contiene la cadena de formato para las filas (para el formato Template)
Cadena de formato para filas (para el formato Template)
Delimitador entre filas (para el formato Template)
Representación personalizada de NULL en formato TSV
Establece el número máximo de errores aceptables al leer formatos de texto (CSV, TSV, etc.).
El valor predeterminado es 0.
Utilícelo siempre junto con input_format_allow_errors_ratio.
Si se produce un error al leer filas, pero el contador de errores sigue siendo menor que input_format_allow_errors_num, ClickHouse ignora la fila y pasa a la siguiente.
Si se superan tanto input_format_allow_errors_num como input_format_allow_errors_ratio, ClickHouse lanza una excepción.
Establece el porcentaje máximo de errores permitido al leer formatos de texto (CSV, TSV, etc.).
El porcentaje de errores se define como un número de coma flotante entre 0 y 1.
El valor predeterminado es 0.
Úselo siempre junto con input_format_allow_errors_num.
Si se produce un error al leer filas, pero el contador de errores sigue siendo inferior a input_format_allow_errors_ratio, ClickHouse ignora la fila y pasa a la siguiente.
Si se superan tanto input_format_allow_errors_num como input_format_allow_errors_ratio, ClickHouse lanza una excepción.
Permite realizar reposicionamientos (o lecturas por rango) al leer los formatos de entrada ORC, Parquet y Arrow.
Cuando está habilitado y el origen lo admite (por ejemplo, un archivo local, S3 o HTTP con compatibilidad con rangos y tamaño conocido),
ClickHouse puede leer solo los rangos de bytes necesarios y usar menos memoria.
Cuando está deshabilitado, o cuando el origen no admite reposicionamientos (por ejemplo, si no se conoce el tamaño del archivo o el flujo no permite reposicionarse),
algunos lectores pueden optar por cargar el archivo completo en memoria.
Habilitado de forma predeterminada.
Permite columnas ausentes al leer formatos de entrada Arrow
No distingue entre mayúsculas y minúsculas al hacer coincidir las columnas de Arrow con las columnas de CH.
Omitir las columnas con tipos no admitidos durante la inferencia del esquema para el formato Arrow
Para el formato Avro/AvroConfluent: cuando no se encuentra un campo en el esquema, se utiliza el valor predeterminado en lugar de generar un error
Para el formato Avro/AvroConfluent: inserta el valor predeterminado en caso de NULL y de columna no Nullable
Leer tipos de datos en formato binario en lugar de nombres de tipos en el formato de entrada RowBinaryWithNamesAndTypes
Número máximo de nodos de tipo al decodificar tipos binarios (no la profundidad, sino el número total). Map(String, UInt32) = 3 nodos. Protege contra entradas maliciosas. 0 = ilimitado.
Lee valores del tipo de dato JSON como valores String JSON en el formato de entrada RowBinary.
Omite los campos con tipos no compatibles durante la inferencia del esquema del formato BSON.
Omitir las columnas con tipos no compatibles durante la inferencia del esquema para el formato CapnProto
Define el modo de coincidencia de los nombres de columna al ingestar datos a través de varios formatos (incluidos, entre otros, JSONEachRow, CSVWithNames, JSONColumns, BSONEachRow, RowBinaryWithNames).
Modos compatibles:
- match_case: distingue mayúsculas y minúsculas
- ignore_case: no distingue mayúsculas y minúsculas
- auto: primero intenta hacer la coincidencia distinguiendo mayúsculas y minúsculas; si falla, la intenta sin distinguir mayúsculas y minúsculas.
Cuando esta opción está activada, si la conexión se cierra inesperadamente, los datos que queden en el búfer se analizarán y procesarán en lugar de tratarse como un error
Activar esta opción desactiva el análisis en paralelo e impide la deduplicación
enum insertados en formatos CSV como índices de enum
Omite el número especificado de líneas al inicio de los datos en formato CSV
Omite las líneas vacías al final en formato CSV
Elimina los espacios y tabulaciones (\t) al principio y al final de las cadenas CSV
Si está habilitada, durante la inferencia del esquema, ClickHouse intentará inferir números a partir de campos de cadena.
Puede ser útil si los datos CSV contienen números UInt64 entre comillas.
Deshabilitada de forma predeterminada.
Interpreta las Tuples entrecomilladas en los datos de entrada como un valor de tipo String.
Utiliza algunos ajustes y heurísticas para inferir el esquema en formato CSV
Permite establecer el valor predeterminado de la columna cuando falla la deserialización de un campo CSV debido a un valor no válido
Ignora las columnas adicionales en la entrada CustomSeparated (si el archivo tiene más columnas de las esperadas) y trata los campos que faltan en la entrada CustomSeparated como valores predeterminados.
Detecta automáticamente el encabezado con nombres y tipos en el formato CustomSeparated
Omitir las líneas vacías finales del formato CustomSeparated
Al realizar consultas INSERT, sustituye los valores omitidos de las columnas de entrada por los valores predeterminados de las columnas correspondientes. Esta opción se aplica a JSONEachRow (y otros formatos JSON), CSV, TabSeparated, TSKV, Parquet, Arrow, Avro, ORC, Native y a los formatos con los sufijos WithNames/WithNamesAndTypes.
Cuando esta opción está habilitada, se envían metadatos ampliados de la tabla desde el servidor al cliente. Esto consume recursos de procesamiento adicionales en el servidor y puede reducir el rendimiento.
- 0 — Deshabilitado.
- 1 — Habilitado.
Forzar la inicialización de los campos omitidos con valores NULL
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 — Deshabilitado.
- 1 — Habilitado.
Véase también:
La deserialización de IPv4 usará valores predeterminados en lugar de generar una excepción si se produce un error de conversión.
Desactivado de forma predeterminada.
La deserialización de IPv6 usará valores predeterminados en lugar de lanzar una excepción si se produce un error de conversión.
Deshabilitado de forma predeterminada.
Permite un número variable de columnas en las filas de los formatos de entrada JSONCompact/JSONCompactEachRow.
Ignora las columnas adicionales en las filas con más columnas de las previstas y considera las columnas que faltan como valores predeterminados.
Deshabilitado de forma predeterminada.
Inserta valores predeterminados para los elementos que faltan en el objeto JSON al analizar una tupla con nombre.
Esta configuración solo funciona cuando la opción input_format_json_named_tuples_as_objects está habilitada.
Está habilitada de forma predeterminada.
Cuando está habilitada, sustituye los campos vacíos de la entrada JSON por valores predeterminados. Para expresiones de valor predeterminado complejas, también debe estar habilitado input_format_defaults_for_omitted_fields.
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
Ignora las claves desconocidas en objetos JSON para las tuplas con nombre.
Habilitado de forma predeterminada.
Ignora los campos innecesarios y no los analiza. Al activarlo, puede que no se lancen excepciones en cadenas JSON con formato no válido o con campos duplicados
Si está habilitado, durante la inferencia del esquema, ClickHouse utilizará el tipo Array(Dynamic) para arrays JSON con valores de distintos tipos de datos.
Ejemplo:
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/{}/[] en la muestra de datos durante la inferencia del esquema.
En formatos JSON, cualquier valor puede leerse como String, y es posible evitar errores como Cannot determine type for column 'column_name' by first 25000 rows of data, most likely this column contains only Nulls or empty Arrays/Maps durante la inferencia del esquema
usando el tipo String para claves con tipos desconocidos.
Ejemplo:
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))) │ │ │ │ │ │
└──────┴────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────┴────────────────────┴─────────┴──────────────────┴────────────────┘
Esta opción solo funciona si input_format_connection_handling está habilitado. Establecer un valor también desactiva el análisis en paralelo y hace imposible la deduplicación.
Para inserts de streaming, también se deben establecer min_insert_block_size_rows=0 y min_insert_block_size_bytes=0. De lo contrario, los bloques analizados pueden seguir acumulándose en memoria durante la etapa de squashing de bloques hasta que se alcancen esos umbrales, lo que impide que los inserts se realicen a tiempo.
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 provoca una excepción. Si el tipo de columna es Nullable, los valores NULL se insertan tal cual, independientemente de esta configuración.
Esta configuración se aplica a la mayoría de los formatos de entrada.
Para expresiones predeterminadas complejas, input_format_defaults_for_omitted_fields también debe estar habilitada.
Valores posibles:
- 0 — Insertar
NULL en una columna no Nullable provoca una excepción.
- 1 — Los campos
NULL se inicializan con los valores predeterminados de la columna.
Permite columnas ausentes al leer formatos de entrada ORC
No distingue entre mayúsculas y minúsculas al hacer coincidir columnas ORC con columnas de CH.
Trata las columnas ORC codificadas con diccionario como columnas LowCardinality al leer archivos ORC.
Al leer archivos ORC, omita stripes enteros o grupos de filas completos en función de las expresiones WHERE/PREWHERE, las estadísticas mín./máx. o el bloom filter de los metadatos de ORC.
El nombre de la zona horaria del lector de filas ORC; la zona horaria predeterminada del lector de filas ORC es GMT.
Tamaño del lote al leer stripes de archivos ORC.
Omitir las columnas con tipos no compatibles durante la inferencia del esquema para el formato ORC
Usa una implementación más rápida del decodificador ORC.
Habilita o deshabilita el análisis paralelo de los formatos de datos conservando el orden. Solo es compatible con los formatos TabSeparated (TSV), TSKV, CSV y JSONEachRow.
Valores posibles:
- 1 — Habilitado.
- 0 — Deshabilitado.
Use el analizador de columnas Geo para convertir Array(UInt8) en tipos Point/Linestring/Polygon/MultiLineString/MultiPolygon
Permite columnas ausentes al leer formatos de entrada Parquet
Al leer archivos Parquet, omite grupos de filas enteros en función de las expresiones WHERE y del bloom filter de los metadatos de Parquet.
Ignora las mayúsculas y minúsculas al hacer coincidir columnas de Parquet con columnas de CH.
Al leer archivos Parquet, interpreta las columnas JSON como columnas JSON de ClickHouse.
Habilita la precarga de grupos de filas durante el análisis de Parquet. Actualmente, solo el análisis en un solo hilo puede realizar precarga.
Al leer archivos Parquet, omite grupos de filas enteros en función de las expresiones WHERE/PREWHERE y de las estadísticas mín./máx. de los metadatos de Parquet.
Bytes mínimos necesarios para que una lectura local (archivo) haga seek, en lugar de leer ignorando datos, en el formato de entrada Parquet
Determina el tipo de dato que usa la inferencia del esquema para las marcas de tiempo de Parquet con isAdjustedToUTC=false. Si es true: DateTime64(…, ‘UTC’); si es false: DateTime64(…). Ninguno de los dos comportamientos es totalmente correcto, ya que ClickHouse no tiene un tipo de dato para la hora local según el reloj. Aunque resulte contraintuitivo, ‘true’ probablemente sea la opción menos incorrecta, porque al formatear la marca de tiempo ‘UTC’ como String se obtiene una representación de la hora local correcta.
Tamaño máximo de bloque del lector de Parquet.
Límite de memoria aproximado para el lector de Parquet v3. Limita cuántos grupos de filas o columnas pueden leerse en paralelo. Al leer varios archivos en una sola consulta, el límite se aplica al uso total de memoria entre esos archivos.
Programa las prelecturas de forma más agresiva si el uso de memoria está por debajo del umbral. Puede resultar útil, por ejemplo, si hay muchos bloom filters pequeños que leer por la red.
input_format_parquet_page_filter_push_down
ORDER BY _row_number.
Omitir las columnas con tipos no compatibles durante la inferencia de esquema para el formato Parquet
Ajuste menor en la forma de leer las páginas del archivo Parquet cuando no se usa el filtrado de páginas.
Verifica las sumas de comprobación de las páginas al leer archivos Parquet.
Habilita los wrappers de Google para columnas normales no anidadas; por ejemplo, google.protobuf.StringValue ‘str’ para la columna String ‘str’. En las columnas Nullable, los wrappers vacíos se interpretan como valores predeterminados y la ausencia de wrappers como NULL
Indica qué campo de protobuf oneof se encontró mediante la asignación de un valor enum en una columna especial
Omite los campos con tipos no compatibles durante la inferencia de esquemas para el formato Protobuf
Ruta del archivo que se utiliza para registrar errores durante la lectura de formatos de texto (CSV, TSV).
Activa o desactiva la omisión de datos adicionales durante la inserción.
Al escribir datos, ClickHouse lanza una excepción si los datos de entrada contienen columnas que no existen en la tabla de destino. Si esta opción está habilitada, ClickHouse no inserta los datos adicionales y no lanza ninguna excepción.
Formatos compatibles:
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
Si está habilitado, ClickHouse intentará inferir el tipo Date a partir de campos de texto durante la inferencia de esquemas para formatos de texto. Si todos los campos de una columna de los datos de entrada se interpretan correctamente como fechas, el tipo resultante será Date; si al menos un campo no se interpreta como fecha, el tipo resultante será String.
Habilitado de forma predeterminada.
Si está habilitada, ClickHouse intentará inferir el tipo DateTime64 a partir de campos de tipo cadena durante la inferencia de esquema para formatos de texto. Si todos los campos de una columna de los datos de entrada se analizan correctamente como fechas y horas, el tipo resultante será DateTime64; si al menos un campo no se analiza como fecha y hora, el tipo resultante será String.
Habilitada de forma predeterminada.
Cuando input_format_try_infer_datetimes está habilitado, infiere solo DateTime64, pero no tipos DateTime
Intenta inferir números de coma flotante en notación exponencial durante la inferencia de esquema en formatos de texto (excepto JSON, donde los números con exponente siempre se infieren)
Si está habilitado, ClickHouse intentará inferir enteros en lugar de números de coma flotante durante la inferencia de esquema para formatos de texto. Si todos los números de la columna en los datos de entrada son enteros, el tipo resultante será Int64; si al menos uno de los números es de coma flotante, el tipo resultante será Float64.
Habilitado de forma predeterminada.
Si está habilitada, ClickHouse intentará inferir el tipo Variant en la inferencia de esquema para formatos de texto cuando haya más de un tipo posible para elementos de columna/array.
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
Ignora las columnas adicionales en la entrada TSV (si el archivo tiene más columnas de las esperadas) y considera los campos faltantes en la entrada TSV como valores predeterminados
Si se establece en true, la función file leerá el formato TSV usando \r\n en lugar de \n.
Detecta automáticamente el encabezado con nombres y tipos en formato TSV
Trata los campos vacíos de la entrada TSV como valores predeterminados.
Trata los valores de enum insertados en formatos TSV como índices de enum.
Omite la cantidad especificada de líneas al inicio de los datos en formato TSV
Omitir las líneas vacías al final en formato TSV
Usa algunos ajustes y heurísticas para inferir el esquema en formato TSV
Para el formato Values, al analizar e interpretar expresiones con Template, compruebe el tipo real del literal para evitar posibles problemas de desbordamiento y de precisión.
Para el formato Values: si el campo no pudo analizarse con el parser de streaming, se ejecuta el parser SQL, se deduce la plantilla de la expresión SQL, se intenta analizar todas las filas usando la plantilla y luego se interpreta la expresión para todas las filas.
Para el formato Values: si el campo no pudo analizarse con el parser de streaming, ejecute el parser SQL e intente interpretarlo como una expresión SQL.
Activa o desactiva la comprobación del orden de las columnas al insertar datos.
Para mejorar el rendimiento de la inserción, recomendamos desactivar esta comprobación si está seguro de que el orden de las columnas en los datos de entrada es el mismo que en la tabla de destino.
Formatos compatibles:
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
Controla si el analizador de formatos debe comprobar que los tipos de datos de los datos de entrada coincidan con los tipos de datos de la tabla de destino.
Formatos compatibles:
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
insert_distributed_one_random_shard
Distributed con más de un segmento, el servidor de ClickHouse rechazará cualquier solicitud de inserción si no se ha definido una clave de distribución. Cuando insert_distributed_one_random_shard = 1, se permiten las inserciones y los datos se reenvían aleatoriamente entre todos los segmentos.
Valores posibles:
- 0 — La inserción se rechaza si hay varios segmentos y no se proporciona una clave de distribución.
- 1 — La inserción se realiza aleatoriamente entre todos los segmentos disponibles cuando no se proporciona una clave de distribución.
Permite elegir distintos formatos de salida para la representación textual de los tipos interval.
Valores posibles:
-
kusto - formato de salida de estilo KQL.
ClickHouse genera los intervalos en formato KQL. Por ejemplo, toIntervalDay(2) se formatearía como 2.00:00:00. Tenga en cuenta que, para los tipos interval de longitud variable (es decir, IntervalMonth y IntervalYear), se considera el número promedio de segundos por intervalo.
-
numeric - formato de salida numérico.
ClickHouse genera los intervalos según su representación numérica subyacente. Por ejemplo, toIntervalDay(2) se formatearía como 2.
Véase también:
into_outfile_create_parent_directories
json_type_escape_dots_in_keys
max_dynamic_subcolumns_in_json_type_parsing
SELECT incluye INTO OUTFILE o al escribir en las funciones de tabla file, url, hdfs, s3 o azureBlobStorage.
Valores posibles: de 1 a 22
Se puede usar cuando el método de compresión de salida es zstd. Si es mayor que 0, esta configuración establece explícitamente el tamaño de la ventana de compresión (potencia de 2) y habilita un modo de largo alcance para la compresión zstd. Esto puede ayudar a lograr un mejor ratio de compresión.
Posibles valores: números no negativos. Tenga en cuenta que, si el valor es demasiado pequeño o demasiado grande, zstdlib lanzará una excepción. Los valores típicos van de 20 (tamaño de la ventana = 1MB) a 30 (tamaño de la ventana = 1GB).
Si se establece en true, el fin de línea en formato CSV será \r\n en lugar de \n.
Si se establece en true, las tuplas en formato CSV se serializan como columnas separadas (es decir, se pierde su anidamiento dentro de la tupla)
Muestra los ceros finales al imprimir valores Decimal. P. ej., 1.230000 en lugar de 1.23.
Desactivado de forma predeterminada.
Habilita la salida de todas las filas como un array JSON en el formato JSONEachRow.
Valores posibles:
- 1 — ClickHouse devuelve todas las filas como un array, con cada fila en el formato
JSONEachRow.
- 0 — ClickHouse devuelve cada fila por separado en el formato
JSONEachRow.
Ejemplo de una consulta con la configuración habilitada
Consulta:
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"}
data al usar el formato de salida JSON.
Por ejemplo, en lugar de esta salida:
"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 o Int128) se encierran entre comillas cuando se generan en formato JSON.
De forma predeterminada, estos enteros se encierran entre comillas. Este comportamiento es compatible con la mayoría de las implementaciones de JavaScript.
Valores posibles:
- 0 — Los enteros se generan sin comillas.
- 1 — Los enteros se encierran entre comillas.
Controla si los valores decimales se encierran entre comillas en los formatos de salida JSON.
Desactivado de forma predeterminada.
Permite la salida de +nan, -nan, +inf y -inf en el formato de salida JSON.
Valores posibles:
- 0 — Deshabilitado.
- 1 — Habilitado.
Ejemplo
Considere la siguiente tabla account_orders:
┌─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 consulta devuelve valores null en la salida:
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 consulta devuelve:
{
"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 — Desactivar.
- 1 — Activar.
Cómo se representa UUID en formato MsgPack.
Escribe tipos de datos en formato binario en lugar de nombres de tipos en el formato de salida Native
Escribe los datos de las columnas JSON y Dynamic en formato aplanado (todos los tipos y rutas como subcolumnas independientes).
Escribe los datos de la columna JSON como una columna String que contiene cadenas JSON, en lugar de usar la serialización JSON nativa predeterminada.
El tamaño, en bytes, del bloque de compresión para el formato de salida ORC.
Método de compresión para el formato de salida ORC. Códecs compatibles: lz4, snappy, zlib, zstd, none (sin comprimir)
Para una columna de tipo cadena en el formato de salida ORC, si el número de valores distintos es mayor que esta fracción del número total de filas no nulas, se desactiva la codificación por diccionario. En caso contrario, la codificación por diccionario se habilita
Paso objetivo del índice de filas en el formato de salida ORC
Usa el tipo String de ORC en lugar de Binary para las columnas String
El nombre de la zona horaria del escritor de ORC; la zona horaria predeterminada del escritor de ORC es GMT.
Habilita o deshabilita el formateo paralelo en los formatos de datos. Solo es compatible con los formatos TSV, TSKV, CSV y JSONEachRow.
Valores posibles:
- 1 — Habilitado.
- 0 — Deshabilitado.
Compruebe el tamaño de la página cada esta cantidad de filas. Considere reducirlo si tiene columnas con un tamaño promedio de los valores superior a unos pocos KB.
Número aproximado de bits que se deben usar para cada valor distinto en los filtros bloom de Parquet. Tasas estimadas de falsos positivos:
- 6 bits - 10%
- 10.5 bits - 1%
- 16.9 bits - 0.1%
- 26.4 bits - 0.01%
- 41 bits - 0.001%
Dónde colocar los filtros bloom en el archivo Parquet. Los filtros bloom se escribirán en grupos de aproximadamente este tamaño. En particular:
- si es 0, los filtros bloom de cada grupo de filas se escriben inmediatamente después del grupo de filas;
- si es mayor que el tamaño total de todos los filtros bloom, los filtros bloom de todos los grupos de filas se acumularán en memoria y después se escribirán juntos cerca del final del archivo;
- en caso contrario, los filtros bloom se acumularán en memoria y se escribirán cuando su tamaño total supere este valor.
Método de compresión para el formato de salida Parquet. Códecs compatibles: snappy, lz4, brotli, zstd, gzip, none (sin comprimir)
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 y output_format_pretty_fallback_to_vertical_min_table_width para ajustar en detalle este comportamiento.
La conmutación por error al formato Vertical (consulte output_format_pretty_fallback_to_vertical) se activará solo si el número de registros de un fragmento no supera el valor especificado.
El cambio al formato Vertical como alternativa (consulte output_format_pretty_fallback_to_vertical) se activará solo si el número de columnas es mayor que el valor especificado.
El cambio al formato Vertical (consulte output_format_pretty_fallback_to_vertical) solo se activará si la suma de las longitudes de las columnas de una tabla alcanza al menos el valor especificado o si al menos un valor contiene un salto de línea.
Si los datos mostrados en formatos Pretty llegan en varios fragmentos, incluso con retraso, pero el siguiente fragmento tiene los mismos anchos de columna que el anterior, use secuencias de escape ANSI para volver a la línea anterior y sobrescribir el pie del fragmento anterior, de modo que continúe con los datos del nuevo fragmento. Esto hace que el resultado sea visualmente más agradable.
0 - deshabilitado, 1 - habilitado, ‘auto’ - habilitado si es un terminal.
Juego de caracteres para imprimir los bordes de la cuadrícula. Juegos de caracteres disponibles: ASCII, UTF-8 (predeterminado).
Si está habilitado y la salida se muestra en un terminal, resalta con subrayado cada dígito correspondiente a los miles, millones, etc.
Si está habilitada y la salida es un terminal, resalta los espacios finales en gris y con subrayado.
Si el nombre de la columna es demasiado largo, se recortará a esta longitud.
La columna se recortará si supera output_format_pretty_max_column_name_width_cut_to más output_format_pretty_max_column_name_width_min_chars_to_cut.
Número mínimo de caracteres que se recortarán si el nombre de la columna es demasiado largo.
La columna se recortará si supera output_format_pretty_max_column_name_width_cut_to más output_format_pretty_max_column_name_width_min_chars_to_cut.
Ancho máximo de relleno para todos los valores de una columna en los formatos Pretty.
Límite de filas para los formatos Pretty.
Ancho máximo del valor que se mostrará en los formatos Pretty. Si se supera, se recortará.
El valor 0 significa que nunca se recorta.
Recorta los valores (consulta la configuración output_format_pretty_max_value_width) solo cuando no se trate de un valor individual en un bloque. En caso contrario, se muestra completo, lo que resulta útil para la consulta SHOW CREATE TABLE.
Si está habilitada, los formatos Pretty mostrarán los campos multilínea dentro de las celdas de la tabla, de modo que se conserven sus bordes.
Si no, se mostrarán tal cual, lo que puede deformar la tabla (una ventaja de dejar esta opción desactivada es que será más fácil copiar y pegar valores multilínea).
Controla si las tuplas con nombre en formato Pretty se muestran como objetos JSON con formato legible.
Agrega números de fila antes de cada fila en el formato de salida Pretty
Muestra un indicador numérico legible a la derecha de la tabla si el bloque consta de un único número que supera este valor (excepto 0)
Espera hasta el número especificado de milisegundos al siguiente bloque y lo combina con el anterior antes de escribirlo.
Esto evita la salida frecuente de bloques demasiado pequeños, pero aun así permite mostrar los datos de forma continua.
Emite el bloque pendiente en formatos Pretty si ha transcurrido más del número especificado de milisegundos desde la salida anterior.
Al serializar columnas Nullable con wrappers de Google, serializa los valores predeterminados como wrappers vacíos. Si se desactiva, los valores predeterminados y los valores NULL no se serializan
La ruta del archivo en el que se guardará el esquema generado automáticamente en los formatos Cap’n Proto o Protobuf.
Incluir los nombres de las columnas en la consulta INSERT
El número máximo de filas en una sola instrucción INSERT.
Poner entre comillas los nombres de las columnas con el carácter ’`‘
El nombre de la tabla en la consulta INSERT de salida
Usa la instrucción REPLACE en lugar de INSERT
Elimina los bytes nulos finales de los valores FixedString en los formatos de salida de texto. Por ejemplo, toFixedString('John', 8) se imprime como John en lugar de John\0\0\0\0.
Si se establece en verdadero, el final de línea en formato TSV será \r\n en lugar de \n.
Si es verdadero, se escapa ’ como ”, de lo contrario, se entrecomilla con '
Escribe estadísticas sobre las filas leídas, los bytes y el tiempo transcurrido en los formatos de salida adecuados.
Habilitado de forma predeterminada
Usar un algoritmo de análisis de números de coma flotante más preciso (pero más lento)
La lista de nombres de columnas y tipos que se utilizarán como sugerencias para la inferencia de esquemas en formatos sin esquema.
Ejemplo:
Consulta:
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 no tiene el formato adecuado, o si hay un error tipográfico, un tipo de dato incorrecto, etc., se ignorará por completo schema_inference_hints.
schema_inference_make_columns_nullable
Nullable durante la inferencia de esquema.
Valores posibles:
- 0 - el tipo inferido nunca será
Nullable (use input_format_null_as_default para controlar qué hacer con los valores nulos en este caso),
- 1 - todos los tipos inferidos serán
Nullable,
- 2 o
auto - el tipo inferido será Nullable solo si la columna contiene NULL en una muestra analizada durante la inferencia de esquema o si los metadatos del archivo contienen información sobre la nulabilidad de la columna,
- 3 - la nulabilidad del tipo inferido coincidirá con los metadatos del archivo si el formato la admite (por ejemplo, Parquet); en caso contrario, siempre será
Nullable (por ejemplo, CSV).
schema_inference_make_json_columns_nullable
Nullable durante la inferencia de esquemas.
Si esta configuración está habilitada junto con schema_inference_make_columns_nullable, el tipo JSON inferido será Nullable.
Modo de inferencia de esquemas. ‘default’: se asume que todos los archivos tienen el mismo esquema y que este puede inferirse a partir de cualquier archivo; ‘union’: los archivos pueden tener esquemas diferentes y el esquema resultante debe ser la unión de los esquemas de todos los archivos
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}}, en los que alguna clave está duplicada, pero una de ellas es un objeto anidado.
type_json_skip_duplicated_paths
type_json_skip_invalid_typed_paths
- 0 — Deshabilitar (generar un error si hay discrepancia de tipo).
- 1 — Habilitar (omitir el campo si hay discrepancia de tipo).
type_json_use_partial_match_to_skip_paths_by_regexp
validate_experimental_and_suspicious_types_inside_nested_types
