1. Introduction aux transactions et à la cohérence des données
Une transaction est une unité logique dans le processus d'exécution d'un système de gestion de base de données, composée d'une série d'opérations. Ces opérations réussissent toutes ou échouent toutes et sont traitées comme un tout indivisible. Les principales caractéristiques d'une transaction peuvent être résumées par l'acronyme ACID :
- Atomicité : Toutes les opérations d'une transaction sont soit complètement réalisées, soit pas du tout ; une réalisation partielle n'est pas possible.
- Cohérence : Une transaction doit faire passer la base de données d'un état cohérent à un autre état cohérent.
- Isolation : L'exécution d'une transaction doit être isolée des interférences des autres transactions, et les données entre plusieurs transactions concurrentes doivent être isolées.
- Durabilité : Une fois qu'une transaction est validée, les modifications effectuées par celle-ci persisteront dans la base de données.
La cohérence des données fait référence au maintien de l'état des données correct et valide dans une base de données après une série d'opérations. Dans les scénarios impliquant un accès concurrentiel ou des défaillances du système, la cohérence des données est particulièrement importante, et les transactions fournissent un mécanisme pour garantir que la cohérence des données n'est pas compromise même en cas d'erreurs ou de conflits.
2. Aperçu du framework ent
ent est un framework d'entité qui, grâce à la génération de code dans le langage de programmation Go, fournit une API sûre pour opérer sur des bases de données. Cela rend les opérations de base de données plus intuitives et sécurisées, capable d'éviter des problèmes de sécurité tels que les injections SQL. En ce qui concerne le traitement des transactions, le framework ent fournit un fort soutien, permettant aux développeurs d'effectuer des opérations de transaction complexes avec un code concis et de garantir que les propriétés ACID des transactions sont respectées.
3. Démarrer une transaction
3.1 Comment démarrer une transaction dans ent
Dans le framework ent, une nouvelle transaction peut être facilement initiée dans un contexte donné en utilisant la méthode client.Tx, renvoyant un objet de transaction Tx. L'exemple de code est le suivant :
tx, err := client.Tx(ctx)
if err != nil {
// Gérer les erreurs lors du démarrage de la transaction
return fmt.Errorf("Une erreur s'est produite lors du démarrage de la transaction : %w", err)
}
// Effectuer des opérations ultérieures en utilisant tx...
3.2 Réaliser des opérations dans une transaction
Une fois que l'objet Tx est créé avec succès, il peut être utilisé pour réaliser des opérations sur la base de données. Toutes les opérations de création, de suppression, de mise à jour et de requête exécutées sur l'objet Tx feront partie de la transaction. L'exemple suivant illustre une série d'opérations :
hub, err := tx.Group.
Create().
SetName("Github").
Save(ctx)
if err != nil {
// En cas d'erreur, annuler la transaction
return rollback(tx, fmt.Errorf("Échec de la création du groupe : %w", err))
}
// Des opérations supplémentaires peuvent être ajoutées ici...
// Valider la transaction
tx.Commit()
4. Gestion des erreurs et annulation dans les transactions
4.1 Importance de la gestion des erreurs
Lors de travailler avec des bases de données, diverses erreurs telles que des problèmes de réseau, des conflits de données ou des violations de contraintes peuvent survenir à tout moment. Gérer correctement ces erreurs est crucial pour maintenir la cohérence des données. Dans une transaction, si une opération échoue, la transaction doit être annulée pour garantir que les opérations partiellement réalisées, qui pourraient compromettre la cohérence de la base de données, ne restent pas en suspens.
4.2 Comment implémenter l'annulation
Dans le framework ent, vous pouvez utiliser la méthode Tx.Rollback() pour annuler l'ensemble de la transaction. En général, une fonction d'aide rollback est définie pour gérer l'annulation et les erreurs, comme illustré ci-dessous :
func rollback(tx *ent.Tx, err error) error {
if rerr := tx.Rollback(); rerr != nil {
// Si l'annulation échoue, retourner l'erreur d'origine et l'erreur d'annulation ensemble
err = fmt.Errorf("%w : Une erreur s'est produite lors de l'annulation de la transaction : %v", err, rerr)
}
return err
}
Grâce à cette fonction rollback, nous pouvons gérer en toute sécurité les erreurs et l'annulation de la transaction chaque fois qu'une opération au sein de la transaction échoue. Cela garantit que même en cas d'erreur, cela n'aura pas d'impact négatif sur la cohérence de la base de données.
5. Utilisation du Client Transactionnel
Dans des applications pratiques, il peut y avoir des scénarios où nous devons rapidement transformer du code non transactionnel en code transactionnel. Dans de tels cas, nous pouvons utiliser un client transactionnel pour migrer le code de manière transparente. Voici un exemple de transformation du code client non transactionnel existant pour prendre en charge les transactions :
// Dans cet exemple, nous encapsulons la fonction Gen d'origine dans une transaction.
func WrapGen(ctx context.Context, client *ent.Client) error {
// Tout d'abord, créer une transaction
tx, err := client.Tx(ctx)
if err != nil {
return err
}
// Obtenir le client transactionnel à partir de la transaction
txClient := tx.Client()
// Exécuter la fonction Gen en utilisant le client transactionnel sans modifier le code Gen d'origine
if err := Gen(ctx, txClient); err != nil {
// En cas d'erreur, annuler la transaction
return rollback(tx, err)
}
// En cas de succès, valider la transaction
return tx.Commit()
}
Dans le code ci-dessus, le client transactionnel tx.Client() est utilisé, permettant à la fonction Gen d'origine d'être exécutée sous la garantie de la transaction. Cette approche nous permet de transformer facilement le code non transactionnel existant en code transactionnel avec un impact minimal sur la logique d'origine.
6. Bonnes pratiques pour les Transactions
6.1 Gestion des Transactions avec des Fonctions de Rappel
Lorsque notre logique de code devient complexe et implique de multiples opérations de base de données, la gestion centralisée de ces opérations au sein d'une transaction devient particulièrement importante. Voici un exemple de gestion des transactions via des fonctions de rappel :
func WithTx(ctx context.Context, client *ent.Client, fn func(tx *ent.Tx) error) error {
tx, err := client.Tx(ctx)
if err != nil {
return err
}
// Utiliser defer et recover pour gérer les scénarios de panique potentiels
defer func() {
if v := recover(); v != nil {
tx.Rollback()
panic(v)
}
}()
// Appeler la fonction de rappel fournie pour exécuter la logique métier
if err := fn(tx); err != nil {
// En cas d'erreur, annuler la transaction
if rerr := tx.Rollback(); rerr != nil {
err = fmt.Errorf("%w: annulation de la transaction : %v", err, rerr)
}
return err
}
// Si la logique métier est exempte d'erreurs, valider la transaction
return tx.Commit()
}
En utilisant la fonction WithTx pour encapsuler la logique métier, nous pouvons garantir que même si des erreurs ou des exceptions surviennent dans la logique métier, la transaction sera correctement gérée (soit validée soit annulée).
6.2 Utilisation des Hooks de Transaction
Tout comme les hooks de schéma et les hooks d'exécution, nous pouvons également enregistrer des hooks dans une transaction active (Tx) qui seront déclenchés lors de Tx.Commit ou Tx.Rollback :
func Do(ctx context.Context, client *ent.Client) error {
tx, err := client.Tx(ctx)
if err != nil {
return err
}
tx.OnCommit(func(next ent.Committer) ent.Committer {
return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
// Logique avant la validation de la transaction
err := next.Commit(ctx, tx)
// Logique après la validation de la transaction
return err
})
})
tx.OnRollback(func(next ent.Rollbacker) ent.Rollbacker {
return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
// Logique avant l'annulation de la transaction
err := next.Rollback(ctx, tx)
// Logique après l'annulation de la transaction
return err
})
})
// Exécuter d'autres logiques métier
//
//
//
return err
}
En ajoutant des hooks lors de la validation et de l'annulation de la transaction, nous pouvons gérer des logiques supplémentaires, telles que la journalisation ou la récupération des ressources.
7. Comprendre les différents niveaux d'isolation des transactions
Dans un système de base de données, définir le niveau d'isolation des transactions est crucial pour prévenir divers problèmes de concurrence (comme les lectures sales, les lectures non reproductibles et les lectures fantômes). Voici quelques niveaux d'isolation standard et comment les définir dans le framework ent :
- READ UNCOMMITTED : Le niveau le plus bas, permettant la lecture des modifications de données qui n'ont pas été validées, ce qui peut entraîner des lectures sales, des lectures non reproductibles et des lectures fantômes.
- READ COMMITTED : Permet la lecture et la validation des données, empêchant les lectures sales, mais des lectures non reproductibles et des lectures fantômes peuvent encore se produire.
- REPEATABLE READ : Garantit que la lecture des mêmes données plusieurs fois au sein de la même transaction produit des résultats cohérents, évitant les lectures non reproductibles, mais des lectures fantômes peuvent encore se produire.
- SERIALIZABLE : Le niveau d'isolation le plus strict, il tente de prévenir les lectures sales, les lectures non reproductibles et les lectures fantômes en verrouillant les données concernées.
Dans ent, si le pilote de base de données prend en charge le réglage du niveau d'isolation des transactions, il peut être défini comme suit :
// Définir le niveau d'isolation des transactions sur repeatable read
tx, err := client.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
Comprendre les niveaux d'isolation des transactions et leur application dans les bases de données est crucial pour garantir la cohérence des données et la stabilité du système. Les développeurs devraient choisir un niveau d'isolation approprié en fonction des besoins spécifiques de l'application pour atteindre la meilleure pratique en matière de sécurité des données et d'optimisation des performances.