FastAPI-உடன் ஒரு SQL database-ஐ எவ்வாறு integrate செய்வது?

Question

Accepted Answer

Django-வைப் போலல்லாமல், FastAPI databases-ஐப் பற்றி **unopinionated**-ஆக உள்ளது — நீங்கள் library-ஐத் தேர்ந்தெடுக்கிறீர்கள். பொதுவான தேர்வு **SQLAlchemy** (பெரும்பாலும் **SQLModel**-உடன், FastAPI-இன் author-ஆல், இது SQLAlchemy + Pydantic-ஐ இணைக்கிறது). Database sessions dependency injection மூலம் வழங்கப்படுகின்றன.

## SQLAlchemy setup

```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-ஐ நிர்வகிக்கும் standard வழியாகும்: ஒவ்வொரு 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-ஆக ஒன்றிணைக்கிறது — database மற்றும் API schemas-க்கு இடையேயான duplication-ஐக் குறைக்கிறது.

## Migrations மற்றும் async options

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

## இது ஏன் முக்கியம்

Database integration கிட்டத்தட்ட எந்த உண்மையான API-க்கும் அவசியமானது, மேலும் FastAPI அதைப் பற்றி வேண்டுமென்றே **unopinionated**-ஆக இருப்பதால் (Django-இன் built-in ORM-ஐப் போலல்லாமல்), பொதுவான அணுகுமுறையைப் புரிந்துகொள்வது முக்கியமான நடைமுறை அறிவாகும்.

standard pattern — **SQLAlchemy** (அல்லது **SQLModel**, இது ORM மற்றும் Pydantic models-ஐ நேர்த்தியாக ஒன்றிணைத்து duplication-ஐக் குறைக்கிறது) `yield` pattern மூலம் **dependency-injected sessions**-உடன் — தரவை நிலைநிறுத்த கிட்டத்தட்ட ஒவ்வொரு FastAPI app-ம் பயன்படுத்துவது இதுதான்.

session-per-request dependency (முன்பே திற, பின்பு மூடு, தானாகவே) database connections-ஐ நிர்வகிக்கும் idiomatic, சரியான வழியாகும், மேலும் SQLModel-இன் database மற்றும் API schemas-இன் ஒன்றிணைப்பு FastAPI-இன் சொந்த author-இடமிருந்து வரும் ஒரு குறிப்பிடத்தக்க productivity அம்சமாகும்.

database-ஐ அமைப்பது, DI மூலம் sessions-ஐ வழங்குவது, queries செய்வது, மற்றும் migrations (Alembic) மற்றும் async caveat (async endpoints-இல் async drivers-ஐப் பயன்படுத்துவது, blocking sync ones-ஐ ஒருபோதும் அல்ல) ஆகியவற்றைக் கையாள்வது எப்படி என்பதை அறிந்திருப்பது data-driven FastAPI applications-ஐ உருவாக்குவதற்கு அவசியம் — FastAPI உங்களுக்குத் தேர்ந்தெடுக்கும் சுதந்திரத்தைக் கொடுப்பதால், வழக்கமான, நன்கு அறியப்பட்ட பாதையை அறிந்திருப்பது உண்மையான apps-ஐ சரியாக உருவாக்குவதற்கு மதிப்புமிக்கது.