Kif tintegra database SQL ma' FastAPI?

Question

Accepted Answer

Bid-differenza minn Django, FastAPI huwa **mingħajr opinjoni** dwar databases — inti tagħżel il-librerija. L-għażla komuni hija **SQLAlchemy** (ħafna drabi ma' **SQLModel**, mitkitba mill-awtur ta' FastAPI, li tgħaqqad SQLAlchemy + Pydantic). In-nuss tad-database jipprovdew permezz tal-dependency injection.

## Qbil ta' 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)
```

## Provdiment tas-sessjoni tal-DB permezz ta' dipendenza

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

Il-mudell ta' dipendenza `yield` huwa l-mod standard biex tiġdawwal is-sessjonijiet: iftaħ waħda għal kull talaba, injettaha, u agħlaqha wara awtomatikament — kull endpoint jikseb sessjoni nadifa u mxejpija sewwa.

## SQLModel — SQLAlchemy + Pydantic f'waħda

```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 tunaqqas il-mudell ORM u l-mudell Pydantic f'klassi waħda — li tnaqqas id-duplikazzjoni bejn id-database u l-iskemi tal-API.

## Migrazzjonijiet u għażliet asincronusjuni

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

## Għaliex hija importanti

L-integrazzjoni tad-database hija essenzjali għal kważi kull API reali, u billi FastAPI huwa deliberatament **mingħajr opinjoni** dwarha (bid-differenza minn ORM mibnija ta' Django), il-fehim tal-approċċ komuni huwa għarfien praktiku importanti.

Il-mudell standard — **SQLAlchemy** (jew **SQLModel**, li tunaqqas b'eleganza l-mudelli ORM u Pydantic biex titnaqqas id-duplikazzjoni) ma' **sessjonijiet injettati permezz ta' dipendenza** permezz tal-mudell `yield` — huwa dak li kważi kull applikazzjoni FastAPI tuża biex iżżomm id-data.

Id-dipendenza ta' sessjoni għal kull talaba (iftaħ qabel, agħlaq wara, awtomatikament) hija l-mod idjoматiku u korrett biex tiġdawwal il-konnessjonijiet tad-database, u l-unifikazzjoni ta' SQLModel tad-database u l-iskemi tal-API hija fattur produktività notevoli mill-awtur tagħha stess ta' FastAPI.

Il-fehim ta' kif tqabbad id-database, tipprovdi sessjonijiet permezz ta' DI, twettaq il-mistoqsijat, u tqabbad il-migrazzjonijiet (Alembic) u l-avvertenza asincronusja (użu ta' drivers asincronusji f'endpoints asincronusji, qatt ma tblokka wħud sincronusji) hija meħtieża għall-bini ta' applikazzjonijiet FastAPI ddrivati mid-data — billi FastAPI jagħtik il-libertà li tagħżel, il-fehim tal-passaġġ konvenzjonali u l-waħda li segwa ħafna nies huwa valutabbli għall-bini ta' apps veri b'mod korrett.