Transaktionen
Committen und zurückrollen
Transaktionen ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum Transaktionen
Eine Transaktion fasst mehrere Statements zusammen, sodass sie entweder alle erfolgreich sind oder gemeinsam fehlschlagen. Dadurch bleiben Daten konsistent, zum Beispiel beim Übertragen von Geld zwischen zwei Konten, ohne dass es auf halbem Weg verloren geht.
- Atomar: alles oder nichts
- Konsistenter Zustand
- Von anderen Transaktionen isoliert
db.Begin
Begin startet eine Transaktion und gibt ein *sql.Tx zurück. Sie führen Statements auf dem Tx aus, nicht auf dem Pool, damit sie dieselbe Verbindung und dieselbe Transaktion verwenden.
tx, err := db.Begin()
if err != nil {
log.Fatal(err)
}Statements auf dem Tx
Rufen Sie tx.Exec und tx.Query genauso wie auf der db auf. Alles wird jedoch innerhalb der Transaktion ausgeführt, bis Sie einen Commit oder Rollback durchführen.
_, err = tx.Exec("UPDATE accounts SET balance = balance - $1 WHERE id = $2", 100, 1)Commit
tx.Commit() macht alle Änderungen dauerhaft und für andere sichtbar. Wenn ein Fehler zurückgegeben wird, wurde die Transaktion nicht angewendet.
if err := tx.Commit(); err != nil {
log.Fatal(err)
}Rollback
Wenn ein beliebiger Schritt fehlschlägt, rufen Sie tx.Rollback() auf, um alle Änderungen seit Begin zu verwerfen. Die Datenbank kehrt in ihren vorherigen Zustand zurück, als wäre nichts geschehen.
if err != nil {
tx.Rollback()
return err
}Das Muster mit defer Rollback
Ein robustes Idiom besteht darin, direkt nach Begin einen Rollback mit defer zu registrieren. Ein Rollback nach einem erfolgreichen Commit hat keine Auswirkungen. Dadurch wird die Bereinigung auf jedem Fehlerpfad garantiert.
tx, err := db.Begin()
if err != nil { return err }
defer tx.Rollback()
// ... do work ...
return tx.Commit()Beispiel für eine atomare Übertragung
Zwei Aktualisierungen bilden eine logische Operation: Von einem Konto wird abgezogen und einem anderen gutgeschrieben. Beide müssen gemeinsam committet werden, oder keine der beiden Änderungen darf angewendet werden.
Eine ausführbare Transaktionssimulation
Für echte Transaktionen wird eine Datenbank benötigt. Dieses ausführbare Beispiel simuliert Begin, zwei Aktualisierungen und Commit oder Rollback mit einer In-Memory-Map.
package main
import (
"errors"
"fmt"
)
func transfer(bal map[string]int, from, to string, amt int) error {
if bal[from] < amt {
return errors.New("insufficient funds")
}
snapshot := map[string]int{from: bal[from], to: bal[to]}
bal[from] -= amt
bal[to] += amt
if bal[from] < 0 {
bal[from], bal[to] = snapshot[from], snapshot[to]
return errors.New("rolled back")
}
return nil
}
func main() {
bal := map[string]int{"alice": 100, "bob": 20}
if err := transfer(bal, "alice", "bob", 30); err != nil {
fmt.Println("error:", err)
} else {
fmt.Println("committed:", bal)
}
}Isolationsebenen
db.BeginTx akzeptiert Optionen, darunter eine Isolationsebene wie sql.LevelSerializable. Eine höhere Isolation verhindert mehr Anomalien, kann aber die Nebenläufigkeit verringern.
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})Transaktionen kurz halten
Eine Transaktion hält eine Verbindung und möglicherweise auch Sperren. Führen Sie die gesamte SQL möglichst schnell aus, vermeiden Sie Netzwerkaufrufe oder Benutzereingaben innerhalb der Transaktion und committen Sie zeitnah, um Konflikte zu reduzieren.
db und tx niemals mischen
Führen Sie innerhalb einer Transaktion Statements ausschließlich auf dem tx aus. Ein Aufruf von db.Exec verwendet dort eine andere Verbindung außerhalb der Transaktion. Diese Änderungen gehören daher nicht zur Transaktion und werden bei einem Rollback nicht zurückgenommen.
Kurzer Test
Testen Sie Ihr Wissen über Transaktionen.
Zusammenfassung
Sie haben Transaktionen kennengelernt:
- Begin gibt einen *sql.Tx zurück; führen Sie Statements darauf aus
- Commit speichert Änderungen dauerhaft, Rollback verwirft alle Änderungen
- defer tx.Rollback() garantiert die Bereinigung bei Fehlern
- BeginTx legt die Isolation fest; halten Sie Transaktionen kurz
- Mischen Sie db und tx niemals innerhalb einer Transaktion
Häufig gestellte Fragen
Ist die Lektion „Transaktionen“ kostenlos?
Ja — der vollständige Text von „Transaktionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Transaktionen“?
Committen und zurückrollen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Transaktionen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.