Piye carane nggabungake database SQL karo FastAPI?

Question

Accepted Answer

Beda karo Django, FastAPI **ora berpendapat** babagan database — sampeyan sing milih perpustakaan. Pilihan umum yaiku **SQLAlchemy** (asring karo **SQLModel**, dening penulis FastAPI, sing nggabungake SQLAlchemy + Pydantic). Sesio database disiyatake liwat dependency injection.

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

## Nyedhiyake sesio DB liwat 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 `yield` dependency minangka cara baku kanggo ngatur sesio: buka siji saben permintaan, injeksi, lan tutup sawise kanthi otomatis — saben endpoint njaluk sesio sing resik lan ditutup kanthi bener.

## SQLModel — SQLAlchemy + Pydantic ing siji

```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 nggabungake model ORM lan model Pydantic dadi siji kelas — nyuda penggandaan antarane database lan skema API.

## Migrasi lan 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 iki penting

Integrasi database penting kanggo meh kabeh API nyata, lan amarga FastAPI kanthi sengaja **ora berpendapat** babagan iku (beda karo ORM bawaan Django), ngerti pendekatan umum iku penting kanggo ilmu praktis.

Pola baku — **SQLAlchemy** (utawa **SQLModel**, sing nggabungake ORM lan model Pydantic kanthi elegan kanggo nyuda penggandaan) karo **sesio injected-dependency** liwat pola `yield` — iki sing meh kabeh aplikasi FastAPI gunakake kanggo tetap data.

Dependency sesio-per-permintaan (buka sadurunge, tutup sawise, kanthi otomatis) minangka cara idiomatic lan bener kanggo ngatur koneksi database, lan penyatuan SQLModel saka database lan skema API minangka fitur produktivitas sing kasorot saka penulis FastAPI dhewe.

Ngerti carane nyedhiyake database, nyedhiyake sesio liwat DI, nindakake query, lan nangani migrasi (Alembic) lan peringatan async (nggunakake async driver ing endpoint async, ora nate nglangi sing sinkron) iku perlu kanggo mbangun aplikasi FastAPI sing didukung data — amarga FastAPI menehi kebebasan kanggo milih, ngerti jalur konvensional sing paling dicakade iku berharga kanggo mbangun aplikasi nyata kanthi bener.