आप FastAPI के साथ SQL database को कैसे integrate करते हैं?

Question

Accepted Answer

Django के विपरीत, FastAPI databases के बारे में **unopinionated** है — आप library चुनते हैं। सामान्य विकल्प **SQLAlchemy** है (अक्सर **SQLModel** के साथ, FastAPI के लेखक द्वारा, जो 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)
```

## dependency के माध्यम से DB session प्रदान करना

```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 को manage करने का मानक तरीका है: प्रति 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 के बीच दोहराव को कम करता है।

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

## यह क्यों महत्वपूर्ण है

Database integration लगभग किसी भी वास्तविक API के लिए आवश्यक है, और चूंकि FastAPI जानबूझकर इसके बारे में **unopinionated** है (Django के built-in ORM के विपरीत), सामान्य दृष्टिकोण को समझना महत्वपूर्ण व्यावहारिक ज्ञान है।

मानक pattern — **SQLAlchemy** (या **SQLModel**, जो दोहराव कम करने के लिए ORM और Pydantic models को सुरुचिपूर्ण ढंग से एकीकृत करता है) के साथ `yield` pattern के माध्यम से **dependency-injected sessions** — वह है जिसका उपयोग लगभग हर FastAPI app data को persist करने के लिए करता है।

session-per-request dependency (पहले खोलें, बाद में बंद करें, स्वचालित रूप से) database connections को manage करने का idiomatic, सही तरीका है, और SQLModel का database और API schemas का एकीकरण FastAPI के अपने लेखक की एक उल्लेखनीय productivity विशेषता है।

यह जानना कि database कैसे set up करें, DI के माध्यम से sessions कैसे प्रदान करें, queries कैसे करें, और migrations (Alembic) तथा async caveat (async endpoints में async drivers का उपयोग करना, blocking sync वालों का कभी नहीं) कैसे संभालें, data-driven FastAPI applications बनाने के लिए आवश्यक है — चूंकि FastAPI आपको चुनने की स्वतंत्रता देता है, पारंपरिक, सुस्थापित मार्ग को जानना वास्तविक apps को सही ढंग से बनाने के लिए मूल्यवान है।