DELETE

Descrição

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

Por padrão, o comando DELETE exclui linhas da tabela especificada e de todas as suas tabelas descendentes. Se for desejado excluir linhas apenas da tabela especificada, deve ser utilizada a cláusula ONLY.

Existem duas maneiras de excluir linhas de uma tabela utilizando informações contidas em outra tabela do banco de dados: utilizando subseleções e especificando tabelas adicionais na cláusula USING. Qual técnica é a mais apropriada vai depender das circunstâncias específicas.

A cláusula opcional RETURNING faz o comando DELETE computar e retornar valores baseados em cada linha excluída. Pode ser computada qualquer expressão que utilize 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. [1]

É necessário possuir o privilégio DELETE na tabela para excluir linhas da mesma, assim como o privilégio SELECT para todas as tabelas da cláusula USING ou cujos valores são lidos pela condição.

Parâmetros

Saídas

Ao término bem-sucedido, o comando DELETE retorna uma linha de fim de comando na forma

DELETE contador

O contador é o número de linhas excluídas. Se contador for igual a 0, então nenhuma linha correspondeu à condição (isto não é considerado um erro).

Se o comando DELETE contiver a cláusula RETURNING, o resultado será semelhante ao do comando SELECT contendo as colunas e valores definidos na lista da cláusula RETURNING, computada sobre as linhas excluídas pelo comando.

Observações

O PostgreSQL permite que se faça referência a colunas de outras tabelas na condição WHERE, desde que se especifique estas tabelas na cláusula USING. Por exemplo, para excluir todos os filmes produzidos por um determinado produtor pode ser utilizado

DELETE FROM filmes USING produtores
  WHERE filmes.id_produtor = produtores.id_produtor AND produtores.nome = 'foo';

Essencialmente o que acontece neste comando é uma junção entre as tabelas filmes e produtores, com todas as linhas de filmes juntadas com sucesso sendo marcadas para exclusão. Esta sintaxe não é padrão. Uma forma mais padrão de se fazer isto é:

DELETE FROM filmes
  WHERE id_produtor IN (SELECT id_produtor FROM produtores WHERE nome = 'foo');

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

Exemplos

Excluir todos os filmes, exceto os musicais:

DELETE FROM filmes WHERE tipo <> 'Musical';

Limpar a tabela filmes:

DELETE FROM filmes;

Excluir as tarefas completadas, retornando todos os detalhes das linhas excluídas:

DELETE FROM tarefas WHERE status = 'COMPLETADA' RETURNING *;

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,'aaa',1);
INSERT INTO filmes VALUES (2,'bbb',2);
INSERT INTO filmes VALUES (3,'ccc',3);
INSERT INTO filmes VALUES (4,'ddd',4);
INSERT INTO filmes VALUES (5,'eee',4);
INSERT INTO filmes VALUES (6,'fff',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 -h Kubuntu -U teste -f filmes.sql -o filmes.out -q teste
# cat filmes.out
                     Linhas excluídas
+----------+--------+-------------+-------------+------+
| id_filme | titulo | id_produtor | id_produtor | nome |
+----------+--------+-------------+-------------+------+
|        4 | ddd    |           4 |           4 | foo  |
|        5 | eee    |           4 |           4 | foo  |
+----------+--------+-------------+-------------+------+
(2 linhas)

       Linhas remanescentes
+----------+--------+-------------+
| id_filme | titulo | id_produtor |
+----------+--------+-------------+
|        1 | aaa    |           1 |
|        2 | bbb    |           2 |
|        3 | ccc    |           3 |
|        6 | fff    |           5 |
+----------+--------+-------------+
(4 linhas)

Compatibilidade

Este comando está em conformidade com o padrão SQL, exceto pelas cláusulas USING e RETURNING que são extensões do PostgreSQL.