CASCADE DELETE nur einmal

Ich habe eine Postgresql-Datenbank, in der ich einige kaskadierende Löschvorgänge ausführen möchte. Die Tabellen werden jedoch nicht mit der Regel ON DELETE CASCADE eingerichtet. Gibt es eine Möglichkeit, einen Löschvorgang durchzuführen und Postgresql anzuweisen, ihn nur einmal zu kaskadieren? Etwas Äquivalentes zu

DELETE FROM some_table CASCADE;

Die Antworten auf diese ältere Frage lassen den Eindruck entstehen, dass es keine solche Lösung gibt, aber ich dachte, ich würde diese Frage explizit stellen, nur um sicherzugehen.

Nein. Um dies nur einmal zu tun, schreiben Sie einfach die delete-Anweisung für die Tabelle, die Sie kaskadieren möchten.

DELETE FROM some_child_table WHERE some_fk_field IN (SELECT some_id FROM some_Table);
DELETE FROM some_table;

Wenn Sie wirklich wollen, DELETE FROM some_table CASCADE; was bedeutet " Alle Zeilen aus der Tabelle entfernensome_table ", können Sie TRUNCATEanstelle von DELETEund CASCADEwird immer unterstützt. Wenn Sie jedoch selektives Löschen mit einer whereKlausel verwenden möchten , TRUNCATEist dies nicht gut genug.

VERWENDUNG MIT PFLEGE - Hiermit werden alle Zeilen aller Tabellen gelöscht , für die eine Fremdschlüsseleinschränkung gilt, some_tablesowie alle Tabellen, für die diese Tabellen usw. eingeschränkt sind.

Postgres unterstützt CASCADEmit dem Befehl TRUNCATE :

TRUNCATE some_table CASCADE;

Handlich ist dies eine Transaktion (dh kann zurückgesetzt werden), obwohl sie nicht vollständig von anderen gleichzeitigen Transaktionen isoliert ist und mehrere andere Einschränkungen aufweist. Lesen Sie die Dokumente für Details.

Ich habe eine (rekursive) Funktion geschrieben, um jede Zeile basierend auf ihrem Primärschlüssel zu löschen. Ich habe dies geschrieben, weil ich meine Einschränkungen nicht als "On Delete Cascade" erstellen wollte. Ich wollte in der Lage sein, komplexe Datensätze (als DBA) zu löschen, aber meinen Programmierern nicht erlauben, das Löschen zu kaskadieren, ohne über alle Auswirkungen nachzudenken. Ich teste diese Funktion immer noch, daher kann es zu Fehlern kommen - aber versuchen Sie es bitte nicht, wenn Ihre Datenbank mehrspaltige Primärschlüssel (und damit Fremdschlüssel) enthält. Außerdem müssen alle Schlüssel in Zeichenfolgenform dargestellt werden können, sie können jedoch auch so geschrieben werden, dass diese Einschränkung nicht besteht. Ich benutze diese Funktion sowieso SEHR SPAREN, ich schätze meine Daten zu sehr, um die kaskadierenden Einschränkungen für alles zu aktivieren. Grundsätzlich wird diese Funktion im Schema, im Tabellennamen und im Primärwert (in Zeichenfolgenform) übergeben. Zunächst werden Fremdschlüssel in dieser Tabelle gefunden, und es wird sichergestellt, dass keine Daten vorhanden sind. Wenn dies der Fall ist, werden die gefundenen Daten rekursiv aufgerufen. Es verwendet ein Array von Daten, die bereits zum Löschen markiert sind, um Endlosschleifen zu verhindern. Bitte testen Sie es und lassen Sie mich wissen, wie es bei Ihnen funktioniert. Hinweis: Es ist etwas langsam. Ich nenne es so: 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;

Wenn ich das richtig verstehe, sollten Sie in der Lage sein, das zu tun, was Sie wollen, indem Sie die Fremdschlüsseleinschränkung löschen, eine neue hinzufügen (die kaskadiert), Ihre Aufgaben erledigen und die einschränkende Fremdschlüsseleinschränkung neu erstellen.

Beispielsweise:

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

Natürlich sollten Sie solche Dinge aus Gründen Ihrer geistigen Gesundheit in ein Verfahren abstrahieren.

Ich kann die Antwort von Palehorse nicht kommentieren, also habe ich meine eigene Antwort hinzugefügt. Die Logik von Palehorse ist in Ordnung, aber die Effizienz kann bei großen Datenmengen schlecht sein.

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;

Es ist schneller, wenn Sie Indizes für Spalten haben und der Datensatz größer als wenige Datensätze ist.

Ja, wie andere gesagt haben, gibt es kein praktisches 'DELETE FROM my_table ... CASCADE' (oder ein gleichwertiges). Um nicht kaskadierende fremdschlüsselgeschützte untergeordnete Datensätze und ihre referenzierten Vorfahren zu löschen, haben Sie folgende Möglichkeiten:

• Führen Sie alle Löschvorgänge explizit nacheinander ab, beginnend mit untergeordneten Tabellen (obwohl dies nicht funktioniert, wenn Sie Zirkelverweise haben). oder
• Führen Sie alle Löschungen explizit in einer einzigen (möglicherweise massiven) Abfrage durch. oder
• Angenommen, Ihre nicht kaskadierenden Fremdschlüsseleinschränkungen wurden als "ON DELETE NO ACTION DEFERRABLE" erstellt. Führen Sie alle Löschvorgänge explizit in einer einzigen Transaktion aus. oder
• Löschen Sie vorübergehend die Einschränkungen "Keine Aktion" und "Einschränken" von Fremdschlüsseln im Diagramm, erstellen Sie sie als CASCADE neu, löschen Sie die betreffenden Vorfahren, löschen Sie die Fremdschlüsseleinschränkungen erneut und erstellen Sie sie schließlich so, wie sie ursprünglich waren (wodurch die Integrität von vorübergehend geschwächt wird) deine Daten); oder
• Etwas, das wahrscheinlich genauso viel Spaß macht.

Ich gehe davon aus, dass das Umgehen von Fremdschlüsseleinschränkungen nicht bequem ist. aber ich verstehe, warum Sie es unter bestimmten Umständen tun möchten. Wenn es etwas ist, das Sie mit einer gewissen Häufigkeit tun, und wenn Sie bereit sind, die Weisheit von Datenbankadministratoren überall zu missachten, möchten Sie es möglicherweise mit einem Verfahren automatisieren.

Ich bin vor ein paar Monaten hierher gekommen, um eine Antwort auf die Frage "CASCADE DELETE nur einmal" zu suchen (ursprünglich vor über einem Jahrzehnt gestellt!). Ich habe einige Meilen aus der cleveren Lösung von Joe Love (und der Variante von Thomas CG de Vilhena) herausgeholt, aber am Ende hatte mein Anwendungsfall besondere Anforderungen (zum Beispiel die Behandlung von zirkularinternen Zirkelverweisen), die mich zu einem anderen Ansatz zwangen. Dieser Ansatz wurde letztendlich rekursiv gelöscht (PG 10.10).

Ich benutze recursively_delete jetzt schon eine Weile in der Produktion und fühle mich schließlich (vorsichtig) sicher genug, um es anderen zur Verfügung zu stellen, die hier auf der Suche nach Ideen landen könnten. Wie bei der Lösung von Joe Love können Sie ganze Datendiagramme löschen, als ob alle Fremdschlüsseleinschränkungen in Ihrer Datenbank vorübergehend auf CASCADE gesetzt wären, bietet jedoch einige zusätzliche Funktionen:

• Bietet eine ASCII-Vorschau des Löschziels und seines Diagramms der abhängigen Personen.
• Führt das Löschen in einer einzelnen Abfrage mit rekursiven CTEs durch.
• Behandelt zirkuläre Abhängigkeiten, Intra- und Inter-Table.
• Behandelt zusammengesetzte Schlüssel.
• Überspringt die Einschränkungen "Standard festlegen" und "Null festlegen".

Um dies zu automatisieren, können Sie die Fremdschlüsseleinschränkung mit definieren ON DELETE CASCADE.
Ich zitiere das Handbuch der Fremdschlüsseleinschränkungen :

CASCADE Gibt an, dass beim Löschen einer referenzierten Zeile auch die referenzierenden Zeilen automatisch gelöscht werden sollen.

Ich nahm die Antwort von Joe Love und schrieb sie mit dem INOperator mit Unterauswahl neu, anstatt =die Funktion schneller zu machen (gemäß Hubbitus 'Vorschlag):

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;

Das Löschen mit der Kaskadenoption gilt nur für Tabellen mit definierten Fremdschlüsseln. Wenn Sie einen Löschvorgang ausführen und dies nicht möglich ist, da dies die Fremdschlüsseleinschränkung verletzen würde, führt die Kaskade dazu, dass die fehlerhaften Zeilen gelöscht werden.

Wenn Sie zugeordnete Zeilen auf diese Weise löschen möchten, müssen Sie zuerst die Fremdschlüssel definieren. Denken Sie auch daran, dass, wenn Sie es nicht ausdrücklich anweisen, eine Transaktion zu starten, oder wenn Sie die Standardeinstellungen ändern, eine automatische Festschreibung durchgeführt wird, deren Bereinigung sehr zeitaufwändig sein kann.