> ## 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.
# Configuración de formatos
> Ajustes que controlan los formatos de entrada y salida.
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 ;
};
Estos ajustes se generan automáticamente a partir del [código fuente](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/FormatFactorySettings.h).
## allow\_special\_bool\_values\_inside\_variant
Permite interpretar valores Bool dentro del tipo Variant a partir de representaciones textuales especiales de valores booleanos, como "on", "off", "enable", "disable", etc.
## bool\_false\_representation
Texto que representa el valor booleano false en los formatos TSV/CSV/Vertical/Pretty.
## bool\_true\_representation
Texto para representar el valor booleano verdadero en los formatos TSV/CSV/Vertical/Pretty.
## check\_conversion\_from\_numbers\_to\_enum
Lanza una excepción durante la conversión de Numbers a Enum si el valor no existe en Enum.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
**Ejemplo**
```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); -- devuelve un error
```
## column\_names\_for\_schema\_inference
La lista de nombres de columnas que se usarán en la inferencia del esquema para formatos sin nombres de columna. Formato: 'column1,column2,column3,...'
## date\_time\_64\_output\_format\_cut\_trailing\_zeros\_align\_to\_groups\_of\_thousands
Elimina dinámicamente los ceros finales de los valores de datetime64 para ajustar la escala de salida a \[0, 3, 6],
correspondientes a 'segundos', 'milisegundos' y 'microsegundos'
## date\_time\_input\_format
Permite elegir un analizador para la representación textual de la fecha y la hora.
Esta configuración no se aplica a las [funciones de fecha y hora](/es/reference/functions/regular-functions/date-time-functions).
Valores posibles:
* `'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](https://en.wikipedia.org/wiki/ISO_8601). Por ejemplo, `'2018-06-08T01:02:03.000Z'`.
* `'best_effort_us'` — Similar a `best_effort` (consulte la diferencia en [parseDateTimeBestEffortUS](/es/reference/functions/regular-functions/type-conversion-functions#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:
* [Tipo de dato DateTime.](/es/reference/data-types/datetime)
* [Funciones para trabajar con fechas y horas.](/es/reference/functions/regular-functions/date-time-functions)
## date\_time\_output\_format
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](https://en.wikipedia.org/wiki/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](https://en.wikipedia.org/wiki/Unix_time). Por ejemplo, `1566285536`.
Véase también:
* [Tipo de dato DateTime.](/es/reference/data-types/datetime)
* [Funciones para trabajar con fechas y horas.](/es/reference/functions/regular-functions/date-time-functions)
## date\_time\_overflow\_behavior
Define el comportamiento cuando [Date](/es/reference/data-types/date), [Date32](/es/reference/data-types/date32), [DateTime](/es/reference/data-types/datetime), [DateTime64](/es/reference/data-types/datetime64) o enteros se convierten a Date, Date32, DateTime o DateTime64, pero el valor no puede representarse en el tipo de resultado.
Valores posibles:
* `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`.
## errors\_output\_format
Método para escribir errores en la salida de texto.
## format\_avro\_schema\_registry\_connection\_timeout
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).
## format\_avro\_schema\_registry\_receive\_timeout
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).
## format\_avro\_schema\_registry\_send\_timeout
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).
## format\_avro\_schema\_registry\_url
Para el formato AvroConfluent: URL del Confluent Schema Registry.
## format\_binary\_max\_array\_size
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
## format\_binary\_max\_object\_size
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
## format\_binary\_max\_string\_size
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
## format\_capn\_proto\_enum\_comparising\_mode
Cómo asignar correspondencias entre Enum de ClickHouse y Enum de CapnProto
## format\_capn\_proto\_max\_message\_size
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.
## format\_capn\_proto\_use\_autogenerated\_schema
Usa el esquema de CapnProto autogenerado cuando no se haya establecido format\_schema
## format\_csv\_allow\_double\_quotes
Si se establece en true, permite cadenas entre comillas dobles.
## format\_csv\_allow\_single\_quotes
Si se establece en true, permite cadenas entre comillas simples.
## format\_csv\_delimiter
El carácter que se considera delimitador en los datos CSV. Si se configura como una cadena, esta debe tener una longitud de 1.
## format\_csv\_null\_representation
Representación personalizada de NULL en formato CSV
## format\_custom\_escaping\_rule
Regla de escape para campos (para el formato CustomSeparated)
## format\_custom\_field\_delimiter
Delimitador entre campos (para el formato CustomSeparated)
## format\_custom\_result\_after\_delimiter
Sufijo tras el conjunto de resultados (para el formato CustomSeparated)
## format\_custom\_result\_before\_delimiter
Prefijo antes del conjunto de resultados (para el formato CustomSeparated)
## format\_custom\_row\_after\_delimiter
Delimitador después del campo de la última columna (para el formato CustomSeparated)
## format\_custom\_row\_before\_delimiter
Delimitador antes del campo de la primera columna (en el formato CustomSeparated)
## format\_custom\_row\_between\_delimiter
Delimitador entre filas (para el formato CustomSeparated)
## format\_display\_secrets\_in\_show\_and\_select
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`](/es/reference/settings/server-settings/settings#display_secrets_in_show_and_select)
activada y el privilegio
[`displaySecretsInShowAndSelect`](/es/reference/statements/grant#displaysecretsinshowandselect).
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## format\_json\_object\_each\_row\_column\_for\_object\_name
El nombre de la columna que se utilizará para almacenar o escribir nombres de objetos en el formato [JSONObjectEachRow](/es/reference/formats/JSON/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.
## format\_protobuf\_use\_autogenerated\_schema
Usa Protobuf autogenerado cuando no se configure `format_schema`
## format\_regexp
Expresión regular (para el formato Regexp)
## format\_regexp\_escaping\_rule
Regla de escape de campo (para formato Regexp)
## format\_regexp\_skip\_unmatched
Omite las líneas que no coincidan con la expresión regular (para el formato Regexp)
## format\_schema
Este parámetro resulta útil cuando se usan formatos que requieren una definición de esquema, como [Cap'n Proto](https://capnproto.org/) o [Protobuf](https://developers.google.com/protocol-buffers/). El valor depende del formato.
## format\_schema\_message\_name
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.
## format\_schema\_source
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.
## format\_template\_resultset
Ruta del archivo que contiene la cadena de formato del conjunto de resultados (para el formato Template)
## format\_template\_resultset\_format
Cadena de formato para el conjunto de resultados (para el formato Template)
## format\_template\_row
Ruta del archivo que contiene la cadena de formato para las filas (para el formato Template)
## format\_template\_row\_format
Cadena de formato para filas (para el formato Template)
## format\_template\_rows\_between\_delimiter
Delimitador entre filas (para el formato Template)
## format\_tsv\_null\_representation
Representación personalizada de NULL en formato TSV
## input\_format\_allow\_errors\_num
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.
## input\_format\_allow\_errors\_ratio
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.
## input\_format\_allow\_seeks
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.
## input\_format\_arrow\_allow\_missing\_columns
Permite columnas ausentes al leer formatos de entrada Arrow
## input\_format\_arrow\_case\_insensitive\_column\_matching
No distingue entre mayúsculas y minúsculas al hacer coincidir las columnas de Arrow con las columnas de CH.
## input\_format\_arrow\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference
Omitir las columnas con tipos no admitidos durante la inferencia del esquema para el formato Arrow
## input\_format\_avro\_allow\_missing\_fields
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
## input\_format\_avro\_null\_as\_default
Para el formato Avro/AvroConfluent: inserta el valor predeterminado en caso de NULL y de columna no Nullable
## input\_format\_binary\_decode\_types\_in\_binary\_format
Leer tipos de datos en formato binario en lugar de nombres de tipos en el formato de entrada RowBinaryWithNamesAndTypes
## input\_format\_binary\_max\_type\_complexity
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.
## input\_format\_binary\_read\_json\_as\_string
Lee valores del tipo de dato [JSON](/es/reference/data-types/newjson) como valores [String](/es/reference/data-types/string) JSON en el formato de entrada RowBinary.
## input\_format\_bson\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference
Omite los campos con tipos no compatibles durante la inferencia del esquema del formato BSON.
## input\_format\_capn\_proto\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference
Omitir las columnas con tipos no compatibles durante la inferencia del esquema para el formato CapnProto
## input\_format\_column\_name\_matching\_mode
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.
## input\_format\_connection\_handling
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
## input\_format\_csv\_allow\_cr\_end\_of\_line
Si se establece en true, se permitirá \r al final de la línea sin que vaya seguido de
## input\_format\_csv\_allow\_variable\_number\_of\_columns
Ignora las columnas adicionales en la entrada CSV (si el archivo tiene más columnas de las esperadas) y trata los campos que faltan en la entrada CSV como valores por defecto
## input\_format\_csv\_allow\_whitespace\_or\_tab\_as\_delimiter
Permite usar espacios y tabuladores (\t) como delimitadores de campo en las cadenas CSV
## input\_format\_csv\_arrays\_as\_nested\_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 arreglo.
## input\_format\_csv\_deserialize\_separate\_columns\_into\_tuple
Si se establece en true, las columnas independientes escritas en formato CSV pueden deserializarse en una columna de tipo Tuple.
Detectar automáticamente la fila de encabezado con nombres y tipos en formato CSV
## input\_format\_csv\_empty\_as\_default
Considera los campos vacíos en la entrada CSV como valores predeterminados.
## input\_format\_csv\_enum\_as\_number
Considera los valores `enum` insertados en formatos CSV como índices de `enum`
## input\_format\_csv\_skip\_first\_lines
Omite el número especificado de líneas al inicio de los datos en formato CSV
## input\_format\_csv\_skip\_trailing\_empty\_lines
Omite las líneas vacías al final en formato CSV
## input\_format\_csv\_trim\_whitespaces
Elimina los espacios y tabulaciones (\t) al principio y al final de las cadenas CSV
## input\_format\_csv\_try\_infer\_numbers\_from\_strings
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.
## input\_format\_csv\_try\_infer\_strings\_from\_quoted\_tuples
Interpreta las Tuples entrecomilladas en los datos de entrada como un valor de tipo String.
## input\_format\_csv\_use\_best\_effort\_in\_schema\_inference
Utiliza algunos ajustes y heurísticas para inferir el esquema en formato CSV
## input\_format\_csv\_use\_default\_on\_bad\_values
Permite establecer el valor predeterminado de la columna cuando falla la deserialización de un campo CSV debido a un valor no válido
## input\_format\_custom\_allow\_variable\_number\_of\_columns
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
## input\_format\_custom\_skip\_trailing\_empty\_lines
Omitir las líneas vacías finales del formato CustomSeparated
## input\_format\_defaults\_for\_omitted\_fields
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](/es/reference/formats/JSON/JSONEachRow) (y otros formatos JSON), [CSV](/es/reference/formats/CSV/CSV), [TabSeparated](/es/reference/formats/TabSeparated/TabSeparated), [TSKV](/es/reference/formats/TabSeparated/TSKV), [Parquet](/es/reference/formats/Parquet/Parquet), [Arrow](/es/reference/formats/Arrow/Arrow), [Avro](/es/reference/formats/Avro/Avro), [ORC](/es/reference/formats/ORC), [Native](/es/reference/formats/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.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## input\_format\_force\_null\_for\_omitted\_fields
Forzar la inicialización de los campos omitidos con valores NULL
## input\_format\_hive\_text\_allow\_variable\_number\_of\_columns
Ignorar las columnas adicionales en la entrada de Hive Text (si el archivo tiene más columnas de las esperadas) y tratar los campos que falten en la entrada de Hive Text como valores por defecto
## input\_format\_hive\_text\_collection\_items\_delimiter
Delimitador entre los elementos de una colección (array o map) en Hive Text File
## input\_format\_hive\_text\_fields\_delimiter
Delimitador entre campos de Hive Text File
## input\_format\_hive\_text\_map\_keys\_delimiter
Delimitador entre la clave y el valor de un par de map en Hive Text File
## input\_format\_import\_nested\_json
Habilita o deshabilita la inserción de datos JSON que contienen objetos anidados.
Formatos compatibles:
* [JSONEachRow](/es/reference/formats/JSON/JSONEachRow)
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
Véase también:
* [Uso de estructuras anidadas](/es/guides/clickhouse/data-formats/json/formats#accessing-nested-json-objects) con el formato `JSONEachRow`.
## input\_format\_ipv4\_default\_on\_conversion\_error
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.
## input\_format\_ipv6\_default\_on\_conversion\_error
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.
## input\_format\_json\_compact\_allow\_variable\_number\_of\_columns
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.
## input\_format\_json\_defaults\_for\_missing\_elements\_in\_named\_tuple
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.
## input\_format\_json\_empty\_as\_default
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.
## input\_format\_json\_ignore\_unknown\_keys\_in\_named\_tuple
Ignora las claves desconocidas en objetos JSON para las tuplas con nombre.
Habilitado de forma predeterminada.
## input\_format\_json\_ignore\_unnecessary\_fields
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
## input\_format\_json\_infer\_array\_of\_dynamic\_from\_array\_of\_different\_types
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:
```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))) │
└──────┴──────────────────────────────────────────────────────────────────┘
```
Habilitado de forma predeterminada.
## input\_format\_json\_infer\_incomplete\_types\_as\_strings
Permite usar el tipo String para claves de JSON que contienen solo `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:
```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" : []}}');
```
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,'{}',[]) │
└────────────────────────────────┘
```
Activado de forma predeterminada.
## input\_format\_json\_map\_as\_array\_of\_tuples
Deserializa las columnas de tipo Map como arrays JSON de tuplas.
Desactivado de forma predeterminada.
## input\_format\_json\_max\_depth
Profundidad máxima de un campo en JSON. No es un límite estricto y no es necesario que se aplique con exactitud.
## input\_format\_json\_named\_tuples\_as\_objects
Interpreta las columnas de tuplas con nombre como objetos JSON.
Habilitado de forma predeterminada.
## input\_format\_json\_read\_arrays\_as\_strings
Permite interpretar arrays JSON como cadenas en los formatos de entrada JSON.
Ejemplo:
```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]]}');
```
Resultado:
```
┌─arr───────────────────┬─toTypeName(arr)─┬─arrayElement(JSONExtractArrayRaw(arr), 3)─┐
│ [1, "Hello", [1,2,3]] │ String │ [1,2,3] │
└───────────────────────┴─────────────────┴───────────────────────────────────────────┘
```
Activado de forma predeterminada.
## input\_format\_json\_read\_bools\_as\_numbers
Permite interpretar valores booleanos como números en los formatos de entrada JSON.
Está habilitado de forma predeterminada.
## input\_format\_json\_read\_bools\_as\_strings
Permite analizar valores booleanos como cadenas en formatos de entrada JSON.
Habilitado de forma predeterminada.
## input\_format\_json\_read\_numbers\_as\_strings
Permite analizar números como cadenas en formatos de entrada JSON.
Habilitado de forma predeterminada.
## input\_format\_json\_read\_objects\_as\_strings
Permite analizar objetos JSON como cadenas en los formatos de entrada JSON.
Ejemplo:
```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;
```
Resultado:
```
┌─id─┬─obj──────────────────────┬───────date─┐
│ 1 │ {"a" : 1, "b" : "Hello"} │ 2020-01-01 │
└────┴──────────────────────────┴────────────┘
```
Habilitado de forma predeterminada.
## input\_format\_json\_throw\_on\_bad\_escape\_sequence
Lanza 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.
Activado de forma predeterminada.
## input\_format\_json\_try\_infer\_named\_tuples\_from\_objects
Si está habilitado, durante la inferencia del esquema, ClickHouse intentará inferir un Tuple con nombre a partir de objetos JSON.
El Tuple con nombre resultante contendrá todos los elementos de todos los objetos JSON correspondientes presentes en los datos de muestra.
Ejemplo:
```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}}}')
```
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 de forma predeterminada.
## input\_format\_json\_try\_infer\_numbers\_from\_strings
Si está habilitado, durante la inferencia del esquema ClickHouse intentará inferir números a partir de campos de tipo cadena.
Puede resultar útil si los datos JSON contienen números UInt64 entre comillas.
Deshabilitado de forma predeterminada.
## input\_format\_json\_use\_string\_type\_for\_ambiguous\_paths\_in\_named\_tuples\_inference\_from\_objects
Usa el tipo String en lugar de generar una excepción en caso de rutas ambiguas en objetos JSON durante la inferencia de tuplas con nombre
## input\_format\_json\_validate\_types\_from\_metadata
Para los formatos de entrada JSON/JSONCompact/JSONColumnsWithMetadata, si esta configuración se establece en 1,
los tipos de los metadatos de los datos de entrada se compararán con los tipos de las columnas correspondientes de la tabla.
Habilitado de forma predeterminada.
## input\_format\_max\_block\_size\_bytes
Limita, en bytes, el tamaño de los bloques que se forman durante el análisis de datos en los formatos de entrada. Se utiliza en formatos de entrada basados en filas cuando el bloque se forma del lado de ClickHouse.
0 significa que no hay límite en bytes.
## input\_format\_max\_block\_wait\_ms
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.
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.
**Ejemplo: transmitir cambios recientes de Wikipedia a ClickHouse**
```bash theme={null}
clickhouse-client --query 'CREATE TABLE wikipedia_edits (data JSON)'
curl -sS --globoff -H 'Accept: application/json' --no-buffer \
'https://stream.wikimedia.org/v2/stream/recentchange' \
| clickhouse-client \
--query 'INSERT INTO wikipedia_edits FORMAT JSONAsObject' \
--input_format_max_block_wait_ms 1000 \
--input_format_connection_handling 1 \
--min_insert_block_size_rows 0 \
--min_insert_block_size_bytes 0
```
## input\_format\_max\_bytes\_to\_read\_for\_schema\_inference
La cantidad máxima de datos, en bytes, que se puede leer para la inferencia automática del esquema.
## input\_format\_max\_rows\_to\_read\_for\_schema\_inference
El número máximo de filas de datos que se pueden leer para la inferencia automática del esquema.
## input\_format\_msgpack\_number\_of\_columns
El número de columnas de los datos MsgPack insertados. Se utiliza para la inferencia automática del esquema a partir de los datos.
## input\_format\_mysql\_dump\_map\_column\_names
Hace coincidir las columnas de la tabla del volcado de MySQL con las columnas de la tabla de ClickHouse por nombre
## input\_format\_mysql\_dump\_table\_name
Nombre de la tabla del volcado de MySQL de la que se leen los datos
## input\_format\_native\_allow\_types\_conversion
Permitir la conversión de tipos en el formato de entrada Native
## input\_format\_native\_decode\_types\_in\_binary\_format
Leer los tipos de datos en formato binario en lugar de los nombres de tipo en el formato de entrada Native
## input\_format\_null\_as\_default
Habilita o deshabilita la inicialización de campos [NULL](/es/reference/syntax#literals) con [valores predeterminados](/es/reference/statements/create/table#default_values), si el tipo de dato de estos campos no es [Nullable](/es/reference/data-types/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 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.
## input\_format\_orc\_allow\_missing\_columns
Permite columnas ausentes al leer formatos de entrada ORC
## input\_format\_orc\_case\_insensitive\_column\_matching
No distingue entre mayúsculas y minúsculas al hacer coincidir columnas ORC con columnas de CH.
## input\_format\_orc\_dictionary\_as\_low\_cardinality
Trata las columnas ORC codificadas con diccionario como columnas LowCardinality al leer archivos ORC.
## input\_format\_orc\_filter\_push\_down
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.
## input\_format\_orc\_reader\_time\_zone\_name
El nombre de la zona horaria del lector de filas ORC; la zona horaria predeterminada del lector de filas ORC es GMT.
## input\_format\_orc\_row\_batch\_size
Tamaño del lote al leer stripes de archivos ORC.
## input\_format\_orc\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference
Omitir las columnas con tipos no compatibles durante la inferencia del esquema para el formato ORC
## input\_format\_orc\_use\_fast\_decoder
Usa una implementación más rápida del decodificador ORC.
## input\_format\_parallel\_parsing
Habilita o deshabilita el análisis paralelo de los formatos de datos conservando el orden. Solo es compatible con los formatos [TabSeparated (TSV)](/es/reference/formats/TabSeparated/TabSeparated), [TSKV](/es/reference/formats/TabSeparated/TSKV), [CSV](/es/reference/formats/CSV/CSV) y [JSONEachRow](/es/reference/formats/JSON/JSONEachRow).
Valores posibles:
* 1 — Habilitado.
* 0 — Deshabilitado.
## input\_format\_parquet\_allow\_geoparquet\_parser
Use el analizador de columnas Geo para convertir Array(UInt8) en tipos Point/Linestring/Polygon/MultiLineString/MultiPolygon
## input\_format\_parquet\_allow\_missing\_columns
Permite columnas ausentes al leer formatos de entrada Parquet
## input\_format\_parquet\_bloom\_filter\_push\_down
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.
## input\_format\_parquet\_case\_insensitive\_column\_matching
Ignora las mayúsculas y minúsculas al hacer coincidir columnas de Parquet con columnas de CH.
## input\_format\_parquet\_enable\_json\_parsing
Al leer archivos Parquet, interpreta las columnas JSON como columnas JSON de ClickHouse.
## input\_format\_parquet\_enable\_row\_group\_prefetch
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.
## input\_format\_parquet\_filter\_push\_down
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.
## input\_format\_parquet\_local\_file\_min\_bytes\_for\_seek
Bytes mínimos necesarios para que una lectura local (archivo) haga `seek`, en lugar de leer ignorando datos, en el formato de entrada Parquet
## input\_format\_parquet\_local\_time\_as\_utc
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.
## input\_format\_parquet\_max\_block\_size
Tamaño máximo de bloque del lector de Parquet.
## input\_format\_parquet\_memory\_high\_watermark
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.
## input\_format\_parquet\_memory\_low\_watermark
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
Omite páginas utilizando los valores mín./máx. del índice de columna.
## input\_format\_parquet\_prefer\_block\_bytes
Promedio de bytes por bloque generado por el lector Parquet
## input\_format\_parquet\_preserve\_order
Evita reordenar las filas al leer archivos Parquet. No se recomienda, ya que, por lo general, no se garantiza el orden de las filas y otras partes del pipeline de consulta pueden alterarlo. En su lugar, usa `ORDER BY _row_number`.
## input\_format\_parquet\_skip\_columns\_with\_unsupported\_types\_in\_schema\_inference
Omitir las columnas con tipos no compatibles durante la inferencia de esquema para el formato Parquet
## input\_format\_parquet\_use\_offset\_index
Ajuste menor en la forma de leer las páginas del archivo Parquet cuando no se usa el filtrado de páginas.
## input\_format\_parquet\_verify\_checksums
Verifica las sumas de comprobación de las páginas al leer archivos Parquet.
## input\_format\_protobuf\_flatten\_google\_wrappers
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
## input\_format\_protobuf\_oneof\_presence
Indica qué campo de protobuf oneof se encontró mediante la asignación de un valor enum en una columna especial
## input\_format\_protobuf\_skip\_fields\_with\_unsupported\_types\_in\_schema\_inference
Omite los campos con tipos no compatibles durante la inferencia de esquemas para el formato Protobuf
## input\_format\_record\_errors\_file\_path
Ruta del archivo que se utiliza para registrar errores durante la lectura de formatos de texto (CSV, TSV).
## input\_format\_skip\_unknown\_fields
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:
* [JSONEachRow](/es/reference/formats/JSON/JSONEachRow) (y otros formatos JSON)
* [BSONEachRow](/es/reference/formats/BSONEachRow) (y otros formatos JSON)
* [TSKV](/es/reference/formats/TabSeparated/TSKV)
* Todos los formatos con sufijos WithNames/WithNamesAndTypes
* [MySQLDump](/es/reference/formats/MySQLDump)
* [Native](/es/reference/formats/Native)
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## input\_format\_try\_infer\_dates
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.
## input\_format\_try\_infer\_datetimes
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.
## input\_format\_try\_infer\_datetimes\_only\_datetime64
Cuando input\_format\_try\_infer\_datetimes está habilitado, infiere solo DateTime64, pero no tipos DateTime
## input\_format\_try\_infer\_exponent\_floats
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)
## input\_format\_try\_infer\_integers
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.
## input\_format\_try\_infer\_variants
Si está habilitada, ClickHouse intentará inferir el tipo [`Variant`](/es/reference/data-types/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.
## input\_format\_tsv\_allow\_variable\_number\_of\_columns
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
## input\_format\_tsv\_crlf\_end\_of\_line
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
## input\_format\_tsv\_empty\_as\_default
Trata los campos vacíos de la entrada TSV como valores predeterminados.
## input\_format\_tsv\_enum\_as\_number
Trata los valores de enum insertados en formatos TSV como índices de enum.
## input\_format\_tsv\_skip\_first\_lines
Omite la cantidad especificada de líneas al inicio de los datos en formato TSV
## input\_format\_tsv\_skip\_trailing\_empty\_lines
Omitir las líneas vacías al final en formato TSV
## input\_format\_tsv\_use\_best\_effort\_in\_schema\_inference
Usa algunos ajustes y heurísticas para inferir el esquema en formato TSV
## input\_format\_values\_accurate\_types\_of\_literals
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.
## input\_format\_values\_deduce\_templates\_of\_expressions
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.
## input\_format\_values\_interpret\_expressions
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:
* [CSVWithNames](/es/reference/formats/CSV/CSVWithNames)
* [CSVWithNamesAndTypes](/es/reference/formats/CSV/CSVWithNamesAndTypes)
* [TabSeparatedWithNames](/es/reference/formats/TabSeparated/TabSeparatedWithNames)
* [TabSeparatedWithNamesAndTypes](/es/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes)
* [JSONCompactEachRowWithNames](/es/reference/formats/JSON/JSONCompactEachRowWithNames)
* [JSONCompactEachRowWithNamesAndTypes](/es/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes)
* [JSONCompactStringsEachRowWithNames](/es/reference/formats/JSON/JSONCompactStringsEachRowWithNames)
* [JSONCompactStringsEachRowWithNamesAndTypes](/es/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes)
* [RowBinaryWithNames](/es/reference/formats/RowBinary/RowBinaryWithNames)
* [RowBinaryWithNamesAndTypes](/es/reference/formats/RowBinary/RowBinaryWithNamesAndTypes)
* [CustomSeparatedWithNames](/es/reference/formats/CustomSeparated/CustomSeparatedWithNames)
* [CustomSeparatedWithNamesAndTypes](/es/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes)
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:
* [CSVWithNamesAndTypes](/es/reference/formats/CSV/CSVWithNamesAndTypes)
* [TabSeparatedWithNamesAndTypes](/es/reference/formats/TabSeparated/TabSeparatedWithNamesAndTypes)
* [JSONCompactEachRowWithNamesAndTypes](/es/reference/formats/JSON/JSONCompactEachRowWithNamesAndTypes)
* [JSONCompactStringsEachRowWithNamesAndTypes](/es/reference/formats/JSON/JSONCompactStringsEachRowWithNamesAndTypes)
* [RowBinaryWithNamesAndTypes](/es/reference/formats/RowBinary/RowBinaryWithNamesAndTypes)
* [CustomSeparatedWithNamesAndTypes](/es/reference/formats/CustomSeparated/CustomSeparatedWithNamesAndTypes)
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## insert\_distributed\_one\_random\_shard
Habilita o deshabilita la inserción en un segmento aleatorio en una tabla [Distributed](/es/reference/engines/table-engines/special/distributed) cuando no hay una clave de distribución.
De forma predeterminada, al insertar datos en una tabla `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.
## interval\_output\_format
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](https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings#the-constant-c-format-specifier). 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:
* [Interval](/es/reference/data-types/special-data-types/interval)
## into\_outfile\_create\_parent\_directories
Crea automáticamente los directorios padre al usar INTO OUTFILE si aún no existen.
## json\_type\_escape\_dots\_in\_keys
Si está habilitado, los puntos de las claves JSON se escaparán durante el análisis.
## max\_dynamic\_subcolumns\_in\_json\_type\_parsing
El número máximo de subcolumnas dinámicas que se pueden crear en cada columna durante el análisis de una columna de tipo JSON.
Permite controlar el número de subcolumnas dinámicas durante el análisis, independientemente de los parámetros dinámicos especificados en el tipo de dato.
## output\_format\_arrow\_compression\_method
Método de compresión para el formato de salida Arrow. Códecs compatibles: lz4\_frame, zstd, none (sin comprimir)
## output\_format\_arrow\_date\_as\_uint16
Escribe los valores Date como números simples de 16 bits (que se vuelven a leer como UInt16), en lugar de convertirlos en un tipo Arrow DATE32 de 32 bits (que se vuelve a leer como Date32).
## output\_format\_arrow\_fixed\_string\_as\_fixed\_byte\_array
Use el tipo Arrow FIXED\_SIZE\_BINARY en lugar de Binary para las columnas FixedString.
## output\_format\_arrow\_low\_cardinality\_as\_dictionary
Habilita la salida del tipo LowCardinality como tipo Diccionario de Arrow
## output\_format\_arrow\_string\_as\_string
Usar el tipo String de Arrow en lugar de Binary para las columnas String
## output\_format\_arrow\_unsupported\_types\_as\_binary
Emite como datos binarios sin procesar los tipos de salida que no tienen conversión. Si es false, esos tipos generarían la excepción UNKNOWN\_TYPE.
## output\_format\_arrow\_use\_64\_bit\_indexes\_for\_dictionary
Usa siempre enteros de 64 bits para los índices de diccionario en formato Arrow
## output\_format\_arrow\_use\_signed\_indexes\_for\_dictionary
Usar enteros con signo para los índices de diccionario en formato Arrow
## output\_format\_avro\_codec
Códec de compresión utilizado para la salida. Valores posibles: 'null', 'deflate', 'snappy', 'zstd'.
## output\_format\_avro\_confluent\_subject
Para el formato de salida AvroConfluent: el nombre del subject con el que se registra el esquema en Confluent Schema Registry. Obligatorio al escribir en formato AvroConfluent.
## output\_format\_avro\_rows\_in\_file
Número máximo de filas por archivo (si el almacenamiento lo permite)
## output\_format\_avro\_string\_column\_pattern
Para el formato Avro: expresión regular de las columnas String que deben seleccionarse como cadenas AVRO.
## output\_format\_avro\_sync\_interval
Intervalo de sincronización en bytes.
## output\_format\_binary\_encode\_types\_in\_binary\_format
Escribe los tipos de datos en formato binario en lugar de los nombres de tipo en el formato de salida RowBinaryWithNamesAndTypes
## output\_format\_binary\_write\_json\_as\_string
Escribe valores del tipo de dato [JSON](/es/reference/data-types/newjson) como valores JSON de tipo [String](/es/reference/data-types/string) en el formato de salida RowBinary.
## output\_format\_bson\_string\_as\_string
Utiliza el tipo String de BSON en lugar de Binary para las columnas de tipo String.
## output\_format\_compression\_level
Nivel de compresión predeterminado si la salida de la consulta está comprimida. Esta configuración se aplica cuando la consulta `SELECT` incluye `INTO OUTFILE` o al escribir en las funciones de tabla `file`, `url`, `hdfs`, `s3` o `azureBlobStorage`.
Valores posibles: de `1` a `22`
## output\_format\_compression\_zstd\_window\_log
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`).
## output\_format\_csv\_crlf\_end\_of\_line
Si se establece en `true`, el fin de línea en formato CSV será \r\n en lugar de \n.
## output\_format\_csv\_serialize\_tuple\_into\_separate\_columns
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)
## output\_format\_decimal\_trailing\_zeros
Muestra los ceros finales al imprimir valores Decimal. P. ej., 1.230000 en lugar de 1.23.
Desactivado de forma predeterminada.
## output\_format\_json\_array\_of\_rows
Habilita la salida de todas las filas como un array JSON en el formato [JSONEachRow](/es/reference/formats/JSON/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:
```sql theme={null}
SET output_format_json_array_of_rows = 1;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
```
Resultado:
```text theme={null}
[
{"number":"0"},
{"number":"1"},
{"number":"2"}
]
```
**Ejemplo de una consulta con la configuración desactivada**
Consulta:
```sql theme={null}
SET output_format_json_array_of_rows = 0;
SELECT number FROM numbers(3) FORMAT JSONEachRow;
```
Resultado:
```text theme={null}
{"number":"0"}
{"number":"1"}
{"number":"2"}
```
## output\_format\_json\_escape\_forward\_slashes
Controla el escape de las barras diagonales en la salida de cadenas en el formato de salida JSON. Está pensado para la compatibilidad con JavaScript. No lo confunda con las barras invertidas, que siempre se escapan.
Habilitado de forma predeterminada.
## output\_format\_json\_map\_as\_array\_of\_tuples
Serializa las columnas Map como arrays JSON de tuplas.
Desactivado de forma predeterminada.
## output\_format\_json\_named\_tuples\_as\_objects
Serializa las columnas de tuplas con nombre como objetos JSON.
Está habilitado de forma predeterminada.
## output\_format\_json\_pretty\_print
Esta configuración determina cómo se muestran las estructuras anidadas, como Tuples, Maps y Arrays, dentro del array `data` al usar el formato de salida JSON.
Por ejemplo, en lugar de esta salida:
```json theme={null}
"data":
[
{
"tuple": {"a":1,"b":2,"c":3},
"array": [1,2,3],
"map": {"a":1,"b":2,"c":3}
}
],
```
La salida tendrá el siguiente formato:
```json theme={null}
"data":
[
{
"tuple": {
"a": 1,
"b": 2,
"c": 3
},
"array": [
1,
2,
3
],
"map": {
"a": 1,
"b": 2,
"c": 3
}
}
],
```
Habilitado de forma predeterminada.
## output\_format\_json\_quote\_64bit\_floats
Controla si los valores [Float](/es/reference/data-types/float) de 64 bits se encierran entre comillas al generarse en formatos JSON\*.
Deshabilitado de forma predeterminada.
## output\_format\_json\_quote\_64bit\_integers
Controla si los [enteros](/es/reference/data-types/int-uint) de 64 bits o mayores (como `UInt64` o `Int128`) se encierran entre comillas cuando se generan en formato [JSON](/es/reference/formats/JSON/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.
## output\_format\_json\_quote\_decimals
Controla si los valores decimales se encierran entre comillas en los formatos de salida JSON.
Desactivado de forma predeterminada.
## output\_format\_json\_quote\_denormals
Permite la salida de `+nan`, `-nan`, `+inf` y `-inf` en el formato de salida [JSON](/es/reference/formats/JSON/JSON).
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
**Ejemplo**
Considere la siguiente tabla `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 │
└────┴────────┴──────────┴────────┴──────┘
```
Cuando `output_format_json_quote_denormals = 0`, la consulta devuelve valores `null` en la salida:
```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
}
}
```
Cuando `output_format_json_quote_denormals = 1`, la consulta devuelve:
```json theme={null}
{
"meta":
[
{
"name": "divide(area, period)",
"type": "Float64"
}
],
"data":
[
{
"divide(area, period)": "inf"
},
{
"divide(area, period)": "-nan"
},
{
"divide(area, period)": "-inf"
}
],
"rows": 3,
"statistics":
{
"elapsed": 0.000070241,
"rows_read": 3,
"bytes_read": 24
}
}
```
## output\_format\_json\_skip\_null\_value\_in\_named\_tuples
Omite los pares clave-valor con valor NULL al serializar columnas de tuplas con nombre como objetos JSON. Solo es válido cuando output\_format\_json\_named\_tuples\_as\_objects es true.
## output\_format\_json\_validate\_utf8
Controla la validación de las secuencias UTF-8 en los formatos de salida JSON; no afecta a los formatos JSON/JSONCompact/JSONColumnsWithMetadata, ya que estos siempre validan UTF-8.
Deshabilitado de forma predeterminada.
## output\_format\_markdown\_escape\_special\_characters
Cuando está habilitada, escapa los caracteres especiales de Markdown.
[Common Mark](https://spec.commonmark.org/0.30/#example-12) define los siguientes caracteres especiales que pueden escaparse mediante :
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Valores posibles:
* 0 — Desactivar.
* 1 — Activar.
## output\_format\_msgpack\_uuid\_representation
Cómo se representa UUID en formato MsgPack.
## output\_format\_native\_encode\_types\_in\_binary\_format
Escribe tipos de datos en formato binario en lugar de nombres de tipos en el formato de salida Native
## output\_format\_native\_use\_flattened\_dynamic\_and\_json\_serialization
Escribe los datos de las columnas [JSON](/es/reference/data-types/newjson) y [Dynamic](/es/reference/data-types/dynamic) en formato aplanado (todos los tipos y rutas como subcolumnas independientes).
## output\_format\_native\_write\_json\_as\_string
Escribe los datos de la columna [JSON](/es/reference/data-types/newjson) como una columna [String](/es/reference/data-types/string) que contiene cadenas JSON, en lugar de usar la serialización JSON nativa predeterminada.
## output\_format\_orc\_compression\_block\_size
El tamaño, en bytes, del bloque de compresión para el formato de salida ORC.
## output\_format\_orc\_compression\_method
Método de compresión para el formato de salida ORC. Códecs compatibles: lz4, snappy, zlib, zstd, none (sin comprimir)
## output\_format\_orc\_dictionary\_key\_size\_threshold
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
## output\_format\_orc\_row\_index\_stride
Paso objetivo del índice de filas en el formato de salida ORC
## output\_format\_orc\_string\_as\_string
Usa el tipo String de ORC en lugar de Binary para las columnas String
## output\_format\_orc\_writer\_time\_zone\_name
El nombre de la zona horaria del escritor de ORC; la zona horaria predeterminada del escritor de ORC es GMT.
## output\_format\_parallel\_formatting
Habilita o deshabilita el formateo paralelo en los formatos de datos. Solo es compatible con los formatos [TSV](/es/reference/formats/TabSeparated/TabSeparated), [TSKV](/es/reference/formats/TabSeparated/TSKV), [CSV](/es/reference/formats/CSV/CSV) y [JSONEachRow](/es/reference/formats/JSON/JSONEachRow).
Valores posibles:
* 1 — Habilitado.
* 0 — Deshabilitado.
## output\_format\_parquet\_batch\_size
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.
## output\_format\_parquet\_bloom\_filter\_bits\_per\_value
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%
## output\_format\_parquet\_bloom\_filter\_flush\_threshold\_bytes
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.
## output\_format\_parquet\_compression\_method
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
Tamaño de página objetivo en bytes, antes de la compresión.
## output\_format\_parquet\_date\_as\_uint16
Escribe los valores Date como números simples de 16 bits (se vuelven a leer como UInt16), en lugar de convertirlos a un tipo DATE de Parquet de 32 bits (se vuelve a leer como Date32).
## output\_format\_parquet\_datetime\_as\_uint32
Escribe los valores DateTime como una marca temporal Unix sin convertir (se leen de nuevo como UInt32), en lugar de convertirlos a milisegundos (se leen de nuevo como DateTime64(3)).
## output\_format\_parquet\_enum\_as\_byte\_array
Escribe enum con el tipo físico de Parquet: BYTE\_ARRAY y el tipo lógico: ENUM
## output\_format\_parquet\_fixed\_string\_as\_fixed\_byte\_array
Utiliza el tipo Parquet FIXED\_LEN\_BYTE\_ARRAY en lugar de Binary para las columnas FixedString.
## output\_format\_parquet\_geometadata
Permite escribir información sobre las columnas geoespaciales en los metadatos de Parquet y codificar las columnas en formato WKB.
## output\_format\_parquet\_max\_dictionary\_size
Si el tamaño del diccionario supera esta cantidad de bytes, se cambia a una codificación sin diccionario. Establézcalo en 0 para desactivar la codificación por diccionario.
## output\_format\_parquet\_parallel\_encoding
Realiza la codificación de Parquet en varios hilos.
## output\_format\_parquet\_row\_group\_size
Tamaño objetivo del grupo de filas, en número de filas.
## output\_format\_parquet\_row\_group\_size\_bytes
Tamaño objetivo del grupo de filas en bytes, antes de la compresión.
## output\_format\_parquet\_string\_as\_string
Use el tipo String de Parquet en lugar de Binary para las columnas String.
## output\_format\_parquet\_write\_bloom\_filter
Escribe filtros bloom en archivos Parquet.
## output\_format\_parquet\_write\_checksums
Escribe sumas de comprobación CRC32 en los encabezados de página de Parquet.
## output\_format\_parquet\_write\_page\_index
Escribe el índice de columna y el índice de offsets (es decir, estadísticas sobre cada página de datos, que pueden usarse para el pushdown de filtros durante la lectura) en archivos parquet.
## output\_format\_pretty\_color
Usa secuencias de escape ANSI en los formatos Pretty. 0 - desactivado, 1 - activado, 'auto' - activado si la salida es una terminal.
## output\_format\_pretty\_display\_footer\_column\_names
Muestra los nombres de las columnas en el pie si hay muchas filas en la tabla.
Valores posibles:
* 0 — No se muestran los nombres de las columnas en el pie.
* 1 — Los nombres de las columnas se muestran en el pie si el número de filas es mayor o igual que el valor de umbral establecido por [output\_format\_pretty\_display\_footer\_column\_names\_min\_rows](#output_format_pretty_display_footer_column_names_min_rows) (50 de forma predeterminada).
**Ejemplo**
Consulta:
```sql theme={null}
SELECT *, toTypeName(*) FROM (SELECT * FROM system.numbers LIMIT 1000);
```
Resultado:
```response theme={null}
┌─number─┬─toTypeName(number)─┐
1. │ 0 │ UInt64 │
2. │ 1 │ UInt64 │
3. │ 2 │ UInt64 │
...
999. │ 998 │ UInt64 │
1000. │ 999 │ UInt64 │
└─number─┴─toTypeName(number)─┘
```
## output\_format\_pretty\_display\_footer\_column\_names\_min\_rows
Establece el número mínimo de filas a partir del cual se mostrará un pie con los nombres de las columnas si el ajuste [output\_format\_pretty\_display\_footer\_column\_names](#output_format_pretty_display_footer_column_names) está habilitado.
## output\_format\_pretty\_fallback\_to\_vertical
Si está habilitada y la tabla es ancha pero corta, el formato Pretty la mostrará igual que el formato Vertical.
Consulta `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.
## output\_format\_pretty\_fallback\_to\_vertical\_max\_rows\_per\_chunk
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.
## output\_format\_pretty\_fallback\_to\_vertical\_min\_columns
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.
## output\_format\_pretty\_fallback\_to\_vertical\_min\_table\_width
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.
## output\_format\_pretty\_glue\_chunks
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.
## output\_format\_pretty\_grid\_charset
Juego de caracteres para imprimir los bordes de la cuadrícula. Juegos de caracteres disponibles: ASCII, UTF-8 (predeterminado).
## output\_format\_pretty\_highlight\_digit\_groups
Si está habilitado y la salida se muestra en un terminal, resalta con subrayado cada dígito correspondiente a los miles, millones, etc.
## output\_format\_pretty\_highlight\_trailing\_spaces
Si está habilitada y la salida es un terminal, resalta los espacios finales en gris y con subrayado.
## output\_format\_pretty\_max\_column\_name\_width\_cut\_to
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`.
## 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`.
## output\_format\_pretty\_max\_column\_pad\_width
Ancho máximo de relleno para todos los valores de una columna en los formatos Pretty.
## output\_format\_pretty\_max\_rows
Límite de filas para los formatos Pretty.
## output\_format\_pretty\_max\_value\_width
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.
## output\_format\_pretty\_max\_value\_width\_apply\_for\_single\_value
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`.
## output\_format\_pretty\_multiline\_fields
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).
## output\_format\_pretty\_named\_tuples\_as\_json
Controla si las tuplas con nombre en formato Pretty se muestran como objetos JSON con formato legible.
## output\_format\_pretty\_row\_numbers
Agrega números de fila antes de cada fila en el formato de salida Pretty
## output\_format\_pretty\_single\_large\_number\_tip\_threshold
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)
## output\_format\_pretty\_squash\_consecutive\_ms
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.
## output\_format\_pretty\_squash\_max\_wait\_ms
Emite el bloque pendiente en formatos Pretty si ha transcurrido más del número especificado de milisegundos desde la salida anterior.
## output\_format\_protobuf\_nullables\_with\_google\_wrappers
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
## output\_format\_schema
La ruta del archivo en el que se guardará el esquema generado automáticamente en los formatos [Cap'n Proto](/es/reference/formats/CapnProto) o [Protobuf](/es/reference/formats/Protobuf/Protobuf).
## output\_format\_sql\_insert\_include\_column\_names
Incluir los nombres de las columnas en la consulta INSERT
## output\_format\_sql\_insert\_max\_batch\_size
El número máximo de filas en una sola instrucción INSERT.
## output\_format\_sql\_insert\_quote\_names
Poner entre comillas los nombres de las columnas con el carácter '\`'
## output\_format\_sql\_insert\_table\_name
El nombre de la tabla en la consulta INSERT de salida
## output\_format\_sql\_insert\_use\_replace
Usa la instrucción REPLACE en lugar de INSERT
## output\_format\_trim\_fixed\_string
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`.
## output\_format\_tsv\_crlf\_end\_of\_line
Si se establece en verdadero, el final de línea en formato TSV será \r\n en lugar de \n.
## output\_format\_values\_escape\_quote\_with\_quote
Si es verdadero, se escapa ' como '', de lo contrario, se entrecomilla con \\'
## output\_format\_write\_statistics
Escribe estadísticas sobre las filas leídas, los bytes y el tiempo transcurrido en los formatos de salida adecuados.
Habilitado de forma predeterminada
## precise\_float\_parsing
Usar un algoritmo de análisis de números de coma flotante más preciso (pero más lento)
## schema\_inference\_hints
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:
```sql theme={null}
desc format(JSONEachRow, '{"x" : 1, "y" : "String", "z" : "0.0.0.0" }') settings schema_inference_hints='x UInt8, z IPv4';
```
Resultado:
```sql theme={null}
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
Controla si los tipos inferidos se convierten en `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
Controla si los tipos JSON inferidos se convierten en `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`.
## schema\_inference\_mode
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
Configura la regla de entrecomillado de los identificadores en la consulta SHOW CREATE
## show\_create\_query\_identifier\_quoting\_style
Establece el estilo de entrecomillado de los identificadores en la consulta SHOW CREATE
## type\_json\_allow\_duplicated\_key\_with\_literal\_and\_nested\_object
Cuando está habilitada, se permite analizar JSON como `{"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
Cuando está habilitado, durante el análisis de un objeto JSON en el tipo JSON, se ignorarán las rutas duplicadas y solo se insertará la primera, en lugar de generar una excepción
## type\_json\_skip\_invalid\_typed\_paths
Cuando está habilitada, los campos con valores que no pueden convertirse al tipo declarado se omiten, en lugar de generar un error, en las columnas de tipo JSON con rutas tipadas. Los campos omitidos se tratan como ausentes y usarán valores predeterminados o NULL según la definición de la ruta tipada.
Esta configuración solo se aplica a columnas de tipo JSON (p. ej., JSON(a Int64, b String)) en las que rutas específicas tienen tipos declarados. No se aplica a formatos de entrada JSON normales, como JSONEachRow, al insertar en columnas tipadas normales.
Valores posibles:
* 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
Cuando está habilitado, durante el análisis de un objeto JSON en el tipo JSON, las expresiones regulares especificadas mediante SKIP REGEXP requerirán una coincidencia parcial para omitir una ruta. Cuando está deshabilitado, se requerirá una coincidencia completa.
## validate\_experimental\_and\_suspicious\_types\_inside\_nested\_types
Valida el uso de tipos experimentales y sospechosos dentro de tipos anidados como Array/Map/Tuple