> ## 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.

> La eliminación ligera simplifica el proceso de eliminar datos de la base de datos.

# La sentencia de eliminación ligera

La sentencia de eliminación ligera elimina filas de la tabla `[db.]table` que coinciden con la expresión `expr`. Solo está disponible para la familia \*MergeTree de motores de tabla.

```sql theme={null}
DELETE FROM [db.]table [ON CLUSTER cluster] [IN PARTITION partition_expr] WHERE expr;
```

Se denomina "eliminación ligera" para diferenciarlo del comando [ALTER TABLE ... DELETE](/es/reference/statements/alter/delete), que implica un proceso pesado.

<div id="examples">
  ## Ejemplos
</div>

```sql theme={null}
-- Elimina todas las filas de la tabla `hits` donde la columna `Title` contiene el texto `hello`
DELETE FROM hits WHERE Title LIKE '%hello%';
```

<div id="lightweight-delete-does-not-delete-data-immediately">
  ## La eliminación ligera no elimina los datos inmediatamente
</div>

La eliminación ligera se implementa como una [mutación](/es/reference/statements/alter#mutations) que marca las filas como eliminadas, pero no las elimina físicamente de inmediato.

De forma predeterminada, las sentencias `DELETE` esperan a que se complete el marcado de las filas como eliminadas antes de devolver el control. Esto puede llevar mucho tiempo si la cantidad de datos es grande. Como alternativa, puede ejecutarse de forma asíncrona en segundo plano mediante la configuración [`lightweight_deletes_sync`](/es/reference/settings/session-settings#lightweight_deletes_sync). Si está deshabilitada, la sentencia `DELETE` devolverá el control inmediatamente, pero los datos pueden seguir siendo visibles para las consultas hasta que finalice la mutación en segundo plano.

La mutación no elimina físicamente las filas que se han marcado como eliminadas; esto solo ocurrirá durante la siguiente fusión. Como resultado, es posible que, durante un período no especificado, los datos no se eliminen realmente del almacenamiento y solo queden marcados como eliminados.

Si necesita garantizar que sus datos se eliminen del almacenamiento en un plazo predecible, considere usar la configuración de tabla [`min_age_to_force_merge_seconds`](/es/reference/settings/merge-tree-settings#min_age_to_force_merge_seconds). O bien, puede usar el comando [ALTER TABLE ... DELETE](/es/reference/statements/alter/delete). Tenga en cuenta que eliminar datos mediante `ALTER TABLE ... DELETE` puede consumir una cantidad significativa de recursos, ya que vuelve a crear todas las partes afectadas.

<div id="deleting-large-amounts-of-data">
  ## Eliminar grandes cantidades de datos
</div>

Las eliminaciones de gran volumen pueden afectar negativamente el rendimiento de ClickHouse. Si intenta eliminar todas las filas de una tabla, considere usar el comando [`TRUNCATE TABLE`](/es/reference/statements/truncate).

Si prevé eliminaciones frecuentes, considere usar una [clave de particionamiento personalizada](/es/reference/engines/table-engines/mergetree-family/custom-partitioning-key). Después, puede usar el comando [`ALTER TABLE ... DROP PARTITION`](/es/reference/statements/alter/partition#drop-partitionpart) para eliminar rápidamente todas las filas asociadas a esa partición.

<div id="limitations-of-lightweight-delete">
  ## Limitaciones de la eliminación ligera
</div>

<div id="lightweight-deletes-with-projections">
  ### Eliminaciones ligeras con proyecciones
</div>

De forma predeterminada, `DELETE` no funciona en tablas con proyecciones. Esto se debe a que las filas de una proyección pueden verse afectadas por una operación `DELETE`. Sin embargo, existe una [configuración de MergeTree](/es/reference/settings/merge-tree-settings), `lightweight_mutation_projection_mode`, para cambiar este comportamiento.

<div id="performance-considerations-when-using-lightweight-delete">
  ## Consideraciones de rendimiento al usar la eliminación ligera
</div>

**Eliminar grandes volúmenes de datos con la sentencia de eliminación ligera puede afectar negativamente al rendimiento de las consultas SELECT.**

Lo siguiente también puede afectar negativamente al rendimiento de la eliminación ligera:

* Una condición `WHERE` compleja en una consulta `DELETE`.
* Si la cola de mutaciones está llena de muchas otras mutaciones, esto puede provocar problemas de rendimiento, ya que todas las mutaciones de una tabla se ejecutan secuencialmente.
* La tabla afectada tiene un número muy elevado de partes de datos.
* Tener muchos datos en partes compactas. En una parte compacta, todas las columnas se almacenan en un único archivo.

<div id="delete-permissions">
  ## Permisos para DELETE
</div>

`DELETE` requiere el privilegio `ALTER DELETE`. Para habilitar sentencias `DELETE` en una tabla específica para un usuario concreto, ejecute el siguiente comando:

```sql theme={null}
GRANT ALTER DELETE ON db.table to username;
```

<div id="how-lightweight-deletes-work-internally-in-clickhouse">
  ## Cómo funciona internamente la eliminación ligera con DELETE en ClickHouse
</div>

1. **Se aplica una "máscara" a las filas afectadas**

   Cuando se ejecuta una consulta `DELETE FROM table ...`, ClickHouse guarda una máscara en la que cada fila queda marcada como "existente" o "eliminada". Esas filas "eliminadas" se omiten en las consultas posteriores. Sin embargo, las filas no se eliminan físicamente hasta más adelante, durante las fusiones posteriores. Escribir esta máscara es mucho más ligero que lo que hace una consulta `ALTER TABLE ... DELETE`.

   La máscara se implementa como una columna oculta del sistema, `_row_exists`, que almacena `True` para todas las filas visibles y `False` para las eliminadas. Esta columna solo está presente en una parte si se eliminaron algunas filas de esa parte. No existe cuando una parte tiene todos los valores iguales a `True`.

2. **Las consultas `SELECT` se transforman para incluir la máscara**

   Cuando se usa una columna enmascarada en una consulta, la consulta `SELECT ... FROM table WHERE condition` se amplía internamente con el predicado sobre `_row_exists` y se transforma en:

   ```sql theme={null}
   SELECT ... FROM table PREWHERE _row_exists WHERE condition
   ```

   En tiempo de ejecución, se lee la columna `_row_exists` para determinar qué filas no deben devolverse. Si hay muchas filas eliminadas, ClickHouse puede determinar qué gránulos se pueden omitir por completo al leer el resto de las columnas.

3. **Las consultas `DELETE` se transforman en consultas `ALTER TABLE ... UPDATE`**

   `DELETE FROM table WHERE condition` se traduce en una mutación `ALTER TABLE table UPDATE _row_exists = 0 WHERE condition`.

   Internamente, esta mutación se ejecuta en dos pasos:

   1. Se ejecuta un comando `SELECT count() FROM table WHERE condition` para cada parte individual a fin de determinar si esa parte está afectada.

   2. A partir de los comandos anteriores, las partes afectadas se mutan y se crean hardlinks para las partes no afectadas. En el caso de las partes wide, se actualiza la columna `_row_exists` de cada fila y los archivos del resto de columnas se enlazan mediante hardlinks. En el caso de las partes compactas, todas las columnas se vuelven a escribir porque se almacenan juntas en un solo archivo.

   Como se desprende de los pasos anteriores, la técnica de enmascaramiento de `DELETE` ligero mejora el rendimiento frente al método tradicional `ALTER TABLE ... DELETE`, porque no vuelve a escribir todos los archivos de columnas de las partes afectadas.

<div id="related-content">
  ## Contenido relacionado
</div>

* Blog: [Cómo gestionar actualizaciones y eliminaciones en ClickHouse](https://clickhouse.com/blog/handling-updates-and-deletes-in-clickhouse)