Hvordan integrerer du en SQL-database med FastAPI?

Question

IT Interview Practice · Accepted Answer

I motsetning til Django er FastAPI **ubestemt** når det gjelder databaser — du velger biblioteket selv. Det vanlige valget er **SQLAlchemy** (ofte med **SQLModel**, skrevet av FastAPI-forfatteren, som kombinerer SQLAlchemy + Pydantic). Databasesesjoner leveres via avhengighetsinjeksjon.

## SQLAlchemy-oppsett

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

## Tilby DB-sesjonen via en avhengighet

```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`-avhengighetsmønsteret er standardmåten å administrere sesjoner på: åpne en per forespørsel, injiser den, og lukk den etterpå automatisk — hver endepunkt får en ren, korrekt lukket sesjon.

## SQLModel — SQLAlchemy + Pydantic i ett

```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 forener ORM-modellen og Pydantic-modellen i én klasse — noe som reduserer duplikering mellom database- og API-skjemaer.

## Migrasjoner og async-alternativer

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

## Hvorfor det er viktig

Databaseintegrasjon er essensielt for nesten alle virkelige APIer, og siden FastAPI bevisst er **ubestemt** når det gjelder dette (i motsetning til Djangos innebygde ORM), er det viktig praktisk kunnskap å forstå den vanlige tilnærmingen.

Standardmønsteret — **SQLAlchemy** (eller **SQLModel**, som elegant forener ORM og Pydantic-modeller for å redusere duplikering) med **avhengighetsinjiserte sesjoner** via `yield`-mønsteret — er det som nesten alle FastAPI-apper bruker for å lagre data.

Sesjonen-per-forespørsel-avhengigheten (åpne før, lukk etterpå, automatisk) er den idiomatiske, korrekte måten å administrere databaseforbindelser på, og SQLModels forening av database- og API-skjemaer er en bemerkelsesverdig produktivitetsfunksjon fra FastAPI-forfatteren selv.

Å vite hvordan du setter opp databasen, leverer sesjoner gjennom DI, utfører spørringer, og håndterer migrasjoner (Alembic) og async-forbehold (bruk async-drivere i async-endepunkter, aldri blokkerande synkrone) er nødvendig for å bygge datadrevne FastAPI-applikasjoner — siden FastAPI gir deg friheten til å velge, er det verdifullt å kjenne den konvensjonelle, velartet stien for å bygge virkelige apper korrekt.

SQLAlchemy-oppsett

Tilby DB-sesjonen via en avhengighet

SQLModel — SQLAlchemy + Pydantic i ett

Migrasjoner og async-alternativer

Hvorfor det er viktig

Relaterte spørsmål