Kako integrirate SQL podatkovne baze s FastAPI?

Question

Accepted Answer

Za razliko od Djanga je **FastAPI neopredelen** glede podatkovnih baz — izbor je prepuščen vam. Običajna izbira je **SQLAlchemy** (pogosto s **SQLModel**, ki ga je avtoriziranastav FastAPI in kombinira SQLAlchemy + Pydantic). Seje podatkovne baze se zagotavljajo prek vbrizgavanja odvisnosti.

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

## Zagotavljanje seje podatkovne baze prek odvisnosti

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

Vzorec odvisnosti `yield` je standardni način upravljanja sejami: odprite eno na zahtevo, jo vbrizgajte in jo nato samodejno zaprette — vsak končni točka dobi čisto, pravilno zaprto sejo.

## SQLModel — SQLAlchemy + Pydantic v enem

```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 poenotva ORM model in model Pydantic v en razred — zmanjšuje podvajanje med podatkovnimi bazami in shemami API.

## Migracije in asinkrone 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)
```

## Zakaj je to pomembno

Integracija podatkovne baze je bistvena za skoraj vsak pravi API, in ker je FastAPI namerno **neopredelen** glede nje (za razliko od vgrajene ORM-a Djanga), je razumevanje običajnega pristopa pomembno praktično znanje.

Standardni vzorec — **SQLAlchemy** (ali **SQLModel**, ki elegantno poenotva ORM in Pydantic modele za zmanjšanje podvajanja) s **sejami, vbrizganimi prek odvisnosti**, preko vzorca `yield` — je tisto, kar uporabljajo skoraj vse aplikacije FastAPI za trajnost podatkov.

Odvisnost seje na zahtevo (odpri prej, zapri potem, samodejno) je idiomatični, pravilen način za upravljanje povezav s podatkovnimi bazami, SQLModel pa poenotenje podatkovne baze in shem API je vidna lastnost produktivnosti avtorja FastAPI.

Znanje, kako nastaviti podatkovno bazo, zagotoviti seje prek DI, izvajati poizvedbe in upravljati migracije (Alembic) ter asinkronih izkušenj (uporaba asinkronih gonilnikov v asinkronih končnih točkah, nikoli ne blokirajočih sinhronih) je potrebno za gradnjo podatkovnih aplikacij FastAPI — ker FastAPI daje svobodo izbire, je poznavanje običajne, dobro uhojene poti dragoceno za pravilno gradnjo pravi aplikacij.