CASCADE DELETE juste une fois
J'ai une base de données Postgresql sur laquelle je veux faire quelques suppressions en cascade. Cependant, les tables ne sont pas configurées avec la règle ON DELETE CASCADE. Existe-t-il un moyen de supprimer et de demander à Postgresql de la mettre en cascade cette fois-ci? Quelque chose d'équivalent à
DELETE FROM some_table CASCADE;
Les réponses à cette question plus ancienne donnent à penser qu’une telle solution n’existe pas, mais j’ai pensé que je poserais cette question explicitement pour en être sûr.
Non. Pour le faire une seule fois, écrivez simplement l'instruction delete pour la table que vous souhaitez mettre en cascade.
DELETE FROM some_child_table WHERE some_fk_field IN (SELECT some_id FROM some_Table);
DELETE FROM some_table;
Si vous voulez vraiment DELETE FROM some_table CASCADE; qui signifie ", supprimez toutes les lignes de la table some_table ", vous pouvez utiliser TRUNCATE au lieu de DELETE et CASCADE est toujours supporté. Toutefois, si vous souhaitez utiliser la suppression sélective avec une clause where, TRUNCATE ne suffit pas.
USE WITH CARE - Ceci supprimera toutes les lignes de toutes les tables qui ont une contrainte de clé étrangère sur some_table et toutes les tables ayant des contraintes sur ces tables, etc.
Postgres supporte CASCADE avec commande TRUNCATE :
TRUNCATE some_table CASCADE;
Il s’agit bien d’une opération transactionnelle (c’est-à-dire qu’elle peut être annulée), bien qu’elle ne soit pas totalement isolée des autres transactions simultanées et comporte plusieurs autres mises en garde. Lisez la documentation pour plus de détails.
J'ai écrit une fonction (récursive) pour supprimer n'importe quelle ligne en fonction de sa clé primaire. J'ai écrit ceci parce que je ne voulais pas créer mes contraintes comme "on delete cascade". Je voulais pouvoir supprimer des ensembles de données complexes (en tant que DBA) mais ne pas permettre à mes programmeurs de pouvoir supprimer en cascade sans réfléchir à toutes les répercussions. Je teste toujours cette fonction, il y a donc peut-être des bogues, mais n'essayez pas si votre base de données contient des clés primaires multi-colonnes (et donc étrangères). De plus, les clés doivent toutes pouvoir être représentées sous forme de chaîne, mais elles pourraient être écrites sans aucune restriction. J'utilise cette fonction TRÈS ÉPARGNEMENT de toute façon, j'accorde trop de valeur à mes données pour activer les contraintes en cascade sur tout. Fondamentalement, cette fonction est transmise dans le schéma, le nom de la table et la valeur primaire (sous forme de chaîne). Elle commence par rechercher les clés étrangères de cette table et garantit que les données n'existent pas. Si c'est le cas, elle appelle de manière récursive. lui-même sur les données trouvées. Il utilise un tableau de données déjà marqué pour suppression afin d'éviter des boucles infinies. S'il vous plaît testez-le et laissez-moi savoir comment cela fonctionne pour vous. Note: c'est un peu lent. Je l'appelle comme suit: select delete_cascade('public','my_table','1');
create or replace function delete_cascade(p_schema varchar, p_table varchar, p_key varchar, p_recursion varchar[] default null)
returns integer as $$
declare
rx record;
rd record;
v_sql varchar;
v_recursion_key varchar;
recnum integer;
v_primary_key varchar;
v_rows integer;
begin
recnum := 0;
select ccu.column_name into v_primary_key
from
information_schema.table_constraints tc
join information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name and ccu.constraint_schema=tc.constraint_schema
and tc.constraint_type='PRIMARY KEY'
and tc.table_name=p_table
and tc.table_schema=p_schema;
for rx in (
select kcu.table_name as foreign_table_name,
kcu.column_name as foreign_column_name,
kcu.table_schema foreign_table_schema,
kcu2.column_name as foreign_table_primary_key
from information_schema.constraint_column_usage ccu
join information_schema.table_constraints tc on tc.constraint_name=ccu.constraint_name and tc.constraint_catalog=ccu.constraint_catalog and ccu.constraint_schema=ccu.constraint_schema
join information_schema.key_column_usage kcu on kcu.constraint_name=ccu.constraint_name and kcu.constraint_catalog=ccu.constraint_catalog and kcu.constraint_schema=ccu.constraint_schema
join information_schema.table_constraints tc2 on tc2.table_name=kcu.table_name and tc2.table_schema=kcu.table_schema
join information_schema.key_column_usage kcu2 on kcu2.constraint_name=tc2.constraint_name and kcu2.constraint_catalog=tc2.constraint_catalog and kcu2.constraint_schema=tc2.constraint_schema
where ccu.table_name=p_table and ccu.table_schema=p_schema
and TC.CONSTRAINT_TYPE='FOREIGN KEY'
and tc2.constraint_type='PRIMARY KEY'
)
loop
v_sql := 'select '||rx.foreign_table_primary_key||' as key from '||rx.foreign_table_schema||'.'||rx.foreign_table_name||'
where '||rx.foreign_column_name||'='||quote_literal(p_key)||' for update';
--raise notice '%',v_sql;
--found a foreign key, now find the primary keys for any data that exists in any of those tables.
for rd in execute v_sql
loop
v_recursion_key=rx.foreign_table_schema||'.'||rx.foreign_table_name||'.'||rx.foreign_column_name||'='||rd.key;
if (v_recursion_key = any (p_recursion)) then
--raise notice 'Avoiding infinite loop';
else
--raise notice 'Recursing to %,%',rx.foreign_table_name, rd.key;
recnum:= recnum +delete_cascade(rx.foreign_table_schema::varchar, rx.foreign_table_name::varchar, rd.key::varchar, p_recursion||v_recursion_key);
end if;
end loop;
end loop;
begin
--actually delete original record.
v_sql := 'delete from '||p_schema||'.'||p_table||' where '||v_primary_key||'='||quote_literal(p_key);
execute v_sql;
get diagnostics v_rows= row_count;
--raise notice 'Deleting %.% %=%',p_schema,p_table,v_primary_key,p_key;
recnum:= recnum +v_rows;
exception when others then recnum=0;
end;
return recnum;
end;
$$
language PLPGSQL;
Si je comprends bien, vous devriez pouvoir faire ce que vous voulez en supprimant la contrainte de clé étrangère, en en ajoutant une nouvelle (qui sera mise en cascade), en effectuant vos tâches et en recréant la contrainte de clé étrangère restrictive.
Par exemple:
testing=# create table a (id integer primary key);
NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "a_pkey" for table "a"
CREATE TABLE
testing=# create table b (id integer references a);
CREATE TABLE
-- put some data in the table
testing=# insert into a values(1);
INSERT 0 1
testing=# insert into a values(2);
INSERT 0 1
testing=# insert into b values(2);
INSERT 0 1
testing=# insert into b values(1);
INSERT 0 1
-- restricting works
testing=# delete from a where id=1;
ERROR: update or delete on table "a" violates foreign key constraint "b_id_fkey" on table "b"
DETAIL: Key (id)=(1) is still referenced from table "b".
-- find the name of the constraint
testing=# \d b;
Table "public.b"
Column | Type | Modifiers
--------+---------+-----------
id | integer |
Foreign-key constraints:
"b_id_fkey" FOREIGN KEY (id) REFERENCES a(id)
-- drop the constraint
testing=# alter table b drop constraint b_a_id_fkey;
ALTER TABLE
-- create a cascading one
testing=# alter table b add FOREIGN KEY (id) references a(id) on delete cascade;
ALTER TABLE
testing=# delete from a where id=1;
DELETE 1
testing=# select * from a;
id
----
2
(1 row)
testing=# select * from b;
id
----
2
(1 row)
-- it works, do your stuff.
-- [stuff]
-- recreate the previous state
testing=# \d b;
Table "public.b"
Column | Type | Modifiers
--------+---------+-----------
id | integer |
Foreign-key constraints:
"b_id_fkey" FOREIGN KEY (id) REFERENCES a(id) ON DELETE CASCADE
testing=# alter table b drop constraint b_id_fkey;
ALTER TABLE
testing=# alter table b add FOREIGN KEY (id) references a(id) on delete restrict;
ALTER TABLE
Bien sûr, vous devriez inclure de telles choses dans une procédure, pour préserver votre santé mentale.
Je ne peux pas commenter la réponse palehorse, alors j'ai ajouté ma propre réponse. Le logical Palehorse est correct, mais l'efficacité peut être mauvaise avec les grands ensembles de données.
DELETE FROM some_child_table sct WHERE exists (SELECT FROM some_Table st
where sct.some_fk_fiel=st.some_id );
DELETE FROM some_table;
C'est plus rapide si vous avez des index sur les colonnes et que le jeu de données est plus grand que quelques enregistrements.
J'ai pris la réponse de Joe Love et l'ai réécrite à l'aide de l'opérateur IN avec sous-sélection au lieu de = pour rendre la fonction plus rapide (selon la suggestion de Hubbitus):
create or replace function delete_cascade(p_schema varchar, p_table varchar, p_keys varchar, p_subquery varchar default null, p_foreign_keys varchar[] default array[]::varchar[])
returns integer as $$
declare
rx record;
rd record;
v_sql varchar;
v_subquery varchar;
v_primary_key varchar;
v_foreign_key varchar;
v_rows integer;
recnum integer;
begin
recnum := 0;
select ccu.column_name into v_primary_key
from
information_schema.table_constraints tc
join information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name and ccu.constraint_schema=tc.constraint_schema
and tc.constraint_type='PRIMARY KEY'
and tc.table_name=p_table
and tc.table_schema=p_schema;
for rx in (
select kcu.table_name as foreign_table_name,
kcu.column_name as foreign_column_name,
kcu.table_schema foreign_table_schema,
kcu2.column_name as foreign_table_primary_key
from information_schema.constraint_column_usage ccu
join information_schema.table_constraints tc on tc.constraint_name=ccu.constraint_name and tc.constraint_catalog=ccu.constraint_catalog and ccu.constraint_schema=ccu.constraint_schema
join information_schema.key_column_usage kcu on kcu.constraint_name=ccu.constraint_name and kcu.constraint_catalog=ccu.constraint_catalog and kcu.constraint_schema=ccu.constraint_schema
join information_schema.table_constraints tc2 on tc2.table_name=kcu.table_name and tc2.table_schema=kcu.table_schema
join information_schema.key_column_usage kcu2 on kcu2.constraint_name=tc2.constraint_name and kcu2.constraint_catalog=tc2.constraint_catalog and kcu2.constraint_schema=tc2.constraint_schema
where ccu.table_name=p_table and ccu.table_schema=p_schema
and TC.CONSTRAINT_TYPE='FOREIGN KEY'
and tc2.constraint_type='PRIMARY KEY'
)
loop
v_foreign_key := rx.foreign_table_schema||'.'||rx.foreign_table_name||'.'||rx.foreign_column_name;
v_subquery := 'select "'||rx.foreign_table_primary_key||'" as key from '||rx.foreign_table_schema||'."'||rx.foreign_table_name||'"
where "'||rx.foreign_column_name||'"in('||coalesce(p_keys, p_subquery)||') for update';
if p_foreign_keys @> ARRAY[v_foreign_key] then
--raise notice 'circular recursion detected';
else
p_foreign_keys := array_append(p_foreign_keys, v_foreign_key);
recnum:= recnum + delete_cascade(rx.foreign_table_schema, rx.foreign_table_name, null, v_subquery, p_foreign_keys);
p_foreign_keys := array_remove(p_foreign_keys, v_foreign_key);
end if;
end loop;
begin
if (coalesce(p_keys, p_subquery) <> '') then
v_sql := 'delete from '||p_schema||'."'||p_table||'" where "'||v_primary_key||'"in('||coalesce(p_keys, p_subquery)||')';
--raise notice '%',v_sql;
execute v_sql;
get diagnostics v_rows = row_count;
recnum := recnum + v_rows;
end if;
exception when others then recnum=0;
end;
return recnum;
end;
$$
language PLPGSQL;
Vous pouvez utiliser pour automatiser cela, vous pouvez définir la contrainte de clé étrangère avec ON DELETE CASCADE.
Je cite le le manuel des contraintes de clé étrangère :
CASCADEspécifie que lorsqu'une ligne référencée est supprimée, la ou les lignes référençant celle-ci doivent également être automatiquement supprimées.
L'option de suppression avec cascade s'applique uniquement aux tables avec des clés étrangères définies. Si vous effectuez une suppression et que cela est impossible, car cela enfreindrait la contrainte de clé étrangère, la cascade entraînera la suppression des lignes incriminées.
Si vous souhaitez supprimer les lignes associées de cette manière, vous devez d’abord définir les clés étrangères. De plus, rappelez-vous que, sauf si vous lui indiquez explicitement de commencer une transaction ou si vous modifiez les valeurs par défaut, il effectuera une validation automatique, ce qui peut prendre beaucoup de temps à nettoyer.