Ausführbare SQLite-Docs: DELETE

Q: Wie löscht man eine einzelne Zeile in SQLite?

Mit DELETE FROM tabellenname WHERE bedingung;. Die WHERE-Klausel entscheidet, welche Zeilen rausfliegen. Beispiel: DELETE FROM users WHERE id = 7; entfernt genau den User mit der id 7. Ohne WHERE ist die komplette Tabelle leer — also Vorsicht.

Q: Wie lösche ich alle Zeilen einer SQLite-Tabelle?

Einfach DELETE FROM tabellenname; ohne WHERE ausführen. SQLite kennt kein TRUNCATE — DELETE ohne Filter ist das Pendant, und SQLite optimiert das intern (die sogenannte 'Truncate Optimization'). Wenn auch die AUTOINCREMENT-Zähler zurückgesetzt werden sollen, musst du anschließend noch aus sqlite_sequence löschen.

Q: Kann SQLite Löschungen auf verknüpfte Tabellen kaskadieren?

Ja, sofern du ON DELETE CASCADE am Foreign Key definierst und die Foreign Keys per PRAGMA foreign_keys = ON; aktiviert hast. In SQLite sind Foreign Keys standardmäßig aus — ohne das Pragma werden Cascades stillschweigend ignoriert.

Q: Wie sehe ich, welche Zeilen tatsächlich gelöscht wurden?

Häng eine RETURNING-Klausel an: DELETE FROM users WHERE active = 0 RETURNING id, email; liefert die gelöschten Zeilen zurück, genau wie ein SELECT. Praktisch für Logging, Undo-Funktionen oder einfach um zu prüfen, dass wirklich nur das weg ist, was weg sollte.

DELETE entfernt Zeilen – mehr nicht

Mit DELETE löschst du Zeilen aus einer Tabelle. Die Tabelle selbst bleibt erhalten, das Schema wird nicht angefasst, und andere Tabellen sind ebenfalls unberührt (es sei denn, du hast Cascades eingerichtet). Die Syntax ist kurz und knackig:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    email TEXT NOT NULL,
    active INTEGER NOT NULL DEFAULT 1
);

INSERT INTO users (email, active) VALUES
    ('ada@example.com', 1),
    ('boris@example.com', 0),
    ('rosa@example.com', 1);

DELETE FROM users WHERE id = 2;

SELECT * FROM users;

DELETE FROM users WHERE id = 2; sucht alle Zeilen, die zur Bedingung passen, und entfernt sie. Die übrigen zwei Zeilen bleiben unberührt. Die Tabelle selbst existiert weiterhin – du kannst nach wie vor neue Zeilen einfügen.

Das Modell dahinter: DELETE ist im Grunde ein SELECT, das die gefundenen Zeilen wegwirft, statt sie zurückzugeben.

Die WHERE-Klausel macht die ganze Arbeit

Jedes ernstzunehmende DELETE steht und fällt mit seiner WHERE-Klausel. Stimmt sie, löschst du genau das, was du löschen wolltest. Stimmt sie nicht, fliegt deutlich mehr raus – im schlimmsten Fall die komplette Tabelle.

CREATE TABLE posts (
    id INTEGER PRIMARY KEY,
    title TEXT,
    published INTEGER NOT NULL DEFAULT 0,
    views INTEGER NOT NULL DEFAULT 0
);

INSERT INTO posts (title, published, views) VALUES
    ('Entwurf eins',     0, 0),
    ('Alter Hit',        1, 5000),
    ('Veröffentlicht',   1, 120),
    ('Leerer Entwurf',   0, 0);

DELETE FROM posts WHERE published = 0 AND views = 0;

SELECT * FROM posts;

Beide unveröffentlichten Entwürfe ohne Aufrufe sind weg. Die veröffentlichten Zeilen bleiben erhalten, weil die Bedingung auf sie nicht zutrifft. Im WHERE kannst du jeden beliebigen Ausdruck verwenden — IN, LIKE, BETWEEN, Subqueries, Kombinationen aus AND/OR.

Eine Angewohnheit, die sich lohnt: Bevor du ein DELETE absetzt, führe dieselbe WHERE-Klausel erst einmal als SELECT aus.

-- Vorschau, was gelöscht wird:
SELECT * FROM posts WHERE published = 0 AND views = 0;

-- Mit den Zeilen zufrieden? Jetzt löschen:
DELETE FROM posts WHERE published = 0 AND views = 0;

Dieser zweistufige Ablauf hat schon mehr Datenbanken gerettet als sämtliche Backup-Tools zusammen.

DELETE ohne WHERE leert die ganze Tabelle

Lässt du das WHERE weg, löscht DELETE jede einzelne Zeile:

CREATE TABLE log (
    id INTEGER PRIMARY KEY,
    message TEXT
);

INSERT INTO log (message) VALUES ('eins'), ('zwei'), ('drei');

DELETE FROM log;

SELECT COUNT(*) AS remaining FROM log;

Die Tabelle ist zwar leer, existiert aber weiterhin. SQLite kennt kein TRUNCATE – das Pendant lautet DELETE FROM tabelle;, wobei SQLite intern eine sogenannte "Truncate-Optimierung" anwendet: Statt jede Zeile einzeln zu entfernen, werden alle Pages auf einen Schlag verworfen. Schnell, aber trotzdem eine transaktionale Operation, die sich per Rollback rückgängig machen lässt – die ideale SQLite-Truncate-Alternative.

Falls du AUTOINCREMENT auf dem Primärschlüssel nutzt, wird der Zähler dabei nicht automatisch zurückgesetzt. Damit die IDs wieder bei 1 beginnen, musst du zusätzlich die Sequence-Zeile leeren:

DELETE FROM log;
DELETE FROM sqlite_sequence WHERE name = 'log';

Bei einem schlichten INTEGER PRIMARY KEY (also ohne AUTOINCREMENT) vergibt SQLite freigewordene IDs ohnehin neu – der Schritt erübrigt sich also.

Mehrere bestimmte Zeilen löschen

Um eine bekannte Menge an Zeilen zu entfernen, ist IN die sauberste Variante eines sqlite delete:

CREATE TABLE tasks (
    id INTEGER PRIMARY KEY,
    title TEXT,
    status TEXT
);

INSERT INTO tasks (title, status) VALUES
    ('Doku schreiben',     'done'),
    ('PR überprüfen',      'todo'),
    ('Deployment',         'done'),
    ('Tests schreiben',    'todo'),
    ('Archivieren',        'done');

DELETE FROM tasks WHERE id IN (1, 3, 5);

SELECT * FROM tasks;

Du kannst ein DELETE auch über eine Subquery steuern – praktisch, wenn sich die zu löschenden Zeilen über einen Join oder eine andere Tabelle ergeben:

CREATE TABLE tasks (
    id INTEGER PRIMARY KEY,
    title TEXT,
    status TEXT
);
CREATE TABLE archived_status (status TEXT);

INSERT INTO tasks (title, status) VALUES
    ('a', 'done'), ('b', 'todo'), ('c', 'cancelled');
INSERT INTO archived_status VALUES ('done'), ('cancelled');

DELETE FROM tasks
WHERE status IN (SELECT status FROM archived_status);

SELECT * FROM tasks;

SQLite kennt keine DELETE ... JOIN-Syntax wie MySQL – mit einer Subquery im WHERE kommst du aber zum gleichen Ergebnis.

RETURNING: gelöschte Zeilen zurückgeben

Hängst du RETURNING an, bekommst du die gelöschten Datensätze als Ergebnismenge zurück – genau wie bei einem SELECT:

CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    email TEXT,
    active INTEGER NOT NULL DEFAULT 1
);

INSERT INTO users (email, active) VALUES
    ('ada@example.com',   1),
    ('boris@example.com', 0),
    ('carol@example.com', 0);

DELETE FROM users
WHERE active = 0
RETURNING id, email;

Du bekommst zu jeder gelöschten Zeile die id und die email zurück. Das ist Gold wert, und zwar für:

Saubere Logs darüber, was genau entfernt wurde.
Undo-Funktionen (die zurückgegebenen Zeilen einfach zwischenspeichern).
Die Bestätigung in einem einzigen Roundtrip, dass wirklich die erwarteten Zeilen betroffen waren.

RETURNING funktioniert übrigens nicht nur hier, sondern auch bei INSERT und UPDATE. Eine ausführliche Erklärung findest du auf der eigenen Seite dazu.

SQLite ON DELETE CASCADE für verknüpfte Zeilen

Wenn Eltern- und Kindtabelle über einen Fremdschlüssel verbunden sind und du den Eltern-Datensatz löschst, bleiben die Kinder als Waisen zurück – es sei denn, du sagst SQLite ausdrücklich, dass es kaskadieren soll:

PRAGMA foreign_keys = ON;

CREATE TABLE authors (
    id INTEGER PRIMARY KEY,
    name TEXT
);

CREATE TABLE books (
    id INTEGER PRIMARY KEY,
    title TEXT,
    author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE
);

INSERT INTO authors (id, name) VALUES (1, 'Le Guin'), (2, 'Borges');
INSERT INTO books (title, author_id) VALUES
    ('A Wizard of Earthsea', 1),
    ('The Dispossessed',     1),
    ('Ficciones',            2);

DELETE FROM authors WHERE id = 1;

SELECT * FROM books;

Wenn der Autor gelöscht wird, verschwinden automatisch auch seine Bücher. Ohne ON DELETE CASCADE würde dasselbe DELETE entweder durchgehen und verwaiste Bücher zurücklassen (wenn Foreign Keys deaktiviert sind) oder mit einem Constraint-Fehler abbrechen (wenn sie aktiv sind).

Die große Stolperfalle: Foreign Keys sind in SQLite standardmäßig deaktiviert. Du musst für jede Verbindung PRAGMA foreign_keys = ON; ausführen. Ist das Pragma nicht gesetzt, wird ON DELETE CASCADE stillschweigend ignoriert – die Bücher bleiben einfach stehen. Die meisten Treiber setzen das entweder automatisch oder bieten eine entsprechende Option an; schau am besten in der Doku deines Treibers nach.

Weitere Cascade-Optionen, die du kennen solltest: ON DELETE SET NULL (setzt den Fremdschlüssel auf NULL), ON DELETE RESTRICT (verhindert das Löschen, solange Kindzeilen existieren) und ON DELETE NO ACTION (der Standard – verhält sich in den meisten Fällen wie RESTRICT).

DELETE mit LIMIT (Compile-Time-Option)

Manche SQLite-Builds unterstützen DELETE ... LIMIT – praktisch, um riesige Tabellen schrittweise in Batches abzuarbeiten:

DELETE FROM logs
WHERE created_at < '2024-01-01'
ORDER BY created_at
LIMIT 1000;

Dafür muss SQLite mit SQLITE_ENABLE_UPDATE_DELETE_LIMIT kompiliert sein. Bei den offiziellen Binaries und den meisten Sprachbindings (sqlite3 in Python, better-sqlite3 in Node) ist das Flag aktiv. Falls bei dir nicht, kommt ein Syntaxfehler – dann hilft eine Subquery als Workaround:

DELETE FROM logs
WHERE id IN (
    SELECT id FROM logs
    WHERE created_at < '2024-01-01'
    ORDER BY created_at
    LIMIT 1000
);

Batched Deletes halten die Transaktionen klein – das ist wichtig, wenn parallel noch andere Verbindungen lesend auf die Datenbank zugreifen.

Große Löschvorgänge in eine Transaktion packen

Ein DELETE läuft implizit in einer Transaktion – entweder verschwinden alle passenden Zeilen oder keine. Wenn du aber gleich richtig viel löschen willst, lohnt sich eine explizite Transaktion: So kannst du per ROLLBACK zurück, falls dir etwas spanisch vorkommt:

CREATE TABLE accounts (
    id INTEGER PRIMARY KEY,
    balance INTEGER
);

INSERT INTO accounts (balance) VALUES (100), (200), (0), (50), (0);

BEGIN;
    DELETE FROM accounts WHERE balance = 0;
    SELECT COUNT(*) AS remaining FROM accounts;
ROLLBACK;

SELECT COUNT(*) AS still_here FROM accounts;

ROLLBACK macht das DELETE komplett rückgängig. In einer echten Sitzung würdest du COMMIT ausführen, sobald die Anzahl plausibel aussieht. Transaktionen sind außerdem deutlich schneller, wenn du viele Zeilen einzeln löschst — packst du die Schleife in BEGIN/COMMIT, sparst du dir ein fsync pro DELETE.

Was nicht gelöscht wird

Ein paar typische Stolperfallen, die man kennen sollte:

DELETE FROM table; leert die Tabelle, entfernt sie aber nicht. Um die Tabelle selbst loszuwerden, brauchst du DROP TABLE table;.
DELETE verkleinert die Datenbankdatei nicht. Die Seiten werden lediglich zur Wiederverwendung freigegeben. Um den Speicherplatz tatsächlich zurückzugewinnen, führe VACUUM; aus (siehe Performance-Kapitel).
Beim Löschen einer Zeile werden zugehörige Zeilen in anderen Tabellen nicht automatisch mitgelöscht — das passiert nur, wenn ON DELETE CASCADE gesetzt ist und Foreign Keys aktiviert sind.
Ein DELETE, das auf keine Zeile passt, ist kein Fehler. Es ist ein erfolgreiches Statement mit changes() = 0. Wenn du wissen willst, ob wirklich etwas gelöscht wurde, prüfe den Zähler.

Als Nächstes: UPSERT

Oft willst du eigentlich gar nicht löschen — sondern eine Zeile einfügen, falls sie neu ist, oder aktualisieren, falls sie schon existiert. SQLite nennt das UPSERT, und mit der ON CONFLICT-Klausel wird daraus ein einziges Statement statt dreier. Darum geht's im nächsten Abschnitt.

Häufig gestellte Fragen

Wie löscht man eine einzelne Zeile in SQLite?

Mit DELETE FROM tabellenname WHERE bedingung;. Die WHERE-Klausel entscheidet, welche Zeilen rausfliegen. Beispiel: DELETE FROM users WHERE id = 7; entfernt genau den User mit der id 7. Ohne WHERE ist die komplette Tabelle leer — also Vorsicht.

Wie lösche ich alle Zeilen einer SQLite-Tabelle?

Einfach DELETE FROM tabellenname; ohne WHERE ausführen. SQLite kennt kein TRUNCATE — DELETE ohne Filter ist das Pendant, und SQLite optimiert das intern (die sogenannte 'Truncate Optimization'). Wenn auch die AUTOINCREMENT-Zähler zurückgesetzt werden sollen, musst du anschließend noch aus sqlite_sequence löschen.

Kann SQLite Löschungen auf verknüpfte Tabellen kaskadieren?

Ja, sofern du ON DELETE CASCADE am Foreign Key definierst und die Foreign Keys per PRAGMA foreign_keys = ON; aktiviert hast. In SQLite sind Foreign Keys standardmäßig aus — ohne das Pragma werden Cascades stillschweigend ignoriert.

Wie sehe ich, welche Zeilen tatsächlich gelöscht wurden?

Häng eine RETURNING-Klausel an: DELETE FROM users WHERE active = 0 RETURNING id, email; liefert die gelöschten Zeilen zurück, genau wie ein SELECT. Praktisch für Logging, Undo-Funktionen oder einfach um zu prüfen, dass wirklich nur das weg ist, was weg sollte.

Verwandte Konzepte

SQLite DELETE: Zeilen sicher löschen mit WHERE