Hur integrerar du en SQL-databas med FastAPI?

Question

Accepted Answer

Till skillnad från Django är FastAPI **inte opinionerad** när det gäller databaser — du väljer själv biblioteket. Det vanligaste valet är **SQLAlchemy** (ofta tillsammans med **SQLModel**, skrivet av FastAPIs författare, som kombinerar SQLAlchemy + Pydantic). Databassessioner tillhandahålls via dependency injection.

## SQLAlchemy-inställning

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

## Tillhandahålla DB-sessionen via ett beroende

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

Mönstret `yield` dependency är standardsättet att hantera sessioner: öppna en per förfrågan, injicera den och stäng den efteråt automatiskt — varje endpoint får en ren, korrekt stängd session.

## 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 förenar ORM-modellen och Pydantic-modellen i en enda klass — vilket minskar duplicering mellan databas och API-scheman.

## Migrationer och async-alternativ

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

## Varför det är viktigt

Databaskörning är väsentlig för nästan alla riktiga API:er, och eftersom FastAPI är medvetet **inte opinionerad** om det (till skillnad från Djangos inbyggda ORM), är det viktigt praktiskt kunskap att förstå den vanliga metoden.

Standardmönstret — **SQLAlchemy** (eller **SQLModel**, som elegant förenar ORM och Pydantic-modeller för att minska duplicering) tillsammans med **beroendeinsprutade sessioner** via `yield`-mönstret — är det som nästan alla FastAPI-appar använder för att lagra data.

Sessionen-per-förfrågan-beroende (öppna innan, stäng efteråt, automatiskt) är det idiomatiska, korrekta sättet att hantera databasanslutningar, och SQLModels förening av databas- och API-scheman är en anmärkningsvärd produktivitetsfunktion från FastAPIs egen författare.

Att veta hur man ställer in databasen, tillhandahåller sessioner genom DI, utför frågor och hanterar migrationer (Alembic) och async-varningen (använda async-drivrutiner i async-endpoints, aldrig blockera synkrona sådana) är nödvändigt för att bygga datadrivna FastAPI-applikationer — eftersom FastAPI ger dig friheten att välja, är det värdefullt att känna till den konventionella, väl upptrampade vägen för att bygga riktiga appar korrekt.