Cum integrezi o bază de date SQL cu FastAPI?

Question

Accepted Answer

Spre deosebire de Django, FastAPI este **lipsit de opinie** cu privire la bazele de date — tu alegi biblioteca. Alegerea comună este **SQLAlchemy** (adesea cu **SQLModel**, creat de autorul FastAPI, care combină SQLAlchemy + Pydantic). Sesiunile de bază de date sunt furnizate prin dependency injection.

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

## Furnizarea sesiunii DB printr-o dependență

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

Patternul de dependență `yield` este modul standard de a gestiona sesiunile: deschide una pe request, injectează-o și închide-o automat după — fiecare endpoint primește o sesiune curată, corect închisă.

## SQLModel — SQLAlchemy + Pydantic într-una

```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 unifică modelul ORM și modelul Pydantic într-o singură clasă — reducând duplicarea între schema bazei de date și API.

## Migrări și opțiuni 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)
```

## De ce este important

Integrarea bazei de date este esențială pentru aproape orice API real, și din moment ce FastAPI este deliberat **lipsit de opinie** cu privire la aceasta (spre deosebire de ORM-ul încorporat al Django), înțelegerea abordării comune este cunoștințe practice importante.

Patternul standard — **SQLAlchemy** (sau **SQLModel**, care unifică elegant modelul ORM și modelele Pydantic pentru a reduce duplicarea) cu **sesiuni injectate prin dependențe** prin patternul `yield` — este ceea ce folosesc aproape toate aplicațiile FastAPI pentru a persista date.

Dependența sesiune-per-request (deschide înainte, închide după, automat) este modul idiomativ și corect de a gestiona conexiunile la baza de date, iar unificarea schemei bazei de date și API a SQLModel este o caracteristică notabilă de productivitate de la autorul propriului FastAPI.

A ști cum să configurezi baza de date, să furnizezi sesiuni prin DI, să efectuezi interogări și să gestionezi migrări (Alembic) și caveatele async (folosind drivere async în endpoints async, niciodată blocând cele sincrone) este necesar pentru a construi aplicații FastAPI orientate pe date — deoarece FastAPI îți oferă libertatea de a alege, a cunoaște calea convențională și bine-călcată este valoroasă pentru a construi aplicații reale corect.