Kategorien:

DML-Befehle – Allgemeines

DELETE

Entfernt Zeilen aus einer Tabelle. Sie können eine WHERE-Klausel verwenden, um anzugeben, welche Zeilen entfernt werden sollen. Wenn Sie Unterabfragen oder zusätzliche Tabellen verwenden müssen, um die zu entfernenden Zeilen zu identifizieren, geben Sie die Unterabfragen oder Tabellen in einer USING-Klausel an.

Wichtig

Im Gegensatz zu TRUNCATE TABLE löscht dieser Befehl nicht den Ladeverlauf der externen Datei. Wenn Sie Zeilen löschen, die aus einer bereitgestellten Datei in die Tabelle geladen wurden, können Sie die Daten aus dieser Datei nur dann erneut laden, wenn Sie die Datei ändern und erneut bereitstellen.

Syntax

DELETE FROM <table_name>
            [ USING <additional_table_or_query> [, <additional_table_or_query> ] ]
            [ WHERE <condition> ]

Erforderliche Parameter

Tabellenname

Gibt die Tabelle an, aus der die Zeilen entfernt werden.

Optionale Parameter

USING Zusätzliche_Tabelle_oder_Abfrage [, ... ]

Wenn Sie in der WHERE-Klausel auf zusätzliche Tabellen verweisen müssen, um die zu entfernenden Zeilen zu identifizieren, dann geben Sie diese Tabellennamen in der USING-Klausel an. Sie können die USING-Klausel auch verwenden, um Unterabfragen anzugeben, mit denen die zu entfernenden Zeilen identifiziert werden.

Wenn Sie eine Unterabfrage angeben, dann setzen Sie die Unterabfrage in Klammern.

Wenn Sie mehr als eine Tabelle oder Abfrage angeben, verwenden Sie ein Komma, um diese voneinander zu trennen.

WHERE Bedingung

Gibt eine Bedingung an, mit der die zu entfernenden Zeilen ausgewählt werden sollen. Wenn dieser Parameter weggelassen wird, werden alle Zeilen in der Tabelle entfernt, aber die Tabelle bleibt erhalten.

Nutzungshinweise

  • Beim Löschen auf der Grundlage von JOIN (durch Angabe einer USING-Klausel) ist es möglich, dass eine Zeile in der Zieltabelle mit mehreren Zeilen in der/den USING-Tabelle(n) verbunden wird. Wenn die DELETE-Bedingung für eine der verknüpften Kombinationen erfüllt ist, wird die Zielzeile gelöscht.

    Beispielsweise gilt für die gegebenen Tabellen tab1 und tab2 mit den Spalten (k number, v number) Folgendes:

    select * from tab1;
    
    -------+-------+
       k   |   v   |
    -------+-------+
       0   |   10  |
    -------+-------+
    
    Select * from tab2;
    
    -------+-------+
       k   |   v   |
    -------+-------+
       0   |   20  |
       0   |   30  |
    -------+-------+
    

    Wenn Sie die folgende Abfrage ausführen, wird die Zeile in tab1 mit beiden Zeilen von tab2 verbunden:

    DELETE FROM tab1 USING tab2 WHERE tab1.k = tab2.k
    

    Da mindestens ein verknüpftes Paar die Bedingung erfüllt, wird die Zeile gelöscht. Daher ist tab1 nach Abschluss der Anweisung leer.

Beispiele

Angenommen, eine Organisation, die Fahrräder vermietet, verwendet die folgenden Tabellen:

  • Die Tabelle mit dem Namen „leased_bicycles“ listet die Fahrräder auf, die vermietet wurden.

  • Die Tabelle mit dem Namen „returned_bicycles“ listet Fahrräder auf, die kürzlich zurückgegeben wurden. Diese Fahrräder müssen aus der Tabelle der gemieteten Fahrräder entfernt werden.

Tabelle erstellen:

CREATE TABLE leased_bicycles (bicycle_id INTEGER, customer_id INTEGER);
CREATE TABLE returned_bicycles (bicycle_id INTEGER);

Daten laden:

INSERT INTO leased_bicycles (bicycle_ID, customer_ID) VALUES
    (101, 1111),
    (102, 2222),
    (103, 3333),
    (104, 4444),
    (105, 5555);
INSERT INTO returned_bicycles (bicycle_ID) VALUES
    (102),
    (104);

Dieses Beispiel zeigt, wie Sie die WHERE-Klausel verwenden, um bestimmte Zeilen zu löschen. Im folgenden Beispiel wird nach „bicycle_ID“ gelöscht:

DELETE FROM leased_bicycles WHERE bicycle_ID = 105;
+------------------------+
| number of rows deleted |
|------------------------|
|                      1 |
+------------------------+

Daten nach dem Löschen anzeigen:

SELECT * FROM leased_bicycles ORDER BY bicycle_ID;
+------------+-------------+
| BICYCLE_ID | CUSTOMER_ID |
|------------+-------------|
|        101 |        1111 |
|        102 |        2222 |
|        103 |        3333 |
|        104 |        4444 |
+------------+-------------+

Dieses Beispiel zeigt, wie Sie die USING-Klausel verwenden, um zu löschende Zeilen anzugeben. Diese USING-Klausel gibt die Tabelle „returned_bicycles“ an, die die IDs der Fahrräder auflistet, die aus der Tabelle „leased_bicycles“ gelöscht werden sollen. Die WHERE-Klausel verbindet die Tabelle „leased_bicycles“ mit der Tabelle „returned_bicycles“, und die Zeilen in „leased_bicycles“, die dieselbe „bicycle_ID“ wie die entsprechenden Zeilen in „returned_bicycles“ aufweisen, werden gelöscht.

BEGIN WORK;
DELETE FROM leased_bicycles 
    USING returned_bicycles
    WHERE leased_bicycles.bicycle_ID = returned_bicycles.bicycle_ID;
TRUNCATE TABLE returned_bicycles;
COMMIT WORK;

(Um zu vermeiden, dass dieselben Zeilen in Zukunft erneut entfernt werden, wenn dies unnötig oder unangebracht ist, wird die Tabelle „returned_bicycles“ im Zuge derselben Transaktion abgeschnitten).

Daten nach dem Löschen anzeigen:

SELECT * FROM leased_bicycles ORDER BY bicycle_ID;
+------------+-------------+
| BICYCLE_ID | CUSTOMER_ID |
|------------+-------------|
|        101 |        1111 |
|        103 |        3333 |
+------------+-------------+

Nehmen Sie nun an, dass andere Fahrräder zurückgegeben werden:

INSERT INTO returned_bicycles (bicycle_ID) VALUES (103);

Die folgende Abfrage zeigt eine USING-Klausel, die eine Unterabfrage (statt einer Tabelle) enthält, um anzugeben, welche „bicycle_ID“ aus der Tabelle „leased_bicycles“ entfernt werden soll:

BEGIN WORK;
DELETE FROM leased_bicycles 
    USING (SELECT bicycle_ID AS bicycle_ID FROM returned_bicycles) AS returned
    WHERE leased_bicycles.bicycle_ID = returned.bicycle_ID;
TRUNCATE TABLE returned_bicycles;
COMMIT WORK;

Daten nach dem Löschen anzeigen:

SELECT * FROM leased_bicycles ORDER BY bicycle_ID;
+------------+-------------+
| BICYCLE_ID | CUSTOMER_ID |
|------------+-------------|
|        101 |        1111 |
+------------+-------------+