మీరు SQLAlchemy డేటాబేస్‌ను FastAPI తో ఎలా ఇంటిగ్రేట్ చేస్తారు?

Question

Accepted Answer

Django కాకుండా, FastAPI డేటాబేస్‌ల గురించి **unopinionated** — మీరు లైబ్రరీని ఎంచుకుంటారు. సాధారణ ఎంపిక **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` డిపెండెన్సీ పాటర్న్ సెషన్‌లను నిర్వహించడానికి ప్రామాణిక మార్గం: ప్రతి రిక్వెస్ట్‌కు ఒకటి తెరవండి, దానిని ఇంజెక్ట్ చేయండి, ఆపై దానిని సవ్యంగా మూసివేయండి — ప్రతి ఎండ్‌పాయింట్ పరిశుద్ధ, సరిగా మూసిన సెషన్‌ను పొందుతుంది.

## 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 Django యొక్క నిర్మిత ORM కాకుండా దాని గురించి ఉద్దేశ్యపూర్వకంగా **unopinionated** (అంటే) కనుక, సాధారణ విధానాన్ని అర్థం చేసుకోవడం ముఖ్యమైన ఆచరణ జ్ఞానం.

ప్రామాణిక పాటర్న్ — **SQLAlchemy** (లేదా **SQLModel**, ఇది ORM మరియు Pydantic మోడల్‌లను సంపూర్ణంగా ఐక్యం చేస్తుంది నకిలీకరణను తగ్గించడానికి) **dependency-injected సెషన్‌లు** `yield` పాటర్న్ ద్వారా — ఇది దాదాపు ప్రతిটి FastAPI యాప్ డేటాను సংరక్షించడానికి ఉపయోగిస్తుంది.

రిక్వెస్ట్-ప్రతి-సెషన్ డిపెండెన్సీ (తెరవండి ఇతిహాస, తర్వాత మూసివేయండి, స్వయంచాలకంగా) డేటాబేస్ కనెక్షన్‌లను నిర్వహించడానికి idiomatic, సరైన మార్గం, మరియు SQLModel యొక్క డేటాబేస్ మరియు API స్కీమాల ఐక్యం FastAPI యొక్క స్వంత రచయిత నుండి ఒక గమనించదగిన ఉత్పాదకత లక్షణం.

డేటాబేస్‌ను సెటআప్ చేయడం, DI ద్వారా సెషన్‌లను అందించడం, కోరలను నిర్వహించడం, మరియు మైగ్రేషన్‌లను (Alembic) మరియు async సावధానియని (async ఎండ్‌పాయింట్‌లలో async డ్రైవర్‌లను ఉపయోగించడం, ఎప్పుడూ బ్లాకింగ్ సింక్ నిర్వహణ) ఎలా చేయాలో తెలుసుకోవడం డేటా-నడిచిన FastAPI యాప్‌లను నిర్మించడానికి అవసరం — FastAPI మీకు ఎంచుకోవడానికి స్వేచ్ఛ ఇస్తుందని కనుక, సంప్రదాయ, బాగా-ట్రోడెన్ పాతను తెలుసుకోవడం నిజమైన యాప్‌లను సరిగ్గా నిర్మించడానికి విలువైనది.