Jak integrujete SQL databázi s FastAPI?

Question

Accepted Answer

Na rozdíl od Django je **FastAPI neovlivňující** ohledně databází — vybíráte si knihovnu sami. Běžná volba je **SQLAlchemy** (často s **SQLModel**, od autora FastAPI, která kombinuje SQLAlchemy + Pydantic). Databázové relace jsou poskytovány prostřednictvím dependency injection.

## Nastavení SQLAlchemy

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

## Poskytnutí databázové relace prostřednictvím dependency

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

Vzor `yield` dependency je standardní způsob správy relací: otevřít jednu na požadavek, injektovat ji a poté ji automaticky zavřít — každý endpoint získá čistou, správně uzavřenou relaci.

## SQLModel — SQLAlchemy + Pydantic v jednom

```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 sjednocuje ORM model a Pydantic model do jedné třídy — snižuje duplikaci mezi databází a schématy API.

## Migrace a async možnosti

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

## Proč je to důležité

Integrace databáze je nezbytná pro téměř jakékoliv reálné API, a protože je FastAPI záměrně **neovlivňující** ohledně ní (na rozdíl od vestavěného ORM Django), porozumění běžnému přístupu je důležitá praktická znalost.

Standardní vzor — **SQLAlchemy** (nebo **SQLModel**, která elegantně sjednocuje ORM a Pydantic modely a snižuje duplikaci) s **dependency-injektovanými relacemi** prostřednictvím vzoru `yield` — je tím, co používá skoro každá FastAPI aplikace k perzistenci dat.

Dependency na relaci za požadavek (otevřít před, zavřít po, automaticky) je idiomatický, správný způsob správy databázových připojení, a sjednocení databází a API schémat v SQLModel je pozoruhodná funkcionalita pro produktivitu od autora FastAPI.

Vědomost, jak nastavit databázi, poskytnout relace prostřednictvím DI, provádět dotazy a zvládat migrace (Alembic) a async varování (použití async ovladačů v async endpointech, nikdy blokování sync), je nezbytná pro vytváření datově orientovaných FastAPI aplikací — jelikož vám FastAPI dává svobodu volby, znalost konvenčního, dobře prošlapaného postupu je cenná pro správné vytváření reálných aplikací.