Comment gérer les transactions dans une seule méthode lorsqu'il y a plusieurs opérations transactionnelles, en tenant compte du contexte d'exécution?

En Go, pour gérer des transactions dans une même méthode avec plusieurs opérations transactionnelles, on utilise généralement un objet de transaction obtenu à partir du contexte de la base de données (par exemple, *sql.Tx). Il est important de transmettre cet objet à chaque fonction effectuant des opérations sur la base de données, afin qu'elles fassent toutes partie d'une même transaction.

Exemple:

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 {
    // Exécution de requêtes SQL via tx.Exec ou tx.Query
    return nil
}

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

Ainsi, toutes les opérations s'effectuent dans le cadre d'une même transaction, et en cas d'erreur, un rollback est effectué. Le contexte d'exécution (context.Context) peut être utilisé pour annuler ou définir un délai d'attente, en le passant aux méthodes de requête, mais l'objet de transaction doit être transmis explicitement.