Descrição

O comando DELETE exclui as linhas que atendem à cláusula WHERE da tabela especificada. Se a cláusula WHERE estiver ausente, o efeito será excluir todas as linhas da tabela. O resultado será uma tabela válida, mas vazia.

Existem duas maneiras de excluir linhas em uma tabela usando informações contidas em outras tabelas no banco de dados: usando sub-seleções, ou especificando tabelas adicionais na cláusula USING. Qual técnica é a mais apropriada depende das circunstâncias específicas.

A cláusula opcional RETURNING faz com que o comando DELETE calcule e retorne valores com base em cada linha realmente excluída. Pode ser computada qualquer expressão usando as colunas da tabela, e/ou colunas de outras tabelas mencionadas na cláusula USING. A sintaxe da lista da cláusula RETURNING é idêntica à da lista de saída do comando SELECT.

É necessário ter o privilégio DELETE na tabela para excluir suas linhas, bem como o privilégio SELECT para qualquer tabela na cláusula USING, ou cujos valores sejam lidos pela condição.

Parâmetros

Saídas

Após a conclusão bem-sucedida, o comando DELETE retorna uma etiqueta de comando na forma

DELETE contador

O contador é o número de linhas excluídas. Note que o número pode ser menor que o número de linhas que corresponderam à condição, quando exclusões forem suprimidas por um gatilho BEFORE DELETE. Se o contador for igual a 0, nenhuma linha foi excluída pelo comando (isso não é considerado um erro).

Se o comando DELETE contiver uma cláusula RETURNING, o resultado será semelhante ao de um comando SELECT contendo as colunas e valores definidos na lista da cláusula RETURNING, computadas sobre a(s) linha(s) excluída(s) pelo comando.

Notas

O PostgreSQL permite referenciar colunas de outras tabelas na condição WHERE, especificando as outras tabelas na cláusula USING. Por exemplo, para excluir todos os filmes produzidos por um determinado produtor, pode-se executar:

DELETE FROM films USING producers
  WHERE producer_id = producers.id AND producers.name = 'foo';

O que está essencialmente acontecendo aqui é uma junção entre as tabelas films e producers, com todas as linhas de films juntadas com sucesso sendo marcadas para exclusão. Essa sintaxe não é padrão. Uma maneira mais de acordo com o padrão de fazer isso é:

DELETE FROM films
  WHERE producer_id IN (SELECT id FROM producers WHERE name = 'foo');

Em alguns casos, o estilo junção é mais fácil de escrever ou mais rápido de executar do que o estilo subseleção.

Exemplos

Excluir todos os filmes, exceto os musicais:

DELETE FROM films WHERE kind <> 'Musical';

Limpar a tabela films:

DELETE FROM films;

Excluir as tarefas concluídas, retornando os detalhes completos das linhas excluídas:

DELETE FROM tasks WHERE status = 'DONE' RETURNING *;

Excluir a linha da tabela tasks onde o cursor c_tasks está posicionado no momento:

DELETE FROM tasks WHERE CURRENT OF c_tasks;

DROP TABLE IF EXISTS produtores;
DROP TABLE IF EXISTS filmes;

CREATE TABLE produtores (
    id_produtor INT PRIMARY KEY,
    nome        TEXT
);
INSERT INTO produtores VALUES (1,'faa');
INSERT INTO produtores VALUES (2,'fee');
INSERT INTO produtores VALUES (3,'fii');
INSERT INTO produtores VALUES (4,'foo');
INSERT INTO produtores VALUES (5,'fuu');
CREATE TABLE filmes (
    id_filme    INT PRIMARY KEY,
    titulo      TEXT,
    id_produtor INT
);
INSERT INTO filmes VALUES (1,'Lorem ipsum dolor',1);
INSERT INTO filmes VALUES (2,'Pretium nibh ipsum',2);
INSERT INTO filmes VALUES (3,'Odio ut sem nulla',3);
INSERT INTO filmes VALUES (4,'Dignissim convallis',4);
INSERT INTO filmes VALUES (5,'Erat velit scelerisquer.',4);
INSERT INTO filmes VALUES (6,'Diam sit amet nisl',5);
\pset border 2
\pset title 'Linhas excluídas'
DELETE FROM filmes USING produtores
  WHERE filmes.id_produtor = produtores.id_produtor
    AND produtores.nome = 'foo'
  RETURNING *;
\pset title 'Linhas remanescentes'
SELECT * FROM filmes;

$ psql --file=filmes.sql
...
Title is "Linhas excluídas".
                             Linhas excluídas
+----------+--------------------------+-------------+-------------+------+
| id_filme |          titulo          | id_produtor | id_produtor | nome |
+----------+--------------------------+-------------+-------------+------+
|        4 | Dignissim convallis      |           4 |           4 | foo  |
|        5 | Erat velit scelerisquer. |           4 |           4 | foo  |
+----------+--------------------------+-------------+-------------+------+
(2 rows)

DELETE 2
Title is "Linhas remanescentes".
             Linhas remanescentes
+----------+--------------------+-------------+
| id_filme |       titulo       | id_produtor |
+----------+--------------------+-------------+
|        1 | Lorem ipsum dolor  |           1 |
|        2 | Pretium nibh ipsum |           2 |
|        3 | Odio ut sem nulla  |           3 |
|        6 | Diam sit amet nisl |           5 |
+----------+--------------------+-------------+
(4 rows)

Compatibilidade

Esse comando está em conformidade com o padrão SQL, exceto que as cláusulas USING e RETURNING são extensões do PostgreSQL, assim como a capacidade de usar WITH com DELETE.

Veja também