คุณ integrate ฐานข้อมูล SQL กับ FastAPI ได้อย่างไร?

Question

Accepted Answer

ต่างจาก Django, FastAPI เป็นแบบ **ไม่มีความเห็นบังคับ (unopinionated)** เกี่ยวกับฐานข้อมูล — คุณเลือก library เอง ตัวเลือกที่ใช้บ่อยคือ **SQLAlchemy** (มักใช้ร่วมกับ **SQLModel** ซึ่งสร้างโดยผู้สร้าง FastAPI โดยรวม SQLAlchemy + Pydantic เข้าด้วยกัน) database sessions ถูกจัดหาผ่าน dependency injection

## การตั้งค่า 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)
```

## การจัดหา DB session ผ่าน 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
```

`yield` dependency pattern เป็นวิธีมาตรฐานในการจัดการ sessions: เปิดหนึ่งตัวต่อ request, inject มัน และปิดมันหลังจากนั้นโดยอัตโนมัติ — ทุก endpoint ได้ session ที่สะอาดและถูกปิดอย่างถูกต้อง

## SQLModel — SQLAlchemy + Pydantic ในตัวเดียว

```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 รวม ORM model และ Pydantic model เข้าเป็น class เดียว — ลดการทำซ้ำระหว่าง schema ของฐานข้อมูลและ API

## Migrations และตัวเลือก 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)
```

## ทำไมจึงสำคัญ

การ integrate ฐานข้อมูลเป็นสิ่งจำเป็นสำหรับ API จริงเกือบทุกตัว และเนื่องจาก FastAPI ตั้งใจเป็นแบบ **ไม่มีความเห็นบังคับ** เกี่ยวกับมัน (ต่างจาก ORM ที่มีในตัวของ Django) การเข้าใจแนวทางที่ใช้บ่อยจึงเป็นความรู้ในทางปฏิบัติที่สำคัญ

pattern มาตรฐาน — **SQLAlchemy** (หรือ **SQLModel** ซึ่งรวม ORM และ Pydantic models เข้าด้วยกันอย่างสง่างามเพื่อลดการทำซ้ำ) พร้อม **sessions ที่ inject ผ่าน DI** ด้วย `yield` pattern — คือสิ่งที่แอป FastAPI เกือบทุกตัวใช้ในการเก็บข้อมูล

dependency แบบ session-per-request (เปิดก่อน ปิดหลัง โดยอัตโนมัติ) เป็นวิธีที่เป็นสำนวนและถูกต้องในการจัดการการเชื่อมต่อฐานข้อมูล และการที่ SQLModel รวม schema ของฐานข้อมูลและ API เข้าด้วยกันเป็นฟีเจอร์ด้านประสิทธิภาพที่โดดเด่นจากผู้สร้าง FastAPI เอง

การรู้วิธีตั้งค่าฐานข้อมูล, จัดหา sessions ผ่าน DI, ทำ queries และจัดการ migrations (Alembic) รวมถึงข้อควรระวังเรื่อง async (การใช้ async drivers ใน async endpoints ไม่ใช่ blocking sync ตัว) เป็นสิ่งจำเป็นสำหรับการสร้างแอป FastAPI ที่ขับเคลื่อนด้วยข้อมูล — เนื่องจาก FastAPI ให้อิสระคุณในการเลือก การรู้เส้นทางที่เป็นแบบแผนและผ่านการทดสอบมาแล้วจึงมีคุณค่าสำหรับการสร้างแอปจริงอย่างถูกต้อง