Miten integroit SQL-tietokannan FastAPI:n kanssa?

Question

Accepted Answer

Toisin kuin Django, FastAPI on **mielipiteetön** tietokantojen suhteen — valitset kirjaston itse. Yleinen valinta on **SQLAlchemy** (usein yhdessä **SQLModel**in kanssa, jonka on kirjoittanut FastAPI:n tekijä, ja joka yhdistää SQLAlchemyn + Pydanticin). Tietokantaistunnot tarjotaan riippuvuusinjektioinnin kautta.

## SQLAlchemy-asetukset

```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-istunnon tarjoaminen riippuvuuden kautta

```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`-riippuvuuskuvio on vakiinttunut tapa hallita istuntoja: avaa yksi pyyntöä kohti, injektoi se ja sulje se jälkeenpäin automaattisesti — jokainen päätepisteen saavat puhtaan, asianmukaisesti suljetun istunnon.

## SQLModel — SQLAlchemy + Pydantic yhdessä

```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 yhdistää ORM-mallin ja Pydantic-mallin yhdeksi luokaksi — vähentäen duplikointia tietokannan ja API-skeemojen välillä.

## Migraatiot ja async-vaihtoehdot

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

## Miksi sillä on merkitystä

Tietokannan integrointi on välttämätöntä lähes jokaiselle todelliselle API:lle, ja koska FastAPI on tarkoituksella **mielipiteetön** sen suhteen (toisin kuin Djangon sisäänrakennettu ORM), yleisen lähestymistavan ymmärtäminen on tärkeää käytännön tietoa.

Vakiomallin — **SQLAlchemy** (tai **SQLModel**, joka tyylikkäästi yhdistää ORM:n ja Pydantic-mallit duplikaatioiden vähentämiseksi) ja **riippuvuusinjektoidut istunnot** `yield`-kuviolla — käyttävät lähes kaikki FastAPI-sovellukset tietojen pysyttämiseksi.

Istunto-per-pyyntö-riippuvuus (avaa ennen, sulje jälkeenpäin, automaattisesti) on idiomatttinen ja oikea tapa hallita tietokantayhteyksiä, ja SQLModel:n tietokannan ja API-skeemojen yhdistäminen on merkittävä tuottavuusominaisuus FastAPI:n omalta tekijältä.

Tietäminen, kuinka konfiguroida tietokanta, tarjota istuntoja DI:n kautta, suorittaa kyselyjä ja hallita migraatioita (Alembic) ja async-huomioita (async-ajurien käyttö async-päätepisteissä, ei koskaan synkronoitujen estäminen) on välttämätöntä data-ohjautuvien FastAPI-sovellusten rakentamiseksi — koska FastAPI antaa sinulle vapauden valita, tavallisen, hyväksi todetun polun tuntemus on arvokasta oikeiden sovellusten rakentamiseksi.