Kako integrirate SQL bazu podataka s FastAPI-jem?

Question

Accepted Answer

Za razliku od Djanga, FastAPI je **bez mišljenja** oko baza podataka — vi birате biblioteku. Čest izbor je **SQLAlchemy** (često s **SQLModel**-om, koji je autor FastAPI-ja, što kombinira SQLAlchemy + Pydantic). Sesije baze podataka pružaju se putem dependency injectiona.

## Postavljanje SQLAlchemy-ja

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

## Pružanje DB sesije kroz dependenciju

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

`yield` pattern dependencije je standardni način upravljanja sesijama: otvorite jednu po zahtjevu, ubacite je, i automatski je zatvorite nakon toga — svaki endpoint dobija čistu, pravilno zatvorenu sesiju.

## SQLModel — SQLAlchemy + Pydantic u 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 ujedinjuje ORM model i Pydantic model u jednu klasu — smanjujući dupliciranje između baze podataka i API shema.

## Migracije i async opcije

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

## Zašto je to važno

Integracija baze podataka je bitna za gotovo svaki pravi API, a budući da je FastAPI namjerno **bez mišljenja** oko nje (za razliku od Django-ovog ugrađenog ORM-a), razumijevanje uobičajenog pristupa je važno praktično znanje.

Standardni pattern — **SQLAlchemy** (ili **SQLModel**, koji elegantno ujedinjuje ORM i Pydantic modele kako bi se smanjilo dupliciranje) s **dependency-injectednim sesijama** putem `yield` patterna — je ono što koristi gotovo svaka FastAPI aplikacija za trajnost podataka.

Sesija-po-zahtjevu dependencija (otvorite prije, zatvorite nakon, automatski) je idiomatski, ispravan način upravljanja vezama baze podataka, a SQLModel-ova unifikacija baze podataka i API shema je značajna produktivna značajka od samog autora FastAPI-ja.

Znanje kako postaviti bazu podataka, pružiti sesije kroz DI, izvršiti upite i upravljati migracijama (Alembic) i async upozorenjem (korištenje async drajvera u async endpointima, nikad blokirajućih sync onih) je neophodno za izgradnju podataka-vođenih FastAPI aplikacija — budući da FastAPI vam daje slobodu izbora, poznavanje uobičajene, dobro prošetane staze je vrijedna za izgrađivanje pravих aplikacija ispravno.