SQLAlchemy-Modelle — Datenbanktabellen entwerfen

In diesem Kapitel lernen Sie, Datenmodelle mit dem nativen SQLAlchemy-ORM zu definieren und Datenbanksitzungen über FastAPI-Dependency-Injection zu verwalten.


Warum hat FastAPI kein eingebautes ORM?

Django hat ein eingebautes ORM, während Flask Flask-SQLAlchemy empfiehlt.

FastAPI hat kein eingebautes ORM – es möchte, dass Sie das am besten geeignete Tool wählen,SQLAlchemy + Pydanticist die von der Community anerkannte beste Kombination.

(venv) $ pip install sqlalchemy

Datenbankverbindung konfigurieren

Beispiel

# Dateipfad: database.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, DeclarativeBase

# Pfad zur SQLite-Datenbankdatei
SQLALCHEMY_DATABASE_URL = "sqlite:///./blog.db"

# Engine erstellen: check_same_thread ist ein SQLite-spezifischer Parameter
engine = create_engine(
    SQLALCHEMY_DATABASE_URL,
    connect_args={"check_same_thread": False}   # SQLite-spezifisch: Cross-Threading erlauben
)

# Session-Factory erstellen
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# Basisklasse: Alle ORM-Modelle erben davon
class Base(DeclarativeBase):
    pass

check_same_thread=Falseist die erforderliche Konfiguration für SQLite in FastAPI. Standardmäßig erlaubt SQLite nicht, dass dieselbe Verbindung über Threads hinweg verwendet wird, aber in Webanwendungen kann jede Anfrage in einem anderen Thread verarbeitet werden.

Abhängigkeitsinjektion: get_db

Beispiel

# Dateipfad: an database.py anhängen
from fastapi import Depends

def get_db():
    """FastAPI-Abhängigkeitsinjektion: Erstellen einer unabhängigen Datenbanksitzung für jede Anfrage"""
    db = SessionLocal()
    try:
        yield db          # Diese Sitzung während der Anfrage verwenden
    finally:
        db.close()        # Die Sitzung nach Ende der Anfrage automatisch schließen, um Verbindungslecks zu vermeiden

Depends(get_db)ist das Abhängigkeitsinjektionssystem von FastAPI, bei dem Routenfunktionen automatisch Datenbanksitzungen durch Abhängigkeitsinjektion erhalten.


Modelle definieren: Post und Category

Beispiel

# Dateipfad: 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):
    """Artikelkategorie"""
    __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 bidirektionale Beziehung
    posts = relationship("Post", back_populates="category")


class Post(Base):
    """Blogbeitrag"""
    __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)
    # Bidirektionale Beziehung zu Category
    category = relationship("Category", back_populates="posts")

Was in FastAPI verwendet wird, istNative SQLAlchemy(nicht die von Flask-SQLAlchemydb.Model). Beachten Sie die Unterschiede bei Column-Importen, Base-Vererbung und relationship-Syntax. Eine Vergleichstabelle wird später bereitgestellt.


Datenbanktabellen initialisieren

Beispiel

# Dateipfad: Tabelle im Startup-Event in main.py erstellen
from fastapi import FastAPI
from database import engine, Base
from models import Category, Post   # Stelle sicher, dass die Modellklassen importiert werden, damit Base.metadata sie erkennen kann

app = FastAPI()

@app.on_event("startup")
def on_startup():
    """Erstellt beim Start der Anwendung automatisch die Datenbanktabellen (nur für die Entwicklung)."""
    Base.metadata.create_all(bind=engine)

Später wechseln wir zu Alembic-Migrationen (Kapitel 6),create_allNur in der schnellen Prototyping-Phase verwendet.


Testdaten einfügen

Testdaten in einem Python-Skript einfügen:

Beispiel

# Dateipfad: seed.py (nur einmal ausführen)
from database import SessionLocal
from models import Category, Post

db = SessionLocal()

# Kategorie erstellen
py = Kategorie(Name="Python", Slug="python")
css = Kategorie(Name="CSS", Slug="css")
fastapi = Kategorie(Name="FastAPI", Slug="fastapi")
db.add_all([py, css, fastapi])
db.commit()

# Artikel erstellen
db.add_all([
    Post(title="Der komplette Anfängerleitfaden für FastAPI", slug="fastapi-guide",
         summary="FastAPI von Grund auf lernen", content="<h2>Warum FastAPI wählen?</h2><p>...</p>",
         category_id=fastapi.id),
    Post(title="Python-Koroutinen erklärt", slug="python-coroutine",
         summary="asyncio verstehen", content=<h2>Was ist eine Coroutine?</h2><p>...</p>,
         category_id=py.id),
    Post(title="CSS Grid Layout in der Praxis", slug="css-grid",
         summary="Responsives Layout mit Grid implementieren", content="<h2>Einführung in Grid</h2><p>...</p>",
         category_id=css.id),
])
db.commit()
db.close()
print("Testdateneinfügung abgeschlossen!")

Führen Siepython seed.py, 3 Artikel in die Datenbank einfügen.


Vergleich der ORM-Syntax über vier Frameworks.

AktionDjangoFlask-SQLAlchemyFastAPI (native SQLAlchemy)
Basisklassemodels.Modeldb.ModelBase (DeclarativeBase)
Fieldsmodels.CharField()db.Column(...)Column(...)
FremdschlüsselForeignKey(to, on_delete)db.ForeignKey('table.col')ForeignKey('table.col')
BeziehungAutomatische Rückbeziehungdb.relationship + backrefrelationship + back_populates
SitzungAutomatische Verwaltungdb.sessionSessionLocal() + Depends

Kapitelzusammenfassung

In diesem Kapitel hast du die SQLAlchemy-Integration in FastAPI gemeistert: create_engine + SessionLocal zum Konfigurieren der Datenbankverbindung, DeclarativeBase zum Definieren der Modell-Basisklasse, get_db-Dependency-Injection zur Verwaltung von Sessions und Column/relationship zum Definieren von Feldern und Beziehungen.

Im Vergleich zu Flask-SQLAlchemy erfordert natives SQLAlchemy etwas mehr Code, ist aber vollständig quelloffen und kontrollierbar.

Weitere Erweiterungen