ਤੁਸੀਂ FastAPI ਨਾਲ SQL ਡਾਟਾਬੇਸ ਨੂੰ ਕਿਵੇਂ ਜੋੜਦੇ ਹੋ?

Question

Accepted Answer

Django ਦੇ ਉਲਟ, FastAPI **ਬਿਨਾ ਕਿਸੇ ਵਿਚਾਰ ਦੇ** ਡਾਟਾਬੇਸ ਬਾਰੇ ਹੈ — ਤੁਸੀਂ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਚੋਣ ਕਰਦੇ ਹੋ। ਆਮ ਵਿਕਲਪ **SQLAlchemy** ਹੈ (ਅਕਸਰ **SQLModel** ਦੇ ਨਾਲ, FastAPI ਦੇ ਲੇਖਕ ਦੁਆਰਾ, ਜੋ SQLAlchemy + Pydantic ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ)। ਡਾਟਾਬੇਸ ਸੈਸ਼ਨ dependency injection ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

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

## 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 ਪੈਟਰਨ ਸੈਸ਼ਨ ਦਾ ਪ੍ਰਬੰਧ ਕਰਨ ਦਾ ਮਿਆਰੀ ਤਰੀਕਾ ਹੈ: ਹਰ ਬੇਨਤੀ ਲਈ ਇੱਕ ਖੋਲੋ, ਇਸਨੂੰ inject ਕਰੋ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਸਵੈਚਲਿਤ ਤੌਰ ਤੇ ਬੰਦ ਕਰੋ — ਹਰ 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 ਸਕੀਮਾ ਦੇ ਵਿਚਕਾਰ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

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

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਡਾਟਾਬੇਸ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਲਗਭਗ ਕਿਸੇ ਵੀ ਅਸਲੀ API ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ FastAPI ਇਸ ਬਾਰੇ ਜਾਣ-ਬੁੱਝ ਕੇ **unopinionated** ਹੈ (Django ਦੇ ਬਿਲਟ-ਇਨ ORM ਦੇ ਉਲਟ), ਆਮ ਪਹੁੰਚ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਵਿਹਾਰਕ ਗਿਆਨ ਹੈ।

ਮਿਆਰੀ ਪੈਟਰਨ — **SQLAlchemy** (ਜਾਂ **SQLModel**, ਜੋ ORM ਅਤੇ Pydantic ਮਾਡਲਾਂ ਨੂੰ ਖੂਬਸੂਰਤੀ ਨਾਲ ਜੋੜਦਾ ਹੈ ਤਾਂ ਜੋ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਇਆ ਜਾ ਸਕੇ) `yield` ਪੈਟਰਨ ਦੁਆਰਾ **dependency-injected sessions** ਦੇ ਨਾਲ — ਲਗਭਗ ਹਰ FastAPI ਐਪ ਡਾਟਾ ਨੂੰ ਸਥਾਈ ਕਰਨ ਲਈ ਵਰਤਦਾ ਹੈ।

Session-per-request dependency (ਪਹਿਲਾਂ ਖੋਲੋ, ਬਾਅਦ ਵਿੱਚ ਬੰਦ ਕਰੋ, ਸਵੈਚਲਿਤ ਤੌਰ ਤੇ) ਡਾਟਾਬੇਸ ਕਨੈਕਸ਼ਨਾਂ ਦਾ ਪ੍ਰਬੰਧ ਕਰਨ ਦਾ idiomatic, ਸਹੀ ਤਰੀਕਾ ਹੈ, ਅਤੇ SQLModel ਦਾ ਡਾਟਾਬੇਸ ਅਤੇ API ਸਕੀਮਾ ਦਾ ਏਕੀਕਰਨ FastAPI ਦੇ ਆਪਣੇ ਲੇਖਕ ਵਲੋਂ ਇੱਕ ਖਾਸ ਉਤਪਾਦਕਤਾ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ।

ਜਾਣਨਾ ਕਿ ਕਿਵੇਂ ਡਾਟਾਬੇਸ ਨੂੰ ਸੈਟ ਅਪ ਕਰਨਾ ਹੈ, DI ਦੁਆਰਾ ਸੈਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨਾ ਹੈ, ਪ੍ਰਸ਼ਨ ਕਰਨੇ ਹਨ, ਅਤੇ migrations (Alembic) ਅਤੇ async caveat (async endpoints ਵਿੱਚ async drivers ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਕਦੇ blocking sync ਦੀ ਨਹੀਂ) ਨੂੰ ਸੰਭਾਲਣਾ ਹੈ data-driven FastAPI ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਕਿਉਂਕਿ FastAPI ਤੁਹਾਨੂੰ ਚੁਣਨ ਦੀ ਆਜ਼ਾਦੀ ਦਿੰਦਾ ਹੈ, ਰਵਾਇਤੀ, ਚੰਗੀ ਤਰ੍ਹਾਂ ਵਿਲਾਸ਼ ਰਸਤਾ ਜਾਣਨਾ ਅਸਲੀ ਐਪ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਬਣਾਉਣ ਲਈ ਮੁੱਲਵਾਨ ਹੈ।