Transactions
Valider et annuler les transactions
Transactions est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.
Pourquoi utiliser les transactions
Une transaction regroupe plusieurs requêtes afin qu'elles réussissent ou échouent toutes ensemble. Cela garantit la cohérence des données, par exemple lors d'un transfert d'argent entre deux comptes, sans perte en cours d'opération.
- Atomique : tout ou rien
- État cohérent
- Isolée des autres transactions
db.Begin
Begin démarre une transaction et renvoie un *sql.Tx. Vous exécutez les requêtes sur le Tx, et non sur le pool, afin qu'elles partagent une même connexion et une même transaction.
tx, err := db.Begin()
if err != nil {
log.Fatal(err)
}Requêtes sur le Tx
Appelez tx.Exec et tx.Query comme vous le feriez sur la base de données, mais tout s'exécute dans la transaction jusqu'à sa validation ou son annulation.
_, err = tx.Exec("UPDATE accounts SET balance = balance - $1 WHERE id = $2", 100, 1)Commit
tx.Commit() rend toutes les modifications permanentes et visibles par les autres. S'il renvoie une erreur, la transaction n'a pas été appliquée.
if err := tx.Commit(); err != nil {
log.Fatal(err)
}Rollback
Si une étape échoue, appelez tx.Rollback() pour annuler toutes les modifications effectuées depuis Begin. La base de données retrouve son état précédent, comme si rien ne s'était produit.
if err != nil {
tx.Rollback()
return err
}L'idiome defer Rollback
Un idiome robuste consiste à différer Rollback immédiatement après Begin. Un Rollback effectué après un Commit réussi ne fait rien et ne provoque aucune erreur ; cela garantit donc le nettoyage dans tous les chemins d'erreur.
tx, err := db.Begin()
if err != nil { return err }
defer tx.Rollback()
// ... do work ...
return tx.Commit()Exemple de transfert atomique
Deux mises à jour constituent une seule opération logique : soustraire un montant d'un compte et l'ajouter à un autre. Les deux doivent être validées ensemble, sinon aucune ne doit être appliquée.
Une simulation exécutable de transaction
Les transactions réelles nécessitent une base de données. Cet exemple exécutable simule le démarrage, deux mises à jour et la validation ou l'annulation à l'aide d'une carte en mémoire.
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)
}
}Niveaux d'isolation
db.BeginTx accepte des options, notamment un niveau d'isolation tel que sql.LevelSerializable. Un niveau d'isolation plus élevé empêche davantage d'anomalies, mais peut réduire la concurrence.
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})Gardez les transactions courtes
Une transaction retient une connexion et peut conserver des verrous. Effectuez rapidement toutes les opérations SQL, évitez les appels réseau ou la saisie de l'utilisateur à l'intérieur de la transaction, puis validez-la rapidement pour réduire la contention.
Ne mélangez jamais db et tx
Dans une transaction, exécutez les requêtes uniquement sur le tx. Appeler db.Exec à cet endroit utilise une autre connexion, en dehors de la transaction ; ces modifications n'en font donc pas partie et ne seront pas annulées.
Vérification rapide
Vérifiez vos connaissances sur les transactions.
Récapitulatif
Vous avez appris à utiliser les transactions :
- Begin renvoie un *sql.Tx ; exécutez les requêtes sur celui-ci
- Commit conserve les modifications ; Rollback les annule toutes
- defer tx.Rollback() garantit le nettoyage en cas d'erreur
- BeginTx définit l'isolation ; gardez les transactions courtes
- Ne mélangez jamais db et tx au sein d'une même transaction
Questions Fréquemment Posées
La leçon « Transactions » est-elle gratuite ?
Oui — le texte complet de « Transactions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Transactions » ?
Valider et annuler les transactions Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Go Academy ?
Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Transactions » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?
Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.