Bagaimana cara mengintegrasikan basis data SQL dengan FastAPI?

Question

Accepted Answer

Tidak seperti Django, FastAPI **tidak memiliki opini yang kuat** tentang basis data — Anda memilih perpustakaan yang ingin digunakan. Pilihan umum adalah **SQLAlchemy** (sering dengan **SQLModel**, dibuat oleh penulis FastAPI, yang menggabungkan SQLAlchemy + Pydantic). Session basis data disediakan melalui dependency injection.

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

## Menyediakan session DB melalui 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
```

Pola dependency `yield` adalah cara standar untuk mengelola session: membuka satu per request, menyuntikkannya, dan menutupnya secara otomatis setelahnya — setiap endpoint mendapatkan session yang bersih dan tertutup dengan benar.

## SQLModel — SQLAlchemy + Pydantic dalam satu

```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 menyatukan model ORM dan model Pydantic menjadi satu kelas — mengurangi duplikasi antara skema basis data dan API.

## Migrasi dan opsi 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)
```

## Mengapa ini penting

Integrasi basis data sangat penting untuk hampir semua API nyata, dan karena FastAPI sengaja **tidak memiliki opini yang kuat** tentangnya (tidak seperti ORM bawaan Django), memahami pendekatan umum adalah pengetahuan praktis yang penting.

Pola standar — **SQLAlchemy** (atau **SQLModel**, yang elegan menyatukan model ORM dan Pydantic untuk mengurangi duplikasi) dengan **session yang disuntikkan melalui dependency** melalui pola `yield` — adalah apa yang digunakan oleh hampir setiap aplikasi FastAPI untuk mempertahankan data.

Dependency session-per-request (dibuka sebelumnya, ditutup setelahnya, secara otomatis) adalah cara idiomatik dan benar untuk mengelola koneksi basis data, dan unifikasi skema basis data dan API SQLModel adalah fitur produktivitas yang luar biasa dari penulis FastAPI sendiri.

Mengetahui cara menyiapkan basis data, menyediakan session melalui DI, melakukan query, dan menangani migrasi (Alembic) dan peringatan async (menggunakan driver async di endpoint async, tidak pernah memblokir yang sinkron) adalah keharusan untuk membangun aplikasi FastAPI yang digerakkan data — karena FastAPI memberikan Anda kebebasan untuk memilih, mengetahui jalur konvensional yang sudah teruji adalah berharga untuk membangun aplikasi nyata dengan benar.