from sqlalchemy import select
from sqlalchemy.exc import IntegrityError

# La session ouvre une transaction implicite dès la première opération
with SessionLocal() as session:
    try:
        compte_source = session.get(Compte, 1)
        compte_dest = session.get(Compte, 2)

        compte_source.solde -= 100
        compte_dest.solde += 100

        if compte_source.solde < 0:
            raise ValueError("Solde insuffisant")

        session.commit()   # valide les DEUX updates ensemble (atomicité)
    except ValueError:
        session.rollback() # annule TOUT, y compris le débit déjà appliqué en mémoire

# begin() explicite : contexte transactionnel clair, commit/rollback automatique
with SessionLocal() as session:
    with session.begin():   # commit automatique en sortie, rollback si exception
        session.add(Utilisateur(email="x@y.com", nom="X"))
        # pas besoin d'appeler commit() explicitement ici

# Gérer une violation de contrainte (ex: email UNIQUE déjà pris)
with SessionLocal() as session:
    try:
        session.add(Utilisateur(email="deja_pris@x.com", nom="Doublon"))
        session.commit()
    except IntegrityError:
        session.rollback()   # OBLIGATOIRE avant de réutiliser la session après une erreur
        print("Cet email existe déjà")

# Savepoints (nested transactions) avec begin_nested()
with SessionLocal() as session:
    session.add(Produit(nom="Stock principal", prix=10))
    session.flush()

    try:
        with session.begin_nested():   # SAVEPOINT
            session.add(Produit(nom="Produit invalide", prix=-5))  # viole un CHECK
            session.flush()            # déclenche l'erreur ici
    except IntegrityError:
        pass  # seul le SAVEPOINT est annulé, "Stock principal" reste en attente

    session.commit()   # valide "Stock principal", le produit invalide n'a jamais été committé

# Transaction en lecture seule / isolation explicite
with SessionLocal() as session:
    session.connection(execution_options={"isolation_level": "SERIALIZABLE"})
    resultat = session.scalars(select(Compte).where(Compte.id == 1)).one()

# Retry automatique sur erreur de sérialisation (pattern SERIALIZABLE)
import time
from sqlalchemy.exc import OperationalError

def transferer_avec_retry(session_factory, source_id, dest_id, montant, max_tentatives=3):
    for tentative in range(max_tentatives):
        try:
            with session_factory() as session:
                with session.begin():
                    source = session.get(Compte, source_id)
                    dest = session.get(Compte, dest_id)
                    source.solde -= montant
                    dest.solde += montant
            return  # succès
        except OperationalError:
            if tentative == max_tentatives - 1:
                raise
            time.sleep(0.1 * (tentative + 1))  # backoff simple avant retry