> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> SETTINGS de MergeTree en `system.merge_tree_settings`
# SETTINGS de las tablas MergeTree
export const SettingsInfoBlock = ({type, default_value, changeable_without_restart}) => {
const cells = [["Type", {type}], ["Default value", {default_value}]];
if (changeable_without_restart) {
const isYes = String(changeable_without_restart).trim().toLowerCase() === "yes";
const badge = isYes ? Yes : No;
cells.push(["Changeable without restart", badge]);
}
return
{cells.map(([h]) => | {h} | )}
{cells.map(([h, v]) => | {v} | )}
;
};
export const galaxyOnClick = eventName => () => {
try {
if (typeof window !== "undefined" && window.galaxy && eventName) {
window.galaxy.track(eventName, {
interaction: "click"
});
}
} catch (e) {}
};
export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => {
if (link) {
return
Beta
;
}
return ;
};
export const ExperimentalBadge = () => {
return ;
};
La tabla del sistema `system.merge_tree_settings` muestra los SETTINGS de MergeTree establecidos globalmente.
Los SETTINGS de MergeTree pueden definirse en la sección `merge_tree` del archivo de configuración del servidor, o especificarse de forma individual para cada tabla `MergeTree` en
la cláusula `SETTINGS` de la sentencia `CREATE TABLE`.
Ejemplo de cómo personalizar el SETTING `max_suspicious_broken_parts`:
Configure el valor predeterminado para todas las tablas `MergeTree` en el archivo de configuración del servidor:
```text theme={null}
5
```
Definido para una tabla concreta:
```sql theme={null}
CREATE TABLE tab
(
`A` Int64
)
ENGINE = MergeTree
ORDER BY tuple()
SETTINGS max_suspicious_broken_parts = 500;
```
Cambie los SETTINGS de una tabla específica con `ALTER TABLE ... MODIFY SETTING`:
```sql theme={null}
ALTER TABLE tab MODIFY SETTING max_suspicious_broken_parts = 100;
-- restablecer al valor predeterminado global (valor de system.merge_tree_settings)
ALTER TABLE tab RESET SETTING max_suspicious_broken_parts;
```
## SETTINGS de MergeTree
## adaptive\_write\_buffer\_initial\_size
Tamaño inicial del búfer de escritura adaptativo
## add\_implicit\_sign\_column\_constraint\_for\_collapsing\_engine
Si es true, añade una restricción implícita para la columna `sign` de una tabla CollapsingMergeTree
o VersionedCollapsingMergeTree, de modo que solo se permitan valores válidos (`1` y `-1`).
## add\_minmax\_index\_for\_block\_number\_column
Cuando está habilitada, se añade un índice min-max implícito (de omisión) para la columna virtual persistente `_block_number`.
Requiere `enable_block_number_column = 1` para surtir efecto. El índice se crea solo durante las fusiones,
no durante las inserciones: en el momento de la inserción, el número de bloque es provisional e indexaría un valor constante.
## add\_minmax\_index\_for\_block\_offset\_column
Cuando se habilita, se añade un índice min-max implícito (omisión) para la columna virtual persistente `_block_offset`.
Requiere `enable_block_offset_column = 1` para surtir efecto. El índice se crea solo durante las fusiones,
no durante las inserciones.
## add\_minmax\_index\_for\_numeric\_columns
Cuando está activada, se añaden índices min-max (de omisión) a todas las columnas numéricas
de la tabla.
## add\_minmax\_index\_for\_string\_columns
Cuando está habilitada, se añaden índices min-max (de omisión) para todas las columnas de cadena de la tabla.
## add\_minmax\_index\_for\_temporal\_columns
Cuando está activada, se añaden índices min-max de omisión para todas las columnas Date, Date32, Time, Time64, DateTime y DateTime64 de la tabla
## allow\_coalescing\_columns\_in\_partition\_or\_order\_key
Cuando está habilitado, permite usar columnas de coalescencia en una tabla CoalescingMergeTree en
la partición o en la clave de ordenación.
## allow\_commit\_order\_projection
Habilita las proyecciones con orden de commit que almacenan las columnas virtuales `_block_number` y `_block_offset`, preservando el orden de inserción original durante las fusiones.
Requiere que `enable_block_number_column` y `enable_block_offset_column` estén habilitadas.
## allow\_experimental\_replacing\_merge\_with\_cleanup
Permite fusiones CLEANUP experimentales para ReplacingMergeTree con la
columna `is_deleted`. Cuando está habilitado, permite usar `OPTIMIZE ... FINAL CLEANUP` para
fusionar manualmente todas las partes de una partición en una sola parte y eliminar
las filas marcadas como eliminadas.
También permite habilitar que estas fusiones se realicen automáticamente en segundo plano
con las configuraciones `min_age_to_force_merge_seconds`,
`min_age_to_force_merge_on_partition_only` y
`enable_replacing_merge_with_cleanup_for_min_age_to_force_merge`.
## allow\_experimental\_reverse\_key
Habilita la compatibilidad con el orden descendente en las claves de ordenación
de MergeTree. Esta configuración es especialmente útil para el análisis de
series temporales y las consultas Top-N, ya que permite almacenar los datos en
orden cronológico inverso para optimizar el rendimiento de las consultas.
Con `allow_experimental_reverse_key` habilitado, puede definir órdenes
descendentes dentro de la cláusula `ORDER BY` de una tabla MergeTree. Esto
permite usar optimizaciones `ReadInOrder` más eficientes en lugar de
`ReadInReverseOrder` para consultas descendentes.
**Ejemplo**
```sql theme={null}
CREATE TABLE example
(
time DateTime,
key Int32,
value String
) ENGINE = MergeTree
ORDER BY (time DESC, key) -- Orden descendente en el campo 'time'
SETTINGS allow_experimental_reverse_key = 1;
SELECT * FROM example WHERE key = 'xxx' ORDER BY time DESC LIMIT 10;
```
Al usar `ORDER BY time DESC` en la consulta, se aplica `ReadInOrder`.
**Valor predeterminado:** false
## allow\_floating\_point\_partition\_key
Permite usar un número de coma flotante como clave de partición.
Valores posibles:
* `0` — No se permite una clave de partición de coma flotante.
* `1` — Se permite una clave de partición de coma flotante.
## allow\_nullable\_key
Permite tipos Nullable como claves primarias.
## allow\_part\_offset\_column\_in\_projections
Permite usar la columna '\_part\_offset' en la consulta SELECT de las proyecciones.
## allow\_reduce\_blocking\_parts\_task
Tarea en segundo plano que reduce las partes bloqueantes en las tablas shared merge tree.
Solo en ClickHouse Cloud
## allow\_remote\_fs\_zero\_copy\_replication
No use esta configuración en producción, ya que no está lista.
## allow\_summing\_columns\_in\_partition\_or\_order\_key
Cuando está habilitada, permite que las columnas sumadas de una tabla SummingMergeTree se usen en
la partición o en la clave de ordenación.
## allow\_suspicious\_indices
Rechaza índices primarios/secundarios y claves de ordenación con la misma expresión
## allow\_vertical\_merges\_from\_compact\_to\_wide\_parts
Permite las fusiones verticales de partes compactas a anchas. Esta configuración debe tener
el mismo valor en todas las réplicas.
## alter\_column\_secondary\_index\_mode
Configura si se permiten los comandos `ALTER` que modifican columnas cubiertas por índices secundarios y qué acción debe tomarse si
se permiten. De forma predeterminada, estos comandos `ALTER` están permitidos y los índices se reconstruyen.
Valores posibles:
* `rebuild` (predeterminado): Reconstruye cualquier índice secundario afectado por la columna en el comando `ALTER`.
* `throw`: Impide cualquier `ALTER` de columnas cubiertas por índices secundarios **explícitos** lanzando una excepción. Los índices implícitos quedan excluidos de esta restricción y se reconstruirán.
* `drop`: Elimina los índices secundarios dependientes. Las partes nuevas no tendrán los índices, por lo que será necesario `MATERIALIZE INDEX` para volver a crearlos.
* `compatibility`: Mantiene el comportamiento original: `throw` en `ALTER ... MODIFY COLUMN` y `rebuild` en `ALTER ... UPDATE/DELETE`.
* `ignore`: Pensado para uso experto. Dejará los índices en un estado inconsistente, lo que puede dar lugar a resultados de consulta incorrectos.
## always\_fetch\_merged\_part
Si es true, esta réplica nunca realiza fusiones de partes y siempre descarga partes fusionadas
de otras réplicas.
Valores posibles:
* true, false
## always\_use\_copy\_instead\_of\_hardlinks
Copie siempre los datos en lugar de usar enlaces duros durante operaciones de mutation/replace/detach
y así sucesivamente.
## apply\_patches\_on\_merge
Si es true, las partes de parche se aplican durante las fusiones
## assign\_part\_uuids
Cuando está habilitado, se asignará un identificador único a cada parte nueva.
Antes de habilitarlo, compruebe que todas las réplicas admitan la versión 4 de UUID.
## async\_block\_ids\_cache\_update\_wait\_ms
Cuánto tiempo esperará cada iteración de insert a que se actualice async\_block\_ids\_cache
## async\_insert
Si es true, los datos de la consulta INSERT se almacenan en una cola y luego se escriben en la tabla en segundo plano.
## auto\_statistics\_types
Lista separada por comas de los tipos de estadísticas que se calcularán automáticamente en todas las columnas adecuadas.
Tipos de estadísticas compatibles: tdigest, countmin, minmax, nullcount, uniq.
## background\_task\_preferred\_step\_execution\_time\_ms
Tiempo objetivo de ejecución de un paso de fusión o mutation. Puede superarse si
un paso tarda más
## cache\_populated\_by\_fetch
Esta SETTING se aplica únicamente a ClickHouse Cloud.
Cuando `cache_populated_by_fetch` está deshabilitada (SETTING predeterminada), las nuevas
partes de datos se cargan en la caché del sistema de archivos solo cuando se ejecuta una consulta que requiere
esas partes.
Si está habilitada, `cache_populated_by_fetch` hace que todos los nodos carguen
las nuevas partes de datos desde el almacenamiento en su caché del sistema de archivos, sin necesidad de que una consulta
desencadene esa acción.
**Véase también**
* [ignore\_cold\_parts\_seconds](/es/reference/settings/session-settings#ignore_cold_parts_seconds)
* [prefer\_warmed\_unmerged\_parts\_seconds](/es/reference/settings/session-settings#prefer_warmed_unmerged_parts_seconds)
* [cache\_warmer\_threads](/es/reference/settings/session-settings#cache_warmer_threads)
## cache\_populated\_by\_fetch\_filename\_regexp
Esta SETTING se aplica solo a ClickHouse Cloud.
Si no está vacío, solo se precargarán en la caché, después de la operación `fetch`, los archivos que coincidan con esta expresión regular (si `cache_populated_by_fetch` está habilitado).
## check\_delay\_period
SETTING obsoleta, no tiene ningún efecto.
## check\_sample\_column\_is\_correct
Habilita la comprobación, al crear la tabla, de que el tipo de dato de una columna para el m
uestreo o de la expresión de muestreo sea correcto. El tipo de dato debe ser uno de los [tipos
de enteros](/es/reference/data-types/int-uint) sin signo: `UInt8`, `UInt16`,
`UInt32`, `UInt64`.
Valores posibles:
* `true` — La comprobación está habilitada.
* `false` — La comprobación se deshabilita al crear la tabla.
Valor predeterminado: `true`.
De forma predeterminada, el servidor de ClickHouse comprueba, al crear la tabla, el tipo de dato de
una columna para el muestreo o de la expresión de muestreo. Si ya tiene tablas con
una expresión de muestreo incorrecta y no quiere que el servidor genere una excepción
durante el inicio, establezca `check_sample_column_is_correct` en `false`.
## clean\_deleted\_rows
SETTING obsoleta; no tiene efecto.
## cleanup\_delay\_period
Período mínimo para limpiar logs antiguos de la cola, hash de bloques y partes.
## cleanup\_delay\_period\_random\_add
Añade a cleanup\_delay\_period un valor distribuido uniformemente entre 0 y x segundos
para evitar el efecto de estampida y el posterior DoS de ZooKeeper en caso de
haber un número muy elevado de tablas.
## cleanup\_thread\_preferred\_points\_per\_iteration
Tamaño de Batch preferido para la limpieza en segundo plano (los puntos son abstractos, pero 1 punto
equivale aproximadamente a 1 bloque insertado).
## cleanup\_threads
SETTING obsoleta, no tiene ningún efecto.
## clone\_replica\_zookeeper\_create\_get\_part\_batch\_size
Tamaño del lote para las solicitudes get-part de creación múltiple en ZooKeeper al clonar una réplica.
## columns\_and\_secondary\_indices\_sizes\_lazy\_calculation
Calcula de forma diferida los tamaños de las columnas y de los índices secundarios en la primera solicitud en lugar
de hacerlo durante la inicialización de la tabla.
## columns\_to\_prewarm\_mark\_cache
Lista de columnas para precalentar la caché de marcas (si está habilitada). Si está vacío, significa todas las columnas
## compact\_parts\_max\_bytes\_to\_buffer
Solo disponible en ClickHouse Cloud. Número máximo de bytes que se pueden escribir en una
sola franja en partes compactas
## compact\_parts\_max\_granules\_to\_buffer
Solo disponible en ClickHouse Cloud. Número máximo de gránulos que se pueden escribir en una
sola stripe de partes compactas
## compact\_parts\_merge\_max\_bytes\_to\_prefetch\_part
Solo disponible en ClickHouse Cloud. Tamaño máximo de una parte compacta para leerla
completa en memoria durante la fusión.
## compatibility\_allow\_sampling\_expression\_not\_in\_primary\_key
Permite crear una tabla con una expresión de muestreo que no forme parte de la clave primaria. Esto
solo es necesario para permitir temporalmente la ejecución del servidor con tablas incorrectas por
compatibilidad con versiones anteriores.
## compress\_marks
Las marcas admiten compresión, lo que reduce el tamaño del archivo de marcas y acelera la
transmisión por la red.
## compress\_per\_column\_in\_compact\_parts
Controla la disposición física de las partes compactas. Si es true (valor predeterminado), cada columna de un gránulo
inicia un nuevo bloque comprimido, lo que permite a ClickHouse omitir la lectura de columnas innecesarias
desde disco. Si es false, todas las columnas de un gránulo se empaquetan en el mismo bloque comprimido,
lo que mejora la relación de compresión, pero requiere descomprimir más datos durante la lectura.
Esto resulta beneficioso para cargas de trabajo que siempre leen todas las columnas (p. ej., proyecciones).
## compress\_primary\_key
La clave primaria admite compresión, lo que reduce el tamaño del archivo de la clave primaria y acelera la
transmisión por la red.
## concurrent\_part\_removal\_threshold
Activa la eliminación concurrente de partes (consulta `max_part_removal_threads`) solo si
el número de partes de datos inactivas es al menos este valor.
## concurrent\_part\_removal\_threshold\_for\_remote\_disk
Igual que `concurrent_part_removal_threshold`, pero se usa cuando al menos una
de las partes que se van a eliminar está almacenada en un disco remoto. El valor predeterminado es más bajo
porque cada eliminación de una parte en almacenamiento remoto normalmente requiere una
ida y vuelta por la red (por ejemplo, un `DELETE` HTTP por parte en el almacenamiento de objetos), por lo que una
eliminación en serie de tan solo 100 partes puede bloquear un `DROP TABLE` durante decenas de
segundos.
## deduplicate\_merge\_projection\_mode
Indica si se permite crear una proyección para una table con un MergeTree no clásico,
es decir, que no sea (Replicated, Shared) MergeTree. La opción `ignore` es solo por
compatibilidad y puede dar lugar a respuestas incorrectas. En caso de que se permita,
define qué acción realizar al fusionar projections: `drop` o `rebuild`. Por tanto, el
MergeTree clásico ignorará esta configuración. También controla `OPTIMIZE DEDUPLICATE`,
pero surte efecto en todos los miembros de la familia MergeTree. Al igual que la
opción `lightweight_mutation_projection_mode`, también es a nivel de part.
Valores posibles:
* `ignore`
* `throw`
* `drop`
* `rebuild`
## default\_compression\_codec
Especifica el códec de compresión predeterminado que se utilizará si no se define ninguno para una columna concreta en la declaración de la tabla.
Orden de selección del códec de compresión para una columna:
1. Códec de compresión definido para la columna en la declaración de la tabla
2. Códec de compresión definido en `default_compression_codec` (esta configuración)
3. Códec de compresión predeterminado definido en la configuración `compression`
Valor predeterminado: una cadena vacía (sin definir).
## detach\_not\_byte\_identical\_parts
Habilita o deshabilita el desacoplamiento de una parte de datos en una réplica después de una
fusión o una mutación, si no es idéntica byte por byte a las partes de datos de otras réplicas. Si está
deshabilitada, la parte de datos se elimina. Active esta configuración si desea
analizar esas partes más adelante.
La configuración es aplicable a las tablas `MergeTree` con
[replicación de datos](/es/reference/engines/table-engines/mergetree-family/replacingmergetree) habilitada.
Valores posibles:
* `0` — Las partes se eliminan.
* `1` — Las partes se desacoplan.
## detach\_old\_local\_parts\_when\_cloning\_replica
No elimina las partes locales antiguas al reparar una réplica perdida.
Valores posibles:
* `true`
* `false`
## disable\_detach\_partition\_for\_zero\_copy\_replication
Deshabilita la consulta DETACH PARTITION para la replicación sin copia.
## disable\_fetch\_partition\_for\_zero\_copy\_replication
Deshabilita la consulta FETCH PARTITION para la replicación sin copia.
## disable\_freeze\_partition\_for\_zero\_copy\_replication
Deshabilita la consulta FREEZE PARTITION en la replicación sin copia.
## disco
Nombre del disco de almacenamiento. Puede especificarse en lugar de una política de almacenamiento.
## distributed\_index\_analysis\_min\_indexes\_bytes\_to\_activate
Tamaños mínimos de los índices (de omisión de datos y de clave primaria) en disco (sin comprimir) para activar el análisis distribuido de índices
## distributed\_index\_analysis\_min\_parts\_to\_activate
Número mínimo de partes para activar el análisis distribuido de índices
## dynamic\_serialization\_version
Versión de serialización para el tipo de datos Dynamic. Necesaria para la compatibilidad.
Valores posibles:
* `v1`
* `v2`
* `v3`
## enable\_block\_number\_column
Habilita el almacenamiento de la columna \_block\_number para cada fila.
## enable\_block\_offset\_column
Guarda la columna virtual `_block_offset` durante las fusiones.
## enable\_index\_granularity\_compression
Comprime los valores en memoria de la granularidad del índice, si es posible
## enable\_max\_bytes\_limit\_for\_min\_age\_to\_force\_merge
Si las SETTINGS `min_age_to_force_merge_seconds` y
`min_age_to_force_merge_on_partition_only` deben respetar la SETTING
`max_bytes_to_merge_at_max_space_in_pool`.
Valores posibles:
* `true`
* `false`
## enable\_mixed\_granularity\_parts
Habilita o deshabilita la transición al control del tamaño del gránulo mediante la
configuración `index_granularity_bytes`. Antes de la versión 19.11, solo existía la
configuración `index_granularity` para restringir el tamaño del gránulo. La
configuración `index_granularity_bytes` mejora el rendimiento de ClickHouse al
seleccionar datos de tablas con filas grandes (decenas o cientos de megabytes).
Si tiene tablas con filas grandes, puede habilitar esta configuración en ellas
para mejorar la eficiencia de las consultas `SELECT`.
## enable\_replacing\_merge\_with\_cleanup\_for\_min\_age\_to\_force\_merge
Indica si se deben usar fusiones `CLEANUP` para ReplacingMergeTree al fusionar particiones
hasta reducirlas a una sola parte. Requiere que `allow_experimental_replacing_merge_with_cleanup`,
`min_age_to_force_merge_seconds` y `min_age_to_force_merge_on_partition_only`
estén habilitados.
Valores posibles:
* `true`
* `false`
## enable\_the\_endpoint\_id\_with\_zookeeper\_name\_prefix
Habilita el ID del endpoint con el prefijo de nombre de ZooKeeper para la
tabla MergeTree replicada.
## enable\_vertical\_merge\_algorithm
Activa el uso del algoritmo de fusión vertical.
## enforce\_index\_structure\_match\_on\_partition\_manipulation
Si esta SETTING está habilitada para la tabla de destino de una consulta de manipulación de particiones
(`ATTACH/MOVE/REPLACE PARTITION`), los índices y las proyecciones deben ser
idénticos entre la tabla de origen y la de destino. De lo contrario, la tabla de destino
puede tener un conjunto de índices y proyecciones que sea un superconjunto del de la tabla de origen.
## escape\_index\_filenames
Antes de la versión 26.1, no escapábamos los símbolos especiales en los nombres de archivo creados para índices secundarios, lo que podía provocar problemas, ya que algunos
caracteres en los nombres de los índices podían generar partes dañadas. Esto se añade únicamente por motivos de compatibilidad. No debe cambiarse a menos que
esté leyendo partes antiguas con índices que usan caracteres no ASCII en sus nombres.
## escape\_variant\_subcolumn\_filenames
Escapar los símbolos especiales en los nombres de archivo creados para las subcolumnas del tipo de datos Variant en partes Wide de la tabla MergeTree. Necesario para mantener la compatibilidad.
## exclude\_deleted\_rows\_for\_part\_size\_in\_merge
Si está habilitada, al seleccionar las partes que se van a fusionar se usará el tamaño real estimado de las partes de datos (es decir, excluyendo las filas
que se hayan eliminado mediante `DELETE FROM`). Tenga en cuenta que este comportamiento solo se activa para las partes de datos
afectadas por `DELETE FROM` ejecutado después de habilitar esta configuración.
Valores posibles:
* `true`
* `false`
**Véase también**
* [load\_existing\_rows\_count\_for\_old\_parts](#load_existing_rows_count_for_old_parts)
configuración
## exclude\_materialize\_skip\_indexes\_on\_merge
Excluye la lista proporcionada de índices de omisión, delimitada por comas, para que no se creen ni se almacenen durante las fusiones. No tiene efecto si
[materialize\_skip\_indexes\_on\_merge](#materialize_skip_indexes_on_merge) es false.
Los índices de omisión excluidos seguirán creándose y almacenándose mediante una
consulta [MATERIALIZE INDEX](/es/reference/statements/alter/skipping-index#materialize-index) explícita o durante los INSERT, según
la configuración de sesión [materialize\_skip\_indexes\_on\_insert](/es/reference/settings/session-settings#materialize_skip_indexes_on_insert).
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() SETTINGS exclude_materialize_skip_indexes_on_merge = 'idx_a';
INSERT INTO tab SELECT number, number / 50 FROM numbers(100); -- la configuración no tiene efecto en los INSERTs
-- idx_a será excluido de la actualización durante una fusión en segundo plano o explícita mediante OPTIMIZE TABLE FINAL
-- se pueden excluir múltiples índices proporcionando una lista
ALTER TABLE tab MODIFY SETTING exclude_materialize_skip_indexes_on_merge = 'idx_a, idx_b';
-- configuración predeterminada, ningún índice excluido de actualizarse durante la fusión
ALTER TABLE tab MODIFY SETTING exclude_materialize_skip_indexes_on_merge = '';
```
## execute\_merges\_on\_single\_replica\_time\_threshold
Cuando esta SETTING tiene un valor mayor que cero, solo una réplica inicia
la fusión de inmediato, y las demás esperan hasta ese tiempo para
descargar el resultado en lugar de realizar las fusiones localmente. Si la réplica elegida
no termina la fusión dentro de ese plazo, se aplica el comportamiento estándar.
Valores posibles:
* Cualquier entero positivo.
## fault\_probability\_after\_part\_commit
Para pruebas. No lo modifique.
## fault\_probability\_before\_part\_commit
Solo para pruebas. No lo cambie.
## finished\_mutations\_to\_keep
Cuántos registros sobre mutaciones ya realizadas se deben conservar. Si es cero, se conservan
todos.
## force\_read\_through\_cache\_for\_merges
Forzar la lectura mediante la caché del sistema de archivos para las fusiones
## fsync\_after\_insert
Ejecuta `fsync` en cada parte insertada. Reduce significativamente el rendimiento de las inserciones; no se recomienda usarlo con partes wide.
## fsync\_part\_directory
Realiza `fsync` en el directorio de la parte después de todas las operaciones de la parte (escrituras, renombrados, etc.).
## in\_memory\_parts\_enable\_wal
SETTING obsoleta; no tiene ningún efecto.
## in\_memory\_parts\_insert\_sync
SETTING obsoleta; no tiene efecto.
## inactive\_parts\_to\_delay\_insert
Si el número de partes inactivas en una sola partición de la tabla supera
el valor de `inactive_parts_to_delay_insert`, la operación `INSERT` se
ralentiza artificialmente.
Esto es útil cuando el servidor no consigue limpiar las partes con la suficiente rapidez.
Valores posibles:
* Cualquier entero positivo.
## inactive\_parts\_to\_throw\_insert
Si el número de partes inactivas en una sola partición supera el valor de
`inactive_parts_to_throw_insert`, `INSERT` se interrumpe con el
siguiente error:
> "Demasiadas partes inactivas (N). La limpieza de partes se está realizando de forma significativamente
> más lenta que los inserts" exception."
Valores posibles:
* Cualquier entero positivo.
## index\_granularity
Número máximo de filas de datos entre las marcas de un índice; es decir, cuántas filas
corresponden a un valor de clave primaria.
## index\_granularity\_bytes
Tamaño máximo de los gránulos de datos, en bytes.
Para restringir el tamaño del gránulo únicamente por el número de filas, establézcalo en `0` (no recomendado).
## initialization\_retry\_period
Período de reintento para la inicialización de la tabla, en segundos.
## kill\_delay\_period
Configuración obsoleta; no tiene efecto.
## kill\_delay\_period\_random\_add
Configuración obsoleta; no tiene ningún efecto.
## kill\_threads
Configuración obsoleta; no tiene ningún efecto.
## lightweight\_mutation\_projection\_mode
De forma predeterminada, la eliminación ligera `DELETE` no funciona en tablas con
proyecciones. Esto se debe a que una operación `DELETE` puede afectar a las
filas de una proyección. Por lo tanto, el valor predeterminado es `throw`. Sin
embargo, esta opción puede cambiar ese comportamiento. Con el valor `drop` o
`rebuild`, las eliminaciones funcionarán con proyecciones. `drop` eliminaría la
proyección, por lo que podría ser rápido en la consulta actual, ya que la
proyección se elimina, pero lento en consultas futuras, ya que no habría
ninguna proyección adjunta. `rebuild` reconstruiría la proyección, lo que
podría afectar al rendimiento de la consulta actual, pero podría acelerar las
consultas futuras. Lo bueno es que estas opciones solo funcionarían a nivel de
parte, lo que significa que las proyecciones de la parte que no se vean
afectadas permanecerían intactas en lugar de desencadenar alguna acción como
drop o rebuild.
Valores posibles:
* `throw`
* `drop`
* `rebuild`
## load\_existing\_rows\_count\_for\_old\_parts
Si se habilita junto con [exclude\_deleted\_rows\_for\_part\_size\_in\_merge](#exclude_deleted_rows_for_part_size_in_merge),
el recuento de filas eliminadas de las partes de datos existentes se calculará durante el
inicio de la tabla. Tenga en cuenta que esto puede ralentizar la carga de la tabla durante el inicio.
Valores posibles:
* `true`
* `false`
**Consulte también**
* La configuración [exclude\_deleted\_rows\_for\_part\_size\_in\_merge](#exclude_deleted_rows_for_part_size_in_merge)
## lock\_acquire\_timeout\_for\_background\_operations
Para operaciones en segundo plano como merges, mutaciones, etc. Indica cuántos segundos se espera antes de que falle la adquisición de bloqueos de tabla.
## map\_buckets\_coefficient
El coeficiente utilizado en [map\_buckets\_strategy](#map_buckets_strategy) `sqrt` y `linear` para calcular el número de buckets a partir del tamaño promedio del Map.
Para la estrategia `sqrt`: `round(map_buckets_coefficient * sqrt(avg_map_size))`.
Para la estrategia `linear`: `round(map_buckets_coefficient * avg_map_size)`.
Se ignora cuando `map_buckets_strategy` es `constant`.
## map\_buckets\_min\_avg\_size
El tamaño promedio mínimo de los Map (número de claves por fila) necesario para aplicar la serialización `with_buckets`.
Si el tamaño promedio de los Map es inferior a este valor, se usa un único bucket independientemente de las demás configuraciones de bucket.
Un valor de `0` desactiva el umbral y siempre aplica la estrategia de segmentación en buckets.
Esta configuración es útil para evitar la sobrecarga de la serialización en buckets en Map pequeños, donde el beneficio es insignificante.
## map\_buckets\_strategy
Controla la estrategia para seleccionar el número de buckets en la serialización `with_buckets` de `Map` según el tamaño promedio del mapa.
Valores posibles:
* constant — Usa siempre [max\_buckets\_in\_map](#max_buckets_in_map) como número de buckets, independientemente del tamaño promedio del mapa.
* sqrt — Usa `round(map_buckets_coefficient * sqrt(avg_map_size))` como número de buckets, limitado al intervalo `[1, max_buckets_in_map]`.
* linear — Usa `round(map_buckets_coefficient * avg_map_size)` como número de buckets, limitado al intervalo `[1, max_buckets_in_map]`.
## map\_serialization\_version
Controla el método de serialización usado para las columnas `Map`.
Valores posibles:
* basic — Usa la serialización estándar de `Map`.
* with\_buckets — Divide las claves en buckets durante la serialización. El uso de buckets mejora la lectura de claves individuales de Map.
El número de buckets en la serialización `with_buckets` viene determinado por [max\_buckets\_in\_map](#max_buckets_in_map) y [map\_buckets\_strategy](#map_buckets_strategy).
## map\_serialization\_version\_for\_zero\_level\_parts
Esta configuración permite especificar una versión de serialización distinta de las
columnas `Map` para las partes de nivel cero que se crean durante las inserciones.
Puede ser útil mantener la serialización `basic` en las partes de nivel cero para evitar
una degradación del rendimiento durante las inserciones, mientras se usa `with_buckets` en las partes fusionadas.
## marks\_compress\_block\_size
Tamaño del bloque de compresión de las marcas; es el tamaño real del bloque que se va a comprimir.
## marks\_compression\_codec
Codificación de compresión usada por las marks; como las marks son lo bastante pequeñas y están en caché, la compresión predeterminada es ZSTD(3).
## materialize\_skip\_indexes\_on\_merge
Si esta opción está habilitada, las fusiones crean y almacenan índices de omisión para las partes nuevas.
De lo contrario, pueden crearse o almacenarse mediante [MATERIALIZE INDEX](/es/reference/statements/alter/skipping-index#materialize-index)
o [durante los INSERTs](/es/reference/settings/session-settings#materialize_skip_indexes_on_insert).
Véase también [exclude\_materialize\_skip\_indexes\_on\_merge](#exclude_materialize_skip_indexes_on_merge) para un control más preciso.
## materialize\_statistics\_on\_merge
Si está habilitada, las fusiones generarán y almacenarán estadísticas para las nuevas partes.
De lo contrario, pueden crearse/almacenarse mediante [MATERIALIZE STATISTICS](/es/reference/statements/alter/statistics)
o [durante los INSERTs](/es/reference/settings/session-settings#materialize_statistics_on_insert)
## materialize\_ttl\_recalculate\_only
Recalcula la información de TTL solo al ejecutar MATERIALIZE TTL
## max\_avg\_part\_size\_for\_too\_many\_parts
La comprobación de 'too many parts' según 'parts\_to\_delay\_insert' y
'parts\_to\_throw\_insert' solo estará activa si el tamaño medio de las partes (en la
partición correspondiente) no supera el umbral especificado. Si lo supera,
los INSERTs no se retrasarán ni se rechazarán. Esto permite tener cientos de
terabytes en una sola tabla en un único servidor si las partes se fusionan
correctamente en partes más grandes. Esto no afecta a los umbrales de las
partes inactivas ni al número total de partes.
## max\_buckets\_in\_map
El número máximo de buckets para la serialización `Map`. Se aplica a la serialización `Map` `with_buckets`.
El número real de buckets lo determina [map\_buckets\_strategy](#map_buckets_strategy).
El valor máximo permitido es 256.
## max\_bytes\_to\_merge\_at\_max\_space\_in\_pool
El tamaño total máximo de las partes (en bytes) que se fusionarán en una sola parte, si hay
suficientes recursos disponibles. Corresponde aproximadamente al tamaño máximo posible de la
parte creada por una fusión automática en segundo plano. (0 significa que las fusiones se desactivarán)
Valores posibles:
* Cualquier entero no negativo.
El planificador de fusiones analiza periódicamente los tamaños y la cantidad de partes en las
particiones y, si hay suficientes recursos libres en el pool, inicia fusiones en segundo plano.
Las fusiones continúan hasta que el tamaño total de las partes de origen es
mayor que `max_bytes_to_merge_at_max_space_in_pool`.
Las fusiones iniciadas por [OPTIMIZE FINAL](/es/reference/statements/optimize)
ignoran `max_bytes_to_merge_at_max_space_in_pool` (solo se tiene en cuenta el espacio libre en disco).
## max\_bytes\_to\_merge\_at\_min\_space\_in\_pool
El tamaño total máximo de las partes (en bytes) que se fusionarán en una sola parte, con los
recursos mínimos disponibles en el background pool.
Valores posibles:
* Cualquier entero positivo.
`max_bytes_to_merge_at_min_space_in_pool` define el tamaño total máximo de las
partes que pueden fusionarse a pesar de la falta de espacio disponible en disco (en el pool).
Esto es necesario para reducir el número de partes pequeñas y la probabilidad de
errores `Too many parts`.
Las fusiones reservan espacio en disco duplicando el tamaño total de las partes fusionadas.
Por lo tanto, con una cantidad reducida de espacio libre en disco, puede darse una situación en la que
haya espacio libre, pero ese espacio ya esté reservado por grandes fusiones en curso,
por lo que otras fusiones no pueden iniciarse y el número de partes pequeñas aumenta
con cada inserción.
## max\_cleanup\_delay\_period
Período máximo para limpiar los logs antiguos de la cola, los hash de bloques y las partes.
## max\_compress\_block\_size
El tamaño máximo de los bloques de datos no comprimidos antes de comprimirlos para escribirlos
en una tabla. También puede especificar esta configuración en la configuración global
(consulte la configuración [max\_compress\_block\_size](/es/reference/settings/merge-tree-settings#max_compress_block_size)
). El valor especificado al crear la tabla sobrescribe el valor global
de esta configuración.
## max\_concurrent\_queries
Número máximo de consultas ejecutadas de forma simultánea relacionadas con la tabla MergeTree.
Las consultas seguirán estando limitadas por otras opciones de configuración de `max_concurrent_queries`.
Valores posibles:
* Entero positivo.
* `0` — Sin límite.
Valor predeterminado: `0` (sin límite).
**Ejemplo**
```xml theme={null}
50
```
## max\_delay\_to\_insert
Valor en segundos que se utiliza para calcular el retraso de `INSERT` si el
número de partes activas en una sola partición supera el
valor de [parts\_to\_delay\_insert](#parts_to_delay_insert).
Valores posibles:
* Cualquier entero positivo.
El retraso (en milisegundos) de `INSERT` se calcula con la fórmula:
```code theme={null}
max_k = parts_to_throw_insert - parts_to_delay_insert
k = 1 + parts_count_in_partition - parts_to_delay_insert
delay_milliseconds = pow(max_delay_to_insert * 1000, k / max_k)
```
Por ejemplo, si una partición tiene 299 partes activas y parts\_to\_throw\_insert
\= 300, parts\_to\_delay\_insert = 150, max\_delay\_to\_insert = 1, `INSERT` se
retrasa `pow( 1 * 1000, (1 + 299 - 150) / (300 - 150) ) = 1000`
milisegundos.
A partir de la versión 23.1, la fórmula se ha cambiado a:
```code theme={null}
allowed_parts_over_threshold = parts_to_throw_insert - parts_to_delay_insert
parts_over_threshold = parts_count_in_partition - parts_to_delay_insert + 1
delay_milliseconds = max(min_delay_to_insert_ms, (max_delay_to_insert * 1000)
* parts_over_threshold / allowed_parts_over_threshold)
```
Por ejemplo, si una partición tiene 224 partes activas y parts\_to\_throw\_insert
\= 300, parts\_to\_delay\_insert = 150, max\_delay\_to\_insert = 1,
min\_delay\_to\_insert\_ms = 10, `INSERT` se retrasa `max( 10, 1 * 1000 *
(224 - 150 + 1) / (300 - 150) ) = 500` milisegundos.
## max\_delay\_to\_mutate\_ms
Retraso máximo para mutar una tabla MergeTree en milisegundos, si hay muchas
mutaciones sin finalizar
## max\_digestion\_size\_per\_segment
Configuración obsoleta; no tiene ningún efecto.
## max\_file\_name\_length
La longitud máxima del nombre de archivo para conservarlo tal cual, sin aplicar un hash.
Solo surte efecto si la opción `replace_long_file_name_to_hash` está habilitada.
El valor de esta opción no incluye la longitud de la extensión del archivo. Por lo tanto,
se recomienda configurarlo por debajo de la longitud máxima del nombre de archivo (normalmente, 255
bytes), dejando cierto margen para evitar errores del sistema de archivos.
## max\_files\_to\_modify\_in\_alter\_columns
No aplique ALTER si el número de archivos que se van a modificar (eliminar o agregar)
es mayor que este ajuste.
Valores posibles:
* Cualquier entero positivo.
Valor predeterminado: 75
## max\_files\_to\_remove\_in\_alter\_columns
No se aplica ALTER si el número de archivos que se van a eliminar es mayor que esta
configuración.
Valores posibles:
* Cualquier entero positivo.
## max\_merge\_delayed\_streams\_for\_parallel\_write
El número máximo de flujos (columnas) que se pueden vaciar en paralelo
(equivalente a max\_insert\_delayed\_streams\_for\_parallel\_write para las fusiones). Funciona
solo para fusiones verticales.
## max\_merge\_selecting\_sleep\_ms
Tiempo máximo de espera antes de volver a intentar seleccionar partes para fusionarlas después de que no se haya
seleccionado ninguna. Un valor menor hará que las tareas de selección en
background\_schedule\_pool se activen con frecuencia, lo que genera una gran cantidad de
solicitudes a ZooKeeper en clústeres a gran escala
## max\_number\_of\_merges\_with\_ttl\_in\_pool
Cuando hay
más fusiones con entradas TTL en el pool de las especificadas, no se asignan
nuevas fusiones con TTL. Esto deja hilos libres para las fusiones normales y
evita "Too many parts"
## max\_number\_of\_mutations\_for\_replica
Limita el número de mutaciones de partes por réplica al valor especificado.
Cero significa que no hay límite en el número de mutaciones por réplica (la ejecución
puede seguir estando limitada por otros ajustes).
## max\_part\_loading\_threads
Configuración obsoleta; no tiene ningún efecto.
## max\_part\_removal\_threads
Configuración obsoleta; no tiene ningún efecto.
## max\_partitions\_to\_read
Limita el número máximo de particiones a las que se puede acceder en una consulta.
El valor de la configuración especificado al crear la tabla puede sobrescribirse con
una configuración a nivel de consulta.
Valores posibles:
* Cualquier entero positivo.
También puede especificar la configuración de complejidad de consulta [max\_partitions\_to\_read](/es/reference/settings/session-settings#max_partitions_to_read)
a nivel de consulta / sesión / perfil.
## max\_parts\_in\_total
Si el número total de partes activas en todas las particiones de una tabla supera el
valor de `max_parts_in_total`, la operación `INSERT` se interrumpe con la excepción `Too many parts
(N)`.
Valores posibles:
* Cualquier entero positivo.
Un gran número de partes en una tabla reduce el rendimiento de las consultas de ClickHouse
y aumenta el tiempo de inicio de ClickHouse. La mayoría de las veces, esto es consecuencia de un
diseño incorrecto (errores al elegir una estrategia de particionamiento: particiones demasiado pequeñas).
## max\_parts\_to\_merge\_at\_once
Cantidad máxima de partes que pueden fusionarse a la vez (0: deshabilitado). No afecta a la
consulta OPTIMIZE FINAL.
## max\_postpone\_time\_for\_failed\_mutations\_ms
El tiempo máximo de aplazamiento de las mutaciones fallidas.
## max\_postpone\_time\_for\_failed\_replicated\_fetches\_ms
El tiempo máximo de aplazamiento para los fetches replicados fallidos.
## max\_postpone\_time\_for\_failed\_replicated\_merges\_ms
El tiempo máximo de aplazamiento para las fusiones replicadas fallidas.
## max\_postpone\_time\_for\_failed\_replicated\_tasks\_ms
El tiempo máximo durante el que se pospone una tarea replicada fallida. Este valor se usa si la tarea no es de tipo fetch, merge o mutation.
## max\_projections
El número máximo de proyecciones de MergeTree.
## max\_replicated\_fetches\_network\_bandwidth
Limita la velocidad máxima del intercambio de datos por la red, en bytes por
segundo, para las descargas [replicadas](/es/reference/engines/table-engines/mergetree-family/replication).
Esta configuración se aplica a una tabla concreta, a diferencia de la
configuración [`max_replicated_fetches_network_bandwidth_for_server`](/es/reference/settings/merge-tree-settings#max_replicated_fetches_network_bandwidth),
que se aplica al servidor.
Puede limitar tanto la red del servidor como la de una tabla concreta, pero para
ello el valor de la configuración a nivel de tabla debe ser inferior al de
nivel de servidor. De lo contrario, el servidor solo tiene en cuenta la
configuración `max_replicated_fetches_network_bandwidth_for_server`.
La configuración no se aplica con total precisión.
Valores posibles:
* Entero positivo.
* `0` — Ilimitado.
Valor predeterminado: `0`.
**Uso**
Puede usarse para limitar la velocidad al replicar datos para añadir o sustituir
nuevos nodos.
## max\_replicated\_logs\_to\_keep
Cuántos registros puede haber en el log de ClickHouse Keeper si hay una
réplica inactiva. Una réplica inactiva se considera perdida cuando se supera este número.
Valores posibles:
* Cualquier entero positivo.
## max\_replicated\_merges\_in\_queue
Cuántas tareas de fusión y mutación de partes se permiten simultáneamente en la
cola de ReplicatedMergeTree.
## max\_replicated\_merges\_with\_ttl\_in\_queue
Número de tareas de fusión de partes con TTL que se permiten simultáneamente en la
cola de ReplicatedMergeTree.
## max\_replicated\_mutations\_in\_queue
Cuántas tareas sobre partes en mutación se permiten simultáneamente en la
cola de ReplicatedMergeTree.
## max\_replicated\_sends\_network\_bandwidth
Limita la velocidad máxima de intercambio de datos por la red, en bytes por
segundo, para los envíos [replicados](/es/reference/engines/table-engines/mergetree-family/replacingmergetree).
Esta configuración se aplica a una tabla concreta, a diferencia de la
configuración
[`max_replicated_sends_network_bandwidth_for_server`](/es/reference/settings/merge-tree-settings#max_replicated_sends_network_bandwidth),
que se aplica al servidor.
Puede limitar tanto el ancho de banda de red del servidor como el de una tabla concreta, pero
para ello el valor de la configuración a nivel de tabla debe ser menor que
el de la configuración a nivel de servidor. De lo contrario, el servidor solo tiene en cuenta la
configuración `max_replicated_sends_network_bandwidth_for_server`.
La configuración no se aplica con total precisión.
Valores posibles:
* Entero positivo.
* `0` — Ilimitado.
**Uso**
Puede usarse para limitar la velocidad al replicar datos para añadir o sustituir
nuevos nodos.
## max\_suspicious\_broken\_parts
Si el número de partes dañadas en una misma partición supera el valor de
`max_suspicious_broken_parts`, no se permite la eliminación automática.
Valores posibles:
* Cualquier entero positivo.
## max\_suspicious\_broken\_parts\_bytes
Tamaño máximo total de todas las partes dañadas; si se supera, se impide la eliminación automática.
Valores posibles:
* Cualquier entero positivo.
## max\_uncompressed\_bytes\_in\_patches
El tamaño máximo sin comprimir, en bytes, de los datos de todas las partes de parche.
Si la cantidad de datos en todas las partes de parche supera este valor, se rechazarán las actualizaciones ligeras.
0 - ilimitado.
## merge\_max\_block\_size
El número de filas que se leen de las partes fusionadas y se cargan en memoria.
Valores posibles:
* Cualquier entero positivo.
La fusión lee filas de las partes en bloques de `merge_max_block_size` filas y, a continuación,
fusiona y escribe el resultado en una parte nueva. El bloque leído se coloca en RAM,
por lo que `merge_max_block_size` afecta a la cantidad de RAM necesaria para la fusión.
Por lo tanto, las fusiones pueden consumir una gran cantidad de RAM en tablas con filas muy anchas
(si el tamaño medio de una fila es de 100kb, entonces, al fusionar 10 partes,
(100kb \* 10 \* 8192) = \~ 8GB de RAM). Al reducir `merge_max_block_size`,
puede reducir la cantidad de RAM necesaria para una fusión, pero también ralentizarla.
## merge\_max\_block\_size\_bytes
Cuántos bytes deben formarse en bloques para las operaciones de fusión. De forma predeterminada,
tiene el mismo valor que `index_granularity_bytes`.
## merge\_max\_bytes\_to\_prewarm\_cache
Solo disponible en ClickHouse Cloud. Tamaño máximo de una parte (compact o packed)
para precalentar la caché durante la fusión.
## merge\_max\_dynamic\_subcolumns\_in\_compact\_part
El número máximo de subcolumnas dinámicas que se pueden crear en cada columna de la parte de datos Compact tras la fusión.
Permite controlar el número de subcolumnas dinámicas en una parte Compact, independientemente de los parámetros dinámicos especificados en el tipo de dato.
Por ejemplo, si la tabla tiene una columna con el tipo JSON(max\_dynamic\_paths=1024) y la configuración merge\_max\_dynamic\_subcolumns\_in\_compact\_part está establecida en 128,
tras la fusión en la parte de datos Compact, el número de rutas dinámicas se reducirá a 128 en esta parte y solo se escribirán 128 rutas como subcolumnas dinámicas.
## merge\_max\_dynamic\_subcolumns\_in\_wide\_part
El número máximo de subcolumnas dinámicas que se pueden crear en cada columna de una parte de datos Wide después de la fusión.
Permite reducir el número de archivos creados en una parte de datos Wide, independientemente de los parámetros dinámicos especificados en el tipo de dato.
Por ejemplo, si la tabla tiene una columna con el tipo JSON(max\_dynamic\_paths=1024) y el ajuste merge\_max\_dynamic\_subcolumns\_in\_wide\_part está establecido en 128,
después de la fusión en la parte de datos Wide, el número de rutas dinámicas se reducirá a 128 en esa parte y solo se escribirán 128 rutas como subcolumnas dinámicas.
## merge\_selecting\_sleep\_ms
Tiempo mínimo de espera antes de volver a intentar seleccionar partes para fusionar cuando no se haya seleccionado ninguna
parte. Un valor más bajo activará con frecuencia las tareas de selección en
background\_schedule\_pool, lo que genera una gran cantidad de solicitudes
a ZooKeeper en clusters a gran escala
## merge\_selecting\_sleep\_slowdown\_factor
El tiempo de espera de la tarea de selección de fusiones se multiplica por este factor cuando
no hay nada que fusionar y se divide cuando se asigna una fusión
## merge\_selector\_algorithm
El algoritmo para seleccionar partes para la asignación de fusiones
## merge\_selector\_base
Afecta a la amplificación de escritura de las
fusiones asignadas (configuración de nivel experto; no la cambie si no entiende
lo que hace). Funciona con los selectores de fusiones Simple y StochasticSimple
## merge\_selector\_blurry\_base\_scale\_factor
Controla cuándo se activa esta lógica en relación con el número de partes de la
partición. Cuanto mayor sea el factor, más se retrasará la reacción.
## merge\_selector\_enable\_heuristic\_to\_lower\_max\_parts\_to\_merge\_at\_once
Habilita una heurística para el selector simple de fusiones que reducirá el límite máximo para la selección de fusiones.
Al hacerlo, aumentará el número de fusiones concurrentes, lo que puede ayudar con los errores
TOO\_MANY\_PARTS, pero al mismo tiempo incrementará la amplificación de escritura.
## merge\_selector\_enable\_heuristic\_to\_remove\_small\_parts\_at\_right
Habilita una heurística para seleccionar partes para la fusión que elimina las partes del lado derecho
del rango si su tamaño es inferior a la proporción especificada (0.01) de sum\_size.
Funciona con los selectores de fusiones Simple y StochasticSimple
## merge\_selector\_heuristic\_to\_lower\_max\_parts\_to\_merge\_at\_once\_exponent
Controla el valor del exponente utilizado en las fórmulas que construyen la curva de reducción. Reducir el exponente
disminuirá la amplitud de las fusiones, lo que provocará un aumento de la amplificación de escritura. Lo contrario también es cierto.
## merge\_selector\_window\_size
Cuántas partes se examinan a la vez.
## merge\_total\_max\_bytes\_to\_prewarm\_cache
Solo disponible en ClickHouse Cloud. Tamaño máximo total de las partes que se usarán para precalentar la
caché durante la fusión.
## merge\_tree\_clear\_old\_broken\_detached\_parts\_ttl\_timeout\_seconds
Configuración obsoleta; no hace nada.
## merge\_tree\_clear\_old\_parts\_interval\_seconds
Establece el intervalo, en segundos, para que ClickHouse ejecute la limpieza de
partes, WAL y mutaciones antiguas.
Valores posibles:
* Cualquier entero positivo.
## merge\_tree\_clear\_old\_temporary\_directories\_interval\_seconds
Establece el intervalo, en segundos, para que ClickHouse ejecute la limpieza de
directorios temporales antiguos.
Valores posibles:
* Cualquier número entero positivo.
## merge\_tree\_enable\_clear\_old\_broken\_detached
Configuración obsoleta; no hace nada.
## merge\_with\_recompression\_ttl\_timeout
Retraso mínimo, en segundos, antes de repetir una fusión con TTL de recompresión.
## merge\_with\_ttl\_timeout
Retraso mínimo en segundos antes de repetir una fusión con TTL de eliminación.
## merge\_workload
Se utiliza para regular cómo se usan y comparten los recursos entre las fusiones y
otras cargas de trabajo. El valor especificado se usa como valor de la configuración `workload` para las
fusiones en segundo plano de esta tabla. Si no se especifica (cadena vacía), se utiliza
en su lugar la configuración del servidor `merge_workload`.
**Véase también**
* [Planificación de cargas de trabajo](/es/concepts/features/configuration/server-config/workload-scheduling)
## min\_absolute\_delay\_to\_close
Retraso absoluto mínimo para cerrar, dejar de atender peticiones y no
devolver Ok durante la comprobación de estado.
## min\_age\_to\_force\_merge\_on\_partition\_only
Indica si `min_age_to_force_merge_seconds` debe aplicarse solo a la
partición completa y no a un subconjunto.
De forma predeterminada, ignora la configuración `max_bytes_to_merge_at_max_space_in_pool` (consulte
`enable_max_bytes_limit_for_min_age_to_force_merge`).
Valores posibles:
* true, false
## min\_age\_to\_force\_merge\_seconds
Fusiona las partes si todas las partes del intervalo son más antiguas que el valor de
`min_age_to_force_merge_seconds`.
De forma predeterminada, ignora la configuración `max_bytes_to_merge_at_max_space_in_pool`
(consulte `enable_max_bytes_limit_for_min_age_to_force_merge`).
Valores posibles:
* Entero positivo.
## min\_bytes\_for\_compact\_part
Configuración obsoleta; no hace nada.
## min\_bytes\_for\_full\_part\_storage
Solo disponible en ClickHouse Cloud. Tamaño mínimo sin comprimir, en bytes, para
usar el tipo de almacenamiento full para la data part en lugar de packed
## min\_bytes\_for\_wide\_part
Número mínimo de bytes/filas en una parte de datos que puede almacenarse en formato `Wide`. Puede establecer uno, ambos o ninguno de estos ajustes.
## min\_bytes\_to\_prewarm\_caches
Tamaño mínimo (en bytes sin comprimir) para precalentar la caché de marcas y la caché del índice primario
para las nuevas partes
## min\_bytes\_to\_rebalance\_partition\_over\_jbod
Establece la cantidad mínima de bytes necesaria para habilitar el equilibrio al distribuir nuevas
partes grandes entre los discos del volumen [JBOD](https://en.wikipedia.org/wiki/Non-RAID_drive_architectures).
Valores posibles:
* Entero positivo.
* `0` — El equilibrio está deshabilitado.
**Uso**
El valor de la configuración `min_bytes_to_rebalance_partition_over_jbod` no debe
ser inferior al valor de
[max\_bytes\_to\_merge\_at\_max\_space\_in\_pool](/es/reference/settings/merge-tree-settings#max_bytes_to_merge_at_max_space_in_pool)
/ 1024. De lo contrario, ClickHouse genera una excepción.
## min\_columns\_to\_activate\_adaptive\_write\_buffer
Permite reducir el uso de memoria en tablas con muchas columnas mediante búferes de escritura adaptativos.
Valores posibles:
* 0 - ilimitado
* 1 - siempre habilitado
## min\_compress\_block\_size
Tamaño mínimo de los bloques de datos sin comprimir necesario para aplicar la compresión al
escribir la siguiente marca. También puede especificar esta configuración en la configuración global
(consulte la configuración
[min\_compress\_block\_size](/es/reference/settings/merge-tree-settings#min_compress_block_size)).
El valor especificado al crear la tabla sobrescribe el valor global
de esta configuración.
## min\_compressed\_bytes\_to\_fsync\_after\_fetch
Número mínimo de bytes comprimidos para realizar `fsync` en la parte tras recuperarla (0: deshabilitado)
## min\_compressed\_bytes\_to\_fsync\_after\_merge
Número mínimo de bytes comprimidos para ejecutar fsync en la parte tras la fusión (0: deshabilitado)
## min\_delay\_to\_insert\_ms
Retraso mínimo para insertar datos en una tabla MergeTree, en milisegundos, si hay
muchas partes sin fusionar en una sola partición.
## min\_delay\_to\_mutate\_ms
Retraso mínimo para aplicar mutaciones a una tabla MergeTree en milisegundos, si hay muchas
mutaciones sin finalizar
## min\_free\_disk\_bytes\_to\_perform\_insert
El número mínimo de bytes que deben estar libres en el disco para poder
insertar datos. Si el número de bytes libres disponibles es menor que
`min_free_disk_bytes_to_perform_insert`, se genera una excepción y la
inserción no se ejecuta. Tenga en cuenta que este ajuste:
* tiene en cuenta el ajuste `keep_free_space_bytes`.
* no tiene en cuenta la cantidad de datos que se escribirán mediante la
operación `INSERT`.
* solo se comprueba si se especifica un número positivo (distinto de cero) de bytes
Valores posibles:
* Cualquier entero positivo.
Si se especifican tanto `min_free_disk_bytes_to_perform_insert` como `min_free_disk_ratio_to_perform_insert`,
ClickHouse tomará el valor que permita realizar
inserts con una mayor cantidad de espacio libre.
## min\_free\_disk\_ratio\_to\_perform\_insert
La proporción mínima de espacio libre con respecto al espacio total en disco para realizar un `INSERT`. Debe ser un
valor de coma flotante entre 0 y 1. Tenga en cuenta que este ajuste:
* tiene en cuenta el ajuste `keep_free_space_bytes`.
* no tiene en cuenta la cantidad de datos que se escribirán mediante la
operación `INSERT`.
* solo se comprueba si se especifica una proporción positiva (distinta de cero)
Valores posibles:
* Float, 0.0 - 1.0
Tenga en cuenta que, si se especifican tanto `min_free_disk_ratio_to_perform_insert` como
`min_free_disk_bytes_to_perform_insert`, ClickHouse se basará
en el valor que permita realizar inserciones con una mayor cantidad de
espacio libre en disco.
## min\_index\_granularity\_bytes
Tamaño mínimo permitido de los gránulos de datos en bytes.
Sirve como protección para evitar la creación accidental de tablas con un valor muy bajo de
`index_granularity_bytes`.
## min\_level\_for\_full\_part\_storage
Solo disponible en ClickHouse Cloud. Nivel mínimo de la parte para
usar el tipo de almacenamiento completo para la parte de datos en lugar de empaquetado
## min\_level\_for\_wide\_part
Nivel mínimo de la parte para crear una parte de datos en formato `Wide` en lugar de `Compact`.
## min\_marks\_to\_honor\_max\_concurrent\_queries
El número mínimo de marcas que debe leer la consulta para aplicar la configuración [max\_concurrent\_queries](#max_concurrent_queries).
Las consultas seguirán estando limitadas por otras configuraciones de `max_concurrent_queries`.
Valores posibles:
* Entero positivo.
* `0` — Deshabilitado (el límite de `max_concurrent_queries` no se aplica a ninguna consulta).
**Ejemplo**
```xml theme={null}
10
```
## min\_merge\_bytes\_to\_use\_direct\_io
El volumen mínimo de datos de una operación de fusión necesario para usar
acceso de E/S directa al disco de almacenamiento. Al fusionar partes de datos, ClickHouse calcula
el volumen total de almacenamiento de todos los datos que se van a fusionar. Si el volumen supera
`min_merge_bytes_to_use_direct_io` bytes, ClickHouse lee y escribe los
datos en el disco de almacenamiento mediante la interfaz de E/S directa (opción `O_DIRECT`).
Si `min_merge_bytes_to_use_direct_io = 0`, la E/S directa se desactiva.
## min\_parts\_to\_merge\_at\_once
Cantidad mínima de partes de datos que el selector de fusiones puede seleccionar para fusionar de una sola vez
(configuración para expertos; no la cambie si no entiende qué hace).
0: deshabilitado. Funciona con los selectores de fusiones Simple y StochasticSimple.
## min\_relative\_delay\_to\_close
Retraso mínimo con respecto a otras réplicas para cerrarse, dejar de atender
solicitudes y no devolver Ok durante la comprobación de estado.
## min\_relative\_delay\_to\_measure
Calcula el retraso relativo de la réplica solo si el retraso absoluto no es inferior a
este valor.
## min\_relative\_delay\_to\_yield\_leadership
Configuración obsoleta; no tiene ningún efecto.
## min\_replicated\_logs\_to\_keep
Mantiene aproximadamente este número de los últimos registros en el log de ZooKeeper, aunque estén
obsoletos. No afecta al funcionamiento de las tablas: se usa solo para diagnosticar el
log de ZooKeeper antes de la limpieza.
Valores posibles:
* Cualquier entero positivo.
## min\_rows\_for\_compact\_part
Configuración obsoleta; no tiene efecto.
## min\_rows\_for\_full\_part\_storage
Solo disponible en ClickHouse Cloud. Número mínimo de filas para usar el tipo de almacenamiento completo
para la parte de datos en lugar del almacenamiento empaquetado
## min\_rows\_for\_wide\_part
Número mínimo de filas para crear una parte de datos en formato `Wide` en vez de `Compact`.
## min\_rows\_to\_fsync\_after\_merge
Número mínimo de filas para ejecutar fsync en la parte tras la fusión (0: deshabilitado)
## mutation\_workload
Se utiliza para regular cómo se utilizan y comparten los recursos entre las mutaciones y
otras cargas de trabajo. El valor especificado se usa como valor de la configuración `workload` para las
mutaciones en segundo plano de esta tabla. Si no se especifica (cadena vacía),
se usa en su lugar la configuración del servidor `mutation_workload`.
**Véase también**
* [Planificación de cargas de trabajo](/es/concepts/features/configuration/server-config/workload-scheduling)
## non\_replicated\_deduplication\_window
El número de bloques insertados más recientemente en la tabla
[MergeTree](/es/reference/engines/table-engines/mergetree-family/mergetree) no replicada
cuyas sumas de hash se almacenan para comprobar si hay duplicados.
Posibles valores:
* Cualquier entero positivo.
* `0` (desactiva la deduplicación).
Se utiliza un mecanismo de deduplicación similar al de las tablas replicadas (consulte la
configuración [replicated\_deduplication\_window](#replicated_deduplication_window)).
Las sumas de hash de las partes creadas se escriben en un archivo local en disco.
## notify\_newest\_block\_number
Notifica el número del bloque más reciente a SharedJoin o SharedSet. Solo en ClickHouse Cloud.
## nullable\_serialization\_version
Controla el método de serialización que se usa para las columnas `Nullable(T)`.
Valores posibles:
* basic — Usa la serialización estándar para `Nullable(T)`.
* allow\_sparse — Permite que `Nullable(T)` use codificación dispersa.
## number\_of\_free\_entries\_in\_pool\_to\_execute\_mutation
Cuando el número de entradas libres en el pool es inferior al especificado, no
ejecute mutaciones de partes. Esto permite dejar hilos libres para las fusiones normales y
evitar errores de "Too many parts".
Valores posibles:
* Cualquier entero positivo.
**Uso**
El valor de la configuración `number_of_free_entries_in_pool_to_execute_mutation`
debe ser menor que el valor de [background\_pool\_size](/es/reference/settings/server-settings/settings#background_pool_size)
* [background\_merges\_mutations\_concurrency\_ratio](/es/reference/settings/server-settings/settings#background_merges_mutations_concurrency_ratio).
De lo contrario, ClickHouse lanzará una excepción.
## number\_of\_free\_entries\_in\_pool\_to\_execute\_optimize\_entire\_partition
Cuando hay menos entradas libres en el pool que el número especificado, no
ejecute la optimización de la partición completa en segundo plano (esta tarea se genera
cuando se establece `min_age_to_force_merge_seconds` y se habilita
`min_age_to_force_merge_on_partition_only`). Esto permite dejar hilos libres
para las fusiones normales y evitar "Too many parts".
Valores posibles:
* Entero positivo.
El valor de la configuración `number_of_free_entries_in_pool_to_execute_optimize_entire_partition`
debe ser menor que el valor de
[background\_pool\_size](/es/reference/settings/server-settings/settings#background_pool_size)
* [background\_merges\_mutations\_concurrency\_ratio](/es/reference/settings/server-settings/settings#background_merges_mutations_concurrency_ratio).
De lo contrario, ClickHouse genera una excepción.
## number\_of\_free\_entries\_in\_pool\_to\_lower\_max\_size\_of\_merge
Cuando haya menos del número especificado de entradas libres en el pool
(o en la cola replicada), se comenzará a reducir el tamaño máximo de la fusión que se va a procesar
(o a poner en la cola).
Esto permite procesar fusiones pequeñas, sin llenar el pool con fusiones
de larga duración.
Valores posibles:
* Cualquier entero positivo.
## number\_of\_mutations\_to\_delay
Si la tabla tiene al menos
esa cantidad de mutaciones sin finalizar, ralentiza artificialmente las mutaciones de la tabla.
Se deshabilita si se establece en 0
## number\_of\_mutations\_to\_throw
Si la tabla tiene al menos esa cantidad de mutaciones sin finalizar, genera la excepción 'Too many mutations'
. Se desactiva si se establece en 0
## number\_of\_partitions\_to\_consider\_for\_merge
Solo disponible en ClickHouse Cloud. Como máximo, las N particiones principales que se
tendrán en cuenta para la fusión. Las particiones se eligen de forma aleatoria y ponderada, donde el peso
es la cantidad de partes de datos que pueden fusionarse en esa partición.
## object\_serialization\_version
Versión de serialización para el tipo de datos JSON. Necesaria para la compatibilidad.
Posibles valores:
* `v1`
* `v2`
* `v3`
Solo la versión `v3` permite cambiar la versión de serialización de los datos compartidos.
## object\_shared\_data\_buckets\_for\_compact\_part
El número de buckets para la serialización de datos compartidos en JSON en partes compactas. Funciona con las serializaciones de datos compartidos `map_with_buckets` y `advanced`.
El valor máximo permitido es 256.
## object\_shared\_data\_buckets\_for\_wide\_part
Número de buckets para la serialización de datos compartidos en JSON en partes Wide. Funciona con las serializaciones de datos compartidos `map_with_buckets` y `advanced`.
El valor máximo permitido es 256.
## object\_shared\_data\_serialization\_version
Versión de serialización de los datos compartidos dentro del tipo de datos JSON.
Valores posibles:
* `map` - almacena los datos compartidos como `Map(String, String)`
* `map_with_buckets` - almacena los datos compartidos como varias columnas `Map(String, String)` separadas. El uso de buckets mejora la lectura de rutas individuales a partir de los datos compartidos.
* `advanced` - serialización especial de datos compartidos diseñada para mejorar significativamente la lectura de rutas individuales a partir de los datos compartidos.
Ten en cuenta que esta serialización aumenta el tamaño de almacenamiento en disco de los datos compartidos porque almacenamos mucha información adicional.
El número de buckets para las serializaciones `map_with_buckets` y `advanced` se determina mediante los ajustes
[object\_shared\_data\_buckets\_for\_compact\_part](#object_shared_data_buckets_for_compact_part)/[object\_shared\_data\_buckets\_for\_wide\_part](#object_shared_data_buckets_for_wide_part).
## object\_shared\_data\_serialization\_version\_for\_zero\_level\_parts
Esta configuración permite especificar una versión de serialización distinta para los
datos compartidos dentro del tipo JSON en las partes de nivel cero que se crean durante las inserciones.
Se recomienda no usar la serialización de datos compartidos `advanced` para las partes de nivel cero, ya que puede aumentar
significativamente el tiempo de inserción.
## old\_parts\_lifetime
Tiempo de almacenamiento (en segundos) de las partes inactivas para proteger contra la pérdida de datos
durante reinicios inesperados del servidor.
Valores posibles:
* Cualquier entero positivo.
Después de fusionar varias partes en una nueva, ClickHouse marca las partes originales
como inactivas y las elimina solo después de `old_parts_lifetime` segundos.
Las partes inactivas se eliminan si no están siendo utilizadas por las consultas actuales, es decir, si
el `refcount` de la parte es 1.
No se llama a `fsync` para las partes nuevas, por lo que durante algún tiempo las partes nuevas existen solo
en la RAM del servidor (caché del SO). Si el servidor se reinicia inesperadamente, las partes nuevas
pueden perderse o dañarse. Para proteger los datos, las partes inactivas no se eliminan
de inmediato.
Durante el inicio, ClickHouse comprueba la integridad de las partes. Si la
parte fusionada está dañada, ClickHouse devuelve las partes inactivas a la lista de partes activas
y, más tarde, vuelve a fusionarlas. Luego, la parte dañada se renombra (se añade el
prefijo `broken_`) y se mueve a la carpeta `detached`. Si la parte fusionada no
está dañada, entonces las partes inactivas originales se renombran (se añade el prefijo
`ignored_`) y se mueven a la carpeta `detached`.
El valor predeterminado de `dirty_expire_centisecs` (una configuración del kernel de Linux) es de 30
segundos (el tiempo máximo durante el cual los datos escritos se almacenan solo en RAM), pero con
cargas elevadas en el sistema de disco, los datos pueden escribirse mucho más tarde. Experimentalmente,
se eligió un valor de 480 segundos para `old_parts_lifetime`, durante el cual se
garantiza que una parte nueva se escribirá en disco.
## optimize\_row\_order
Controla si el orden de las filas debe optimizarse durante las inserciones para mejorar la
compresibilidad de la parte de tabla recién insertada.
Solo tiene efecto en tablas ordinarias del motor MergeTree. No hace nada en
tablas especializadas del motor MergeTree (p. ej., CollapsingMergeTree).
Las tablas MergeTree se comprimen (opcionalmente) usando [códecs de compresión](/es/reference/statements/create/table#column_compression_codec).
Los códecs de compresión genéricos, como LZ4 y ZSTD, alcanzan tasas máximas de compresión
si los datos presentan patrones. Las secuencias largas del mismo valor normalmente
se comprimen muy bien.
Si esta configuración está habilitada, ClickHouse intenta almacenar los datos en las
partes recién insertadas en un orden de filas que minimice el número de secuencias de valores iguales
a lo largo de las columnas de la nueva parte de tabla.
En otras palabras, un número reducido de secuencias de valores iguales significa que las secuencias individuales
son largas y se comprimen bien.
Encontrar el orden óptimo de las filas es computacionalmente inviable (NP-hard).
Por lo tanto, ClickHouse usa una heurística para encontrar rápidamente un orden de filas que
aun así mejore las tasas de compresión con respecto al orden original de las filas.
Heurística para encontrar un orden de filas
En general, es posible reordenar libremente las filas de una tabla (o parte de tabla),
ya que SQL considera equivalente la misma tabla (parte de tabla) con un orden de filas diferente.
Esta libertad para reordenar filas se restringe cuando se define una clave primaria
para la tabla. En ClickHouse, una clave primaria `C1, C2, ..., CN` impone que
las filas de la tabla estén ordenadas por las columnas `C1`, `C2`, ... `Cn` ([índice agrupado](https://en.wikipedia.org/wiki/Database_index#Clustered)).
Como resultado, las filas solo pueden reordenarse dentro de "clases de equivalencia" de filas,
es decir, filas que tienen los mismos valores en sus columnas de clave primaria.
La idea es que las claves primarias con alta cardinalidad, por ejemplo, claves primarias
que incluyen una columna timestamp `DateTime64`, dan lugar a muchas clases de equivalencia
pequeñas. Del mismo modo, las tablas con una clave primaria de baja cardinalidad crean pocas
clases de equivalencia, pero grandes. Una tabla sin clave primaria representa el caso extremo
de una única clase de equivalencia que abarca todas las filas.
Cuanto menos numerosas y más grandes sean las clases de equivalencia, mayor será el grado
de libertad al reordenar filas.
La heurística aplicada para encontrar el mejor orden de filas dentro de cada clase de equivalencia
es la sugerida por D. Lemire y O. Kaser en
[Reordering columns for smaller indexes](https://doi.org/10.1016/j.ins.2011.02.002)
y se basa en ordenar las filas dentro de cada clase de equivalencia por cardinalidad
ascendente de las columnas que no forman parte de la clave primaria.
Consta de tres pasos:
1. Encontrar todas las clases de equivalencia basadas en los valores de las filas en las columnas de clave primaria.
2. Para cada clase de equivalencia, calcular (normalmente estimar) las cardinalidades
de las columnas que no forman parte de la clave primaria.
3. Para cada clase de equivalencia, ordenar las filas en orden ascendente de
cardinalidad de las columnas que no forman parte de la clave primaria.
Si está habilitada, las operaciones de inserción incurren en costos adicionales de CPU para analizar y
optimizar el orden de las filas de los nuevos datos. Se espera que los INSERT tarden entre un 30 y un 50 %
más, según las características de los datos.
Las tasas de compresión de LZ4 o ZSTD mejoran en promedio entre un 20 y un 40 %.
Esta configuración funciona mejor en tablas sin clave primaria o con una clave primaria de baja cardinalidad,
es decir, una tabla con solo unos pocos valores distintos de clave primaria.
No se espera que las claves primarias de alta cardinalidad, por ejemplo, las que incluyen columnas timestamp de tipo
`DateTime64`, se beneficien de esta configuración.
## part\_minmax\_index\_columns
Selecciona qué columnas cubre el índice min-max de cada parte. Cada valor habilita un grupo adicional de columnas sobre el anterior.
Posibles valores:
* `partition_key_only` — solo se registran las columnas de la clave de partición.
* `with_block_number_offset` — columnas de la clave de partición, además de las columnas virtuales persistidas `_block_number` y `_block_offset`. Habilita la poda a nivel de parte mediante estas columnas.
## part\_moves\_between\_shards\_delay\_seconds
Tiempo de espera antes y después de mover partes entre segmentos.
## part\_moves\_between\_shards\_enable
Funcionalidad experimental/incompleta para mover partes entre segmentos. No tiene
en cuenta las expresiones de sharding.
## parts\_to\_delay\_insert
Si el número de partes activas en una sola partición supera el valor de
`parts_to_delay_insert`, una operación `INSERT` se ralentiza artificialmente.
Valores posibles:
* Cualquier entero positivo.
ClickHouse hace que `INSERT` tarde más en ejecutarse de forma artificial (añade "sleep") para que el
proceso de fusión en segundo plano pueda fusionar las partes más rápido de lo que se añaden.
## parts\_to\_throw\_insert
Si el número de partes activas en una única partición supera el valor de
`parts_to_throw_insert`, `INSERT` se interrumpe con la excepción `Too many
parts (N). Merges are processing significantly slower than inserts`.
Valores posibles:
* Cualquier entero positivo.
Para lograr el máximo rendimiento de las consultas `SELECT`, es necesario
minimizar el número de partes procesadas; consulte [Merge Tree](/es/resources/develop-contribute/introduction/architecture#merge-tree).
Antes de la versión 23.6, esta configuración estaba establecida en 300. Puede establecer un valor
más alto; esto reducirá la probabilidad del error `Too many parts`, pero al
mismo tiempo el rendimiento de `SELECT` podría verse afectado. Además, en caso
de que haya un problema con las fusiones (por ejemplo, por falta de espacio en
disco), lo notará más tarde que con el valor original de 300.
## prefer\_fetch\_merged\_part\_size\_threshold
Si la suma de los tamaños de las partes supera este umbral y el tiempo transcurrido desde la
creación de una entrada en el registro de replicación es mayor que
`prefer_fetch_merged_part_time_threshold`, se prioriza obtener la parte fusionada
desde una réplica en lugar de realizar la fusión localmente. Esto acelera las
fusiones muy largas.
Valores posibles:
* Cualquier entero positivo.
## prefer\_fetch\_merged\_part\_time\_threshold
Si el tiempo transcurrido desde la creación de una entrada en el registro de replicación (ClickHouse Keeper o ZooKeeper)
supera este umbral y la suma del tamaño de las partes es
mayor que `prefer_fetch_merged_part_size_threshold`, se prefiere obtener la
parte fusionada desde una réplica en lugar de realizar la fusión localmente. Esto sirve para acelerar
fusiones muy largas.
Valores posibles:
* Cualquier entero positivo.
## prewarm\_mark\_cache
Si es true, la caché de marcas se
precalentará guardando marks en la caché de marcas durante inserts, merges, fetches y
al iniciar el servidor
## prewarm\_primary\_key\_cache
Si se establece en true, la caché del índice primario
se precargará guardando marcas en la caché de marcas durante las inserciones, las fusiones,
los fetches y al iniciar el servidor
## primary\_key\_compress\_block\_size
Tamaño del bloque de compresión de la clave primaria; es el tamaño real del bloque que se va a comprimir.
## primary\_key\_compression\_codec
La codificación de compresión utilizada por la clave primaria; la clave primaria es lo suficientemente pequeña y está en caché,
por lo que la compresión predeterminada es ZSTD(3).
## primary\_key\_lazy\_load
Carga la clave primaria en memoria en el
primer uso en lugar de hacerlo durante la inicialización de la tabla. Esto puede ahorrar memoria cuando hay
una gran cantidad de tablas.
## primary\_key\_ratio\_of\_unique\_prefix\_values\_to\_skip\_suffix\_columns
Si el valor de una columna de la clave primaria en una parte de datos cambia al menos con esta frecuencia, se omite la carga en memoria de las siguientes columnas. Esto permite ahorrar memoria al no cargar columnas inútiles de la clave primaria.
## propagate\_types\_serialization\_versions\_to\_nested\_types
Si es true, las versiones de serialización como string\_serialization\_version se propagarán a los tipos anidados como Array/Map/Nullable/JSON/etc. Si está deshabilitado, la versión de serialización solo surtirá efecto en las columnas de nivel superior de este tipo y Tuple el
## ratio\_of\_defaults\_for\_sparse\_serialization
Proporción mínima entre la cantidad de valores *por defecto* y la cantidad total de valores
en una columna. Al establecer este valor, la columna se almacena usando serializaciones
dispersas.
Si una columna es dispersa (contiene principalmente ceros), ClickHouse puede codificarla en
un formato disperso y optimizar automáticamente los cálculos; los datos no
requieren una descompresión completa durante las consultas. Para habilitar esta serialización
dispersa, defina la configuración `ratio_of_defaults_for_sparse_serialization`
con un valor inferior a 1.0. Si el valor es mayor o igual que 1.0,
las columnas siempre se escribirán usando la serialización completa normal.
Valores posibles:
* Float entre `0` y `1` para habilitar la serialización dispersa
* `1.0` (o mayor) si no desea usar la serialización dispersa
**Ejemplo**
Observe que la columna `s` de la siguiente tabla es una cadena vacía en el 95 % de
las filas. En `my_regular_table` no usamos serialización dispersa, y en
`my_sparse_table` establecemos `ratio_of_defaults_for_sparse_serialization` en
0.95:
```sql theme={null}
CREATE TABLE my_regular_table
(
`id` UInt64,
`s` String
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO my_regular_table
SELECT
number AS id,
number % 20 = 0 ? toString(number): '' AS s
FROM
numbers(10000000);
CREATE TABLE my_sparse_table
(
`id` UInt64,
`s` String
)
ENGINE = MergeTree
ORDER BY id
SETTINGS ratio_of_defaults_for_sparse_serialization = 0.95;
INSERT INTO my_sparse_table
SELECT
number,
number % 20 = 0 ? toString(number): ''
FROM
numbers(10000000);
```
Observe que la columna `s` de `my_sparse_table` ocupa menos espacio en disco:
```sql theme={null}
SELECT table, name, data_compressed_bytes, data_uncompressed_bytes FROM system.columns
WHERE table LIKE 'my_%_table';
```
```response theme={null}
┌─table────────────┬─name─┬─data_compressed_bytes─┬─data_uncompressed_bytes─┐
│ my_regular_table │ id │ 37790741 │ 75488328 │
│ my_regular_table │ s │ 2451377 │ 12683106 │
│ my_sparse_table │ id │ 37790741 │ 75488328 │
│ my_sparse_table │ s │ 2283454 │ 9855751 │
└──────────────────┴──────┴───────────────────────┴─────────────────────────┘
```
Puede verificar si una columna usa la codificación dispersa consultando la
columna `serialization_kind` de la tabla `system.parts_columns`:
```sql theme={null}
SELECT column, serialization_kind FROM system.parts_columns
WHERE table LIKE 'my_sparse_table';
```
Puedes ver qué partes de `s` se almacenaron mediante la serialización dispersa:
```response theme={null}
┌─column─┬─serialization_kind─┐
│ id │ Default │
│ s │ Default │
│ id │ Default │
│ s │ Default │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
│ id │ Default │
│ s │ Sparse │
└────────┴────────────────────┘
```
## reduce\_blocking\_parts\_sleep\_ms
Solo disponible en ClickHouse Cloud. Tiempo mínimo de espera antes de intentar
reducir de nuevo las partes bloqueantes después de que no se haya descartado ni sustituido ningún rango. Un valor más bajo
activará tareas en background\_schedule\_pool con frecuencia, lo que
da como resultado una gran cantidad de solicitudes a ZooKeeper en clústeres a gran escala
## refresh\_parts\_interval
Si es mayor que cero, actualiza la lista de partes de datos desde el sistema de archivos subyacente para comprobar si los datos se han actualizado internamente.
Solo se puede establecer si la tabla está ubicada en discos de solo lectura (lo que significa que se trata de una réplica de solo lectura, mientras que otra réplica está escribiendo los datos).
## refresh\_statistics\_interval
Intervalo de actualización de la caché de estadísticas, en segundos. Si se establece en cero, se deshabilita la actualización.
## remote\_fs\_execute\_merges\_on\_single\_replica\_time\_threshold
Cuando esta configuración tiene un valor mayor que cero, solo una réplica inicia
la fusión inmediatamente si la parte fusionada está en el almacenamiento compartido.
La replicación zero-copy no está lista para producción.
La replicación zero-copy está deshabilitada de forma predeterminada en la versión 22.8 de ClickHouse y
posteriores.
Esta funcionalidad no se recomienda para su uso en producción.
Valores posibles:
* Cualquier entero positivo.
## remote\_fs\_zero\_copy\_path\_compatible\_mode
Ejecuta zero-copy en modo de compatibilidad durante el proceso de conversión.
## remote\_fs\_zero\_copy\_zookeeper\_path
Ruta de ZooKeeper para la información de zero-copy independiente de la tabla.
## remove\_empty\_parts
Elimina las partes vacías después de que TTL, una mutación o el algoritmo de fusión por collapsing las hayan depurado.
## remove\_rolled\_back\_parts\_immediately
Ajuste para una funcionalidad experimental incompleta.
## remove\_unused\_patch\_parts
Elimina en segundo plano las patch parts aplicadas a todas las partes activas.
## replace\_long\_file\_name\_to\_hash
Si el nombre de archivo de la columna es demasiado largo (más de 'max\_file\_name\_length'
bytes), sustitúyalo por SipHash128
## replicated\_can\_become\_leader
Si es `true`, las réplicas de las tablas replicadas en este nodo intentarán asumir
el liderazgo.
Valores posibles:
* `true`
* `false`
## replicated\_deduplication\_window
La cantidad de bloques insertados más recientemente para los cuales ClickHouse Keeper almacena
sumas hash para comprobar duplicados.
Posibles valores:
* Cualquier entero positivo.
* 0 (desactiva la deduplicación)
El comando `Insert` crea uno o más bloques (partes). Para la
[deduplicación de inserciones](/es/reference/engines/table-engines/mergetree-family/replication),
al escribir en tablas replicadas, ClickHouse escribe las sumas hash de las
partes creadas en ClickHouse Keeper. Las sumas hash se almacenan solo para los
`replicated_deduplication_window` bloques más recientes. Las sumas hash más antiguas se
eliminan de ClickHouse Keeper.
Un valor alto para `replicated_deduplication_window` ralentiza los `Inserts`
porque hay que comparar más entradas. La suma hash se calcula a partir
de la combinación de los nombres y tipos de los campos y de los datos de la parte
insertada (flujo de bytes).
## replicated\_deduplication\_window\_for\_async\_inserts
El número de bloques insertados de forma asíncrona más recientemente para los que ClickHouse Keeper
almacena sumas hash con el fin de comprobar duplicados.
Valores posibles:
* Cualquier entero positivo.
* 0 (desactiva la deduplicación para async\_inserts)
El comando [Async Insert](/es/reference/settings/session-settings#async_insert) se
almacena en caché en uno o más bloques (partes). Para la [deduplicación de inserciones](/es/reference/engines/table-engines/mergetree-family/replication),
al escribir en tablas replicadas, ClickHouse escribe las sumas hash de cada
inserción en ClickHouse Keeper. Las sumas hash se almacenan solo para los
`replicated_deduplication_window_for_async_inserts` bloques más recientes. Las sumas hash
más antiguas se eliminan de ClickHouse Keeper.
Un valor grande de `replicated_deduplication_window_for_async_inserts` ralentiza
`Async Inserts` porque necesita comparar más entradas.
La suma hash se calcula a partir de la combinación de los nombres y tipos de los campos
y de los datos de la inserción (flujo de bytes).
## replicated\_deduplication\_window\_seconds
El número de segundos tras los cuales se eliminan de ClickHouse Keeper las sumas hash de los bloques insertados.
Posibles valores:
* Cualquier entero positivo.
Al igual que [replicated\_deduplication\_window](#replicated_deduplication_window),
`replicated_deduplication_window_seconds` especifica durante cuánto tiempo se almacenan las sumas hash
de los bloques para la deduplicación de inserciones. Las sumas hash anteriores a
`replicated_deduplication_window_seconds` se eliminan de ClickHouse Keeper,
incluso si son menores que ` replicated_deduplication_window`.
El tiempo es relativo al momento del registro más reciente, no al tiempo del
reloj. Si es el único registro, se almacenará para siempre.
## replicated\_deduplication\_window\_seconds\_for\_async\_inserts
El número de segundos tras los cuales las sumas hash de los async inserts se
eliminan de ClickHouse Keeper.
Valores posibles:
* Cualquier entero positivo.
Al igual que [replicated\_deduplication\_window\_for\_async\_inserts](#replicated_deduplication_window_for_async_inserts),
`replicated_deduplication_window_seconds_for_async_inserts` especifica durante
cuánto tiempo se almacenan las sumas hash de los bloques para la deduplicación
de async insert. Las sumas hash con una antigüedad superior a
`replicated_deduplication_window_seconds_for_async_inserts` se eliminan de
ClickHouse Keeper, incluso si son inferiores a
`replicated_deduplication_window_for_async_inserts`.
El tiempo se calcula en relación con el momento del registro más reciente, no
con el tiempo del reloj del sistema. Si es el único registro, se almacenará
para siempre.
## replicated\_fetches\_http\_connection\_timeout
Configuración obsoleta; no tiene ningún efecto.
## replicated\_fetches\_http\_receive\_timeout
Configuración obsoleta, no tiene ningún efecto.
## replicated\_fetches\_http\_send\_timeout
Configuración obsoleta; no tiene efecto.
## replicated\_fetches\_min\_part\_level
Nivel mínimo de las partes que se deben obtener de otras réplicas. Las partes con un nivel inferior a este umbral se posponen
(se mantienen en la cola de replicación y se vuelven a evaluar en cada ciclo de planificación; no se omiten de forma permanente).
Use 1 para posponer la obtención de partes de nivel 0 (sin fusionar), lo que reduce la sobrecarga de replicación durante una ingestión intensa.
Valor predeterminado: 0 (obtener todas las partes independientemente del nivel).
## replicated\_fetches\_min\_part\_level\_timeout\_seconds
Tiempo de espera, en segundos, tras el cual una parte por debajo de replicated\_fetches\_min\_part\_level se recuperará de todos modos.
Use 0 para desactivar el tiempo de espera (las partes por debajo del nivel mínimo se posponen indefinidamente hasta que se fusionen).
Predeterminado: 300 (forzar la recuperación después de 5 minutos).
## replicated\_max\_mutations\_in\_one\_entry
Número máximo de comandos de mutación que pueden fusionarse y ejecutarse en
una sola entrada MUTATE\_PART (0 significa sin límite)
## replicated\_max\_parallel\_fetches
Configuración obsoleta; no tiene efecto.
## replicated\_max\_parallel\_fetches\_for\_host
Configuración obsoleta; no tiene ningún efecto.
## replicated\_max\_parallel\_fetches\_for\_table
Configuración obsoleta; no tiene ningún efecto.
## replicated\_max\_parallel\_sends
Configuración obsoleta; no tiene ningún efecto.
## replicated\_max\_parallel\_sends\_for\_table
Configuración obsoleta; no tiene ningún efecto.
## replicated\_max\_ratio\_of\_wrong\_parts
Si la proporción de partes incorrectas respecto del número total de partes es inferior a este valor,
se permite el inicio.
Valores posibles:
* Float, 0.0 - 1.0
## search\_orphaned\_parts\_disks
ClickHouse examina todos los discos en busca de partes huérfanas al ejecutar cualquier ATTACH o CREATE de tabla,
para evitar que se omitan partes de datos en discos no definidos (no incluidos en la política).
Las partes huérfanas se originan por una reconfiguración del almacenamiento potencialmente insegura; por ejemplo, si un disco se excluyó de la política de almacenamiento.
Esta configuración limita el alcance de la búsqueda de discos según sus características.
Valores posibles:
* any - el alcance no está limitado.
* local - el alcance se limita a los discos locales.
* none - alcance vacío, no buscar
## serialization\_info\_version
Versión de la información de serialización utilizada al escribir `serialization.json`.
Esta configuración es necesaria para mantener la compatibilidad durante las actualizaciones del clúster.
Valores posibles:
* `basic` - Formato básico.
* `with_types` - Formato con el campo adicional `types_serialization_versions`, que permite versiones de serialización por tipo.
Esto hace que configuraciones como `string_serialization_version` surtan efecto.
Durante las actualizaciones graduales, establece esto en `basic` para que los servidores nuevos produzcan
partes de datos compatibles con los servidores antiguos. Una vez completada la actualización,
cambia a `WITH_TYPES` para habilitar las versiones de serialización por tipo.
## share\_nested\_offsets
Cuando está habilitada (valor predeterminado), las columnas Array con nombres con puntos que comparten un prefijo común (p. ej., n.a y n.b)
se tratan como parte de una estructura Nested: comparten un único archivo de offsets en disco (p. ej., n.size0),
y se valida durante INSERT que sus tamaños de array sean iguales.
Cuando está deshabilitada, cada columna Array obtiene su propio archivo de offsets independiente, los nombres con puntos no tienen
ninguna semántica especial y una columna escalar puede coexistir con columnas Array con puntos que compartan el mismo prefijo
(p. ej., n UInt32 junto con n.a Array(String)). Esta configuración es inmutable después de crear la tabla.
## shared\_merge\_tree\_activate\_coordinated\_merges\_tasks
Activa la reprogramación de tareas de fusiones coordinadas. Puede ser útil incluso cuando
shared\_merge\_tree\_enable\_coordinated\_merges=0, porque esto rellenará las estadísticas del coordinador de fusiones
y ayudará con el arranque en frío.
## shared\_merge\_tree\_create\_per\_replica\_metadata\_nodes
Habilita la creación de nodos /metadata y /columns para cada réplica en ZooKeeper.
Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_disable\_merges\_and\_mutations\_assignment
Detiene la asignación de merges y mutations en shared merge tree. Solo está disponible en ClickHouse
Cloud
## shared\_merge\_tree\_empty\_partition\_lifetime
Cuántos segundos se almacenará la partición en Keeper si no tiene partes.
## shared\_merge\_tree\_enable\_automatic\_empty\_partitions\_cleanup
Habilita la limpieza de las entradas de Keeper de las particiones vacías.
## shared\_merge\_tree\_enable\_coordinated\_merges
Habilita la estrategia de fusiones coordinadas
Habilita la escritura de atributos en las partes virtuales y la confirmación de bloques en Keeper
## shared\_merge\_tree\_enable\_outdated\_parts\_check
Habilita la comprobación de partes obsoletas. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_idle\_parts\_update\_seconds
Intervalo en segundos para actualizar las partes sin que lo active un watch de ZooKeeper en el shared merge tree. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_initial\_parts\_update\_backoff\_ms
Backoff inicial para la actualización de partes. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_interserver\_http\_connection\_timeout\_ms
Tiempos de espera para las conexiones HTTP entre servidores. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_interserver\_http\_timeout\_ms
Tiempos de espera para la comunicación HTTP entre servidores. Solo disponible en ClickHouse
Cloud
## shared\_merge\_tree\_leader\_update\_period\_random\_add\_seconds
Añade a shared\_merge\_tree\_leader\_update\_period un valor distribuido
uniformemente entre 0 y x segundos para evitar el efecto de
estampida. Solo está disponible en ClickHouse Cloud
## shared\_merge\_tree\_leader\_update\_period\_seconds
Período máximo para volver a comprobar el liderazgo de la actualización de partes. Solo disponible en
ClickHouse Cloud
## shared\_merge\_tree\_max\_outdated\_parts\_to\_process\_at\_once
Cantidad máxima de partes obsoletas cuya eliminación el líder intentará confirmar en una sola solicitud HTTP. Solo disponible en ClickHouse Cloud.
## shared\_merge\_tree\_max\_parts\_update\_backoff\_ms
Tiempo máximo de backoff para la actualización de partes. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_max\_parts\_update\_leaders\_in\_total
Número máximo total de líderes de actualización de partes. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_max\_parts\_update\_leaders\_per\_az
Número máximo de líderes de actualización de partes. Solo está disponible en ClickHouse Cloud
## shared\_merge\_tree\_max\_replicas\_for\_parts\_deletion
Número máximo de réplicas que participarán en la eliminación de partes (hilo killer). Solo
disponible en ClickHouse Cloud
## shared\_merge\_tree\_max\_replicas\_to\_merge\_parts\_for\_each\_parts\_range
Número máximo de réplicas que intentarán asignar fusiones potencialmente conflictivas (permite
evitar conflictos redundantes en la asignación de fusiones). 0 significa que está deshabilitado. Solo
disponible en ClickHouse Cloud
## shared\_merge\_tree\_max\_suspicious\_broken\_parts
Número máximo de partes dañadas para SMT; si hay más, se deniega el detach automático.
## shared\_merge\_tree\_max\_suspicious\_broken\_parts\_bytes
Tamaño máximo de todas las partes dañadas para SMT; si se supera, se impide el detach automático.
## shared\_merge\_tree\_memo\_ids\_remove\_timeout\_seconds
Cuánto tiempo almacenamos los ID de memoización de inserción para evitar acciones incorrectas durante
los reintentos de inserción. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_merge\_coordinator\_election\_check\_period\_ms
Intervalo entre ejecuciones del hilo de elección del coordinador de fusiones
## shared\_merge\_tree\_merge\_coordinator\_factor
Factor de ajuste del tiempo de retraso del hilo del coordinador
## shared\_merge\_tree\_merge\_coordinator\_fetch\_fresh\_metadata\_period\_ms
Frecuencia con la que el coordinador de fusiones debe sincronizarse con ZooKeeper para obtener metadatos actualizados
## shared\_merge\_tree\_merge\_coordinator\_max\_merge\_request\_size
Número de fusiones que el coordinador puede solicitar a MergerMutator a la vez
## shared\_merge\_tree\_merge\_coordinator\_max\_period\_ms
Tiempo máximo entre ejecuciones del hilo del coordinador de fusiones
## shared\_merge\_tree\_merge\_coordinator\_merges\_prepare\_count
Número de entradas de merge que el coordinador debe preparar y distribuir entre los workers.
Cuando se establece en 'auto', equivale al número máximo de tareas de merge permitidas en una sola réplica multiplicado por el número de réplicas activas.
## shared\_merge\_tree\_merge\_coordinator\_min\_period\_ms
Tiempo mínimo entre ejecuciones del hilo del coordinador de merge
## shared\_merge\_tree\_merge\_worker\_fast\_timeout\_ms
Tiempo de espera que usará el merge worker thread si necesita actualizar su estado después de una acción inmediata
## shared\_merge\_tree\_merge\_worker\_regular\_timeout\_ms
Tiempo entre ejecuciones del hilo de trabajo de merge
## shared\_merge\_tree\_outdated\_parts\_group\_size
Número de réplicas que estarán en el mismo grupo de hash rendezvous para la limpieza de partes obsoletas.
Solo disponible en ClickHouse Cloud.
## shared\_merge\_tree\_partitions\_hint\_ratio\_to\_reload\_merge\_pred\_for\_mutations
Volverá a cargar el predicado de merge en la tarea de selección de merge/mutación cuando la proporción `/` sea mayor que este valor de configuración. Solo disponible
en ClickHouse Cloud
## shared\_merge\_tree\_parts\_load\_batch\_size
Cantidad de trabajos de obtención de metadatos de partes que se programan a la vez. Solo disponible en
ClickHouse Cloud
## shared\_merge\_tree\_postpone\_next\_merge\_for\_locally\_merged\_parts\_ms
Tiempo durante el que se conserva una parte fusionada localmente sin iniciar una nueva fusión que incluya
esta parte. Da a otras réplicas la oportunidad de recuperar la parte e iniciar esta fusión.
Solo disponible en ClickHouse Cloud.
## shared\_merge\_tree\_postpone\_next\_merge\_for\_locally\_merged\_parts\_rows\_threshold
Tamaño mínimo de una parte (en filas) para posponer la asignación de la siguiente fusión inmediatamente después de fusionarla localmente. Solo disponible en ClickHouse Cloud.
## shared\_merge\_tree\_range\_for\_merge\_window\_size
Tiempo durante el que se conserva una parte fusionada localmente sin iniciar una nueva fusión que la incluya.
Da a otras réplicas la oportunidad de recuperar la parte e iniciar esta fusión.
Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_read\_virtual\_parts\_from\_leader
Leer partes virtuales desde el líder cuando sea posible. Solo disponible en ClickHouse
Cloud
## shared\_merge\_tree\_replica\_set\_max\_lifetime\_seconds
Con qué frecuencia las réplicas intentarán actualizar en segundo plano el conjunto de réplicas. La siguiente ejecución se programa con una variación aleatoria
uniforme en \[0, value] segundos. Excepción: value = 0 no sigue ese criterio;
la implementación aplica un mínimo de 200 ms, por lo que la siguiente ejecución se programa con una variación aleatoria en \[0, 200] ms.
## shared\_merge\_tree\_try\_fetch\_part\_in\_memory\_data\_from\_replicas
Si está habilitada, todas las réplicas intentan obtener de otras réplicas, donde ya existen, los datos en memoria de las partes (como la clave primaria, la información de la partición, etc.).
## shared\_merge\_tree\_update\_replica\_flags\_delay\_ms
Frecuencia con la que la réplica intentará volver a cargar sus flags según la programación en segundo plano.
## shared\_merge\_tree\_use\_metadata\_hints\_cache
Permite solicitar sugerencias de caché del FS desde la caché en memoria de otras réplicas. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_use\_outdated\_parts\_compact\_format
Usa el formato compacto para las partes obsoletas: reduce la carga sobre Keeper y mejora
el procesamiento de las partes obsoletas. Solo disponible en ClickHouse Cloud
## shared\_merge\_tree\_use\_too\_many\_parts\_count\_from\_virtual\_parts
Si está habilitado, el contador de Too many parts se basará en los datos compartidos de Keeper y no en el estado de la réplica local. Solo está disponible en ClickHouse Cloud
## shared\_merge\_tree\_use\_zookeeper\_connection\_pool
Si está habilitada, SharedMergeTree usa una de las sesiones de ZooKeeper del pool a nivel de servidor.
## shared\_merge\_tree\_virtual\_parts\_discovery\_batch
Cuántos descubrimientos de particiones deben agruparse en un batch
## simultaneous\_parts\_removal\_limit
Si hay muchas partes obsoletas, el hilo de limpieza intentará eliminar hasta
`simultaneous_parts_removal_limit` partes en una sola iteración.
Si `simultaneous_parts_removal_limit` se establece en `0`, significa que no hay límite.
## sleep\_before\_commit\_local\_part\_in\_replicated\_table\_ms
Para pruebas. No lo modifique.
## sleep\_before\_loading\_outdated\_parts\_ms
Solo para pruebas. No lo cambie.
## storage\_policy
Nombre de la política de discos de almacenamiento
## string\_serialization\_version
Controla el formato de serialización de las columnas `String` de nivel superior.
Esta configuración solo surte efecto cuando `serialization_info_version` está establecido en "with\_types".
Cuando se establece en `with_size_stream`, las columnas `String` de nivel superior se serializan con una
subcolumna `.size` independiente que almacena las longitudes de las cadenas, en lugar de hacerlo en línea. Esto permite subcolumnas `.size`
reales y puede mejorar la eficiencia de compresión.
Los tipos `String` anidados (por ejemplo, dentro de `Nullable`, `LowCardinality`, `Array` o `Map`)
no se ven afectados, excepto cuando aparecen en una `Tuple`.
Valores posibles:
* `single_stream` — Usa el formato de serialización estándar con tamaños en línea.
* `with_size_stream` — Usa un flujo de tamaños independiente para las columnas `String` de nivel superior.
## table\_disk
Se trata de un disco de tabla; la ruta/endpoint debe apuntar a los datos de la tabla, no a
los datos de la base de datos. Solo se puede establecer para s3\_plain/s3\_plain\_rewritable/web.
## table\_readonly
Si se establece en true, la tabla queda en modo de solo lectura. Cualquier intento de insertar datos o modificarla fallará.
## temporary\_directories\_lifetime
Cuántos segundos se deben conservar los directorios tmp\_. No debe reducir este valor,
porque es posible que las merges y las mutations no puedan funcionar correctamente con un valor bajo de esta
configuración.
## try\_fetch\_recompressed\_part\_timeout
Tiempo de espera (en segundos) antes de iniciar la fusión con recompresión. Durante este
tiempo, ClickHouse intenta recuperar la parte recomprimida de la réplica a la que se asignó
esta fusión con recompresión.
La recompresión suele ser lenta en la mayoría de los casos, por lo que no se inicia la fusión con
recompresión hasta que transcurre este tiempo de espera, mientras se intenta recuperar la parte recomprimida de la
réplica a la que se asignó esta fusión con recompresión.
Valores posibles:
* Cualquier entero positivo.
## ttl\_only\_drop\_parts
Controla si las partes de datos se eliminan por completo en las tablas MergeTree cuando todas las
filas de esa parte han caducado según su configuración de `TTL`.
Cuando `ttl_only_drop_parts` está deshabilitado (de forma predeterminada), solo se eliminan las filas que han
caducado según su configuración de `TTL`.
Cuando `ttl_only_drop_parts` está habilitado, se elimina la parte completa si todas las
filas de esa parte han caducado según su configuración de `TTL`.
## use\_adaptive\_write\_buffer\_for\_dynamic\_subcolumns
Permite usar búferes de escritura adaptativos al escribir subcolumnas dinámicas para
reducir el consumo de memoria
## use\_async\_block\_ids\_cache
Si es `true`, almacenamos en caché las sumas hash de las inserciones asíncronas.
Valores posibles:
* `true`
* `false`
Un bloque asociado a múltiples inserciones asíncronas generará múltiples sumas hash.
Cuando algunas de las inserciones estén duplicadas, Keeper solo devolverá una
suma hash duplicada en una RPC, lo que provocará reintentos de RPC innecesarios.
Esta caché observará la ruta de las sumas hash en Keeper. Si se detectan
actualizaciones en Keeper, la caché se actualizará lo antes posible para que
podamos filtrar en memoria las inserciones duplicadas.
## use\_compact\_variant\_discriminators\_serialization
Habilita el modo compacto para la serialización binaria de discriminadores en el
tipo de dato Variant.
Este modo permite usar mucha menos memoria para almacenar discriminadores
en las partes cuando predomina una sola variante o hay muchos valores NULL.
## use\_const\_adaptive\_granularity
Utilice siempre una granularidad constante para toda la parte. Esto permite comprimir en
memoria los valores de granularidad del índice. Puede ser útil en cargas de
trabajo extremadamente grandes con tablas con pocas columnas.
## use\_metadata\_cache
Configuración obsoleta; no tiene ningún efecto.
## use\_minimalistic\_checksums\_in\_zookeeper
Utiliza un formato pequeño (decenas de bytes) para las sumas de comprobación de las partes en ZooKeeper en lugar de
las normales (decenas de KB). Antes de habilitarlo, comprueba que todas las réplicas admiten el
nuevo formato.
Método de almacenamiento de los encabezados de las partes de datos en ZooKeeper. Si está habilitada, ZooKeeper
almacena menos datos. Para más información, consulte [aquí](/es/reference/settings/server-settings/settings#use_minimalistic_part_header_in_zookeeper).
## use\_primary\_key\_cache
Usa la caché del índice primario
en lugar de mantener todos los índices en memoria. Puede ser útil para tablas muy grandes
## vertical\_merge\_algorithm\_min\_bytes\_to\_activate
Tamaño mínimo (aproximado) no comprimido, en bytes, de las partes en proceso de combinación para activar
el algoritmo de fusión vertical.
## vertical\_merge\_algorithm\_min\_columns\_to\_activate
Cantidad mínima de columnas no PK necesaria para activar el algoritmo de combinación vertical.
## vertical\_merge\_algorithm\_min\_rows\_to\_activate
Suma mínima (aproximada) de filas en las
partes que se fusionan para activar el algoritmo de fusión vertical.
## vertical\_merge\_optimize\_lightweight\_delete
Si es true, la eliminación ligera se optimiza durante la fusión vertical.
## vertical\_merge\_optimize\_ttl\_delete
Si se establece en true, la eliminación de filas por TTL se optimiza en la mezcla vertical. En lugar de forzar una mezcla horizontal,
el filtro TTL se evalúa y se pasa al algoritmo de mezcla, que establece marcas de omisión en las fuentes de filas.
## vertical\_merge\_remote\_filesystem\_prefetch
Si es true, se utiliza la precarga de datos desde el sistema de archivos remoto para la siguiente
columna durante la fusión
## wait\_for\_unique\_parts\_send\_before\_shutdown\_ms
Antes de apagarse, la tabla esperará el tiempo necesario para que otras réplicas obtengan las partes únicas
(que existen solo en la réplica actual) (`0` significa
deshabilitado).
## write\_ahead\_log\_bytes\_to\_fsync
Configuración obsoleta, no tiene efecto.
## write\_ahead\_log\_interval\_ms\_to\_fsync
Configuración obsoleta; no tiene ningún efecto.
## write\_ahead\_log\_max\_bytes
Configuración obsoleta; no tiene ningún efecto.
## write\_final\_mark
Configuración obsoleta; no tiene ningún efecto.
## write\_marks\_for\_substreams\_in\_compact\_parts
Habilita la escritura de marcas para cada subflujo en lugar de para cada columna en partes compactas.
Permite leer subcolumnas individuales de la parte de datos de forma eficiente.
Por ejemplo, la columna `t Tuple(a String, b UInt32, c Array(Nullable(UInt32)))` se serializa en los siguientes subflujos:
* `t.a` para los datos String del elemento de Tuple `a`
* `t.b` para los datos UInt32 del elemento de Tuple `b`
* `t.c.size0` para los tamaños del array del elemento de Tuple `c`
* `t.c.null` para el mapa de NULL de los elementos del array anidado del elemento de Tuple `c`
* `t.c` para los datos UInt32 de los elementos del array anidado del elemento de Tuple `c`
Cuando esta configuración está habilitada, escribiremos una marca para cada uno de estos 5 subflujos, lo que significa que podremos leer
los datos de cada subflujo individual del gránulo por separado si es necesario. Por ejemplo, si queremos leer la subcolumna `t.c`, leeremos solo los datos de los
subflujos `t.c.size0`, `t.c.null` y `t.c`, y no leeremos datos de los subflujos `t.a` y `t.b`. Cuando esta configuración está deshabilitada,
escribiremos una marca solo para la columna de nivel superior `t`, lo que significa que siempre leeremos todos los datos de la columna del gránulo, incluso si solo necesitamos los datos de algunos subflujos.
## zero\_copy\_concurrent\_part\_removal\_max\_postpone\_ratio
Porcentaje máximo de partes de nivel superior cuyo borrado puede posponerse para obtener
rangos independientes más pequeños. Se recomienda no modificarlo.
## zero\_copy\_concurrent\_part\_removal\_max\_split\_times
Profundidad máxima de recursión para dividir rangos independientes de partes obsoletas en
subrangos más pequeños. Se recomienda no modificarlo.
## zero\_copy\_merge\_mutation\_min\_parts\_size\_sleep\_before\_lock
Si la replicación de copia cero está habilitada, espera un intervalo aleatorio antes de intentar
adquirir el bloqueo, en función del tamaño de las partes para merge o mutation
## zero\_copy\_merge\_mutation\_min\_parts\_size\_sleep\_no\_scale\_before\_lock
Si la replicación de copia cero está habilitada, espere un intervalo aleatorio de hasta 500 ms
antes de intentar adquirir el bloqueo para una combinación o mutación.
## zookeeper\_session\_expiration\_check\_period
Período de comprobación de la expiración de la sesión de ZooKeeper, en segundos.
Valores posibles:
* Cualquier entero positivo.