Bagaimana anda mengintegrasikan pangkalan data SQL dengan FastAPI?

Question

IT Interview Practice · Accepted Answer

Tidak seperti Django, FastAPI bersifat **tidak berpendapat (unopinionated)** tentang pangkalan data — anda memilih pustakanya. Pilihan biasa ialah **SQLAlchemy** (selalunya dengan **SQLModel**, oleh pengarang FastAPI, yang menggabungkan SQLAlchemy + Pydantic). Sesi pangkalan data disediakan melalui suntikan kebergantungan (dependency injection).

## Persediaan 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 sesi DB melalui kebergantungan

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

Corak kebergantungan `yield` ialah cara standard untuk menguruskan sesi: buka satu setiap permintaan, suntik ia, dan tutup ia selepas itu secara automatik — setiap endpoint mendapat sesi yang bersih dan ditutup dengan betul.

## 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 — mengurangkan pertindihan antara skema pangkalan data dan API.

## Migrasi dan pilihan 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 ia penting

Integrasi pangkalan data adalah penting untuk hampir mana-mana API sebenar, dan kerana FastAPI sengaja bersifat **tidak berpendapat** tentangnya (tidak seperti ORM terbina dalam Django), memahami pendekatan biasa ialah pengetahuan praktikal yang penting.

Corak standard — **SQLAlchemy** (atau **SQLModel**, yang dengan anggun menyatukan model ORM dan Pydantic untuk mengurangkan pertindihan) dengan **sesi yang disuntik secara kebergantungan** melalui corak `yield` — ialah apa yang hampir setiap aplikasi FastAPI gunakan untuk menyimpan data.

Kebergantungan sesi-setiap-permintaan (buka sebelum, tutup selepas, secara automatik) ialah cara idiomatik dan betul untuk menguruskan sambungan pangkalan data, dan penyatuan skema pangkalan data dan API oleh SQLModel ialah ciri produktiviti yang ketara daripada pengarang FastAPI sendiri.

Mengetahui cara mempersiapkan pangkalan data, menyediakan sesi melalui DI, melaksanakan pertanyaan, dan mengendalikan migrasi (Alembic) serta peringatan async (menggunakan pemacu async dalam endpoint async, jangan sekali-kali menyekat dengan yang segerak) adalah perlu untuk membina aplikasi FastAPI yang dipacu data — kerana FastAPI memberi anda kebebasan untuk memilih, mengetahui jalan konvensional yang sering dilalui adalah berharga untuk membina aplikasi sebenar dengan betul.

Persediaan SQLAlchemy

Menyediakan sesi DB melalui kebergantungan

SQLModel — SQLAlchemy + Pydantic dalam satu

Migrasi dan pilihan async

Mengapa ia penting

Soalan berkaitan