КАСКАД-УДАЛИТЬ только один раз

У меня есть база данных 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и всех таблиц, которые имеют ограничения для этих таблиц и т. Д.

Postgres поддерживает CASCADEс командой TRUNCATE :

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;

Это быстрее, если у вас есть индексы для столбцов и набор данных больше, чем несколько записей.

Да, как уже говорили другие, нет удобного «УДАЛИТЬ ИЗ my_table ... CASCADE» (или эквивалент). Чтобы удалить не каскадные дочерние записи, защищенные внешним ключом, и их предков, на которые ссылаются, вы можете выбрать следующие параметры:

• Выполните все удаления явно, по одному запросу за раз, начиная с дочерних таблиц (хотя это не произойдет, если у вас есть циклические ссылки); или
• Выполните все удаления явно в одном (потенциально массивном) запросе; или
• Предполагая, что ваши не каскадные ограничения внешнего ключа были созданы как «ON DELETE NO ACTION DEFERRABLE», выполните все удаления явно в одной транзакции; или
• Временно удалите ограничения «без действия» и «ограничить» внешнего ключа в графе, воссоздайте их как CASCADE, удалите предков-нарушителей, снова удалите ограничения внешнего ключа и, наконец, воссоздайте их такими, какими они были изначально (таким образом временно ослабив целостность ваши данные); или
• Что-то, наверное, одинаково весело.

Я предполагаю, что намеренно обходить ограничения внешнего ключа не удобно; но я понимаю, почему в определенных обстоятельствах вы захотите это сделать. Если это то, чем вы будете заниматься с какой-то частотой, и если вы хотите повсюду пренебрегать мудростью администраторов баз данных, вы можете автоматизировать это с помощью процедуры.

Я приехал сюда несколько месяцев назад в поисках ответа на вопрос «УДАЛИТЬ КАСКАД только один раз» (первоначально задавался более десяти лет назад!). Я получил некоторое преимущество от умного решения Джо Лава (и варианта Томаса К.Г. де Вильены), но, в конце концов, в моем случае использования были особые требования (например, обработка циклических ссылок внутри таблицы), что заставило меня выбрать другой подход. Этот подход в конечном итоге стал recursively_delete (PG 10.10).

Я уже некоторое время использую recursively_delete в производстве и, наконец, чувствую себя (достаточно осторожно) достаточно уверенно, чтобы сделать его доступным для других, которые могут оказаться здесь в поисках идей. Как и в случае решения Joe Love, оно позволяет вам удалять целые графы данных, как если бы все ограничения внешнего ключа в вашей базе данных были на мгновение установлены на CASCADE, но предлагает пару дополнительных функций:

• Обеспечивает предварительный просмотр ASCII цели удаления и ее графика зависимостей.
• Выполняет удаление в одном запросе с использованием рекурсивных CTE.
• Обрабатывает круговые зависимости, внутри и между таблицами.
• Ручки составные ключи.
• Пропускает ограничения 'set default' и 'set null'.

Вы можете использовать для автоматизации этого, вы можете определить ограничение внешнего ключа с помощью 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;

Удаление с опцией каскада применяется только к таблицам с определенными внешними ключами. Если вы делаете удаление, и он говорит, что вы не можете, потому что это нарушило бы ограничение внешнего ключа, каскад заставит его удалить ошибочные строки.

Если вы хотите удалить связанные строки таким способом, вам нужно сначала определить внешние ключи. Кроме того, помните, что если вы явно не дадите ему указание начать транзакцию или не измените значения по умолчанию, он выполнит автоматическую фиксацию, которая может занять очень много времени для очистки.