ajustes de formato input_format_*

Estos ajustes se generan automáticamente a partir del código fuente.

Establece el número máximo de errores aceptables al leer en formatos de texto (CSV, TSV, etc.).

El valor predeterminado es 0.

Úselo siempre junto con input_format_allow_errors_ratio.

Si se produce un error al leer filas, pero el contador de errores sigue siendo inferior a 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 permitidos 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 rangos) al leer 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 si el origen no admite reposicionamientos (por ejemplo, si no se conoce el tamaño del archivo o el flujo no permite reposicionamiento), algunos lectores pueden recurrir a 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 columnas con tipos no compatibles durante la inferencia de esquema para el formato Arrow

Para el formato Avro/AvroConfluent: cuando no se encuentra un campo en el esquema, use el valor predeterminado en lugar de generar un error

Para el formato Avro/AvroConfluent: insertar el valor predeterminado en caso de NULL y columna no Nullable

Leer los tipos de datos en formato binario en lugar de los nombres de tipo en el formato de entrada RowBinaryWithNamesAndTypes

Número máximo de nodos de tipo al decodificar tipos binarios (no la profundidad, sino la cantidad total). Map(String, UInt32) = 3 nodos. Protege frente a entradas maliciosas. 0 = ilimitado.

Lee los 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 de esquema para el formato BSON.

Omite las columnas con tipos no compatibles durante la inferencia de esquema para el formato CapnProto

Define el modo de coincidencia de nombres de columna al ingestar datos mediante varios formatos (incluidos, entre otros, JSONEachRow, CSVWithNames, JSONColumns, BSONEachRow y RowBinaryWithNames). Modos compatibles:

• match_case: coincidencia sensible a mayúsculas y minúsculas
  • ignore_case: coincidencia no sensible a mayúsculas y minúsculas
  • auto: primero intenta hacer coincidir de forma sensible a mayúsculas y minúsculas; si falla, intenta hacerlo de forma no sensible a mayúsculas y minúsculas.

Cuando esta opción está habilitada, si la conexión se cierra de forma inesperada, los datos que queden en el búfer se analizarán y procesarán en lugar de tratarse como un error

Si se establece como true, se permitirá \r al final de la línea sin que esté seguido de

Ignora las columnas adicionales en la entrada CSV (si el archivo tiene más columnas de las previstas) y trata los campos que faltan en la entrada CSV como valores predeterminados

Permite usar espacios y tabuladores (\t) como delimitador de campos en las cadenas CSV

Al leer Array desde CSV, se espera que sus elementos se hayan serializado como CSV anidado y luego se hayan colocado en una cadena. Ejemplo: "[""Hello"", ""world"", ""42"""" TV""]". Se pueden omitir los corchetes alrededor del array.

Si se establece en true, las columnas independientes escritas en formato CSV pueden deserializarse en una columna tupla.

Esto se aplica solo a Tuple simple. Un Nullable(Tuple) siempre se escribe como un único campo CSV (consulte output_format_csv_serialize_tuple_into_separate_columns) y, del mismo modo, se vuelve a leer desde un único campo, nunca desde columnas independientes, independientemente de esta configuración. El análisis de columnas independientes no es compatible con Nullable(Tuple) porque un campo inicial \N es ambiguo (puede ser el NULL externo de la tupla o el NULL de su primer elemento).

Como una Tuple simple ocupa entonces un campo por elemento, un \N en el campo de un elemento directo de nivel superior corresponde a ese elemento y no a toda la columna, por lo que input_format_null_as_default se aplica a ese elemento. Una fila que proporciona un único campo para toda la tupla carece de los elementos restantes y se rechaza en lugar de usar el valor predeterminado de la columna. Establezca esta configuración en 0 para volver a leer dicho campo como toda la columna. Un \N en el campo de un elemento de una Tuple anidada sigue leyéndose como todo ese elemento anidado.

Detecta automáticamente el encabezado con nombres y tipos en formato CSV

Considera los campos vacíos de la entrada CSV como valores predeterminados.

Trata los valores enum insertados en formatos CSV como índices de enum

Controla cómo se lee Nullable(String) cuando hay un valor ausente en un CSV. Un valor ausente es un espacio vacío entre/antes/después de comas, no delimitado por comillas. Si esta configuración está habilitada, independientemente del valor de input_format_csv_empty_as_default, el valor ausente de Nullable(String) se interpretará como una String vacía, no como NULL.

Omitir el número especificado de líneas al comienzo de los datos en formato CSV

Omite las líneas vacías finales en formato CSV

Elimina los espacios y tabulaciones (\t) al principio y al final de las cadenas CSV

Si está habilitado, durante la inferencia de esquema, ClickHouse intentará inferir números a partir de campos de texto. Puede resultar útil si los datos CSV contienen números UInt64 entre comillas.

Deshabilitado de forma predeterminada.

Interpreta las tuplas entrecomilladas en los datos de entrada como un valor de tipo String.

Usa algunos ajustes y heurísticas para inferir el esquema del formato CSV

Permite establecer el valor predeterminado de una columna cuando falla la deserialización de un campo CSV debido a un valor no válido

Ignorar las columnas adicionales en la entrada CustomSeparated (si el archivo tiene más columnas de las esperadas) y tratar los campos que faltan en la entrada CustomSeparated como valores predeterminados

Detecta automáticamente el encabezado con nombres y tipos en el formato CustomSeparated

Omite las líneas vacías finales en el 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 los formatos JSONEachRow (y otros formatos JSON), CSV, TabSeparated, TSKV, Parquet, Arrow, Avro, ORC, Native, y a los formatos con los sufijos WithNames/WithNamesAndTypes.

Valores posibles:

• 0 — Deshabilitado.
• 1 — Habilitado.

Forzar la inicialización de los campos omitidos con valores NULL

Controla qué sucede cuando un tipo de geometría GeoJSON válido que no puede representarse en el tipo Geometry de ClickHouse (como GeometryCollection) debe almacenarse en la columna geometry al leer la entrada GeoJSON.

Posibles valores:

• 'throw' (por defecto) — lanzar una excepción.
• 'null' — insertar un valor NULL en la columna geometry y continuar el procesamiento.

Esto solo se aplica cuando la columna geometry está materializada. Cuando no es una columna de salida solicitada, esa geometría se valida para comprobar que está bien formada, pero no activa este tratamiento.

Ignora las columnas adicionales en la entrada de Hive Text (si el archivo tiene más columnas de las esperadas) y trata los campos que faltan en la entrada de Hive Text como valores predeterminados

Delimitador entre los elementos de una colección (Array o Map) en Hive Text File

Delimitador entre los campos de Hive Text File

Delimitador entre cada par clave-valor de un mapa en Hive Text File

Habilita o deshabilita la inserción de datos JSON con objetos anidados.

Formatos compatibles:

• JSONEachRow

Posibles valores:

• 0 — Deshabilitado.
• 1 — Habilitado.

Consulte también:

• Uso de estructuras Nested con el formato JSONEachRow.

La deserialización de IPv4 usará valores predeterminados en lugar de lanzar una excepción en caso de error de conversión.

Deshabilitado de forma predeterminada.

La deserialización de IPV6 usará valores predeterminados en lugar de generar una excepción si se produce un error de conversión.

Desactivado de forma predeterminada.

Permite un número variable de columnas por fila en los formatos de entrada JSONCompact/JSONCompactEachRow. Ignora las columnas adicionales en las filas que tienen más columnas de las esperadas y usa los valores predeterminados para las columnas que faltan.

Deshabilitado de forma predeterminada.

Inserta valores predeterminados para los elementos ausentes en el objeto JSON al analizar una tupla con nombre. Esta configuración solo funciona cuando está habilitada la configuración input_format_json_named_tuples_as_objects.

Habilitada de forma predeterminada.

Cuando se habilita, los campos vacíos de la entrada JSON se reemplazan por valores predeterminados. Para las expresiones predeterminadas complejas, también debe habilitarse input_format_defaults_for_omitted_fields.

Valores posibles:

• 0 — Deshabilitado.
• 1 — Habilitado.

Ignora las claves desconocidas en los objetos JSON para las tuplas con nombre.

Habilitado de forma predeterminada.

Ignora los campos innecesarios y no los analiza. Al habilitar esta opción, es posible que no se generen excepciones en cadenas JSON con formato no válido o con campos duplicados

Si está habilitado, durante la inferencia de esquemas, ClickHouse usará el tipo Array(Dynamic) para los 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))) │
└──────┴──────────────────────────────────────────────────────────────────┘

Habilitado de forma predeterminada.

Permite usar el tipo String para claves JSON que contienen solo Null/{}/[] en la muestra de datos durante la inferencia de esquemas. En los formatos JSON, cualquier valor puede leerse como String, y se pueden 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 de esquemas 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" : []}}');

Resultado:

┌─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,'{}',[]) │
└────────────────────────────────┘

Habilitado de forma predeterminada.

Deserializa las columnas Map como arrays JSON de tuplas.

Desactivado de forma predeterminada.

Profundidad máxima de un campo en JSON. No es un límite estricto y no es necesario aplicarlo con exactitud.

Tamaño máximo permitido de un único objeto JSON, en bytes. Los objetos que superen este límite se rechazan, ya que probablemente estén malformados. Esto evita el agotamiento de memoria cuando se analiza un documento JSON malformado como un único objeto. Se aplica el mismo límite tanto en las rutas de análisis paralelas como en las no paralelas. Establézcalo en 0 para desactivar la comprobación.

Al crear los búferes String internos de la columna JSON al analizar JSON desde una cadena, limite el crecimiento en potencias de dos a esta cantidad de bytes: cuando el tamaño reservado alcance este valor, el búfer crecerá en incrementos de este tamaño en lugar de duplicarse. Esto acota la sobreasignación en columnas JSON grandes. 0 significa ilimitado (solo duplicación).

Interpreta las columnas de tuplas con nombre como objetos JSON.

Activado de forma predeterminada.

Permite interpretar arrays JSON como cadenas en los formatos de entrada JSON.

Ejemplo:

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]]}');

Resultado:

┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String          │ [1,2,3]                                   │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘

Activado por defecto.

Permite interpretar valores booleanos como números en formatos de entrada JSON.

Habilitado de forma predeterminada.

Permite interpretar booleanos como cadenas en formatos de entrada JSON.

Habilitado de forma predeterminada.

Permite interpretar números como cadenas en formatos de entrada JSON.

Está habilitado de forma predeterminada.

Permite procesar objetos JSON como cadenas en los formatos de entrada JSON.

Ejemplo:

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;

Resultado:

┌─id─┬─obj──────────────────────┬───────date─┐
│  1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │
└────┴──────────────────────────┴────────────┘

Activado de forma predeterminada.

Genera una excepción si una cadena JSON contiene una secuencia de escape no válida en los formatos de entrada JSON. Si se desactiva, las secuencias de escape no válidas permanecerán tal cual en los datos.

Habilitado de forma predeterminada.

Si está habilitado, durante la inferencia de esquema, ClickHouse intentará inferir una tupla con nombre a partir de objetos JSON. La tupla con nombre resultante contendrá todos los elementos de todos los objetos JSON correspondientes de los datos de ejemplo.

Ejemplo:

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

Resultado:

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

Habilitado por defecto.

Si está habilitado, durante la inferencia de esquema ClickHouse intentará inferir números a partir de campos de cadena. Puede resultar útil si los datos JSON contienen números UInt64 entre comillas.

Deshabilitado de forma predeterminada.

Usa el tipo String en lugar de generar una excepción cuando hay rutas ambiguas en objetos JSON durante la inferencia de tuplas con nombre

Para los formatos de entrada JSON/JSONCompact/JSONColumnsWithMetadata, si esta configuración se establece en 1, los tipos indicados en los metadatos de los datos de entrada se compararán con los tipos de las columnas correspondientes de la tabla.

Está habilitado de forma predeterminada.

Limita, en bytes, el tamaño de los bloques formados durante el análisis de datos en los formatos de entrada. Se utiliza en los formatos de entrada basados en filas cuando el bloque se forma en el lado de ClickHouse. 0 significa que no hay límite en bytes.

Limita el tiempo máximo de espera, en milisegundos, antes de emitir un bloque durante el análisis en formatos de entrada basados en filas. 0 significa que no hay límite.

Ejemplo: transmitir a ClickHouse los cambios recientes de Wikipedia

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

La cantidad máxima de datos, en bytes, que se leerá para la inferencia automática de esquema.

El número máximo de filas de datos que se pueden leer para la inferencia automática de esquema.

El número de columnas de los datos MsgPack insertados. Se utiliza para la inferencia automática de esquema a partir de los datos.

Hace coincidir las columnas de la tabla en MySQL dump y las columnas de la tabla de ClickHouse por nombre

Nombre de la tabla del volcado de MySQL de la que se leerán los datos

Permitir la conversión de tipos de datos en el formato de entrada Native

Lee los tipos de datos en formato binario en lugar de los nombres de tipo en el formato de entrada Native

Habilita o deshabilita la inicialización de los campos NULL con valores predeterminados, si el tipo de dato de estos campos no es Nullable. Si el tipo de columna no es Nullable y esta configuración está deshabilitada, insertar 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 habilitado.

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 las columnas ORC con las columnas de CH.

Trata las columnas codificadas con diccionario ORC como columnas LowCardinality al leer archivos ORC.

Al leer archivos ORC, omite stripes o row groups 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 las stripes de ORC.

Omite las columnas con tipos no compatibles durante la inferencia de esquema para el formato ORC

Habilita o deshabilita el análisis en paralelo de formatos de datos conservando el orden. Compatible solo con los formatos TabSeparated (TSV), TSKV, CSV y JSONEachRow.

Valores posibles:

• 1 — Habilitado.
• 0 — Deshabilitado.

Usa el analizador de columnas geo para convertir Array(UInt8) en tipos Point/MultiPoint/Linestring/Polygon/MultiLineString/MultiPolygon

Permitir columnas ausentes al leer formatos de entrada Parquet

Al leer archivos Parquet, se omiten grupos de filas completos en función de las expresiones WHERE y del filtro bloom en los metadatos de Parquet.

No distinguir entre mayúsculas y minúsculas al hacer coincidir las columnas de Parquet con las columnas de CH.

Al leer archivos Parquet (con el lector v3), omite grupos de filas completos según las expresiones WHERE/PREWHERE y el contenido de las páginas de diccionario cuando todas las páginas de datos de un fragmento de columna están codificadas mediante diccionario. El valor es el tamaño máximo, en bytes, de las páginas de diccionario al que se aplica esta optimización; establézcalo en 0 para deshabilitarla. Esta opción tiene prioridad sobre el filtro Bloom cuando ambos están disponibles.

Al leer archivos Parquet, interpretar 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 admite la precarga.

Al leer archivos Parquet, se omiten grupos de filas completos según las expresiones WHERE/PREWHERE y las estadísticas mín./máx. en los metadatos de Parquet.

Cantidad mínima de bytes necesaria para que una lectura local (archivo) haga seek, en lugar de leer con ignore, en el formato de entrada Parquet

Determina el tipo de dato que usa la inferencia de esquema para los timestamps de Parquet con isAdjustedToUTC=false. Si es true: DateTime64(…, 'UTC'); si es false: DateTime64(…). Ninguno de los dos comportamientos es del todo correcto, ya que ClickHouse no tiene un tipo de dato para la hora local según el reloj. Aunque resulte poco intuitivo, 'true' probablemente sea la opción menos incorrecta, porque al dar formato al timestamp 'UTC' como String se obtiene una representación de la hora local correcta.

Tamaño máximo del bloque para el lector de Parquet.

Límite aproximado de memoria 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 de todos esos archivos.

Programa las prelecturas de forma más agresiva si el uso de memoria está por debajo del umbral. Puede ser útil, por ejemplo, si hay muchos filtros bloom pequeños que deben leerse a través de la red.

Omite páginas usando los valores mín./máx. del índice de columna.

Promedio de bytes por bloque generado por el lector de Parquet

Evita reordenar las filas al leer archivos Parquet. No se recomienda, ya que el orden de las filas por lo general no está garantizado y otras partes del pipeline de consulta pueden alterarlo. Usa ORDER BY _row_number en su lugar.

Omitir las columnas con tipos no compatibles durante la inferencia del esquema para el formato Parquet

Al leer archivos GeoParquet, omite grupos de filas completos y, junto con input_format_parquet_page_filter_push_down, páginas individuales en función de los predicados espaciales de la cláusula WHERE y de las estadísticas del cuadro delimitador de la geometría (columnas geospatial_statistics.bbox o covering.bbox) en los metadatos de Parquet.

Pequeño ajuste en la forma de leer páginas de un 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 el uso de las envolturas de Google para columnas normales no anidadas; por ejemplo, google.protobuf.StringValue 'str' para la columna String 'str'. En las columnas Nullable, las envolturas vacías se interpretan como valores predeterminados y las ausentes como NULL

Indica qué campo de Protobuf oneof se encontró estableciendo un valor enum en una columna especial

Omitir los campos con tipos no compatibles durante la inferencia de esquema del formato Protobuf

Lea un entero sin comillas para una columna DateTime/DateTime64 como el valor subyacente sin procesar: segundos para DateTime y ticks según la precisión de la columna para DateTime64, en lugar de como una marca de tiempo Unix en segundos.

Desactivada de forma predeterminada, un número sin comillas se interpreta como una marca de tiempo Unix en segundos (con precisión subsegundo opcional), de forma coherente con el formato Values, CAST y toDateTime64. Actívela (o use SET compatibility = '26.7') para restaurar el comportamiento de las versiones hasta la 26.7 incluida, en el que un entero sin comillas proporcionado a una columna DateTime64 se interpretaba como el valor escalado sin procesar (ticks). La ruta legacy solo acepta este tipo de entero: con la configuración activada, las rutas de entrada de filas rechazan los números con parte fraccionaria o exponente (como antes de la versión 26.8), mientras que en JSONExtract y el tipo JSON tipado, los números fraccionarios se siguen interpretando como segundos para DateTime64 y se rechazan para DateTime (también como antes de la versión 26.8). En el propio formato Values, si el analizador de streaming rechaza un número, se recurre a la evaluación de expresiones SQL y se interpreta como segundos, tanto antes de la versión 26.8 como con esta configuración activada; por lo tanto, el comportamiento de Values para los números fraccionarios es el mismo en todas las configuraciones.

Esta configuración rige únicamente las rutas JSON, Values/Quoted y JSONExtract/JSON tipado (la ruta Quoted abarca todos los formatos que analizan campos con la regla de escaping Quoted: Values, MySQLDump y Template/CustomSeparated/Regexp configurados con escaping de campos Quoted). Los formatos separados por tabulaciones, CSV y otros formatos escapados/de texto completo no se ven afectados: en ellos, los números DateTime64 grandes sin comillas se siguen interpretando como ticks.

Ruta del archivo que se utiliza para registrar errores al leer formatos de texto (CSV, TSV).

Habilita o deshabilita 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 la omisión está habilitada, ClickHouse no inserta los datos adicionales y no lanza ninguna excepción.

Formatos compatibles:

• JSONEachRow (y otros formatos JSON)
• BSONEachRow (y otros formatos JSON)
• TSKV
• Todos los formatos con sufijos WithNames/WithNamesAndTypes
• MySQLDump
• Native

Valores posibles:

• 0 — Deshabilitado.
• 1 — Habilitado.

Si está habilitada, ClickHouse intentará inferir el tipo Date a partir de campos de texto durante la inferencia de esquema 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.

Habilitada de forma predeterminada.

Si está habilitado, 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 analizaron correctamente como valores datetime, el tipo resultante será DateTime64; si al menos un campo no se analizó como datetime, el tipo resultante será String.

Habilitado de forma predeterminada.

Cuando input_format_try_infer_datetimes está habilitado, infiere solo tipos DateTime64, no DateTime

Intenta inferir números de punto flotante en notación exponencial durante la inferencia del esquema en formatos de texto (excepto en 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 del esquema para formatos de texto. Si todos los números de la columna de los datos de entrada son enteros, el tipo de resultado será Int64; si al menos uno es de coma flotante, el tipo de resultado será Float64.

Está habilitado de forma predeterminada.

Si está habilitado, ClickHouse intentará inferir el tipo Variant durante la inferencia de esquema en formatos de texto cuando haya más de un tipo posible para los elementos de columnas/arrays.

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 trata los campos que faltan en la entrada TSV como valores predeterminados.

Si se establece en true, la función file leerá el formato TSV con \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 el número especificado de líneas al principio de los datos en formato TSV

Omitir las líneas vacías al final en formato TSV

Utiliza ciertos ajustes y heurísticas para inferir el esquema en el 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 precisión.

Para el formato Values: si el campo no puede analizarse con el analizador de streaming, se ejecuta el analizador de 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 puede analizarse con el analizador de streaming, ejecute el analizador de 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 al insertar, recomendamos desactivar esta comprobación si está seguro de que el orden de las columnas de los datos de entrada es el mismo que en la tabla de destino.

Formatos compatibles:

• CSVWithNames
• CSVWithNamesAndTypes
• TabSeparatedWithNames
• TabSeparatedWithNamesAndTypes
• JSONCompactEachRowWithNames
• JSONCompactEachRowWithNamesAndTypes
• JSONCompactStringsEachRowWithNames
• JSONCompactStringsEachRowWithNamesAndTypes
• RowBinaryWithNames
• RowBinaryWithNamesAndTypes
• CustomSeparatedWithNames
• CustomSeparatedWithNamesAndTypes

Valores posibles:

• 0 — Desactivado.
• 1 — Activado.

Controla si el analizador del formato debe comprobar que los tipos de datos de entrada coincidan con los de la tabla de destino.

Formatos compatibles:

• CSVWithNamesAndTypes
• TabSeparatedWithNamesAndTypes
• JSONCompactEachRowWithNamesAndTypes
• JSONCompactStringsEachRowWithNamesAndTypes
• RowBinaryWithNamesAndTypes
• CustomSeparatedWithNamesAndTypes

Valores posibles:

• 0 — Deshabilitado.
• 1 — Habilitado.