{"canonical_url":"https://engineer.company/de/glossary/transaction/","content_markdown":"# Transaktion\n\n## Was es ist\n\nEine Transaktion ist eine Gruppe von Änderungen, die eine Datenbank als Einheit anwendet: Entweder wirken alle oder keine. Zur Abgrenzung von einer Zahlung, die ebenfalls als Transaktion bezeichnet wird, heißt es Datenbanktransaktion. Das PostgreSQL-Tutorial beschreibt sie als etwas, das „mehrere Schritte zu einer einzigen Alles-oder-nichts-Operation bündelt“. Zwischenzustände sind für niemand anderen sichtbar.\n\nIn PostgreSQL beginnt eine Transaktion mit `BEGIN` und endet mit `COMMIT`, das ihre Änderungen dauerhaft und für andere Sitzungen sichtbar macht, oder mit `ROLLBACK`, das sie verwirft. Auch eine einzeln gesendete Anweisung läuft in einer Transaktion: PostgreSQL umgibt sie mit einem impliziten `BEGIN` und bei Erfolg mit einem impliziten `COMMIT`. Eine lange Transaktion kann einen `SAVEPOINT` setzen und später mit `ROLLBACK TO` dorthin zurückkehren. Die seitdem geleistete Arbeit wird verworfen; alles davor bleibt erhalten.\n\nDie Garantien einer Transaktion werden als ACID zusammengefasst. Atomarität bedeutet, dass eine Transaktion als Einheit oder gar nicht abgeschlossen wird und kein halbfertiges Ergebnis einen Absturz überlebt. Konsistenz heißt, dass die für die Daten definierten Bedingungen nach dem Commit erfüllt sind. Eine Transaktion, die eine verletzen würde, wird stattdessen zurückgerollt. Isolation bedeutet, dass ihre Änderungen für gleichzeitig laufende Transaktionen bis zum Commit unsichtbar bleiben. Dauerhaftigkeit heißt, dass eine bestätigte Änderung einen Serverabsturz übersteht.\n\nIsolation hat Stufen. Der SQL-Standard definiert vier: Read Uncommitted, Read Committed, Repeatable Read und Serializable. Ohne andere Vorgabe beginnt PostgreSQL jede Transaktion auf Read Committed. Sein Read Uncommitted verhält sich genauso wie Read Committed. Auf Read Committed sieht jede Anweisung die vor ihrem Beginn bestätigten Daten. Zwei Abfragen innerhalb derselben Transaktion können deshalb unterschiedliche Zahlen sehen. Auf Repeatable Read arbeitet die ganze Transaktion mit einem Snapshot, der beim Ausführen ihrer ersten Anweisung entsteht, die keine Anweisung zur Transaktionssteuerung ist. Serializable geht weiter: Gleichzeitige Transaktionen erzeugen dasselbe Ergebnis wie bei einer Ausführung nacheinander.\n\n## Warum es wichtig ist\n\nFast jede aufzeichnungswürdige Aktion betrifft mehr als eine Zeile. Eine Bestellung ist eine Zeile in einer Tabelle, eine Verringerung in einer anderen und ein Eintrag im Journal. Ohne Transaktion hinterlassen ein Absturz, eine Zeitüberschreitung oder eine verletzte Bedingung zwischen der zweiten und dritten Anweisung eine Bestellung ohne abgezogenen Bestand oder einen abgezogenen Bestand ohne Bestellung. Jemand findet es später in einem Bericht und korrigiert es von Hand. Mit einer Transaktion ist dieser halbfertige Zustand für niemanden sichtbar. Das garantiert die Datenbank, nicht die Anwendung.\n\nDer zweite Grund ist Nebenläufigkeit. Zwei gleichzeitig eintreffende Anfragen laufen nebeneinander. Die Isolationsstufe entscheidet, was jede sieht; Sperren entscheiden, wer wartet. Hier erleben Teams die meisten Überraschungen: Code in `BEGIN` und `COMMIT` einzuschließen verhindert allein nicht, dass zwei Anfragen denselben Kontostand lesen und beide ausgeben. Auf Read Committed liest jede Anweisung, was bei ihrem Beginn bestätigt war. Zwischen einer Prüfung in einer Anweisung und einem Schreibvorgang in der nächsten kann deshalb ein Commit einer anderen Sitzung liegen. Die Prüfung muss vorher die Zeile sperren oder Teil des Schreibvorgangs werden.\n\nTransaktionen haben auch Kosten, bezahlt in Zeit. Zeilensperren von `UPDATE`, `DELETE` und `SELECT ... FOR UPDATE` bleiben normalerweise bis zum Transaktionsende bestehen. Ein Rollback zu einem Savepoint gibt die danach erworbenen Sperren frei. Eine Sitzung, die eine dazu im Konflikt stehende Sperre benötigt, muss warten, sofern nicht der Ablauf einer Zeitgrenze, ein Abbruch oder eine Deadlock-Auflösung das Warten beendet. Eine offene Transaktion verhindert außerdem, dass `VACUUM` alte Zeilenversionen entfernt, die sie möglicherweise noch lesen muss. Eine stundenlang offene Transaktion lässt Tabellen deshalb aufblähen. Beim Entwurf geht es nie nur darum, ob eine Transaktion verwendet wird, sondern wo ihre Grenzen liegen und wie wenig dazwischen geschieht.\n\nSchließlich umfasst eine gewöhnliche lokale Datenbanktransaktion nicht von selbst externe Wirkungen. Ein Aufruf bei einem Zahlungsanbieter, eine E-Mail oder eine in eine separate Warteschlange gestellte Nachricht wird durch ein Zurückrollen der Datenbank nicht rückgängig gemacht. Die Abstimmung mit anderen Systemen braucht einen zusätzlichen Entwurf; ein umschließendes `BEGIN` genügt nicht. Was innerhalb der Grenze liegt und wie die Außenwelt von einem Commit erfährt, macht den Großteil des Transaktionsentwurfs aus.\n\n## Wie es in der Praxis aussieht\n\nEin Mitglied eines Treueprogramms gibt 250 Punkte für einen Kinogutschein aus. Drei Dinge müssen gemeinsam geschehen: Die Punkte werden vom Wallet abgezogen, das Journal hält den Grund fest, und die Einlösung wird angelegt. Als eine Transaktion sieht das so aus:\n\n```sql\nBEGIN;\n\nUPDATE wallet\nSET    points = points - 250\nWHERE  member_id = 42\nAND    points \u003e= 250\nRETURNING points;\n-- no row back: not enough points, so ROLLBACK and stop here\n\nINSERT INTO points_entry (member_id, delta, reason)\nVALUES (42, -250, 'redeemed: cinema voucher');\n\nINSERT INTO redemption (member_id, reward_id)\nVALUES (42, 7);\n\nCOMMIT;\n```\n\nDas `UPDATE` nimmt eine Zeilensperre auf dem Wallet von Mitglied 42. Bis zum `COMMIT` sieht jede andere Sitzung, die das Wallet liest, weiter den alten Stand: Zeilensperren blockieren Leser nicht, und unbestätigte Änderungen sind unsichtbar. Eine zweite Einlösung für dasselbe Mitglied, kurz darauf von einem anderen Tab gesendet, erreicht ihr eigenes `UPDATE` und wartet. Sobald die erste Transaktion bestätigt ist, wertet PostgreSQL auf Read Committed die `WHERE`-Bedingung der zweiten erneut gegen den nun vorliegenden Zeilenstand aus. Sind nur noch 100 Punkte übrig, scheitert die Bedingung. Es kommt keine Zeile zurück, und die zweite Anfrage rollt zurück, ohne etwas geschrieben zu haben. Scheitert stattdessen das letzte `INSERT`, etwa weil Prämie 7 zurückgezogen wurde und ein Fremdschlüssel sie ablehnt, rollt der Client zurück. Die Punkte stehen dann genau dort, wo sie vorher waren.\n\nDas ist die Form des [Treue-Wallets mit Ligen und Abzeichen](/de/portfolio/built-a-loyalty-wallet-leagues-and-badges/). Jede Änderung an einem Wallet nimmt dort vor dem Lesen eine Zeilensperre. Eine zweite Anfrage wartet deshalb auf den Abschluss der ersten, statt mit ihr um die Wette zu laufen. Weil das Wallet in derselben Datenbank wie alles andere liegt, werden der Kontostand und das damit Bezahlte gemeinsam bestätigt oder gar nicht. Die Seite nennt den Preis offen: Zeilensperren sind die langsamere Antwort. Mitglieder warten der Reihe nach, statt dieselben Punkte zweimal auszugeben.\n\nDie Notiz darüber, [das letzte Ticket genau einmal zu verkaufen](/de/notes/selling-limited-stock-without-overselling/), setzt dasselbe Werkzeug bei einem Blitzverkauf ein. Ihre Lösung verbindet Bestandsprüfung und Verringerung in einem bedingten `UPDATE`. Eine Sperre, die während der Überlegungen der Anwendung zwischen `SELECT` und `UPDATE` bestehen bleibt, lässt den nächsten Käufer jede einzelne Millisekunde warten. An erster Stelle der übrigen Arbeiten steht, alles Externe aus der Transaktion herauszuhalten: Ein Zahlungsaufruf, eine HTTP-Anfrage oder eine veröffentlichte Nachricht gehört davor oder danach.\n\n## Wo es schiefgeht\n\n**Eine Sitzung bleibt in einer Transaktion untätig, und alles dahinter wartet.** Eine Anwendung öffnet eine Transaktion, aktualisiert eine Zeile und wartet dann auf eine langsame API, den nächsten Klick eines Nutzers oder einen abgestürzten Worker, der nie `COMMIT` sendet. Die Sperren bleiben. Sind Timeouts deaktiviert, lässt PostgreSQL eine Sitzung, die eine kollidierende Sperre anfordert, unbegrenzt warten, sofern es keinen Deadlock erkennt und die Wartezeit nicht abgebrochen wird. Die Dokumentation bezeichnet es als schlechte Idee, eine Transaktion beim Warten auf Nutzereingaben offen zu halten. `pg_stat_activity` zeigt solche Sitzungen im Zustand `idle in transaction`; `xact_start` gibt ihren Beginn an:\n\n```sql\nSELECT pid, now() - xact_start AS open_for, state, query\nFROM pg_stat_activity\nWHERE state LIKE 'idle in transaction%'\nORDER BY xact_start;\n```\n\nDie langsame Arbeit aus der Transaktion verlagern und dem Server eine Grenze geben, damit eine vergessene Transaktion keine Sperren stundenlang halten kann. `idle_in_transaction_session_timeout` beendet jede Sitzung, die länger als sein Wert innerhalb einer offenen Transaktion untätig bleibt. Standardmäßig ist der Wert 0 und die Funktion damit deaktiviert. Der Parameter muss also gesetzt werden, etwa für die Rolle der Anwendung mit `ALTER ROLE app SET idle_in_transaction_session_timeout = '30s';`.\n\n**Zwei Anfragen geben denselben Kontostand aus.** Der Code liest einen Wert in einer Anweisung, entscheidet in der Anwendung und schreibt das Ergebnis mit einer anderen. Zwei Sitzungen lesen dieselbe Zahl, bestehen beide die Prüfung und schreiben beide. Eine Änderung überschreibt dabei unbemerkt die andere. Ein umschließendes `BEGIN` verhindert das auf Read Committed nicht. Die Prüfung wie im obigen Beispiel als Bedingung im `UPDATE` zum Teil des Schreibvorgangs machen oder die Zeile vor dem Lesen mit `SELECT ... FOR UPDATE` sperren. Das lässt die zweite Sitzung auf die erste warten.\n\n**Unter Last erscheinen Fehler bei Repeatable Read oder Serializable.** Auf diesen Stufen lehnt PostgreSQL eine Transaktion ab, die deren Zusicherung verletzen würde, und meldet einen Serialisierungsfehler, SQLSTATE `40001`, etwa `could not serialize access due to concurrent update`. So funktioniert der Entwurf; es ist kein Fehler im Programm. Laut Dokumentation müssen Anwendungen auf diesen Stufen für Wiederholungen gerüstet sein. `40001` abfangen und die ganze Transaktion ab `BEGIN` erneut ausführen, einschließlich ihrer Lesevorgänge. Ihre Entscheidung beruhte auf inzwischen geänderten Daten. Nur die gescheiterte Anweisung zu wiederholen wiederholt den Fehler.\n\n**Zwei Transaktionen geraten in einen Deadlock.** Eine sperrt Bestellung 1 und danach Bestellung 2, die andere Bestellung 2 und danach Bestellung 1. Beide warten aufeinander. PostgreSQL erkennt den Kreis und bricht eine Transaktion ab, damit die andere fertig werden kann. Welche es auswählt, lässt sich schwer vorhersagen. Die dokumentierte Abhilfe besteht darin, in jedem Codepfad Sperren in derselben Reihenfolge anzufordern, etwa durch das Aktualisieren der Zeilen nach aufsteigendem Primärschlüssel, und eine wegen eines Deadlocks abgebrochene Transaktion erneut auszuführen.\n\n**Eine E-Mail geht für eine zurückgerollte Bestellung heraus.** Die Anwendung sendet innerhalb der Transaktion eine Bestätigung oder veröffentlicht ein Ereignis. Dann scheitert eine spätere Anweisung. Der Rollback entfernt die Bestellung, aber nichts kann die E-Mail zurückholen. Die Nachricht in derselben Transaktion wie die beschriebene Änderung in einer Outbox-Tabelle festhalten und nach dem Commit von einem separaten Prozess senden lassen. Dann existiert die Nachricht genau dann, wenn die Bestellung existiert.\n\n## Weiterführende Lektüre\n\n- [Transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)\n  — das PostgreSQL-Tutorial: Alles-oder-nichts-Verhalten, implizite Transaktionen und Savepoints, gezeigt an einer Überweisung.\n- [Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — die vier Standardstufen, ihre jeweilige Sicht in PostgreSQL und die Serialisierungsfehler, die einen erneuten Versuch verlangen.\n- [Explicit Locking](https://www.postgresql.org/docs/current/explicit-locking.html)\n  — Zeilen- und Tabellensperren, ihre Haltedauer sowie Erkennung und Vermeidung von Deadlocks.\n- [Client Connection Defaults](https://www.postgresql.org/docs/current/runtime-config-client.html)\n  — `default_transaction_isolation`, `idle_in_transaction_session_timeout`, `lock_timeout` und die übrigen Sitzungsgrenzen.\n- [Routine Vacuuming](https://www.postgresql.org/docs/current/routine-vacuuming.html)\n  — warum alte Zeilenversionen bleiben, solange eine Transaktion sie noch sehen könnte, und was lange offene Transaktionen für die Bereinigung bedeuten.\n\n\u003chttps://engineer.company/de/glossary/transaction/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Wie Datenbanken mehrere Änderungen als Einheit behandeln: Commit, Rollback, Isolationsstufen, Zeilensperren und fünf typische Transaktionsfehler.","formats":{"gemtext":"https://engineer.company/de/glossary/transaction/index.gmi","gopher":"https://engineer.company/de/glossary/transaction/gophermap","html":"https://engineer.company/de/glossary/transaction/","json":"https://engineer.company/de/glossary/transaction/index.json","markdown":"https://engineer.company/de/glossary/transaction/index.md","pdf":"https://engineer.company/de/glossary/transaction/index.pdf"},"kind":"page","language":"de","title":"Was ist eine Transaktion?","url":"https://engineer.company/de/glossary/transaction/","version":1}