FastAPI मध्ये SQL डेटाबेस कसे एकीकृत करावे?

Question

Accepted Answer

Django च्या विपरीत, FastAPI डेटाबेसच्या बाबतीत **निरपेक्ष** आहे — आपण लायब्रेरी निवडतो. सामान्य पर्याय **SQLAlchemy** (अनेकदा **SQLModel** सह, FastAPI च्या लेखकाकडून, जो SQLAlchemy + Pydantic एकत्रित करतो). डेटाबेस सेशन 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 सेशन प्रदान करणे

```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 हा सेशन व्यवस्थापनचा मानक मार्ग आहे: प्रत्येक request साठी एक उघडा, त्याला इंजेक्ट करा, आणि नंतर स्वयंचलितपणे बंद करा — प्रत्येक 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 model आणि Pydantic model एकत्रित करतो — डेटाबेस आणि API schemas मधील duplicity कमी करतो.

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

## हे महत्वाचे का आहे

डेटाबेस एकीकरण जवळजवळ कोणत्याही वास्तविक API साठी आवश्यक आहे, आणि FastAPI हे Django च्या built-in ORM च्या विपरीत, त्याच्या बाबतीत जाणूनबुझून **निरपेक्ष** आहे, सामान्य दृष्टिकोन समजणे महत्वाचे व्यावहारिक ज्ञान आहे.

मानक pattern — **SQLAlchemy** (किंवा **SQLModel**, जो ORM आणि Pydantic models एकत्रित करून duplication कमी करते) `yield` pattern द्वारे **dependency-injected sessions** सह — हा जवळजवळ प्रत्येक FastAPI app डेटा जतन करण्यासाठी वापरतो.

Session-per-request dependency (आधी उघडा, नंतर बंद करा, स्वयंचलितपणे) डेटाबेस कनेक्शन व्यवस्थापनचा idiomatic, योग्य मार्ग आहे, आणि SQLModel च्या डेटाबेस आणि API schemas च्या एकीकरणाने FastAPI च्या स्वत: लेखकाकडून उल्लेखनीय उत्पादकता वैशिष्ट्य आहे.

डेटाबेस कसे setup करावे, DI द्वारे सेशन कसे प्रदान करावे, queries कसे perform करावे, आणि migrations (Alembic) आणि async caveat (async endpoints मध्ये async drivers वापरा, कधीही blocking sync ones वापरू नका) हाताळण्यास कसे जाणून घेणे डेटा-driven FastAPI applications तयार करण्यासाठी आवश्यक आहे — FastAPI तुम्हाला निवडण्याचे स्वातंत्र्य देते म्हणून, पारंपारिक, सुप्रतिष्ठित मार्ग जाणून घेणे वास्तविक apps योग्यरित्या तयार करण्यासाठी मूल्यवान आहे.