FastAPI सँग SQL डेटाबेस कसरी एकीकृत गर्नुहुन्छ?

Question

Accepted Answer

Django को विपरीत, FastAPI **अनिर्णायक** छ डेटाबेसको बारेमा — तपाई लाइब्रेरी छनोट गर्नुहुन्छ। सामान्य छनोट **SQLAlchemy** हो (प्रायः **SQLModel** सँग, FastAPI को लेखक द्वारा, जसले SQLAlchemy + Pydantic लाई जोड्छ)। डेटाबेस सत्रहरू निर्भरता इन्जेकशनको माध्यमबाट प्रदान गरिन्छन्।

## 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 सत्र प्रदान गर्दै

```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` निर्भरता प्याटर्न सत्रहरू व्यवस्थापन गर्ने मानक तरीका हो: प्रत्येक अनुरोधको लागि एक खोल्नुहोस्, यो इन्जेक्ट गर्नुहोस्, र त्यसपछि यो स्वचालित रूपमा बन्द गर्नुहोस् — प्रत्येक endpoint ले एक स्वच्छ, सही तरीकामा बन्द सत्र पায्।

## 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 मडेल र Pydantic मडेल लाई एक वर्गमा एकीकृत गर्छ — डेटाबेस र API स्कीमा बीचको दोहोरोपन कम गर्दछ।

## माइग्रेशन र 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)
```

## किन यो महत्त्वपूर्ण हो

डेटाबेस एकीकरण लगभग कुनै पनि वास्तविक API को लागि आवश्यक छ, र FastAPI deliberate रूपमा यसको बारेमा **अनिर्णायक** छ (Django को built-in ORM को विपरीत), सामान्य दृष्टिकोण बुझ्न महत्त्वपूर्ण व्यावहारिक ज्ञान हो।

मानक प्याटर्न — **SQLAlchemy** (वा **SQLModel**, जसले elegantly ORM र Pydantic मडेलहरूलाई एकीकृत गर्छ दोहोरोपन कम गर्न) **निर्भरता-इन्जेक्ट गरिएको सत्रहरू** सँग `yield` प्याटर्नको माध्यमबाट — यो लगभग प्रत्येक FastAPI अनुप्रयोगमा डेटा persist गर्न को लागि प्रयोग हुन्छ।

सत्र-प्रति-अनुरोध निर्भरता (खोल्नु पहिले, बन्द गर्नु पछि, स्वचालित रूपमा) डेटाबेस कनेक्शनहरू व्यवस्थापन गर्ने idiomatic, सही तरीका हो, र SQLModel को डेटाबेस र API स्कीमाहरूको एकीकरण FastAPI को आफ्नै लेखकको एक उल्लेखनीय उत्पादकता सुविधा हो।

डेटाबेस कसरी सेट अप गर्ने, DI को माध्यमबाट सत्रहरू कसरी प्रदान गर्ने, queries कसरी गर्ने, र माइग्रेशनहरू (Alembic) र async caveat (async endpoints मा async drivers प्रयोग गर्दै, कहिले पनि blocking sync ones गर्न नहुने) व्यवस्थापन गर्ने तरीका जान्न डेटा-संचालित FastAPI अनुप्रयोगहरू निर्माण गर्नको लागि आवश्यक छ — FastAPI ले तपाईलाई छनोट गर्ने स्वतन्त्रता दिएको कारण, पारंपरिक, well-trodden बाटो जान्न वास्तविक अनुप्रयोगहरू सही तरीकामा निर्माण गर्नको लागि मूल्यवान छ।