Pourquoi devriez-vous différer la restauration des transactions de la base de données Go ?

Comprendre la nécessité de différer la restauration

Lors de l'interaction avec des bases de données à l'aide de Go pour les services Web, il est essentiel de gérer efficacement les transactions. Le report de l'appel Rollback de la transaction joue un rôle crucial dans la simplification du code et la garantie de l'intégrité des données.

Considérez l'extrait de code suivant de la base de données Go/documentation SQL :

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}
defer tx.Rollback()
stmt, err := tx.Prepare("INSERT INTO foo VALUES (?)")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()
for i := 0; i < 10; i++ {
    _, err = stmt.Exec(i)
    if err != nil {
        log.Fatal(err)
    }
}
err = tx.Commit()
if err != nil {
    log.Fatal(err)
}

L'instruction de report ci-jointe à l'appel tx.Rollback() garantit que la transaction sera annulée si des erreurs se produisent avant l'appel tx.Commit(). Cependant, cela soulève une question : pourquoi ne pas simplement gérer l'erreur après tx.Commit() et appeler explicitement tx.Rollback() ?

err := tx.Commit()
if err != nil {
    log.Error(err)
    tx.Rollback()
}

Cette approche semble logique, mais elle néglige un aspect critique du report. .

Le pouvoir du report

Le mot-clé defer dans Go garantit qu'un appel de fonction sera exécuté à la fin de la fonction, même si une erreur se produit ou si la fonction se termine plus tôt via un retour déclaration. Ce comportement est particulièrement précieux dans le contexte des transactions de base de données.

En différant l'appel à tx.Rollback(), vous pouvez simplifier la logique de gestion des erreurs. Si des erreurs se produisent avant l'appel de tx.Commit(), l'instruction defer garantit que la transaction sera annulée, quel que soit l'emplacement de l'erreur.

Au contraire, si vous gérez l'erreur après tx .Commit(), vous devez appeler manuellement tx.Rollback() en cas d'erreur. Cette approche ajoute une autre couche de complexité et augmente le risque d'omettre accidentellement l'appel de restauration.

Commettre une transaction validée

Un autre point important à considérer est que l'appel de tx.Rollback() sur une transaction validée la transaction n’a aucun effet. Une fois qu'une transaction est validée, elle ne peut pas être annulée.

Ce comportement garantit que même si defer tx.Rollback() est appelé après tx.Commit(), la transaction ne sera pas annulée. Cela signifie que vous pouvez différer l'appel de restauration sans craindre d'annuler accidentellement une transaction réussie.

Conclusion

Différer l'appel de restauration de transaction dans Go offre plusieurs avantages, notamment une gestion simplifiée des erreurs, une restauration garantie dans en cas d'erreurs et protection contre l'annulation accidentelle des transactions validées. C'est une technique puissante qui favorise un code propre et fiable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!