КАСКАДНОЕ УДАЛЕНИЕ только один раз
https://stackoverflow.com/questions/129265
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
У меня есть база данных Postgresql, в которой я хочу выполнить несколько каскадных удалений.Однако таблицы не настроены с использованием правила ON DELETE CASCADE.Есть ли способ выполнить удаление и сказать Postgresql, чтобы он каскадировал его только один раз?Что-то эквивалентное
DELETE FROM some_table CASCADE;
Ответы на этот старый вопрос может показаться, что такого решения не существует, но я решил задать этот вопрос явно, просто чтобы быть уверенным.
Решение
Нет.Чтобы сделать это только один раз, вам нужно просто написать оператор удаления для таблицы, которую вы хотите каскадировать.
DELETE FROM some_child_table WHERE some_fk_field IN (SELECT some_id FROM some_Table);
DELETE FROM some_table;
Другие советы
Если ты действительно хочешь DELETE FROM some_table CASCADE; что значит "удалить все строки из таблицы some_table", вы можете использовать TRUNCATE вместо DELETE и CASCADE всегда поддерживается.Однако если вы хотите использовать выборочное удаление с where пункт, TRUNCATE недостаточно хорош.
ИСПОЛЬЗУЙТЕ С осторожностью - Это будет удалить все строки всех таблиц которые имеют ограничение внешнего ключа на some_table и все таблицы, которые имеют ограничения на эти таблицы и т. д.
Постгрес поддерживает CASCADE с команда УСЕЧИТЬ:
TRUNCATE some_table CASCADE;
Удобно, что это транзакционно (т.можно откатить), хотя он не полностью изолирован от других параллельных транзакций и имеет несколько других предостережений.Подробности читайте в документации.
Я написал (рекурсивную) функцию для удаления любой строки на основе ее первичного ключа.Я написал это, потому что не хотел создавать свои ограничения как «каскадное удаление».Я хотел иметь возможность удалять сложные наборы данных (как администратор базы данных), но не позволять моим программистам выполнять каскадное удаление, не задумываясь обо всех последствиях.Я все еще тестирую эту функцию, поэтому в ней могут быть ошибки, но, пожалуйста, не пытайтесь использовать ее, если ваша БД имеет многостолбцовые первичные (и, следовательно, внешние) ключи.Кроме того, все ключи должны быть представлены в строковой форме, но их можно записать таким образом, чтобы не было такого ограничения.В любом случае я использую эту функцию ОЧЕНЬ ЭКОНОМНО, я слишком ценю свои данные, чтобы включить каскадные ограничения для всего.По сути, эта функция передается в схеме, имени таблицы и первичном значении (в строковой форме), и она начнет с поиска любых внешних ключей в этой таблице и убедится, что данные не существуют - если они существуют, она рекурсивно вызывает себя по найденным данным.Он использует массив данных, уже помеченных для удаления, чтобы предотвратить бесконечные циклы.Пожалуйста, проверьте это и дайте мне знать, как это работает для вас.Примечание:Это немного медленно.Я называю это так: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;
Если я правильно понимаю, вы сможете делать то, что хотите, отбрасывая ограничение внешнего ключа, добавляя новое (которое будет каскадным), выполняя свои действия и воссоздавая ограничивающее ограничение внешнего ключа.
Например:
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
Конечно, вам следует абстрагировать подобные вещи в процедуру ради вашего психического здоровья.
Я не могу комментировать ответ Пэйлхорса, поэтому добавил свой собственный ответ.Логика Бледного коня хороша, но эффективность может быть плохой при работе с большими наборами данных.
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;
Это быстрее, если у вас есть индексы по столбцам, а набор данных больше, чем несколько записей.
Вы можете использовать это для автоматизации, вы можете определить ограничение внешнего ключа с помощью ON DELETE CASCADE.
Я цитирую руководство по ограничениям внешнего ключа:
CASCADEУказывает, что при удалении указанной строки строки (ы) ссылаются на ее также автоматически удалять.
Я взял ответ Джо Лава и переписал его, используя IN оператор с подвыборками вместо = чтобы сделать функцию быстрее (согласно предложению 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;
Удаление с опцией каскадирования применяется только к таблицам с определенными внешними ключами.Если вы выполняете удаление, и он говорит, что вы не можете, потому что это нарушит ограничение внешнего ключа, каскад заставит его удалить строки, нарушающие правила.
Если вы хотите удалить связанные строки таким образом, вам необходимо сначала определить внешние ключи.Кроме того, помните, что если вы явно не укажете ему начать транзакцию или не измените значения по умолчанию, он выполнит автоматическую фиксацию, очистка которой может занять очень много времени.
