Si e integroni një bazë të dhënash SQL me FastAPI?

Question

Accepted Answer

Ndryshe nga Django, FastAPI është **pa mendim** për bazat e të dhënave — ju zgjidhni bibliotekën. Zgjedhja e zakonshme është **SQLAlchemy** (shpesh me **SQLModel**, nga autori i FastAPI, i cili kombinon SQLAlchemy + Pydantic). Seanca të bazës të dhënave ofrohen përmes injektimit të varësisë.

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

## Sigurimi i sesionit të DB përmes një varësie

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

Shema e varësisë `yield` është mënyra standarde për të menaxhuar seanca: hapni një për kërkesë, injektojeni atë, dhe mbylleni atë pas-pasit automatikisht — çdo endpoint merr një sesion të pastër, të mbyllur siç duhet.

## SQLModel — SQLAlchemy + Pydantic në një

```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 unifikajon modelin ORM dhe modelin Pydantic në një klasë — duke reduktuar duplikimin midis bazës të dhënave dhe skemave API.

## Migracionet dhe opsionet async

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

## Pse ka rëndësi

Integrimi i bazës të dhënave është thelbësor për pothuajse çdo API reale, dhe meqenëse FastAPI është qëllimisht **pa mendim** për atë (ndryshe nga ORM i integruar i Django), kuptimi i qasjes së zakonshme është njohuri praktike e rëndësishme.

Shema standarde — **SQLAlchemy** (ose **SQLModel**, i cili bashkon me elegancë modelin ORM dhe modelet Pydantic për të reduktuar duplikimin) me **seanca të injektuara përmes varësisë** përmes modelit `yield` — është ajo që përdor pothuajse çdo aplikim FastAPI për të ruajtur të dhënat.

Varësia sesion-për-kërkesë (hape përpara, mbyll pas, automatikisht) është mënyra idiomatike, e saktë për të menaxhuar koneksionet e bazës të dhënave, dhe unifikimi i SQLModel të bazës të dhënave dhe skemave API është një veti produktiviteti të shënuar nga autori i vetë FastAPI.

Ditja se si të konfigurohet baza e të dhënave, të sigurohen seanca përmes DI, të kryhen kërkime dhe të trajtohen migracionet (Alembic) dhe kurja async (përdorimi i drajverëve async në endpoints async, nuk bllokohen kurrë ato sinkrone) është e nevojshme për ndërtimin e aplikimeve FastAPI të drejtuara nga të dhënat — meqenëse FastAPI ju jep lirinë të zgjedhni, kuptimi i rrugës konvencionale, të mirëzhur është i vlefshëm për ndërtimin e aplikimeve reale siç duhet.