const)` antes del análisis de índices, de modo que puedan usarse la clave primaria por columna y los skip indexes de cada `a_i`. Se admiten formas con constantes parciales como `coalesce(a, 42, b)` y `coalesce(a, b, 42)`: la lista de argumentos se normaliza igual que el propio `coalesce` (se eliminan los literales `NULL` y se descartan los argumentos posteriores al primero que no sea `Nullable`) y, si existe, una constante final distinta de `NULL` se emite como la rama final. La reescritura es estrictamente aditiva para la poda de índices; el filtrado en tiempo de ejecución sigue usando el predicado original.
## allow\_materialized\_view\_with\_bad\_select
Permite CREATE MATERIALIZED VIEW con una consulta SELECT que haga referencia a tablas o columnas inexistentes. Aun así, debe ser sintácticamente válida. No se aplica a las MV actualizables. Tampoco se aplica si el esquema de la MV debe inferirse a partir de la consulta SELECT (es decir, si CREATE no tiene lista de columnas ni tabla TO). Puede usarse para crear una MV antes de su tabla de origen.
## allow\_named\_collection\_override\_by\_default
Permite de forma predeterminada la sobrescritura de los campos de las colecciones con nombre.
## allow\_non\_metadata\_alters
Permite ejecutar sentencias ALTER que afectan no solo a los metadatos de las tablas, sino también a los datos en disco
## allow\_nonconst\_timezone\_arguments
Permite argumentos de zona horaria no constantes en determinadas funciones relacionadas con el tiempo, como toTimeZone(), fromUnixTimestamp\*(), snowflakeToDateTime\*().
Esta configuración existe únicamente por motivos de compatibilidad. En ClickHouse, la zona horaria es una propiedad del tipo de dato y, por tanto, de la columna.
Habilitar esta configuración da la impresión errónea de que distintos valores dentro de una columna pueden tener distintas zonas horarias.
Por lo tanto, no habilite esta configuración.
## allow\_nondeterministic\_mutations
Configuración a nivel de usuario que permite que las mutaciones en tablas replicadas utilicen funciones no deterministas como `dictGet`.
Dado que, por ejemplo, los diccionarios pueden estar desincronizados entre nodos, las mutaciones que extraen valores de ellos no están permitidas en tablas replicadas de forma predeterminada. Al habilitar esta configuración, se permite este comportamiento, por lo que es responsabilidad del usuario garantizar que los datos utilizados estén sincronizados en todos los nodos.
**Ejemplo**
```xml theme={null}
1
```
## allow\_nondeterministic\_optimize\_skip\_unused\_shards
Permite usar funciones no deterministas (como `rand` o `dictGet`, ya que esta última tiene algunas particularidades con las actualizaciones) en la clave de segmentación.
Valores posibles:
* 0 — No permitido.
* 1 — Permitido.
## allow\_nullable\_tuple\_in\_extracted\_subcolumns
Controla si las subcolumnas extraídas de tipo `Tuple(...)` pueden tener el tipo `Nullable(Tuple(...))`.
* `false`: Devuelve `Tuple(...)` y usa los valores de tupla predeterminados para las filas en las que falta la subcolumna.
* `true`: Devuelve `Nullable(Tuple(...))` y usa `NULL` para las filas en las que falta la subcolumna.
Esta configuración solo controla el comportamiento de las subcolumnas extraídas.
No controla si se pueden crear columnas `Nullable(Tuple(...))` en tablas; eso se controla con `allow_experimental_nullable_tuple_type`.
ClickHouse usa el valor de esta configuración cargado al iniciar el servidor.
Los cambios realizados con `SET` o `SETTINGS` a nivel de consulta no modifican el comportamiento de las subcolumnas extraídas.
Para cambiar el comportamiento de las subcolumnas extraídas, actualice `allow_nullable_tuple_in_extracted_subcolumns` en la configuración del perfil de inicio (por ejemplo, users.xml) y reinicie el servidor.
## allow\_prefetched\_read\_pool\_for\_local\_filesystem
Usa preferentemente el threadpool de prelectura si todas las partes están en el sistema de archivos local
## allow\_prefetched\_read\_pool\_for\_remote\_filesystem
Preferir el pool de hilos con lectura anticipada si todas las partes están en un sistema de archivos remoto
## allow\_push\_predicate\_ast\_for\_distributed\_subqueries
Permite aplicar push predicate a nivel de AST en subconsultas distribuidas con el analizador habilitado
## allow\_push\_predicate\_when\_subquery\_contains\_with
Permite aplicar push predicate cuando la subconsulta contiene una cláusula WITH
## allow\_rank\_dense\_rank\_arguments
Permite pasar argumentos a las funciones de ventana `RANK` y `DENSE_RANK` para mantener la compatibilidad con versiones anteriores.
Según el estándar SQL, `RANK` y `DENSE_RANK` no aceptan argumentos: clasifican las filas únicamente en función de la ventana
`OVER (ORDER BY ...)`. En las versiones de ClickHouse anteriores a la 26.5, consultas como
`RANK(x) OVER (...)` aceptaban e ignoraban silenciosamente el argumento, lo que generaba confusión entre los usuarios
(el argumento visible sugería que influía en la clasificación, pero no era así).
Cuando esta configuración es `false` (el valor predeterminado), `RANK` y `DENSE_RANK` rechazan cualquier argumento y
generan `NUMBER_OF_ARGUMENTS_DOESNT_MATCH`. Cuando se establece en `true`, se restaura el comportamiento heredado permisivo:
los argumentos se ignoran silenciosamente, igual que antes de la versión 26.5.
## allow\_reorder\_prewhere\_conditions
Permite reordenar las condiciones al moverlas de WHERE a PREWHERE para optimizar el filtrado
## allow\_settings\_after\_format\_in\_insert
Controla si se permite o no `SETTINGS` después de `FORMAT` en consultas `INSERT`. No se recomienda usar esta opción, ya que puede interpretar parte de `SETTINGS` como valores.
Ejemplo:
```sql theme={null}
INSERT INTO FUNCTION null('foo String') SETTINGS max_threads=1 VALUES ('bar');
```
Pero la siguiente consulta solo funcionará con `allow_settings_after_format_in_insert`:
```sql theme={null}
SET allow_settings_after_format_in_insert=1;
INSERT INTO FUNCTION null('foo String') VALUES ('bar') SETTINGS max_threads=1;
```
Valores posibles:
* 0 — No se permite.
* 1 — Se permite.
Use esta configuración solo por compatibilidad con versiones anteriores si sus casos de uso dependen de la sintaxis anterior.
## allow\_simdjson
Permite utilizar la biblioteca simdjson en las funciones 'JSON\*' si las instrucciones AVX2 están disponibles. Si se desactiva, se utilizará rapidjson.
## allow\_special\_serialization\_kinds\_in\_output\_formats
Permite generar la salida de columnas con tipos especiales de serialización, como Sparse y Replicated, sin convertirlas en una representación de columna completa.
Ayuda a evitar copias de datos innecesarias durante el formateo.
## allow\_statistics
**Alias**: `allow_experimental_statistics`
Permite definir columnas con [estadísticas](/es/reference/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-creating-a-table) y [gestionar las estadísticas](/es/reference/engines/table-engines/mergetree-family/mergetree#column-statistics).
## allow\_statistics\_optimize
**Alias**: `allow_statistic_optimize`
Permite utilizar estadísticas para optimizar consultas
## allow\_suspicious\_codecs
Si se establece en true, se permite especificar códecs de compresión sin sentido.
## allow\_suspicious\_fixed\_string\_types
En la instrucción CREATE TABLE, permite crear columnas de tipo FixedString(n) con n > 256. Un FixedString con longitud >= 256 es sospechoso y muy probablemente indica un uso incorrecto
## allow\_suspicious\_indices
Rechaza índices primarios/secundarios y claves de ordenación con expresiones idénticas
## allow\_suspicious\_low\_cardinality\_types
Permite o restringe el uso de [LowCardinality](/es/reference/data-types/lowcardinality) con tipos de datos de tamaño fijo de 8 bytes o menos: tipos de datos numéricos y `FixedString(8_bytes_or_less)`.
En valores fijos pequeños, el uso de `LowCardinality` suele ser ineficiente, porque ClickHouse almacena un índice numérico para cada fila. Como resultado:
* El uso de espacio en disco puede aumentar.
* El consumo de RAM puede ser mayor, según el tamaño del diccionario.
* Algunas funciones pueden ejecutarse más lentamente debido a operaciones adicionales de codificación/decodificación.
Los tiempos de merge en tablas con motor [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree) pueden aumentar por todas las razones descritas anteriormente.
Posibles valores:
* 1 — El uso de `LowCardinality` no está restringido.
* 0 — El uso de `LowCardinality` está restringido.
## allow\_suspicious\_primary\_key
Permite `PRIMARY KEY`/`ORDER BY` sospechosos en MergeTree (es decir, SimpleAggregateFunction).
## allow\_suspicious\_ttl\_expressions
Rechaza las expresiones TTL que no dependen de ninguna columna de la tabla. La mayoría de las veces, esto indica un error del usuario.
## allow\_suspicious\_types\_in\_group\_by
Permite o restringe el uso de los tipos [Variant](/es/reference/data-types/variant) y [Dynamic](/es/reference/data-types/dynamic) en las claves de GROUP BY.
## allow\_suspicious\_types\_in\_order\_by
Permite o restringe el uso de los tipos [Variant](/es/reference/data-types/variant) y [Dynamic](/es/reference/data-types/dynamic) en las claves ORDER BY.
## allow\_suspicious\_variant\_types
En la instrucción CREATE TABLE, permite especificar el tipo Variant con tipos de variante similares (por ejemplo, distintos tipos numéricos o de fecha). Habilitar esta configuración puede introducir cierta ambigüedad al trabajar con valores de tipos similares.
## allow\_unrestricted\_reads\_from\_keeper
Permite lecturas sin restricciones (sin condición en la ruta) desde la tabla system.zookeeper; puede ser útil, pero no es seguro para ZooKeeper
## alter\_move\_to\_space\_execute\_async
Ejecuta ALTER TABLE MOVE ... TO \[DISK|VOLUME] de forma asíncrona
## alter\_partition\_verbose\_result
Habilita o deshabilita la visualización de información sobre las partes a las que se han aplicado correctamente las operaciones de manipulación de particiones y partes.
Se aplica a [ATTACH PARTITION|PART](/es/reference/statements/alter/partition#attach-partitionpart) y a [FREEZE PARTITION](/es/reference/statements/alter/partition#freeze-partition).
Valores posibles:
* 0 — deshabilita el nivel de detalle.
* 1 — habilita el nivel de detalle.
**Ejemplo**
```sql theme={null}
CREATE TABLE test(a Int64, d Date, s String) ENGINE = MergeTree PARTITION BY toYYYYMDECLARE(d) ORDER BY a;
INSERT INTO test VALUES(1, '2021-01-01', '');
INSERT INTO test VALUES(1, '2021-01-01', '');
ALTER TABLE test DETACH PARTITION ID '202101';
ALTER TABLE test ATTACH PARTITION ID '202101' SETTINGS alter_partition_verbose_result = 1;
┌─command_type─────┬─partition_id─┬─part_name────┬─old_part_name─┐
│ ATTACH PARTITION │ 202101 │ 202101_7_7_0 │ 202101_5_5_0 │
│ ATTACH PARTITION │ 202101 │ 202101_8_8_0 │ 202101_6_6_0 │
└──────────────────┴──────────────┴──────────────┴───────────────┘
ALTER TABLE test FREEZE SETTINGS alter_partition_verbose_result = 1;
┌─command_type─┬─partition_id─┬─part_name────┬─backup_name─┬─backup_path───────────────────┬─part_backup_path────────────────────────────────────────────┐
│ FREEZE ALL │ 202101 │ 202101_7_7_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_7_7_0 │
│ FREEZE ALL │ 202101 │ 202101_8_8_0 │ 8 │ /var/lib/clickhouse/shadow/8/ │ /var/lib/clickhouse/shadow/8/data/default/test/202101_8_8_0 │
└──────────────┴──────────────┴──────────────┴─────────────┴───────────────────────────────┴─────────────────────────────────────────────────────────────┘
```
## alter\_sync
**Alias**: `replication_alter_partitions_sync`
Permite especificar el comportamiento de espera para las acciones que deben ejecutarse en las réplicas mediante consultas [`ALTER`](/es/reference/statements/alter), [`OPTIMIZE`](/es/reference/statements/optimize) o [`TRUNCATE`](/es/reference/statements/truncate).
Valores posibles:
* `0` — No esperar.
* `1` — Esperar la ejecución propia.
* `2` — Esperar a todos.
* `3` - Esperar solo a las réplicas activas.
Valor predeterminado de Cloud: `0`.
`alter_sync` se aplica solo a tablas `Replicated` y `SharedMergeTree`; no tiene efecto al alterar tablas que no sean `Replicated` ni `Shared`.
## alter\_update\_mode
Modo para las consultas `ALTER` que incluyen comandos `UPDATE`.
Valores posibles:
* `heavy` - ejecuta una mutación normal.
* `lightweight` - ejecuta una actualización ligera si es posible; de lo contrario, ejecuta una mutación normal.
* `lightweight_force` - ejecuta una actualización ligera si es posible; de lo contrario, lanza una excepción.
## analyze\_index\_with\_space\_filling\_curves
Si una tabla tiene una curva de relleno espacial en su índice, p. ej., `ORDER BY mortonEncode(x, y)` o `ORDER BY hilbertEncode(x, y)`, y la consulta incluye condiciones sobre sus argumentos, p. ej., `x >= 10 AND x <= 20 AND y >= 20 AND y <= 30`, utilice la curva de relleno espacial para el análisis del índice.
## analyzer\_compatibility\_allow\_compound\_identifiers\_in\_unflatten\_nested
Permite añadir identificadores compuestos a nested. Esta es una configuración de compatibilidad porque cambia el resultado de la consulta. Cuando está deshabilitada, `SELECT a.b.c FROM table ARRAY JOIN a` no funciona, y `SELECT a FROM table` no incluye la columna `a.b.c` en el resultado de `Nested a`.
## analyzer\_compatibility\_join\_using\_top\_level\_identifier
Forzar la resolución del identificador en JOIN USING a partir de la proyección (por ejemplo, en `SELECT a + 1 AS b FROM t1 JOIN t2 USING (b)` el join se realizará mediante `t1.a + 1 = t2.b`, en lugar de `t1.b = t2.b`).
## analyzer\_inline\_views
Cuando está habilitado, el analizador sustituye las vistas ordinarias (no materializadas y no parametrizadas) por las subconsultas que las definen, lo que permite optimizaciones que abarcan esos límites, como el pushdown de predicados y la poda de columnas.
## any\_join\_distinct\_right\_table\_keys
Habilita el comportamiento heredado del servidor de ClickHouse en las operaciones `ANY INNER|LEFT JOIN`.
Use esta configuración solo por compatibilidad con versiones anteriores si sus casos de uso dependen del comportamiento heredado de `JOIN`.
Cuando el comportamiento heredado está habilitado:
* Los resultados de las operaciones `t1 ANY LEFT JOIN t2` y `t2 ANY RIGHT JOIN t1` no son iguales porque ClickHouse usa una lógica con una correspondencia de claves entre tablas, de izquierda a derecha, de muchos a uno.
* Los resultados de las operaciones `ANY INNER JOIN` contienen todas las filas de la tabla izquierda, igual que las operaciones `SEMI LEFT JOIN`.
Cuando el comportamiento heredado está deshabilitado:
* Los resultados de las operaciones `t1 ANY LEFT JOIN t2` y `t2 ANY RIGHT JOIN t1` son iguales porque ClickHouse usa una lógica que proporciona una correspondencia de claves de uno a muchos en las operaciones `ANY RIGHT JOIN`.
* Los resultados de las operaciones `ANY INNER JOIN` contienen una fila por clave de las tablas izquierda y derecha.
Valores posibles:
* 0 — El comportamiento heredado está deshabilitado.
* 1 — El comportamiento heredado está habilitado.
Véase también:
* [JOIN strictness](/es/reference/statements/select/join#settings)
## apply\_deleted\_mask
Habilita el filtrado de las filas eliminadas con eliminación ligera. Si se desactiva, una consulta podrá leer esas filas. Esto resulta útil para escenarios de depuración y de recuperación de filas eliminadas
## apply\_mutations\_on\_fly
Si es true, las mutaciones (UPDATE y DELETE) que no están materializadas en la data part se aplicarán en las consultas SELECT.
## apply\_patch\_parts
Si es true, las patch parts (que representan actualizaciones ligeras) se aplican en las consultas SELECT.
## apply\_patch\_parts\_join\_cache\_buckets
El número de buckets de la caché temporal para aplicar partes de parche en modo Join.
## apply\_prewhere\_after\_final
Cuando se habilita, las condiciones PREWHERE se aplican después del procesamiento FINAL en ReplacingMergeTree y motores similares.
Esto puede resultar útil cuando PREWHERE hace referencia a columnas que pueden tener valores distintos entre filas duplicadas
y quiere que FINAL seleccione la fila que prevalece antes de filtrar. Cuando está deshabilitada, PREWHERE se aplica durante la lectura.
Nota: Si apply\_row\_level\_security\_after\_final está habilitada y la política de filas usa columnas que no forman parte de la clave de ordenación, PREWHERE también
se pospondrá para mantener el orden de ejecución correcto (la política de filas debe aplicarse antes de PREWHERE).
## apply\_row\_policy\_after\_final
Cuando está habilitado, las políticas de fila y PREWHERE se aplican después del procesamiento FINAL en tablas \*MergeTree. (Especialmente en ReplacingMergeTree)
Cuando está deshabilitado, las políticas de fila se aplican antes de FINAL, lo que puede producir resultados diferentes cuando la política
filtra filas que deberían usarse para la deduplicación en ReplacingMergeTree o motores similares.
Si la expresión de la política de fila depende solo de columnas de ORDER BY, seguirá aplicándose antes de FINAL como optimización,
ya que ese filtrado no puede afectar al resultado de la deduplicación.
Valores posibles:
* 0 — La política de fila y PREWHERE se aplican antes de FINAL (predeterminado).
* 1 — La política de fila y PREWHERE se aplican después de FINAL.
## apply\_settings\_from\_server
Indica si el cliente debe aceptar la configuración del servidor.
Esto solo afecta a las operaciones realizadas del lado del cliente, en particular el análisis de los datos de entrada de INSERT y el formateo del resultado de la consulta. La mayor parte de la ejecución de la consulta ocurre en el servidor y no se ve afectada por esta configuración.
Normalmente, esta configuración debe establecerse en el perfil de usuario (`users.xml` o consultas como `ALTER USER`), no a través del cliente (argumentos de la línea de comandos del cliente, consulta `SET` o sección `SETTINGS` de la consulta `SELECT`). A través del cliente puede cambiarse a false, pero no puede cambiarse a true (porque el servidor no enviará la configuración si el perfil de usuario tiene `apply_settings_from_server = false`).
Tenga en cuenta que, inicialmente (24.12), existía una configuración de servidor (`send_settings_to_client`), pero más tarde fue reemplazada por esta configuración de cliente para mejorar la usabilidad.
## archive\_adaptive\_buffer\_max\_size\_bytes
Limita el tamaño máximo del búfer adaptativo utilizado al escribir en archivos de archivado (por ejemplo, archivos tar
## arrow\_flight\_request\_descriptor\_type
Tipo de descriptor que se utiliza para las solicitudes de Arrow Flight. 'path' envía el nombre del conjunto de datos como descriptor de ruta. 'command' envía una consulta SQL como descriptor de comando (obligatorio para Dremio).
Valores posibles:
* 'path' — Usa FlightDescriptor::Path (predeterminado; funciona con la mayoría de los servidores Arrow Flight)
* 'command' — Usa FlightDescriptor::Command con una consulta SELECT (obligatorio para Dremio)
## ast\_fuzzer\_any\_query
Si es false (valor predeterminado), el AST fuzzer del servidor (controlado por `ast_fuzzer_runs`) solo aplica fuzzing a consultas de solo lectura (SELECT, EXPLAIN, SHOW, DESCRIBE, EXISTS). Si es true, se aplica fuzzing a todos los tipos de consultas, incluidas DDL e INSERT.
## ast\_fuzzer\_runs
Habilita el AST fuzzer del servidor, que ejecuta consultas aleatorias después de cada consulta normal y descarta sus resultados.
* 0: deshabilitado (predeterminado).
* Un valor entre 0 y 1 (sin incluirlos): probabilidad de ejecutar una sola consulta generada por el fuzzer.
* Un valor >= 1: número de consultas generadas por el fuzzer que se ejecutarán por cada consulta normal.
El fuzzer acumula fragmentos de AST de todas las consultas de todas las sesiones, lo que produce mutaciones cada vez más interesantes con el tiempo. Las consultas generadas por el fuzzer que fallan se descartan silenciosamente; los resultados nunca se devuelven al cliente.
## asterisk\_include\_alias\_columns
Incluye las columnas [ALIAS](/es/reference/statements/create/table#alias) en las consultas con comodín (`SELECT *`).
Valores posibles:
* 0 - deshabilitado
* 1 - habilitado
## asterisk\_include\_materialized\_columns
Incluye columnas [MATERIALIZED](/es/reference/statements/create/view#materialized-view) en consultas con comodín (`SELECT *`).
Posibles valores:
* 0 - deshabilitado
* 1 - habilitado
## asterisk\_include\_virtual\_columns
Incluye las columnas virtuales en la consulta con comodín (`SELECT *`).
Posibles valores:
* 0 - deshabilitado
* 1 - habilitado
## async\_insert
Si es true, los datos de la consulta INSERT se almacenan en una cola y más tarde se escriben en la tabla en segundo plano. Si wait\_for\_async\_insert es false, la consulta INSERT se procesa casi al instante; de lo contrario, el cliente esperará hasta que los datos se escriban en la tabla
## async\_insert\_busy\_timeout\_decrease\_rate
La tasa de crecimiento exponencial con la que se reduce el tiempo de espera de inserción asíncrona adaptativo
## async\_insert\_busy\_timeout\_increase\_rate
La tasa de crecimiento exponencial a la que aumenta el tiempo de espera adaptativo de inserción asíncrona
## async\_insert\_busy\_timeout\_max\_ms
**Alias**: `async_insert_busy_timeout_ms`
Tiempo máximo de espera antes de volcar los datos recopilados por consulta desde que apareció el primer dato.
Valor predeterminado de Cloud: `1000` (1s).
## async\_insert\_busy\_timeout\_min\_ms
Si el ajuste automático está habilitado mediante async\_insert\_use\_adaptive\_busy\_timeout, es el tiempo mínimo de espera antes de volcar los datos recopilados por consulta desde que aparecieron los primeros datos. También sirve como valor inicial para el algoritmo adaptativo
## async\_insert\_deduplicate
Para las consultas INSERT asíncronas en la tabla replicada, especifica que debe realizarse la deduplicación de los bloques que se insertan
## async\_insert\_max\_data\_size
Tamaño máximo, en bytes, de los datos sin analizar recopilados por consulta antes de insertarse
Valor predeterminado de Cloud: `104857600` (100 MiB).
## async\_insert\_max\_query\_number
Número máximo de consultas de inserción antes de que se realice la inserción.
Solo surte efecto si la configuración [`async_insert_deduplicate`](#async_insert_deduplicate) es 1.
## async\_insert\_poll\_timeout\_ms
Tiempo de espera para recuperar datos de la cola de inserción asíncrona
## async\_insert\_use\_adaptive\_busy\_timeout
Si se establece en true, usa un timeout adaptativo por ocupación para las inserciones asíncronas
## async\_query\_sending\_for\_remote
Habilita la creación asíncrona de conexiones y el envío de la consulta mientras se ejecuta una consulta remota.
Habilitado de forma predeterminada.
## async\_socket\_for\_remote
Habilita la lectura asíncrona desde el socket al ejecutar una consulta remota.
Habilitado de forma predeterminada.
## automatic\_parallel\_replicas\_min\_bytes\_per\_replica
Umbral de bytes que se deben leer por réplica para habilitar automáticamente las réplicas paralelas (solo se aplica cuando `automatic_parallel_replicas_mode`=1). 0 significa que no hay umbral.
El número total de bytes que se deben leer se estima a partir de las estadísticas recopiladas.
## automatic\_parallel\_replicas\_mode
Habilita el cambio automático a la ejecución con réplicas paralelas en función de las estadísticas recopiladas. Requiere `enable_analyzer = 1`, `enable_parallel_replicas != 0`, `parallel_replicas_local_plan = 1` y que se proporcione `cluster_for_parallel_replicas`.
0 - deshabilitado, 1 - habilitado, 2 - solo está habilitada la recopilación de estadísticas (el cambio a la ejecución con réplicas paralelas está deshabilitado).
## azure\_allow\_parallel\_part\_upload
Usa varios hilos para la carga multiparte de Azure.
## azure\_check\_objects\_after\_upload
Comprobar cada objeto cargado en Azure Blob Storage para asegurarse de que la carga se haya completado correctamente
## azure\_connect\_timeout\_ms
Tiempo de espera de conexión al host para discos de Azure.
## azure\_create\_new\_file\_on\_insert
Habilita o deshabilita la creación de un nuevo archivo en cada operación de insert en las tablas del motor Azure
## azure\_ignore\_file\_doesnt\_exist
Ignora la ausencia de un archivo si este no existe al leer ciertas claves.
Valores posibles:
* 1 — `SELECT` devuelve un resultado vacío.
* 0 — `SELECT` genera una excepción.
## azure\_list\_object\_keys\_size
Número máximo de archivos que la solicitud ListObject puede devolver en un lote
## azure\_max\_blocks\_in\_multipart\_upload
Número máximo de bloques en una carga multiparte para Azure.
## azure\_max\_get\_burst
Número máximo de solicitudes que pueden emitirse simultáneamente antes de alcanzar el límite de solicitudes por segundo. De forma predeterminada, (0) equivale a `azure_max_get_rps`
## azure\_max\_get\_rps
Límite de solicitudes GET por segundo en Azure antes de que se aplique throttling. Cero significa sin límite.
## azure\_max\_inflight\_parts\_for\_one\_file
El número máximo de partes que se pueden cargar simultáneamente en una solicitud de carga multiparte. 0 significa que no hay límite.
## azure\_max\_put\_burst
Número máximo de solicitudes que pueden emitirse simultáneamente antes de alcanzar el límite de solicitudes por segundo. De forma predeterminada, (0) equivale a `azure_max_put_rps`
## azure\_max\_put\_rps
Límite de solicitudes PUT por segundo en Azure antes de aplicar throttling. Cero significa sin límite.
## azure\_max\_redirects
Número máximo permitido de saltos de redirección de Azure.
## azure\_max\_single\_part\_copy\_size
El tamaño máximo del objeto que se puede copiar mediante una copia de una sola parte en Azure blob storage.
## azure\_max\_single\_part\_upload\_size
El tamaño máximo del objeto que se puede cargar mediante una carga de una sola parte en Azure Blob Storage.
## azure\_max\_single\_read\_retries
El número máximo de reintentos durante una sola lectura desde Azure blob storage.
## azure\_max\_unexpected\_write\_error\_retries
El número máximo de reintentos en caso de errores inesperados durante la escritura en Azure blob storage
## azure\_max\_upload\_part\_size
El tamaño máximo de la parte que se va a subir durante una subida multiparte a Azure blob storage.
## azure\_min\_upload\_part\_size
El tamaño mínimo de la parte que se va a subir durante una carga multiparte en Azure blob storage.
## azure\_request\_timeout\_ms
Tiempo de espera por inactividad para el envío y la recepción de datos desde/hacia Azure. Se produce un error si una sola llamada TCP de lectura o escritura queda bloqueada durante este tiempo.
## azure\_sdk\_max\_retries
Número máximo de reintentos del SDK de Azure
## azure\_sdk\_retry\_initial\_backoff\_ms
Espera mínima entre reintentos en Azure SDK
## azure\_sdk\_retry\_max\_backoff\_ms
Backoff máximo entre reintentos en Azure SDK
## azure\_skip\_empty\_files
Activa o desactiva la omisión de archivos vacíos en el motor S3.
Valores posibles:
* 0 — `SELECT` genera una excepción si el archivo vacío no es compatible con el formato solicitado.
* 1 — `SELECT` devuelve un resultado vacío para un archivo vacío.
## azure\_strict\_upload\_part\_size
El tamaño exacto de la parte que se va a subir durante una subida multiparte a Azure blob storage.
## azure\_throw\_on\_zero\_files\_match
Lanza un error si no coincide ningún archivo según las reglas de expansión de glob.
Valores posibles:
* 1 — `SELECT` lanza una excepción.
* 0 — `SELECT` devuelve un resultado vacío.
## azure\_truncate\_on\_insert
Activa o desactiva el truncado antes de insertar en las tablas del engine Azure.
## azure\_upload\_part\_size\_multiply\_factor
Multiplica azure\_min\_upload\_part\_size por este factor cada vez que se hayan cargado azure\_multiply\_parts\_count\_threshold partes en una única escritura en Azure blob storage.
## azure\_upload\_part\_size\_multiply\_parts\_count\_threshold
Cada vez que se cargue este número de partes en Azure blob storage, azure\_min\_upload\_part\_size se multiplica por azure\_upload\_part\_size\_multiply\_factor.
## azure\_use\_adaptive\_timeouts
Si se establece en `true`, en todas las solicitudes a Azure los dos primeros intentos se realizan con tiempos de espera de envío y recepción reducidos.
Si se establece en `false`, todos los intentos se realizan con tiempos de espera idénticos.
## backup\_restore\_batch\_size\_for\_keeper\_multi
Tamaño máximo del lote para una solicitud múltiple a \[Zoo]Keeper durante la copia de seguridad o la restauración
## backup\_restore\_batch\_size\_for\_keeper\_multiread
Tamaño máximo del lote de una solicitud de multilectura a \[Zoo]Keeper durante la copia de seguridad o la restauración
## backup\_restore\_failure\_after\_host\_disconnected\_for\_seconds
Si, durante una operación BACKUP ON CLUSTER o RESTORE ON CLUSTER, un host no vuelve a crear su nodo efímero 'alive' en ZooKeeper dentro de este intervalo, toda la copia de seguridad o restauración se considera fallida.
Este valor debe ser mayor que cualquier tiempo razonable que un host pueda tardar en volver a conectarse a ZooKeeper después de un fallo.
Cero significa sin límite.
## backup\_restore\_finish\_timeout\_after\_error\_sec
Cuánto tiempo debe esperar el iniciador para que otros hosts reaccionen al nodo 'error' y detengan su trabajo en la operación actual BACKUP ON CLUSTER o RESTORE ON CLUSTER.
## backup\_restore\_keeper\_fault\_injection\_probability
Probabilidad aproximada de fallo de una solicitud de Keeper durante una copia de seguridad o una restauración. El valor válido se encuentra en el intervalo \[0.0f, 1.0f]
## backup\_restore\_keeper\_fault\_injection\_seed
0: semilla aleatoria; en caso contrario, el valor de la configuración
## backup\_restore\_keeper\_max\_retries
Número máximo de reintentos para operaciones de \[Zoo]Keeper durante una operación BACKUP o RESTORE.
Debe ser lo bastante grande como para que toda la operación no falle debido a un fallo temporal de \[Zoo]Keeper.
## backup\_restore\_keeper\_max\_retries\_while\_handling\_error
Número máximo de reintentos para las operaciones de \[Zoo]Keeper al gestionar un error en una operación BACKUP ON CLUSTER o RESTORE ON CLUSTER.
## backup\_restore\_keeper\_max\_retries\_while\_initializing
Número máximo de reintentos para las operaciones de \[Zoo]Keeper durante la inicialización de una operación BACKUP ON CLUSTER o RESTORE ON CLUSTER.
## backup\_restore\_keeper\_retry\_initial\_backoff\_ms
Tiempo de espera del backoff inicial para las operaciones de \[Zoo]Keeper durante la copia de seguridad o la restauración
## backup\_restore\_keeper\_retry\_max\_backoff\_ms
Tiempo de espera máximo del backoff para las operaciones de \[Zoo]Keeper durante la copia de seguridad o la restauración
Valor predeterminado de Cloud: `60000`.
## backup\_restore\_keeper\_value\_max\_size
Tamaño máximo de los datos de un nodo de \[Zoo]Keeper durante la restauración de una copia de seguridad
## backup\_restore\_s3\_retry\_attempts
Configuración para Aws::Client::RetryStrategy. Aws::Client gestiona los reintentos por sí mismo; 0 significa que no habrá reintentos. Solo se aplica a la copia de seguridad/restauración.
## backup\_restore\_s3\_retry\_initial\_backoff\_ms
Retraso de backoff inicial, en milisegundos, antes del primer reintento durante la copia de seguridad y la restauración. Cada reintento posterior aumenta el retraso de forma exponencial, hasta el máximo especificado por `backup_restore_s3_retry_max_backoff_ms`
## backup\_restore\_s3\_retry\_jitter\_factor
Factor de jitter aplicado al retraso de backoff de reintento en Aws::Client::RetryStrategy durante las operaciones de copia de seguridad y restauración. El retraso de backoff calculado se multiplica por un factor aleatorio en el intervalo \[1.0, 1.0 + jitter], hasta un máximo de `backup_restore_s3_retry_max_backoff_ms`. Debe estar en el intervalo \[0.0, 1.0]
## backup\_restore\_s3\_retry\_max\_backoff\_ms
Retraso máximo, en milisegundos, entre reintentos durante las operaciones de copia de seguridad y restauración.
## backup\_slow\_all\_threads\_after\_retryable\_s3\_error
Cuando se establece en `true`, todos los hilos que ejecutan solicitudes a S3 hacia el mismo endpoint de backup se ralentizan
después de que una sola solicitud a S3 encuentre un error de S3 que permita reintentos, como 'Slow Down'.
Cuando se establece en `false`, cada hilo gestiona el backoff de las solicitudes a S3 de forma independiente de los demás.
## cache\_warmer\_threads
Solo tiene efecto en ClickHouse Cloud. Número de hilos en segundo plano para descargar de forma especulativa nuevas partes de datos en la caché del sistema de archivos cuando [cache\_populated\_by\_fetch](/es/reference/settings/merge-tree-settings#cache_populated_by_fetch) está habilitado. Cero para deshabilitarlo.
## calculate\_text\_stack\_trace
Calcula la traza de pila en texto en caso de excepciones durante la ejecución de la consulta. Este es el valor predeterminado. Requiere búsquedas de símbolos que pueden ralentizar las pruebas de fuzzing cuando se ejecuta una gran cantidad de consultas incorrectas. En condiciones normales, no debería desactivar esta opción.
## cancel\_http\_readonly\_queries\_on\_client\_close
Cancela las consultas HTTP de solo lectura (p. ej., `SELECT`) cuando el cliente cierra la conexión sin esperar la respuesta.
Valor predeterminado en Cloud: `1`.
## cast\_ipv4\_ipv6\_default\_on\_conversion\_error
Los operadores CAST a IPv4 y CAST al tipo IPv6, así como las funciones toIPv4 y toIPv6, devolverán el valor predeterminado en lugar de lanzar una excepción si se produce un error de conversión.
## cast\_keep\_nullable
Habilita o deshabilita la conservación del tipo de dato `Nullable` en las operaciones [CAST](/es/reference/functions/regular-functions/type-conversion-functions#CAST).
Cuando esta configuración está habilitada y el argumento de la función `CAST` es `Nullable`, el resultado también se convierte al tipo `Nullable`. Cuando la configuración está deshabilitada, el resultado siempre tiene exactamente el tipo de destino.
Posibles valores:
* 0 — El resultado de `CAST` tiene exactamente el tipo de destino especificado.
* 1 — Si el tipo del argumento es `Nullable`, el resultado de `CAST` se convierte en `Nullable(DestinationDataType)`.
**Ejemplos**
La siguiente consulta produce exactamente el tipo de dato de destino:
```sql theme={null}
SET cast_keep_nullable = 0;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
```
Resultado:
```text theme={null}
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Int32 │
└───┴───────────────────────────────────────────────────┘
```
La siguiente consulta produce la modificación `Nullable` en el tipo de dato de destino:
```sql theme={null}
SET cast_keep_nullable = 1;
SELECT CAST(toNullable(toInt32(0)) AS Int32) as x, toTypeName(x);
```
Resultado:
```text theme={null}
┌─x─┬─toTypeName(CAST(toNullable(toInt32(0)), 'Int32'))─┐
│ 0 │ Nullable(Int32) │
└───┴───────────────────────────────────────────────────┘
```
**Ver también**
* [CAST](/es/reference/functions/regular-functions/type-conversion-functions#CAST) función
## cast\_string\_to\_date\_time\_mode
Permite elegir un parser para la representación textual de fecha y hora al convertir desde String.
Posibles valores:
* `'best_effort'` — Habilita el análisis ampliado.
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 parser básico.
ClickHouse solo puede analizar 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`.
Vea 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)
## cast\_string\_to\_dynamic\_use\_inference
Usar la inferencia de tipos durante la conversión de String a Dynamic
## cast\_string\_to\_variant\_use\_inference
Utiliza la inferencia de tipos durante la conversión de String a Variant.
## check\_named\_collection\_dependencies
Comprueba que DROP NAMED COLLECTION no provoque fallos en las tablas que dependen de ella
## check\_query\_single\_value\_result
Define el nivel de detalle del resultado de la consulta [CHECK TABLE](/es/reference/statements/check-table) para los motores de la familia `MergeTree` .
Valores posibles:
* 0 — la consulta muestra un estado de verificación para cada parte de datos individual de una tabla.
* 1 — la consulta muestra el estado general de verificación de la tabla.
## check\_referential\_table\_dependencies
Compruebe que la consulta DDL (como DROP TABLE o RENAME) no interrumpa las dependencias referenciales
## check\_table\_dependencies
Verifica que una consulta DDL (como DROP TABLE o RENAME) no rompa las dependencias
## checksum\_on\_read
Valida las sumas de verificación durante la lectura. Está habilitada de forma predeterminada y siempre debería estarlo en producción. No espere obtener ningún beneficio al deshabilitar este ajuste. Solo puede usarse para experimentos y benchmarks. Este ajuste solo se aplica a tablas de la familia MergeTree. Las sumas de verificación siempre se validan para otros motores de tabla y al recibir datos a través de la red.
## cloud\_mode
Modo Cloud
Valor predeterminado en Cloud: `1`.
## cloud\_mode\_database\_engine
El motor de base de datos permitido en Cloud. 1 - reescribe las DDL para usar una base de datos Replicated, 2 - reescribe las DDL para usar una base de datos Shared
Valor predeterminado de Cloud: `2`.
## cloud\_mode\_engine
La familia de motores permitida en Cloud.
* 0 - permitir todo
* 1 - reescribir las DDLs para usar \*ReplicatedMergeTree
* 2 - reescribir las DDLs para usar SharedMergeTree
* 3 - reescribir las DDLs para usar SharedMergeTree, excepto cuando se especifique explícitamente un disco remoto
* 4 - igual que 3, y además usar Alias en lugar de Distributed (la tabla Alias apuntará a la tabla de destino de la tabla Distributed, por lo que usará la tabla local correspondiente)
UInt64 para minimizar la parte pública
Valor predeterminado de Cloud: `2`.
## cluster\_for\_parallel\_replicas
Clúster para un segmento en el que se encuentra el servidor actual
Valor predeterminado de Cloud: `default`.
## cluster\_function\_process\_archive\_on\_multiple\_nodes
Si se establece en `true`, mejora el rendimiento al procesar archivos comprimidos en funciones de clúster. Debe establecerse en `false` para mantener la compatibilidad y evitar errores durante la actualización a 25.7+ si se usan funciones de clúster con archivos comprimidos en versiones anteriores.
## cluster\_table\_function\_buckets\_batch\_size
Define el tamaño aproximado de un lote (en bytes) que se usa en el procesamiento distribuido de tareas en funciones de tabla de clúster con granularidad de división `bucket`. El sistema acumula datos hasta alcanzar al menos esta cantidad. El tamaño real puede ser ligeramente mayor para ajustarse a los límites de los datos.
## cluster\_table\_function\_split\_granularity
Controla cómo se dividen los datos en tareas al ejecutar una CLUSTER TABLE FUNCTION.
Esta configuración define la granularidad de la distribución del trabajo en el cluster:
* `file` — cada tarea procesa un archivo completo.
* `bucket` — las tareas se crean por cada bloque de datos interno dentro de un archivo (por ejemplo, grupos de filas de Parquet).
Elegir una granularidad más fina (como `bucket`) puede mejorar el paralelismo al trabajar con una cantidad reducida de archivos grandes.
Por ejemplo, si un archivo Parquet contiene varios grupos de filas, habilitar la granularidad `bucket` permite que cada grupo se procese de forma independiente en distintos workers.
## collect\_hash\_table\_stats\_during\_aggregation
Activa la recopilación de estadísticas de la tabla hash para optimizar la asignación de memoria
## collect\_hash\_table\_stats\_during\_joins
Activa la recopilación de estadísticas de la tabla hash para optimizar la asignación de memoria
## compatibility
La configuración `compatibility` hace que ClickHouse use la configuración predeterminada de una versión anterior de ClickHouse, indicada en este ajuste.
Si algunos ajustes tienen valores distintos de los predeterminados, esos valores se respetan (solo los ajustes que no se han modificado se ven afectados por la configuración `compatibility`).
Esta configuración acepta un número de versión de ClickHouse como cadena, por ejemplo `22.3` o `22.8`. Un valor vacío significa que esta configuración está deshabilitada.
Deshabilitada de forma predeterminada.
En ClickHouse Cloud, la configuración de compatibilidad predeterminada a nivel de servicio debe establecerla ClickHouse Cloud Support. [Abra un caso](https://clickhouse.cloud/support) para solicitarlo.
Sin embargo, la configuración `compatibility` se puede sobrescribir a nivel de usuario, rol, perfil, consulta o sesión mediante los mecanismos de configuración estándar de ClickHouse, como `SET compatibility = '22.3'` en una sesión o `SETTINGS compatibility = '22.3'` en una consulta.
## compatibility\_ignore\_auto\_increment\_in\_create\_table
Ignora la palabra clave AUTO\_INCREMENT en la declaración de la columna si es true; de lo contrario, devuelve un error. Esto simplifica la migración desde MySQL
## compatibility\_ignore\_collation\_in\_create\_table
Compatibilidad: ignorar la cotejación en CREATE TABLE
## compatibility\_s3\_presigned\_url\_query\_in\_path
Compatibilidad: cuando está habilitado, integra los parámetros de consulta de la URL prefirmada (p. ej., X-Amz-\*) en la clave de S3 (comportamiento heredado),
por lo que '?' actúa como un comodín en la ruta. Cuando está deshabilitado (valor predeterminado), los parámetros de consulta de la URL prefirmada se mantienen en la cadena de consulta de la URL
para evitar interpretar '?' como un comodín.
## compile\_aggregate\_expressions
Habilita o deshabilita la compilación JIT de las funciones de agregación en código nativo. Habilitar esta opción puede mejorar el rendimiento.
Valores posibles:
* 0 — La agregación se realiza sin compilación JIT.
* 1 — La agregación se realiza con compilación JIT.
**Vea también**
* [min\_count\_to\_compile\_aggregate\_expression](#min_count_to_compile_aggregate_expression)
## compile\_expressions
Compila algunas funciones escalares y operadores en código nativo.
## compile\_sort\_description
Compila la descripción de ordenación en código nativo.
## connect\_timeout
Tiempo de espera de conexión si no hay réplicas.
## connect\_timeout\_with\_failover\_ms
El tiempo de espera, en milisegundos, para conectarse a un servidor remoto con un motor de tabla Distributed, si se usan las secciones 'shard' y 'replica' en la definición del clúster.
Si no se logra la conexión, se realizan varios intentos para conectarse a distintas réplicas.
## connect\_timeout\_with\_failover\_secure\_ms
Tiempo de espera de conexión para seleccionar la primera réplica en buen estado (para conexiones seguras).
## connection\_pool\_max\_wait\_ms
El tiempo de espera, en milisegundos, de una conexión cuando el pool de conexiones está lleno.
Valores posibles:
* Entero positivo.
* 0 — Tiempo de espera infinito.
## connections\_with\_failover\_max\_tries
El número máximo de intentos de conexión con cada réplica para el engine de tabla Distributed.
## convert\_query\_to\_cnf
Cuando se establece en `true`, una consulta `SELECT` se convertirá en forma normal conjuntiva (CNF). En algunos casos, reescribir una consulta en CNF puede ejecutarse más rápido (consulta este [issue de GitHub](https://github.com/ClickHouse/ClickHouse/issues/11749) para obtener una explicación).
Por ejemplo, observa cómo la siguiente consulta `SELECT` no se modifica (comportamiento predeterminado):
```sql theme={null}
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = false;
```
El resultado es:
```response theme={null}
┌─explain────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ ) AS a │
│ WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15)) │
│ SETTINGS convert_query_to_cnf = 0 │
└────────────────────────────────────────────────────────────────┘
```
Establezcamos `convert_query_to_cnf` en `true` y veamos qué cambia:
```sql theme={null}
EXPLAIN SYNTAX
SELECT *
FROM
(
SELECT number AS x
FROM numbers(20)
) AS a
WHERE ((x >= 1) AND (x <= 5)) OR ((x >= 10) AND (x <= 15))
SETTINGS convert_query_to_cnf = true;
```
Observe que la cláusula `WHERE` se reescribe en CNF, pero el conjunto de resultados sigue siendo idéntico: la lógica booleana no cambia:
```response theme={null}
┌─explain───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ SELECT x │
│ FROM │
│ ( │
│ SELECT number AS x │
│ FROM numbers(20) │
│ WHERE ((x <= 15) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x >= 10) OR (x >= 1)) │
│ ) AS a │
│ WHERE ((x >= 10) OR (x >= 1)) AND ((x >= 10) OR (x <= 5)) AND ((x <= 15) OR (x >= 1)) AND ((x <= 15) OR (x <= 5)) │
│ SETTINGS convert_query_to_cnf = 1 │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Valores posibles: true, false
## correlated\_subqueries\_default\_join\_kind
Controla el tipo de JOIN del plan de consulta decorrelacionado. El valor predeterminado es `right`, lo que significa que el plan decorrelacionado contendrá RIGHT JOINs con la entrada de la subconsulta en el lado derecho.
Valores posibles:
* `left` - El proceso de decorrelación producirá LEFT JOINs y la tabla de entrada aparecerá en el lado izquierdo.
* `right` - El proceso de decorrelación producirá RIGHT JOINs y la tabla de entrada aparecerá en el lado derecho.
## correlated\_subqueries\_substitute\_equivalent\_expressions
Usa expresiones de filtro para inferir expresiones equivalentes y sustituirlas en lugar de crear un CROSS JOIN.
## correlated\_subqueries\_use\_in\_memory\_buffer
Usa un búfer en memoria para la entrada de subconsultas correlacionadas a fin de evitar su evaluación repetida.
## count\_distinct\_implementation
Especifica cuál de las funciones `uniq*` debe usarse para implementar la construcción [COUNT(DISTINCT ...)](/es/reference/functions/aggregate-functions/count).
Valores posibles:
* [uniq](/es/reference/functions/aggregate-functions/uniq)
* [uniqCombined](/es/reference/functions/aggregate-functions/uniqCombined)
* [uniqCombined64](/es/reference/functions/aggregate-functions/uniqCombined64)
* [uniqHLL12](/es/reference/functions/aggregate-functions/uniqHLL12)
* [uniqExact](/es/reference/functions/aggregate-functions/uniqExact)
## count\_distinct\_optimization
Reescribe count distinct como una subconsulta con group by
## count\_matches\_stop\_at\_empty\_match
Deja de contar cuando un patrón produce una coincidencia de longitud cero en la función `countMatches`.
## create\_if\_not\_exists
Activa `IF NOT EXISTS` para la instrucción `CREATE` de forma predeterminada. Si se especifica esta configuración o `IF NOT EXISTS`, y ya existe una tabla con el nombre indicado, no se lanzará ninguna excepción.
## create\_index\_ignore\_unique
Ignora la palabra clave UNIQUE en CREATE UNIQUE INDEX. Diseñado para pruebas de compatibilidad con SQL.
## create\_replicated\_merge\_tree\_fault\_injection\_probability
La probabilidad de que se inyecte un fallo durante la creación de la tabla después de crear los metadatos en ZooKeeper
## create\_table\_empty\_primary\_key\_by\_default
Permite crear tablas \*MergeTree con una clave primaria vacía cuando no se especifican ORDER BY ni PRIMARY KEY
## cross\_join\_min\_bytes\_to\_compress
Tamaño mínimo del bloque que se debe comprimir en CROSS JOIN. Un valor de cero significa desactivar este umbral. Este bloque se comprime cuando se alcanza cualquiera de los dos umbrales (por filas o por bytes).
## cross\_join\_min\_rows\_to\_compress
Número mínimo de filas para comprimir el bloque en CROSS JOIN. Un valor de cero significa deshabilitar este umbral. Este bloque se comprime cuando se alcanza cualquiera de los dos umbrales (por filas o por bytes).
## cross\_to\_inner\_join\_rewrite
Usa inner join en lugar de comma/cross join si hay expresiones de join en la sección WHERE. Valores: 0 - sin reescritura, 1 - aplicar si es posible para comma/cross, 2 - forzar la reescritura de todos los comma joins, cross - si es posible
## data\_type\_default\_nullable
Hace que los tipos de datos sin modificadores explícitos [NULL o NOT NULL](/es/reference/statements/create/table#null-or-not-null-modifiers) en la definición de columnas sean [Nullable](/es/reference/data-types/nullable).
Valores posibles:
* 1 — Los tipos de datos en las definiciones de columna se establecen como `Nullable` de forma predeterminada.
* 0 — Los tipos de datos en las definiciones de columna se establecen como no `Nullable` de forma predeterminada.
## database\_atomic\_wait\_for\_drop\_and\_detach\_synchronously
Añade un modificador `SYNC` a todas las consultas `DROP` y `DETACH`.
Valores posibles:
* 0 — Las consultas se ejecutarán de forma diferida.
* 1 — Las consultas se ejecutarán sin demora.
## database\_datalake\_require\_metadata\_access
Indica si se debe lanzar un error o no cuando no se tienen permisos para obtener los metadatos de la tabla en el motor de base de datos DataLakeCatalog.
## database\_replicated\_allow\_explicit\_uuid
0 - No permite especificar explícitamente UUIDs para las tablas en bases de datos Replicated. 1 - Lo permite. 2 - Lo permite, pero ignora el UUID especificado y genera uno aleatorio en su lugar.
## database\_replicated\_allow\_heavy\_create
Permite las consultas DDL de larga duración (CREATE AS SELECT y POPULATE) en el motor de base de datos Replicated. Tenga en cuenta que puede bloquear la cola DDL durante mucho tiempo.
## database\_replicated\_allow\_only\_replicated\_engine
Permite crear únicamente tablas Replicated en una base de datos con motor Replicated
Valor predeterminado de Cloud: `1`.
## database\_replicated\_allow\_replicated\_engine\_arguments
0 - No permitir especificar explícitamente la ruta de ZooKeeper ni el nombre de la réplica para las tablas \*MergeTree en bases de datos Replicated. 1 - Permitirlo. 2 - Permitirlo, pero ignorar la ruta especificada y usar en su lugar la predeterminada. 3 - Permitirlo y no registrar ninguna advertencia.
## database\_replicated\_always\_detach\_permanently
Ejecuta DETACH TABLE como DETACH TABLE PERMANENTLY si el engine de la base de datos es Replicated
## database\_replicated\_enforce\_synchronous\_settings
Obliga a esperar de forma síncrona en algunas consultas (véase también database\_atomic\_wait\_for\_drop\_and\_detach\_synchronously, mutations\_sync, alter\_sync). No se recomienda habilitar estos ajustes.
## database\_replicated\_initial\_query\_timeout\_sec
Establece cuánto tiempo debe esperar la consulta DDL inicial a que la base de datos Replicated procese las entradas previas de la cola DDL, en segundos.
Valores posibles:
* Entero positivo.
* 0 — Ilimitado.
## database\_shared\_drop\_table\_delay\_seconds
El tiempo de espera, en segundos, antes de que una tabla eliminada se quite realmente de una base de datos Shared. Esto permite recuperar la tabla durante ese tiempo mediante la sentencia `UNDROP TABLE`.
## decimal\_check\_overflow
Comprueba el desbordamiento de las operaciones aritméticas y de comparación de Decimal
## deduplicate\_blocks\_in\_dependent\_materialized\_views
Habilita o deshabilita la comprobación de deduplicación para las vistas materializadas que reciben datos de tablas Replicated\*.
Valores posibles:
0 — Deshabilitado.
1 — Habilitado.
Cuando está habilitado, ClickHouse realiza la deduplicación de bloques en las vistas materializadas que dependen de tablas Replicated\*.
Esta configuración es útil para garantizar que las vistas materializadas no contengan datos duplicados cuando la operación de inserción se reintenta debido a un fallo.
**Véase también**
* [Procesamiento de NULL en los operadores IN](/es/concepts/features/operations/insert/deduplicating-inserts-on-retries#insert-deduplication-with-materialized-views)
## deduplicate\_insert
Habilita o deshabilita la deduplicación de bloques de `INSERT INTO` (para tablas Replicated\*).
Este ajuste sobrescribe los ajustes `insert_deduplicate` y `async_insert_deduplicate`.
Este ajuste tiene tres valores posibles:
* disable — La deduplicación está deshabilitada para la consulta `INSERT INTO`.
* enable — La deduplicación está habilitada para la consulta `INSERT INTO`.
* backward\_compatible\_choice — La deduplicación está habilitada si `insert_deduplicate` o `async_insert_deduplicate` están habilitados para el tipo de insert específico.
## deduplicate\_insert\_select
Habilita o deshabilita la deduplicación de bloques de `INSERT SELECT` (para tablas Replicated\*).
Esta configuración anula `insert_deduplicate` y `deduplicate_insert` para las consultas `INSERT SELECT`.
Esta configuración tiene cuatro valores posibles:
* disable — La deduplicación está deshabilitada para la consulta `INSERT SELECT`.
* force\_enable — La deduplicación está habilitada para la consulta `INSERT SELECT`. Si el resultado de SELECT no es estable, se lanza una excepción.
* enable\_when\_possible — La deduplicación está habilitada si `insert_deduplicate` está habilitado y el resultado de SELECT es estable; de lo contrario, se deshabilita.
* enable\_even\_for\_bad\_queries - La deduplicación está habilitada si `insert_deduplicate` está habilitado. Si el resultado de SELECT no es estable, se registra una advertencia, pero la consulta se ejecuta con deduplicación. Esta opción es por compatibilidad con versiones anteriores. Considere usar otras opciones, ya que esta puede dar lugar a resultados inesperados.
## default\_materialized\_view\_sql\_security
Permite establecer un valor predeterminado para la opción SQL SECURITY al crear una vista materializada. [Más información sobre SQL security](/es/reference/statements/create/view#sql_security).
El valor predeterminado es `DEFINER`.
## default\_max\_bytes\_in\_join
Tamaño máximo de la tabla del lado derecho cuando se requiere un límite pero `max_bytes_in_join` no está configurado.
## default\_normal\_view\_sql\_security
Permite establecer la opción predeterminada de `SQL SECURITY` al crear una vista normal. [Más información sobre la seguridad SQL](/es/reference/statements/create/view#sql_security).
El valor predeterminado es `INVOKER`.
## default\_table\_engine
Motor de tabla predeterminado que se utilizará cuando no se especifique `ENGINE` en una sentencia `CREATE`.
Valores posibles:
* una cadena que represente cualquier nombre de motor de tabla válido
Valor predeterminado de Cloud: `SharedMergeTree`.
**Ejemplo**
Consulta:
```sql theme={null}
SET default_table_engine = 'Log';
SELECT name, value, changed FROM system.settings WHERE name = 'default_table_engine';
```
Resultado:
```response theme={null}
┌─name─────────────────┬─value─┬─changed─┐
│ default_table_engine │ Log │ 1 │
└──────────────────────┴───────┴─────────┘
```
En este ejemplo, cualquier tabla nueva que no especifique un `Engine` utilizará el motor de tabla `Log`:
Consulta:
```sql theme={null}
CREATE TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TABLE my_table;
```
Resultado:
```response theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
```
## default\_temporary\_table\_engine
Igual que [default\_table\_engine](#default_table_engine), pero para las tablas temporales.
En este ejemplo, cualquier tabla temporal nueva que no especifique un `Engine` usará el engine de tabla `Log`:
Consulta:
```sql theme={null}
SET default_temporary_table_engine = 'Log';
CREATE TEMPORARY TABLE my_table (
x UInt32,
y UInt32
);
SHOW CREATE TEMPORARY TABLE my_table;
```
Resultado:
```response theme={null}
┌─statement────────────────────────────────────────────────────────────────┐
│ CREATE TEMPORARY TABLE default.my_table
(
`x` UInt32,
`y` UInt32
)
ENGINE = Log
└──────────────────────────────────────────────────────────────────────────┘
```
## default\_view\_definer
Permite establecer la opción `DEFINER` predeterminada al crear una vista. [Más información sobre SQL SECURITY](/es/reference/statements/create/view#sql_security).
El valor predeterminado es `CURRENT_USER`.
## defer\_partition\_pruning\_after\_final
Cuando está habilitado (valor predeterminado), la poda de particiones se omite para las consultas `FINAL` en tablas cuyas
columnas de la clave de partición no forman parte de la clave de ordenación. Este es el comportamiento seguro desde el punto de vista de la corrección
introducido en 26.3: `FINAL` puede necesitar deduplicar filas que comparten una clave primaria pero están
en particiones distintas, y la poda de particiones excluiría silenciosamente esas filas de la
entrada usada para la deduplicación.
Cuando está deshabilitado, la poda de particiones se aplica incluso con `FINAL`, lo que restaura el comportamiento
anterior a la versión 26.3. Esto puede ser considerablemente más rápido para consultas con predicados `WHERE` en la
columna de partición, pero solo es correcto cuando filas con la misma clave primaria no pueden existir
en particiones distintas; por ejemplo, en tablas de registro de eventos cuya columna de partición se establece en el momento de la inserción
y nunca cambia.
Este ajuste solo afecta a las tablas particionadas cuyas columnas de la clave de partición no están incluidas
en la clave de ordenación; en las demás tablas, la poda de particiones siempre se aplica.
Posibles valores:
* 0 — Aplicar la poda de particiones antes de `FINAL` (comportamiento anterior a la versión 26.3, más rápido pero inseguro en el caso general).
* 1 — Aplazar la poda de particiones hasta después de `FINAL` (valor predeterminado, seguro desde el punto de vista de la corrección).
## delta\_lake\_enable\_engine\_predicate
Activa la poda interna de datos de delta-kernel.
## delta\_lake\_enable\_expression\_visitor\_logging
Habilita los logs de nivel Test del visitante de expresiones de DeltaLake. Estos logs pueden ser demasiado verbosos incluso para el registro de prueba.
## delta\_lake\_insert\_max\_bytes\_in\_data\_file
Define el límite en bytes para un único archivo de datos insertado en delta lake.
## delta\_lake\_insert\_max\_rows\_in\_data\_file
Define el límite de filas para un único archivo de datos insertado en delta lake.
## delta\_lake\_log\_metadata
Habilita el registro de los archivos de metadatos de delta lake en la tabla del sistema.
## delta\_lake\_reload\_schema\_for\_consistency
Si está habilitada, el esquema se recarga a partir de los metadatos de DeltaLake antes de cada ejecución de la consulta para garantizar
la consistencia entre el esquema utilizado durante el análisis de la consulta y el esquema utilizado durante la ejecución.
## delta\_lake\_snapshot\_end\_version
Versión final del snapshot de Delta Lake que se va a leer. El valor -1 significa que se lee la versión más reciente (el valor 0 es una versión de snapshot válida).
## delta\_lake\_snapshot\_start\_version
Versión inicial de la instantánea de Delta Lake que se leerá. El valor -1 indica que se leerá la versión más reciente (el valor 0 es una versión de instantánea válida).
## delta\_lake\_snapshot\_version
Versión de la instantánea de delta lake que se debe leer. El valor -1 indica que se leerá la versión más reciente (el valor 0 es una versión de instantánea válida).
## delta\_lake\_throw\_on\_engine\_predicate\_error
Hace que se lance una excepción si se produce un error al analizar el predicado de escaneo en delta-kernel.
## describe\_compact\_output
Si es true, incluye solo los nombres de las columnas y los tipos en el resultado de la consulta DESCRIBE
## describe\_include\_subcolumns
Permite describir subcolumnas en una consulta [DESCRIBE](/es/reference/statements/describe-table). Por ejemplo, los miembros de un [Tuple](/es/reference/data-types/tuple) o las subcolumnas de un tipo de dato [Map](/es/reference/data-types/map#reading-subcolumns-of-map), [Nullable](/es/reference/data-types/nullable#finding-null) o [Array](/es/reference/data-types/array#array-size).
Valores posibles:
* 0 — Las subcolumnas no se incluyen en las consultas `DESCRIBE`.
* 1 — Las subcolumnas se incluyen en las consultas `DESCRIBE`.
**Ejemplo**
Vea un ejemplo de la sentencia [DESCRIBE](/es/reference/statements/describe-table).
## describe\_include\_virtual\_columns
Si es true, las columnas virtuales de la tabla se incluirán en el resultado de la consulta DESCRIBE.
## dialecto
Dialecto que se utilizará para analizar la consulta
## dictionary\_use\_async\_executor
Ejecuta una canalización para leer la fuente del diccionario en varios hilos. Solo es compatible con diccionarios con una fuente CLICKHOUSE local.
## dictionary\_validate\_primary\_key\_type
Valida el tipo de clave primaria de los diccionarios. De forma predeterminada, el tipo de id de los layouts simples se convertirá implícitamente en UInt64.
## distinct\_overflow\_mode
Establece qué ocurre cuando la cantidad de datos supera uno de los límites.
Valores posibles:
* `throw`: lanza una excepción (predeterminado).
* `break`: deja de ejecutar la consulta y devuelve el resultado parcial, como si los
datos de origen se hubieran agotado.
## distributed\_aggregation\_memory\_efficient
Indica si está habilitado el modo de agregación distribuida con ahorro de memoria.
## distributed\_background\_insert\_batch
**Aliases**: `distributed_directory_monitor_batch_inserts`
Habilita o deshabilita el envío por lotes de los datos insertados.
Cuando el envío por lotes está habilitado, el motor de tabla [Distributed](/es/reference/engines/table-engines/special/distributed) intenta enviar varios archivos de datos insertados en una sola operación en lugar de enviarlos por separado. El envío por lotes mejora el rendimiento del clúster al aprovechar mejor los recursos del servidor y de la red.
Valores posibles:
* 1 — Habilitado.
* 0 — Deshabilitado.
## distributed\_background\_insert\_max\_sleep\_time\_ms
**Aliases**: `distributed_directory_monitor_max_sleep_time_ms`
Intervalo máximo para que el motor de tabla [Distributed](/es/reference/engines/table-engines/special/distributed) envíe datos. Limita el crecimiento exponencial del intervalo establecido en la opción de configuración [distributed\_background\_insert\_sleep\_time\_ms](#distributed_background_insert_sleep_time_ms).
Valores posibles:
* Un número entero positivo de milisegundos.
## distributed\_background\_insert\_sleep\_time\_ms
**Aliases**: `distributed_directory_monitor_sleep_time_ms`
Intervalo base para que el motor de tabla [Distributed](/es/reference/engines/table-engines/special/distributed) envíe datos. El intervalo real aumenta exponencialmente en caso de errores.
Valores posibles:
* Un número entero positivo de milisegundos.
## distributed\_background\_insert\_split\_batch\_on\_failure
**Alias**: `distributed_directory_monitor_split_batch_on_failure`
Habilita o deshabilita la división de lotes cuando se producen fallos.
A veces, el envío de un lote concreto al segmento remoto puede fallar debido a alguna canalización compleja posterior (por ejemplo, una `MATERIALIZED VIEW` con `GROUP BY`) por `Memory limit exceeded` u otros errores similares. En este caso, reintentar no servirá de ayuda (y esto bloqueará los envíos distribuidos de la tabla), pero enviar los archivos de ese lote uno por uno puede hacer que el `INSERT` se complete correctamente.
Por lo tanto, establecer esta configuración en `1` deshabilitará el procesamiento por lotes para esos lotes (es decir, deshabilitará temporalmente `distributed_background_insert_batch` para los lotes fallidos).
Valores posibles:
* 1 — Habilitado.
* 0 — Deshabilitado.
Esta configuración también afecta a los lotes dañados (que pueden aparecer debido a una finalización anómala del servidor (máquina) y a la ausencia de `fsync_after_insert`/`fsync_directories` para el motor de tabla [Distributed](/es/reference/engines/table-engines/special/distributed)).
No debe confiar en la división automática de lotes, ya que puede perjudicar el rendimiento.
## distributed\_background\_insert\_timeout
**Alias**: `insert_distributed_timeout`
Tiempo de espera de la consulta de inserción en Distributed. Esta configuración se usa solo cuando `insert_distributed_sync` está habilitado. Un valor de cero significa que no hay tiempo de espera.
## distributed\_cache\_alignment
Solo tiene efecto en ClickHouse Cloud. Es una configuración para pruebas; no la cambie
## distributed\_cache\_bypass\_connection\_pool
Solo tiene efecto en ClickHouse Cloud. Permite omitir el pool de conexiones de Distributed Cache
## distributed\_cache\_connect\_backoff\_max\_ms
Solo tiene efecto en ClickHouse Cloud. Máximo de milisegundos de backoff para la creación de conexiones de distributed cache.
## distributed\_cache\_connect\_backoff\_min\_ms
Solo tiene efecto en ClickHouse Cloud. Milisegundos mínimos de backoff para la creación de conexiones a distributed cache.
## distributed\_cache\_connect\_max\_tries
Solo tiene efecto en ClickHouse Cloud. Número de intentos de conexión a distributed cache en caso de error
## distributed\_cache\_connect\_timeout\_ms
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera de conexión al establecer conexión con el servidor de caché distribuida.
## distributed\_cache\_credentials\_refresh\_period\_seconds
Solo tiene efecto en ClickHouse Cloud. Período de actualización de credenciales.
## distributed\_cache\_data\_packet\_ack\_window
Solo tiene efecto en ClickHouse Cloud. Una ventana para enviar ACK de la secuencia de DataPacket en una sola solicitud de lectura de distributed cache
## distributed\_cache\_discard\_connection\_if\_unread\_data
Solo tiene efecto en ClickHouse Cloud. Descarta la conexión si queda algún dato sin leer.
## distributed\_cache\_fetch\_metrics\_only\_from\_current\_az
Solo tiene efecto en ClickHouse Cloud. Obtiene métricas únicamente de la zona de disponibilidad actual en system.distributed\_cache\_metrics, system.distributed\_cache\_events
## distributed\_cache\_file\_cache\_name
Solo tiene efecto en ClickHouse Cloud. Configuración usada solo para pruebas de CI: nombre de la filesystem cache que se usará en distributed cache.
## distributed\_cache\_log\_mode
Solo tiene efecto en ClickHouse Cloud. Modo para escribir en system.distributed\_cache\_log
## distributed\_cache\_max\_unacked\_inflight\_packets
Solo surte efecto en ClickHouse Cloud. Número máximo de paquetes en vuelo sin confirmar en una única solicitud de lectura de distributed cache
## distributed\_cache\_min\_bytes\_for\_seek
Solo surte efecto en ClickHouse Cloud. Número mínimo de bytes para realizar un seek en distributed cache.
## distributed\_cache\_pool\_behaviour\_on\_limit
Solo tiene efecto en ClickHouse Cloud. Describe el comportamiento de la conexión de caché distribuida cuando se alcanza el límite del pool
## distributed\_cache\_prefer\_bigger\_buffer\_size
Solo tiene efecto en ClickHouse Cloud. Es igual que filesystem\_cache\_prefer\_bigger\_buffer\_size, pero para la caché distribuida.
## distributed\_cache\_read\_only\_from\_current\_az
Solo tiene efecto en ClickHouse Cloud. Permite leer solo de la zona de disponibilidad actual. Si se desactiva, se leerá de todos los servidores de caché de todas las zonas de disponibilidad.
## distributed\_cache\_read\_request\_max\_tries
Solo tiene efecto en ClickHouse Cloud. Número de intentos para realizar una solicitud de lectura al distributed cache si falla
## distributed\_cache\_receive\_response\_wait\_milliseconds
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera en milisegundos para recibir los datos de una solicitud desde la caché distribuida
## distributed\_cache\_receive\_timeout\_milliseconds
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera, en milisegundos, para recibir cualquier tipo de respuesta de la caché distribuida
Valor predeterminado en Cloud: `20000`.
## distributed\_cache\_receive\_timeout\_ms
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera para recibir datos del servidor de caché distribuida, en milisegundos. Si no se recibe ningún byte en este intervalo, se lanza una excepción.
## distributed\_cache\_send\_timeout\_ms
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera para enviar datos al servidor de caché distribuida, en milisegundos. Si un cliente necesita enviar datos, pero no puede enviar ningún byte dentro de este intervalo, se genera una excepción.
## distributed\_cache\_tcp\_keep\_alive\_timeout\_ms
Solo tiene efecto en ClickHouse Cloud. Tiempo, en milisegundos, durante el que la conexión con el servidor de caché distribuida debe permanecer inactiva antes de que TCP empiece a enviar sondas keepalive.
## distributed\_cache\_throw\_on\_error
Solo tiene efecto en ClickHouse Cloud. Vuelve a lanzar la excepción que se produzca durante la comunicación con la caché distribuida o la excepción recibida de la caché distribuida. De lo contrario, en caso de error, se omite la caché distribuida
## distributed\_cache\_use\_clients\_cache\_for\_read
Solo tiene efecto en ClickHouse Cloud. Use la caché de los clientes para las solicitudes de lectura.
## distributed\_cache\_use\_clients\_cache\_for\_write
Solo tiene efecto en ClickHouse Cloud. Usa la caché del cliente para las solicitudes de escritura.
## distributed\_cache\_wait\_connection\_from\_pool\_milliseconds
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera en milisegundos para obtener una conexión del pool de conexiones si distributed\_cache\_pool\_behaviour\_on\_limit es wait
## distributed\_cache\_write\_request\_max\_tries
Solo tiene efecto en ClickHouse Cloud. Número de intentos para realizar una solicitud de escritura en distributed cache si falla
## distributed\_connections\_pool\_size
El número máximo de conexiones simultáneas con servidores remotos para el procesamiento distribuido de todas las consultas a una única tabla Distributed. Recomendamos establecer un valor no inferior al número de servidores del clúster.
## distributed\_ddl\_entry\_format\_version
Versión de compatibilidad para las consultas de DDL distribuido (ON CLUSTER)
Valor predeterminado de Cloud: `6`.
## distributed\_ddl\_output\_mode
Establece el formato del conjunto de resultados de la consulta DDL distribuida.
Valores posibles:
* `throw` — Devuelve un conjunto de resultados con el estado de ejecución de la consulta para todos los hosts en los que la consulta ha finalizado. Si la consulta ha fallado en algunos hosts, vuelve a lanzar la primera excepción. Si la consulta aún no ha finalizado en algunos hosts y se ha superado [distributed\_ddl\_task\_timeout](#distributed_ddl_task_timeout), lanza la excepción `TIMEOUT_EXCEEDED`.
* `none` — Es similar a `throw`, pero la consulta DDL distribuida no devuelve ningún conjunto de resultados.
* `null_status_on_timeout` — Devuelve `NULL` como estado de ejecución en algunas filas del conjunto de resultados en lugar de lanzar `TIMEOUT_EXCEEDED` si la consulta no ha finalizado en los hosts correspondientes.
* `never_throw` — No lanza `TIMEOUT_EXCEEDED` ni vuelve a lanzar excepciones si la consulta ha fallado en algunos hosts.
* `none_only_active` - Similar a `none`, pero no espera a las réplicas inactivas de la base de datos `Replicated`. Nota: con este modo es imposible determinar que la consulta no se ejecutó en alguna réplica y que se ejecutará en segundo plano.
* `null_status_on_timeout_only_active` — Similar a `null_status_on_timeout`, pero no espera a las réplicas inactivas de la base de datos `Replicated`
* `throw_only_active` — Similar a `throw`, pero no espera a las réplicas inactivas de la base de datos `Replicated`
Valor predeterminado de Cloud: `none_only_active`.
## distributed\_ddl\_task\_timeout
Establece el tiempo de espera para las respuestas a consultas DDL de todos los hosts del clúster. Si una solicitud DDL no se ha ejecutado en todos los hosts, la respuesta contendrá un error de tiempo de espera y la solicitud se ejecutará en modo asíncrono. Un valor negativo significa que el tiempo de espera es infinito.
Valores posibles:
* Entero positivo.
* 0 — Modo asíncrono.
* Entero negativo — tiempo de espera infinito.
## distributed\_foreground\_insert
**Aliases**: `insert_distributed_sync`
Habilita o deshabilita la inserción síncrona de datos en una tabla [Distributed](/es/reference/engines/table-engines/special/distributed).
De forma predeterminada, al insertar datos en una tabla `Distributed`, el servidor de ClickHouse envía los datos a los nodos del clúster en segundo plano. Cuando `distributed_foreground_insert=1`, los datos se procesan de forma síncrona y la operación `INSERT` solo se completa correctamente después de que todos los datos se hayan guardado en todos los segmentos (al menos una réplica por cada segmento si `internal_replication` es true).
Valores posibles:
* `0` — Los datos se insertan en segundo plano.
* `1` — Los datos se insertan en modo síncrono.
Valor predeterminado de Cloud: `1`.
**Véase también**
* [Motor de tabla Distributed](/es/reference/engines/table-engines/special/distributed)
* [Administración de tablas distribuidas](/es/reference/statements/system#managing-distributed-tables)
## distributed\_group\_by\_no\_merge
No fusiona los estados de agregación de distintos servidores durante el procesamiento distribuido de consultas; puede usarse cuando se tiene la certeza de que hay claves distintas en diferentes segmentos
Valores posibles:
* `0` — Deshabilitado (el procesamiento final de la consulta se realiza en el nodo iniciador).
* `1` - No fusiona los estados de agregación de distintos servidores durante el procesamiento distribuido de consultas (la consulta se procesa por completo en el segmento; el iniciador solo actúa como proxy de los datos); puede usarse cuando se tiene la certeza de que hay claves distintas en diferentes segmentos.
* `2` - Igual que `1`, pero aplica `ORDER BY` y `LIMIT` en el iniciador (esto no es posible cuando la consulta se procesa por completo en el nodo remoto, como en `distributed_group_by_no_merge=1`) y puede usarse para consultas con `ORDER BY` y/o `LIMIT`.
**Ejemplo**
```sql theme={null}
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 1
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
│ 0 │
└───────┘
```
```sql theme={null}
SELECT *
FROM remote('127.0.0.{2,3}', system.one)
GROUP BY dummy
LIMIT 1
SETTINGS distributed_group_by_no_merge = 2
FORMAT PrettyCompactMonoBlock
┌─dummy─┐
│ 0 │
└───────┘
```
## distributed\_index\_analysis
El análisis de índices se distribuirá entre las réplicas.
Resulta beneficioso para el almacenamiento compartido y grandes volúmenes de datos en el clúster.
Utiliza réplicas de cluster\_for\_parallel\_replicas.
**Véase también**
* [distributed\_index\_analysis\_for\_non\_shared\_merge\_tree](#distributed_index_analysis_for_non_shared_merge_tree)
* [distributed\_index\_analysis\_min\_parts\_to\_activate](/es/reference/settings/merge-tree-settings#distributed_index_analysis_min_parts_to_activate)
* [distributed\_index\_analysis\_min\_indexes\_bytes\_to\_activate](/es/reference/settings/merge-tree-settings#distributed_index_analysis_min_indexes_bytes_to_activate)
## distributed\_index\_analysis\_for\_non\_shared\_merge\_tree
Habilita el análisis distribuido de índices incluso para motores que no son SharedMergeTree (motor exclusivo de Cloud).
## distributed\_index\_analysis\_only\_on\_coordinator
Si está habilitado, el análisis de índices distribuidos se ejecuta solo en el coordinador.
Esto evita la generación de consultas O(N^2) cuando el predicado contiene subconsultas (p. ej., `IN (SELECT ...)`),
porque, de lo contrario, cada réplica follower activaría de forma independiente su propio análisis de índices distribuidos,
pero hace que el análisis de índices distribuidos sea menos eficiente si en las subconsultas se usan tablas grandes.
## distributed\_insert\_skip\_read\_only\_replicas
Permite omitir las réplicas de solo lectura en las consultas INSERT en Distributed.
Valores posibles:
* 0 — INSERT se realizará como de costumbre; si se dirige a una réplica de solo lectura, fallará
* 1 — El nodo iniciador omitirá las réplicas de solo lectura antes de enviar los datos a los segmentos.
## distributed\_plan\_default\_reader\_bucket\_count
Número predeterminado de tareas para la lectura paralela en una consulta distribuida. Las tareas se distribuyen entre las réplicas.
## distributed\_plan\_default\_shuffle\_join\_bucket\_count
Número predeterminado de buckets para el shuffle-hash-join distribuido.
## distributed\_plan\_execute\_locally
Ejecuta localmente todas las tareas de un plan de consulta distribuida. Útil para pruebas y depuración.
## distributed\_plan\_force\_exchange\_kind
Fuerza el tipo especificado de operadores Exchange entre las etapas de una consulta distribuida.
Valores posibles:
* '' - no forzar ningún tipo de operadores Exchange; dejar que el optimizador elija,
* 'Persisted' - usar archivos temporales en el almacenamiento de objetos,
* 'Streaming' - transmitir datos de intercambio a través de la red.
## distributed\_plan\_force\_shuffle\_aggregation
Usa la estrategia de agregación Shuffle en lugar de PartialAggregation + Merge en el plan de consulta distribuida.
## distributed\_plan\_max\_rows\_to\_broadcast
Número máximo de filas para usar un broadcast join en lugar de un shuffle join en el plan de consulta distribuida.
## distributed\_plan\_optimize\_exchanges
Elimina los intercambios innecesarios en el plan de consulta distribuida. Desactívelo para depuración.
## distributed\_plan\_prefer\_replicas\_over\_workers
Serializa el plan de consulta distribuida para ejecutarlo en las réplicas.
## distributed\_product\_mode
Cambia el comportamiento de las [subconsultas distribuidas](/es/reference/statements/in).
ClickHouse aplica esta configuración cuando la consulta contiene el producto de tablas distribuidas; es decir, cuando la consulta de una tabla distribuida contiene una subconsulta no GLOBAL para la tabla distribuida.
Restricciones:
* Solo se aplica a las subconsultas `IN` y `JOIN`.
* Solo si la sección `FROM` usa una tabla distribuida que contiene más de un segmento.
* Si la subconsulta hace referencia a una tabla distribuida que contiene más de un segmento.
* No se usa para la función de tabla [remote](/es/reference/functions/table-functions/remote).
Valores posibles:
* `deny` — Valor predeterminado. Prohíbe usar estos tipos de subconsultas (devuelve la excepción "Double-distributed in/JOIN subqueries is denied").
* `local` — Reemplaza la base de datos y la tabla de la subconsulta por las locales del servidor de destino (segmento), dejando `IN`/`JOIN` normal.
* `global` — Reemplaza la consulta `IN`/`JOIN` por `GLOBAL IN`/`GLOBAL JOIN`.
* `allow` — Permite el uso de estos tipos de subconsultas.
## distributed\_push\_down\_limit
Habilita o deshabilita la aplicación de [LIMIT](#limit) por separado en cada segmento.
Esto permite evitar:
* Enviar filas adicionales por la red;
* Procesar filas que quedan fuera del límite en el iniciador.
A partir de la versión 21.9, ya no es posible obtener resultados inexactos, ya que `distributed_push_down_limit` cambia la ejecución de la consulta solo si se cumple al menos una de estas condiciones:
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge) > 0.
* La consulta **no tiene** `GROUP BY`/`DISTINCT`/`LIMIT BY`, pero sí `ORDER BY`/`LIMIT`.
* La consulta **tiene** `GROUP BY`/`DISTINCT`/`LIMIT BY` con `ORDER BY`/`LIMIT` y:
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards) está habilitado.
* [optimize\_distributed\_group\_by\_sharding\_key](#optimize_distributed_group_by_sharding_key) está habilitado.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
Véase también:
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge)
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards)
* [optimize\_distributed\_group\_by\_sharding\_key](#optimize_distributed_group_by_sharding_key)
## distributed\_replica\_error\_cap
* Tipo: entero sin signo
* Valor predeterminado: 1000
El número de errores de cada réplica está limitado a este valor, lo que evita que una sola réplica acumule demasiados errores.
Véase también:
* [load\_balancing](#load_balancing-round_robin)
* [Motor de tabla Distributed](/es/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_half\_life](#distributed_replica_error_half_life)
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
## distributed\_replica\_error\_half\_life
* Tipo: segundos
* Valor predeterminado: 60 segundos
Controla la rapidez con la que los errores en las tablas distribuidas se ponen a cero. Si una réplica no está disponible durante un tiempo, acumula 5 errores y distributed\_replica\_error\_half\_life se establece en 1 segundo, la réplica vuelve a considerarse normal 3 segundos después del último error.
Véase también:
* [load\_balancing](#load_balancing-round_robin)
* [Motor de tabla Distributed](/es/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_cap](#distributed_replica_error_cap)
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
## distributed\_replica\_max\_ignored\_errors
* Tipo: entero sin signo
* Valor predeterminado: 0
El número de errores que se ignorarán al seleccionar las réplicas (según el algoritmo `load_balancing`).
Vea también:
* [load\_balancing](#load_balancing-round_robin)
* [Motor de tabla Distributed](/es/reference/engines/table-engines/special/distributed)
* [distributed\_replica\_error\_cap](#distributed_replica_error_cap)
* [distributed\_replica\_error\_half\_life](#distributed_replica_error_half_life)
## do\_not\_merge\_across\_partitions\_select\_final
Mejora las consultas FINAL al evitar los merges entre distintas particiones.
Cuando está habilitado, durante las consultas SELECT FINAL, las partes de distintas particiones no se mezclarán entre sí. En su lugar, la mezcla solo se producirá dentro de cada partición por separado. Esto puede mejorar significativamente el rendimiento de las consultas al trabajar con tablas particionadas.
## dynamic\_disk\_allow\_from\_env
Permite usar sustituciones `from_env` en la configuración de discos dinámicos (es decir, en los argumentos de la función `disk()`).
Está deshabilitada de forma predeterminada para evitar que los usuarios puedan leer variables de entorno arbitrarias al definir el almacenamiento de la tabla.
## dynamic\_disk\_allow\_from\_zk
Permite usar sustituciones `from_zk` en la configuración dinámica del disco (es decir, en los argumentos de la función `disk()`).
Deshabilitada de forma predeterminada.
## dynamic\_disk\_allow\_include
Permite usar `include` en la configuración dinámica de discos (es decir, en los argumentos de la función `disk()`).
Desactivada de forma predeterminada.
## dynamic\_throw\_on\_type\_mismatch
Al aplicar una función a una columna [Dynamic](/es/reference/data-types/dynamic) mediante la implementación predeterminada,
controla qué ocurre con las filas cuyo tipo real es incompatible con la función:
* `true` (predeterminado) — lanzar una excepción.
* `false` — devolver `NULL` para esas filas.
## empty\_result\_for\_aggregation\_by\_constant\_keys\_on\_empty\_set
Devuelve un resultado vacío al agregar por claves constantes sobre un conjunto vacío.
## empty\_result\_for\_aggregation\_by\_empty\_set
Devuelve un resultado vacío al realizar una agregación sin claves sobre un conjunto vacío.
## enable\_adaptive\_memory\_spill\_scheduler
Hace que el procesador vuelque datos al almacenamiento externo de forma adaptativa. Actualmente, se admite `grace join`.
## enable\_add\_distinct\_to\_in\_subqueries
Habilita `DISTINCT` en las subconsultas `IN`. Esta configuración implica una compensación: activarla puede reducir considerablemente el tamaño de las tablas temporales transferidas para las subconsultas `IN` distribuidas y acelerar significativamente la transferencia de datos entre segmentos, ya que garantiza que solo se envíen valores únicos.
Sin embargo, activar esta configuración añade trabajo de fusión adicional en cada nodo, ya que debe realizarse la deduplicación (`DISTINCT`). Usa esta configuración cuando la transferencia de red sea un cuello de botella y el coste adicional de fusión sea aceptable.
## enable\_automatic\_decision\_for\_merging\_across\_partitions\_for\_final
Si está habilitado, ClickHouse activará automáticamente esta optimización cuando la expresión de la clave de partición sea determinista y todas las columnas usadas en ella estén incluidas en la clave primaria.
Esta deducción automática garantiza que las filas con los mismos valores de clave primaria siempre pertenecerán a la misma partición, por lo que es seguro evitar las fusiones entre particiones.
## enable\_blob\_storage\_log
Registra información sobre las operaciones de blob storage en la tabla system.blob\_storage\_log
## enable\_blob\_storage\_log\_for\_read\_operations
Registra información sobre las operaciones de lectura de almacenamiento de blobs en la tabla system.blob\_storage\_log.
Requiere que `enable_blob_storage_log` también esté habilitado.
## enable\_early\_constant\_folding
Habilita la optimización de consultas en la que se analizan los resultados de funciones y subconsultas, y se reescribe la consulta si contienen constantes
## enable\_extended\_results\_for\_datetime\_functions
Habilita o deshabilita la devolución de resultados de tipo `Date32` con rango ampliado (en comparación con el tipo `Date`)
o de tipo `DateTime64` con rango ampliado (en comparación con el tipo `DateTime`).
Valores posibles:
* `0` — Las funciones devuelven `Date` o `DateTime` para todos los tipos de argumentos.
* `1` — Las funciones devuelven `Date32` o `DateTime64` para argumentos `Date32` o `DateTime64`, y `Date` o `DateTime` en los demás casos.
La siguiente tabla muestra el comportamiento de esta configuración para varias funciones de fecha y hora.
| Función | `enable_extended_results_for_datetime_functions = 0` | `enable_extended_results_for_datetime_functions = 1` |
| ------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `toStartOfYear` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para entradas de tipo `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para entradas de tipo `Date32`/`DateTime64` |
| `toStartOfISOYear` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para entradas `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfQuarter` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para entradas `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfMonth` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para entradas `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfWeek` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para valores de entrada `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para valores de entrada `Date32`/`DateTime64` |
| `toLastDayOfWeek` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` cuando la entrada es `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` cuando la entrada es `Date32`/`DateTime64` |
| `toLastDayOfMonth` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para entradas `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para entradas `Date32`/`DateTime64` |
| `toMonday` | Devuelve `Date` o `DateTime` | Devuelve `Date`/`DateTime` para valores de entrada `Date`/`DateTime`
Devuelve `Date32`/`DateTime64` para valores de entrada `Date32`/`DateTime64` |
| `toStartOfDay` | Devuelve `DateTime`
*Nota: resultados incorrectos para valores fuera del intervalo 1970-2149* | Devuelve `DateTime` para una entrada `Date`/`DateTime`
Devuelve `DateTime64` para una entrada `Date32`/`DateTime64` |
| `toStartOfHour` | Devuelve `DateTime`
*Nota: resultados incorrectos para valores fuera del rango 1970-2149* | Devuelve `DateTime` para entradas `Date`/`DateTime`
Devuelve `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfFifteenMinutes` | Devuelve `DateTime`
*Nota: resultados incorrectos para valores fuera del rango 1970-2149* | Devuelve `DateTime` para entradas `Date`/`DateTime`
Devuelve `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfTenMinutes` | Devuelve `DateTime`
*Nota: resultados incorrectos para valores fuera del rango 1970-2149* | Devuelve `DateTime` para entradas `Date`/`DateTime`
Devuelve `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfFiveMinutes` | Devuelve `DateTime`
*Nota: devuelve resultados incorrectos para valores fuera del intervalo 1970-2149* | Devuelve `DateTime` para entradas `Date`/`DateTime`
Devuelve `DateTime64` para entradas `Date32`/`DateTime64` |
| `toStartOfMinute` | Devuelve `DateTime`
*Nota: resultados incorrectos para valores fuera del intervalo 1970-2149* | Devuelve `DateTime` para entradas `Date`/`DateTime`
Devuelve `DateTime64` para entradas `Date32`/`DateTime64` |
| `timeSlot` | Devuelve `DateTime`
*Nota: produce resultados incorrectos para valores fuera del rango 1970-2149* | Devuelve `DateTime` para entradas `Date`/`DateTime`
Devuelve `DateTime64` para entradas `Date32`/`DateTime64` |
## enable\_filesystem\_cache
Usa la caché para el filesystem remoto. Esta configuración no activa ni desactiva la caché de los discos (debe hacerse mediante la configuración del disco), pero permite omitir la caché para algunas consultas si así se pretende
## enable\_filesystem\_cache\_log
Permite registrar el log de la caché del sistema de archivos para cada consulta
## enable\_filesystem\_cache\_on\_write\_operations
Habilita o deshabilita la caché `write-through`. Si se establece en `false`, la caché `write-through` se desactiva para las operaciones de escritura. Si se establece en `true`, la caché `write-through` se activa siempre que `cache_on_write_operations` esté habilitado en la sección de configuración del disco de caché de la configuración del servidor.
Consulta ["Using local cache"](/es/concepts/features/configuration/server-config/storing-data#using-local-cache) para obtener más información.
Valor predeterminado de Cloud: `1`.
## enable\_filesystem\_read\_prefetches\_log
Registra en system.filesystem prefetch\_log durante la consulta. Debe usarse solo para pruebas o depuración; no se recomienda habilitarlo de forma predeterminada
## enable\_full\_text\_index
**Aliases**: `allow_experimental_full_text_index`
Si se establece en `true`, permite usar el índice de texto.
## enable\_global\_with\_statement
Propagar las sentencias WITH a las consultas UNION y a todas las subconsultas
## enable\_hdfs\_pread
Habilita o deshabilita `pread` para archivos HDFS. De forma predeterminada, se usa `hdfsPread`. Si se deshabilita, se usarán `hdfsRead` y `hdfsSeek` para leer archivos HDFS.
## enable\_http\_compression
Habilita o deshabilita la compresión de datos en la respuesta a una petición HTTP.
Para obtener más información, consulta la [descripción de la interfaz HTTP](/es/concepts/features/interfaces/http).
Posibles valores:
* 0 — Deshabilitado.
* 1 — Habilitado.
## enable\_job\_stack\_trace
Muestra la traza de pila del creador de un trabajo cuando este genera una excepción. Está deshabilitado de forma predeterminada para evitar la sobrecarga de rendimiento.
## enable\_join\_fixed\_hash\_table\_conversion
Habilita la conversión de la tabla hash a un array plano para joins cuando la clave es un solo entero con un rango de valores pequeño.
## enable\_join\_runtime\_filters
Filtra el lado izquierdo usando el conjunto de claves de JOIN recopiladas del lado derecho en tiempo de ejecución.
## enable\_join\_transitive\_predicates
Infiere predicados transitivos de equijoin a partir de las condiciones de join existentes.
Por ejemplo, dados `A.x = B.x` y `B.x = C.x`, se añade un predicado sintético `A.x = C.x`
para que el optimizador del orden de join pueda considerar planes directos de (A JOIN C).
## enable\_lazy\_columns\_replication
Habilita la replicación diferida de columnas en JOIN y ARRAY JOIN, lo que permite evitar copias innecesarias de las mismas filas varias veces en memoria.
## enable\_lightweight\_delete
**Alias**: `allow_experimental_lightweight_delete`
Habilita las mutaciones DELETE de eliminación ligera en tablas MergeTree.
## enable\_lightweight\_update
**Alias**: `allow_experimental_lightweight_update`
Permite utilizar actualizaciones ligeras.
## enable\_materialized\_cte
Habilita las expresiones de tabla comunes materializadas; tiene prioridad sobre enable\_global\_with\_statement
## enable\_memory\_bound\_merging\_of\_aggregation\_results
Activa la estrategia de fusión limitada por memoria para la agregación.
## enable\_multiple\_prewhere\_read\_steps
Traslada más condiciones de WHERE a PREWHERE y realiza lecturas desde disco y filtrado en varios pasos si hay varias condiciones combinadas con AND
## enable\_named\_columns\_in\_function\_tuple
Genera tuplas con nombre en la función tuple() cuando todos los nombres sean únicos y puedan tratarse como identificadores sin comillas.
## enable\_optimize\_predicate\_expression
Activa el pushdown de predicados en las consultas `SELECT`.
El pushdown de predicados puede reducir significativamente el tráfico de red en las consultas distribuidas.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
Uso
Considere las siguientes consultas:
1. `SELECT count() FROM test_table WHERE date = '2018-10-10'`
2. `SELECT count() FROM (SELECT * FROM test_table) WHERE date = '2018-10-10'`
Si `enable_optimize_predicate_expression = 1`, el tiempo de ejecución de estas consultas es el mismo porque ClickHouse aplica `WHERE` a la subconsulta durante su procesamiento.
Si `enable_optimize_predicate_expression = 0`, el tiempo de ejecución de la segunda consulta es mucho mayor porque la cláusula `WHERE` se aplica a todos los datos una vez finalizada la subconsulta.
## enable\_optimize\_predicate\_expression\_to\_final\_subquery
Permite trasladar el predicado a la subconsulta FINAL.
## enable\_order\_by\_all
Habilita o deshabilita la ordenación mediante la sintaxis `ORDER BY ALL`; consulte [ORDER BY](/es/reference/statements/select/order-by).
Valores posibles:
* 0 — Deshabilita ORDER BY ALL.
* 1 — Habilita ORDER BY ALL.
**Ejemplo**
Consulta:
```sql theme={null}
CREATE TABLE TAB(C1 Int, C2 Int, ALL Int) ENGINE=Memory();
INSERT INTO TAB VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM TAB ORDER BY ALL; -- devuelve un error porque ALL es ambiguo
SELECT * FROM TAB ORDER BY ALL SETTINGS enable_order_by_all = 0;
```
Resultado:
```text theme={null}
┌─C1─┬─C2─┬─ALL─┐
│ 20 │ 20 │ 10 │
│ 30 │ 10 │ 20 │
│ 10 │ 20 │ 30 │
└────┴────┴─────┘
```
## enable\_parallel\_blocks\_marshalling
Afecta solo a las consultas distribuidas. Si está habilitado, los bloques se (des)serializarán y (des)comprimirán en los hilos del pipeline (es decir, con un paralelismo mayor que el predeterminado) antes/después de enviarlos al iniciador.
## enable\_parsing\_to\_custom\_serialization
Si es true, los datos pueden interpretarse directamente en columnas con serialización personalizada (p. ej., Sparse), según las indicaciones de serialización obtenidas de la tabla.
## enable\_positional\_arguments
Habilita o deshabilita el uso de argumentos posicionales en las sentencias [GROUP BY](/es/reference/statements/select/group-by), [LIMIT BY](/es/reference/statements/select/limit-by) y [ORDER BY](/es/reference/statements/select/order-by).
Valores posibles:
* 0 — No se admiten argumentos posicionales.
* 1 — Se admiten argumentos posicionales: se pueden usar números de columna en lugar de nombres de columna.
**Ejemplo**
Consulta:
```sql theme={null}
CREATE TABLE positional_arguments(one Int, two Int, three Int) ENGINE=Memory();
INSERT INTO positional_arguments VALUES (10, 20, 30), (20, 20, 10), (30, 10, 20);
SELECT * FROM positional_arguments ORDER BY 2,3;
```
Resultado:
```text theme={null}
┌─one─┬─two─┬─three─┐
│ 30 │ 10 │ 20 │
│ 20 │ 20 │ 10 │
│ 10 │ 20 │ 30 │
└─────┴─────┴───────┘
```
## enable\_positional\_arguments\_for\_projections
Habilita o deshabilita la compatibilidad con argumentos posicionales en las definiciones de PROJECTION. Consulte también la configuración [enable\_positional\_arguments](#enable_positional_arguments).
Esta es una configuración de nivel experto y no debe cambiarla si apenas está empezando con ClickHouse.
Valores posibles:
* 0 — Los argumentos posicionales no se admiten.
* 1 — Los argumentos posicionales se admiten: se pueden usar números de columna en lugar de nombres de columna.
## enable\_producing\_buckets\_out\_of\_order\_in\_aggregation
Permite que la agregación con uso eficiente de memoria (consulta `distributed_aggregation_memory_efficient`) produzca buckets fuera de orden.
Puede mejorar el rendimiento cuando los tamaños de los buckets de agregación son desiguales, ya que permite que una réplica envíe buckets con identificadores más altos al iniciador mientras sigue procesando algunos buckets pesados con identificadores más bajos.
La desventaja es un uso de memoria potencialmente mayor.
## enable\_reads\_from\_query\_cache
Si está activado, los resultados de las consultas `SELECT` se recuperan de la [caché de consultas](/es/concepts/features/performance/caches/query-cache).
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## enable\_s3\_requests\_logging
Habilita un registro muy detallado de las solicitudes a S3. Solo tiene sentido para depuración.
## enable\_scalar\_subquery\_optimization
Si se establece en true, evita que las subconsultas escalares (de)serialicen valores escalares grandes y, posiblemente, que la misma subconsulta se ejecute más de una vez.
## enable\_scopes\_for\_with\_statement
Si está deshabilitada, las declaraciones en las cláusulas WITH de nivel superior tendrán el mismo alcance que si se hubieran declarado en el alcance actual.
Tenga en cuenta que esta es una configuración de compatibilidad del analizador para permitir la ejecución de algunas consultas no válidas que el analizador antiguo podía ejecutar.
## enable\_shared\_storage\_snapshot\_in\_query
Si está habilitado, todas las subconsultas dentro de una misma consulta compartirán la misma StorageSnapshot para cada tabla.
Esto garantiza una vista coherente de los datos en toda la consulta, incluso si se accede varias veces a la misma tabla.
Esto es necesario para consultas en las que la coherencia interna de las partes de datos es importante. Ejemplo:
```sql theme={null}
SELECT
count()
FROM events
WHERE (_part, _part_offset) IN (
SELECT _part, _part_offset
FROM events
WHERE user_id = 42
)
```
Sin esta configuración, las consultas externa e interna pueden operar sobre instantáneas de datos distintas, lo que puede producir resultados incorrectos.
Al habilitar esta configuración, se desactiva la optimización que elimina de las instantáneas las partes de datos innecesarias una vez completada la fase de planificación.
Como resultado, las consultas de larga duración pueden retener partes obsoletas durante toda su ejecución, lo que retrasa la limpieza de partes y aumenta la presión sobre el almacenamiento.
Actualmente, esta configuración solo se aplica a tablas de la familia MergeTree.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## enable\_sharing\_sets\_for\_mutations
Permite compartir objetos Set creados para subconsultas `IN` entre diferentes tareas de la misma mutación. Esto reduce el uso de memoria y el consumo de CPU
## enable\_software\_prefetch\_in\_aggregation
Habilita el uso de la precarga por software en la agregación
## enable\_software\_prefetch\_in\_join
Habilita el uso de prefetch por software en la fase de sondeo de hash join para ocultar la latencia de acceso a memoria en tablas hash grandes.
## enable\_time\_time64\_type
**Aliases**: `allow_experimental_time_time64_type`
Permite crear los tipos de datos [Time](/es/reference/data-types/time) y [Time64](/es/reference/data-types/time64).
## enable\_unaligned\_array\_join
Permite ARRAY JOIN con varios arrays de distinto tamaño. Cuando esta configuración está habilitada, los arrays se redimensionan al de mayor longitud.
## enable\_url\_encoding
Permite habilitar o deshabilitar la decodificación/codificación de la ruta de la URI en tablas con motor [URL](/es/reference/engines/table-engines/special/url).
Está deshabilitado de forma predeterminada.
## enable\_vertical\_final
Si está habilitado, elimina las filas duplicadas durante FINAL marcando las filas como eliminadas y filtrándolas posteriormente en lugar de fusionarlas
## enable\_writes\_to\_query\_cache
Si está activado, los resultados de las consultas `SELECT` se almacenan en la [caché de consultas](/es/concepts/features/performance/caches/query-cache).
Valores posibles:
* 0 - Desactivado
* 1 - Activado
## enforce\_strict\_identifier\_format
Si está habilitada, solo se permiten identificadores que contengan caracteres alfanuméricos y guiones bajos.
## engine\_file\_allow\_create\_multiple\_files
Habilita o deshabilita la creación de un archivo nuevo en cada inserción en tablas con el engine File si el format tiene el sufijo (`JSON`, `ORC`, `Parquet`, etc.). Si está habilitado, en cada inserción se creará un archivo nuevo con un nombre que siga este patrón:
`data.Parquet` -> `data.1.Parquet` -> `data.2.Parquet`, etc.
Valores posibles:
* 0 — la consulta `INSERT` agrega datos nuevos al final del archivo.
* 1 — la consulta `INSERT` crea un archivo nuevo.
## engine\_file\_empty\_if\_not\_exists
Permite seleccionar datos de una tabla del motor File aunque no exista el archivo.
Valores posibles:
* 0 — `SELECT` lanza una excepción.
* 1 — `SELECT` devuelve un resultado vacío.
## engine\_file\_skip\_empty\_files
Habilita o deshabilita la omisión de archivos vacíos en las tablas del motor [File](/es/reference/engines/table-engines/special/file).
Valores posibles:
* 0 — `SELECT` genera una excepción si el archivo vacío no es compatible con el formato solicitado.
* 1 — `SELECT` devuelve un resultado vacío para un archivo vacío.
## engine\_file\_truncate\_on\_insert
Habilita o deshabilita el truncado antes de insertar en las tablas del motor [File](/es/reference/engines/table-engines/special/file).
Posibles valores:
* 0 — la consulta `INSERT` añade datos nuevos al final del archivo.
* 1 — la consulta `INSERT` sustituye el contenido existente del archivo por los nuevos datos.
## engine\_url\_skip\_empty\_files
Habilita o deshabilita la omisión de archivos vacíos en las tablas del motor [URL](/es/reference/engines/table-engines/special/url).
Valores posibles:
* 0 — `SELECT` genera una excepción si el archivo vacío no es compatible con el format solicitado.
* 1 — `SELECT` devuelve un resultado vacío si el archivo está vacío.
## exact\_rows\_before\_limit
Cuando está habilitada, ClickHouse proporcionará el valor exacto de la estadística rows\_before\_limit\_at\_least, pero a costa de tener que leer por completo los datos anteriores al límite
## except\_default\_mode
Establece el modo predeterminado en la consulta EXCEPT. Posibles valores: cadena vacía, 'ALL', 'DISTINCT'. Si está vacío, una consulta sin modo generará una excepción.
## exclude\_materialize\_skip\_indexes\_on\_insert
Excluye los índices de omisión especificados para que no se creen ni se almacenen durante los INSERTs. Los índices de omisión excluidos se seguirán creando y almacenando [durante las fusiones](/es/reference/settings/merge-tree-settings#materialize_skip_indexes_on_merge) o mediante una
consulta [MATERIALIZE INDEX](/es/reference/statements/alter/skipping-index#materialize-index) explícita.
No tiene efecto si [materialize\_skip\_indexes\_on\_insert](#materialize_skip_indexes_on_insert) es false.
Ejemplo:
```sql theme={null}
CREATE TABLE tab
(
a UInt64,
b UInt64,
INDEX idx_a a TYPE minmax,
INDEX idx_b b TYPE set(3)
)
ENGINE = MergeTree ORDER BY tuple();
SET exclude_materialize_skip_indexes_on_insert='idx_a'; -- idx_a no se actualizará al insertar
--SET exclude_materialize_skip_indexes_on_insert='idx_a, idx_b'; -- ningún índice se actualizaría al insertar
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- solo se actualiza idx_b
-- al ser una configuración de sesión, puede establecerse a nivel de consulta individual
INSERT INTO tab SELECT number, number / 50 FROM numbers(100, 100) SETTINGS exclude_materialize_skip_indexes_on_insert='idx_b';
ALTER TABLE tab MATERIALIZE INDEX idx_a; -- esta consulta puede usarse para materializar el índice de forma explícita
SET exclude_materialize_skip_indexes_on_insert = DEFAULT; -- restablecer la configuración al valor predeterminado
```
## execute\_exists\_as\_scalar\_subquery
Ejecuta las subconsultas `EXISTS` no correlacionadas como subconsultas escalares. Igual que con las subconsultas escalares, se utiliza la caché y el plegado de constantes se aplica al resultado.
Valor predeterminado en Cloud: `0`.
## external\_storage\_connect\_timeout\_sec
Tiempo de espera de conexión en segundos. Actualmente, solo es compatible con MySQL
## external\_storage\_max\_read\_bytes
Limita el número máximo de bytes cuando una tabla con motor externo debe vaciar los datos del historial. Actualmente, solo es compatible con el motor de tabla MySQL, el motor de base de datos y el diccionario. Si es igual a 0, esta configuración está deshabilitada
## external\_storage\_max\_read\_rows
Limita el número máximo de filas cuando una tabla con motor externo deba volcar los datos del historial. Actualmente, solo es compatible con el motor de tabla MySQL, el motor de base de datos y el diccionario. Si es igual a 0, esta configuración está deshabilitada
## external\_storage\_rw\_timeout\_sec
Tiempo de espera de lectura/escritura en segundos. Actualmente, solo se admite para MySQL
## external\_table\_functions\_use\_nulls
Define cómo las funciones de tabla [mysql](/es/reference/functions/table-functions/mysql), [postgresql](/es/reference/functions/table-functions/postgresql) y [odbc](/es/reference/functions/table-functions/odbc) utilizan columnas Nullable.
Valores posibles:
* 0 — La función de tabla utiliza explícitamente columnas Nullable.
* 1 — La función de tabla utiliza implícitamente columnas Nullable.
**Uso**
Si esta configuración se establece en `0`, la función de tabla no genera columnas Nullable e inserta valores predeterminados en lugar de NULL. Esto también se aplica a los valores NULL dentro de los arrays.
## external\_table\_strict\_query
Si se establece en true, se prohíbe convertir la expresión en un filtro local en las consultas a tablas externas.
**Alias**: `extract_kvp_max_pairs_per_row`
Número máximo de pares que puede generar la función `extractKeyValuePairs`. Se utiliza como medida de protección para evitar un consumo excesivo de memoria.
## extremes
Indica si se deben contar los valores extremos (los mínimos y máximos en las columnas del resultado de una consulta). Acepta 0 o 1. De forma predeterminada, 0 (deshabilitado).
Para obtener más información, consulte la sección "Valores extremos".
## fallback\_to\_stale\_replicas\_for\_distributed\_queries
Obliga a que una consulta use una réplica desactualizada si no hay datos actualizados disponibles. Consulte [Replicación](/es/reference/engines/table-engines/mergetree-family/replication).
ClickHouse selecciona la más adecuada entre las réplicas desactualizadas de la tabla.
Se utiliza al ejecutar `SELECT` en una tabla distribuida que apunta a tablas replicadas.
De forma predeterminada, 1 (habilitado).
## filesystem\_cache\_allow\_background\_download
Permite que la caché del sistema de archivos ponga en cola descargas en segundo plano para los datos leídos del almacenamiento remoto. Desactívelo para mantener las descargas en primer plano para la consulta o sesión actual.
## filesystem\_cache\_boundary\_alignment
Alineación de los límites de la caché del sistema de archivos. Esta configuración se aplica solo a lecturas que no se realizan desde disco (p. ej., para la caché de motores de tabla remotos / funciones de tabla, pero no para la configuración de almacenamiento de las tablas MergeTree). El valor 0 significa que no hay alineación.
## filesystem\_cache\_enable\_background\_download\_during\_fetch
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera para bloquear la caché al reservar espacio en la caché del sistema de archivos
## filesystem\_cache\_enable\_background\_download\_for\_metadata\_files\_in\_packed\_storage
Solo tiene efecto en ClickHouse Cloud. Tiempo de espera para adquirir un bloqueo de caché y reservar espacio en la caché del sistema de archivos
## filesystem\_cache\_max\_download\_size
Tamaño máximo de la caché remota del sistema de archivos que puede descargarse con una sola consulta
## filesystem\_cache\_name
Nombre de la caché del sistema de archivos que se utilizará para motores de tabla sin estado o lagos de datos
## filesystem\_cache\_prefer\_bigger\_buffer\_size
Prioriza un tamaño de búfer mayor si la caché del sistema de archivos está habilitada para evitar escribir segmentos de archivo pequeños, que perjudican el rendimiento de la caché. Por otro lado, habilitar esta configuración podría aumentar el uso de memoria.
## filesystem\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Tiempo de espera para bloquear la caché al reservar espacio en la caché del sistema de archivos
## filesystem\_cache\_segments\_batch\_size
Límite del tamaño de un único batch de segmentos de archivo que un búfer de lectura puede solicitar a la caché. Un valor demasiado bajo provocará demasiadas solicitudes a la caché; uno demasiado alto puede ralentizar la expulsión de la caché
## filesystem\_cache\_skip\_download\_if\_exceeds\_per\_query\_cache\_write\_limit
**Alias**: `skip_download_if_exceeds_query_cache`
Omitir la descarga desde el sistema de archivos remoto si supera el tamaño de la caché de consultas
## filesystem\_prefetch\_max\_memory\_usage
Uso máximo de memoria para las operaciones de precarga.
Valor predeterminado en Cloud: 10% de la memoria total.
## filesystem\_prefetch\_step\_bytes
Paso de prefetch en bytes. Cero significa `auto`: el paso de prefetch óptimo se inferirá automáticamente de forma aproximada, aunque puede que no sea el mejor en todos los casos. El valor real puede ser diferente debido a la configuración filesystem\_prefetch\_min\_bytes\_for\_single\_read\_task
## filesystem\_prefetch\_step\_marks
Paso de precarga en marcas. Cero significa `auto`: se deducirá automáticamente un paso de precarga aproximadamente óptimo, aunque puede que no sea el mejor en todos los casos. El valor real puede ser diferente debido a la configuración filesystem\_prefetch\_min\_bytes\_for\_single\_read\_task
## filesystem\_prefetches\_limit
Número máximo de precargas. Cero significa sin límite. Se recomienda la configuración `filesystem_prefetches_max_memory_usage` si desea limitar el número de precargas
## final
Aplica automáticamente el modificador [FINAL](/es/reference/statements/select/from#final-modifier) a todas las tablas de una consulta en las que [FINAL](/es/reference/statements/select/from#final-modifier) sea aplicable, incluidas las tablas combinadas, las tablas de las subconsultas y
las tablas distribuidas.
Posibles valores:
* 0 - deshabilitado
* 1 - habilitado
Ejemplo:
```sql theme={null}
CREATE TABLE test
(
key Int64,
some String
)
ENGINE = ReplacingMergeTree
ORDER BY key;
INSERT INTO test FORMAT Values (1, 'first');
INSERT INTO test FORMAT Values (1, 'second');
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
┌─key─┬─some──┐
│ 1 │ first │
└─────┴───────┘
SELECT * FROM test SETTINGS final = 1;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
SET final = 1;
SELECT * FROM test;
┌─key─┬─some───┐
│ 1 │ second │
└─────┴────────┘
```
## finalize\_projection\_parts\_synchronously
Cuando está habilitada, las partes de proyección se finalizan de forma síncrona durante INSERT, lo que reduce el uso máximo de memoria a costa de una menor paralelización de las cargas a S3. De forma predeterminada, el flujo de salida de cada proyección se mantiene activo hasta que se finaliza la parte completa (incluidas todas las proyecciones), lo que permite solapar las cargas a S3, pero aumenta el uso máximo de memoria en proporción al número de proyecciones. Esta configuración solo afecta a la ruta de INSERT; merge y mutation ya finalizan las proyecciones de forma síncrona.
## flatten\_nested
Establece el formato de datos de las columnas de tipo [nested](/es/reference/data-types/nested-data-structures).
Valores posibles:
* 1 — La columna nested se aplana en arrays separados.
* 0 — La columna nested sigue siendo un único array de tuplas.
**Uso**
Si el ajuste se establece en `0`, se puede usar cualquier nivel de anidamiento.
**Ejemplos**
Consulta:
```sql theme={null}
SET flatten_nested = 1;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
```
Resultado:
```text theme={null}
┌─statement───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n.a` Array(UInt32),
`n.b` Array(UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Consulta:
```sql theme={null}
SET flatten_nested = 0;
CREATE TABLE t_nest (`n` Nested(a UInt32, b UInt32)) ENGINE = MergeTree ORDER BY tuple();
SHOW CREATE TABLE t_nest;
```
Resultado:
```text theme={null}
┌─statement──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ CREATE TABLE default.t_nest
(
`n` Nested(a UInt32, b UInt32)
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS index_granularity = 8192 │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## force\_aggregate\_partitions\_independently
Fuerza el uso de esta optimización cuando es aplicable, aunque las heurísticas hayan decidido no utilizarla
## force\_aggregation\_in\_order
Esta configuración la utiliza el propio servidor para admitir consultas distribuidas. No la cambie manualmente, porque interrumpirá el funcionamiento normal. (Fuerza el uso de la agregación en orden en los nodos remotos durante la agregación distribuida).
## force\_data\_skipping\_indices
Deshabilita la ejecución de la consulta si no se utilizaron los índices de omisión de datos especificados.
Considere el siguiente ejemplo:
```sql theme={null}
CREATE TABLE data
(
key Int,
d1 Int,
d1_null Nullable(Int),
INDEX d1_idx d1 TYPE minmax GRANULARITY 1,
INDEX d1_null_idx assumeNotNull(d1_null) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
SELECT * FROM data_01515;
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices=''; -- la consulta producirá el error CANNOT_PARSE_TEXT.
SELECT * FROM data_01515 SETTINGS force_data_skipping_indices='d1_idx'; -- la consulta producirá el error INDEX_NOT_USED.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='d1_idx'; -- Correcto.
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`'; -- Correcto (ejemplo de parser con todas las funcionalidades).
SELECT * FROM data_01515 WHERE d1 = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- la consulta producirá el error INDEX_NOT_USED, ya que d1_null_idx no se utiliza.
SELECT * FROM data_01515 WHERE d1 = 0 AND assumeNotNull(d1_null) = 0 SETTINGS force_data_skipping_indices='`d1_idx`, d1_null_idx'; -- Correcto.
```
## force\_grouping\_standard\_compatibility
Hace que la función GROUPING devuelva 1 cuando el argumento no se use como clave de agregación
## force\_index\_by\_date
Desactiva la ejecución de la consulta si no se puede usar el índice de fecha.
Funciona con tablas de la familia MergeTree.
Si `force_index_by_date=1`, ClickHouse comprueba si la consulta tiene una condición sobre la clave de fecha que pueda usarse para restringir los rangos de datos. Si no hay una condición adecuada, lanza una excepción. Sin embargo, no comprueba si la condición reduce la cantidad de datos que se deben leer. Por ejemplo, la condición `Date != ' 2000-01-01 '` es aceptable incluso cuando coincide con todos los datos de la tabla (es decir, ejecutar la consulta requiere un escaneo completo). Para obtener más información sobre los rangos de datos en las tablas MergeTree, consulta [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree).
## force\_optimize\_projection
Habilita o deshabilita el uso obligatorio de [proyecciones](/es/reference/engines/table-engines/mergetree-family/mergetree#projections) en las consultas `SELECT` cuando está habilitada la optimización de proyecciones (consulta el ajuste [optimize\_use\_projections](#optimize_use_projections)).
Valores posibles:
* 0 — La optimización de proyecciones no es obligatoria.
* 1 — La optimización de proyecciones es obligatoria.
## force\_optimize\_projection\_name
Si se establece como una cadena no vacía, compruebe que esta proyección se utilice en la consulta al menos una vez.
Valores posibles:
* cadena: nombre de la proyección que se utiliza en una consulta
## force\_optimize\_skip\_unused\_shards
Habilita o deshabilita la ejecución de consultas si [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards) está habilitado y no es posible omitir los segmentos no utilizados. Si no es posible omitirlos y esta configuración está habilitada, se lanzará una excepción.
Valores posibles:
* 0 — Deshabilitado. ClickHouse no lanza ninguna excepción.
* 1 — Habilitado. La ejecución de consultas se deshabilita solo si la tabla tiene una clave de segmentación.
* 2 — Habilitado. La ejecución de consultas se deshabilita independientemente de si la tabla tiene definida una clave de segmentación.
## force\_optimize\_skip\_unused\_shards\_nesting
Controla [`force_optimize_skip_unused_shards`](#force_optimize_skip_unused_shards) en función del nivel de anidamiento de la consulta distribuida (es decir, cuando tiene una tabla `Distributed` que consulta otra tabla `Distributed`), por lo que sigue requiriendo [`force_optimize_skip_unused_shards`](#force_optimize_skip_unused_shards).
Valores posibles:
* 0 - Deshabilitado; `force_optimize_skip_unused_shards` funciona siempre.
* 1 — Habilita `force_optimize_skip_unused_shards` solo para el primer nivel.
* 2 — Habilita `force_optimize_skip_unused_shards` hasta el segundo nivel.
## force\_primary\_key
Deshabilita la ejecución de la consulta si no es posible usar el índice de la clave primaria.
Funciona con tablas de la familia MergeTree.
Si `force_primary_key=1`, ClickHouse comprueba si la consulta tiene una condición sobre la clave primaria que pueda usarse para restringir los rangos de datos. Si no existe una condición adecuada, lanza una excepción. Sin embargo, no comprueba si la condición reduce la cantidad de datos que se deben leer. Para obtener más información sobre los rangos de datos en las tablas MergeTree, consulte [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree).
## force\_remove\_data\_recursively\_on\_drop
Elimina los datos de forma recursiva en la consulta DROP. Evita el error 'El directorio no está vacío', pero puede eliminar silenciosamente datos detached
## formatdatetime\_e\_with\_space\_padding
El especificador de formato '%e' de la función 'formatDateTime' imprime los días de un solo dígito con un espacio delante, por ejemplo, ' 2' en lugar de '2'.
## formatdatetime\_f\_prints\_scale\_number\_of\_digits
El formateador '%f' de la función 'formatDateTime' imprime solo la cantidad de dígitos correspondiente a la escala de un DateTime64, en lugar de 6 dígitos fijos.
## formatdatetime\_f\_prints\_single\_zero
El formateador '%f' de la función 'formatDateTime' imprime un único cero en lugar de seis ceros si el valor formateado no tiene fracciones de segundo.
## formatdatetime\_format\_without\_leading\_zeros
Los formateadores '%c', '%l' y '%k' de la función 'formatDateTime' muestran los meses y las horas sin ceros a la izquierda.
## formatdatetime\_parsedatetime\_m\_is\_month\_name
El especificador de formato '%M' en las funciones 'formatDateTime' y 'parseDateTime' imprime/analiza el nombre del mes en lugar de los minutos.
## fsync\_metadata
Habilita o deshabilita [fsync](http://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html) al escribir archivos `.sql`. Está habilitado de forma predeterminada.
Tiene sentido deshabilitarlo si el server tiene millones de tablas pequeñas que se crean y destruyen constantemente.
## function\_date\_trunc\_return\_type\_behavior
Permite cambiar el comportamiento del tipo de resultado de la función `dateTrunc`.
Valores posibles:
* 0 - Cuando el segundo argumento es `DateTime64/Date32`, el tipo de retorno será `DateTime64/Date32` independientemente de la unidad de tiempo del primer argumento.
* 1 - Para `Date32`, el resultado siempre es `Date`. Para `DateTime64`, el resultado es `DateTime` para las unidades de tiempo `second` y superiores.
## function\_implementation
Elija la implementación de la función para un destino específico o Variant (experimental). Si se deja vacío, se habilitan todas.
## function\_json\_value\_return\_type\_allow\_complex
Controla si se permite devolver tipos complejos (como struct, array y map) en la función json\_value.
```sql theme={null}
SELECT JSON_VALUE('{"hello":{"world":"!"}}', '$.hello') settings function_json_value_return_type_allow_complex=true
┌─JSON_VALUE('{"hello":{"world":"!"}}', '$.hello')─┐
│ {"world":"!"} │
└──────────────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
```
Valores posibles:
* true — Se permite.
* false — No se permite.
## function\_json\_value\_return\_type\_allow\_nullable
Controla si se permite devolver `NULL` cuando no existe ningún valor para la función JSON\_VALUE.
```sql theme={null}
SELECT JSON_VALUE('{"hello":"world"}', '$.b') settings function_json_value_return_type_allow_nullable=true;
┌─JSON_VALUE('{"hello":"world"}', '$.b')─┐
│ ᴺᵁᴸᴸ │
└────────────────────────────────────────┘
1 row in set. Elapsed: 0.001 sec.
```
Valores posibles:
* true — Se permite.
* false — No se permite.
## function\_locate\_has\_mysql\_compatible\_argument\_order
Controla el orden de los argumentos de la función [locate](/es/reference/functions/regular-functions/string-search-functions#locate).
Valores posibles:
* 0 — La función `locate` acepta los argumentos `(haystack, needle[, start_pos])`.
* 1 — La función `locate` acepta los argumentos `(needle, haystack, [, start_pos])` (comportamiento compatible con MySQL)
## function\_range\_max\_elements\_in\_block
Establece el umbral de seguridad para el volumen de datos generado por la función [range](/es/reference/functions/regular-functions/array-functions#range). Define el número máximo de valores que la función puede generar por bloque de datos (la suma de los tamaños de los arrays para cada fila de un bloque).
Valores posibles:
* Entero positivo.
**Véase también**
* [`max_block_size`](#max_block_size)
* [`min_insert_block_size_rows`](#min_insert_block_size_rows)
## function\_sleep\_max\_microseconds\_per\_block
Número máximo de microsegundos durante los que la función `sleep` puede suspenderse por cada bloque. Si un usuario la llama con un valor mayor, lanza una excepción. Es un umbral de seguridad.
## function\_visible\_width\_behavior
Versión del comportamiento de `visibleWidth`. 0: solo cuenta el número de puntos de código; 1: cuenta correctamente los caracteres de ancho cero y los caracteres combinantes, cuenta los caracteres de ancho completo como dos, estima el ancho de las tabulaciones y cuenta los caracteres de supresión.
## functions\_h3\_default\_if\_invalid
Si es false, las funciones h3, por ejemplo h3CellAreaM2, generan una excepción si la entrada no es válida. Si es true, devuelven 0 o el valor predeterminado.
## geo\_distance\_returns\_float64\_on\_float64\_arguments
Si los cuatro argumentos de las funciones `geoDistance`, `greatCircleDistance` y `greatCircleAngle` son Float64, estas devuelven Float64 y usan precisión doble para los cálculos internos. En versiones anteriores de ClickHouse, estas funciones siempre devolvían Float32.
## geotoh3\_argument\_order
La función `geoToH3` acepta (lon, lat) si está configurada como 'lon\_lat' y (lat, lon) si está configurada como 'lat\_lon'.
## glob\_expansion\_max\_elements
Número máximo de direcciones permitidas (para sistemas de almacenamiento externos, funciones de tabla, etc.).
## grace\_hash\_join\_initial\_buckets
Número inicial de buckets de grace hash join
## grace\_hash\_join\_max\_buckets
Límite en el número de buckets de grace hash join
## group\_by\_overflow\_mode
Establece qué ocurre cuando el número de claves únicas para la agregación supera el límite:
* `throw`: lanzar una excepción
* `break`: detener la ejecución de la consulta y devolver el resultado parcial
* `any`: continuar la agregación para las claves que entraron en el conjunto, pero sin añadir nuevas claves al conjunto.
Usar el valor `any` permite ejecutar una aproximación de GROUP BY. La calidad de
esta aproximación depende de la naturaleza estadística de los datos.
## group\_by\_two\_level\_threshold
A partir de cuántas claves comienza una agregación en dos niveles. 0: el umbral no está establecido.
## group\_by\_two\_level\_threshold\_bytes
A partir de qué tamaño del estado de agregación, en bytes, se empieza a usar una agregación en dos niveles. 0: el umbral no está establecido. La agregación en dos niveles se utiliza cuando se alcanza al menos uno de los umbrales.
## group\_by\_use\_nulls
Cambia la forma en que la [cláusula GROUP BY](/es/reference/statements/select/group-by) trata los tipos de las claves de agregación.
Cuando se usan los especificadores `ROLLUP`, `CUBE` o `GROUPING SETS`, es posible que algunas claves de agregación no se utilicen para generar algunas filas de resultados.
Las columnas de estas claves se rellenan con el valor predeterminado o con `NULL` en las filas correspondientes, según esta configuración.
Valores posibles:
* 0 — Se utiliza el valor predeterminado del tipo de clave de agregación para generar los valores faltantes.
* 1 — ClickHouse ejecuta `GROUP BY` de la misma forma que indica el estándar SQL. Los tipos de las claves de agregación se convierten a [Nullable](/es/reference/data-types/nullable). Las columnas de las claves de agregación correspondientes se rellenan con [NULL](/es/reference/syntax#null) en las filas donde no se usaron.
Véase también:
* [cláusula GROUP BY](/es/reference/statements/select/group-by)
## h3togeo\_lon\_lat\_result\_order
La función 'h3ToGeo' devuelve (lon, lat) si es true; de lo contrario, (lat, lon).
## handshake\_timeout\_ms
Tiempo de espera, en milisegundos, para recibir el paquete Hello de las réplicas durante el handshake.
## hdfs\_create\_new\_file\_on\_insert
Habilita o deshabilita la creación de un archivo nuevo en cada insert en las tablas del motor HDFS. Si está habilitado, en cada insert se creará un nuevo archivo HDFS con un nombre similar a este patrón:
inicial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
Valores posibles:
* 0 — la consulta `INSERT` añade nuevos datos al final del archivo.
* 1 — la consulta `INSERT` crea un archivo nuevo.
## hdfs\_ignore\_file\_doesnt\_exist
Ignora la ausencia de un archivo si este no existe al leer determinadas claves.
Valores posibles:
* 1 — `SELECT` devuelve un resultado vacío.
* 0 — `SELECT` lanza una excepción.
## hdfs\_replication
El número real de réplicas puede especificarse al crear el archivo hdfs.
## hdfs\_skip\_empty\_files
Habilita o deshabilita la omisión de archivos vacíos en las tablas con motor [HDFS](/es/reference/engines/table-engines/integrations/hdfs).
Valores posibles:
* 0 — `SELECT` lanza una excepción si el archivo vacío no es compatible con el formato solicitado.
* 1 — `SELECT` devuelve un resultado vacío para un archivo vacío.
## hdfs\_throw\_on\_zero\_files\_match
Genera un error si no se encuentra ningún archivo que coincida según las reglas de expansión de glob.
Valores posibles:
* 1 — `SELECT` lanza una excepción.
* 0 — `SELECT` devuelve un resultado vacío.
## hdfs\_truncate\_on\_insert
Habilita o deshabilita el truncado antes de un `insert` en tablas con el engine HDFS. Si está deshabilitado, se lanzará una excepción al intentar hacer un `insert` si el archivo ya existe en HDFS.
Valores posibles:
* 0 — la consulta `INSERT` agrega datos nuevos al final del archivo.
* 1 — la consulta `INSERT` reemplaza el contenido existente del archivo por los datos nuevos.
## hedged\_connection\_timeout\_ms
Tiempo de espera para establecer una conexión con una réplica en solicitudes hedged
## highlight\_max\_matches\_per\_row
Establece el número máximo de coincidencias de resaltado por fila en la función [highlight](/es/reference/functions/regular-functions/string-search-functions#highlight). Úselo para evitar un uso excesivo de memoria al resaltar patrones muy repetitivos en textos grandes.
Valores posibles:
* Entero positivo.
## hnsw\_candidate\_list\_size\_for\_search
El tamaño de la lista dinámica de candidatos al buscar en el índice de similitud vectorial, también conocido como 'ef\_search'.
## hsts\_max\_age
Tiempo de expiración de HSTS. 0 significa deshabilitar HSTS.
## http\_connection\_timeout
Tiempo de espera de la conexión HTTP (en segundos).
Valores posibles:
* Cualquier número entero positivo.
* 0 - Desactivado (tiempo de espera infinito).
No envíe la cabecera HTTP X-ClickHouse-Progress con una frecuencia superior al intervalo especificado.
Tiempo máximo, en segundos, para leer todas las cabeceras de la solicitud HTTP. Es un plazo total para toda la fase de análisis de cabeceras, no un `timeout` por lectura. Protege frente a ataques de tipo slowloris, en los que un cliente envía lentamente los datos de las cabeceras para mantener abiertas las conexiones.
## http\_make\_head\_request
La configuración `http_make_head_request` permite ejecutar una solicitud `HEAD` al leer datos desde HTTP para obtener información sobre el archivo que se va a leer, como su tamaño. Dado que está habilitada de forma predeterminada, puede ser conveniente desactivar esta configuración cuando el server no admita solicitudes `HEAD`.
## http\_max\_field\_name\_size
Longitud máxima del nombre del campo del encabezado HTTP
## http\_max\_field\_value\_size
Longitud máxima del valor de un campo en el encabezado HTTP
## http\_max\_fields
Número máximo de campos en el encabezado HTTP
## http\_max\_multipart\_form\_data\_size
Límite del tamaño del contenido `multipart/form-data`. Esta configuración no puede analizarse a partir de los parámetros de URL y debe establecerse en un perfil de usuario. Tenga en cuenta que el contenido se analiza y las tablas externas se crean en memoria antes de que comience la ejecución de la consulta. Además, este es el único límite que surte efecto en esa etapa (los límites de uso máximo de memoria y de tiempo máximo de ejecución no tienen efecto durante la lectura de form data de HTTP).
Tamaño máximo total de todos los encabezados de la solicitud HTTP (nombres y valores combinados), en bytes.
## http\_max\_request\_param\_data\_size
Límite del tamaño de los datos de la solicitud utilizados como parámetro de consulta en solicitudes HTTP predefinidas.
## http\_max\_tries
Número máximo de intentos de lectura a través de HTTP.
## http\_max\_uri\_size
Establece la longitud máxima del URI de una solicitud HTTP.
Valores posibles:
* Entero positivo.
## http\_native\_compression\_disable\_checksumming\_on\_decompress
Habilita o deshabilita la verificación de la suma de comprobación al descomprimir los datos de HTTP POST del cliente. Se usa solo para el formato de compresión nativo de ClickHouse (no se utiliza con `gzip` ni `deflate`).
Para obtener más información, consulte la [descripción de la interfaz HTTP](/es/concepts/features/interfaces/http).
Posibles valores:
* 0 — Deshabilitado.
* 1 — Habilitado.
## http\_receive\_timeout
Tiempo de espera de recepción de HTTP (en segundos).
Valores posibles:
* Cualquier entero positivo.
* 0 - Deshabilitado (tiempo de espera infinito).
## http\_response\_buffer\_size
La cantidad de bytes que se almacenan en búfer en la memoria del servidor antes de enviar una respuesta HTTP al cliente o volcarlos al disco (cuando http\_wait\_end\_of\_query está habilitado).
Permite añadir o sobrescribir cabeceras HTTP que el servidor devolverá en la respuesta cuando el resultado de la consulta sea correcto.
Esto solo afecta a la interfaz HTTP.
Si la cabecera ya está establecida de forma predeterminada, el valor proporcionado la sobrescribirá.
Si la cabecera no estaba establecida de forma predeterminada, se añadirá a la lista de cabeceras.
Las cabeceras que el servidor establece de forma predeterminada y que esta configuración no sobrescribe permanecerán.
Esta configuración permite establecer una cabecera con un valor constante. Actualmente no hay forma de establecer una cabecera con un valor calculado dinámicamente.
Ni los nombres ni los valores pueden contener caracteres de control ASCII.
Si implementa una aplicación con UI que permite a los usuarios modificar la configuración, pero al mismo tiempo toma decisiones en función de las cabeceras devueltas, se recomienda restringir esta configuración a readonly.
Ejemplo: `SET http_response_headers = '{"Content-Type": "image/png"}'`
## http\_retry\_initial\_backoff\_ms
Milisegundos mínimos de backoff al reintentar la lectura mediante HTTP
## http\_retry\_max\_backoff\_ms
Número máximo de milisegundos de backoff al reintentar una lectura mediante http
## http\_send\_timeout
Tiempo de espera de envío HTTP (en segundos).
Valores posibles:
* Cualquier entero positivo.
* 0 - Deshabilitado (timeout infinito).
Se aplica solo al perfil predeterminado. Es necesario reiniciar el servidor para que los cambios surtan efecto.
## http\_skip\_not\_found\_url\_for\_globs
Omitir las URL de los globs que devuelvan el error HTTP\_NOT\_FOUND
## http\_wait\_end\_of\_query
Activa el almacenamiento en búfer de la respuesta HTTP en el servidor.
## http\_write\_exception\_in\_output\_format
Escribe la excepción en el formato de salida para que la salida sea válida. Funciona con los formatos JSON y XML.
## http\_zlib\_compression\_level
Establece el nivel de compresión de los datos en la respuesta a una solicitud HTTP si [enable\_http\_compression = 1](#enable_http_compression).
Valores posibles: números del 1 al 9.
## iceberg\_compaction\_data\_cleanup
Tiempo tras el cual se eliminarán los datos.
## iceberg\_compaction\_delay\_bias
Tiempo mínimo de espera entre 2 operaciones de compactación en segundo plano.
## iceberg\_data\_file\_size\_lower\_threshold\_compaction
Umbral de compactación para archivos de datos en Iceberg.
## iceberg\_data\_file\_size\_upper\_threshold\_compaction
Umbral para los archivos de datos de compactación en Iceberg.
## iceberg\_delete\_data\_on\_drop
Indica si se deben eliminar todos los archivos de Iceberg al hacer drop.
## iceberg\_expire\_default\_max\_ref\_age\_ms
Valor predeterminado de la propiedad `history.expire.max-ref-age-ms` de la tabla Iceberg que utiliza `expire_snapshots` cuando dicha propiedad no está definida.
## iceberg\_expire\_default\_max\_snapshot\_age\_ms
Valor predeterminado de la propiedad de tabla Iceberg `history.expire.max-snapshot-age-ms` que usa `expire_snapshots` cuando dicha propiedad no está presente.
## iceberg\_expire\_default\_min\_snapshots\_to\_keep
Valor predeterminado de la propiedad `history.expire.min-snapshots-to-keep` de la tabla Iceberg que `expire_snapshots` utiliza cuando dicha propiedad no está definida.
## iceberg\_insert\_max\_bytes\_in\_data\_file
Número máximo de bytes del archivo de datos Parquet de Iceberg en una operación de inserción.
## iceberg\_insert\_max\_partitions
Número máximo de particiones permitido por operación de inserción para el motor de tabla Iceberg.
## iceberg\_insert\_max\_rows\_in\_data\_file
Número máximo de filas en el archivo de datos Parquet de Iceberg durante una operación de inserción.
## iceberg\_max\_number\_datafiles\_to\_compact
Umbral de compactación de archivos de datos en Iceberg.
## iceberg\_metadata\_compression\_method
Método de compresión del archivo `.metadata.json`.
## iceberg\_metadata\_log\_level
Controla el nivel de registro de metadatos de las tablas Iceberg en system.iceberg\_metadata\_log.
Normalmente, esta configuración puede modificarse con fines de depuración.
Valores posibles:
* none - Sin registro de metadatos.
* metadata - Archivo raíz metadata.json.
* manifest\_list\_metadata - Todo lo anterior + metadatos de la lista de manifiestos Avro correspondiente a una instantánea.
* manifest\_list\_entry - Todo lo anterior + entradas de la lista de manifiestos Avro.
* manifest\_file\_metadata - Todo lo anterior + metadatos de los archivos de manifiesto Avro recorridos.
* manifest\_file\_entry - Todo lo anterior + entradas de los archivos de manifiesto Avro recorridos.
## iceberg\_metadata\_staleness\_ms
Si no es cero, omite la obtención de metadatos de Iceberg desde el catálogo remoto si existe una instantánea de metadatos en caché más reciente que la ventana de antigüedad especificada. Un valor de cero significa que siempre se obtiene la versión más reciente de los metadatos desde el catálogo remoto. Configurar este valor con un valor distinto de cero implica aceptar cierta antigüedad a cambio de una menor latencia en las operaciones de lectura.
## iceberg\_orphan\_files\_older\_than\_seconds
Umbral de antigüedad predeterminado, en segundos, para eliminar archivos huérfanos en tablas Iceberg. Los archivos más recientes que este umbral no se consideran huérfanos. Se usa cuando se omite el argumento older\_than en la llamada al procedimiento remove\_orphan\_files(). El valor predeterminado es 259200 (3 días).
## iceberg\_snapshot\_id
Consulta la tabla Iceberg con el ID de snapshot especificado.
## iceberg\_timestamp\_ms
Consulta la tabla Iceberg usando la instantánea vigente en una marca de tiempo determinada.
## idle\_connection\_timeout
Tiempo de espera para cerrar las conexiones TCP inactivas tras el número de segundos especificado.
Valores posibles:
* Entero positivo (0: cerrar inmediatamente, tras 0 segundos).
## ignore\_cold\_parts\_seconds
Solo tiene efecto en ClickHouse Cloud. Excluye las partes de datos nuevas de las consultas SELECT hasta que se precalienten (consulta [cache\_populated\_by\_fetch](/es/reference/settings/merge-tree-settings#cache_populated_by_fetch)) o alcancen esta antigüedad en segundos. Solo para Replicated-/SharedMergeTree.
## ignore\_data\_skipping\_indices
Ignora los índices de omisión de datos especificados si la consulta los utiliza.
Considere el siguiente ejemplo:
```sql theme={null}
CREATE TABLE data
(
key Int,
x Int,
y Int,
INDEX x_idx x TYPE minmax GRANULARITY 1,
INDEX y_idx y TYPE minmax GRANULARITY 1,
INDEX xy_idx (x,y) TYPE minmax GRANULARITY 1
)
Engine=MergeTree()
ORDER BY key;
INSERT INTO data VALUES (1, 2, 3);
SELECT * FROM data;
SELECT * FROM data SETTINGS ignore_data_skipping_indices=''; -- la consulta producirá el error CANNOT_PARSE_TEXT.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='x_idx'; -- Ok.
SELECT * FROM data SETTINGS ignore_data_skipping_indices='na_idx'; -- Ok.
SELECT * FROM data WHERE x = 1 AND y = 1 SETTINGS ignore_data_skipping_indices='xy_idx',force_data_skipping_indices='xy_idx' ; -- la consulta producirá el error INDEX_NOT_USED, ya que xy_idx está explícitamente ignorado.
SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
```
La consulta sin ignorar ningún índice:
```sql theme={null}
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2;
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
Skip
Name: xy_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
```
Al ignorar el índice `xy_idx`:
```sql theme={null}
EXPLAIN indexes = 1 SELECT * FROM data WHERE x = 1 AND y = 2 SETTINGS ignore_data_skipping_indices='xy_idx';
Expression ((Projection + Before ORDER BY))
Filter (WHERE)
ReadFromMergeTree (default.data)
Indexes:
PrimaryKey
Condition: true
Parts: 1/1
Granules: 1/1
Skip
Name: x_idx
Description: minmax GRANULARITY 1
Parts: 0/1
Granules: 0/1
Skip
Name: y_idx
Description: minmax GRANULARITY 1
Parts: 0/0
Granules: 0/0
```
Se aplica a las tablas de la familia MergeTree.
## ignore\_drop\_queries\_probability
Si está habilitado, el servidor ignorará todas las consultas DROP TABLE con la probabilidad especificada (para los motores Memory y JOIN, sustituirá DROP por TRUNCATE). Se utiliza con fines de prueba
## ignore\_format\_null\_for\_explain
Si está habilitado, `FORMAT Null` se ignorará en las consultas `EXPLAIN` y se usará en su lugar el formato de salida predeterminado.
Si está deshabilitado, las consultas `EXPLAIN` con `FORMAT Null` no producirán ninguna salida (comportamiento compatible con versiones anteriores).
## ignore\_materialized\_views\_with\_dropped\_target\_table
Ignora las vistas materializadas cuya tabla de destino se ha eliminado al enviar a las vistas
## ignore\_on\_cluster\_for\_replicated\_access\_entities\_queries
Omite la cláusula ON CLUSTER en las consultas de gestión de entidades de acceso replicadas.
## ignore\_on\_cluster\_for\_replicated\_database
Ignora siempre la cláusula ON CLUSTER en las consultas DDL con bases de datos Replicated.
## ignore\_on\_cluster\_for\_replicated\_named\_collections\_queries
Ignora la cláusula ON CLUSTER en las consultas de gestión de colecciones con nombre replicadas.
## ignore\_on\_cluster\_for\_replicated\_udf\_queries
Omite la cláusula ON CLUSTER en las consultas de gestión de UDF replicadas.
## implicit\_select
Permite escribir consultas SELECT simples sin la palabra clave SELECT al principio, lo que facilita su uso como calculadora; por ejemplo, `1 + 2` se convierte en una consulta válida.
En `clickhouse-local` está habilitado de forma predeterminada y puede deshabilitarse explícitamente.
## implicit\_table\_at\_top\_level
Si no está vacía, las consultas sin FROM en el nivel superior leerán de esta tabla en lugar de system.one.
Se usa en clickhouse-local para procesar datos de entrada.
Un usuario puede establecer esta configuración explícitamente, pero no está pensada para ese tipo de uso.
Las subconsultas no se ven afectadas por esta configuración (ni las escalares ni las subconsultas de FROM o IN).
Las sentencias SELECT en el nivel superior de cadenas UNION, INTERSECT y EXCEPT se tratan de forma uniforme y se ven afectadas por esta configuración, independientemente de cómo se agrupen entre paréntesis.
No está especificado cómo afecta esta configuración a las vistas y a las consultas distribuidas.
La configuración acepta un nombre de tabla (en ese caso, la tabla se resuelve en la base de datos actual) o un nombre cualificado con el formato 'database.table'.
Tanto los nombres de la base de datos como los de la tabla deben ir sin comillas; solo se permiten identificadores simples.
## implicit\_transaction
Si está habilitado y aún no se está dentro de una transacción, encapsula la consulta en una transacción completa (begin + commit o rollback)
## inject\_random\_order\_for\_select\_without\_order\_by
Si está habilitada, inserta 'ORDER BY rand()' en las consultas SELECT sin cláusula ORDER BY.
Se aplica solo cuando la profundidad de la subconsulta es 0. Las subconsultas e INSERT INTO ... SELECT no se ven afectados.
Si la construcción de nivel superior es UNION, se inserta 'ORDER BY rand()' en todos los elementos secundarios de forma independiente.
Solo es útil para pruebas y desarrollo (la ausencia de ORDER BY es una fuente de resultados de consultas no deterministas).
## insert\_allow\_materialized\_columns
Si esta configuración está habilitada, permite usar columnas materializadas en INSERT.
## insert\_deduplicate
Activa o desactiva la deduplicación de bloques de `INSERT` (para tablas Replicated\*).
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
De forma predeterminada, los bloques insertados en tablas replicadas mediante la instrucción `INSERT` se deduplican (consulte [Replicación de datos](/es/reference/engines/table-engines/mergetree-family/replication)).
De forma predeterminada, en las tablas replicadas solo se deduplican los 100 bloques más recientes de cada partición (consulte [replicated\_deduplication\_window](/es/reference/settings/merge-tree-settings#replicated_deduplication_window), [replicated\_deduplication\_window\_seconds](/es/reference/settings/merge-tree-settings#replicated_deduplication_window_seconds)).
Para las tablas no replicadas, consulte [non\_replicated\_deduplication\_window](/es/reference/settings/merge-tree-settings#non_replicated_deduplication_window).
## insert\_deduplication\_token
Esta configuración permite que un usuario defina su propia semántica de deduplicación en MergeTree/ReplicatedMergeTree.
Por ejemplo, si proporciona un valor único para esta configuración en cada sentencia INSERT,
el usuario puede evitar que se deduzcan como duplicados los mismos datos insertados.
Valores posibles:
* Cualquier cadena
`insert_deduplication_token` se usa para la deduplicación *solo* cuando no está vacío.
En las tablas replicadas, de forma predeterminada, solo se deduplican las 100 inserciones más recientes de cada partición (consulte [replicated\_deduplication\_window](/es/reference/settings/merge-tree-settings#replicated_deduplication_window), [replicated\_deduplication\_window\_seconds](/es/reference/settings/merge-tree-settings#replicated_deduplication_window_seconds)).
Para las tablas no replicadas, consulte [non\_replicated\_deduplication\_window](/es/reference/settings/merge-tree-settings#non_replicated_deduplication_window).
`insert_deduplication_token` funciona a nivel de partición (igual que el checksum de `insert_deduplication`). Varias particiones pueden tener el mismo `insert_deduplication_token`.
Ejemplo:
```sql theme={null}
CREATE TABLE test_table
( A Int64 )
ENGINE = MergeTree
ORDER BY A
SETTINGS non_replicated_deduplication_window = 100;
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (1);
-- el siguiente insert no se deduplicará porque insert_deduplication_token es diferente
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test1' VALUES (1);
-- el siguiente insert se deduplicará porque insert_deduplication_token
-- es igual a uno de los anteriores
INSERT INTO test_table SETTINGS insert_deduplication_token = 'test' VALUES (2);
SELECT * FROM test_table
┌─A─┐
│ 1 │
└───┘
┌─A─┐
│ 1 │
└───┘
```
## insert\_keeper\_fault\_injection\_probability
Probabilidad aproximada de fallo de una solicitud a Keeper durante la inserción. El valor válido debe estar en el intervalo \[0.0f, 1.0f]
## insert\_keeper\_fault\_injection\_seed
0 - semilla aleatoria; de lo contrario, el valor de la configuración
## insert\_keeper\_max\_retries
Esta configuración establece el número máximo de reintentos para las solicitudes a ClickHouse Keeper (o ZooKeeper) durante la inserción en MergeTree replicado. Solo se reintentan las solicitudes a Keeper que fallan debido a un error de red, un timeout de sesión de Keeper o un timeout de solicitud.
Valores posibles:
* Entero positivo.
* 0 — Los reintentos están deshabilitados
Valor predeterminado de Cloud: `20`.
Los reintentos de solicitudes a Keeper se realizan tras un cierto timeout. El timeout está controlado por las siguientes configuraciones: `insert_keeper_retry_initial_backoff_ms`, `insert_keeper_retry_max_backoff_ms`.
El primer reintento se realiza tras el timeout de `insert_keeper_retry_initial_backoff_ms`. Los timeouts posteriores se calculan de la siguiente manera:
```
timeout = min(insert_keeper_retry_max_backoff_ms, latest_timeout * 2)
```
Por ejemplo, si `insert_keeper_retry_initial_backoff_ms=100`, `insert_keeper_retry_max_backoff_ms=10000` y `insert_keeper_max_retries=8`, los tiempos de espera serán `100, 200, 400, 800, 1600, 3200, 6400, 10000`.
Además de la tolerancia a fallos, los reintentos también buscan ofrecer una mejor experiencia de usuario: permiten evitar que se devuelva un error durante la ejecución de INSERT si Keeper se reinicia, por ejemplo, a causa de una actualización.
## insert\_keeper\_retry\_initial\_backoff\_ms
Tiempo de espera inicial (en milisegundos) para reintentar una solicitud fallida a Keeper durante la ejecución de la consulta INSERT
Valores posibles:
* Entero positivo.
* 0 — Sin tiempo de espera
## insert\_keeper\_retry\_max\_backoff\_ms
Tiempo de espera máximo (en milisegundos) para reintentar una solicitud de Keeper fallida durante la ejecución de una consulta INSERT
Valores posibles:
* Entero positivo.
* 0 — El tiempo de espera máximo no está limitado
## insert\_null\_as\_default
Habilita o deshabilita la inserción de [valores predeterminados](/es/reference/statements/create/table#default_values) en lugar de [NULL](/es/reference/syntax#null) en columnas con un tipo de datos no [Nullable](/es/reference/data-types/nullable).
Si el tipo de la columna no es Nullable y esta configuración está deshabilitada, al insertar `NULL` se produce una excepción. Si el tipo de la columna es Nullable, los valores `NULL` se insertan tal cual, independientemente de esta configuración.
Esta configuración se aplica a las consultas [INSERT ... SELECT](/es/reference/statements/insert-into#inserting-the-results-of-select). Ten en cuenta que las subconsultas `SELECT` pueden concatenarse con la cláusula `UNION ALL`.
Valores posibles:
* 0 — Insertar `NULL` en una columna no Nullable produce una excepción.
* 1 — Se inserta el valor predeterminado de la columna en lugar de `NULL`.
## insert\_quorum
Esta configuración no se aplica a SharedMergeTree; consulta [SharedMergeTree consistency](/es/products/cloud/features/infrastructure/shared-merge-tree#consistency) para obtener más información.
Habilita las escrituras con quorum.
* Si `insert_quorum < 2`, las escrituras con quorum están deshabilitadas.
* Si `insert_quorum >= 2`, las escrituras con quorum están habilitadas.
* Si `insert_quorum = 'auto'`, usa la mayoría (`number_of_replicas / 2 + 1`) como número de quorum.
Escrituras con quorum
`INSERT` solo se realiza correctamente cuando ClickHouse logra escribir correctamente los datos en `insert_quorum` réplicas dentro de `insert_quorum_timeout`. Si, por cualquier motivo, el número de réplicas con escrituras correctas no alcanza `insert_quorum`, la escritura se considera fallida y ClickHouse eliminará el bloque insertado de todas las réplicas en las que ya se hayan escrito datos.
Cuando `insert_quorum_parallel` está deshabilitado, todas las réplicas del quorum son consistentes; es decir, contienen datos de todas las consultas `INSERT` anteriores (la secuencia de `INSERT` se lineariza). Al leer datos escritos mediante `insert_quorum` y con `insert_quorum_parallel` deshabilitado, puedes activar la consistencia secuencial para las consultas `SELECT` mediante [select\_sequential\_consistency](#select_sequential_consistency).
ClickHouse genera una excepción:
* Si el número de réplicas disponibles en el momento de la consulta es menor que `insert_quorum`.
* Cuando `insert_quorum_parallel` está deshabilitado y se intenta escribir datos mientras el bloque anterior aún no se ha insertado en `insert_quorum` réplicas. Esta situación puede darse si el usuario intenta realizar otra consulta `INSERT` en la misma tabla antes de que se complete la anterior con `insert_quorum`.
Véase también:
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_quorum\_parallel
Esta configuración no se aplica a SharedMergeTree; consulta [consistencia de SharedMergeTree](/es/products/cloud/features/infrastructure/shared-merge-tree#consistency) para obtener más información.
Habilita o deshabilita el paralelismo para las consultas `INSERT` con cuórum. Si está habilitado, se pueden enviar consultas `INSERT` adicionales mientras las consultas anteriores aún no hayan finalizado. Si está deshabilitado, se rechazarán escrituras adicionales en la misma tabla.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
Véase también:
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_quorum\_timeout
Tiempo de espera, en milisegundos, para escribir en un quórum. Si el tiempo de espera ha transcurrido y todavía no se ha realizado ninguna escritura, ClickHouse generará una excepción y el cliente deberá repetir la consulta para escribir el mismo bloque en la misma o en cualquier otra réplica.
Véase también:
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
* [select\_sequential\_consistency](#select_sequential_consistency)
## insert\_shard\_id
Si no es `0`, especifica el segmento de la tabla [Distributed](/es/reference/engines/table-engines/special/distributed) en el que se insertarán los datos de forma síncrona.
Si el valor de `insert_shard_id` es incorrecto, el servidor lanzará una excepción.
Para obtener el número de segmentos en `requested_cluster`, puede consultar la configuración del servidor o usar esta consulta:
```sql theme={null}
SELECT uniq(shard_num) FROM system.clusters WHERE cluster = 'requested_cluster';
```
Valores posibles:
* 0 — Desactivado.
* Cualquier número entre `1` y `shards_num` de la tabla [Distributed](/es/reference/engines/table-engines/special/distributed) correspondiente.
**Ejemplo**
Consulta:
```sql theme={null}
CREATE TABLE x AS system.numbers ENGINE = MergeTree ORDER BY number;
CREATE TABLE x_dist AS x ENGINE = Distributed('test_cluster_two_shards_localhost', currentDatabase(), x);
INSERT INTO x_dist SELECT * FROM numbers(5) SETTINGS insert_shard_id = 1;
SELECT * FROM x_dist ORDER BY number ASC;
```
Resultado:
```text theme={null}
┌─number─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
│ 3 │
│ 3 │
│ 4 │
│ 4 │
└────────┘
```
## interactive\_delay
El intervalo, en microsegundos, para comprobar si se ha cancelado la ejecución de la petición y enviar el progreso.
## intersect\_default\_mode
Establece el modo predeterminado de la consulta INTERSECT. Valores posibles: cadena vacía, 'ALL', 'DISTINCT'. Si está vacío, una consulta sin modo generará una excepción.
## jemalloc\_collect\_profile\_samples\_in\_trace\_log
Recopila muestras de asignación y liberación de memoria de jemalloc en el registro de trazas.
## jemalloc\_enable\_profiler
Habilita el perfilador de jemalloc para la consulta. Jemalloc tomará muestras de las asignaciones y de todas las liberaciones de memoria de las asignaciones muestreadas.
Los perfiles se pueden vaciar con SYSTEM JEMALLOC FLUSH PROFILE para analizarlos.
Las muestras también se pueden almacenar en system.trace\_log usando la configuración jemalloc\_collect\_global\_profile\_samples\_in\_trace\_log o la configuración de consulta jemalloc\_collect\_profile\_samples\_in\_trace\_log.
Consulta [Perfilado de asignaciones](/es/concepts/features/performance/allocation-profiling)
## jemalloc\_profile\_text\_collapsed\_use\_count
Al usar el formato de salida 'collapsed' para el perfil de heap de jemalloc, se agrega por número de asignaciones en lugar de por bytes. Cuando es false (predeterminado), cada pila se pondera por bytes activos; cuando es true, por el número de asignaciones activas.
## jemalloc\_profile\_text\_output\_format
Formato de salida del perfil de heap de jemalloc en la tabla system.jemalloc\_profile\_text. Puede ser: 'raw' (perfil sin procesar), 'symbolized' (formato jeprof con símbolos) o 'collapsed' (formato FlameGraph).
## jemalloc\_profile\_text\_symbolize\_with\_inline
Si se deben incluir frames inline al simbolizar el perfil del heap de jemalloc. Cuando está habilitada, los frames inline se incluyen, lo que puede ralentizar drásticamente el proceso de simbolización; cuando está deshabilitada, se omiten. Solo afecta a los formatos de salida 'symbolized' y 'collapsed'.
## join\_algorithm
Especifica qué algoritmo de [JOIN](/es/reference/statements/select/join) se usa.
Se pueden especificar varios algoritmos, y se elegirá uno disponible para una consulta concreta según el tipo/la strictness y el motor de tabla.
Posibles valores:
* grace\_hash
Se usa [Grace hash join](https://en.wikipedia.org/wiki/Hash_join#Grace_hash_join). Grace hash ofrece una opción de algoritmo para realizar joins complejos con buen rendimiento, limitando al mismo tiempo el uso de memoria.
La primera fase de un grace join lee la tabla derecha y la divide en N buckets según el hash de las columnas clave (inicialmente, N es `grace_hash_join_initial_buckets`). Esto se hace de forma que cada bucket pueda procesarse de manera independiente. Las filas del primer bucket se añaden a una tabla hash en memoria, mientras que las demás se guardan en disco. Si la tabla hash supera el límite de memoria (por ejemplo, el definido por [`max_bytes_in_join`](/es/reference/settings/session-settings#max_bytes_in_join)), se incrementa el número de buckets y se vuelve a asignar el bucket correspondiente a cada fila. Las filas que no pertenezcan al bucket actual se vacían y se reasignan.
Admite `INNER/LEFT/RIGHT/FULL ALL/ANY JOIN`.
* hash
Se usa [Hash join algorithm](https://en.wikipedia.org/wiki/Hash_join). Es la implementación más genérica: admite todas las combinaciones de tipo y strictness, así como múltiples claves de join combinadas con `OR` en la sección `JOIN ON`.
Al usar el algoritmo `hash`, la parte derecha de `JOIN` se carga en RAM.
* parallel\_hash
Una variación de `hash` join que divide los datos en buckets y construye varias tablas hash en lugar de una, de forma concurrente, para acelerar este proceso.
Al usar el algoritmo `parallel_hash`, la parte derecha de `JOIN` se carga en RAM.
* partial\_merge
Una variación del [algoritmo sort-merge](https://en.wikipedia.org/wiki/Sort-merge_join), donde solo la tabla derecha se ordena por completo.
`RIGHT JOIN` y `FULL JOIN` solo se admiten con strictness `ALL` (`SEMI`, `ANTI`, `ANY` y `ASOF` no son compatibles).
Al usar el algoritmo `partial_merge`, ClickHouse ordena los datos y los vuelca a disco. El algoritmo `partial_merge` en ClickHouse difiere ligeramente de la implementación clásica. Primero, ClickHouse ordena la tabla derecha por las claves de join en bloques y crea un índice min-max para los bloques ordenados. Luego ordena partes de la tabla izquierda por la `join key` y las une con la tabla derecha. El índice min-max también se usa para omitir bloques innecesarios de la tabla derecha.
* direct
El algoritmo `direct` (también conocido como nested loop) realiza una búsqueda en la tabla derecha usando como claves las filas de la tabla izquierda.
Es compatible con motores especiales como [Dictionary](/es/reference/engines/table-engines/special/dictionary), [EmbeddedRocksDB](/es/reference/engines/table-engines/integrations/embedded-rocksdb) y tablas [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree).
Para las tablas MergeTree, el algoritmo aplica filtros de join key directamente a la capa de almacenamiento. Esto puede ser más eficiente cuando la clave puede usar el índice de primary key de la tabla para las búsquedas; de lo contrario, realiza escaneos completos de la tabla derecha para cada bloque de la tabla izquierda.
Admite joins `INNER` y `LEFT`, y solo claves de join de igualdad de una sola columna, sin otras condiciones.
* auto
Cuando se establece en `auto`, primero se prueba `hash` join, y el algoritmo cambia dinámicamente a otro si se supera el límite de memoria.
* full\_sorting\_merge
[Algoritmo sort-merge](https://en.wikipedia.org/wiki/Sort-merge_join) con ordenación completa de las tablas antes de realizar el join.
* prefer\_partial\_merge
ClickHouse siempre intenta usar `partial_merge` join si es posible; de lo contrario, usa `hash`. *Obsoleto*, igual que `partial_merge,hash`.
* default (obsoleto)
Valor heredado; no lo use.
Igual que `direct,hash`, es decir, intenta usar direct join y hash join (en este orden).
## join\_any\_take\_last\_row
Cambia el comportamiento de las operaciones `JOIN` con strictness `ANY`.
Esta configuración se aplica solo a las operaciones `JOIN` con tablas del motor [Join](/es/reference/engines/table-engines/special/join).
Valores posibles:
* 0 — Si la tabla de la derecha tiene más de una fila coincidente, solo se une la primera encontrada.
* 1 — Si la tabla de la derecha tiene más de una fila coincidente, solo se une la última encontrada.
Véase también:
* [cláusula JOIN](/es/reference/statements/select/join)
* [motor de tabla Join](/es/reference/engines/table-engines/special/join)
* [join\_default\_strictness](#join_default_strictness)
## join\_default\_strictness
Establece la estrictez predeterminada para las [cláusulas JOIN](/es/reference/statements/select/join).
Valores posibles:
* `ALL` — Si la tabla de la derecha tiene varias filas coincidentes, ClickHouse crea un [producto cartesiano](https://en.wikipedia.org/wiki/Cartesian_product) a partir de las filas coincidentes. Este es el comportamiento normal de `JOIN` en SQL estándar.
* `ANY` — Si la tabla de la derecha tiene varias filas coincidentes, solo se une la primera que se encuentra. Si la tabla de la derecha tiene solo una fila coincidente, los resultados de `ANY` y `ALL` son los mismos.
* `ASOF` — Para unir secuencias con una coincidencia incierta.
* `Cadena vacía` — Si no se especifica `ALL` o `ANY` en la consulta, ClickHouse lanza una excepción.
## join\_on\_disk\_max\_files\_to\_merge
Limita el número de archivos permitidos para la ordenación paralela en operaciones MergeJoin cuando se ejecutan en disco.
Cuanto mayor sea el valor de la configuración, más RAM se utiliza y menos operaciones de E/S en disco se necesitan.
Posibles valores:
* Cualquier número entero positivo a partir de 2.
## join\_output\_by\_rowlist\_perkey\_rows\_threshold
El límite inferior del promedio de filas por clave en la tabla de la derecha para determinar si la salida debe generarse mediante una lista de filas en hash join.
## join\_overflow\_mode
Define qué acción realiza ClickHouse cuando se alcanza alguno de los siguientes límites de join:
* [max\_bytes\_in\_join](/es/reference/settings/session-settings#max_bytes_in_join)
* [max\_rows\_in\_join](/es/reference/settings/session-settings#max_rows_in_join)
Valores posibles:
* `THROW` — ClickHouse genera una excepción e interrumpe la operación.
* `BREAK` — ClickHouse interrumpe la operación y no genera una excepción.
Valor predeterminado: `THROW`.
**Vea también**
* [cláusula JOIN](/es/reference/statements/select/join)
* [motor de tabla Join](/es/reference/engines/table-engines/special/join)
## join\_runtime\_bloom\_filter\_bytes
Tamaño en bytes de un filtro de Bloom utilizado como filtro de tiempo de ejecución de JOIN (consulte la configuración enable\_join\_runtime\_filters).
## join\_runtime\_bloom\_filter\_hash\_functions
Número de funciones hash de un bloom filter utilizado como filtro runtime para JOIN (consulte la configuración enable\_join\_runtime\_filters).
## join\_runtime\_bloom\_filter\_max\_ratio\_of\_set\_bits
Si la cantidad de bits activados en un bloom filter en tiempo de ejecución supera esta proporción, el filtro se desactiva por completo para reducir la sobrecarga.
## join\_runtime\_filter\_blocks\_to\_skip\_before\_reenabling
Número de bloques que se omiten antes de intentar volver a habilitar dinámicamente un filtro de runtime que se había deshabilitado previamente debido a una tasa de filtrado deficiente.
## join\_runtime\_filter\_exact\_values\_limit
Número máximo de elementos del runtime filter que se almacenan tal cual en un conjunto; cuando se supera este umbral, se cambia a bloom filter.
## join\_runtime\_filter\_pass\_ratio\_threshold\_for\_disabling
Si la proporción entre las filas que pasan el filtro y las filas comprobadas supera este umbral, el filtro de tiempo de ejecución se considera poco eficaz y se desactiva durante los siguientes `join_runtime_filter_blocks_to_skip_before_reenabling` bloques para reducir la sobrecarga.
## join\_to\_sort\_maximum\_table\_rows
El número máximo de filas de la tabla derecha para determinar si se debe reordenar por clave en un left o inner join.
## join\_to\_sort\_minimum\_perkey\_rows
El límite inferior del promedio de filas por clave en la tabla de la derecha para determinar si se debe volver a ordenar la tabla de la derecha por clave en un left o inner join. Esta configuración garantiza que la optimización no se aplique a claves dispersas de la tabla
## join\_use\_nulls
Establece el comportamiento de [JOIN](/es/reference/statements/select/join). Al unir tablas, pueden aparecer celdas vacías. ClickHouse las rellena de forma distinta según esta configuración.
Posibles valores:
* 0 — Las celdas vacías se rellenan con el valor predeterminado del tipo de campo correspondiente.
* 1 — `JOIN` se comporta igual que en el SQL estándar. El tipo del campo correspondiente se convierte en [Nullable](/es/reference/data-types/nullable), y las celdas vacías se rellenan con [NULL](/es/reference/syntax).
## joined\_block\_split\_single\_row
Permite dividir en fragmentos el resultado de un hash join por las filas correspondientes a una única fila de la tabla izquierda.
Esto puede reducir el uso de memoria en el caso de una fila con muchas coincidencias en la tabla derecha, pero puede aumentar el uso de CPU.
Ten en cuenta que `max_joined_block_size_rows != 0` es obligatorio para que esta configuración surta efecto.
`max_joined_block_size_bytes`, combinado con esta configuración, ayuda a evitar un uso excesivo de memoria en casos de datos sesgados, con algunas filas grandes que tienen muchas coincidencias en la tabla derecha.
## joined\_subquery\_requires\_alias
Obliga a que las subconsultas incluidas en JOIN y las funciones de tabla tengan alias para que la calificación de nombres sea correcta.
## kafka\_disable\_num\_consumers\_limit
Desactiva el límite de kafka\_num\_consumers que depende del número de núcleos de CPU disponibles.
## kafka\_max\_wait\_ms
El tiempo de espera, en milisegundos, para leer mensajes de [Kafka](/es/reference/engines/table-engines/integrations/kafka) antes de reintentar.
Valores posibles:
* Entero positivo.
* 0 — Tiempo de espera infinito.
Véase también:
* [Apache Kafka](https://kafka.apache.org/)
## keeper\_map\_strict\_mode
Aplica comprobaciones adicionales durante las operaciones en KeeperMap. Por ejemplo, lanzar una excepción al insertar una clave que ya existe
## keeper\_max\_retries
Número máximo de reintentos para operaciones generales de Keeper
## keeper\_retry\_initial\_backoff\_ms
Tiempo de espera del backoff inicial para las operaciones generales de Keeper
## keeper\_retry\_max\_backoff\_ms
Tiempo máximo de backoff para las operaciones generales de Keeper
## least\_greatest\_legacy\_null\_behavior
Si está activada, las funciones 'least' y 'greatest' devuelven NULL si uno de sus argumentos es NULL.
## legacy\_column\_name\_of\_tuple\_literal
Muestra en los nombres de columna todos los nombres de los elementos de los literales Tuple grandes en lugar del hash. Esta configuración existe solo por motivos de compatibilidad. Tiene sentido establecerla en 'true' mientras se realiza una actualización gradual del clúster desde una versión anterior a la 21.7 a una posterior.
## lightweight\_delete\_mode
Modo de consulta de actualización interna que se ejecuta como parte de la eliminación ligera.
Valores posibles:
* `alter_update` - ejecuta la consulta `ALTER UPDATE`, que crea una mutación pesada.
* `lightweight_update` - ejecuta la actualización ligera si es posible; de lo contrario, ejecuta `ALTER UPDATE`.
* `lightweight_update_force` - ejecuta la actualización ligera si es posible; de lo contrario, genera una excepción.
## lightweight\_deletes\_sync
Lo mismo que [`mutations_sync`](#mutations_sync), pero solo controla la ejecución de eliminaciones ligeras.
Valores posibles:
| Valor | Descripción |
| ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `0` | Las mutaciones se ejecutan de forma asíncrona. |
| `1` | La consulta espera a que las eliminaciones ligeras finalicen en el servidor actual. |
| `2` | La consulta espera a que las eliminaciones ligeras finalicen en todas las réplicas (si existen). |
| `3` | La consulta espera solo a las réplicas activas. Solo compatible con `SharedMergeTree`. Para `ReplicatedMergeTree`, se comporta igual que `mutations_sync = 2`. |
**Véase también**
* [Sincronía de las consultas ALTER](/es/reference/statements/alter#synchronicity-of-alter-queries)
* [Mutations](/es/reference/statements/alter#mutations)
Valor predeterminado en Cloud: `1`.
## limit
Establece el número máximo de filas que se pueden obtener del resultado de la consulta. Ajusta el valor establecido por la cláusula [LIMIT](/es/reference/statements/select/limit), de modo que el límite especificado en la consulta no pueda superar el límite establecido por esta opción de configuración.
Posibles valores:
* 0 — El número de filas no está limitado.
* Entero positivo.
## load\_balancing
Especifica el algoritmo de selección de réplicas utilizado para el procesamiento distribuido de consultas.
ClickHouse admite los siguientes algoritmos de selección de réplicas:
* [Random](#load_balancing-random) (de forma predeterminada)
* [Nearest hostname](#load_balancing-nearest_hostname)
* [Hostname levenshtein distance](#load_balancing-hostname_levenshtein_distance)
* [In order](#load_balancing-in_order)
* [First or random](#load_balancing-first_or_random)
* [Round robin](#load_balancing-round_robin)
Véase también:
* [distributed\_replica\_max\_ignored\_errors](#distributed_replica_max_ignored_errors)
### Random (por defecto)
```sql theme={null}
load_balancing = random
```
Se cuenta el número de errores de cada réplica. La consulta se envía a la réplica con menos errores y, si hay varias en esa situación, a cualquiera de ellas.
Desventajas: no se tiene en cuenta la proximidad del servidor; si las réplicas tienen datos distintos, también obtendrá datos distintos.
### Hostname más cercano
```sql theme={null}
load_balancing = nearest_hostname
```
Se cuenta el número de errores de cada réplica. Cada 5 minutos, el número de errores se divide entre 2 mediante división entera. Así, el número de errores se calcula para un periodo reciente con suavizado exponencial. Si hay una réplica con el menor número de errores (es decir, si recientemente se produjeron errores en las otras réplicas), la consulta se envía a esa réplica. Si hay varias réplicas con el mismo número mínimo de errores, la consulta se envía a la réplica cuyo hostname más se parezca al hostname del servidor en el archivo de configuración (según el número de caracteres distintos en posiciones idénticas, hasta la longitud mínima de ambos hostnames).
Por ejemplo, example01-01-1 y example01-01-2 difieren en una posición, mientras que example01-01-1 y example01-02-2 difieren en dos posiciones.
Este método puede parecer primitivo, pero no requiere datos externos sobre la topología de la red y no compara direcciones IP, lo cual sería complicado en el caso de nuestras direcciones IPv6.
Así, si hay réplicas equivalentes, se da preferencia a la que tenga el nombre más parecido.
También podemos suponer que, al enviar una consulta al mismo servidor, si no hay fallos, una consulta distribuida también irá a los mismos servidores. Por lo tanto, aunque en las réplicas haya datos distintos, la consulta devolverá prácticamente los mismos resultados.
### Distancia de Levenshtein del nombre de host
```sql theme={null}
load_balancing = hostname_levenshtein_distance
```
Al igual que `nearest_hostname`, pero compara el hostname según la [distancia de Levenshtein](https://en.wikipedia.org/wiki/Levenshtein_distance). Por ejemplo:
```text theme={null}
example-clickhouse-0-0 ample-clickhouse-0-0
1
example-clickhouse-0-0 example-clickhouse-1-10
2
example-clickhouse-0-0 example-clickhouse-12-0
3
```
### In Order
```sql theme={null}
load_balancing = in_order
```
Se accede a las réplicas con el mismo número de errores en el mismo orden en que se especifican en la configuración.
Este método es apropiado cuando se sabe exactamente qué réplica es preferible.
### First or Random
```sql theme={null}
load_balancing = first_or_random
```
Este algoritmo elige la primera réplica del conjunto o una réplica aleatoria si la primera no está disponible. Es eficaz en topologías de replicación cruzada, pero no resulta útil en otras configuraciones.
El algoritmo `first_or_random` resuelve el problema del algoritmo `in_order`. Con `in_order`, si una réplica deja de estar disponible, la siguiente recibe el doble de carga, mientras que las demás réplicas manejan la cantidad habitual de tráfico. Al usar el algoritmo `first_or_random`, la carga se distribuye uniformemente entre las réplicas que siguen disponibles.
Es posible definir explícitamente cuál es la primera réplica mediante la configuración `load_balancing_first_offset`. Esto ofrece un mayor control para redistribuir las cargas de trabajo de las consultas entre réplicas.
### Round Robin
```sql theme={null}
load_balancing = round_robin
```
Este algoritmo utiliza una política de round robin entre las réplicas con el mismo número de errores (solo se tienen en cuenta las consultas con la política `round_robin`).
## load\_balancing\_first\_offset
A qué réplica enviar preferentemente una consulta cuando se usa la estrategia de balanceo de carga FIRST\_OR\_RANDOM.
## load\_marks\_asynchronously
Cargar las marcas de MergeTree de forma asíncrona
Valor predeterminado en Cloud: `1`.
## local\_filesystem\_read\_method
Método para leer datos del sistema de archivos local; puede ser uno de los siguientes: read, pread, mmap, io\_uring, pread\_threadpool.
El método 'io\_uring' es experimental y no funciona con Log, TinyLog, StripeLog, File, Set y Join, ni con otras tablas cuyos archivos permiten anexar datos cuando hay lecturas y escrituras concurrentes.
Si lees varios artículos sobre 'io\_uring' en Internet, no te dejes impresionar por ellos. No es un método mejor para leer archivos, salvo en el caso de una gran cantidad de solicitudes de IO pequeñas, que no es el caso de ClickHouse. No hay motivos para habilitar 'io\_uring'.
## local\_filesystem\_read\_prefetch
Debe usarse la precarga al leer datos del sistema de archivos local.
## lock\_acquire\_timeout
Define cuántos segundos espera una solicitud de bloqueo antes de fallar.
El tiempo de espera de bloqueo se usa para evitar interbloqueos al ejecutar operaciones de lectura y escritura en tablas. Cuando vence el tiempo de espera y la solicitud de bloqueo falla, el servidor ClickHouse lanza la excepción "Locking attempt timed out! Possible deadlock avoided. Client should retry." con el código de error `DEADLOCK_AVOIDED`.
Valores posibles:
* Entero positivo (en segundos).
* 0 — Sin tiempo de espera de bloqueo.
Especifica el valor del campo `log_comment` de la tabla [system.query\_log](/es/reference/system-tables/query_log) y el texto del comentario para el registro del servidor.
Puede utilizarse para mejorar la legibilidad de los registros del servidor. Además, ayuda a seleccionar las consultas relacionadas con la prueba en `system.query_log` después de ejecutar [clickhouse-test](/es/resources/develop-contribute/contribute/tests).
Valores posibles:
* Cualquier cadena de longitud no superior a [max\_query\_size](#max_query_size). Si se supera `max_query_size`, el servidor lanza una excepción.
**Ejemplo**
Consulta:
```sql theme={null}
SET log_comment = 'log_comment test', log_queries = 1;
SELECT 1;
SYSTEM FLUSH LOGS;
SELECT type, query FROM system.query_log WHERE log_comment = 'log_comment test' AND event_date >= yesterday() ORDER BY event_time DESC LIMIT 2;
```
Resultado:
```text theme={null}
┌─type────────┬─query─────┐
│ QueryStart │ SELECT 1; │
│ QueryFinish │ SELECT 1; │
└─────────────┴───────────┘
```
## log\_formatted\_queries
Permite registrar consultas con formato en la tabla del sistema [system.query\_log](/es/reference/system-tables/query_log) (rellena la columna `formatted_query` de [system.query\_log](/es/reference/system-tables/query_log)).
Valores posibles:
* 0 — Las consultas con formato no se registran en la tabla del sistema.
* 1 — Las consultas con formato se registran en la tabla del sistema.
## log\_processors\_profiles
Escribe en la tabla `system.processors_profile_log` el tiempo que el procesador dedicó a la ejecución o a esperar datos.
Véase también:
* [`system.processors_profile_log`](/es/reference/system-tables/processors_profile_log)
* [`EXPLAIN PIPELINE`](/es/reference/statements/explain#explain-pipeline)
## log\_profile\_events
Registra estadísticas de rendimiento de consultas en query\_log, query\_thread\_log y query\_views\_log.
## log\_queries
Habilita el registro de consultas.
Las consultas enviadas a ClickHouse con esta configuración se registran según las reglas del parámetro de configuración del servidor [query\_log](/es/reference/settings/server-settings/settings#query_log).
Ejemplo:
```text theme={null}
log_queries=1
```
## log\_queries\_cut\_to\_length
Si la longitud de la consulta supera un umbral especificado (en bytes), la consulta se recorta al escribirla en el registro de consultas. También se limita la longitud de la consulta impresa en el registro de texto normal.
## log\_queries\_min\_query\_duration\_ms
Si está habilitado (distinto de cero), no se registrarán las consultas cuya duración sea inferior al valor de esta configuración (puede considerarlo como un `long_query_time` para [MySQL Slow Query Log](https://dev.mysql.com/doc/refman/5.7/slow-query-log.html)), lo que básicamente significa que no las encontrará en las siguientes tablas:
* `system.query_log`
* `system.query_thread_log`
Solo se registrarán en el log las consultas con el siguiente tipo:
* `QUERY_FINISH`
* `EXCEPTION_WHILE_PROCESSING`
* Tipo: milisegundos
* Valor predeterminado: 0 (cualquier consulta)
## log\_queries\_min\_type
Tipo mínimo que se registrará en `query_log`.
Valores posibles:
* `QUERY_START` (`=1`)
* `QUERY_FINISH` (`=2`)
* `EXCEPTION_BEFORE_START` (`=3`)
* `EXCEPTION_WHILE_PROCESSING` (`=4`)
Puede usarse para limitar qué eventos se escribirán en `query_log`; por ejemplo, si solo le interesan los errores, puede usar `EXCEPTION_WHILE_PROCESSING`:
```text theme={null}
log_queries_min_type='EXCEPTION_WHILE_PROCESSING'
```
## log\_queries\_probability
Permite que un usuario escriba en las tablas del sistema [query\_log](/es/reference/system-tables/query_log), [query\_thread\_log](/es/reference/system-tables/query_thread_log) y [query\_views\_log](/es/reference/system-tables/query_views_log) solo una muestra de consultas seleccionadas aleatoriamente con la probabilidad especificada. Esto ayuda a reducir la carga cuando hay un gran volumen de consultas por segundo.
Valores posibles:
* 0 — Las consultas no se registran en las tablas del sistema.
* Número de coma flotante positivo en el intervalo \[0..1]. Por ejemplo, si el valor de la configuración es `0.5`, aproximadamente la mitad de las consultas se registran en las tablas del sistema.
* 1 — Todas las consultas se registran en las tablas del sistema.
## log\_query\_settings
Registra la configuración de la consulta en query\_log y en el registro de spans de OpenTelemetry.
## log\_query\_threads
Configura el registro de los hilos de consulta.
Los hilos de consulta se registran en la tabla [system.query\_thread\_log](/es/reference/system-tables/query_thread_log). Esta configuración solo surte efecto cuando [log\_queries](#log_queries) es true. Los hilos de las consultas ejecutadas por ClickHouse con esta configuración se registran según las reglas del parámetro de configuración del servidor [query\_thread\_log](/es/reference/settings/server-settings/settings#query_thread_log).
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
**Ejemplo**
```text theme={null}
log_query_threads=1
```
## log\_query\_views
Configura el registro de las vistas de consulta.
Cuando una consulta ejecutada por ClickHouse con este ajuste habilitado tiene vistas asociadas (materializadas o live views), estas se registran en el parámetro de configuración del servidor [query\_views\_log](/es/reference/settings/server-settings/settings#query_views_log).
Ejemplo:
```text theme={null}
log_query_views=1
```
## low\_cardinality\_allow\_in\_native\_format
Permite o restringe el uso del tipo de dato [LowCardinality](/es/reference/data-types/lowcardinality) con el formato [Native](/es/reference/formats/Native).
Si el uso de `LowCardinality` está restringido, ClickHouse server convierte las columnas `LowCardinality` en columnas normales para las consultas `SELECT` y las columnas normales en columnas `LowCardinality` para las consultas `INSERT`.
Esta configuración es necesaria principalmente para clientes de terceros que no admiten el tipo de dato `LowCardinality`.
Valores posibles:
* 1 — El uso de `LowCardinality` no está restringido.
* 0 — El uso de `LowCardinality` está restringido.
## low\_cardinality\_max\_dictionary\_size
Establece el tamaño máximo, en filas, de un diccionario global compartido para el tipo de datos [LowCardinality](/es/reference/data-types/lowcardinality) que puede escribirse en el sistema de archivos de almacenamiento. Esta configuración evita problemas de RAM en caso de que el diccionario crezca sin límite. ClickHouse escribe por el método habitual todos los datos que no pueden codificarse debido a la limitación del tamaño máximo del diccionario.
Valores posibles:
* Cualquier entero positivo.
## low\_cardinality\_use\_single\_dictionary\_for\_part
Activa o desactiva el uso de un único diccionario para la parte de datos.
De forma predeterminada, el servidor de ClickHouse supervisa el tamaño de los diccionarios y, si un diccionario supera el límite, el servidor comienza a escribir el siguiente. Para impedir la creación de varios diccionarios, establezca `low_cardinality_use_single_dictionary_for_part = 1`.
Valores posibles:
* 1 — Se prohíbe crear varios diccionarios para la parte de datos.
* 0 — No se prohíbe crear varios diccionarios para la parte de datos.
## low\_priority\_query\_wait\_time\_ms
Cuando se utiliza el mecanismo de priorización de consultas (consulte la configuración `priority`), las consultas de baja prioridad esperan a que terminen las consultas de mayor prioridad. Esta configuración especifica el tiempo de espera.
## make\_distributed\_plan
Crea el plan de consulta distribuida.
## materialize\_skip\_indexes\_on\_insert
Indica si las operaciones INSERT crean y almacenan índices de salto. Si está deshabilitado, los índices de salto solo se crearán y almacenarán [durante las fusiones](/es/reference/settings/merge-tree-settings#materialize_skip_indexes_on_merge) o mediante [MATERIALIZE INDEX](/es/reference/statements/alter/skipping-index#materialize-index) explícito.
Véase también [exclude\_materialize\_skip\_indexes\_on\_insert](#exclude_materialize_skip_indexes_on_insert).
## materialize\_statistics\_on\_insert
Indica si los INSERT generan e insertan estadísticas. Si está desactivado, las estadísticas se crearán y almacenarán durante los merges o mediante MATERIALIZE STATISTICS explícito
## materialize\_ttl\_after\_modify
Aplica TTL a los datos antiguos después de la consulta ALTER MODIFY TTL
## materialized\_views\_ignore\_errors
Permite ignorar los errores de MATERIALIZED VIEW y enviar el bloque original a la tabla independientemente de las MV
## materialized\_views\_squash\_parallel\_inserts
Combina las inserciones de una única consulta INSERT en la tabla de destino de las vistas materializadas a partir de inserciones paralelas para reducir la cantidad de partes generadas.
Si se establece en false y `parallel_view_processing` está habilitado, la consulta INSERT generará una parte en la tabla de destino por cada `max_insert_thread`.
## max\_analyze\_depth
Número máximo de análisis que realiza el intérprete.
## max\_ast\_depth
La profundidad máxima de anidamiento del árbol sintáctico de una consulta. Si se supera, se lanza una excepción.
En este momento, no se comprueba durante el análisis sintáctico, sino solo después de analizar la consulta.
Esto significa que durante el análisis sintáctico se puede crear un árbol sintáctico demasiado profundo,
pero la consulta fallará.
## max\_ast\_elements
El número máximo de elementos en el árbol sintáctico de una consulta. Si se supera, se lanza una excepción.
Actualmente, no se comprueba durante el análisis, sino solo después de analizar la consulta.
Esto significa que durante el análisis puede crearse un árbol sintáctico demasiado profundo,
pero la consulta fallará.
## max\_autoincrement\_series
El límite de la cantidad de series creadas por la función `generateSerialID`.
Como cada serie representa un nodo en Keeper, se recomienda no tener más de un par de millones.
## max\_backup\_bandwidth
La velocidad máxima de lectura, en bytes por segundo, para una copia de seguridad concreta en el server. Cero significa que no hay límite.
## max\_block\_size
En ClickHouse, los datos se procesan en bloques, que son conjuntos de partes de columnas. Los ciclos internos de procesamiento de un solo bloque son eficientes, pero procesar cada bloque conlleva costos perceptibles.
La configuración `max_block_size` indica el número máximo recomendado de filas que se deben incluir en un solo bloque al cargar datos desde tablas. No siempre se cargan de la tabla bloques del tamaño de `max_block_size`: si ClickHouse determina que es necesario recuperar menos datos, se procesa un bloque más pequeño.
El tamaño del bloque no debe ser demasiado pequeño, para evitar costos perceptibles al procesar cada bloque. Tampoco debe ser demasiado grande, para garantizar que las consultas con una cláusula LIMIT se ejecuten rápidamente después de procesar el primer bloque. Al configurar `max_block_size`, el objetivo debe ser evitar consumir demasiada memoria al extraer una gran cantidad de columnas en varios hilos y preservar al menos cierta localidad de caché.
## max\_bytes\_before\_external\_group\_by
Valor predeterminado de Cloud: la mitad de la memoria por réplica.
Habilita o deshabilita la ejecución de cláusulas `GROUP BY` en memoria externa.
(Consulte [GROUP BY en memoria externa](/es/reference/statements/select/group-by#group-by-in-external-memory))
Valores posibles:
* Volumen máximo de RAM (en bytes) que puede usar una sola operación [GROUP BY](/es/reference/statements/select/group-by).
* `0` — `GROUP BY` en memoria externa deshabilitado.
Si el uso de memoria durante las operaciones `GROUP BY` supera este umbral en bytes,
active el modo de 'agregación externa' (volcado de datos a disco).
El valor recomendado es la mitad de la memoria disponible del sistema.
## max\_bytes\_before\_external\_join
Si se establece en un valor distinto de cero y `join_algorithm` es `hash`, `parallel_hash`, `default` o `auto`, el hash join se convertirá automáticamente en grace hash join para permitir el volcado a disco cuando los datos del lado derecho superen esta cantidad de bytes. Cuando se establece en 0 (valor predeterminado), este umbral absoluto de bytes se desactiva, pero el volcado automático aún puede producirse mediante `max_bytes_ratio_before_external_join` (cuyo valor predeterminado es `0.5`); establezca ambos en `0` para desactivar por completo el volcado automático. Esto impide la optimización de lectura en orden mediante join.
## max\_bytes\_before\_external\_sort
Valor predeterminado de Cloud: la mitad de la memoria por réplica.
Habilita o deshabilita la ejecución de cláusulas `ORDER BY` en memoria externa. Consulte [Detalles de implementación de ORDER BY](/es/reference/statements/select/order-by#implementation-details)
Si el uso de memoria durante una operación ORDER BY supera este umbral en bytes, se activa el modo de «ordenación externa» (volcado de datos a disco).
Valores posibles:
* Volumen máximo de RAM (en bytes) que puede usar una única operación [ORDER BY](/es/reference/statements/select/order-by).
El valor recomendado es la mitad de la memoria del sistema disponible
* `0` — `ORDER BY` en memoria externa desactivado.
## max\_bytes\_before\_remerge\_sort
En el caso de ORDER BY con LIMIT, cuando el uso de memoria supera el umbral especificado, se realizan pasos adicionales de fusión de bloques antes de la fusión final para conservar solo las primeras filas de LIMIT.
## max\_bytes\_for\_lazy\_final
Número máximo de bytes del conjunto usado en la optimización lazy de FINAL. Si se supera, se recurre al FINAL normal.
## max\_bytes\_in\_distinct
La cantidad máxima de bytes del estado (en bytes sin comprimir) en memoria que
utiliza una tabla hash al usar DISTINCT.
## max\_bytes\_in\_join
El tamaño máximo, en número de bytes, de la tabla hash utilizada para unir tablas.
Esta configuración se aplica a las operaciones [SELECT ... JOIN](/es/reference/statements/select/join)
y al [Join table engine](/es/reference/engines/table-engines/special/join).
Si la consulta contiene joins, ClickHouse comprueba esta configuración para cada resultado intermedio.
Cuando se alcanza el límite, ClickHouse puede realizar distintas acciones. Use
la configuración [join\_overflow\_mode](/es/reference/settings/session-settings#join_overflow_mode) para elegir la acción.
Valores posibles:
* Entero positivo.
* 0 — El control de memoria está desactivado.
## max\_bytes\_in\_set
El número máximo de bytes (de datos sin comprimir) utilizado por un conjunto en la cláusula IN
creado a partir de una subconsulta.
## max\_bytes\_ratio\_before\_external\_group\_by
La proporción de la memoria disponible que puede usarse para `GROUP BY`. Una vez alcanzado este valor,
se utiliza memoria externa para la agregación.
Por ejemplo, si se establece en `0.6`, `GROUP BY` permitirá usar el 60% de la memoria disponible
(para servidor/usuario/fusiones) al inicio de la ejecución; a partir de ese momento,
comenzará a usar agregación externa.
## max\_bytes\_ratio\_before\_external\_join
La proporción de memoria disponible permitida para `JOIN`. Una vez alcanzada, el hash join se convertirá en grace hash join para volcar al disco los datos del lado derecho.
Por ejemplo, si se establece en `0.6`, `JOIN` permitirá usar el `60%` de la memoria disponible (para server/user/merges) para la hash table del lado derecho al comienzo de la ejecución; después de eso, comenzará el volcado a disco.
Si se establecen tanto `max_bytes_before_external_join` como `max_bytes_ratio_before_external_join`, se utiliza el umbral resultante menor. Si la proporción es `0`, solo se aplica la configuración absoluta.
Solo tiene efecto cuando `join_algorithm` es `hash`, `parallel_hash`, `default` o `auto` y hay una ruta de datos temporal configurada.
## max\_bytes\_ratio\_before\_external\_sort
La proporción de memoria disponible que puede usar `ORDER BY`. Una vez alcanzado este valor, se utiliza la ordenación externa.
Por ejemplo, si se establece en `0.6`, `ORDER BY` permitirá usar el `60%` de la memoria disponible (para server/user/merges) al inicio de la ejecución; después, empezará a usar la ordenación externa.
Tenga en cuenta que `max_bytes_before_external_sort` sigue respetándose; el volcado a disco solo se realizará si el bloque de ordenación es mayor que `max_bytes_before_external_sort`.
## max\_bytes\_to\_read
La cantidad máxima de bytes (de datos sin comprimir) que se pueden leer de una tabla al ejecutar una consulta.
La restricción se comprueba para cada fragmento de datos procesado, se aplica solo a la
expresión de tabla más interna y, al leer desde un servidor remoto, solo se comprueba en
el servidor remoto.
## max\_bytes\_to\_read\_leaf
La cantidad máxima de bytes (de datos sin comprimir) que se puede leer desde una
tabla local en un nodo hoja al ejecutar una consulta distribuida. Aunque las consultas distribuidas
pueden emitir varias subconsultas a cada segmento (hoja), este límite
solo se comprobará en la fase de lectura en los nodos hoja y se ignorará en la
fase de fusión de resultados en el nodo raíz.
Por ejemplo, un clúster consta de 2 segmentos y cada segmento contiene una tabla con
100 bytes de datos. Una consulta distribuida que deba leer todos los datos
de ambas tablas con la configuración `max_bytes_to_read=150` fallará, ya que en total
serán 200 bytes. Una consulta con `max_bytes_to_read_leaf=150` se ejecutará correctamente, ya que
los nodos hoja leerán como máximo 100 bytes.
La restricción se comprueba para cada fragmento de datos procesado.
Esta configuración es inestable con `prefer_localhost_replica=1`.
## max\_bytes\_to\_sort
El número máximo de bytes antes de ordenar. Si para la operación ORDER BY
deben procesarse más bytes sin comprimir que la cantidad especificada, el comportamiento
lo determinará `sort_overflow_mode`, que de forma predeterminada está establecido en `throw`.
## max\_bytes\_to\_transfer
El número máximo de bytes (datos sin comprimir) que pueden pasarse a un
servidor remoto o guardarse en una tabla temporal cuando se ejecuta la sección GLOBAL IN/JOIN.
## max\_columns\_to\_read
El número máximo de columnas que se pueden leer de una tabla en una sola consulta.
Si una consulta requiere leer un número de columnas superior al especificado, se
genera una excepción.
Esta configuración es útil para evitar consultas demasiado complejas.
El valor `0` significa que no hay límite.
## max\_compress\_block\_size
El tamaño máximo de los bloques de datos sin comprimir antes de comprimirlos para escribirlos en una tabla. El valor predeterminado es 1.048.576 (1 MiB). Especificar un tamaño de bloque menor suele dar como resultado un ratio de compresión ligeramente inferior; la velocidad de compresión y descompresión aumenta ligeramente debido a la localidad de la caché, y se reduce el consumo de memoria.
Esta es una configuración de nivel experto, y no debería cambiarla si está empezando con ClickHouse.
No confunda los bloques de compresión (un fragmento de memoria compuesto por bytes) con los bloques de procesamiento de consultas (un conjunto de filas de una tabla).
## max\_concurrent\_queries\_for\_all\_users
Lanza una excepción si el valor de esta configuración es menor o igual que el número actual de consultas que se procesan simultáneamente.
Ejemplo: `max_concurrent_queries_for_all_users` se puede establecer en 99 para todos los usuarios, y el administrador de la base de datos puede establecerlo en 100 para sí mismo a fin de ejecutar consultas de investigación incluso cuando el servidor está sobrecargado.
Modificar la configuración para una consulta o un usuario no afecta a las demás consultas.
Valores posibles:
* Entero positivo.
* 0 — Sin límite.
**Ejemplo**
```xml theme={null}
99
```
**Véase también**
* [max\_concurrent\_queries](/es/reference/settings/server-settings/settings#max_concurrent_queries)
Valor predeterminado en Cloud: `1000`.
## max\_concurrent\_queries\_for\_user
El número máximo de consultas que se pueden procesar simultáneamente por usuario.
Valores posibles:
* Entero positivo.
* 0 — Sin límite.
**Ejemplo**
```xml theme={null}
5
```
## max\_consume\_snapshots
Número máximo de instantáneas de Paimon que se pueden consumir en cada lectura incremental. 0 significa que no hay límite.
## max\_distributed\_connections
El número máximo de conexiones simultáneas con servidores remotos para el procesamiento distribuido de una única consulta sobre una única tabla Distributed. Recomendamos establecer un valor no inferior al número de servidores del clúster.
Los siguientes parámetros solo se usan al crear tablas Distributed (y al iniciar un servidor), por lo que no tiene sentido cambiarlos en tiempo de ejecución.
## max\_distributed\_depth
Limita la profundidad máxima de las consultas recursivas para las tablas [Distributed](/es/reference/engines/table-engines/special/distributed).
Si se supera este valor, el servidor lanza una excepción.
Valores posibles:
* Entero positivo.
* 0 — Profundidad ilimitada.
## max\_download\_buffer\_size
El tamaño máximo del búfer para la descarga en paralelo (p. ej., para URL engine) en cada thread.
## max\_download\_threads
El número máximo de hilos para la descarga de datos (p. ej., para URL engine).
## max\_estimated\_execution\_time
Tiempo máximo estimado de ejecución de la consulta, en segundos. Se comprueba en cada bloque de datos
cuando vence [`timeout_before_checking_execution_speed`](/es/reference/settings/session-settings#timeout_before_checking_execution_speed).
## max\_execution\_speed
El número máximo de filas procesadas por segundo. Se comprueba en cada bloque de datos cuando
[`timeout_before_checking_execution_speed`](/es/reference/settings/session-settings#timeout_before_checking_execution_speed)
vence. Si la velocidad de ejecución es demasiado alta, se reducirá.
## max\_execution\_speed\_bytes
El número máximo de bytes de ejecución por segundo. Se comprueba en cada bloque de datos cuando
[`timeout_before_checking_execution_speed`](/es/reference/settings/session-settings#timeout_before_checking_execution_speed)
expira. Si la velocidad de ejecución es alta, se reducirá.
## max\_execution\_time
El tiempo máximo de ejecución de la consulta, en segundos.
El parámetro `max_execution_time` puede ser algo difícil de entender.
Funciona a partir de una interpolación relativa a la velocidad actual de ejecución de la consulta
(este comportamiento está controlado por [`timeout_before_checking_execution_speed`](/es/reference/settings/session-settings#timeout_before_checking_execution_speed)).
ClickHouse interrumpirá una consulta si el tiempo de ejecución estimado supera el
`max_execution_time` especificado. De forma predeterminada, `timeout_before_checking_execution_speed`
está establecido en 10 segundos. Esto significa que, tras 10 segundos de ejecución de la consulta, ClickHouse
comenzará a estimar el tiempo total de ejecución. Si, por ejemplo, `max_execution_time`
está establecido en 3600 segundos (1 hora), ClickHouse finalizará la consulta si el tiempo estimado
supera este límite de 3600 segundos. Si establece `timeout_before_checking_execution_speed`
en 0, ClickHouse usará el tiempo de reloj como base para `max_execution_time`.
Si el tiempo de ejecución de la consulta supera el número de segundos especificado, el comportamiento
vendrá determinado por `timeout_overflow_mode`, que de forma predeterminada está establecido en `throw`.
El tiempo de espera se comprueba y la consulta solo puede detenerse en puntos determinados durante el procesamiento de datos.
Actualmente no puede detenerse durante la fusión de estados de agregación ni durante el análisis de la consulta,
y el tiempo real de ejecución será mayor que el valor de esta configuración.
## max\_execution\_time\_leaf
Semánticamente es similar a [`max_execution_time`](#max_execution_time), pero solo
se aplica a los nodos hoja en consultas distribuidas o remotas.
Por ejemplo, si queremos limitar a `10s` el tiempo de ejecución en un nodo hoja, pero
no establecer ningún límite en el nodo inicial, en lugar de incluir `max_execution_time` en la
configuración de la subconsulta anidada:
```sql theme={null}
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t SETTINGS max_execution_time = 10));
```
Podemos usar `max_execution_time_leaf` como parámetro de configuración de la consulta:
```sql theme={null}
SELECT count()
FROM cluster(cluster, view(SELECT * FROM t)) SETTINGS max_execution_time_leaf = 10;
```
## max\_expanded\_ast\_elements
Tamaño máximo del árbol de sintaxis de la consulta, medido en número de nodos, tras expandir los alias y el asterisco.
## max\_fetch\_partition\_retries\_count
Número de reintentos al obtener una partición desde otro host.
## max\_final\_threads
Establece el número máximo de hilos paralelos para la fase de lectura de datos de la consulta `SELECT` con el modificador [FINAL](/es/reference/statements/select/from#final-modifier).
Valores posibles:
* Entero positivo.
* 0 o 1 — Deshabilitado. Las consultas `SELECT` se ejecutan en un solo hilo.
## max\_http\_get\_redirects
Número máximo de saltos de redirección HTTP GET permitidos. Garantiza medidas de seguridad adicionales para evitar que un servidor malicioso redirija sus solicitudes a servicios inesperados.\n\nEsto ocurre cuando un servidor externo redirige a otra dirección, pero esa dirección parece pertenecer a la infraestructura interna de la empresa y, al enviar una solicitud HTTP a un servidor interno, podría solicitar una API interna desde la red interna, eludir la autenticación o incluso consultar otros servicios, como Redis o Memcached. Cuando no tiene una infraestructura interna (incluido algo que se esté ejecutando en su localhost), o si confía en el servidor, es seguro permitir redirecciones. Sin embargo, tenga en cuenta que, si la URL usa HTTP en lugar de HTTPS, tendrá que confiar no solo en el servidor remoto, sino también en su ISP y en cada una de las redes intermedias.
Valor predeterminado de Cloud: `10`.
## max\_hyperscan\_regexp\_length
Define la longitud máxima de cada expresión regular en las [funciones hyperscan multi-match](/es/reference/functions/regular-functions/string-search-functions#multiMatchAny).
Valores posibles:
* Entero positivo.
* 0 - La longitud no está limitada.
**Ejemplo**
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 3;
```
Resultado:
```text theme={null}
┌─multiMatchAny('abcd', ['ab', 'bcd', 'c', 'd'])─┐
│ 1 │
└────────────────────────────────────────────────┘
```
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bcd','c','d']) SETTINGS max_hyperscan_regexp_length = 2;
```
Resultado:
```text theme={null}
Exception: Regexp length too large.
```
**Véase también**
* [max\_hyperscan\_regexp\_total\_length](#max_hyperscan_regexp_total_length)
## max\_hyperscan\_regexp\_total\_length
Establece la longitud total máxima de todas las expresiones regulares en cada [función hyperscan multi-match](/es/reference/functions/regular-functions/string-search-functions#multiMatchAny).
Valores posibles:
* Entero positivo.
* 0: la longitud no está limitada.
**Ejemplo**
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['a','b','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
```
Resultado:
```text theme={null}
┌─multiMatchAny('abcd', ['a', 'b', 'c', 'd'])─┐
│ 1 │
└─────────────────────────────────────────────┘
```
Consulta:
```sql theme={null}
SELECT multiMatchAny('abcd', ['ab','bc','c','d']) SETTINGS max_hyperscan_regexp_total_length = 5;
```
Resultado:
```text theme={null}
Exception: Total regexp lengths too large.
```
**Véase también**
* [max\_hyperscan\_regexp\_length](#max_hyperscan_regexp_length)
## max\_insert\_block\_size
**Alias**: `max_insert_block_size_rows`
El tamaño máximo de los bloques (medido en número de filas) que se forman para insertar en una tabla.
Esta configuración controla la formación de bloques en dos contextos:
1. Análisis de formatos: Cuando el servidor analiza formatos de entrada basados en filas (CSV, TSV, JSONEachRow, etc.) desde cualquier interfaz (HTTP, clickhouse-client con datos en línea, gRPC, PostgreSQL wire protocol), los bloques se emiten cuando:
* Se alcanzan tanto min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes, OR
* Se alcanza cualquiera de max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes
Nota: Al usar clickhouse-client o clickhouse-local para leer desde un archivo, el propio cliente analiza los datos y esta configuración se aplica del lado del cliente.
2. Operaciones INSERT: Durante las consultas INSERT y cuando los datos fluyen a través de vistas materializadas, el comportamiento de esta configuración depende de `use_strict_insert_block_limits`:
* Cuando está habilitado: Los bloques se emiten cuando:
* Umbrales mínimos (AND): Se alcanzan tanto min\_insert\_block\_size\_rows AND min\_insert\_block\_size\_bytes
* Umbrales máximos (OR): Se alcanza cualquiera de max\_insert\_block\_size\_rows OR max\_insert\_block\_size\_bytes
* Cuando está deshabilitado: Los bloques se emiten cuando se alcanza min\_insert\_block\_size\_rows OR min\_insert\_block\_size\_bytes. Los ajustes max\_insert\_block\_size no se aplican.
Valores posibles:
* Entero positivo.
## max\_insert\_block\_size\_bytes
El tamaño máximo de los bloques (en bytes) que se deben formar para insertar en una tabla.
Esta configuración funciona junto con max\_insert\_block\_size\_rows y controla la formación de bloques en el mismo contexto. Consulte max\_insert\_block\_size\_rows para obtener información detallada sobre cuándo y cómo se aplican estas configuraciones.
Valores posibles:
* Entero positivo.
* 0 — la configuración no interviene en la formación de bloques.
## max\_insert\_delayed\_streams\_for\_parallel\_write
El número máximo de streams (columnas) para retrasar el volcado final de la parte. Valor predeterminado: automático (100 si el almacenamiento subyacente admite escritura en paralelo, por ejemplo, S3, y deshabilitado en caso contrario)
Valor predeterminado de Cloud: `50`.
## max\_insert\_threads
El número máximo de hilos para ejecutar la consulta `INSERT SELECT`.
Valores posibles:
* 0 (o 1): `INSERT SELECT` no se ejecuta en paralelo.
* Entero positivo. Mayor que 1.
Valor predeterminado en Cloud:
* `1` para nodos con 8 GiB de memoria
* `2` para nodos con 16 GiB de memoria
* `4` para nodos más grandes
`INSERT SELECT` en paralelo solo surte efecto si la parte `SELECT` se ejecuta en paralelo; consulta la configuración [`max_threads`](#max_threads).
Los valores más altos darán lugar a un mayor uso de memoria.
## max\_insert\_threads\_min\_free\_memory\_per\_thread
Igual que `max_threads_min_free_memory_per_thread`, pero aplicado a `max_insert_threads` en vez de a `max_threads`. El valor predeterminado es mayor porque las canalizaciones de inserción suelen mantener búferes por hilo más grandes (partes de MergeTree, bloques de compresión) que las canalizaciones de lectura.
Si la cantidad de memoria libre es inferior a `max_insert_threads` multiplicado por este valor, `max_insert_threads` se reduce para ajustarse, hasta un mínimo de `1`.
Establézcalo en `0` para desactivar este límite.
## max\_joined\_block\_size\_bytes
Tamaño máximo del bloque, en bytes, para el resultado de JOIN (si el algoritmo de JOIN lo admite). 0 significa ilimitado.
## max\_joined\_block\_size\_rows
Tamaño máximo del bloque para el resultado del JOIN (si el algoritmo de JOIN lo admite). 0 significa que no hay límite.
## max\_limit\_for\_vector\_search\_queries
Las consultas SELECT con un LIMIT superior a este ajuste no pueden usar índices de similitud vectorial. Ayuda a evitar desbordamientos de memoria en los índices de similitud vectorial.
## max\_local\_read\_bandwidth
La velocidad máxima de lectura local en bytes por segundo.
## max\_local\_write\_bandwidth
La velocidad máxima de escritura local en bytes por segundo.
## max\_memory\_usage
Valor predeterminado de Cloud: depende de la cantidad de RAM en la réplica.
La cantidad máxima de RAM que se puede usar para ejecutar una consulta en un único servidor.
Un valor de `0` significa que no hay límite.
Esta configuración no tiene en cuenta la cantidad de memoria disponible ni la cantidad total
de memoria de la máquina. La restricción se aplica a una única consulta dentro de un
único servidor.
Puede usar `SHOW PROCESSLIST` para ver el consumo actual de memoria de cada consulta.
El consumo máximo de memoria se registra para cada consulta y se escribe en el log.
El uso de memoria no se rastrea por completo para los estados de las siguientes funciones de agregación
con argumentos `String` y `Array`:
* `min`
* `max`
* `any`
* `anyLast`
* `argMin`
* `argMax`
El consumo de memoria también está restringido por los parámetros [`max_memory_usage_for_user`](/es/reference/settings/session-settings#max_memory_usage_for_user)
y [`max_server_memory_usage`](/es/reference/settings/server-settings/settings#max_server_memory_usage).
## max\_memory\_usage\_for\_user
La cantidad máxima de RAM que se puede usar para ejecutar las consultas de un usuario en un solo servidor. Cero significa sin límite.
De forma predeterminada, la cantidad no está restringida (`max_memory_usage_for_user = 0`).
Véase también la descripción de [`max_memory_usage`](/es/reference/settings/session-settings#max_memory_usage).
Por ejemplo, si desea establecer `max_memory_usage_for_user` en 1000 bytes para un usuario llamado `clickhouse_read`, puede usar la instrucción
```sql theme={null}
ALTER USER clickhouse_read SETTINGS max_memory_usage_for_user = 1000;
```
Puedes verificar que ha funcionado cerrando la sesión en tu cliente, volviendo a iniciarla y usando después la función `getSetting`:
```sql theme={null}
SELECT getSetting('max_memory_usage_for_user');
```
## max\_network\_bandwidth
Limita la velocidad del intercambio de datos por la red en bytes por segundo. Esta configuración se aplica a cada consulta.
Valores posibles:
* Entero positivo.
* 0 — El control del ancho de banda está deshabilitado.
## max\_network\_bandwidth\_for\_all\_users
Limita la velocidad a la que se intercambian los datos a través de la red, en bytes por segundo. Esta configuración se aplica a todas las consultas que se ejecutan de forma concurrente en el servidor.
Valores posibles:
* Entero positivo.
* 0 — El control de la velocidad de transferencia de datos está deshabilitado.
## max\_network\_bandwidth\_for\_user
Limita la velocidad del intercambio de datos por la red en bytes por segundo. Esta configuración se aplica a todas las consultas ejecutadas de forma concurrente por un mismo usuario.
Valores posibles:
* Entero positivo.
* 0 — El control de la velocidad de transferencia de datos está deshabilitado.
## max\_network\_bytes
Limita el volumen de datos (en bytes) que se recibe o transmite por la red al ejecutar una consulta. Esta configuración se aplica a cada consulta de forma individual.
Valores posibles:
* Entero positivo.
* 0 — El control del volumen de datos está desactivado.
## max\_number\_of\_partitions\_for\_independent\_aggregation
Número máximo de particiones de la tabla para aplicar la optimización
## max\_os\_cpu\_wait\_time\_ratio\_to\_throw
Relación máxima entre los tiempos de espera de la CPU del SO (métrica OSCPUWaitMicroseconds) y de actividad (métrica OSCPUVirtualTimeMicroseconds) a partir de la cual se considera rechazar consultas. Se utiliza interpolación lineal entre la relación mínima y la máxima para calcular la probabilidad; en este punto, la probabilidad es 1.
## max\_parallel\_replicas
El número máximo de réplicas para cada segmento al ejecutar una consulta.
Valores posibles:
* Entero positivo.
**Información adicional**
Esta opción producirá resultados diferentes según la configuración utilizada.
### Procesamiento en paralelo con la clave `SAMPLE`
Una consulta puede procesarse más rápido si se ejecuta en varios servidores en paralelo. Sin embargo, el rendimiento de la consulta puede empeorar en los siguientes casos:
* La posición de la clave de muestreo dentro de la clave de partición no permite realizar lecturas por rango de forma eficiente.
* Añadir una clave de muestreo a la tabla hace que el filtrado por otras columnas sea menos eficiente.
* La clave de muestreo es una expresión cuyo cálculo resulta costoso.
* La distribución de la latencia del clúster tiene una cola larga, por lo que consultar más servidores aumenta la latencia total de la consulta.
### Procesamiento paralelo con [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key)
Esta configuración es útil para cualquier tabla replicada.
## max\_parser\_backtracks
Número máximo de retrocesos del analizador sintáctico (cuántas veces intenta distintas alternativas en el proceso de análisis sintáctico por descenso recursivo).
## max\_parser\_depth
Limita la profundidad máxima de recursión del analizador sintáctico descendente recursivo. Permite controlar el tamaño de la pila.
Valores posibles:
* Entero positivo.
* 0 — La profundidad de recursión es ilimitada.
## max\_parsing\_threads
El número máximo de hilos para analizar datos en formatos de entrada que admiten el análisis en paralelo. De forma predeterminada, se calcula automáticamente.
## max\_partition\_size\_to\_drop
Restricción para eliminar particiones en tiempo de consulta. El valor `0` significa que se pueden eliminar particiones sin ninguna restricción.
Valor predeterminado de Cloud: 1 TB.
Esta configuración de consulta prevalece sobre la configuración equivalente del servidor; consulte [max\_partition\_size\_to\_drop](/es/reference/settings/server-settings/settings#max_partition_size_to_drop)
## max\_partitions\_per\_insert\_block
Limita el número máximo de particiones en un único block insertado
y se lanza una excepción si el block contiene demasiadas particiones.
* Entero positivo.
* `0` — Número ilimitado de particiones.
**Detalles**
Al insertar datos, ClickHouse calcula el número de particiones en el
block insertado. Si el número de particiones es mayor que
`max_partitions_per_insert_block`, ClickHouse registra una advertencia o lanza una
excepción según `throw_on_max_partitions_per_insert_block`. Las excepciones tienen
el siguiente texto:
> "Demasiadas particiones para un único bloque INSERT (`partitions_count` particiones; el límite es " + toString(max\_partitions) + ").
> El límite está controlado por la configuración 'max\_partitions\_per\_insert\_block'.
> Un gran número de particiones es un error conceptual frecuente. Esto provocará
> un grave impacto negativo en el rendimiento, incluido un inicio lento del servidor, consultas INSERT lentas
> y consultas SELECT lentas. El número total recomendado de particiones para una tabla es
> inferior a 1000..10000. Tenga en cuenta que la partición no está pensada para acelerar
> las consultas SELECT (la clave ORDER BY es suficiente para que las consultas por rango sean rápidas).
> Las particiones están pensadas para la manipulación de datos (DROP PARTITION, etc.)."
Esta configuración es un umbral de seguridad porque usar un gran número de particiones es un error conceptual frecuente.
## max\_partitions\_to\_read
Limita el número máximo de particiones a las que se puede acceder en una sola consulta.
El valor de configuración especificado al crear la tabla puede sobrescribirse mediante una configuración a nivel de consulta.
Valores posibles:
* Entero positivo
* `-1` - ilimitado (predeterminado)
También puede especificar la configuración de MergeTree [`max_partitions_to_read`](/es/reference/settings/session-settings#max_partitions_to_read) en la configuración de la tabla.
## max\_parts\_to\_move
Limita el número de partes que se pueden mover en una sola consulta. Cero significa que no hay límite.
## max\_projection\_rows\_to\_use\_projection\_index
Si el número de filas que se leerán del índice de proyección es inferior o igual a este umbral, ClickHouse intentará aplicar el índice de proyección durante la ejecución de la consulta.
## max\_query\_size
El número máximo de bytes de la cadena de consulta que analiza el parser SQL.
Los datos de la cláusula VALUES de las consultas INSERT se procesan mediante un parser de flujo independiente (que consume O(1) de RAM) y no se ven afectados por esta restricción.
`max_query_size` no puede establecerse dentro de una consulta SQL (por ejemplo, `SELECT now() SETTINGS max_query_size=10000`) porque ClickHouse necesita asignar un búfer para analizar la consulta, y el tamaño de este búfer lo determina la configuración `max_query_size`, que debe configurarse antes de ejecutar la consulta.
## max\_rand\_distribution\_parameter
Valor máximo de los parámetros de forma de las distribuciones en funciones de distribución aleatoria como `randChiSquared`, `randStudentT` y `randFisherF`. Esto evita tiempos de cálculo excesivamente largos con valores de parámetros extremos.
## max\_rand\_distribution\_trials
Número máximo de ensayos permitidos para funciones de distribución aleatoria como `randBinomial` y `randNegativeBinomial`. Esto evita tiempos de cálculo extremadamente largos cuando el número de ensayos es elevado.
## max\_read\_buffer\_size
El tamaño máximo del búfer de lectura desde el sistema de archivos.
## max\_read\_buffer\_size\_local\_fs
El tamaño máximo del búfer de lectura del sistema de archivos local. Si se establece en 0, se utilizará max\_read\_buffer\_size.
## max\_read\_buffer\_size\_remote\_fs
El tamaño máximo del búfer de lectura desde un sistema de archivos remoto. Si se establece en 0, se usará max\_read\_buffer\_size.
## max\_recursive\_cte\_evaluation\_depth
Límite máximo de la profundidad de evaluación de las CTE recursivas
## max\_remote\_read\_network\_bandwidth
La velocidad máxima de intercambio de datos a través de la red, en bytes por segundo, para la lectura.
## max\_remote\_write\_network\_bandwidth
La velocidad máxima de intercambio de datos a través de la red, en bytes por segundo, para la escritura.
## max\_replica\_delay\_for\_distributed\_queries
Desactiva las réplicas con retraso para las consultas distribuidas. Consulte [Replication](/es/reference/engines/table-engines/mergetree-family/replication).
Establece el tiempo en segundos. Si el retraso de una réplica es mayor o igual que el valor establecido, esa réplica no se utiliza.
Valores posibles:
* Entero positivo.
* 0 — No se comprueba el retraso de las réplicas.
Para evitar el uso de cualquier réplica con un retraso distinto de cero, establezca este parámetro en 1.
Se utiliza al ejecutar `SELECT` desde una tabla distribuida que apunta a tablas replicadas.
## max\_result\_bytes
Limita el tamaño del resultado en bytes (sin comprimir). La consulta se detendrá después de procesar un bloque de datos si se alcanza el umbral,
pero no recortará el último bloque del resultado; por lo tanto, el tamaño del resultado puede ser mayor que el umbral.
**Consideraciones**
Para este umbral, se tiene en cuenta el tamaño del resultado en memoria.
Incluso si el tamaño del resultado es pequeño, puede hacer referencia a estructuras de datos más grandes en memoria,
como los diccionarios de columnas LowCardinality y las Arenas de columnas AggregateFunction,
por lo que el umbral puede superarse a pesar del pequeño tamaño del resultado.
Este ajuste es de un nivel bastante bajo y debe usarse con precaución
## max\_result\_rows
Valor predeterminado de Cloud: `0`.
Limita el número de filas del resultado. También se comprueba en las subconsultas y en servidores remotos al ejecutar partes de una consulta distribuida.
No se aplica ningún límite cuando el valor es `0`.
La consulta se detendrá después de procesar un bloque de datos si se alcanza el umbral, pero
no recortará el último bloque del resultado, por lo que el tamaño del resultado puede ser
mayor que el umbral.
## max\_reverse\_dictionary\_lookup\_cache\_size\_bytes
Tamaño máximo en bytes de la caché de búsqueda inversa en diccionarios por consulta utilizada por la función `dictGetKeys`. La caché almacena tuplas de claves serializadas por valor de atributo para evitar volver a recorrer el diccionario dentro de la misma consulta. Cuando se alcanza el límite, las entradas se expulsan mediante LRU. Establezca 0 para desactivar la caché.
## max\_rows\_for\_lazy\_final
Número máximo de filas del conjunto para la optimización lazy FINAL. Si se supera, se recurre a FINAL normal.
## max\_rows\_in\_distinct
El número máximo de filas distintas al usar DISTINCT.
## max\_rows\_in\_join
Limita el número de filas de la tabla hash que se utiliza al combinar tablas.
Esta configuración se aplica a las operaciones [SELECT ... JOIN](/es/reference/statements/select/join)
y al motor de tabla [Join](/es/reference/engines/table-engines/special/join).
Si una consulta contiene varios JOIN, ClickHouse comprueba esta configuración para cada resultado intermedio.
Cuando se alcanza el límite, ClickHouse puede seguir distintos cursos de acción. Use la
configuración [`join_overflow_mode`](/es/reference/settings/session-settings#join_overflow_mode) para elegir la acción.
Valores posibles:
* Entero positivo.
* `0` — Número ilimitado de filas.
## max\_rows\_in\_set
El número máximo de filas de un conjunto de datos en la cláusula IN creado a partir de una subconsulta.
## max\_rows\_in\_set\_to\_optimize\_join
Tamaño máximo del conjunto usado para filtrar las tablas que se van a unir mediante los conjuntos de filas de cada una antes de realizar el join.
Valores posibles:
* 0 — Desactivar.
* Cualquier entero positivo.
## max\_rows\_to\_group\_by
El número máximo de claves únicas recibidas de la aggregación. Esta configuración permite
limitar el consumo de memoria durante la aggregación.
Si la aggregación durante GROUP BY genera más del número especificado de
filas (claves únicas de GROUP BY), el comportamiento vendrá determinado por
'group\_by\_overflow\_mode', que de forma predeterminada es `throw`, aunque también puede cambiarse
a un modo aproximado de GROUP BY.
## max\_rows\_to\_read
El número máximo de filas que se pueden leer desde una tabla al ejecutar una consulta.
La restricción se comprueba para cada fragmento de datos procesado, se aplica solo a la
expresión de tabla más profunda y, al leer desde un servidor remoto, se comprueba solo en
el servidor remoto.
## max\_rows\_to\_read\_leaf
El número máximo de filas que se pueden leer de una tabla local en un nodo hoja al
ejecutar una consulta distribuida. Aunque las consultas distribuidas pueden emitir múltiples subconsultas
a cada segmento (hoja), este límite solo se comprobará en la fase de lectura en los
nodos hoja y se ignorará en la fase de combinación de resultados en el nodo raíz.
Por ejemplo, un clúster consta de 2 segmentos y cada segmento contiene una tabla con
100 filas. La consulta distribuida que debe leer todos los datos de ambas
tablas con la configuración `max_rows_to_read=150` fallará, ya que en total habrá
200 filas. Una consulta con `max_rows_to_read_leaf=150` se ejecutará correctamente, ya que los nodos hoja
leerán como máximo 100 filas.
La restricción se comprueba para cada fragmento de datos procesado.
Esta configuración es inestable con `prefer_localhost_replica=1`.
## max\_rows\_to\_sort
El número máximo de filas antes de la ordenación. Esto permite limitar el consumo de memoria al ordenar.
Si es necesario procesar más registros que la cantidad especificada para la operación ORDER BY,
el comportamiento vendrá determinado por `sort_overflow_mode`, que de forma predeterminada está configurado como `throw`.
## max\_rows\_to\_transfer
Tamaño máximo (en filas) que se puede transferir a un servidor remoto o guardar en una
tabla temporal cuando se ejecuta la sección GLOBAL IN/JOIN.
## max\_sessions\_for\_user
Número máximo de sesiones simultáneas por usuario autenticado en el servidor de ClickHouse.
Ejemplo:
```xml theme={null}
1
2
0
single_session_user
two_sessions_profile
unlimited_sessions_profile
```
Valores posibles:
* Entero positivo
* `0`: número infinito de sesiones simultáneas (valor predeterminado)
## max\_size\_to\_preallocate\_for\_aggregation
Número total de elementos para los que se permite preasignar espacio en todas las tablas hash antes de la agregació
## max\_size\_to\_preallocate\_for\_joins
Para cuántos elementos se permite preasignar espacio en total en todas las tablas hash antes de joi
## max\_skip\_unavailable\_shards\_num
Cuando `skip_unavailable_shards` está habilitado, limita el número máximo de segmentos que pueden omitirse silenciosamente.
Si el número de segmentos no disponibles supera este valor, se lanza una excepción en lugar de omitirlos silenciosamente.
Un valor de 0 significa que no hay límite (comportamiento predeterminado: pueden omitirse todos los segmentos no disponibles).
## max\_skip\_unavailable\_shards\_ratio
Cuando `skip_unavailable_shards` está habilitado, limita la proporción máxima (de 0 a 1) de segmentos que pueden omitirse silenciosamente.
Si la proporción de segmentos no disponibles respecto al total de segmentos supera este valor, se lanza una excepción en lugar de omitirlos silenciosamente.
Un valor de 0 significa que no hay límite (comportamiento predeterminado: se pueden omitir todos los segmentos no disponibles).
## max\_streams\_for\_files\_processing\_in\_cluster\_functions
Si no es cero, limita el número de hilos que leen datos de archivos en las *funciones de tabla de clúster*.
## max\_streams\_for\_merge\_tree\_reading
Si no es cero, limita el número de streams de lectura para la tabla MergeTree.
## max\_streams\_for\_union\_step
Limita el número de streams de datos activos simultáneamente en un paso `UNION` (se aplica tanto a `UNION ALL` como a `UNION DISTINCT`, porque `UNION DISTINCT` se implementa mediante un paso `UNION ALL` seguido de un paso `DISTINCT`). Cuando una consulta `UNION` tiene muchas subconsultas, todas abren sus búferes de lectura al mismo tiempo, lo que hace que el uso de memoria sea proporcional al número de subconsultas. Esta configuración inserta procesadores `Concat` para estrechar la canalización, de modo que como máximo este número de streams esté activo a la vez, lo que reduce drásticamente el pico de memoria. El límite real es el menor entre este valor y `max_threads * max_streams_for_union_step_to_max_threads_ratio` (si cualquiera de los dos es 0, se ignora). Cuando ambos son 0, no se aplica ningún estrechamiento.
## max\_streams\_for\_union\_step\_to\_max\_threads\_ratio
Esta proporción, multiplicada por `max_threads`, determina un límite de flujos activos simultáneamente en un paso `UNION` (se aplica tanto a `UNION ALL` como a `UNION DISTINCT`). El límite real es el mínimo entre este valor calculado y `max_streams_for_union_step` (si cualquiera de los dos es 0, se ignora). Por ejemplo, con `max_threads = 8` y esta proporción establecida en 1, habrá como máximo 8 flujos activos. Establézcala en 0 para desactivar este límite basado en la proporción.
## max\_streams\_multiplier\_for\_merge\_tables
Solicita más flujos al leer de una tabla Merge. Los flujos se distribuirán entre las tablas que utiliza la tabla Merge. Esto permite repartir el trabajo de forma más uniforme entre los hilos y resulta especialmente útil cuando las tablas fusionadas difieren en tamaño.
## max\_streams\_to\_max\_threads\_ratio
Permite usar más flujos que hilos para distribuir el trabajo de forma más uniforme entre ellos. Se asume que esta es una solución temporal, ya que en el futuro será posible hacer que el número de flujos sea igual al número de hilos, pero que cada flujo seleccione dinámicamente el trabajo disponible por sí mismo.
## max\_subquery\_depth
Si una consulta tiene más subconsultas anidadas que el número especificado, se
genera una excepción.
Esto permite realizar una comprobación de cordura para evitar que los usuarios de su
cluster escriban consultas excesivamente complejas.
## max\_table\_size\_to\_drop
Restricción para eliminar tablas durante la ejecución de la consulta. El valor `0` significa que puede eliminar todas las tablas sin ninguna restricción.
Valor predeterminado de Cloud: 1 TB.
Esta configuración de consulta anula la configuración equivalente del servidor; consulte [max\_table\_size\_to\_drop](/es/reference/settings/server-settings/settings#max_table_size_to_drop)
## max\_temporary\_columns
El número máximo de columnas temporales que deben mantenerse simultáneamente en RAM
al ejecutar una consulta, incluidas las columnas constantes. Si una consulta genera en
memoria un número de columnas temporales superior al especificado como resultado de un
cálculo intermedio, se genera una excepción.
Esta configuración es útil para evitar consultas excesivamente complejas.
El valor `0` significa que no hay límite.
## max\_temporary\_data\_on\_disk\_size\_for\_query
La cantidad máxima de datos consumida por los archivos temporales en disco, en bytes, para todas
las consultas que se ejecutan de forma concurrente.
Valores posibles:
* Entero positivo.
* `0` — ilimitado (predeterminado)
## max\_temporary\_data\_on\_disk\_size\_for\_user
La cantidad máxima de datos, en bytes, consumidos por los archivos temporales en disco para todas
las consultas del usuario que se ejecutan de forma concurrente.
Valores posibles:
* Entero positivo.
* `0` — ilimitado (predeterminado)
## max\_temporary\_non\_const\_columns
Al igual que `max_temporary_columns`, es el número máximo de columnas temporales que deben
mantenerse simultáneamente en RAM al ejecutar una consulta, sin contar las
columnas constantes.
Las columnas constantes se generan con bastante frecuencia al ejecutar una consulta, pero requieren
prácticamente cero recursos de cómputo.
## max\_threads
El número máximo de hilos de procesamiento de consultas, excluidos los hilos para recuperar datos de servidores remotos (consulte el parámetro ['max\_distributed\_connections'](/es/reference/settings/session-settings#max_distributed_connections)).
Este parámetro se aplica a los hilos que ejecutan las mismas etapas de la canalización de procesamiento de consultas en paralelo.
Por ejemplo, al leer de una tabla, si es posible evaluar expresiones con funciones, filtrar con `WHERE` y preagregar para `GROUP BY` en paralelo usando al menos 'max\_threads' hilos, se usan 'max\_threads'.
Para las consultas que se completan rápidamente debido a un LIMIT, puede establecer un valor más bajo de 'max\_threads'.
Por ejemplo, si el número necesario de entradas se encuentra en cada bloque y max\_threads = 8, se recuperan 8 bloques, aunque habría bastado con leer solo uno.
Cuanto menor sea el valor de `max_threads`, menos memoria se consume.
De forma predeterminada, la configuración `max_threads` coincide con el número de hilos de hardware (número de CPU cores) disponibles para ClickHouse.
Como caso especial, para procesadores x86 con menos de 32 CPU cores y SMT (por ejemplo, Intel HyperThreading), ClickHouse usa de forma predeterminada el número de núcleos lógicos (= 2 x número de núcleos físicos).
Sin SMT (por ejemplo, Intel HyperThreading), esto corresponde al número de CPU cores.
Para los usuarios de ClickHouse Cloud, el valor predeterminado se mostrará como `auto(N)`, donde N coincide con el tamaño de vCPU de su servicio, por ejemplo, 2vCPU/8GiB, 4vCPU/16GiB, etc.
Consulte la pestaña de configuración en la consola de Cloud para ver una lista de todos los tamaños de servicio.
## max\_threads\_for\_indexes
El número máximo de hilos para procesar índices.
## max\_threads\_min\_free\_memory\_per\_thread
Reduce `max_threads` cuando el servidor está bajo presión de memoria, para evitar iniciar consultas con un alto nivel de paralelismo que probablemente alcancen el límite de memoria.
La memoria libre se calcula como `max_server_memory_usage` del servidor menos la memoria que actualmente registra el memory tracker global. Si esa memoria libre es inferior a `max_threads` multiplicado por este valor, `max_threads` se reduce al mayor valor de N tal que `N * value <= free_memory`, con un mínimo de `1`.
Establézcalo en `0` para desactivar este límite.
Por ejemplo, con el valor predeterminado de 1 GiB y 32 GiB de memoria libre, `max_threads` queda limitado a 32; con 1 GiB de memoria libre, se reduce a 1.
Esta configuración se aplica al paralelismo del lado de lectura (`SELECT`, `UNION`, `INTERSECT`/`EXCEPT` y el lado `SELECT` de `INSERT ... SELECT`). Para el lado de escritura, consulte `max_insert_threads_min_free_memory_per_thread`.
## max\_untracked\_memory
Las asignaciones y liberaciones pequeñas se agrupan en una variable local del thread y solo se rastrean o perfilan cuando una cantidad (en valor absoluto) supera el valor especificado. Si el valor es mayor que 'memory\_profiler\_step', en la práctica se reducirá a 'memory\_profiler\_step'.
## max\_wkb\_geometry\_elements
Número máximo de puntos, anillos o polígonos permitidos en un único elemento de geometría WKB durante el análisis por `readWKB` y funciones relacionadas. Esto protege frente a asignaciones excesivas de memoria causadas por datos WKB malformados. Establézcalo en 0 para usar el límite fijo en el código (100 millones).
## memory\_overcommit\_ratio\_denominator
Representa el límite de memoria blando cuando se alcanza el límite estricto a nivel global.
Este valor se usa para calcular el ratio de overcommit de la consulta.
Cero significa omitir la consulta.
Lea más sobre [memory overcommit](/es/concepts/features/configuration/settings/memory-overcommit).
## memory\_overcommit\_ratio\_denominator\_for\_user
Representa el límite de memoria blando cuando se alcanza el límite estricto a nivel de usuario.
Este valor se usa para calcular el ratio de overcommit de la consulta.
Un valor de cero significa omitir la consulta.
Más información sobre [memory overcommit](/es/concepts/features/configuration/settings/memory-overcommit).
## memory\_profiler\_sample\_max\_allocation\_size
Recopila allocations aleatorias de tamaño menor o igual que el valor especificado, con una probabilidad igual a `memory_profiler_sample_probability`. 0 significa que está deshabilitado. Es posible que quieras establecer `max_untracked_memory` en 0 para que este umbral funcione como se espera.
## memory\_profiler\_sample\_min\_allocation\_size
Recopila asignaciones de memoria aleatorias de tamaño mayor o igual que el valor especificado, con una probabilidad igual a `memory_profiler_sample_probability`. 0 significa que está deshabilitado. Puede que quieras establecer `max_untracked_memory` en 0 para que este umbral funcione como se espera.
## memory\_profiler\_sample\_probability
Recopila asignaciones y liberaciones aleatorias y las escribe en system.trace\_log con el trace\_type 'MemorySample'. La probabilidad se aplica a cada operación de alloc/free, independientemente del tamaño de la asignación (puede cambiarse con `memory_profiler_sample_min_allocation_size` y `memory_profiler_sample_max_allocation_size`). Ten en cuenta que el muestreo solo se produce cuando la cantidad de memoria no registrada supera 'max\_untracked\_memory'. Puede que te convenga establecer 'max\_untracked\_memory' en 0 para obtener un muestreo aún más detallado.
## memory\_profiler\_step
Establece el intervalo del perfilador de memoria. Cada vez que el uso de memoria de una consulta supere el siguiente intervalo en bytes, el perfilador de memoria recopilará el stacktrace de asignación y lo escribirá en [trace\_log](/es/reference/system-tables/trace_log).
Valores posibles:
* Un número entero positivo de bytes.
* 0 para desactivar el perfilador de memoria.
## memory\_tracker\_fault\_probability
Para probar la `seguridad ante excepciones`, lanza una excepción cada vez que se asigne memoria con la probabilidad especificada.
## memory\_usage\_overcommit\_max\_wait\_microseconds
Tiempo máximo que el thread esperará a que se libere memoria en caso de overcommit de memoria a nivel de usuario.
Si se alcanza el timeout y no se libera memoria, se lanza una excepción.
Lea más sobre [memory overcommit](/es/concepts/features/configuration/settings/memory-overcommit).
## merge\_table\_max\_tables\_to\_look\_for\_schema\_inference
Al crear una tabla `Merge` sin un esquema explícito o al usar la función de tabla `merge`, el esquema se infiere como la unión de no más de la cantidad especificada de tablas coincidentes.
Si el número de tablas es mayor, el esquema se inferirá a partir de las primeras tablas hasta alcanzar la cantidad especificada.
## merge\_tree\_coarse\_index\_granularity
Al buscar datos, ClickHouse comprueba las marcas de datos del archivo de índice. Si ClickHouse detecta que las claves necesarias están dentro de algún rango, divide ese rango en `merge_tree_coarse_index_granularity` subrangos y busca recursivamente las claves necesarias en ellos.
Valores posibles:
* Cualquier entero par positivo.
## merge\_tree\_compact\_parts\_min\_granules\_to\_multibuffer\_read
Solo tiene efecto en ClickHouse Cloud. Número de gránulos en una franja de una parte compacta de las tablas MergeTree para usar el lector multibúfer, que admite lectura en paralelo y lectura anticipada. En caso de leer desde un sistema de archivos remoto, el uso del lector multibúfer aumenta el número de solicitudes de lectura.
## merge\_tree\_determine\_task\_size\_by\_prewhere\_columns
Si se debe usar solo el tamaño de las columnas de prewhere para determinar el tamaño de la tarea de lectura.
## merge\_tree\_max\_bytes\_to\_use\_cache
Si ClickHouse necesita leer más de `merge_tree_max_bytes_to_use_cache` bytes en una consulta, no utiliza la caché de bloques sin comprimir.
La caché de bloques sin comprimir almacena los datos extraídos para las consultas. ClickHouse utiliza esta caché para acelerar las respuestas a consultas pequeñas repetidas. Esta configuración evita que la caché se vea afectada por consultas que leen una gran cantidad de datos. La configuración del servidor [uncompressed\_cache\_size](/es/reference/settings/server-settings/settings#uncompressed_cache_size) define el tamaño de la caché de bloques sin comprimir.
Valores posibles:
* Cualquier entero positivo.
## merge\_tree\_max\_rows\_to\_use\_cache
Si ClickHouse tiene que leer más de `merge_tree_max_rows_to_use_cache` filas en una consulta, no utiliza la caché de bloques sin comprimir.
La caché de bloques sin comprimir almacena datos extraídos durante las consultas. ClickHouse utiliza esta caché para acelerar las respuestas a consultas pequeñas repetidas. Esta configuración evita que consultas que leen grandes volúmenes de datos degraden la caché. La configuración del servidor [uncompressed\_cache\_size](/es/reference/settings/server-settings/settings#uncompressed_cache_size) define el tamaño de la caché de bloques sin comprimir.
Valores posibles:
* Cualquier entero positivo.
## merge\_tree\_min\_bytes\_for\_concurrent\_read
Si la cantidad de bytes que se va a leer de un archivo de una tabla con motor [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree) supera `merge_tree_min_bytes_for_concurrent_read`, ClickHouse intenta leer este archivo de forma concurrente en varios hilos.
Valor posible:
* Entero positivo.
## merge\_tree\_min\_bytes\_for\_concurrent\_read\_for\_remote\_filesystem
La cantidad mínima de bytes que se deben leer de un archivo para que el motor [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree) pueda paralelizar la lectura cuando se lee desde un sistema de archivos remoto. No recomendamos usar esta configuración.
Valores posibles:
* Entero positivo.
## merge\_tree\_min\_bytes\_for\_seek
Si la distancia entre dos bloques de datos que deben leerse en un archivo es menor que `merge_tree_min_bytes_for_seek` bytes, ClickHouse lee secuencialmente un rango del archivo que contiene ambos bloques, evitando así una operación de búsqueda adicional.
Valores posibles:
* Cualquier entero positivo.
## merge\_tree\_min\_bytes\_per\_task\_for\_remote\_reading
**Aliases**: `filesystem_prefetch_min_bytes_for_single_read_task`
Cantidad mínima de bytes que se deben leer por tarea.
## merge\_tree\_min\_read\_task\_size
Límite inferior estricto del tamaño de la tarea (incluso cuando el número de gránulos es bajo y el número de hilos disponibles es alto, no asignaremos tareas más pequeñas
## merge\_tree\_min\_rows\_for\_concurrent\_read
Si el número de filas que se va a leer desde un archivo de una tabla [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree) supera `merge_tree_min_rows_for_concurrent_read`, ClickHouse intenta realizar una lectura concurrente de ese archivo en varios hilos.
Valores posibles:
* Entero positivo.
## merge\_tree\_min\_rows\_for\_concurrent\_read\_for\_remote\_filesystem
La cantidad mínima de filas que se deben leer de un archivo para que el motor [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree) pueda paralelizar la lectura al leer desde un sistema de archivos remoto. No recomendamos usar esta configuración.
Valores posibles:
* Entero positivo.
## merge\_tree\_min\_rows\_for\_seek
Si la distancia entre dos bloques de datos que deben leerse de un archivo es menor que `merge_tree_min_rows_for_seek` filas, ClickHouse no se desplaza por el archivo, sino que lee los datos secuencialmente.
Valores posibles:
* Cualquier entero positivo.
## merge\_tree\_read\_split\_ranges\_into\_intersecting\_and\_non\_intersecting\_injection\_probability
Para probar `PartsSplitter`: divide los rangos de lectura en rangos que se intersecan y rangos que no se intersecan cada vez que se lee desde MergeTree con la probabilidad especificada.
## merge\_tree\_storage\_snapshot\_sleep\_ms
Introduce un retraso artificial (en milisegundos) al crear una instantánea de almacenamiento para tablas MergeTree.
Se usa únicamente con fines de prueba y depuración.
Valores posibles:
* 0 - Sin retraso (predeterminado)
* N - Retraso en milisegundos
## merge\_tree\_use\_const\_size\_tasks\_for\_remote\_reading
Indica si se deben usar tareas de tamaño constante para leer desde una tabla remota.
## merge\_tree\_use\_deserialization\_prefixes\_cache
Habilita el almacenamiento en caché de los metadatos de las columnas desde los prefijos de archivo durante la lectura desde discos remotos en MergeTree.
## merge\_tree\_use\_prefixes\_deserialization\_thread\_pool
Habilita el uso del pool de hilos para la lectura paralela de prefijos en partes Wide en MergeTree. El tamaño de ese pool de hilos se controla mediante la configuración del servidor `max_prefixes_deserialization_thread_pool_size`.
## merge\_tree\_use\_v1\_object\_and\_dynamic\_serialization
Cuando está habilitada, en MergeTree se usará la versión de serialización V1 de los tipos JSON y Dynamic en lugar de V2. Este cambio en la configuración solo surte efecto después de reiniciar el servidor.
## metrics\_perf\_events\_enabled
Si está habilitada, algunos de los eventos de perf se medirán durante la ejecución de las consultas.
## metrics\_perf\_events\_list
Lista separada por comas de métricas de perf que se medirán durante la ejecución de las consultas. Si está vacío, significa que se medirán todos los eventos. Consulte PerfEventInfo en sources para ver los eventos disponibles.
## min\_bytes\_to\_use\_direct\_io
El volumen mínimo de datos necesario para usar acceso de E/S directa al disco de almacenamiento.
ClickHouse utiliza esta configuración al leer datos de las tablas. Si el volumen total de almacenamiento de todos los datos que se van a leer supera `min_bytes_to_use_direct_io` bytes, ClickHouse lee los datos del disco de almacenamiento con la opción `O_DIRECT`.
Valores posibles:
* 0 — La E/S directa está deshabilitada.
* Entero positivo.
## min\_bytes\_to\_use\_mmap\_io
Esta es una configuración experimental. Establece la cantidad mínima de memoria para leer archivos grandes sin copiar datos del kernel al espacio de usuario. El umbral recomendado es de aproximadamente 64 MB, porque [mmap/munmap](https://en.wikipedia.org/wiki/Mmap) es lento. Solo tiene sentido para archivos grandes y solo resulta útil si los datos residen en la caché de páginas.
Valores posibles:
* Entero positivo.
* 0 — Los archivos grandes se leen únicamente copiando datos del kernel al espacio de usuario.
## min\_chunk\_bytes\_for\_parallel\_parsing
* Tipo: entero sin signo
* Valor predeterminado: 1 MiB
El tamaño mínimo del fragmento, en bytes, que cada hilo analizará en paralelo.
## min\_compress\_block\_size
Para las tablas [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree). Para reducir la latencia al procesar consultas, un bloque se comprime al escribir la siguiente marca si su tamaño es de al menos `min_compress_block_size`. El valor predeterminado es 65,536.
El tamaño real del bloque, si los datos sin comprimir son inferiores a `max_compress_block_size`, no será menor que este valor ni menor que el volumen de datos correspondiente a una marca.
Veamos un ejemplo. Supongamos que `index_granularity` se estableció en 8192 durante la creación de la tabla.
Estamos escribiendo una columna de tipo UInt32 (4 bytes por valor). Al escribir 8192 filas, el total será de 32 KB de datos. Como min\_compress\_block\_size = 65,536, se formará un bloque comprimido cada dos marcas.
Estamos escribiendo una columna URL de tipo String (con un tamaño medio de 60 bytes por valor). Al escribir 8192 filas, el total medio será de algo menos de 500 KB de datos. Como esto supera 65,536, se formará un bloque comprimido para cada marca. En este caso, al leer datos del disco dentro del rango de una sola marca, no habrá que descomprimir datos adicionales.
Esta es una configuración de nivel experto y no deberías cambiarla si apenas estás empezando con ClickHouse.
## min\_count\_to\_compile\_aggregate\_expression
El número mínimo de expresiones de agregación idénticas necesario para iniciar la compilación JIT. Solo funciona si la configuración [compile\_aggregate\_expressions](#compile_aggregate_expressions) está habilitada.
Valores posibles:
* Entero positivo.
* 0 — Las expresiones de agregación idénticas siempre se compilan con JIT.
## min\_count\_to\_compile\_expression
Número mínimo de ejecuciones de la misma expression antes de que se compile.
## min\_count\_to\_compile\_sort\_description
El número de descripciones de ordenación idénticas antes de compilarlas con JIT
## min\_execution\_speed
Velocidad mínima de ejecución en filas por segundo. Se comprueba en cada bloque de datos cuando
[`timeout_before_checking_execution_speed`](/es/reference/settings/session-settings#timeout_before_checking_execution_speed)
vence. Si la velocidad de ejecución es inferior, se lanza una excepción.
## min\_execution\_speed\_bytes
El número mínimo de bytes procesados por segundo. Se comprueba en cada bloque de datos cuando
[`timeout_before_checking_execution_speed`](/es/reference/settings/session-settings#timeout_before_checking_execution_speed)
vence. Si la velocidad de ejecución es inferior, se produce una excepción.
## min\_external\_table\_block\_size\_bytes
Agrupa los bloques enviados a la tabla externa hasta alcanzar el tamaño especificado en bytes, si no son lo suficientemente grandes.
## min\_external\_table\_block\_size\_rows
Combina los bloques enviados a la tabla externa hasta alcanzar el tamaño especificado, medido en filas, si los bloques no son lo suficientemente grandes.
## min\_filtered\_ratio\_for\_lazy\_final
Proporción mínima de marcas filtradas por el análisis de índices para la optimización lazy FINAL. Si se filtra menos de esta fracción de marcas, se recurre al FINAL normal. El valor 0 desactiva esta comprobación.
## min\_free\_disk\_bytes\_to\_perform\_insert
Bytes mínimos de espacio libre en disco para realizar una inserción.
## min\_free\_disk\_ratio\_to\_perform\_insert
Proporción mínima de espacio libre en disco necesaria para realizar una inserción.
## min\_free\_disk\_space\_for\_temporary\_data
El espacio mínimo en disco que debe mantenerse al escribir datos temporales utilizados en la ordenación externa y la agregación.
## min\_hit\_rate\_to\_use\_consecutive\_keys\_optimization
Tasa mínima de aciertos de una caché usada en la optimización de claves consecutivas en la agregación para mantenerla habilitada
## min\_insert\_block\_size\_bytes
El tamaño mínimo de los bloques (en bytes) que deben formarse para insertarlos en una tabla.
Esta configuración funciona junto con min\_insert\_block\_size\_rows y controla la formación de bloques en los mismos contextos (análisis del formato y operaciones INSERT). Consulte min\_insert\_block\_size\_rows para obtener información detallada sobre cuándo y cómo se aplican estas configuraciones.
Valores posibles:
* Entero positivo.
* 0 — la configuración no interviene en la formación de bloques.
## min\_insert\_block\_size\_bytes\_for\_materialized\_views
Establece la cantidad mínima de bytes del bloque que puede insertarse en una tabla mediante una consulta `INSERT`. Los bloques más pequeños se compactan en bloques más grandes. Esta configuración se aplica solo a los bloques insertados en una [vista materializada](/es/reference/statements/create/view). Al ajustar esta configuración, puede controlarse la compactación de bloques al insertarlos en la vista materializada y evitar un uso excesivo de memoria.
Valores posibles:
* Cualquier entero positivo.
* 0 — Compactación deshabilitada.
**Véase también**
* [min\_insert\_block\_size\_bytes](#min_insert_block_size_bytes)
## min\_insert\_block\_size\_rows
El tamaño mínimo de los bloques (en filas) que deben formarse para insertarlos en una tabla.
Esta configuración controla la formación de bloques en dos contextos:
1. Análisis de formatos: Cuando el servidor analiza formatos de entrada basados en filas (CSV, TSV, JSONEachRow, etc.) desde cualquier interfaz (HTTP, clickhouse-client con datos en línea, gRPC, protocolo wire de PostgreSQL), los bloques se generan cuando:
* Se alcanzan tanto min\_insert\_block\_size\_rows COMO min\_insert\_block\_size\_bytes, O
* Se alcanza max\_insert\_block\_size\_rows O max\_insert\_block\_size\_bytes
Nota: Al usar clickhouse-client o clickhouse-local para leer desde un archivo, el propio cliente analiza los datos y esta configuración se aplica del lado del cliente.
2. Operaciones INSERT: Durante las consultas INSERT y cuando los datos fluyen a través de vistas materializadas, el comportamiento de esta configuración depende de `use_strict_insert_block_limits`:
* Cuando está habilitada: Los bloques se generan cuando:
* Umbrales mínimos (AND): Se alcanzan tanto min\_insert\_block\_size\_rows COMO min\_insert\_block\_size\_bytes
* Umbrales máximos (OR): Se alcanza max\_insert\_block\_size\_rows O max\_insert\_block\_size\_bytes
* Cuando está deshabilitada (valor predeterminado): Los bloques se generan cuando se alcanza min\_insert\_block\_size\_rows O min\_insert\_block\_size\_bytes. No se aplican las configuraciones max\_insert\_block\_size.
Valores posibles:
* Entero positivo.
* 0 — la configuración no participa en la formación de bloques.
## min\_insert\_block\_size\_rows\_for\_materialized\_views
Establece el número mínimo de filas del bloque que pueden insertarse en una tabla mediante una consulta `INSERT`. Los bloques más pequeños se agrupan en otros más grandes. Esta configuración se aplica solo a los bloques insertados en una [vista materializada](/es/reference/statements/create/view). Al ajustar esta configuración, se controla la agrupación de bloques al enviarlos a la vista materializada y se evita un uso excesivo de memoria.
Valores posibles:
* Cualquier entero positivo.
* 0 — Agrupación deshabilitada.
**Véase también**
* [min\_insert\_block\_size\_rows](#min_insert_block_size_rows)
## min\_joined\_block\_size\_bytes
Tamaño mínimo del bloque, en bytes, para los bloques de entrada y salida de JOIN (si el algoritmo JOIN lo admite). Los bloques pequeños se compactarán. 0 significa que no hay límite.
## min\_joined\_block\_size\_rows
Tamaño mínimo de bloque, en filas, para los bloques de entrada y salida de JOIN (si el algoritmo de JOIN lo admite). Los bloques pequeños se compactan. 0 significa sin límite.
## min\_os\_cpu\_wait\_time\_ratio\_to\_throw
Relación mínima entre los tiempos de espera de CPU del SO (métrica OSCPUWaitMicroseconds) y de actividad (métrica OSCPUVirtualTimeMicroseconds) para empezar a considerar el rechazo de consultas. Se utiliza interpolación lineal entre la relación mínima y la máxima para calcular la probabilidad; en este punto, la probabilidad es 0.
## min\_outstreams\_per\_resize\_after\_split
Especifica el número mínimo de flujos de salida de un procesador `Resize` o `StrictResize` después de realizar la división durante la generación de la canalización. Si el número resultante de flujos es inferior a este valor, la operación de división no se realizará.
### Qué es un nodo Resize
Un nodo `Resize` es un procesador del pipeline de consultas que ajusta la cantidad de flujos de datos que circulan por el pipeline. Puede aumentar o reducir la cantidad de flujos para equilibrar la carga de trabajo entre varios hilos o procesadores. Por ejemplo, si una consulta requiere más paralelismo, el nodo `Resize` puede dividir un único flujo en varios flujos. A la inversa, puede fusionar varios flujos en menos flujos para consolidar el procesamiento de los datos.
El nodo `Resize` garantiza que los datos se distribuyan uniformemente entre los flujos, manteniendo la estructura de los bloques de datos. Esto ayuda a optimizar el uso de los recursos y a mejorar el rendimiento de las consultas.
### Por qué es necesario dividir el nodo Resize
Durante la ejecución del pipeline, `ExecutingGraph::Node::status_mutex` del nodo `Resize`, que actúa como concentrador central, sufre una fuerte contención, especialmente en entornos con muchos núcleos, y esta contención provoca:
1. Un aumento de la latencia de `ExecutingGraph::updateNode`, lo que afecta directamente al rendimiento de las consultas.
2. Un desperdicio excesivo de ciclos de CPU por la contención del spin-lock (`native_queued_spin_lock_slowpath`), lo que reduce la eficiencia.
3. Una menor utilización de la CPU, lo que limita el paralelismo y la capacidad de procesamiento.
### Cómo se divide el nodo Resize
1. Se comprueba el número de flujos de salida para garantizar que la división pueda realizarse: los flujos de salida de cada procesador resultante de la división cumplen o superan el umbral `min_outstreams_per_resize_after_split`.
2. El nodo `Resize` se divide en nodos `Resize` más pequeños con el mismo número de puertos, y cada uno gestiona un subconjunto de flujos de entrada y de salida.
3. Cada grupo se procesa de forma independiente, lo que reduce la contención por bloqueos.
### División de nodos Resize con entradas/salidas arbitrarias
En algunos casos, cuando las entradas/salidas no son divisibles por el número de nodos `Resize` resultantes de la división, algunas entradas se conectan a `NullSource` y algunas salidas a `NullSink`. Esto permite realizar la división sin afectar al flujo general de datos.
### Propósito de la configuración
La configuración `min_outstreams_per_resize_after_split` garantiza que la división de los nodos `Resize` tenga sentido y evita crear muy pocos flujos, lo que podría provocar un procesamiento paralelo ineficiente. Al imponer un número mínimo de flujos de salida, esta configuración ayuda a mantener un equilibrio entre el paralelismo y la sobrecarga, lo que optimiza la ejecución de consultas en escenarios que implican la división y la fusión de flujos.
### Desactivar el ajuste
Para desactivar la división de los nodos `Resize`, establezca este ajuste en 0. Esto evita que los nodos `Resize` se dividan durante la generación del pipeline, lo que les permite conservar su estructura original sin subdividirse en nodos más pequeños.
## min\_table\_rows\_to\_use\_projection\_index
Si el número estimado de filas que se leerán de la tabla es igual o superior a este umbral, ClickHouse intentará usar el índice de proyección durante la ejecución de la consulta.
## mongodb\_throw\_on\_unsupported\_query
Si está habilitada, las tablas de MongoDB devolverán un error cuando no se pueda generar una consulta de MongoDB. En caso contrario, ClickHouse lee la tabla completa y la procesa localmente. Esta opción no se aplica cuando 'allow\_experimental\_analyzer=0'.
## move\_all\_conditions\_to\_prewhere
Traslada todas las condiciones aplicables de WHERE a PREWHERE
## move\_primary\_key\_columns\_to\_end\_of\_prewhere
Mueve al final de la cadena AND las condiciones de PREWHERE que contienen columnas de la clave primaria. Es probable que estas condiciones ya se tengan en cuenta durante el análisis de la clave primaria y, por lo tanto, apenas contribuyan al filtrado de PREWHERE.
## multiple\_joins\_try\_to\_keep\_original\_names
No añadir alias a la lista de expresiones de nivel superior al reescribir múltiples JOIN
## mutations\_execute\_nondeterministic\_on\_initiator
Si es `true`, las funciones constantes no deterministas (p. ej., la función `now()`) se ejecutan en el iniciador y se reemplazan por literales en las consultas `UPDATE` y `DELETE`. Esto ayuda a mantener los datos sincronizados en las réplicas al ejecutar mutaciones con funciones constantes no deterministas. Valor predeterminado: `false`.
## mutations\_execute\_subqueries\_on\_initiator
Si es `true`, las subconsultas escalares se ejecutan en el iniciador y se sustituyen por literales en las consultas `UPDATE` y `DELETE`. Valor predeterminado: `false`.
## mutations\_max\_literal\_size\_to\_replace
El tamaño máximo, en bytes, del literal serializado que se puede reemplazar en las consultas `UPDATE` y `DELETE`. Solo surte efecto si al menos una de las dos opciones anteriores está habilitada. Valor predeterminado: 16384 (16 KiB).
## mutations\_sync
Permite ejecutar de forma síncrona las consultas `ALTER TABLE ... UPDATE|DELETE|MATERIALIZE INDEX|MATERIALIZE PROJECTION|MATERIALIZE COLUMN|MATERIALIZE STATISTICS` ([mutations](/es/reference/statements/alter#mutations)).
Valores posibles:
| Valor | Descripción |
| ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `0` | Las mutaciones se ejecutan de forma asíncrona. |
| `1` | La consulta espera a que todas las mutaciones finalicen en el servidor actual. |
| `2` | La consulta espera a que todas las mutaciones finalicen en todas las réplicas (si existen). |
| `3` | La consulta espera solo a las réplicas activas. Solo es compatible con `SharedMergeTree`. En `ReplicatedMergeTree`, se comporta igual que `mutations_sync = 2`. |
## mysql\_datatypes\_support\_level
Define cómo los tipos de MySQL se convierten a los tipos correspondientes de ClickHouse. Es una lista separada por comas con cualquier combinación de `decimal`, `datetime64`, `date2Date32` o `date2String`. Todas las correspondencias modernas (`decimal`, `datetime64`, `date2Date32`) están habilitadas de forma predeterminada.
* `decimal`: convierte los tipos `NUMERIC` y `DECIMAL` a `Decimal` cuando la precisión lo permite.
* `datetime64`: convierte los tipos `DATETIME` y `TIMESTAMP` a `DateTime64` en lugar de `DateTime` cuando la precisión no es `0`.
* `date2Date32`: convierte `DATE` a `Date32` en lugar de `Date`. Tiene prioridad sobre `date2String`.
* `date2String`: convierte `DATE` a `String` en lugar de `Date`. `datetime64` lo sobrescribe.
## mysql\_map\_fixed\_string\_to\_text\_in\_show\_columns
Cuando está habilitado, el tipo de dato [FixedString](/es/reference/data-types/fixedstring) de ClickHouse se mostrará como `TEXT` en [SHOW COLUMNS](/es/reference/statements/show#show_columns).
Solo surte efecto cuando la conexión se realiza a través del MySQL wire protocol.
* 0 - Usar `BLOB`.
* 1 - Usar `TEXT`.
## mysql\_map\_string\_to\_text\_in\_show\_columns
Cuando está habilitado, el tipo de datos [String](/es/reference/data-types/string) de ClickHouse se mostrará como `TEXT` en [SHOW COLUMNS](/es/reference/statements/show#show_columns).
Solo surte efecto cuando la conexión se realiza a través del MySQL wire protocol.
* 0 - Usar `BLOB`.
* 1 - Usar `TEXT`.
## mysql\_max\_rows\_to\_insert
El número máximo de filas en la inserción por lotes del motor de almacenamiento MySQL
## network\_compression\_method
El codec para comprimir la comunicación entre cliente y servidor, y entre servidores.
Valores posibles:
* `NONE` — sin compresión.
* `LZ4` — usa el codec LZ4.
* `LZ4HC` — usa el codec LZ4HC.
* `ZSTD` — usa el codec ZSTD.
**Véase también**
* [network\_zstd\_compression\_level](#network_zstd_compression_level)
## network\_zstd\_compression\_level
Ajusta el nivel de compresión de ZSTD. Se usa solo cuando [network\_compression\_method](#network_compression_method) está configurado como `ZSTD`.
Valores posibles:
* Entero positivo del 1 al 15.
## normalize\_function\_names
Normaliza los nombres de las funciones a su forma canónica
## number\_of\_mutations\_to\_delay
Si la tabla con mutaciones contiene al menos esa cantidad de mutaciones sin finalizar, ralentiza artificialmente las mutaciones de la tabla. 0: deshabilitado
## number\_of\_mutations\_to\_throw
Si la tabla mutada contiene al menos esa cantidad de mutaciones sin finalizar, se genera la excepción 'Too many mutations ...'. 0 - deshabilitado
## odbc\_bridge\_connection\_pool\_size
Tamaño del grupo de conexiones para cada cadena de configuración de conexión del ODBC bridge.
## odbc\_bridge\_use\_connection\_pooling
Usa un pool de conexiones en ODBC bridge. Si se establece en false, se crea una nueva conexión cada vez.
## offset
Establece el número de filas que se omiten antes de empezar a devolver filas de la consulta. Ajusta el desplazamiento establecido por la cláusula [OFFSET](/es/reference/statements/select/offset), de modo que ambos valores se sumen.
Valores posibles:
* 0 — No se omite ninguna fila.
* Entero positivo.
**Ejemplo**
Tabla de entrada:
```sql theme={null}
CREATE TABLE test (i UInt64) ENGINE = MergeTree() ORDER BY i;
INSERT INTO test SELECT number FROM numbers(500);
```
Consulta:
```sql theme={null}
SET limit = 5;
SET offset = 7;
SELECT * FROM test LIMIT 10 OFFSET 100;
```
Resultado:
```text theme={null}
┌───i─┐
│ 107 │
│ 108 │
│ 109 │
└─────┘
```
## opentelemetry\_start\_keeper\_trace\_probability
Probabilidad de iniciar una traza para una solicitud de ZooKeeper, tenga o no una traza principal.
Valores posibles:
* 'auto' - Equivale al ajuste opentelemetry\_start\_trace\_probability
* 0 — El trazado está deshabilitado
* 0 a 1 — Probabilidad (p. ej., 1.0 = siempre habilitado)
## opentelemetry\_start\_trace\_probability
Establece la probabilidad de que ClickHouse pueda iniciar una traza para las consultas ejecutadas (si no se proporciona un [trace context](https://www.w3.org/TR/trace-context/) principal).
Valores posibles:
* 0 — La traza para todas las consultas ejecutadas está deshabilitada (si no se proporciona un trace context principal).
* Número de coma flotante positivo en el rango \[0..1]. Por ejemplo, si el valor de la configuración es `0,5`, ClickHouse puede iniciar una traza, en promedio, para la mitad de las consultas.
* 1 — La traza para todas las consultas ejecutadas está habilitada.
## opentelemetry\_trace\_cpu\_scheduling
Recopila spans de OpenTelemetry para la planificación preventiva de la CPU de la carga de trabajo.
## opentelemetry\_trace\_processors
Recopila spans de OpenTelemetry para los procesadores.
## optimize\_aggregation\_in\_order
Habilita la optimización de [GROUP BY](/es/reference/statements/select/group-by) en consultas [SELECT](/es/reference/statements/select) para agregar datos en el orden correspondiente en tablas [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree).
Valores posibles:
* 0 — la optimización de `GROUP BY` está deshabilitada.
* 1 — la optimización de `GROUP BY` está habilitada.
**Véase también**
* [optimización de GROUP BY](/es/reference/statements/select/group-by#group-by-optimization-depending-on-table-sorting-key)
## optimize\_aggregators\_of\_group\_by\_keys
Elimina los agregadores min/max/any/anyLast de las claves de GROUP BY en la sección SELECT
## optimize\_and\_compare\_chain
Propaga las comparaciones con constantes en cadenas de AND para mejorar la capacidad de filtrado. Admite los operadores `<`, `<=`, `>`, `>=`, `=` y sus combinaciones. Por ejemplo, `(a < b) AND (b < c) AND (c < 5)` pasaría a ser `(a < b) AND (b < c) AND (c < 5) AND (b < 5) AND (a < 5)`.
## optimize\_append\_index
Utilice [restricciones](/es/reference/statements/create/table#constraints) para añadir la condición del índice. El valor predeterminado es `false`.
Valores posibles:
* true, false
## optimize\_arithmetic\_operations\_in\_aggregate\_functions
Sacar las operaciones aritméticas de las funciones de agregación
## optimize\_const\_name\_size
Reemplazar por un valor escalar y usar un hash como nombre para constantes grandes (el tamaño se estima por la longitud del nombre).
Valores posibles:
* entero positivo - longitud máxima del nombre,
* 0 — siempre,
* entero negativo - nunca.
## optimize\_count\_from\_files
Habilita o deshabilita la optimización para contar el número de filas en archivos con distintos formatos de entrada. Se aplica a las funciones de tabla/motores `file`/`s3`/`url`/`hdfs`/`azureBlobStorage`.
Valores posibles:
* 0 — Optimización deshabilitada.
* 1 — Optimización habilitada.
## optimize\_dictget\_tuple\_element
Reescribe `tupleElement(dictGet('dict', ('a', 'b', 'c'), key), 2)` como `dictGet('dict', 'b', key)` para evitar obtener atributos de diccionario innecesarios. Admite acceso posicional (`.1`, `.2`, ...) y con nombre (`.b`), y también se aplica a `dictGetOrDefault` cuando el argumento por defecto es una tupla constante o una `tuple(...)` de constantes.
## optimize\_distinct\_in\_order
Habilita la optimización de DISTINCT si algunas de las columnas de DISTINCT constituyen un prefijo de ordenación. Por ejemplo, un prefijo de la clave de ordenación en MergeTree o de la cláusula ORDER BY
## optimize\_distributed\_group\_by\_sharding\_key
Optimiza las consultas `GROUP BY sharding_key` al evitar la costosa agregación en el servidor iniciador (lo que reduce el uso de memoria de la consulta en ese servidor).
Se admiten los siguientes tipos de consultas (y todas sus combinaciones):
* `SELECT DISTINCT [..., ]sharding_key[, ...] FROM dist`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...]`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] ORDER BY x`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1`
* `SELECT ... FROM dist GROUP BY sharding_key[, ...] LIMIT 1 BY x`
No se admiten los siguientes tipos de consultas (es posible que más adelante se añada compatibilidad para algunas de ellas):
* `SELECT ... GROUP BY sharding_key[, ...] WITH TOTALS`
* `SELECT ... GROUP BY sharding_key[, ...] WITH ROLLUP`
* `SELECT ... GROUP BY sharding_key[, ...] WITH CUBE`
* `SELECT ... GROUP BY sharding_key[, ...] SETTINGS extremes=1`
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
Ver también:
* [distributed\_group\_by\_no\_merge](#distributed_group_by_no_merge)
* [distributed\_push\_down\_limit](#distributed_push_down_limit)
* [optimize\_skip\_unused\_shards](#optimize_skip_unused_shards)
Por ahora, requiere `optimize_skip_unused_shards` (esto se debe a que en algún momento podría habilitarse de forma predeterminada, y solo funcionará correctamente si los datos se insertaron a través de una tabla Distributed; es decir, si los datos se distribuyen de acuerdo con `sharding_key`).
## optimize\_dry\_run\_check\_part
Cuando está activado, `OPTIMIZE ... DRY RUN` valida la parte fusionada resultante con `checkDataPart`. Si la comprobación falla, se lanza una excepción.
## optimize\_empty\_string\_comparisons
Convierte expresiones como col = '' o '' = col en empty(col), y col != '' o '' != col en notEmpty(col),
solo cuando col es de tipo String o FixedString.
Permite extraer expresiones comunes de disyunciones en expresiones WHERE, PREWHERE, ON, HAVING y QUALIFY. Una expresión lógica como `(A AND B) OR (A AND C)` se puede reescribir como `A AND (B OR C)`, lo que puede ayudar a aprovechar:
* índices en expresiones de filtrado simples
* la optimización de CROSS JOIN a INNER JOIN
## optimize\_functions\_to\_subcolumns
Habilita o deshabilita la optimización convirtiendo algunas funciones para que lean subcolumnas. Esto reduce la cantidad de datos que se deben leer.
Estas funciones se pueden transformar:
* [length](/es/reference/functions/regular-functions/array-functions#length) para leer la subcolumna [size0](/es/reference/data-types/array#array-size).
* [empty](/es/reference/functions/regular-functions/array-functions#empty) para leer la subcolumna [size0](/es/reference/data-types/array#array-size).
* [notEmpty](/es/reference/functions/regular-functions/array-functions#notEmpty) para leer la subcolumna [size0](/es/reference/data-types/array#array-size).
* [isNull](/es/reference/functions/regular-functions/functions-for-nulls#isNull) para leer la subcolumna [null](/es/reference/data-types/nullable#finding-null).
* [isNotNull](/es/reference/functions/regular-functions/functions-for-nulls#isNotNull) para leer la subcolumna [null](/es/reference/data-types/nullable#finding-null).
* [count](/es/reference/functions/aggregate-functions/count) para leer la subcolumna [null](/es/reference/data-types/nullable#finding-null).
* [mapKeys](/es/reference/functions/regular-functions/tuple-map-functions#mapKeys) para leer la subcolumna [keys](/es/reference/data-types/map#reading-subcolumns-of-map).
* [mapValues](/es/reference/functions/regular-functions/tuple-map-functions#mapValues) para leer la subcolumna [values](/es/reference/data-types/map#reading-subcolumns-of-map).
Posibles valores:
* 0 — Optimización deshabilitada.
* 1 — Optimización habilitada.
## optimize\_group\_by\_constant\_keys
Optimiza GROUP BY cuando todas las claves del bloque son constantes
## optimize\_group\_by\_function\_keys
Elimina las funciones de otras claves en la cláusula GROUP BY
## optimize\_if\_chain\_to\_multiif
Reemplaza las cadenas de `if(cond1, then1, if(cond2, ...))` por `multiIf`. Actualmente no resulta beneficioso para los tipos numéricos.
## optimize\_if\_transform\_strings\_to\_enum
Reemplaza por enum los argumentos de tipo String en If y Transform. Está deshabilitado de forma predeterminada porque podría provocar un cambio inconsistente en una consulta distribuida, lo que haría que fallara.
## optimize\_injective\_functions\_in\_group\_by
Sustituye las funciones inyectivas por sus argumentos en la cláusula GROUP BY
## optimize\_injective\_functions\_inside\_uniq
Elimina las funciones inyectivas de un solo argumento dentro de las funciones uniq\*().
## optimize\_inverse\_dictionary\_lookup
Evita las búsquedas inversas repetidas en el diccionario mediante búsquedas más rápidas en un conjunto precalculado de posibles valores de clave.
## optimize\_min\_equality\_disjunction\_chain\_length
La longitud mínima de la expresión `expr = x1 OR ... expr = xN` para la optimización
## optimize\_min\_inequality\_conjunction\_chain\_length
La longitud mínima de la expresión `expr <> x1 AND ... expr <> xN` para la optimización
## optimize\_move\_to\_prewhere
Activa o desactiva la optimización automática de [PREWHERE](/es/reference/statements/select/prewhere) en las consultas [SELECT](/es/reference/statements/select).
Solo funciona con tablas [\*MergeTree](/es/reference/engines/table-engines/mergetree-family).
Posibles valores:
* 0 — La optimización automática de `PREWHERE` está desactivada.
* 1 — La optimización automática de `PREWHERE` está activada.
## optimize\_move\_to\_prewhere\_if\_final
Habilita o deshabilita la optimización automática de [PREWHERE](/es/reference/statements/select/prewhere) en las consultas [SELECT](/es/reference/statements/select) con el modificador [FINAL](/es/reference/statements/select/from#final-modifier).
Solo funciona con tablas [\*MergeTree](/es/reference/engines/table-engines/mergetree-family).
Valores posibles:
* 0 — La optimización automática de `PREWHERE` en las consultas `SELECT` con el modificador `FINAL` está deshabilitada.
* 1 — La optimización automática de `PREWHERE` en las consultas `SELECT` con el modificador `FINAL` está habilitada.
**Véase también**
* La configuración [optimize\_move\_to\_prewhere](#optimize_move_to_prewhere)
## optimize\_multiif\_to\_if
Sustituye 'multiIf' con una sola condición por 'if'.
## optimize\_normalize\_count\_variants
Reescribe como count() las funciones de agregación semánticamente equivalentes a count().
## optimize\_on\_insert
Habilita o deshabilita la transformación de datos antes de la inserción, como si se hubiera realizado una combinación en este bloque (según el motor de tabla).
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
**Ejemplo**
La diferencia entre habilitado y deshabilitado:
Consulta:
```sql theme={null}
SET optimize_on_insert = 1;
CREATE TABLE test1 (`FirstTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY FirstTable;
INSERT INTO test1 SELECT number % 2 FROM numbers(5);
SELECT * FROM test1;
SET optimize_on_insert = 0;
CREATE TABLE test2 (`SecondTable` UInt32) ENGINE = ReplacingMergeTree ORDER BY SecondTable;
INSERT INTO test2 SELECT number % 2 FROM numbers(5);
SELECT * FROM test2;
```
Resultado:
```text theme={null}
┌─FirstTable─┐
│ 0 │
│ 1 │
└────────────┘
┌─SecondTable─┐
│ 0 │
│ 0 │
│ 0 │
│ 1 │
│ 1 │
└─────────────┘
```
Ten en cuenta que esta configuración afecta al comportamiento de la [vista materializada](/es/reference/statements/create/view#materialized-view).
## optimize\_or\_like\_chain
Optimiza varias expresiones OR LIKE en multiMatchAny. Esta optimización no debería estar habilitada de forma predeterminada, porque en algunos casos dificulta el análisis de índices.
## optimize\_qbit\_distance\_function\_reads
Reemplaza las funciones de distancia del tipo de datos `QBit` por otras equivalentes que solo leen del almacenamiento las columnas necesarias para el cálculo.
## optimize\_read\_in\_order
Habilita la optimización de [ORDER BY](/es/reference/statements/select/order-by#optimization-of-data-reading) en las consultas [SELECT](/es/reference/statements/select) para la lectura de datos de tablas [MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree).
Valores posibles:
* 0 — la optimización de `ORDER BY` está deshabilitada.
* 1 — la optimización de `ORDER BY` está habilitada.
**Véase también**
* [Cláusula ORDER BY](/es/reference/statements/select/order-by#optimization-of-data-reading)
## optimize\_redundant\_functions\_in\_order\_by
Elimina las funciones de ORDER BY si su argumento también aparece en ORDER BY
## optimize\_respect\_aliases
Si se establece en true, respetará los alias en WHERE/GROUP BY/ORDER BY, lo que ayudará a la poda de particiones/índices secundarios/optimize\_aggregation\_in\_order/optimize\_read\_in\_order/optimize\_trivial\_count
## optimize\_rewrite\_aggregate\_function\_with\_if
Reescribe las funciones de agregación cuyo argumento es una expresión `if` cuando sean lógicamente equivalentes.
Por ejemplo, `avg(if(cond, col, null))` se puede reescribir como `avgOrNullIf(cond, col)`. Esto puede mejorar el rendimiento.
Solo se admite con el analizador (`enable_analyzer = 1`).
## optimize\_rewrite\_array\_exists\_to\_has
Reescribe las funciones arrayExists() como has() cuando sean lógicamente equivalentes. Por ejemplo, arrayExists(x -> x = 1, arr) puede reescribirse como has(arr, 1)
## optimize\_rewrite\_like\_perfect\_affix
Reescribe las expresiones LIKE con un prefijo o sufijo exacto (p. ej., `col LIKE 'ClickHouse%'`) como funciones startsWith o endsWith (p. ej., `startsWith(col, 'ClickHouse')`).
## optimize\_rewrite\_regexp\_functions
Reescribe las funciones relacionadas con expresiones regulares para convertirlas en formas más simples y eficientes
## optimize\_rewrite\_sum\_if\_to\_count\_if
Reescribe las funciones sumIf() y sum(if()) como countIf() cuando son lógicamente equivalentes
## optimize\_skip\_merged\_partitions
Habilita o deshabilita la optimización para la consulta [OPTIMIZE TABLE ... FINAL](/es/reference/statements/optimize) si solo hay una parte con nivel > 0 y no tiene un TTL vencido.
* `OPTIMIZE TABLE ... FINAL SETTINGS optimize_skip_merged_partitions=1`
De forma predeterminada, la consulta `OPTIMIZE TABLE ... FINAL` reescribe esa parte aunque solo haya una única parte.
Posibles valores:
* 1 - Habilita la optimización.
* 0 - Deshabilita la optimización.
## optimize\_skip\_unused\_shards
Habilita o deshabilita la omisión de segmentos no utilizados para las consultas [SELECT](/es/reference/statements/select) que tienen una condición sobre la clave de segmentación en `WHERE/PREWHERE`, y activa optimizaciones relacionadas para las consultas distribuidas (por ejemplo, la agregación por clave de segmentación).
Se asume que los datos se distribuyen por la clave de segmentación; de lo contrario, una consulta devuelve un resultado incorrecto.
Posibles valores:
* 0 — Deshabilitado.
* 1 — Habilitado.
## optimize\_skip\_unused\_shards\_limit
Límite del número de valores de la clave de sharding; desactiva `optimize_skip_unused_shards` si se alcanza este límite.
Demasiados valores pueden requerir un procesamiento considerable, mientras que el beneficio es dudoso, ya que, si tienes una gran cantidad de valores en `IN (...)`, lo más probable es que la consulta se envíe a todos los segmentos de todos modos.
## optimize\_skip\_unused\_shards\_nesting
Controla el nivel de anidamiento de la consulta distribuida en el que depende [`optimize_skip_unused_shards`](#optimize_skip_unused_shards) (por lo tanto, sigue requiriendo [`optimize_skip_unused_shards`](#optimize_skip_unused_shards)); es el caso en el que una tabla `Distributed` consulta otra tabla `Distributed`.
Valores posibles:
* 0 — Deshabilitado; `optimize_skip_unused_shards` funciona siempre.
* 1 — Habilita `optimize_skip_unused_shards` solo para el primer nivel.
* 2 — Habilita `optimize_skip_unused_shards` hasta el segundo nivel.
## optimize\_skip\_unused\_shards\_rewrite\_in
Reescribe `IN` en la consulta para los segmentos remotos a fin de excluir los valores que no pertenecen al segmento (requiere optimize\_skip\_unused\_shards).
Valores posibles:
* 0 — Desactivado.
* 1 — Activado.
## optimize\_sorting\_by\_input\_stream\_properties
Optimiza la ordenación en función de las propiedades de ordenación del flujo de entrada
## optimize\_substitute\_columns
Use [restricciones](/es/reference/statements/create/table#constraints) para sustituir columnas. El valor predeterminado es `false`.
Valores posibles:
* true, false
## optimize\_syntax\_fuse\_functions
Permite fusionar funciones de agregación con el mismo argumento. Reescribe una consulta que contiene al menos dos funciones de agregación, [sum](/es/reference/functions/aggregate-functions/sum), [count](/es/reference/functions/aggregate-functions/count) o [avg](/es/reference/functions/aggregate-functions/avg), con el mismo argumento, como [sumCount](/es/reference/functions/aggregate-functions/sumCount).
Valores posibles:
* 0 — Las funciones con el mismo argumento no se fusionan.
* 1 — Las funciones con el mismo argumento se fusionan.
**Ejemplo**
Consulta:
```sql theme={null}
CREATE TABLE fuse_tbl(a Int8, b Int8) Engine = Log;
SET optimize_syntax_fuse_functions = 1;
EXPLAIN SYNTAX run_query_tree_passes = 1 SELECT sum(a), sum(b), count(b), avg(b) from fuse_tbl FORMAT TSV;
```
Resultado:
```text theme={null}
SELECT
sum(__table1.a) AS `sum(a)`,
tupleElement(sumCount(__table1.b), 1) AS `sum(b)`,
tupleElement(sumCount(__table1.b), 2) AS `count(b)`,
divide(tupleElement(sumCount(__table1.b), 1), toFloat64(tupleElement(sumCount(__table1.b), 2))) AS `avg(b)`
FROM default.fuse_tbl AS __table1
```
## optimize\_throw\_if\_noop
Habilita o deshabilita el lanzamiento de una excepción si una consulta [OPTIMIZE](/es/reference/statements/optimize) no realizó ningún merge.
De forma predeterminada, `OPTIMIZE` finaliza correctamente aunque no haga nada. Esta configuración permite distinguir estas situaciones y obtener el motivo en un mensaje de excepción.
Valores posibles:
* 1 — El lanzamiento de una excepción está habilitado.
* 0 — El lanzamiento de una excepción está deshabilitado.
## optimize\_time\_filter\_with\_preimage
col >= '2023-01-01' AND col <= '2023-12-31')"}]}]} />
Optimiza los predicados de Date y DateTime convirtiendo las funciones en comparaciones equivalentes sin necesidad de conversiones (p. ej., `toYear(col) = 2023 -> col >= '2023-01-01' AND col <= '2023-12-31'`)
## optimize\_trivial\_approximate\_count\_query
Usa un valor aproximado para la optimización del recuento trivial en almacenamientos que admiten este tipo de estimación, por ejemplo, EmbeddedRocksDB.
Valores posibles:
* 0 — Optimización deshabilitada.
* 1 — Optimización habilitada.
## optimize\_trivial\_count\_query
Habilita o deshabilita la optimización de la consulta trivial `SELECT count() FROM table` a partir de los metadatos de MergeTree. Si necesita usar seguridad a nivel de fila, deshabilite este ajuste.
Valores posibles:
* 0 — Optimización deshabilitada.
* 1 — Optimización habilitada.
Véase también:
* [optimize\_functions\_to\_subcolumns](#optimize_functions_to_subcolumns)
## optimize\_trivial\_group\_by\_limit\_query
Habilita o deshabilita la optimización de una consulta trivial `SELECT key_expr FROM table GROUP BY key_expr LIMIT n` (sin funciones de agregación en la proyección, sin cláusulas `HAVING`/`ORDER BY`/`LIMIT BY`/window y sin modificadores de `GROUP BY`) estableciendo `max_rows_to_group_by = n + offset` con `group_by_overflow_mode = 'any'`. La agregación se detiene en cuanto se obtienen `n + offset` claves distintas.
La optimización se omite cuando el usuario ha establecido explícitamente `group_by_overflow_mode` en un valor distinto de `any` (para preservar la semántica explícita de `throw`/`break`) y cuando el usuario ya ha establecido un `max_rows_to_group_by` más restrictivo (la optimización sería un no-op).
Valores posibles:
* 0 — Optimización deshabilitada.
* 1 — Optimización habilitada.
## optimize\_trivial\_insert\_select
Optimiza la consulta trivial 'INSERT INTO table SELECT ... FROM TABLES'
## optimize\_truncate\_order\_by\_after\_group\_by\_keys
Elimina los elementos finales de ORDER BY una vez que todas las claves de GROUP BY queden cubiertas por el prefijo de ORDER BY.
## optimize\_uniq\_to\_count
Reescribe `uniq` y sus variantes (excepto `uniqUpTo`) como `count` si la subconsulta incluye `distinct` o una cláusula `group by`.
## optimize\_use\_implicit\_projections
Elegir automáticamente proyecciones implícitas para ejecutar la consulta SELECT
## optimize\_use\_projection\_filtering
Permite usar proyecciones para filtrar rangos de partes incluso cuando no se seleccionan proyecciones para ejecutar una consulta SELECT.
## optimize\_use\_projections
**Alias**: `allow_experimental_projection_optimization`
Activa o desactiva la optimización de [proyecciones](/es/reference/engines/table-engines/mergetree-family/mergetree#projections) al procesar consultas `SELECT`.
Valores posibles:
* 0 — Optimización de proyecciones desactivada.
* 1 — Optimización de proyecciones activada.
## optimize\_using\_constraints
Utilice [restricciones](/es/reference/statements/create/table#constraints) para optimizar las consultas. El valor predeterminado es `false`.
Valores posibles:
* true, false
## os\_threads\_nice\_value\_materialized\_view
Valor nice de Linux para los hilos de la vista materializada. Los valores más bajos implican una mayor prioridad de CPU.
Requiere la capacidad CAP\_SYS\_NICE; de lo contrario, no hace nada.
Posibles valores: -20 a 19.
## os\_threads\_nice\_value\_query
**Alias**: `os_thread_priority`
Valor nice de Linux para los hilos de procesamiento de consultas. Los valores más bajos implican una mayor prioridad de CPU.
Requiere la capability CAP\_SYS\_NICE; de lo contrario, no tiene efecto.
Valores posibles: -20 a 19.
## page\_cache\_block\_size
Tamaño de los fragmentos de archivo que se almacenan en la caché de páginas en espacio de usuario, en bytes. Todas las lecturas que pasen por la caché se redondearán hacia arriba al múltiplo más próximo de este tamaño.
Esta configuración puede ajustarse por consulta, pero las entradas de caché con distintos tamaños de bloque no pueden reutilizarse. Cambiar esta configuración invalida en la práctica las entradas existentes en la caché.
Un valor más alto, como 1 MiB, es adecuado para consultas de alto rendimiento, y un valor más bajo, como 64 KiB, es adecuado para consultas puntuales de baja latencia.
## page\_cache\_inject\_eviction
La caché de páginas en espacio de usuario a veces invalidará algunas páginas de forma aleatoria. Está pensado para pruebas.
## page\_cache\_lookahead\_blocks
Si se produce un fallo en la caché de páginas en espacio de usuario, lee de una sola vez hasta esta cantidad de bloques consecutivos desde el almacenamiento subyacente, siempre que tampoco estén en la caché. Cada bloque tiene `page_cache_block_size` bytes.
Un valor más alto es beneficioso para consultas de alto rendimiento, mientras que las consultas puntuales de baja latencia funcionan mejor sin lectura anticipada.
## page\_cache\_max\_coalesced\_bytes
Cuando `readBigAt` puebla la caché de páginas en espacio de usuario, los fallos de caché consecutivos se combinan en una sola lectura desde el almacenamiento subyacente. Esta configuración limita en bytes el tamaño de una lectura combinada; las secuencias de fallos más largas se dividen en varias lecturas. Limita el uso transitorio de memoria del búfer temporal durante lecturas en frío en paralelo.
Un valor más alto reduce el número de solicitudes HTTP en los escaneos en frío sobre almacenamiento de objetos; un valor más bajo reduce el pico de memoria transitoria.
## paimon\_target\_snapshot\_id
Lectura dirigida de snapshots a nivel de consulta para el modo incremental de Paimon. Cuando es >0, el lector solo recuperará el delta
del snapshot\_id especificado sin avanzar el watermark confirmado.
Predeterminado: -1 (deshabilitado)
## parallel\_distributed\_insert\_select
Habilita la consulta distribuida `INSERT ... SELECT` en paralelo.
Si ejecutamos consultas `INSERT INTO distributed_table_a SELECT ... FROM distributed_table_b`, y ambas tablas usan el mismo clúster, y ambas tablas son [replicadas](/es/reference/engines/table-engines/mergetree-family/replication) o no replicadas, esta consulta se procesa localmente en cada segmento.
Posibles valores:
* `0` — Deshabilitado.
* `1` — `SELECT` se ejecutará en cada segmento desde la tabla subyacente del motor Distributed.
* `2` — `SELECT` e `INSERT` se ejecutarán en cada segmento desde/hacia la tabla subyacente del motor Distributed.
Desde la versión 25.4, `INSERT ... SELECT` desde un origen `ReplicatedMergeTree` o `SharedMergeTree` también puede paralelizarse entre réplicas. Para habilitarlo:
* `parallel_distributed_insert_select = 2`
* `enable_parallel_replicas = 1`
## parallel\_hash\_join\_threshold
Cuando se aplica un algoritmo de join basado en hash, este umbral ayuda a decidir entre usar `hash` y `parallel_hash` (solo si se dispone de una estimación del tamaño de la tabla de la derecha).
El primero se usa cuando sabemos que el tamaño de la tabla de la derecha está por debajo del umbral.
## parallel\_non\_joined\_rows\_processing
Permite que varios hilos procesen en paralelo las filas no emparejadas de la tabla derecha durante los JOIN RIGHT y FULL.
Esto puede acelerar la fase de filas no emparejadas al usar el algoritmo de join `parallel_hash` con tablas grandes.
Cuando está deshabilitado, las filas no emparejadas se procesan con un solo hilo.
## parallel\_replica\_offset
Esta configuración es interna, no debe usarse directamente y representa un detalle de implementación del modo de 'réplicas paralelas'. El servidor iniciador establecerá automáticamente esta configuración, para las consultas distribuidas, con el índice de la réplica que participa en el procesamiento de la consulta entre las réplicas paralelas.
## parallel\_replicas\_allow\_in\_with\_subquery
Si es true, la subconsulta de IN se ejecutará en cada réplica follower.
## parallel\_replicas\_allow\_materialized\_views
Permitir el uso de vistas materializadas con réplicas paralelas
## parallel\_replicas\_allow\_view\_over\_mergetree
Permite que las réplicas paralelas ejecuten la consulta externa de una vista simple sobre tablas `MergeTree` (en lugar de la consulta interna de la vista), lo que mejora la paralelización entre nodos. También se aplica a las vistas `UNION ALL` cuyas ramas leen cada una de una tabla `MergeTree` distinta.
## parallel\_replicas\_connect\_timeout\_ms
El tiempo de espera en milisegundos para conectarse a una réplica remota durante la ejecución de consultas con réplicas paralelas. Si el tiempo de espera vence, la réplica correspondiente no se utiliza para la ejecució
## parallel\_replicas\_count
Esta es una configuración interna que no debe usarse directamente y representa un detalle de implementación del modo de 'réplicas en paralelo'. El servidor iniciador configurará automáticamente esta opción para las consultas distribuidas con el número de réplicas en paralelo que participan en el procesamiento de la consulta.
## parallel\_replicas\_custom\_key
Una expresión entera arbitraria que puede utilizarse para dividir el trabajo entre réplicas de una tabla específica.
El valor puede ser cualquier expresión entera.
Se prefieren las expresiones simples que usan claves primarias.
Si la configuración se utiliza en un clúster que consta de un solo segmento con varias réplicas, esas réplicas se convertirán en segmentos virtuales.
De lo contrario, se comportará igual que con la clave `SAMPLE`: usará varias réplicas de cada segmento.
## parallel\_replicas\_custom\_key\_range\_lower
Permite que el tipo de filtro `range` divida el trabajo de manera uniforme entre las réplicas según el rango personalizado `[parallel_replicas_custom_key_range_lower, INT_MAX]`.
Cuando se usa junto con [parallel\_replicas\_custom\_key\_range\_upper](#parallel_replicas_custom_key_range_upper), permite que el filtro divida de manera uniforme el trabajo entre las réplicas para el rango `[parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper]`.
Nota: Esta configuración no hace que se filtren datos adicionales durante el procesamiento de consultas; más bien, cambia los puntos en los que el filtro de rango divide el rango `[0, INT_MAX]` para su procesamiento en paralelo.
## parallel\_replicas\_custom\_key\_range\_upper
Permite que el tipo de filtro `range` divida el trabajo de manera uniforme entre las réplicas en función del rango personalizado `[0, parallel_replicas_custom_key_range_upper]`. Un valor de 0 desactiva el límite superior y lo establece en el valor máximo de la expresión de clave personalizada.
Cuando se usa junto con [parallel\_replicas\_custom\_key\_range\_lower](#parallel_replicas_custom_key_range_lower), permite que el filtro divida uniformemente el trabajo entre las réplicas para el rango `[parallel_replicas_custom_key_range_lower, parallel_replicas_custom_key_range_upper]`.
Nota: esta configuración no hará que se filtren datos adicionales durante el procesamiento de consultas; más bien, cambia los puntos en los que el filtro de rango divide el intervalo `[0, INT_MAX]` para el procesamiento paralelo
## parallel\_replicas\_filter\_pushdown
Permite aplicar pushdown de filtros en la parte de la consulta que ejecutan las réplicas paralelas
## parallel\_replicas\_for\_cluster\_engines
Reemplaza los motores de las funciones de tabla por sus alternativas -Cluster
## parallel\_replicas\_for\_non\_replicated\_merge\_tree
Si es true, ClickHouse también usará el algoritmo de réplicas paralelas para las tablas MergeTree no replicadas
## parallel\_replicas\_index\_analysis\_only\_on\_coordinator
El análisis del índice se realiza solo en la réplica coordinadora y se omite en las demás réplicas. Solo surte efecto con parallel\_replicas\_local\_pla
## parallel\_replicas\_insert\_select\_local\_pipeline
Usar un pipeline local durante un INSERT SELECT distribuido con réplicas paralelas
## parallel\_replicas\_local\_plan
Construye el plan local para la réplica local
## parallel\_replicas\_mark\_segment\_size
Las partes se dividen virtualmente en segmentos para distribuirlas entre las réplicas durante la lectura en paralelo. Esta configuración controla el tamaño de estos segmentos. No se recomienda cambiarla hasta estar absolutamente seguro de lo que se está haciendo. El valor debe estar en el rango \[128; 16384]
## parallel\_replicas\_min\_number\_of\_rows\_per\_replica
Limita el número de réplicas utilizadas en una consulta a (filas estimadas que se van a leer / min\_number\_of\_rows\_per\_replica). El máximo sigue estando limitado por 'max\_parallel\_replicas'
## parallel\_replicas\_mode
Tipo de filtro que se usará con la clave personalizada para las réplicas paralelas. default - usa la operación de módulo sobre la clave personalizada, range - usa un filtro de rango sobre la clave personalizada utilizando todos los valores posibles del tipo de valor de la clave personalizada.
## parallel\_replicas\_only\_with\_analyzer
El analizador debe estar habilitado para usar réplicas paralelas. Si el analizador está deshabilitado, la ejecución de la consulta recurre a la ejecución local, incluso si la lectura paralela desde réplicas está habilitada. No se admite usar réplicas paralelas sin el analizador habilitado
## parallel\_replicas\_prefer\_local\_join
Si es true, JOIN puede ejecutarse con el algoritmo de réplicas paralelas y todos los motores de almacenamiento de la parte derecha del JOIN son \*MergeTree, se usará JOIN local en lugar de GLOBAL JOIN.
## parallel\_replicas\_prefer\_local\_replica
Cuando está habilitada (de forma predeterminada), la réplica local siempre se incluye en el conjunto de réplicas utilizadas para la lectura en paralelo.
Cuando está deshabilitada, no se da preferencia a la réplica local y las réplicas se seleccionan únicamente mediante el algoritmo de balanceo de carga.
Esto permite que las consultas con `max_parallel_replicas = 1` se dirijan a otro host, lo que puede mejorar la localidad de la caché cuando muchas consultas cortas se distribuyen en un clúster.
## parallel\_replicas\_support\_projection
La optimización de las proyecciones puede aplicarse en réplicas paralelas. Solo surte efecto si parallel\_replicas\_local\_plan está habilitado y aggregation\_in\_order está inactivo.
## parallel\_view\_processing
Habilita el envío concurrente a las vistas adjuntas en lugar de secuencial.
## parallelize\_output\_from\_storages
Paraleliza la salida en la etapa de lectura desde el almacenamiento. Permite paralelizar el procesamiento de consultas inmediatamente después de leer del almacenamiento, cuando sea posible
## parsedatetime\_e\_requires\_space\_padding
El formateador '%e' de la función 'parseDateTime' requiere que los días de un solo dígito estén rellenados con espacios; por ejemplo, se acepta ' 2', pero '2' genera un error.
## parsedatetime\_parse\_without\_leading\_zeros
Los formateadores '%c', '%l' y '%k' de la función 'parseDateTime' interpretan meses y horas sin ceros a la izquierda.
## partial\_merge\_join\_left\_table\_buffer\_bytes
Si no es 0, agrupa los bloques de la tabla izquierda en bloques más grandes para el lado izquierdo de partial merge join. Utiliza hasta 2 veces la memoria especificada por cada hilo de join.
## partial\_merge\_join\_rows\_in\_right\_blocks
Limita el tamaño de los bloques de datos del lado derecho de JOIN en el algoritmo partial merge join para las consultas [JOIN](/es/reference/statements/select/join).
Servidor de ClickHouse:
1. Divide los datos del lado derecho de JOIN en bloques de hasta el número de filas especificado.
2. Indexa cada bloque con sus valores mínimo y máximo.
3. Vuelca los bloques preparados a disco si es posible.
Valores posibles:
* Cualquier entero positivo. Rango de valores recomendado: \[1000, 100000].
## partial\_result\_on\_first\_cancel
Permite que la consulta devuelva un resultado parcial tras cancelarla.
## parts\_to\_delay\_insert
Si la tabla de destino contiene al menos esa cantidad de partes activas en una sola partición, ralentiza artificialmente la inserción en la tabla.
## parts\_to\_throw\_insert
Si el número de partes activas en una sola partición de la tabla de destino supera este valor, se lanza la excepción 'Too many parts ...'.
## per\_part\_index\_stats
Registra estadísticas del índice para cada parte
## poll\_interval
Bloquea el bucle de espera de la consulta en el servidor durante el número de segundos especificado.
## polyglot\_dialect
Dialecto SQL de origen del transpilador políglota (p. ej., 'sqlite', 'mysql', 'postgresql', 'snowflake', 'duckdb').
## postgresql\_connection\_attempt\_timeout
Tiempo de espera de conexión, en segundos, para un único intento de conexión al endpoint de PostgreSQL.
El valor se pasa como parámetro `connect_timeout` en la URL de conexión.
## postgresql\_connection\_pool\_auto\_close\_connection
Cierra la conexión antes de devolverla al grupo.
## postgresql\_connection\_pool\_retries
Número de reintentos de push/pop del pool de conexiones para el motor de tabla PostgreSQL y el motor de base de datos.
## postgresql\_connection\_pool\_size
Tamaño del pool de conexiones para el motor de tabla PostgreSQL y el motor de base de datos.
## postgresql\_connection\_pool\_wait\_timeout
Tiempo de espera de push/pop del pool de conexiones cuando el pool está vacío para el engine de tabla PostgreSQL y el engine de base de datos. De forma predeterminada, se bloqueará si el pool está vacío.
## postgresql\_fault\_injection\_probability
Probabilidad aproximada de fallo de las consultas internas de PostgreSQL (para la replicación). El valor válido está en el intervalo \[0.0f, 1.0f]
## predicate\_statistics\_sample\_rate
Recopila estadísticas de selectividad de predicados en `system.predicate_statistics_log`. Cuando se establece en N > 0, se toma una muestra de aproximadamente 1/N de las consultas (según el ID de la consulta). 0 significa deshabilitado.
## prefer\_column\_name\_to\_alias
Habilita o deshabilita el uso de los nombres de columna originales en lugar de alias en las expresiones y cláusulas de una consulta. Esto es especialmente importante cuando el alias coincide con el nombre de la columna; consulte [Expression Aliases](/es/reference/syntax#notes-on-usage). Active esta configuración para que las reglas sintácticas de los alias en ClickHouse sean más compatibles con la mayoría de los demás motores de base de datos.
Valores posibles:
* 0 — El nombre de la columna se sustituye por el alias.
* 1 — El nombre de la columna no se sustituye por el alias.
**Ejemplo**
Diferencia entre habilitado y deshabilitado:
Consulta:
```sql theme={null}
SET prefer_column_name_to_alias = 0;
SELECT avg(number) AS number, max(number) FROM numbers(10);
```
Resultado:
```text theme={null}
Received exception from server (version 21.5.1):
Code: 184. DB::Exception: Received from localhost:9000. DB::Exception: Aggregate function avg(number) is found inside another aggregate function in query: While processing avg(number) AS number.
```
Consulta:
```sql theme={null}
SET prefer_column_name_to_alias = 1;
SELECT avg(number) AS number, max(number) FROM numbers(10);
```
Resultado:
```text theme={null}
┌─number─┬─max(number)─┐
│ 4.5 │ 9 │
└────────┴─────────────┘
```
## prefer\_external\_sort\_block\_bytes
Prioriza el número máximo de bytes por bloque para la ordenación externa; reduce el uso de memoria durante la fusión.
## prefer\_global\_in\_and\_join
Habilita el reemplazo de los operadores `IN`/`JOIN` por `GLOBAL IN`/`GLOBAL JOIN`.
Valores posibles:
* 0 — Deshabilitado. Los operadores `IN`/`JOIN` no se reemplazan por `GLOBAL IN`/`GLOBAL JOIN`.
* 1 — Habilitado. Los operadores `IN`/`JOIN` se reemplazan por `GLOBAL IN`/`GLOBAL JOIN`.
**Uso**
Aunque `SET distributed_product_mode=global` puede cambiar el comportamiento de las consultas para las tablas distribuidas, no resulta adecuado para las tablas locales ni para las tablas de fuentes externas. Aquí es donde entra en juego la configuración `prefer_global_in_and_join`.
Por ejemplo, podemos tener nodos que sirven consultas y contienen tablas locales que no son adecuadas para la distribución. Necesitamos distribuir sus datos sobre la marcha durante el procesamiento distribuido con la palabra clave `GLOBAL`: `GLOBAL IN`/`GLOBAL JOIN`.
Otro caso de uso de `prefer_global_in_and_join` es acceder a tablas creadas por motores externos. Esta configuración ayuda a reducir el número de llamadas a fuentes externas al unir esas tablas: solo una llamada por consulta.
**Véase también:**
* [Subconsultas distribuidas](/es/reference/statements/in#distributed-subqueries) para obtener más información sobre cómo usar `GLOBAL IN`/`GLOBAL JOIN`
## prefer\_localhost\_replica
Habilita o deshabilita el uso preferente de la réplica localhost al procesar consultas distribuidas.
Valores posibles:
* 1 — ClickHouse siempre envía una consulta a la réplica localhost si existe.
* 0 — ClickHouse usa la estrategia de balanceo especificada por el ajuste [load\_balancing](#load_balancing).
Deshabilite este ajuste si usa [max\_parallel\_replicas](#max_parallel_replicas) sin [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key).
Si [parallel\_replicas\_custom\_key](#parallel_replicas_custom_key) está establecido, deshabilite este ajuste solo si se usa en un clúster con múltiples segmentos que contienen múltiples réplicas.
Si se usa en un clúster con un solo segmento y múltiples réplicas, deshabilitar este ajuste tendrá efectos negativos.
## prefer\_warmed\_unmerged\_parts\_seconds
Solo tiene efecto en ClickHouse Cloud. Si una parte fusionada tiene menos de esta cantidad de segundos de antigüedad y no está precalentada (véase [cache\_populated\_by\_fetch](/es/reference/settings/merge-tree-settings#cache_populated_by_fetch)), pero todas sus partes de origen están disponibles y precalentadas, las consultas SELECT leerán de esas partes en su lugar. Solo para Replicated-/SharedMergeTree. Ten en cuenta que esto solo comprueba si CacheWarmer procesó la parte; si la parte se cargó en la caché por algún otro medio, seguirá considerándose fría hasta que CacheWarmer la procese; si se precalentó y luego fue expulsada de la caché, seguirá considerándose caliente.
## preferred\_block\_size\_bytes
Esta configuración ajusta el tamaño del bloque de datos para el procesamiento de consultas y supone un ajuste adicional más preciso de la configuración más general `max_block_size`. Si las columnas son grandes y, con `max_block_size` filas, es probable que el tamaño del bloque supere la cantidad de bytes especificada, se reducirá para mejorar la localidad de caché de la CPU.
## preferred\_max\_column\_in\_block\_size\_bytes
Límite del tamaño máximo de una columna en un bloque durante la lectura. Ayuda a reducir la cantidad de fallos de caché. Debe ser cercano al tamaño de la caché L2.
## preferred\_optimize\_projection\_name
Si se establece en una cadena no vacía, ClickHouse intentará aplicar la proyección especificada en la consulta.
Valores posibles:
* string: nombre de la proyección preferida
## prefetch\_buffer\_size
El tamaño máximo del búfer de precarga para la lectura desde el sistema de archivos.
## print\_pretty\_type\_names
Permite mostrar nombres de tipos con anidamiento profundo de forma legible y con sangrías en la consulta `DESCRIBE` y en la función `toTypeName()`.
Ejemplo:
```sql theme={null}
CREATE TABLE test (a Tuple(b String, c Tuple(d Nullable(UInt64), e Array(UInt32), f Array(Tuple(g String, h Map(String, Array(Tuple(i String, j UInt64))))), k Date), l Nullable(String))) ENGINE=Memory;
DESCRIBE TABLE test FORMAT TSVRaw SETTINGS print_pretty_type_names=1;
```
```
a Tuple(
b String,
c Tuple(
d Nullable(UInt64),
e Array(UInt32),
f Array(Tuple(
g String,
h Map(
String,
Array(Tuple(
i String,
j UInt64
))
)
)),
k Date
),
l Nullable(String)
)
```
## priority
Prioridad de la consulta. 1: la más alta; cuanto mayor sea el valor, menor será la prioridad; 0: no se usan prioridades.
## promql\_database
Especifica el nombre de la base de datos que utiliza el dialecto 'promql'. Una cadena vacía indica la base de datos actual.
## promql\_evaluation\_time
**Aliases**: `evaluation_time`
Establece el momento de evaluación que se usará con el dialecto promql. 'auto' significa la hora actual.
## promql\_table
Especifica el nombre de la tabla TimeSeries utilizada por el dialecto 'promql'.
## push\_external\_roles\_in\_interserver\_queries
Permite enviar roles de usuario desde el nodo de origen a otros nodos al ejecutar una consulta.
## query\_cache\_compress\_entries
Comprime las entradas de la [caché de consultas](/es/concepts/features/performance/caches/query-cache). Reduce el consumo de memoria de la caché de consultas a costa de ralentizar las inserciones y lecturas.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## query\_cache\_for\_subqueries
Si está activado, los resultados de las subconsultas pueden escribirse en la [caché de consultas](/es/concepts/features/performance/caches/query-cache) y leerse desde ella. Esto permite propagar `use_query_cache` a todas las subconsultas.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## query\_cache\_max\_entries
La cantidad máxima de resultados de consulta que el usuario actual puede almacenar en la [caché de consultas](/es/concepts/features/performance/caches/query-cache). 0 significa que no hay límite.
Valores posibles:
* Entero no negativo >= 0.
## query\_cache\_max\_size\_in\_bytes
La cantidad máxima de memoria (en bytes) que el usuario actual puede asignar a la [caché de consultas](/es/concepts/features/performance/caches/query-cache). 0 significa que no hay límite.
Valores posibles:
* Entero mayor o igual que 0.
## query\_cache\_min\_query\_duration
Duración mínima, en milisegundos, que debe tener una consulta para que su resultado se almacene en la [caché de consultas](/es/concepts/features/performance/caches/query-cache).
Posibles valores:
* Entero positivo >= 0.
## query\_cache\_min\_query\_runs
Número mínimo de veces que debe ejecutarse una consulta `SELECT` antes de que su resultado se almacene en la [caché de consultas](/es/concepts/features/performance/caches/query-cache).
Posibles valores:
* Entero mayor o igual que 0.
## query\_cache\_nondeterministic\_function\_handling
Controla cómo la [caché de consultas](/es/concepts/features/performance/caches/query-cache) gestiona las consultas `SELECT` con funciones no deterministas como `rand()` o `now()`.
Valores posibles:
* `'throw'` - Lanza una excepción y no almacena en caché el resultado de la consulta.
* `'save'` - Almacena en caché el resultado de la consulta.
* `'ignore'` - No almacena en caché el resultado de la consulta y no lanza ninguna excepción.
## query\_cache\_share\_between\_users
Si está activado, el resultado de las consultas `SELECT` almacenado en la [query cache](/es/concepts/features/performance/caches/query-cache) puede ser leído por otros usuarios.
No se recomienda habilitar esta configuración por motivos de seguridad.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## query\_cache\_squash\_partial\_results
Combina los bloques de resultados parciales en bloques del tamaño de [max\_block\_size](#max_block_size). Reduce el rendimiento de las inserciones en la [query cache](/es/concepts/features/performance/caches/query-cache), pero mejora la capacidad de compresión de las entradas de caché (consulta [query\_cache\_compress-entries](#query_cache_compress_entries)).
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## query\_cache\_system\_table\_handling
Controla cómo la [caché de consultas](/es/concepts/features/performance/caches/query-cache) gestiona las consultas `SELECT` realizadas sobre tablas del sistema, es decir, tablas de las bases de datos `system.*` e `information_schema.*`.
Valores posibles:
* `'throw'` - Lanza una excepción y no almacena el resultado de la consulta en caché.
* `'save'` - Almacena el resultado de la consulta en caché.
* `'ignore'` - No almacena el resultado de la consulta en caché ni lanza una excepción.
## query\_cache\_tag
Una cadena que actúa como etiqueta para las entradas de la [caché de consultas](/es/concepts/features/performance/caches/query-cache).
La caché de consultas considera distintas las mismas consultas con etiquetas diferentes.
Valores posibles:
* Cualquier cadena
## query\_cache\_ttl
Transcurrido este tiempo, en segundos, las entradas de la [caché de consultas](/es/concepts/features/performance/caches/query-cache) caducan.
Valores posibles:
* Número entero positivo >= 0.
## query\_metric\_log\_interval
El intervalo, en milisegundos, en el que se recopila [query\_metric\_log](/es/reference/system-tables/query_metric_log) para cada consulta.
Si se establece en cualquier valor negativo, tomará el valor `collect_interval_milliseconds` de la [configuración de query\_metric\_log](/es/reference/settings/server-settings/settings#query_metric_log) o, si no está presente, usará 1000 de forma predeterminada.
Para deshabilitar la recopilación de una sola consulta, establezca `query_metric_log_interval` en 0.
Valor predeterminado: -1
## query\_plan\_aggregation\_in\_order
Activa la optimización de agregación en orden a nivel del plan de consulta.
Solo surte efecto si la configuración [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para depuración. La configuración puede cambiar en el futuro de forma incompatible con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Desactivar
* 1 - Activar
## query\_plan\_convert\_any\_join\_to\_semi\_or\_anti\_join
Permite convertir ANY JOIN en SEMI o ANTI JOIN si el filtro posterior a JOIN siempre se evalúa como falso para las filas con coincidencia o sin coincidencia
## query\_plan\_convert\_join\_to\_in
Permite convertir `JOIN` en una subconsulta con `IN` si las columnas de salida están asociadas únicamente a la tabla izquierda. Puede producir resultados incorrectos con `JOIN` que no sean `ANY` (p. ej., `ALL JOIN`, que es el valor predeterminado).
## query\_plan\_convert\_outer\_join\_to\_inner\_join
Permite convertir `OUTER JOIN` en `INNER JOIN` si el filtro después de `JOIN` siempre descarta los valores por defecto
## query\_plan\_direct\_read\_from\_text\_index
Permite aplicar el filtrado de búsqueda de texto completo usando únicamente el índice de texto invertido en el plan de consulta.
## query\_plan\_display\_internal\_aliases
Muestra los alias internos (como \_\_table1) en EXPLAIN PLAN en lugar de los especificados en la consulta original.
## query\_plan\_enable\_multithreading\_after\_window\_functions
Habilita el procesamiento multihilo después de evaluar las funciones de ventana para permitir el procesamiento de flujo en paralelo
## query\_plan\_enable\_optimizations
Activa o desactiva la optimización de consultas a nivel del plan de consulta.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para tareas de depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Desactiva todas las optimizaciones a nivel del plan de consulta
* 1 - Activa las optimizaciones a nivel del plan de consulta (pero las optimizaciones individuales aún pueden desactivarse mediante sus configuraciones específicas)
## query\_plan\_execute\_functions\_after\_sorting
Activa o desactiva una optimización a nivel del plan de consulta que desplaza las expresiones para que se ejecuten después de los pasos de ordenación.
Solo surte efecto si la configuración [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para tareas de depuración. La configuración puede cambiar en el futuro de maneras incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_filter\_push\_down
Activa o desactiva una optimización a nivel del plan de consulta que empuja los filtros hacia abajo en el plan de ejecución.
Solo surte efecto si la configuración [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para tareas de depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Desactivar
* 1 - Activar
## query\_plan\_join\_shard\_by\_pk\_ranges
Aplica sharding a JOIN si las claves de JOIN contienen un prefijo de PRIMARY KEY en ambas tablas. Compatible con los algoritmos hash, parallel\_hash y full\_sorting\_merge. Normalmente no acelera las consultas, pero puede reducir el consumo de memoria.
## query\_plan\_join\_swap\_table
Determina qué lado del join debe ser la tabla de construcción (también llamada interna, la que se inserta en la tabla hash para un hash join) en el plan de consulta. Esta configuración solo es compatible con la strictness `ALL` de `JOIN` con la cláusula `JOIN ON`. Los valores posibles son:
* 'auto': Deja que el planificador decida qué tabla usar como tabla de construcción.
* 'false': No intercambiar nunca las tablas (la tabla derecha es la tabla de construcción).
* 'true': Intercambiar siempre las tablas (la tabla izquierda es la tabla de construcción).
## query\_plan\_lift\_up\_array\_join
Activa o desactiva una optimización a nivel del plan de consulta que mueve los ARRAY JOIN a una posición superior en el plan de ejecución.
Solo tiene efecto si el ajuste [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_lift\_up\_union
Activa o desactiva una optimización a nivel del plan de consulta que mueve subárboles más grandes del plan de consulta a union para permitir optimizaciones adicionales.
Solo surte efecto si el ajuste [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Este es un ajuste para expertos que los desarrolladores solo deben usar para depuración. El ajuste puede cambiar en el futuro de maneras incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_max\_limit\_for\_lazy\_materialization
Controla el valor límite máximo que permite usar el plan de consulta para la optimización de materialización diferida. Si es cero, no hay límite.
## query\_plan\_max\_limit\_for\_top\_k\_optimization
Controla el valor máximo del límite que permite evaluar el plan de consulta para la optimización TopK usando el índice de omisión minmax y el filtrado dinámico por umbral. Si es cero, no hay límite.
## query\_plan\_max\_optimizations\_to\_apply
Limita el número total de optimizaciones aplicadas al plan de consulta; consulte la configuración [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations).
Es útil para evitar tiempos de optimización excesivos en consultas complejas.
En la consulta EXPLAIN PLAN, se dejan de aplicar optimizaciones una vez alcanzado este límite y se devuelve el plan tal cual.
En la ejecución normal de consultas, si el número real de optimizaciones supera esta configuración, se lanza una excepción.
Esta es una configuración de nivel experto que solo deberían usar los desarrolladores para tareas de depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
## query\_plan\_max\_step\_description\_length
Longitud máxima de la descripción del paso en EXPLAIN PLAN.
## query\_plan\_merge\_expressions
Activa o desactiva una optimización a nivel del plan de consulta que fusiona filtros consecutivos.
Solo surte efecto si la configuración [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que los desarrolladores solo deben usar para tareas de depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_merge\_filter\_into\_join\_condition
Permite integrar el filtro en la condición de `JOIN` y convertir `CROSS JOIN` en `INNER`.
## query\_plan\_merge\_filters
Permite combinar filtros en el plan de consulta.
## query\_plan\_optimize\_join\_order\_algorithm
Especifica qué algoritmos de orden de JOIN se intentan durante la optimización del plan de consulta. Están disponibles los siguientes algoritmos:
* 'greedy' - algoritmo voraz básico - funciona rápido, pero puede que no produzca el mejor orden de JOIN
* 'dpsize' - implementa el algoritmo DPsize, actualmente solo para Inner joins - considera todos los órdenes de JOIN posibles y encuentra el más óptimo, pero puede ser lento para consultas con muchas tablas y predicados de JOIN.
Se pueden especificar varios algoritmos, por ejemplo, 'dpsize,greedy'.
## query\_plan\_optimize\_join\_order\_limit
Optimiza el orden de los JOIN dentro de la misma subconsulta. Actualmente, solo se admite en casos muy limitados.
El valor es el número máximo de tablas que se pueden optimizar.
## query\_plan\_optimize\_join\_order\_randomize
Cuando es distinto de cero, el optimizador del orden de join utiliza cardinalidades y NDV generados aleatoriamente en lugar de estadísticas reales.
Cuando se establece en 1, se genera una semilla aleatoria; cuando se establece en un valor > 1, ese valor se usa directamente como semilla.
Su propósito es realizar pruebas para detectar errores provocados por distintos órdenes de join.
## query\_plan\_optimize\_lazy\_final
Optimiza la lectura con FINAL en ReplacingMergeTree creando un conjunto de claves primarias y utilizándolo para el análisis de índices.
## query\_plan\_optimize\_lazy\_materialization
Utiliza el plan de consulta en la optimización de la materialización diferida.
## query\_plan\_optimize\_prewhere
Permite trasladar el filtro a la expresión PREWHERE en los storages compatibles
## query\_plan\_push\_down\_limit
Activa o desactiva una optimización a nivel del plan de consulta que desplaza las cláusulas LIMIT a niveles inferiores del plan de ejecución.
Solo tiene efecto si el ajuste [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Este es un ajuste de nivel experto que solo deberían usar los desarrolladores para depuración. El ajuste puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_read\_in\_order
Activa o desactiva la optimización de lectura en orden a nivel del plan de consulta.
Solo surte efecto si el ajuste [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Este es un ajuste de nivel experto que solo deben usar los desarrolladores para tareas de depuración. El ajuste puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Desactivar
* 1 - Activar
## query\_plan\_read\_in\_order\_through\_join
Mantiene la lectura en orden desde la tabla izquierda en las operaciones JOIN, lo que pueden aprovechar los pasos posteriores.
## query\_plan\_remove\_redundant\_distinct
Activa o desactiva una optimización a nivel del plan de consulta que elimina pasos DISTINCT redundantes.
Solo surte efecto si la configuración [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deberían usar los desarrolladores para tareas de depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_remove\_redundant\_sorting
Activa o desactiva una optimización a nivel del plan de consulta que elimina pasos de ordenación redundantes, por ejemplo, en subconsultas.
Solo surte efecto si la configuración [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para tareas de depuración. Esta configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_remove\_unused\_columns
Activa o desactiva una optimización a nivel del plan de consulta que intenta eliminar las columnas no utilizadas (tanto de entrada como de salida) de los pasos del plan de consulta.
Solo tiene efecto si la configuración [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que solo deben usar los desarrolladores para tareas de depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## query\_plan\_reuse\_storage\_ordering\_for\_window\_functions
**Alias**: `optimize_read_in_window_order`
Activa o desactiva una optimización a nivel del plan de consulta que utiliza el ordenamiento del almacenamiento al ordenar para funciones de ventana.
Solo tiene efecto si el ajuste [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Este es un ajuste de nivel experto que solo deben usar los desarrolladores para depuración. El ajuste puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Desactivar
* 1 - Activar
## query\_plan\_split\_filter
Esta es una configuración de nivel experto que solo los desarrolladores deberían usar para tareas de depuración. La configuración puede cambiar en el futuro de formas no compatibles con versiones anteriores o eliminarse.
Activa o desactiva una optimización a nivel del plan de consulta que divide los filtros en expresiones.
Solo surte efecto si la configuración [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Posibles valores:
* 0 - Deshabilitar
* 1 - Habilitar
## query\_plan\_text\_index\_add\_hint
Permite añadir una sugerencia (un predicado adicional) al filtrado generado a partir del índice de texto invertido en el plan de consulta.
## query\_plan\_top\_k\_through\_join
Activa una optimización a nivel del plan de consulta que desplaza `ORDER BY ... LIMIT n` por debajo de un join cuando la clave de ordenación solo hace referencia a columnas del lado preservado por el join (LEFT/RIGHT). Restringe cuántas filas debe producir la entrada del lado preservado antes de hacer el join.
Solo tiene efecto si la configuración [query\_plan\_enable\_optimizations](#query_plan_enable_optimizations) es 1.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## query\_plan\_try\_use\_vector\_search
Activa o desactiva una optimización a nivel del plan de consulta que intenta utilizar el índice de similitud vectorial.
Solo tiene efecto si la configuración [`query_plan_enable_optimizations`](#query_plan_enable_optimizations) es 1.
Esta es una configuración de nivel experto que los desarrolladores solo deberían usar para depuración. La configuración puede cambiar en el futuro de formas incompatibles con versiones anteriores o eliminarse.
Valores posibles:
* 0 - Desactivar
* 1 - Activar
## query\_profiler\_cpu\_time\_period\_ns
Establece el período de un temporizador del reloj de la CPU del [perfilador de consultas](/es/concepts/features/performance/troubleshoot/sampling-query-profiler). Este temporizador cuenta solo el tiempo de CPU.
Valores posibles:
* Un número entero positivo de nanosegundos.
Valores recomendados:
* 10000000 (100 veces por segundo) nanosegundos o más para consultas individuales.
* 1000000000 (una vez por segundo) para el perfilado en todo el clúster.
* 0 para desactivar el temporizador.
Véase también:
* Tabla del sistema [trace\_log](/es/reference/system-tables/trace_log)
## query\_profiler\_real\_time\_period\_ns
Establece el período de un temporizador de reloj real del [perfilador de consultas](/es/concepts/features/performance/troubleshoot/sampling-query-profiler). El temporizador de reloj real mide el tiempo real transcurrido.
Posibles valores:
* Número entero positivo, en nanosegundos.
Valores recomendados:
* 10000000 (100 veces por segundo) nanosegundos o menos para consultas individuales.
* 1000000000 (una vez por segundo) para el perfilado de todo el clúster.
* 0 para desactivar el temporizador.
Véase también:
* Tabla del sistema [trace\_log](/es/reference/system-tables/trace_log)
Valor predeterminado de Cloud: `3000000000`.
## queue\_max\_wait\_ms
El tiempo de espera en la cola de solicitudes si el número de solicitudes concurrentes supera el máximo.
## rabbitmq\_max\_wait\_ms
El tiempo de espera para leer desde RabbitMQ antes de volver a intentarlo.
## read\_backoff\_max\_throughput
Ajuste para reducir el número de hilos en caso de lecturas lentas. Cuenta eventos cuando el ancho de banda de lectura es inferior a esa cantidad de bytes por segundo.
## read\_backoff\_min\_concurrency
Configuración para intentar mantener el número mínimo de hilos en caso de lecturas lentas.
## read\_backoff\_min\_events
Configuración para reducir la cantidad de hilos en caso de lecturas lentas. La cantidad de eventos tras la cual se reducirá la cantidad de hilos.
## read\_backoff\_min\_interval\_between\_events\_ms
Configuración para reducir el número de hilos en caso de lecturas lentas. Ignore el evento si desde el anterior ha transcurrido menos de un determinado intervalo de tiempo.
## read\_backoff\_min\_latency\_ms
Configuración para reducir el número de hilos en caso de lecturas lentas. Solo se tienen en cuenta las lecturas que hayan tardado al menos ese tiempo.
## read\_from\_distributed\_cache\_if\_exists\_otherwise\_bypass\_cache
Solo tiene efecto en ClickHouse Cloud. Es igual que read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache, pero para la caché distribuida.
## read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache
Permite usar la caché del sistema de archivos en modo pasivo: aprovechar las entradas de caché existentes, pero sin añadir más entradas a la caché. Si establece esta configuración para consultas ad hoc pesadas y la deja deshabilitada para consultas cortas en tiempo real, podrá evitar que las consultas demasiado pesadas saturen la caché y mejorar la eficiencia general del sistema.
## read\_from\_page\_cache\_if\_exists\_otherwise\_bypass\_cache
Usa la caché de páginas en espacio de usuario en modo pasivo, de forma similar a read\_from\_filesystem\_cache\_if\_exists\_otherwise\_bypass\_cache.
## read\_in\_order\_two\_level\_merge\_threshold
Número mínimo de partes que se deben leer para ejecutar el paso de fusión preliminar durante la lectura multihilo en el orden de la clave primaria.
## read\_in\_order\_use\_buffering
Usa el búfer antes de la fusión al leer en orden de clave primaria. Aumenta el paralelismo de la ejecución de consultas
## read\_in\_order\_use\_virtual\_row
Usa una fila virtual al leer siguiendo el orden de la clave primaria o de su función monótona. Es útil al buscar entre múltiples partes, ya que solo se accede a las relevantes.
## read\_in\_order\_use\_virtual\_row\_per\_block
Cuando se habilita junto con `read_in_order_use_virtual_row`, emite una fila virtual después de leer cada bloque (no solo al principio de cada parte).
Esto permite que `MergingSortedTransform` repriorice las fuentes con más frecuencia, lo que resulta útil cuando los filtros posteriores descartan muchas filas y los datos se distribuyen de forma desigual entre las partes.
Ten en cuenta que deshabilita la optimización `read_in_order_use_buffering` y la fusión preliminar (`read_in_order_two_level_merge_threshold`) para la lectura.
## read\_overflow\_mode
Qué hacer si se supera el límite.
## read\_overflow\_mode\_leaf
Establece lo que ocurre cuando el volumen de datos leídos supera uno de los límites de hoja.
Opciones posibles:
* `throw`: lanzar una excepción (predeterminado).
* `break`: detener la ejecución de la consulta y devolver el resultado parcial.
## read\_priority
Prioridad para la lectura de datos desde el sistema de archivos local o remoto. Solo es compatible con el método 'pread\_threadpool' para el sistema de archivos local y con el método `threadpool` para el sistema de archivos remoto.
## read\_through\_distributed\_cache
Solo tiene efecto en ClickHouse Cloud. Permite leer desde la caché distribuida
## readonly
0: sin restricciones de solo lectura. 1: solo solicitudes de lectura, así como cambios en configuraciones permitidas explícitamente. 2: solo solicitudes de lectura, así como cambios en las configuraciones, excepto en la configuración 'readonly'.
## receive\_data\_timeout\_ms
Tiempo de espera de la conexión para recibir el primer paquete de datos o un paquete con progreso positivo desde una réplica
## receive\_timeout
Tiempo de espera para recibir datos de la red, en segundos. Si no se recibe ningún byte durante este intervalo, se lanza una excepción. Si establece esta configuración en el cliente, también se configurará `send_timeout` para el `socket` en el extremo correspondiente de la conexión en el servidor.
## recursive\_cte\_max\_steps\_in\_type\_inference
Número máximo de iteraciones para inferir tipos de columna en CTE recursivas. Los tipos de columna se determinan aplicando `getLeastSupertype` de forma iterativa a las partes no recursiva y recursiva de UNION ALL hasta alcanzar la convergencia. Establézcalo en 0 para desactivar el ensanchamiento de tipos y usar solo los tipos de la parte no recursiva.
## regexp\_dict\_allow\_hyperscan
Permite que el diccionario regexp\_tree use la biblioteca Hyperscan.
## regexp\_dict\_flag\_case\_insensitive
Usa coincidencias sin distinción entre mayúsculas y minúsculas para un diccionario regexp\_tree. Se puede sobrescribir en expresiones individuales con (?i) y (?-i).
## regexp\_dict\_flag\_dotall
Permite que '.' coincida con caracteres de salto de línea en un diccionario regexp\_tree.
## regexp\_max\_matches\_per\_row
Establece el número máximo de coincidencias de una sola expresión regular por fila. Úselo para protegerse frente a la sobrecarga de memoria al usar una expresión regular codiciosa en la función [extractAllGroupsHorizontal](/es/reference/functions/regular-functions/string-search-functions#extractAllGroupsHorizontal).
Valores posibles:
* Entero positivo.
## reject\_expensive\_hyperscan\_regexps
Rechaza los patrones cuya evaluación con hyperscan probablemente sea costosa (debido a la explosión de estados del NFA)
## remerge\_sort\_lowered\_memory\_bytes\_ratio
Si el uso de memoria después de la recombinación no se reduce en esta proporción, la recombinación se deshabilitará.
## remote\_filesystem\_read\_method
Método para leer datos desde el sistema de archivos remoto; puede ser uno de los siguientes: read, threadpool.
## remote\_filesystem\_read\_prefetch
Debe usar prefetching al leer datos de un sistema de archivos remoto.
## remote\_fs\_read\_backoff\_max\_tries
Número máximo de reintentos de lectura con backoff
## remote\_fs\_read\_max\_backoff\_ms
Tiempo máximo de espera al intentar leer datos de un disco remoto
## remote\_read\_min\_bytes\_for\_seek
Cantidad mínima de bytes necesaria para que una lectura remota (url, s3) realice `seek`, en lugar de leer con `ignore`.
## rename\_files\_after\_processing
* **Tipo:** String
* **Valor predeterminado:** Cadena vacía
Esta configuración permite especificar un patrón de cambio de nombre para los archivos procesados por la función de tabla `file`. Cuando esta opción está configurada, todos los archivos leídos por la función de tabla `file` se renombrarán según el patrón especificado con marcadores de posición, solo si el procesamiento de los archivos se completó correctamente.
### Marcadores de posición
* `%a` — Nombre completo del archivo original (p. ej., "sample.csv").
* `%f` — Nombre del archivo original sin la extensión (p. ej., "sample").
* `%e` — Extensión del archivo original con el punto (p. ej., ".csv").
* `%t` — Marca de tiempo (en microsegundos).
* `%%` — Signo de porcentaje ("%").
### Ejemplo
* Opción: `--rename_files_after_processing="processed_%f_%t%e"`
* Consulta: `SELECT * FROM file('sample.csv')`
Si la lectura de `sample.csv` se realiza correctamente, el archivo pasará a llamarse `processed_sample_1683473210851438.csv`
## replace\_running\_query
Al usar la interfaz HTTP, se puede pasar el parámetro 'query\_id'. Puede ser cualquier cadena que sirva como identificador de la consulta.
Si en ese momento ya existe una consulta del mismo usuario con el mismo 'query\_id', el comportamiento depende del parámetro 'replace\_running\_query'.
`0` (predeterminado) – Lanzar una excepción (no permitir que la consulta se ejecute si ya hay una consulta con el mismo 'query\_id' en ejecución).
`1` – Cancelar la consulta anterior y empezar a ejecutar la nueva.
Establezca este parámetro en 1 para implementar sugerencias para condiciones de segmentación. Después de introducir el siguiente carácter, si la consulta anterior aún no ha terminado, debe cancelarse.
## replace\_running\_query\_max\_wait\_ms
El tiempo de espera para que finalice la consulta en ejecución con el mismo `query_id` cuando la configuración [replace\_running\_query](#replace_running_query) está activa.
Valores posibles:
* Entero positivo.
* 0 — Lanza una excepción y no permite ejecutar una nueva consulta si el servidor ya está ejecutando una consulta con el mismo `query_id`.
## replication\_wait\_for\_inactive\_replica\_timeout
Especifica cuánto tiempo (en segundos) se debe esperar para que las réplicas inactivas ejecuten consultas [`ALTER`](/es/reference/statements/alter), [`OPTIMIZE`](/es/reference/statements/optimize) o [`TRUNCATE`](/es/reference/statements/truncate).
Posibles valores:
* `0` — No esperar.
* Entero negativo — Esperar indefinidamente.
* Entero positivo — Número de segundos que se debe esperar.
## restore\_replace\_external\_dictionary\_source\_to\_null
Reemplaza las fuentes externas de diccionario por Null al restaurar. Útil para pruebas
## restore\_replace\_external\_engines\_to\_null
Con fines de prueba. Sustituye todos los motores externos por Null para evitar iniciar conexiones externas.
## restore\_replace\_external\_table\_functions\_to\_null
Con fines de prueba. Sustituye todas las funciones de tabla externas por Null para no iniciar conexiones externas.
## restore\_replicated\_merge\_tree\_to\_shared\_merge\_tree
Reemplaza el motor de tabla Replicated*MergeTree por Shared*MergeTree durante RESTORE.
Valor predeterminado de Cloud: `1`.
## result\_overflow\_mode
Valor predeterminado en Cloud: `throw`
Define qué hacer si el volumen del resultado supera uno de los límites.
Valores posibles:
* `throw`: lanzar una excepción (predeterminado).
* `break`: detener la ejecución de la consulta y devolver el resultado parcial, como si los
datos de origen se hubieran agotado.
Usar 'break' es similar a usar LIMIT. `Break` interrumpe la ejecución solo a nivel de
bloque. Esto significa que la cantidad de filas devueltas será mayor que
[`max_result_rows`](/es/reference/settings/session-settings#max_result_rows), será un múltiplo de [`max_block_size`](/es/reference/settings/session-settings#max_block_size)
y dependerá de [`max_threads`](/es/reference/settings/session-settings#max_threads).
**Ejemplo**
```sql title="Query" theme={null}
SET max_threads = 3, max_block_size = 3333;
SET max_result_rows = 3334, result_overflow_mode = 'break';
SELECT *
FROM numbers_mt(100000)
FORMAT Null;
```
```text title="Result" theme={null}
6666 rows in set. ...
```
## rewrite\_count\_distinct\_if\_with\_count\_distinct\_implementation
Permite reescribir `countDistcintIf` mediante la configuración [count\_distinct\_implementation](#count_distinct_implementation).
Posibles valores:
* true — Se permite.
* false — No se permite.
## rewrite\_in\_to\_join
Reescribe expresiones como 'x IN subquery' como JOIN. Esto puede ser útil para optimizar toda la consulta mediante la reordenación de JOIN.
## rows\_before\_aggregation
Si está habilitado, ClickHouse proporcionará el valor exacto de la estadística rows\_before\_aggregation; representa el número de filas leídas antes de la agregación
## s3\_allow\_multipart\_copy
Permite la copia multiparte en S3.
## s3\_allow\_parallel\_part\_upload
Usa varios hilos para la carga multiparte en S3. Esto puede provocar un uso de memoria ligeramente mayor
## s3\_check\_objects\_after\_upload
Comprueba cada objeto cargado en S3 con una solicitud HEAD para asegurarse de que la carga se haya completado correctamente
## s3\_connect\_timeout\_ms
Tiempo de espera de conexión al host de los discos S3.
## s3\_create\_new\_file\_on\_insert
Habilita o deshabilita la creación de un archivo nuevo en cada inserción en tablas del motor S3. Si está habilitado, en cada inserción se creará un nuevo objeto de S3 con la clave, siguiendo un patrón similar a este:
inicial: `data.Parquet.gz` -> `data.1.Parquet.gz` -> `data.2.Parquet.gz`, etc.
Valores posibles:
* 0 — la consulta `INSERT` crea un archivo nuevo o falla si el archivo ya existe y `s3_truncate_on_insert` no está establecido.
* 1 — la consulta `INSERT` crea un archivo nuevo en cada inserción usando un sufijo (a partir del segundo) si `s3_truncate_on_insert` no está establecido.
Consulta más detalles [aquí](/es/integrations/connectors/data-ingestion/AWS/integrating-s3-with-clickhouse#inserting-data).
## s3\_disable\_checksum
No calcule una suma de comprobación al enviar un archivo a S3. Esto acelera las escrituras al evitar pasadas de procesamiento excesivas sobre el archivo. En general, es seguro, ya que los datos de las tablas MergeTree de todos modos llevan sumas de comprobación en ClickHouse y, cuando se accede a S3 mediante HTTPS, la capa TLS ya proporciona integridad durante la transferencia por la red. Aun así, las sumas de comprobación adicionales en S3 aportan una defensa en profundidad.
## s3\_ignore\_file\_doesnt\_exist
Ignora la ausencia de un archivo si no existe al leer ciertas claves.
Valores posibles:
* 1 — `SELECT` devuelve un resultado vacío.
* 0 — `SELECT` lanza una excepción.
## s3\_list\_object\_keys\_size
Número máximo de archivos que puede devolver por lote la solicitud ListObject
## s3\_max\_connections
El número máximo de conexiones por servidor.
## s3\_max\_get\_burst
Número máximo de solicitudes que se pueden emitir simultáneamente antes de alcanzar el límite de solicitudes por segundo. De forma predeterminada (0), equivale a `s3_max_get_rps`
## s3\_max\_get\_rps
Límite de solicitudes GET por segundo a S3 antes de aplicar throttling. Cero significa sin límite.
## s3\_max\_inflight\_parts\_for\_one\_file
El número máximo de partes cargadas simultáneamente en una solicitud de carga multiparte. 0 significa ilimitado.
## s3\_max\_part\_number
Número máximo de parte para la carga de partes en S3.
## s3\_max\_put\_burst
Número máximo de solicitudes que pueden emitirse simultáneamente antes de alcanzar el límite de solicitudes por segundo. De forma predeterminada, (0) es igual a `s3_max_put_rps`
## s3\_max\_put\_rps
Límite de solicitudes PUT a S3 por segundo antes de aplicar throttling. Cero significa sin límite.
## s3\_max\_single\_operation\_copy\_size
Tamaño máximo para una única operación de copia en S3. Esta configuración solo se utiliza si s3\_allow\_multipart\_copy es true.
## s3\_max\_single\_part\_upload\_size
El tamaño máximo del objeto que se puede subir a S3 mediante una carga de una sola parte.
## s3\_max\_single\_read\_retries
El número máximo de reintentos durante una lectura única de S3.
## s3\_max\_unexpected\_write\_error\_retries
El número máximo de reintentos en caso de errores inesperados durante la escritura en S3.
## s3\_max\_upload\_part\_size
El tamaño máximo de cada parte durante una subida multiparte a S3.
## s3\_min\_upload\_part\_size
El tamaño mínimo de la parte que se va a subir durante una carga multiparte a S3.
## s3\_path\_filter\_limit
Número máximo de valores de `_path` que pueden extraerse de los filtros de la consulta para utilizarlos en la iteración de archivos
en lugar del listado con glob. 0 significa deshabilitado.
## s3\_request\_timeout\_ms
Tiempo de espera por inactividad para enviar y recibir datos hacia/desde S3. Se produce un error si una única llamada TCP de lectura o escritura queda bloqueada durante este tiempo.
## s3\_skip\_empty\_files
Activa o desactiva la omisión de archivos vacíos en las tablas del motor [S3](/es/reference/engines/table-engines/integrations/s3).
Valores posibles:
* 0 — `SELECT` lanza una excepción si el archivo vacío no es compatible con el formato solicitado.
* 1 — `SELECT` devuelve un resultado vacío para un archivo vacío.
## s3\_slow\_all\_threads\_after\_network\_error
Cuando se establece en `true`, todos los hilos que ejecutan solicitudes a S3 hacia el mismo endpoint de copia de seguridad se ralentizan
después de que una sola solicitud a S3 encuentre un error de red que permita reintento, como un timeout de socket.
Cuando se establece en `false`, cada hilo gestiona el backoff de las solicitudes a S3 de forma independiente de los demás.
## s3\_strict\_upload\_part\_size
El tamaño exacto de la parte que se va a subir durante la subida multiparte a S3 (algunas implementaciones no admiten partes de tamaño variable).
## s3\_throw\_on\_zero\_files\_match
Genera un error cuando la solicitud `ListObjects` no encuentra ningún archivo
## s3\_truncate\_on\_insert
Activa o desactiva el truncado antes de las inserciones en tablas con el motor S3. Si está desactivado, se lanzará una excepción al intentar insertar si ya existe un objeto en S3.
Valores posibles:
* 0 — la consulta `INSERT` crea un archivo nuevo o falla si el archivo ya existe y no se ha establecido s3\_create\_new\_file\_on\_insert.
* 1 — la consulta `INSERT` reemplaza el contenido existente del archivo con los datos nuevos.
Consulta más detalles [aquí](/es/integrations/connectors/data-ingestion/AWS/integrating-s3-with-clickhouse#inserting-data).
## s3\_upload\_part\_size\_multiply\_factor
Multiplica s3\_min\_upload\_part\_size por este factor cada vez que se hayan subido s3\_multiply\_parts\_count\_threshold partes en una sola escritura en S3.
## s3\_upload\_part\_size\_multiply\_parts\_count\_threshold
Cada vez que se haya subido este número de partes a S3, `s3_min_upload_part_size` se multiplica por `s3_upload_part_size_multiply_factor`.
## s3\_uri\_style
Obliga a usar el estilo de endpoint de S3. Valores posibles: auto, virtual\_hosted, path.
## s3\_use\_adaptive\_timeouts
Cuando se establece en `true`, en todas las solicitudes a S3 los dos primeros intentos se realizan con tiempos de espera de envío y recepción reducidos.
Cuando se establece en `false`, todos los intentos se realizan con los mismos tiempos de espera.
## s3\_validate\_request\_settings
Habilita la validación de la configuración de solicitudes de S3.
Valores posibles:
* 1 — validar la configuración.
* 0 — no validar la configuración.
## s3queue\_default\_zookeeper\_path
Prefijo de ruta de ZooKeeper predeterminado para el motor S3Queue
## s3queue\_enable\_logging\_to\_s3queue\_log
Habilita la escritura en system.s3queue\_log. El valor puede sobrescribirse para cada tabla mediante la configuración de la tabla
## s3queue\_keeper\_fault\_injection\_probability
Probabilidad de inyección de fallos en Keeper para S3Queue.
## s3queue\_migrate\_old\_metadata\_to\_buckets
Migra la estructura antigua de metadatos de la tabla S3Queue a una nueva estructura
## schema\_inference\_cache\_require\_modification\_time\_for\_url
Usa el esquema de la caché para URL con validación de la hora de la última modificación (para URL con el encabezado Last-Modified)
## schema\_inference\_use\_cache\_for\_azure
Usa la caché durante la inferencia de esquemas al usar la función de tabla de Azure
## schema\_inference\_use\_cache\_for\_file
Usa caché en la inferencia de esquemas al utilizar la función de tabla File
## schema\_inference\_use\_cache\_for\_hdfs
Usa la caché en la inferencia de esquemas al utilizar la función de tabla hdfs
## schema\_inference\_use\_cache\_for\_s3
Usa la caché durante la inferencia de esquema al usar la función de tabla S3
## schema\_inference\_use\_cache\_for\_url
Utiliza la caché en la inferencia de esquemas al usar la función de tabla url
## secondary\_indices\_enable\_bulk\_filtering
Habilita el algoritmo de filtrado masivo para índices. Se espera que siempre sea mejor, pero mantenemos esta configuración por compatibilidad y control.
## select\_sequential\_consistency
Esta configuración se comporta de forma distinta en SharedMergeTree y ReplicatedMergeTree; consulta [SharedMergeTree consistency](/es/products/cloud/features/infrastructure/shared-merge-tree#consistency) para obtener más información sobre el comportamiento de `select_sequential_consistency` en SharedMergeTree.
Habilita o deshabilita la consistencia secuencial para las consultas `SELECT`. Requiere que `insert_quorum_parallel` esté deshabilitado (está habilitado de forma predeterminada).
Posibles valores:
* 0 — Deshabilitado.
* 1 — Habilitado.
Uso
Cuando la consistencia secuencial está habilitada, ClickHouse permite al cliente ejecutar la consulta `SELECT` solo en aquellas réplicas que contienen los datos de todas las consultas `INSERT` anteriores ejecutadas con `insert_quorum`. Si el cliente apunta a una réplica parcial, ClickHouse generará una excepción. La consulta `SELECT` no incluirá datos que aún no se hayan escrito en el quórum de réplicas.
Cuando `insert_quorum_parallel` está habilitado (valor predeterminado), `select_sequential_consistency` no funciona. Esto se debe a que las consultas paralelas `INSERT` pueden escribirse en distintos conjuntos de réplicas del quórum, por lo que no hay garantía de que una sola réplica haya recibido todas las escrituras.
Vea también:
* [insert\_quorum](#insert_quorum)
* [insert\_quorum\_timeout](#insert_quorum_timeout)
* [insert\_quorum\_parallel](#insert_quorum_parallel)
## send\_logs\_level
Envía los logs de texto del servidor al cliente con el nivel mínimo especificado. Valores válidos: 'trace', 'debug', 'information', 'warning', 'error', 'fatal', 'none'
## send\_logs\_source\_regexp
Envía los logs de texto del servidor cuya fuente coincida con la expresión regular especificada. Si está vacío, se incluyen todas las fuentes.
## send\_profile\_events
Habilita o deshabilita el envío de paquetes de [ProfileEvents](/es/resources/develop-contribute/native-protocol/server#profile-events) al cliente.
Esto se puede deshabilitar para reducir el tráfico de red para los clientes que no requieren eventos de perfil.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
Activa o desactiva las cabeceras de respuesta HTTP `X-ClickHouse-Progress` en las respuestas de `clickhouse-server`.
Para obtener más información, lea la [descripción de la interfaz HTTP](/es/concepts/features/interfaces/http).
Posibles valores:
* 0 — Deshabilitado.
* 1 — Habilitado.
## send\_table\_structure\_on\_insert\_with\_inline\_data
Si está deshabilitada y la consulta INSERT contiene datos incluidos en la propia consulta, el servidor no enviará al cliente la estructura de la tabla ni los valores predeterminados de las columnas a través del protocolo nativo. En su lugar, el servidor analizará por sí mismo esos datos. Esto puede mejorar el rendimiento de muchas inserciones pequeñas a través del protocolo nativo.
## send\_timeout
Tiempo de espera para enviar datos por la red, en segundos. Si un cliente necesita enviar datos pero no puede enviar ningún byte durante este intervalo, se produce una excepción. Si configura este ajuste en el cliente, también se establecerá `receive_timeout` para el socket en el extremo correspondiente de la conexión en el servidor.
## serialize\_query\_plan
Serializa el plan de ejecución de la consulta para el procesamiento distribuido
## serialize\_string\_in\_memory\_with\_zero\_byte
Serializa los valores String durante la agregación con un byte nulo al final. Actívela para mantener la compatibilidad al consultar un clúster con versiones incompatibles.
## session\_timezone
Establece la zona horaria implícita de la sesión o consulta actual.
La zona horaria implícita es la que se aplica a los valores de tipo DateTime/DateTime64 que no tienen una zona horaria especificada explícitamente.
Este ajuste tiene prioridad sobre la zona horaria implícita configurada globalmente (a nivel del servidor).
Un valor de '' (cadena vacía) significa que la zona horaria implícita de la sesión o consulta actual es igual a la [zona horaria del servidor](/es/reference/settings/server-settings/settings#timezone).
Puede usar las funciones `timeZone()` y `serverTimeZone()` para obtener la zona horaria de la sesión y la del servidor.
Valores posibles:
* Cualquier nombre de zona horaria de `system.time_zones`, por ejemplo, `Europe/Berlin`, `UTC` o `Zulu`
Ejemplos:
```sql theme={null}
SELECT timeZone(), serverTimeZone() FORMAT CSV
"Europe/Berlin","Europe/Berlin"
```
```sql theme={null}
SELECT timeZone(), serverTimeZone() SETTINGS session_timezone = 'Asia/Novosibirsk' FORMAT CSV
"Asia/Novosibirsk","Europe/Berlin"
```
Asigne la zona horaria de la sesión 'America/Denver' al `DateTime` interno sin especificar explícitamente una zona horaria:
```sql theme={null}
SELECT toDateTime64(toDateTime64('1999-12-12 23:23:23.123', 3), 3, 'Europe/Zurich') SETTINGS session_timezone = 'America/Denver' FORMAT TSV
1999-12-13 07:23:23.123
```
No todas las funciones que analizan DateTime/DateTime64 respetan `session_timezone`. Esto puede dar lugar a errores sutiles.
Consulte el siguiente ejemplo y su explicación.
```sql theme={null}
CREATE TABLE test_tz (`d` DateTime('UTC')) ENGINE = Memory AS SELECT toDateTime('2000-01-01 00:00:00', 'UTC');
SELECT *, timeZone() FROM test_tz WHERE d = toDateTime('2000-01-01 00:00:00') SETTINGS session_timezone = 'Asia/Novosibirsk'
0 rows in set.
SELECT *, timeZone() FROM test_tz WHERE d = '2000-01-01 00:00:00' SETTINGS session_timezone = 'Asia/Novosibirsk'
┌───────────────────d─┬─timeZone()───────┐
│ 2000-01-01 00:00:00 │ Asia/Novosibirsk │
└─────────────────────┴──────────────────┘
```
Esto sucede debido a distintos procesos de análisis:
* `toDateTime()`, sin una zona horaria especificada explícitamente, usado en la primera consulta `SELECT`, respeta la configuración `session_timezone` y la zona horaria global.
* En la segunda consulta, un DateTime se interpreta a partir de un String y hereda el tipo y la zona horaria de la columna existente `d`. Por lo tanto, no se respetan la configuración `session_timezone` ni la zona horaria global.
**Véase también**
* [timezone](/es/reference/settings/server-settings/settings#timezone)
## set\_overflow\_mode
Establece qué ocurre cuando la cantidad de datos supera uno de los límites.
Valores posibles:
* `throw`: lanzar una excepción (valor predeterminado).
* `break`: detener la ejecución de la consulta y devolver el resultado parcial, como si se hubieran agotado los datos de origen.
## shared\_merge\_tree\_sequential\_consistency\_initial\_parts\_update\_backoff\_ms
Retardo inicial, en milisegundos, para la actualización de partes al usar `select_sequential_consistency` con `SharedMergeTree`. Solo disponible en ClickHouse Cloud.
## shared\_merge\_tree\_sequential\_consistency\_max\_parts\_update\_backoff\_ms
Tiempo máximo de backoff, en milisegundos, para la actualización de partes al usar `select_sequential_consistency` con `SharedMergeTree`. Solo está disponible en ClickHouse Cloud.
## shared\_merge\_tree\_sequential\_consistency\_parts\_update\_max\_retries
Número máximo de reintentos para actualizar las partes al usar `select_sequential_consistency` con `SharedMergeTree`. Solo disponible en ClickHouse Cloud.
## shared\_merge\_tree\_sync\_parts\_on\_partition\_operations
Sincroniza automáticamente el conjunto de partes de datos tras las operaciones de partición MOVE|REPLACE|ATTACH en tablas SMT. Solo en Cloud
## short\_circuit\_function\_evaluation
Permite evaluar las funciones [if](/es/reference/functions/regular-functions/conditional-functions#if), [multiIf](/es/reference/functions/regular-functions/conditional-functions#multiIf), [and](/es/reference/functions/regular-functions/logical-functions#and) y [or](/es/reference/functions/regular-functions/logical-functions#or) mediante [evaluación de cortocircuito](https://en.wikipedia.org/wiki/Short-circuit_evaluation). Esto ayuda a optimizar la ejecución de expresiones complejas en estas funciones y a evitar posibles excepciones (como una división por cero cuando no se esperaba).
Valores posibles:
* `enable` — Habilita la evaluación de cortocircuito para las funciones en las que resulta adecuada (pueden generar una excepción o tener un coste computacional elevado).
* `force_enable` — Habilita la evaluación de cortocircuito para todas las funciones.
* `disable` — Deshabilita la evaluación de cortocircuito.
## short\_circuit\_function\_evaluation\_for\_nulls
Optimiza la evaluación de funciones que devuelven NULL cuando cualquiera de sus argumentos es NULL. Cuando el porcentaje de valores NULL en los argumentos de la función supera el umbral `short_circuit_function_evaluation_for_nulls_threshold`, el sistema omite evaluar la función fila por fila. En su lugar, devuelve NULL de inmediato para todas las filas, evitando cálculos innecesarios.
## short\_circuit\_function\_evaluation\_for\_nulls\_threshold
Umbral de la proporción de valores NULL para ejecutar funciones con argumentos Nullable solo en filas en las que todos los argumentos tienen valores distintos de NULL. Se aplica cuando la configuración short\_circuit\_function\_evaluation\_for\_nulls está habilitada.
Cuando la proporción de filas que contienen valores NULL con respecto al número total de filas supera este umbral, esas filas con valores NULL no se evaluarán.
## show\_data\_lake\_catalogs\_in\_system\_tables
Permite mostrar catálogos de lago de datos en las tablas del sistema.
## show\_processlist\_include\_internal
Muestra los procesos auxiliares internos en la salida de la consulta `SHOW PROCESSLIST`.
Los procesos internos incluyen recargas de diccionarios, recargas de vistas materializadas actualizables, consultas `SELECT` auxiliares ejecutadas en consultas `SHOW ...`, y consultas auxiliares `CREATE DATABASE ...` ejecutadas internamente para gestionar tablas dañadas, entre otros.
## show\_table\_uuid\_in\_table\_create\_query\_if\_not\_nil
Configura cómo se muestra la consulta `SHOW TABLE`.
Valores posibles:
* 0 — La consulta se mostrará sin el UUID de la tabla.
* 1 — La consulta se mostrará con el UUID de la tabla.
## single\_join\_prefer\_left\_table
Para un único JOIN, en caso de ambigüedad entre identificadores, se prefiere la tabla de la izquierda
## skip\_redundant\_aliases\_in\_udf
Los alias redundantes se omiten (se sustituyen) en las funciones definidas por el usuario para simplificar su uso.
Posibles valores:
* 1 — Los alias se omiten (se sustituyen) en las UDF.
* 0 — Los alias no se omiten (se sustituyen) en las UDF.
**Ejemplo**
La diferencia entre tenerlo habilitado o deshabilitado:
Consulta:
```sql theme={null}
SET skip_redundant_aliases_in_udf = 0;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
```
Resultado:
```text theme={null}
SELECT ((4 + 2) + 1 AS y, y + 2)
```
Consulta:
```sql theme={null}
SET skip_redundant_aliases_in_udf = 1;
CREATE FUNCTION IF NOT EXISTS test_03274 AS ( x ) -> ((x + 1 as y, y + 2));
EXPLAIN SYNTAX SELECT test_03274(4 + 2);
```
Resultado:
```text theme={null}
SELECT ((4 + 2) + 1, ((4 + 2) + 1) + 2)
```
## skip\_unavailable\_shards
Habilita o deshabilita la omisión silenciosa de segmentos no disponibles.
Un segmento se considera no disponible si ninguna de sus réplicas está disponible. Una réplica no está disponible en los siguientes casos:
* ClickHouse no puede conectarse a la réplica por cualquier motivo.
Al conectarse a una réplica, ClickHouse realiza varios intentos. Si todos ellos fallan, la réplica se considera no disponible.
* La réplica no puede resolverse mediante DNS.
Si el hostname de la réplica no puede resolverse mediante DNS, esto puede indicar las siguientes situaciones:
* El host de la réplica no tiene un registro DNS. Esto puede ocurrir en sistemas con DNS dinámico, por ejemplo, [Kubernetes](https://kubernetes.io), donde los nodos pueden no resolverse durante una caída, y esto no es un error.
* Error de configuración. El archivo de configuración de ClickHouse contiene un hostname incorrecto.
Valores posibles:
* 1 — omisión habilitada.
Si un segmento no está disponible, ClickHouse devuelve un resultado basado en datos parciales y no informa de problemas de disponibilidad de nodos.
* 0 — omisión deshabilitada.
Si un segmento no está disponible, ClickHouse lanza una excepción.
## sleep\_after\_receiving\_query\_ms
Tiempo de espera después de recibir una consulta en TCPHandler
## sleep\_in\_send\_data\_ms
Tiempo de espera durante el envío de datos en TCPHandler
## sleep\_in\_send\_tables\_status\_ms
Tiempo de espera antes de enviar la respuesta de estado de las tablas en TCPHandler
## sort\_overflow\_mode
Establece qué ocurre si el número de filas recibidas antes de la ordenación supera uno de los límites.
Valores posibles:
* `throw`: lanzar una excepción.
* `break`: detener la ejecución de la consulta y devolver el resultado parcial.
## split\_intersecting\_parts\_ranges\_into\_layers\_final
Divide en capas los rangos de partes superpuestas durante la optimización FINAL
## dividir\_rangos\_de\_partes\_en\_intersectantes\_y\_no\_intersectantes\_final
Dividir los rangos de partes en intersectantes y no intersectantes durante la optimización FINAL
## splitby\_max\_substrings\_includes\_remaining\_string
Controla si la función [splitBy\*()](/es/reference/functions/regular-functions/splitting-merging-functions) con el argumento `max_substrings` > 0 incluirá la cadena restante en el último elemento del array de resultados.
Valores posibles:
* `0` - La cadena restante no se incluirá en el último elemento del array de resultados.
* `1` - La cadena restante se incluirá en el último elemento del array de resultados. Este es el comportamiento de la función [`split()`](https://spark.apache.org/docs/3.1.2/api/python/reference/api/pyspark.sql.functions.split.html) de Spark y del método ['string.split()'](https://docs.python.org/3/library/stdtypes.html#str.split) de Python.
## stop\_refreshable\_materialized\_views\_on\_startup
Al iniciar el servidor, evita la programación de las vistas materializadas actualizables, como si se hubiera ejecutado SYSTEM STOP VIEWS. Después, puede iniciarlas manualmente con `SYSTEM START VIEWS` o `SYSTEM START VIEW `. También se aplica a las vistas recién creadas. No tiene efecto sobre las vistas materializadas no actualizables.
## storage\_file\_read\_method
Método de lectura de datos del archivo de almacenamiento; uno de los siguientes: `read`, `pread`, `mmap`. El método `mmap` no se aplica a clickhouse-server (está destinado a clickhouse-local).
## storage\_system\_stack\_trace\_pipe\_read\_timeout\_ms
Tiempo máximo para leer de una tubería y recibir información de los hilos al consultar la tabla `system.stack_trace`. Esta configuración se utiliza con fines de prueba y no está pensada para que los usuarios la cambien.
## stream\_flush\_interval\_ms
Funciona para tablas con streaming en caso de timeout, o cuando un hilo genera [max\_insert\_block\_size](#max_insert_block_size) filas.
El valor predeterminado es 7500.
Cuanto menor sea el valor, con mayor frecuencia se vacían los datos en la tabla. Establecer un valor demasiado bajo provoca un rendimiento deficiente.
## stream\_like\_engine\_allow\_direct\_select
Permite realizar una consulta SELECT directa en los motores Kafka, RabbitMQ, FileLog, Redis Streams, S3Queue, AzureQueue y NATS. Si hay vistas materializadas asociadas, la consulta SELECT no está permitida aunque esta opción esté habilitada.
Si no hay vistas materializadas asociadas, habilitar esta opción permite leer datos. Ten en cuenta que, por lo general, los datos leídos se eliminan de la cola. Para evitarlo, los ajustes relacionados del motor deben configurarse correctamente.
## stream\_like\_engine\_insert\_queue
Cuando un motor de tipo stream lee de varias colas, el usuario deberá seleccionar una cola en la que insertar al escribir. Se usa en Redis Streams y NATS.
## stream\_poll\_timeout\_ms
Tiempo de espera al consultar datos desde/hacia almacenamientos de streaming.
## system\_events\_show\_zero\_values
Permite seleccionar eventos con valor cero de [`system.events`](/es/reference/system-tables/events).
Algunos sistemas de monitorización requieren que se les envíen todos los valores de las métricas en cada punto de control, incluso cuando el valor de la métrica es cero.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
**Ejemplos**
Consulta
```sql theme={null}
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
```
Resultado
```text theme={null}
Ok.
```
Consulta
```sql theme={null}
SET system_events_show_zero_values = 1;
SELECT * FROM system.events WHERE event='QueryMemoryLimitExceeded';
```
Resultado
```text theme={null}
┌─event────────────────────┬─value─┬─description───────────────────────────────────────────┐
│ QueryMemoryLimitExceeded │ 0 │ Number of times when memory limit exceeded for query. │
└──────────────────────────┴───────┴───────────────────────────────────────────────────────┘
```
## system\_metric\_log\_show\_zero\_values\_in\_histograms
Controla si los datos de histogramas con valor cero se escriben en la columna anidada `histograms` de `system.metric_log`.
De forma predeterminada, se omiten los histogramas cuyo `count` total de observaciones es cero y, dentro de cada histograma emitido, también se omiten del map `histogram` las entradas de bucket sin observaciones. Habilite esta opción para escribir todos los histogramas y todos los buckets independientemente del recuento; es útil para sistemas de monitorización que requieren que cada métrica aparezca en cada punto de control.
Posibles valores:
* 0 — Deshabilitado. Los histogramas con `count = 0` no se emiten; los histogramas emitidos incluyen solo los buckets que recibieron al menos una observación.
* 1 — Habilitado. Se escriben todos los histogramas y cada límite de bucket aparece en `histogram`.
## table\_engine\_read\_through\_distributed\_cache
Solo tiene efecto en ClickHouse Cloud. Permite leer desde la caché distribuida mediante motores de tabla / funciones de tabla (s3, azure, etc.)
## table\_function\_remote\_max\_addresses
Establece el número máximo de direcciones generadas a partir de patrones para la función [remote](/es/reference/functions/table-functions/remote).
Valores posibles:
* Un entero positivo.
## tcp\_keep\_alive\_timeout
El tiempo, en segundos, que la conexión debe permanecer inactiva antes de que TCP comience a enviar sondas keepalive
## temporary\_data\_in\_cache\_reserve\_space\_wait\_lock\_timeout\_milliseconds
Tiempo de espera para bloquear la caché al reservar espacio para datos temporales en la caché del sistema de archivos
## temporary\_files\_buffer\_size
Tamaño del búfer para la escritura de archivos temporales. Un tamaño de búfer mayor implica menos llamadas al sistema, pero un mayor consumo de memoria.
## temporary\_files\_codec
Establece el códec de compresión para los archivos temporales utilizados en operaciones de ordenación y join en disco.
Valores posibles:
* LZ4 — Se aplica compresión [LZ4](https://en.wikipedia.org/wiki/LZ4_\(compression_algorithm\)).
* NONE — No se aplica compresión.
## text\_index\_hint\_max\_selectivity
Selectividad máxima del filtro para utilizar la sugerencia generada a partir del índice de texto invertido.
## text\_index\_like\_max\_postings\_to\_read
Número máximo de listas de postings grandes que se pueden leer cuando está habilitada la evaluación de `LIKE` del índice de texto mediante dictionary scan.
Requiere que `use_text_index_like_evaluation_by_dictionary_scan` esté habilitado.
## text\_index\_like\_min\_pattern\_length
Longitud mínima de la cadena alfanumérica buscada en un patrón LIKE/ILIKE necesaria para usar la evaluación de LIKE del índice de texto mediante el escaneo del diccionario.
Los patrones más cortos que este umbral coinciden con demasiados tokens del diccionario y se omiten para evitar escaneos costosos.
Requiere que `use_text_index_like_evaluation_by_dictionary_scan` esté habilitado.
## throw\_if\_no\_data\_to\_insert
Permite o prohíbe los INSERT vacíos; está habilitado de forma predeterminada (genera un error si se realiza un insert vacío). Solo se aplica a los INSERT realizados con [`clickhouse-client`](/es/concepts/features/interfaces/cli) o mediante la [interfaz gRPC](/es/concepts/features/interfaces/grpc).
## throw\_on\_error\_from\_cache\_on\_write\_operations
Ignora los errores de la caché al escribir en caché durante las operaciones de escritura (INSERT, merges)
## throw\_on\_max\_partitions\_per\_insert\_block
Permite controlar el comportamiento cuando se alcanza `max_partitions_per_insert_block`.
Valores posibles:
* `true` - Cuando un bloque de inserción alcanza `max_partitions_per_insert_block`, se lanza una excepción.
* `false` - Registra una advertencia cuando se alcanza `max_partitions_per_insert_block`.
Esto puede ser útil si intentas entender el impacto en los usuarios al cambiar [`max_partitions_per_insert_block`](/es/reference/settings/session-settings#max_partitions_per_insert_block).
## throw\_on\_unsupported\_query\_inside\_transaction
Lanza una excepción si se usa una consulta no compatible dentro de una transacció
## timeout\_before\_checking\_execution\_speed
Comprueba que la velocidad de ejecución no sea demasiado baja (no inferior a `min_execution_speed`)
una vez transcurrido el tiempo especificado en segundos.
## timeout\_overflow\_mode
Establece qué hacer si la consulta se ejecuta durante más tiempo que `max_execution_time` o si el
tiempo de ejecución estimado supera `max_estimated_execution_time`.
Valores posibles:
* `throw`: generar una excepción (por defecto).
* `break`: detener la ejecución de la consulta y devolver el resultado parcial, como si los
datos de origen se hubieran agotado.
## timeout\_overflow\_mode\_leaf
Establece qué sucede cuando la consulta en el nodo hoja tarda más que `max_execution_time_leaf`.
Valores posibles:
* `throw`: lanzar una excepción (predeterminado).
* `break`: detener la ejecución de la consulta y devolver el resultado parcial, como si los
datos de origen se hubieran agotado.
## totals\_auto\_threshold
El umbral para `totals_mode = 'auto'`.
Consulte la sección «modificador WITH TOTALS».
## totals\_mode
Cómo calcular TOTALS cuando se usa HAVING, así como cuando están presentes max\_rows\_to\_group\_by y group\_by\_overflow\_mode = 'any'.
Consulte la sección «modificador WITH TOTALS».
## trace\_profile\_events
Habilita o deshabilita la recopilación de stacktraces en cada actualización de los profile events, junto con el nombre del profile event y el valor del incremento, y su envío a [trace\_log](/es/reference/system-tables/trace_log).
Valores posibles:
* 1 — Seguimiento de profile events habilitado.
* 0 — Seguimiento de profile events deshabilitado.
## trace\_profile\_events\_list
Cuando la configuración `trace_profile_events` está habilitada, limita los eventos rastreados a la lista especificada de nombres separados por comas.
Si `trace_profile_events_list` es una cadena vacía (valor predeterminado), rastrea todos los eventos de perfil.
Valor de ejemplo: 'DiskS3ReadMicroseconds,DiskS3ReadRequestsCount,SelectQueryTimeMicroseconds,ReadBufferFromS3Bytes'
Usar esta configuración permite recopilar datos con mayor precisión para un gran número de consultas, ya que, de lo contrario, la enorme cantidad de eventos puede desbordar la cola interna del registro del sistema y hacer que se descarte una parte de ellos.
## transfer\_overflow\_mode
Establece qué ocurre cuando la cantidad de datos supera uno de los límites.
Valores posibles:
* `throw`: lanzar una excepción (predeterminado).
* `break`: dejar de ejecutar la consulta y devolver el resultado parcial, como si los
datos de origen se hubieran agotado.
## transform\_null\_in
Habilita la igualdad entre valores [NULL](/es/reference/syntax#null) para el operador [IN](/es/reference/statements/in).
De forma predeterminada, los valores `NULL` no se pueden comparar porque `NULL` significa que el valor no está definido. Por lo tanto, la comparación `expr = NULL` siempre debe devolver `false`. Con esta configuración, `NULL = NULL` devuelve `true` para el operador `IN`.
Valores posibles:
* 0 — La comparación de valores `NULL` en el operador `IN` devuelve `false`.
* 1 — La comparación de valores `NULL` en el operador `IN` devuelve `true`.
**Ejemplo**
Considere la tabla `null_in`:
```text theme={null}
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
│ 3 │ 3 │
└──────┴───────┘
```
Consulta:
```sql theme={null}
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 0;
```
Resultado:
```text theme={null}
┌──idx─┬────i─┐
│ 1 │ 1 │
└──────┴──────┘
```
Consulta:
```sql theme={null}
SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 1;
```
Resultado:
```text theme={null}
┌──idx─┬─────i─┐
│ 1 │ 1 │
│ 2 │ NULL │
└──────┴───────┘
```
**Véase también**
* [Procesamiento de NULL en los operadores IN](/es/reference/statements/in#null-processing)
## traverse\_shadow\_remote\_data\_paths
Recorre, además de los datos reales de la tabla, los datos congelados (directorio shadow) al consultar system.remote\_data\_paths
## union\_default\_mode
Establece un modo para combinar los resultados de las consultas `SELECT`. Esta configuración solo se utiliza con [UNION](/es/reference/statements/select/union) cuando no se especifica explícitamente `UNION ALL` o `UNION DISTINCT`.
Valores posibles:
* `'DISTINCT'` — ClickHouse devuelve las filas resultantes de combinar consultas, eliminando las filas duplicadas.
* `'ALL'` — ClickHouse devuelve todas las filas resultantes de combinar consultas, incluidas las filas duplicadas.
* `''` — ClickHouse genera una excepción cuando se usa con `UNION`.
Consulte ejemplos en [UNION](/es/reference/statements/select/union).
## unknown\_packet\_in\_send\_data
Enviar un paquete desconocido en lugar del enésimo paquete de datos
## update\_parallel\_mode
Determina el comportamiento de las consultas `UPDATE` concurrentes.
Valores posibles:
* `sync` - ejecutar secuencialmente todas las consultas `UPDATE`.
* `auto` - ejecutar secuencialmente solo las consultas `UPDATE` con dependencias entre las columnas actualizadas en una consulta y las columnas usadas en las expresiones de otra consulta.
* `async` - no sincronizar las consultas `UPDATE`.
## update\_sequential\_consistency
Si está activado, el conjunto de partes se actualiza a la versión más reciente antes de ejecutar la actualización.
## url\_base
La URL base que se utiliza para resolver URL relativas en la [url](/es/reference/functions/table-functions/url) table function y el motor de tabla [URL](/es/reference/engines/table-engines/special/url).
Cuando se establece, las URL relativas se resuelven de la siguiente manera:
* URL relativa a la ruta (p. ej., `data.csv`): se combina con la ruta de la URL base según la RFC 3986. Todo lo que aparece después de la última `/` en la ruta base se sustituye por la URL relativa, por lo que la barra diagonal final importa: `https://example.com/dir/` + `data.csv` = `https://example.com/dir/data.csv`, pero `https://example.com/dir` + `data.csv` = `https://example.com/data.csv`. Si la base no tiene ruta (p. ej., `https://example.com`), se inserta una `/`: `https://example.com/data.csv`. Los segmentos de punto (`./` y `../`) de la URL relativa se normalizan: `https://example.com/dir/` + `../a.csv` = `https://example.com/a.csv`.
* URL relativa al host (p. ej., `/test/data.csv`): se resuelve a partir del esquema y el host de la URL base.
* URL relativa al esquema (p. ej., `//other.com/test/data.csv`): se resuelve usando el esquema de la URL base.
* Referencia de solo consulta (p. ej., `?x=1`): se añade a la ruta de la URL base (sustituyendo cualquier consulta o fragmento existente).
* Referencia de solo fragmento (p. ej., `#frag`): se añade a la URL base, conservando cualquier query string (sustituyendo cualquier fragmento existente).
* Referencia vacía: devuelve la URL base sin fragmento.
Por ejemplo, si `url_base` es `https://example.com/def/`, entonces:
* `data.csv` se resuelve en `https://example.com/def/data.csv`
* `/test/data.csv` se resuelve en `https://example.com/test/data.csv`
* `//other.com/test/data.csv` se resuelve en `https://other.com/test/data.csv`
## use\_async\_executor\_for\_materialized\_views
Usa la ejecución asíncrona y, potencialmente, multihilo de la consulta de la vista materializada; puede acelerar el procesamiento de las vistas durante INSERT, pero también consumir más memoria.
## use\_cache\_for\_count\_from\_files
Habilita el almacenamiento en caché del número de filas al contar desde archivos en las funciones de tabla `file`/`s3`/`url`/`hdfs`/`azureBlobStorage`.
Habilitado de forma predeterminada.
## use\_client\_time\_zone
Utiliza la zona horaria del cliente para interpretar los valores de cadena DateTime, en lugar de usar la zona horaria del servidor.
## use\_compact\_format\_in\_distributed\_parts\_names
Usa el formato compacto para almacenar bloques para `INSERT` en segundo plano (`distributed_foreground_insert`) en tablas con el engine `Distributed`.
Valores posibles:
* 0 — Usa el formato de directorio `user[:password]@host:port#default_database`.
* 1 — Usa el formato de directorio `[shard{shard_index}[_replica{replica_index}]]`.
- con `use_compact_format_in_distributed_parts_names=0`, los cambios en la definición del clúster no se aplicarán al `INSERT` en segundo plano.
- con `use_compact_format_in_distributed_parts_names=1`, cambiar el orden de los nodos en la definición del clúster cambiará `shard_index`/`replica_index`, así que tenlo en cuenta.
## use\_concurrency\_control
Respeta el control de concurrencia del servidor (consulta las configuraciones globales del servidor `concurrent_threads_soft_limit_num` y `concurrent_threads_soft_limit_ratio_to_cores`). Si se deshabilita, permite usar un mayor número de hilos incluso si el servidor está sobrecargado (no se recomienda para un uso normal y se necesita principalmente para pruebas).
Valor predeterminado en Cloud: `0`.
## use\_hash\_table\_stats\_for\_join\_reordering
Habilita el uso de las estadísticas recopiladas de la tabla hash para estimar la cardinalidad durante la reordenación de JOIN
## use\_hedged\_requests
Habilita la lógica de Hedged Requests para consultas remotas. Permite establecer varias conexiones con distintas réplicas para una misma consulta.
Se habilita una nueva conexión si la(s) conexión(es) existente(s) con la(s) réplica(s) no se ha(n) establecido dentro de `hedged_connection_timeout`
o si no se han recibido datos dentro de `receive_data_timeout`. La consulta usa la primera conexión que envía un paquete de progreso no vacío (o un paquete de datos, si `allow_changing_replica_until_first_data_packet`);
las demás conexiones se cancelan. Se admiten consultas con `max_parallel_replicas > 1`.
Habilitado de forma predeterminada.
Valor predeterminado de Cloud: `0`.
## use\_hive\_partitioning
Cuando está habilitada, ClickHouse detectará el particionado de estilo Hive en la ruta (`/name=value/`) en los motores de tabla de tipo archivo [File](/es/reference/functions/table-functions/file#hive-style-partitioning)/[S3](/es/reference/functions/table-functions/s3#hive-style-partitioning)/[URL](/es/reference/functions/table-functions/url#hive-style-partitioning)/[HDFS](/es/reference/functions/table-functions/hdfs#hive-style-partitioning)/[AzureBlobStorage](/es/reference/functions/table-functions/azureBlobStorage#hive-style-partitioning) y permitirá usar las columnas de partición como columnas virtuales en la consulta. Estas columnas virtuales tendrán los mismos nombres que en la ruta con particiones, pero comenzarán con `_`.
## use\_iceberg\_metadata\_files\_cache
Si está activado, la función de tabla Iceberg y el almacenamiento Iceberg pueden utilizar la caché de archivos de metadatos de Iceberg.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## use\_iceberg\_partition\_pruning
Usa la poda de particiones de Iceberg para las tablas Iceberg
## use\_index\_for\_in\_with\_subqueries
Intenta usar un índice si hay una subconsulta o una expresión de tabla en el lado derecho del operador IN.
## use\_index\_for\_in\_with\_subqueries\_max\_values
El tamaño máximo del conjunto en el lado derecho del operador IN para usar el índice de la tabla en el filtrado. Permite evitar la degradación del rendimiento y un mayor uso de memoria debidos a la preparación de estructuras de datos adicionales para consultas grandes. Cero significa que no hay límite.
## use\_join\_disjunctions\_push\_down
Habilita el pushdown de las partes de las condiciones `JOIN` conectadas por `OR` hacia los lados de entrada correspondientes ("pushdown parcial").
Esto permite que los motores de almacenamiento filtren antes, lo que puede reducir la cantidad de datos leídos.
La optimización preserva la semántica y solo se aplica cuando cada rama `OR` de nivel superior aporta al menos un
predicado determinista para el lado de destino.
## use\_legacy\_to\_time
Cuando está habilitada, permite usar la función heredada toTime, que convierte una fecha con hora en una fecha fija determinada, conservando la hora.
De lo contrario, utiliza una nueva función toTime, que convierte distintos tipos de datos al tipo Time.
La antigua función heredada también está disponible incondicionalmente como toTimeWithFixedDate.
## use\_page\_cache\_for\_disks\_without\_file\_cache
Utiliza la caché de páginas en espacio de usuario para discos remotos que no tienen habilitada la caché del sistema de archivos.
## use\_page\_cache\_for\_local\_disks
Usa la caché de páginas en espacio de usuario al leer desde discos locales. Se usa para pruebas y es poco probable que mejore el rendimiento en la práctica. Requiere `local_filesystem_read_method = 'pread'` o `'read'`. No desactiva la caché de páginas del SO; para ello se puede usar `min_bytes_to_use_direct_io`. Solo afecta a las tablas normales, no a la función de tabla `file()` ni al motor de tabla `File()`.
## use\_page\_cache\_for\_object\_storage
Use la caché de páginas en espacio de usuario al leer desde funciones de tabla para almacenamiento de objetos (s3, azure, hdfs) y motores de tabla (S3, Azure, HDFS).
## use\_page\_cache\_with\_distributed\_cache
Use la caché de páginas en espacio de usuario cuando se use distributed cache.
## use\_paimon\_partition\_pruning
Usar la poda de particiones de Paimon en las funciones de tabla de Paimon
## use\_parquet\_metadata\_cache
Si está activado, el formato Parquet puede utilizar la caché de metadatos de Parquet.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## use\_partition\_pruning
**Alias**: `use_partition_key`
Usa la clave de partición para la poda de particiones durante la ejecución de consultas en tablas MergeTree.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_primary\_key
Utiliza la clave primaria para podar gránulos durante la ejecución de consultas en las tablas MergeTree.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_query\_cache
Si está activado, las consultas `SELECT` pueden utilizar la [caché de consultas](/es/concepts/features/performance/caches/query-cache). Los parámetros [enable\_reads\_from\_query\_cache](#enable_reads_from_query_cache)
y [enable\_writes\_to\_query\_cache](#enable_writes_to_query_cache) controlan con mayor detalle cómo se utiliza la caché.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## use\_query\_condition\_cache
Habilita la [caché de condiciones de consulta](/es/concepts/features/performance/caches/query-condition-cache). La caché almacena rangos de gránulos en partes de datos que no cumplen la condición de la cláusula `WHERE`
y reutiliza esta información como un índice temporal para las consultas posteriores.
Valores posibles:
* 0 - Deshabilitado
* 1 - Habilitado
## use\_roaring\_bitmap\_iceberg\_positional\_deletes
Usa roaring bitmap para las eliminaciones posicionales de Iceberg.
## use\_skip\_indexes
Utiliza índices de omisión de datos durante la ejecución de consultas.
Posibles valores:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_for\_disjunctions
Evalúa los filtros WHERE con condiciones mixtas AND y OR mediante índices de omisión. Ejemplo: WHERE A = 5 AND (B = 5 OR C = 5).
Si está deshabilitado, los índices de omisión se siguen usando para evaluar las condiciones WHERE, pero solo pueden contener cláusulas unidas con AND.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_for\_top\_k
Habilita el uso de índices de omisión de datos para el filtrado TopK.
Cuando está habilitada, si existe un índice MinMax en la columna de una consulta `ORDER BY LIMIT n`, el optimizador intentará usar el índice MinMax para omitir gránulos que no sean relevantes para el resultado final. Esto puede reducir la latencia de la consulta.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_if\_final
Controla si se usan índices de omisión al ejecutar una consulta con el modificador FINAL.
Los índices de omisión pueden excluir filas (gránulos) que contienen los datos más recientes, lo que podría dar lugar a resultados incorrectos en una consulta con el modificador FINAL. Cuando este ajuste está habilitado, los índices de omisión se aplican incluso con el modificador FINAL, lo que puede mejorar el rendimiento, pero con el riesgo de omitir actualizaciones recientes. Este ajuste debe habilitarse al mismo tiempo que el ajuste use\_skip\_indexes\_if\_final\_exact\_mode (está habilitado de forma predeterminada).
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_if\_final\_exact\_mode
Controla si los gránulos devueltos por un índice de omisión se expanden en las partes más recientes para devolver resultados correctos al ejecutar una consulta con el modificador FINAL.
El uso de índice de omisión puede excluir filas (gránulos) que contienen los datos más recientes, lo que podría dar lugar a resultados incorrectos. Esta configuración puede garantizar que se devuelvan resultados correctos al examinar las partes más recientes que se superponen con los rangos devueltos por el índice de omisión. Esta configuración solo debe deshabilitarse si, para una aplicación, son aceptables los resultados aproximados basados en la consulta del índice de omisión.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_skip\_indexes\_on\_data\_read
Permite usar índices de omisión de datos durante la lectura de datos.
Cuando está habilitada, los índices de omisión se evalúan dinámicamente en el momento en que se lee cada gránulo de datos, en lugar de analizarse por adelantado antes de que comience la ejecución de la consulta. Esto puede reducir la latencia de inicio de la consulta.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_statistics
/// se prefiere a 'allow\_statistics\_optimize' por coherencia con 'use\_primary\_key' y 'use\_skip\_indexes'
Permite usar estadísticas para optimizar las consultas
## use\_statistics\_cache
Utilice la caché de estadísticas en una consulta para evitar la sobrecarga que supone cargar las estadísticas de todas las partes
## use\_statistics\_for\_part\_pruning
Usa estadísticas para descartar partes durante la ejecución de consultas.
Cuando está habilitado, la poda en las consultas SELECT usará estadísticas de columnas (p. ej., estadísticas MinMax) para eliminar partes que no puedan contener datos coincidentes antes de leer ningún dato.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_strict\_insert\_block\_limits
Cuando está habilitada, aplica estrictamente los límites mínimo y máximo del tamaño del bloque de inserción.
Se emite un bloque cuando:
* Umbrales mínimos (AND): Se alcanzan tanto min\_insert\_block\_size\_rows como min\_insert\_block\_size\_bytes.
* Umbrales máximos (OR): Se alcanza max\_insert\_block\_size\_rows o max\_insert\_block\_size\_bytes.
Cuando está deshabilitada, se emite un bloque cuando:
* Umbrales mínimos (OR): Se alcanza min\_insert\_block\_size\_rows o min\_insert\_block\_size\_bytes.
**Nota**: Si la configuración máxima es menor que la configuración mínima, prevalecen los límites máximos y los bloques se emitirán antes de alcanzar los umbrales mínimos.
**Nota**: Esta configuración se desactiva automáticamente para las inserciones asíncronas, porque las inserciones asíncronas añaden tokens de deduplicación por entrada que son incompatibles con la división de bloques necesaria para aplicar límites estrictos.
Deshabilitada de forma predeterminada.
## use\_structure\_from\_insertion\_table\_in\_table\_functions
Utiliza la estructura de la tabla de inserción en lugar de inferir el esquema a partir de los datos. Posibles valores: 0 - deshabilitado, 1 - habilitado, 2 - auto
Indica si se usa una caché del encabezado deserializado del índice de texto.
Usar la caché del encabezado del índice de texto puede reducir significativamente la latencia y aumentar el rendimiento al trabajar con un gran número de consultas con índices de texto.
## use\_text\_index\_like\_evaluation\_by\_dictionary\_scan
Habilita la evaluación de consultas LIKE/ILIKE mediante el análisis del diccionario del índice de texto invertido.
## use\_text\_index\_postings\_cache
Si se debe usar una caché de listas de postings deserializadas del índice de texto.
Usar la caché de postings del índice de texto puede reducir significativamente la latencia y aumentar el rendimiento cuando se trabaja con un gran número de consultas sobre índices de texto.
## use\_text\_index\_tokens\_cache
Indica si se debe usar una caché de información deserializada de los tokens del índice de texto.
Usar la caché de tokens del índice de texto puede reducir significativamente la latencia y aumentar el rendimiento al trabajar con una gran cantidad de consultas de índice de texto.
## use\_top\_k\_dynamic\_filtering
Habilita la optimización de filtrado dinámico al ejecutar una consulta `ORDER BY LIMIT n`.
Cuando está habilitada, el ejecutor de la consulta intentará omitir gránulos y filas que no formarán parte de las `top N` filas finales del conjunto de resultados. Esta optimización es dinámica por naturaleza, y las mejoras de latencia dependen de la distribución de los datos y de la presencia de otros predicados en la consulta.
Valores posibles:
* 0 — Deshabilitado.
* 1 — Habilitado.
## use\_top\_k\_dynamic\_filtering\_for\_variable\_length\_types
Permite que `use_top_k_dynamic_filtering` se aplique cuando la columna de ordenación tiene un tipo de datos de longitud variable (p. ej., `String`, `Array`, `Map`, `Tuple` que contiene elementos de longitud variable).
Para estos tipos, la comparación del umbral por fila que realiza el filtro dinámico puede costar más de lo que ahorra cuando predomina el mínimo lexicográfico de la columna (p. ej., cadenas mayoritariamente vacías) y se pueden omitir pocos gránulos. En ese caso, el filtro dinámico empeora la latencia de la consulta en lugar de mejorarla.
Cuando este ajuste es `0`, el filtrado dinámico se restringe a columnas cuyos valores tienen un tamaño máximo fijo en memoria (números, `Date`, `DateTime`, `FixedString`, `Enum`, `Nullable` de esos tipos, `Tuple` de esos tipos). Cuando se establece en `1`, el filtrado dinámico también se aplica a tipos de longitud variable.
Valores posibles:
* 0 — Desactivado.
* 1 — Activado.
## use\_uncompressed\_cache
Indica si se debe usar una caché de bloques sin comprimir. Acepta 0 o 1. De forma predeterminada, 0 (deshabilitado).
El uso de la caché sin comprimir (solo para tablas de la familia MergeTree) puede reducir significativamente la latencia y aumentar el rendimiento al trabajar con una gran cantidad de consultas cortas. Habilite esta configuración para los usuarios que envían solicitudes cortas con frecuencia. Preste atención también al parámetro de configuración [uncompressed\_cache\_size](/es/reference/settings/server-settings/settings#uncompressed_cache_size) (solo se puede establecer en el archivo de configuración): el tamaño de los bloques de la caché sin comprimir. De forma predeterminada, es de 8 GiB. La caché sin comprimir se llena según sea necesario y los datos menos utilizados se eliminan automáticamente.
En las consultas que leen un volumen de datos al menos moderadamente grande (un millón de filas o más), la caché sin comprimir se deshabilita automáticamente para ahorrar espacio para las consultas realmente pequeñas. Esto significa que puede mantener siempre la configuración 'use\_uncompressed\_cache' establecida en 1.
## use\_variant\_as\_common\_type
Permite usar el tipo `Variant` como tipo de resultado de las funciones [if](/es/reference/functions/regular-functions/conditional-functions#if)/[multiIf](/es/reference/functions/regular-functions/conditional-functions#multiIf)/[array](/es/reference/functions/regular-functions/array-functions)/[map](/es/reference/functions/regular-functions/tuple-map-functions) cuando no existe un tipo común para los tipos de argumento.
Ejemplo:
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(if(number % 2, number, range(number))) as variant_type FROM numbers(1);
SELECT if(number % 2, number, range(number)) as variant FROM numbers(5);
```
```text theme={null}
┌─variant_type───────────────────┐
│ Variant(Array(UInt64), UInt64) │
└────────────────────────────────┘
┌─variant───┐
│ [] │
│ 1 │
│ [0,1] │
│ 3 │
│ [0,1,2,3] │
└───────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL)) AS variant_type FROM numbers(1);
SELECT multiIf((number % 4) = 0, 42, (number % 4) = 1, [1, 2, 3], (number % 4) = 2, 'Hello, World!', NULL) AS variant FROM numbers(4);
```
```text theme={null}
─variant_type─────────────────────────┐
│ Variant(Array(UInt8), String, UInt8) │
└──────────────────────────────────────┘
┌─variant───────┐
│ 42 │
│ [1,2,3] │
│ Hello, World! │
│ ᴺᵁᴸᴸ │
└───────────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(array(range(number), number, 'str_' || toString(number))) as array_of_variants_type from numbers(1);
SELECT array(range(number), number, 'str_' || toString(number)) as array_of_variants FROM numbers(3);
```
```text theme={null}
┌─array_of_variants_type────────────────────────┐
│ Array(Variant(Array(UInt64), String, UInt64)) │
└───────────────────────────────────────────────┘
┌─array_of_variants─┐
│ [[],0,'str_0'] │
│ [[0],1,'str_1'] │
│ [[0,1],2,'str_2'] │
└───────────────────┘
```
```sql theme={null}
SET use_variant_as_common_type = 1;
SELECT toTypeName(map('a', range(number), 'b', number, 'c', 'str_' || toString(number))) as map_of_variants_type from numbers(1);
SELECT map('a', range(number), 'b', number, 'c', 'str_' || toString(number)) as map_of_variants FROM numbers(3);
```
```text theme={null}
┌─map_of_variants_type────────────────────────────────┐
│ Map(String, Variant(Array(UInt64), String, UInt64)) │
└─────────────────────────────────────────────────────┘
┌─map_of_variants───────────────┐
│ {'a':[],'b':0,'c':'str_0'} │
│ {'a':[0],'b':1,'c':'str_1'} │
│ {'a':[0,1],'b':2,'c':'str_2'} │
└───────────────────────────────┘
```
## use\_variant\_default\_implementation\_for\_comparisons
Habilita o deshabilita la implementación predeterminada para el tipo Variant en las funciones de comparación.
## use\_with\_fill\_by\_sorting\_prefix
Las columnas anteriores a las columnas WITH FILL de la cláusula ORDER BY constituyen el prefijo de ordenación. Las filas con valores distintos en el prefijo de ordenación se rellenan de forma independiente
## validate\_enum\_literals\_in\_operators
Si está habilitado, valida los literales de enum en operadores como `IN`, `NOT IN`, `==`, `!=` con respecto al tipo enum y lanza una excepción si el literal no es un valor válido del enum.
## validate\_mutation\_query
Valida las consultas de mutación antes de aceptarlas. Las mutaciones se ejecutan en segundo plano, y ejecutar una consulta no válida hará que queden bloqueadas y requieran intervención manual.
Cambie esta configuración solo si encuentra un error que rompa la compatibilidad con versiones anteriores.
## validate\_polygons
Habilita o deshabilita que se lance una excepción en la función [pointInPolygon](/es/reference/functions/regular-functions/geo/coordinates#pointinpolygon) si el polígono se autointerseca o es autotangente.
Valores posibles:
* 0 — El lanzamiento de excepciones está deshabilitado. `pointInPolygon` acepta polígonos no válidos y devuelve resultados posiblemente incorrectos para ellos.
* 1 — El lanzamiento de excepciones está habilitado.
## variant\_throw\_on\_type\_mismatch
Al aplicar una función a una columna [Variant](/es/reference/data-types/variant) mediante la implementación predeterminada,
determina qué ocurre con las filas cuyo tipo real es incompatible con la función:
* `true` (predeterminado) — lanzar una excepción.
* `false` — devolver `NULL` para esas filas.
## vector\_search\_filter\_strategy
Si una consulta de búsqueda vectorial tiene una cláusula WHERE, esta configuración determina si se evalúa primero (pre-filtering) o si primero se comprueba el índice de similitud vectorial (post-filtering). Posibles valores:
* 'auto' - Posfiltrado (la semántica exacta puede cambiar en el futuro).
* 'postfilter' - Usa el índice de similitud vectorial para identificar los vecinos más cercanos y luego aplica otros filtros.
* 'prefilter' - Evalúa primero otros filtros y luego realiza una búsqueda por fuerza bruta para identificar a los vecinos.
## vector\_search\_index\_fetch\_multiplier
**Alias**: `vector_search_postfilter_multiplier`
Multiplica por este número la cantidad de vecinos más cercanos recuperados del índice de similitud vectorial. Solo se aplica al posfiltrado con otros predicados o si la configuración 'vector\_search\_with\_rescoring = 1'.
## vector\_search\_with\_rescoring
Si ClickHouse aplica rescoring a las consultas que usan el índice de similitud vectorial.
Sin rescoring, el índice de similitud vectorial devuelve directamente las filas que contienen las mejores coincidencias.
Con rescoring, las filas se extrapolan al nivel de gránulo y se vuelven a comprobar todas las filas del gránulo.
En la mayoría de los casos, el rescoring solo mejora ligeramente la precisión, pero reduce significativamente el rendimiento de las consultas de búsqueda vectorial.
Nota: Una consulta ejecutada sin rescoring y con las réplicas paralelas habilitadas puede pasar a usar rescoring.
## wait\_changes\_become\_visible\_after\_commit\_mode
Esperar a que los cambios confirmados pasen a ser realmente visibles en la instantánea más reciente
## wait\_for\_async\_insert
Si es true, espera a que se procese la inserción asíncrona
## wait\_for\_async\_insert\_timeout
Tiempo de espera para el procesamiento de la inserción asíncrona
## wait\_for\_window\_view\_fire\_signal\_timeout
Tiempo de espera para la señal de activación de window view en el procesamiento por tiempo de evento
## webassembly\_udf\_max\_fuel
Límite de fuel por ejecución de una instancia de WebAssembly UDF. Cada instrucción de WebAssembly consume una cierta cantidad de fuel.
Establezca 0 para desactivar el límite.
## webassembly\_udf\_max\_input\_block\_size
Número máximo de filas que se pueden pasar a una UDF de WebAssembly en un solo bloque. Establezca 0 para procesar todas las filas de una sola vez.
## webassembly\_udf\_max\_instances
Número máximo de instancias de WebAssembly UDF que pueden ejecutarse en paralelo por función.
## webassembly\_udf\_max\_memory
Límite de memoria en bytes para cada instancia de WebAssembly UDF.
## window\_view\_clean\_interval
El intervalo de limpieza de window view, en segundos, para eliminar datos obsoletos.
## window\_view\_heartbeat\_interval
El intervalo de latido, en segundos, que indica que la consulta watch sigue activa.
## workload
Nombre de la workload que se utilizará para acceder a los recursos
## write\_full\_path\_in\_iceberg\_metadata
Escribir rutas completas (incluido s3://) en los archivos de metadatos de Iceberg.
## write\_through\_distributed\_cache
Solo tiene efecto en ClickHouse Cloud. Permite escribir en la caché distribuida (la escritura en S3 también se realizará mediante la caché distribuida)
## write\_through\_distributed\_cache\_buffer\_size
Solo tiene efecto en ClickHouse Cloud. Establece el tamaño del búfer para la caché distribuida con write-through. Si es 0, se usará el tamaño del búfer que se habría utilizado si no hubiera caché distribuida.
## zstd\_window\_log\_max
Permite seleccionar el valor máximo de window log de ZSTD (no se utilizará para la familia MergeTree)