Modèles SQLAlchemy | Concevoir des tables de base de données

Dans ce chapitre, vous apprendrez à définir des modèles de données à l'aide de l'ORM natif SQLAlchemy et à gérer les sessions de base de données via l'injection de dépendances de FastAPI.


Pourquoi FastAPI n'a-t-il pas d'ORM intégré ?

Django dispose d'un ORM intégré, tandis que Flask recommande Flask-SQLAlchemy.

FastAPI n'a pas d'ORM intégré — il veut que vous choisissiez l'outil le plus adapté,SQLAlchemy + Pydanticest la meilleure combinaison reconnue par la communauté.

(venv) $ pip install sqlalchemy

Configurer la connexion à la base de données

Exemple

# Chemin du fichier : database.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, DeclarativeBase

# Chemin du fichier de base de données SQLite
SQLALCHEMY_DATABASE_URL = "sqlite:///./blog.db"

# Création du moteur : check_same_thread est un paramètre spécifique à SQLite
engine = create_engine(
    SQLALCHEMY_DATABASE_URL,
    connect_args={"check_same_thread": False}   # Spécifique à SQLite : autoriser les accès inter-threads
)

# Créer la fabrique de sessions
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# Classe de base : tous les modèles ORM en héritent
class Base(DeclarativeBase):
    pass

check_same_thread=Falseest la configuration requise pour SQLite dans FastAPI. Par défaut, SQLite n'autorise pas la même connexion à être utilisée entre les threads, mais dans les applications web, chaque requête peut être traitée dans un thread différent.

Injection de dépendances : get_db

Exemple

# Chemin du fichier : ajouter à database.py
from fastapi import Depends

def get_db():
    """Injection de dépendances FastAPI : créer une session de base de données indépendante pour chaque requête"""
    db = SessionLocal()
    try:
        yield db          # Utiliser cette session pendant la requête
    finally:
        db.close()        # Fermer automatiquement la session après la fin de la requête pour éviter les fuites de connexion

Depends(get_db)est le système d'injection de dépendances de FastAPI, où les fonctions de route obtiennent automatiquement des sessions de base de données via l'injection de dépendances.


Définir les modèles : Post et Category

Exemple

# Chemin du fichier : models.py
from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey
from sqlalchemy.orm import relationship
from datetime import datetime
from database import Base

class Category(Base):
    """Catégorie d'article"""
    __tablename__ = "categories"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(50), unique=True, nullable=False)
    slug = Column(String(50), unique=True, nullable=False)
    # back_populates relation bidirectionnelle
    posts = relationship("Post", back_populates="category")


class Post(Base):
    """Article de blog"""
    __tablename__ = "posts"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(200), nullable=False)
    slug = Column(String(200), unique=True, nullable=False)
    summary = Column(Text, default="")
    content = Column(Text, nullable=False)
    category_id = Column(Integer, ForeignKey("categories.id"), nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    # Relation bidirectionnelle avec Category
    category = relationship("Category", back_populates="posts")

Ce qui est utilisé dans FastAPI estSQLAlchemy natif(et non celui de Flask-SQLAlchemydb.Model). Notez les différences dans les imports de Column, l'héritage de Base et la syntaxe de relationship. Un tableau comparatif sera fourni plus tard.


Initialiser les tables de la base de données

Exemple

# Chemin du fichier : créer une table dans l'événement de démarrage dans main.py
from fastapi import FastAPI
from database import engine, Base
from models import Category, Post   # Assurez-vous que les classes de modèles sont importées afin que Base.metadata puisse les reconnaître

app = FastAPI()

@app.on_event("startup")
def on_startup():
    """Crée automatiquement les tables de la base de données au démarrage de l'application (développement uniquement)"""
    Base.metadata.create_all(bind=engine)

Plus tard, nous passerons aux migrations Alembic (chapitre 6),create_allUtilisé uniquement pendant la phase de prototypage rapide.


Insérer des données de test

Insérer des données de test dans un script Python :

Exemple

# Chemin du fichier : seed.py (à exécuter une seule fois)
from database import SessionLocal
from models import Category, Post

db = SessionLocal()

# Créer une catégorie
py = Category(name="Python", slug="python")
css = Category(name="CSS", slug="css")
fastapi = Category(name="FastAPI", slug="fastapi")
db.add_all([py, css, fastapi])
db.commit()

# Créer un article
db.add_all([
    Post(title="Le guide complet du débutant pour FastAPI", slug="fastapi-guide",
         summary="Apprendre FastAPI à partir de zéro", content="<h2>Pourquoi choisir FastAPI ?</h2><p>...</p>",
         category_id=fastapi.id),
    Post(title="Les coroutines Python expliquées", slug="python-coroutine",
         summary="Comprendre asyncio", content=<h2>Qu'est-ce qu'une coroutine ?</h2><p>...</p>,
         category_id=py.id),
    Post(title="CSS Grid Layout en action", slug="css-grid",
         summary="Mettre en œuvre une mise en page responsive avec Grid", content="<h2>Introduction à Grid</h2><p>...</p>",
         category_id=css.id),
])
db.commit()
db.close()
print("Insertion des données de test terminée !")

Exécutezpython seed.py, insérer 3 articles dans la base de données.


Comparaison de la syntaxe ORM entre quatre frameworks.

OpérationDjangoFlask-SQLAlchemyFastAPI (SQLAlchemy natif)
classe de basemodels.Modeldb.ModelBase (DeclarativeBase)
Fieldsmodels.CharField()db.Column(...)Column(...)
Clé étrangèreForeignKey(to, on_delete)db.ForeignKey('table.col')ForeignKey('table.col')
RelationInversion automatiquedb.relationship + backrefrelationship + back_populates
SessionGestion automatiquedb.sessionSessionLocal() + Depends

Résumé du chapitre

Dans ce chapitre, vous avez maîtrisé l'intégration de SQLAlchemy dans FastAPI : create_engine + SessionLocal pour configurer la connexion à la base de données, DeclarativeBase pour définir la classe de base des modèles, l'injection de dépendance get_db pour gérer les sessions, et Column/relationship pour définir les champs et les relations.

Comparé à Flask-SQLAlchemy, SQLAlchemy natif nécessite un peu plus de code mais est entièrement open-source et contrôlable.

autres extensions