Como adicionar restrições "ao excluir cascata"?

163

No PostgreSQL 8, é possível adicionar ON DELETE CASCADESas duas chaves estrangeiras na tabela a seguir sem descartar a última?

# \d scores
        Table "public.scores"
 Column  |         Type          | Modifiers
---------+-----------------------+-----------
 id      | character varying(32) |
 gid     | integer               |
 money   | integer               | not null
 quit    | boolean               |
 last_ip | inet                  |
Foreign-key constraints:
   "scores_gid_fkey" FOREIGN KEY (gid) REFERENCES games(gid)
   "scores_id_fkey" FOREIGN KEY (id) REFERENCES users(id)

Ambas as tabelas referenciadas estão abaixo - aqui:

# \d games
                                     Table "public.games"
  Column  |            Type             |                        Modifiers
----------+-----------------------------+----------------------------------------------------------
 gid      | integer                     | not null default nextval('games_gid_seq'::regclass)
 rounds   | integer                     | not null
 finished | timestamp without time zone | default now()
Indexes:
    "games_pkey" PRIMARY KEY, btree (gid)
Referenced by:
    TABLE "scores" CONSTRAINT "scores_gid_fkey" FOREIGN KEY (gid) REFERENCES games(gid)

E aqui:

# \d users
                Table "public.users"
   Column   |            Type             |   Modifiers
------------+-----------------------------+---------------
 id         | character varying(32)       | not null
 first_name | character varying(64)       |
 last_name  | character varying(64)       |
 female     | boolean                     |
 avatar     | character varying(128)      |
 city       | character varying(64)       |
 login      | timestamp without time zone | default now()
 last_ip    | inet                        |
 logout     | timestamp without time zone |
 vip        | timestamp without time zone |
 mail       | character varying(254)      |
Indexes:
    "users_pkey" PRIMARY KEY, btree (id)
Referenced by:
    TABLE "cards" CONSTRAINT "cards_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "catch" CONSTRAINT "catch_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "chat" CONSTRAINT "chat_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "game" CONSTRAINT "game_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "hand" CONSTRAINT "hand_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "luck" CONSTRAINT "luck_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "match" CONSTRAINT "match_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "misere" CONSTRAINT "misere_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "money" CONSTRAINT "money_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "pass" CONSTRAINT "pass_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "payment" CONSTRAINT "payment_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "rep" CONSTRAINT "rep_author_fkey" FOREIGN KEY (author) REFERENCES users(id)
    TABLE "rep" CONSTRAINT "rep_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "scores" CONSTRAINT "scores_id_fkey" FOREIGN KEY (id) REFERENCES users(id)
    TABLE "status" CONSTRAINT "status_id_fkey" FOREIGN KEY (id) REFERENCES users(id)

E também me pergunto se faz sentido adicionar 2 index'es à tabela anterior?

UPDATE: Obrigado, e também tenho os conselhos na lista de discussão, de que eu poderia gerenciá-lo em uma instrução e, portanto, sem iniciar explicitamente uma transação:

ALTER TABLE public.scores
DROP CONSTRAINT scores_gid_fkey,
ADD CONSTRAINT scores_gid_fkey
   FOREIGN KEY (gid)
   REFERENCES games(gid)
   ON DELETE CASCADE;
Alexander Farber
fonte
1
Um pouco OT, mas notei que você não criou índices nas colunas de referência (por exemplo pref_scores.gid). As exclusões na tabela referenciada levarão muito tempo sem essas, se você receber muitas linhas nessas tabelas. Alguns bancos de dados criam automaticamente um índice nas colunas de referência; O PostgreSQL deixa isso para você, pois há alguns casos em que não vale a pena.
kgrittn
1
Obrigado! Na verdade, eu notei que de exclusão leva muito tempo, mas não sabia o que é a razão
Alexander Farber
1
Quais casos seriam esses, quando os índices em chaves estrangeiras não valessem a pena?
Alexander Farber
2
Eu incorporei sua descoberta na minha resposta. (Essa declaração única é também uma única transação.)
Mike Sherrill 'Cat recall'
2
@AlexanderFarber: Quando você pode omitir um índice na (s) coluna (s) de referência de um FK? Quando houver outro índice, não uma correspondência exata, que funcione bem o suficiente (por exemplo, você pode ter um índice trigrama para pesquisas frequentes de similaridade, que também serão boas para excluir FK). Quando exclusões não são frequentes e podem ser agendadas fora do horário comercial. Quando uma tabela tem atualizações frequentes do valor de referência. Quando a tabela de referência é muito pequena, mas é atualizada com freqüência. As exceções ocorrem com frequência suficiente para que a comunidade do PostgreSQL prefira ter controle sobre ela, em vez de torná-la automática.
precisa saber é o seguinte

Respostas:

218

Tenho certeza de que você não pode simplesmente adicionar on delete cascadea uma restrição de chave estrangeira existente. Você deve eliminar a restrição primeiro e depois adicionar a versão correta. No SQL padrão, acredito que a maneira mais fácil de fazer isso é

  • iniciar uma transação,
  • solte a chave estrangeira,
  • adicione uma chave estrangeira com on delete cascade, e finalmente
  • confirmar a transação

Repita para cada chave estrangeira que deseja alterar.

Mas o PostgreSQL possui uma extensão não padrão que permite usar várias cláusulas de restrição em uma única instrução SQL. Por exemplo

alter table public.scores
drop constraint scores_gid_fkey,
add constraint scores_gid_fkey
   foreign key (gid)
   references games(gid)
   on delete cascade;

Se você não souber o nome da restrição de chave estrangeira que deseja eliminar, procure-o no pgAdminIII (basta clicar no nome da tabela e olhar para o DDL ou expandir a hierarquia até ver "Restrições"), ou você pode consultar o esquema de informações .

select *
from information_schema.key_column_usage
where position_in_unique_constraint is not null
Mike Sherrill 'Recorde Gato'
fonte
Obrigado, foi o que pensei também - mas o que fazer com as CHAVES ESTRANGEIRAS? São apenas restrições (semelhantes a NOT NULL) que podem ser eliminadas e lidas facilmente?
27512 Alexander Farber
2
@AlexanderFarber: Sim, eles são chamados de restrições que você pode remover e adicionar facilmente. Mas você provavelmente deseja fazer isso dentro de uma transação. Atualizei minha resposta com mais detalhes.
Mike Sherrill 'Cat Recall'
+1 para procurar ot no pgAdminIII. Ele ainda fornece os comandos DROP CONSTRAINT e ADD CONSTRAINT, para que você possa copiar e colar em uma janela de consulta e editar o comando da maneira que desejar.
Dave Pilha
Depois de escrever a consulta, notei que a minha Postgres GUI (Navicat) vamos me trivialmente fazer esta mudança de dentro da GUI: dl.dropboxusercontent.com/spa/quq37nq1583x0lf/wwqne-lw.png
danneu
Para tabelas grandes, isso é possível com NOT VALIDe validando em uma transação separada? Eu tenho uma pergunta sem resposta sobre isso.
TheCloudlessSky
11

Baseado na resposta de Mike Sherrill Cat Recall, foi o que funcionou para mim:

ALTER TABLE "Children"
DROP CONSTRAINT "Children_parentId_fkey",
ADD CONSTRAINT "Children_parentId_fkey"
  FOREIGN KEY ("parentId")
  REFERENCES "Parent"(id)
  ON DELETE CASCADE;
Estrangeiro companheiro
fonte
5

Uso:

select replace_foreign_key('user_rates_posts', 'post_id', 'ON DELETE CASCADE');

Função:

CREATE OR REPLACE FUNCTION 
    replace_foreign_key(f_table VARCHAR, f_column VARCHAR, new_options VARCHAR) 
RETURNS VARCHAR
AS $$
DECLARE constraint_name varchar;
DECLARE reftable varchar;
DECLARE refcolumn varchar;
BEGIN

SELECT tc.constraint_name, ccu.table_name AS foreign_table_name, ccu.column_name AS foreign_column_name 
FROM 
    information_schema.table_constraints AS tc 
    JOIN information_schema.key_column_usage AS kcu
      ON tc.constraint_name = kcu.constraint_name
    JOIN information_schema.constraint_column_usage AS ccu
      ON ccu.constraint_name = tc.constraint_name
WHERE constraint_type = 'FOREIGN KEY' 
   AND tc.table_name= f_table AND kcu.column_name= f_column
INTO constraint_name, reftable, refcolumn;

EXECUTE 'alter table ' || f_table || ' drop constraint ' || constraint_name || 
', ADD CONSTRAINT ' || constraint_name || ' FOREIGN KEY (' || f_column || ') ' ||
' REFERENCES ' || reftable || '(' || refcolumn || ') ' || new_options || ';';

RETURN 'Constraint replaced: ' || constraint_name || ' (' || f_table || '.' || f_column ||
 ' -> ' || reftable || '.' || refcolumn || '); New options: ' || new_options;

END;
$$ LANGUAGE plpgsql;

Esteja ciente: esta função não copiará atributos da chave estrangeira inicial. Leva apenas o nome da tabela estrangeira / nome da coluna, descarta a chave atual e substitui pela nova.

Daniel Garmoshka
fonte