Hogyan integrálsz egy SQL adatbázist a FastAPI-val?

Question

Accepted Answer

A Django-val ellentétben a FastAPI **véleménytelen** az adatbázisokkal kapcsolatban — te választod az kódtárat. A közös választás az **SQLAlchemy** (gyakran a **SQLModel**-lel, amely a FastAPI szerzője által készült, és ötvözi az SQLAlchemy-t + Pydantic-et). Az adatbázis-munkamenetek függőségi injekción keresztül kerülnek biztosításra.

## SQLAlchemy beállítás

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

## A DB munkamenet biztosítása egy függőségen keresztül

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

A `yield` függőségi minta a standard módszer a munkamenetek kezelésére: nyissunk egyet kérésenként, injektáljuk be, és zárjuk be utána automatikusan — minden végpont egy tiszta, megfelelően lezárt munkamenetet kap.

## SQLModel — SQLAlchemy + Pydantic egyben

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

A SQLModel egy osztályba egyesíti az ORM modellt és a Pydantic modellt — csökkentve az adatbázis és az API sémák közötti duplikációt.

## Migrációk és aszinkron opciók

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

## Miért számít

Az adatbázis-integráció szinte minden valós API-hoz elengedhetetlen, és mivel a FastAPI szándékosan **véleménytelen** erről (a Django beépített ORM-jével ellentétben), a közös megközelítés megértése fontos gyakorlati tudás.

A standard minta — az **SQLAlchemy** (vagy a **SQLModel**, amely elegánsan egyesíti az ORM-et és a Pydantic modelleket a duplikáció csökkentésére) a `yield` mintán keresztül **függőségi injekciós munkamenetekkel** — az, amit szinte minden FastAPI alkalmazás használ az adatok tárolásához.

A kérésenként egy munkamenet függőség (automatikusan nyitva előtte, zárva utána) az idiomatikus, helyes módja az adatbázis-kapcsolatok kezelésének, és a SQLModel sémáját az adatbázis és az API sémáját egyesítő megközelítése a FastAPI saját szerzőjétől származó figyelemreméltó termelékenységi funkció.

Tudni, hogyan kell beállítani az adatbázist, munkameneteket biztosítani a DI-n keresztül, lekérdezéseket végezni, és kezelni a migrációkat (Alembic) és az aszinkron figyelmeztetést (aszinkron illesztőprogramok használata aszinkron végpontokban, soha nem blokkoló szinkron olyanokat) szükséges az adatvezérelt FastAPI alkalmazások létrehozásához — mivel a FastAPI szabadságot ad a választásban, a szokásos, jól járt út ismerete értékes a valós alkalmazások helyes felépítéséhez.