Einführung in Transaktionen: BEGIN, COMMIT, ROLLBACK

In unserem Kurs schauen wir uns Transaktionen gleich dreimal an. Und jedes Mal entdecken wir was Neues. Jetzt lernen wir erstmal die Basics von Transaktionen. In der zweiten Hälfte des Kurses geht’s dann um die Isolationslevel von Transaktionen und ganz am Ende um die Feinheiten von verschachtelten Transaktionen.

Was ist eine Transaktion

Fangen wir easy an – mit der Definition. Eine Transaktion ist eine Gruppe von Aktionen, die nur zusammen ausgeführt werden. Punkt.

Daraus folgt was Wichtiges: Wenn bei irgendeiner (wirklich irgendeiner!) Aktion in der Gruppe was schiefgeht, muss das Ergebnis aller anderen Aktionen zurückgesetzt werden und das System wieder in den Ursprungszustand gebracht werden.

Aus SQL-Sicht ist eine Transaktion ein Set von Aktionen (zum Beispiel Einfügen, Aktualisieren oder Löschen von Daten), das garantiert, dass entweder alle Operationen innerhalb der Transaktion erfolgreich abgeschlossen werden oder keine einzige davon ausgeführt wird. Dieses Verhalten macht die Arbeit mit Datenbanken zuverlässig und konsistent, besonders in kritischen Szenarien wie Zahlungsabwicklung oder beim Updaten von zusammenhängenden Daten.

Stell dir vor, du überweist Geld zwischen zwei Bankkonten. Wenn wir’s vereinfachen, gibt’s zwei aufeinanderfolgende Aktionen:

1. Von einem Konto wird ein Betrag abgebucht.
2. Auf das andere Konto wird derselbe Betrag gutgeschrieben.

Wenn am Ende der Aktion was schiefgeht (zum Beispiel stürzt der Server ab), ist es wichtig, dass keiner der Nutzer am Ende der Dumme ist. Mit anderen Worten: Entweder beide Schritte sind erfolgreich (Transaktion wird bestätigt) oder beide werden zurückgesetzt (Transaktion wird abgebrochen).

Transaktionen und die ACID-Prinzipien

Transaktionen basieren auf den ACID-Prinzipien, die uns an vier wichtige Eigenschaften erinnern:

• Atomicity (Atomarität): alles oder nichts. Entweder alle Operationen in der Transaktion werden ausgeführt oder alles wird zurückgesetzt.
• Consistency (Konsistenz): Die Daten bleiben vor und nach der Transaktion in einem korrekten Zustand.
• Isolation (Isolation): Jede Transaktion läuft so, als wäre sie die einzige im System.
• Durability (Dauerhaftigkeit): Nach dem Commit bleiben die Daten erhalten, selbst wenn der Server abstürzt.

Die wichtigsten Befehle zur Steuerung von Transaktionen

Jetzt wird’s praktisch! Hier sind die drei Hauptbefehle, um Transaktionen zu steuern:

1. BEGIN
   Startet eine neue Transaktion. Alle folgenden Aktionen laufen innerhalb dieser Transaktion.

2. COMMIT
   Bestätigt die Änderungen. Nach diesem Befehl sind alle Aktionen dauerhaft gespeichert.

3. ROLLBACK
   Macht die Änderungen rückgängig. Wenn was schiefgeht, kannst du die Transaktion zurücksetzen und die Daten bleiben wie vorher.

Grundlegende Syntax von Transaktionen

So sieht eine einfache Transaktion aus:

BEGIN; 
-- hier kommen deine SQL-Operationen hin
COMMIT;

Beispiel für die Nutzung von ROLLBACK:

BEGIN;
-- Änderung der Tabelle students
UPDATE students
SET grade = grade + 10
WHERE id = 1;

-- Oh! Uns ist klar geworden, dass das ein Fehler war.
ROLLBACK;

Beispiel für die Nutzung einer Transaktion in einer echten Aufgabe

Nehmen wir an, wir haben folgende Tabellen:

students:

courses:

Sagen wir, wir wollen einen Studenten gleichzeitig für einen Kurs anmelden und seine Durchschnittsnote updaten:

BEGIN;

-- Schritt 1: Füge einen Eintrag in die Tabelle "Kursanmeldungen" ein
INSERT INTO course_enrollments (student_id, course_id)
VALUES (1, 2);

-- Schritt 2: Update die Durchschnittsnote des Studenten
UPDATE students
SET grade = grade + 5
WHERE id = 1;

COMMIT;

Was passiert, wenn der Server zwischen dem ersten und zweiten Schritt abstürzt? Wenn wir keine Transaktion nutzen würden, wären die Daten inkonsistent: Die Kursanmeldung wäre drin, aber die Note nicht aktualisiert. Mit einer Transaktion werden aber entweder beide Aktionen durchgeführt oder beide zurückgesetzt.

Fehlerbehandlung innerhalb von Transaktionen

Manchmal läuft was schief und wir müssen den Fehler sauber behandeln. In PostgreSQL wird eine Transaktion automatisch zurückgesetzt, wenn ein Fehler passiert.

Lass uns absichtlich einen Fehler machen und schauen, was passiert. Stell dir vor, wir haben eine Unique-Constraint auf die Spalte student_id in der Tabelle course_enrollments. Wir versuchen jetzt, eine doppelte Zeile einzufügen:

BEGIN;

INSERT INTO course_enrollments (student_id, course_id)
VALUES (1, 2);

-- ENDE DER TRANSAKTION (noch nicht ausgeführt)
COMMIT;

Wenn du einen Studenten einfügst, der schon für den Kurs angemeldet ist, gibt’s einen Fehler und PostgreSQL beendet die Transaktion automatisch mit einem Rollback.

ROLLBACK für manuelles Zurücksetzen nutzen

Oft kann man Fehler nicht vorhersehen und will die Transaktion zurücksetzen, falls was schiefgeht:

BEGIN;

-- Neuen Studenten hinzufügen
INSERT INTO students (name, grade)
VALUES ('Omori Sanny', 75);

-- Ups! Uns ist klar geworden, dass der Student versehentlich hinzugefügt wurde.
ROLLBACK;

Nach dem ROLLBACK bleibt die Tabelle unverändert – Omori Sanny taucht in students gar nicht erst auf.

Nützliche Tipps und typische Fehler

Mit Transaktionen arbeitest du entspannter, wenn du ein paar wichtige Regeln beachtest:

• Nutze immer Transaktionen, wenn deine Aktion mehr als einen Schritt hat, besonders wenn du Daten in mehreren Tabellen änderst.
• Vergiss nie, die Änderungen zu bestätigen (COMMIT). Sonst bleibt die Transaktion offen und die Daten werden nicht geändert.
• Pack komplexe Aktionen in Transaktionen, um die Konsistenz der Daten zu sichern.
• Wenn du irgendwo einen Fehler siehst, hab keine Angst, ROLLBACK zu nutzen.

Jetzt, wo du weißt, wie du mit Transaktionen deine Aktionen kontrollierst, ist es Zeit, das Ganze in der Praxis auszuprobieren und weiterzugehen zu Transaktionen für Datenintegrität!