Anayi haɗa SQL database da FastAPI?

Question

Accepted Answer

Ba kamar Django ba, FastAPI ba shi da **ra'ayi** game da databases — ka zaɓi labreri. Zaɓin gida shine **SQLAlchemy** (sau da yawa tare da **SQLModel**, na marubucin FastAPI, wanda ya haɗa SQLAlchemy + Pydantic). Ana ba da database sessions ta hanyar dependency injection.

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

## Samar da DB session ta hanyar dependency

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

The `yield` dependency pattern shine karamin hanyar sarrafa sessions: buɗe ɗaya per request, jera shi, kuma rufe shi bayan nan ta atomatik — kowane endpoint yana samun tsabar, da kyau-rufuffiyar session.

## SQLModel — SQLAlchemy + Pydantic cikin ɗaya

```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 ya haɗa ORM model da Pydantic model cikin ɗaya ajiyar — rage watsi tsakanin database da API schemas.

## Migrations da zaɓuwan 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)
```

## Me yake matukar muhimmi

Haɗawar database yake mahimmanci ga kusan kowane real API, kuma tunda FastAPI shi ba shi da **ra'ayi** game da shi (ba kamar Django's built-in ORM ba), fahimtar sabon hanyar gida yake mahimmanci ilimin aiki.

Sabon hanyar — **SQLAlchemy** (ko **SQLModel**, wanda ya haɗa ORM da Pydantic models a kaifin rage watsi) tare da **dependency-injected sessions** ta hanyar `yield` pattern — shine abin da kusan kowane FastAPI app yana amfani shi don tsare data.

The session-per-request dependency (buɗe kafin, rufe bayan, ta atomatik) shine karamin, daidai hanyar sarrafa database connections, kuma SQLModel's haɗawa na database da API schemas yake fasalin manufa daga marubucin FastAPI shi kansa.

Sanin yadda ake saita database, samar da sessions ta hanyar DI, aiwatar da queries, da sarrafa migrations (Alembic) da async caveat (amfani da async drivers a cikin async endpoints, kamɗa kuma blocking sync ones ba) yake dole a gina data-driven FastAPI applications — tunda FastAPI yana ba ku 'yancin zaɓi, sanin sabon hanyar gida, da kyau-tafiyayya ita ce abin yatakamata don gina real apps daidai.