from sqlalchemy import select, insert, update, delete
from sqlalchemy.orm import selectinload
import time

# --- Le problème N+1 ---
# 1 requête pour charger N auteurs + N requêtes pour charger leurs articles = N+1 requêtes
with SessionLocal() as session:
    auteurs = session.scalars(select(Auteur)).all()   # 1 requête
    for auteur in auteurs:
        print(len(auteur.articles))                   # +1 requête PAR auteur -> lent !

# Solution : eager loading (voir aussi la leçon dédiée)
with SessionLocal() as session:
    stmt = select(Auteur).options(selectinload(Auteur.articles))
    auteurs = session.scalars(stmt).all()              # 2 requêtes au total, quel que soit N
    for auteur in auteurs:
        print(len(auteur.articles))                    # zéro requête supplémentaire

# Détecter les N+1 en développement : activer echo ou un compteur de requêtes
from sqlalchemy import event

compteur_requetes = {"n": 0}

@event.listens_for(engine, "before_cursor_execute")
def compter(conn, cursor, statement, parameters, context, executemany):
    compteur_requetes["n"] += 1

# --- Bulk insert : éviter un objet Python + un INSERT par ligne ---
with SessionLocal() as session:
    # LENT : 10 000 objets Python, 10 000 aller-retours de tracking ORM
    for i in range(10_000):
        session.add(Produit(nom=f"Produit {i}", prix=9.99))
    session.commit()

# RAPIDE : bulk_insert_mappings / insert() Core, contourne le tracking objet par objet
with SessionLocal() as session:
    session.execute(
        insert(Produit),
        [{"nom": f"Produit {i}", "prix": 9.99} for i in range(10_000)],
    )
    session.commit()

# Bulk update : un seul UPDATE au lieu de charger puis modifier chaque objet
with SessionLocal() as session:
    session.execute(
        update(Produit).where(Produit.categorie == "obsolete").values(actif=False)
    )
    session.commit()

# Bulk delete
with SessionLocal() as session:
    session.execute(delete(Produit).where(Produit.stock == 0))
    session.commit()

# yield_per : streamer de très gros résultats sans tout charger en mémoire
with SessionLocal() as session:
    stmt = select(Produit).execution_options(yield_per=1000)
    for lot in session.scalars(stmt).partitions():   # traite par lots de 1000
        for produit in lot:
            traiter(produit)

# Mesurer l'impact : bulk vs ORM classique
def benchmark_insert(n=5000):
    debut = time.perf_counter()
    with SessionLocal() as session:
        session.execute(insert(Produit), [{"nom": f"P{i}", "prix": 1.0} for i in range(n)])
        session.commit()
    return time.perf_counter() - debut   # généralement 5-20x plus rapide que l'ORM classique

# Éviter expire_on_commit=True par défaut si on relit beaucoup après commit (force un SELECT)
SessionRapide = sessionmaker(bind=engine, expire_on_commit=False)