> ## Documentation Index
> Fetch the complete documentation index at: https://villagesql.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# DELETE no MySQL

> Como a instrução DELETE do MySQL remove linhas, por que você deve executar o WHERE como um SELECT primeiro, e o que separa um DELETE de um TRUNCATE TABLE.

> [card] [VillageSQL is a drop-in replacement for MySQL with extensions.](https://villagesql.com/docs/en/8.4/stable/install-server.md)
>
> All examples on this page work on VillageSQL. Install Now →

`DELETE` remove linhas inteiras. Não há como desfazer fora de uma
[transação](https://villagesql.com/docs/pt-BR/tutorial/transactions.md), então o hábito que vale a pena criar é escrever
o `WHERE` primeiro e olhar o que ele seleciona.

Estes exemplos usam o banco de dados `sakila_practice` de
[INSERT](https://villagesql.com/docs/pt-BR/tutorial/insert.md). Execute o bloco de configuração de lá de novo antes de começar,
e então abra o cliente com `mysql -u root -p sakila_practice`.

## Como DELETE funciona

```sql theme={null}
DELETE FROM TABLE_NAME
WHERE CONDITION;
```

Substitua `TABLE_NAME` pela tabela e `CONDITION` pelo teste que escolhe
as linhas a remover.

Não há lista de colunas. Um `DELETE` leva a linha inteira, então esvaziar 1 coluna
é um [UPDATE](https://villagesql.com/docs/pt-BR/tutorial/update.md) que a define como NULL.

## Exemplos

### Olhe primeiro, depois apague

Escreva o `WHERE` como um `SELECT` e leia as linhas que você está prestes a perder.

```sql theme={null}
SELECT member_id, first_name, last_name FROM member WHERE active = 0;
```

```text theme={null}
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
|         3 | Linda      | Williams  |
+-----------+------------+-----------+
1 row in set (0.00 sec)
```

Uma linha, e é a que você queria. Agora mude o início da instrução
e deixe o `WHERE` intocado.

```sql theme={null}
DELETE FROM member WHERE active = 0;
```

```text theme={null}
Query OK, 1 row affected (0.00 sec)
```

```sql theme={null}
SELECT member_id, first_name, last_name, active FROM member;
```

```text theme={null}
+-----------+------------+-----------+--------+
| member_id | first_name | last_name | active |
+-----------+------------+-----------+--------+
|         1 | Mary       | Smith     |      1 |
|         2 | Patricia   | Johnson   |      1 |
+-----------+------------+-----------+--------+
2 rows in set (0.00 sec)
```

Um `DELETE` informa as linhas afetadas e nada mais. Um `UPDATE` imprime uma segunda
linha com `Rows matched` e `Changed`; um `DELETE` não tem equivalente.

### Um WHERE que não corresponde a nada não é um erro

```sql theme={null}
DELETE FROM member WHERE member_id = 99;
```

```text theme={null}
Query OK, 0 rows affected (0.00 sec)
```

Nada deu errado e nada aconteceu. `0 rows affected` depois de um delete que você
esperava que funcionasse significa que o `WHERE` está errado, e a instrução não vai
dizer isso a você.

## Sem um WHERE ele esvazia a tabela

```sql theme={null}
DELETE FROM member;
```

```text theme={null}
Query OK, 2 rows affected (0.00 sec)
```

```sql theme={null}
SELECT COUNT(*) AS members FROM member;
```

```text theme={null}
+---------+
| members |
+---------+
|       0 |
+---------+
1 row in set (0.00 sec)
```

O modo de atualização segura recusa esta forma, exatamente como recusa um `UPDATE` sem
chave em seu `WHERE`. [UPDATE](https://villagesql.com/docs/pt-BR/tutorial/update.md) mostra o `ERROR 1175` que ele
gera, e `mysql -u root -p --safe-updates sakila_practice` o ativa para
a sessão inteira.

## TRUNCATE esvazia de outra forma

A tabela está vazia, então insira uma linha e olhe o id dela.

```sql theme={null}
INSERT INTO member (first_name, last_name, joined) VALUES ('Sam', 'Reed', '2026-06-01');
```

```text theme={null}
Query OK, 1 row affected (0.00 sec)
```

```sql theme={null}
SELECT member_id, first_name FROM member;
```

```text theme={null}
+-----------+------------+
| member_id | first_name |
+-----------+------------+
|         4 | Sam        |
+-----------+------------+
1 row in set (0.00 sec)
```

O contador continuou de onde as linhas que o `DELETE` removeu pararam. `TRUNCATE TABLE`
não faz isso.

```sql theme={null}
TRUNCATE TABLE member;
```

```text theme={null}
Query OK, 0 rows affected (0.00 sec)
```

```sql theme={null}
INSERT INTO member (first_name, last_name, joined) VALUES ('Sam', 'Reed', '2026-06-01');
```

```text theme={null}
Query OK, 1 row affected (0.00 sec)
```

```sql theme={null}
SELECT member_id, first_name FROM member;
```

```text theme={null}
+-----------+------------+
| member_id | first_name |
+-----------+------------+
|         1 | Sam        |
+-----------+------------+
1 row in set (0.00 sec)
```

`TRUNCATE` descarta a tabela e constrói uma vazia, e é por isso que informa
`0 rows affected` não importa quantas linhas removeu, e por isso o contador recomeça.
Ele não aceita `WHERE`, não pode ser revertido, e não dispara nenhum trigger de
`DELETE`. Use `TRUNCATE` para zerar uma tabela, e `DELETE` para
todo o resto.

## Resumo

* Escreva `DELETE FROM table WHERE condition`, e execute o `WHERE` como um `SELECT` primeiro.
* Espere uma contagem de linhas e nenhuma linha `Rows matched`.
* Leia `0 rows affected` como um `WHERE` que não encontrou nada, e não como uma falha.
* Deixe o `WHERE` de fora e a tabela é esvaziada, sem passo de confirmação.
* Use `TRUNCATE TABLE` para esvaziar e zerar uma tabela, sabendo que não pode ser desfeito.

## Veja também

* [UPDATE](https://villagesql.com/docs/pt-BR/tutorial/update.md) — mudando linhas, e a proteção de atualização segura
* [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) — a cláusula que decide quais linhas saem
* [Transações](https://villagesql.com/docs/pt-BR/tutorial/transactions.md) — a única forma de reverter um DELETE
* [Exclusões lógicas no MySQL](https://villagesql.com/docs/pt-BR/guides/soft-deletes.md) — marcando linhas como removidas em vez de removê-las


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.