Wie verwaltet man Transaktionen innerhalb einer einzelnen Methode, wenn mehrere transaktionale Operationen verwendet werden, unter Berücksichtigung des Ausführungskontexts?

In Go wird zur Verwaltung von Transaktionen innerhalb einer Methode mit mehreren transaktionalen Operationen in der Regel ein Transaktionsobjekt verwendet, das aus dem Datenbankkontext (z.B. *sql.Tx) stammt. Es ist wichtig, dieses Objekt an jede Funktion zu übergeben, die Datenbankoperationen durchführt, damit alle Teil einer einzigen Transaktion sind.

Beispiel:

func doComplexOperation(db *sql.DB) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer func() {
        if p := recover(); p != nil {
            tx.Rollback()
            panic(p)
        } else if err != nil {
            tx.Rollback()
        } else {
            err = tx.Commit()
        }
    }()

    err = operation1(tx)
    if err != nil {
        return err
    }

    err = operation2(tx)
    if err != nil {
        return err
    }

    return nil
}

func operation1(tx *sql.Tx) error {
    // Ausführen von SQL-Abfragen mit tx.Exec oder tx.Query
    return nil
}

func operation2(tx *sql.Tx) error {
    // Ähnlich
    return nil
}

Auf diese Weise werden alle Operationen im Rahmen einer einzigen Transaktion ausgeführt, und bei Fehler erfolgt ein Rollback. Der Ausführungskontext (context.Context) kann verwendet werden, um Abbrüche oder Timeouts zu steuern, indem er an die Abfrage-Methoden übergeben wird, aber das Transaktionsobjekt muss explizit übergeben werden.