Hoe beheer je transacties binnen één methode wanneer er meerdere transactionele operaties worden gebruikt, rekening houdend met de uitvoeringcontext?

In Go wordt voor het beheren van transacties binnen één methode met meerdere transactie-operaties meestal een transactie-object gebruikt dat uit de databasecontext is gehaald (bijvoorbeeld *sql.Tx). Het is belangrijk om dit object door te geven aan elke functie die databasebewerkingen uitvoert, zodat ze allemaal deel uitmaken van dezelfde transactie.

Voorbeeld:

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 {
    // SQL-query's uitvoeren via tx.Exec of tx.Query
    return nil
}

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

Op deze manier worden alle operaties binnen één transactie uitgevoerd, en bij een fout wordt een rollback gedaan. De uitvoeringcontext (context.Context) kan worden gebruikt om te annuleren of een timeout in te stellen, door deze door te geven aan de query-methoden, maar het transactieobject moet expliciet worden doorgegeven.