Hoe integreer je een SQL-database met FastAPI?

Question

Accepted Answer

In tegenstelling tot Django is FastAPI **onwetenschappelijk** over databases — je kiest zelf de bibliotheek. De veelgebruikte keuze is **SQLAlchemy** (vaak met **SQLModel**, van FastAPI's auteur, wat SQLAlchemy + Pydantic combineert). Databasesessies worden geleverd via dependency injection.

## SQLAlchemy setup

```python
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base

engine = create_engine("postgresql://user:pass@localhost/db")
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

class User(Base):                        # an ORM model (maps to a table)
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String, unique=True)
```

## De DB-sessie via een dependency verstrekken

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                 # provide the session
    finally:
        db.close()               # ALWAYS close after the request (cleanup)

@app.get("/users/{id}")
def get_user(id: int, db: Session = Depends(get_db)):   # inject a session per request
    user = db.query(User).filter(User.id == id).first()
    if not user:
        raise HTTPException(404, "Not found")
    return user
```

Het `yield` dependency-patroon is de standaardmanier om sessies te beheren: open één per aanvraag, injecteer deze, en sluit deze daarna automatisch — elk endpoint krijgt een schone, correct gesloten sessie.

## SQLModel — SQLAlchemy + Pydantic in één

```python
from sqlmodel import SQLModel, Field, Session, select

class User(SQLModel, table=True):        # ONE class = ORM model AND Pydantic model
    id: int | None = Field(default=None, primary_key=True)
    name: str
    email: str

@app.get("/users")
def list_users(db: Session = Depends(get_session)):
    return db.exec(select(User)).all()    # query; results are also valid response models
```

SQLModel verenigt het ORM-model en het Pydantic-model in één klasse — wat dubbeling tussen database en API-schema's vermindert.

## Migraties en async-opties

```text
✓ Migrations: use Alembic (SQLAlchemy's migration tool) for schema changes
✓ Async: use SQLAlchemy's async engine + async session for async endpoints
  (don't use a SYNC database driver inside async def — it blocks the event loop)
```

## Waarom het belangrijk is

Databaseintegratie is essentieel voor bijna elke echte API, en omdat FastAPI bewust **onwetenschappelijk** is erover (in tegenstelling tot Django's ingebouwde ORM), is het begrijpen van de veelgebruikte aanpak belangrijk praktische kennis.

Het standaardpatroon — **SQLAlchemy** (of **SQLModel**, wat elegant het ORM en Pydantic-modellen verenigt om dubbeling te verminderen) met **dependency-geïnjecteerde sessies** via het `yield` patroon — is wat bijna elke FastAPI-app gebruikt om gegevens te behouden.

De sessie-per-aanvraag-dependency (open ervoor, sluit erna, automatisch) is de idiomatische, correcte manier om databaseverbindingen te beheren, en SQLModel's vereniging van database- en API-schema's is een opmerkelijke productiviteitsfunctie van FastAPI's eigen auteur.

Weten hoe je de database instelt, sessies via DI verstrekt, query's uitvoert en migraties (Alembic) en de async-voorbehoud (async-stuurprogramma's in async-eindpunten gebruiken, nooit blockerende synchrone) handelt is nodig voor het bouwen van datagestuurd FastAPI-toepassingen — omdat FastAPI je de vrijheid geeft om te kiezen, is het weten van het conventionele, goed betreden pad waardevol voor het correct bouwen van echte apps.