તમે 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` નિર્ભરતા પેટર્ન એ સેશનો સંચાલન કરવાનો પ્રમાણભૂત માર્ગ છે: એક પ્રતિ વિનંતી ખોલો, તેને ઇંજેક્ટ કરો, અને તે પછી આપોઆપ બંધ કરો — દરેક એન્ડપોઇન્ટ એક સ્વચ્છ, યોગ્યરીતે બંધ સેશન મેળવે છે।

## 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 ની વિપરીતમાં), સામાન્ય પદ્ધતિને સમજવું મહત્વપૂર્ણ વ્યવહારિક જ્ઞાન છે।

પ્રમાણભૂત પેટર્ન — **SQLAlchemy** (અથવા **SQLModel**, જે ORM અને Pydantic મોડેલોને શ્રેષ્ઠતાપૂર્વક એકીકૃત કરે છે દ્વૈધતા ઘટાડવા માટે) **નિર્ભરતા-ઇંજેક્ટેડ સેશનો** સાથે `yield` પેટર્ન દ્વારા — લગભગ દરેક FastAPI એપ્લિકેશન ડેટા સ્થિર કરવા માટે ઉપયોગ કરે છે।

સેશન-પ્રતિ-વિનંતી નિર્ભરતા (પહેલા ખોલો, પછી બંધ કરો, આપોઆપ) ડેટાબેસ કનેક્શનો સંચાલન કરવાનો શાસ્ત્રીય, સાચો માર્ગ છે, અને SQLModel ડેટાબેસ અને API સ્કીમાનું એકીકરણ FastAPI ના પોતાના લેખક તરફથી એક નોંધણીય ઉત્પાદનક્ષમતા લક્ષણ છે।

ડેટાબેસ સેટ કરવું, DI દ્વારા સેશનો પ્રદાન કરવું, ક્વેરીઝ કરવી, અને મહત્તર (Alembic) અને async ચેતવણી (async એન્ડપોઇન્ટમાં async ડ્રાઇવરોનો ઉપયોગ કરવો, ક્યારેય બ્લોક કરતો સમન્વય તો નહીં) સંચાલન કરવું જાણવું ડેટા-સંચાલિત FastAPI એપ્લિકેશનો બનાવવા માટે જરૂરી છે — કારણ કે FastAPI તમને પસંદ કરવાની સ્વતંત્રતા આપે છે, પરંપરાગત, સુપ્રતિષ્ઠિત પથ જાણવું વાસ્તવિક એપ્લિકેશનો સાચી રીતે બનાવવા માટે મૂલ્યવાન છે।