Wie integrierst du eine SQL-Datenbank mit FastAPI?

Question

Accepted Answer

Anders als Django ist FastAPI **unabhängig** von Datenbankentscheidungen — du wählst die Bibliothek. Die häufige Wahl ist **SQLAlchemy** (oft mit **SQLModel**, vom Autor von FastAPI, das SQLAlchemy + Pydantic kombiniert). Datenbanksessions werden über Dependency Injection bereitgestellt.

## 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)
```

## Bereitstellen der DB-Session über eine Abhängigkeit

```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
```

Das `yield`-Dependency-Muster ist die Standardmethode zur Sessionverwaltung: öffne eine pro Anfrage, injiziere sie und schließe sie danach automatisch — jeder Endpoint erhält eine saubere, ordnungsgemäß geschlossene Session.

## SQLModel — SQLAlchemy + Pydantic in einem

```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 vereinheitlicht das ORM-Modell und das Pydantic-Modell in einer Klasse — reduziert Duplikation zwischen Datenbank- und API-Schemas.

## Migrationen und Async-Optionen

```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)
```

## Warum es wichtig ist

Datenbankintegration ist für fast jede echte API unverzichtbar, und da FastAPI bewusst **unabhängig** davon ist (anders als Djangos eingebautes ORM), ist das Verständnis des gängigen Ansatzes wichtiges praktisches Wissen.

Das Standardmuster — **SQLAlchemy** (oder **SQLModel**, das elegant das ORM und Pydantic-Modelle vereinheitlicht, um Duplikation zu vermeiden) mit **Dependency-Injection-Sessions** über das `yield`-Muster — ist das, das nahezu jede FastAPI-App verwendet, um Daten zu persistieren.

Die Session-pro-Anfrage-Abhängigkeit (öffne vorher, schließe danach, automatisch) ist die idiomatische, korrekte Methode zur Verwaltung von Datenbankverbindungen, und SQLModels Vereinheitlichung von Datenbank- und API-Schemas ist eine bemerkenswerte Produktivitätsfunktion vom eigenen Autor von FastAPI.

Zu wissen, wie du die Datenbank einrichtest, Sessions durch DI bereitstellst, Abfragen durchführst und Migrationen (Alembic) und die Async-Einschränkung handhabst (verwende Async-Treiber in Async-Endpunkten, niemals blockierende Sync-Endpunkte), ist notwendig für die Erstellung datenbankgestützter FastAPI-Anwendungen — da FastAPI dir die Freiheit gibt zu wählen, ist das Wissen um den konventionellen, bewährten Pfad wertvoll für die korrekte Erstellung echter Apps.