Partie 4 · Fiabilité

Transactions et gestion d'erreur

Le système traite des insertions unitaires et des traitements en lot. Il faut donc prévoir des scénarios transactionnels réalistes :

définir au moins un scénario nécessitant un COMMIT / ROLLBACK ;
décrire un cas d'échec qui doit annuler tout le lot ;
préciser la journalisation attendue en cas de succès et d'erreur ;
expliquer l'intérêt métier d'une gestion transactionnelle correcte.

Critères d'évaluation : utilisation de BEGIN / COMMIT / ROLLBACK, cohérence des scénarios, gestion des erreurs.

Un lot est tout ou rien

Exemple (exemple ajouté) : un lot de 3 annonces dont la 2e a un budget négatif. Sans transaction, la 1re annonce est déjà écrite et la 3e ne l'est pas : la base contient un lot à moitié traité. Avec transaction, l'échec annule tout le lot. L'intérêt métier : pas d'état incohérent, retraitement du lot possible, une panne ou une erreur de manipulation ne fait pas perdre ni corrompre les données.

Journalisation : un log métier/technique de succès (lot validé) et un log d'erreur (cause, lot concerné). Point d'attention : le log d'erreur doit être écrit après le ROLLBACK, sinon il serait annulé avec le reste (notion générale, hors cours).

À toi de coder

Un lot atomique : COMMIT ou ROLLBACK

Un traitement en lot doit être tout ou rien : si une annonce du lot est invalide, tout le lot est annulé. Le journal technique doit garder la trace de l'erreur : on l'écrit après le ROLLBACK, sinon l'écriture du log serait elle aussi annulée.

Complète traiter_lot : BEGIN au départ, COMMIT si tout passe, ROLLBACK en cas d'erreur (la table a une contrainte CHECK (budget >= 0)). La fonction renvoie True si le lot est validé.

import sqlite3
con = sqlite3.connect(":memory:", isolation_level=None)
con.executescript("""
CREATE TABLE marche(id INTEGER PRIMARY KEY, titre TEXT NOT NULL, budget REAL CHECK (budget >= 0));
CREATE TABLE log_technique(id INTEGER PRIMARY KEY, niveau TEXT, message TEXT);
""")

def traiter_lot(lot):
    con.execute("___")
    try:
        for titre, budget in lot:
            con.execute("INSERT INTO marche(titre, budget) VALUES (?, ?)", (titre, budget))
        con.execute("___")
    except sqlite3.DatabaseError as e:
        con.execute("___")
        con.execute("INSERT INTO log_technique(niveau, message) VALUES ('ERROR', ?)", (str(e),))
        return False
    con.execute("INSERT INTO log_technique(niveau, message) VALUES ('INFO', 'lot ok')")
    return True

res_bad = traiter_lot([("A", 10), ("B", -5), ("C", 20)])
n_apres_echec = con.execute("SELECT COUNT(*) FROM marche").fetchone()[0]
res_ok = traiter_lot([("D", 5), ("E", 6)])
n_apres_succes = con.execute("SELECT COUNT(*) FROM marche").fetchone()[0]
niveaux = [r[0] for r in con.execute("SELECT niveau FROM log_technique ORDER BY id")]

import sqlite3
con = sqlite3.connect(":memory:", isolation_level=None)
con.executescript("""
CREATE TABLE marche(id INTEGER PRIMARY KEY, titre TEXT NOT NULL, budget REAL CHECK (budget >= 0));
CREATE TABLE log_technique(id INTEGER PRIMARY KEY, niveau TEXT, message TEXT);
""")

def traiter_lot(lot):
    con.execute("___")
    try:
        for titre, budget in lot:
            con.execute("INSERT INTO marche(titre, budget) VALUES (?, ?)", (titre, budget))
        con.execute("___")
    except sqlite3.DatabaseError as e:
        con.execute("___")
        con.execute("INSERT INTO log_technique(niveau, message) VALUES ('ERROR', ?)", (str(e),))
        return False
    con.execute("INSERT INTO log_technique(niveau, message) VALUES ('INFO', 'lot ok')")
    return True

res_bad = traiter_lot([("A", 10), ("B", -5), ("C", 20)])
n_apres_echec = con.execute("SELECT COUNT(*) FROM marche").fetchone()[0]
res_ok = traiter_lot([("D", 5), ("E", 6)])
n_apres_succes = con.execute("SELECT COUNT(*) FROM marche").fetchone()[0]
niveaux = [r[0] for r in con.execute("SELECT niveau FROM log_technique ORDER BY id")]

Ctrl/⌘+Entrée

Vérifie que tu as compris

Dans un lot de 3 insertions dont la 2e échoue, que garantit une transaction avec ROLLBACK ?