Hvordan vælger du databaser i systemdesign?

Question

Accepted Answer

At vælge den rigtige **database** er en vigtig systemdesign-beslutning — mellem **SQL (relationel)** og **NoSQL**-typer (dokument, nøgle-værdi osv.), baseret på data, adgangsmønstre, skalering og konsistenskrav. Forskellige databaser passer til forskellige krav.

## SQL vs NoSQL (det vigtigste valg)

```text
SQL (relational: PostgreSQL, MySQL) → structured data, tables, relationships, ACID:
  ✓ strong consistency, complex queries/joins, transactions, well-defined schema
  ✓ for: relational data, transactions, complex queries (most traditional apps)
NOSQL → various non-relational models, flexible schema, often easier horizontal scaling:
  → DOCUMENT (MongoDB) → flexible JSON-like docs
  → KEY-VALUE (Redis, DynamoDB) → simple, fast lookups, caching
  → WIDE-COLUMN (Cassandra) → massive scale, high write throughput
  → GRAPH (Neo4j) → relationships/networks
  ✓ for: flexible schema, huge scale, specific access patterns, high throughput
```

## Hvordan man vælger

```text
Consider:
  → DATA structure → relational/structured (SQL) vs flexible/varied (NoSQL document)
  → ACCESS PATTERNS → complex queries/joins (SQL) vs simple key lookups (key-value)
  → SCALE → massive horizontal scale / huge write volume (some NoSQL) vs moderate (SQL fine)
  → CONSISTENCY → strong consistency/transactions (SQL) vs eventual OK (some NoSQL)
  → choose the database that FITS the requirements (not just what's trendy)
```

## Polyglot persistence

```text
→ Use DIFFERENT databases for different needs in one system ("polyglot persistence"):
  e.g. PostgreSQL for core data + Redis for caching + Elasticsearch for search
→ no single database is best for everything → use the right tool for each job
```

## Hvorfor det betyder noget

At forstå, hvordan man vælger databaser, er grundlæggende, fordi **valg af database er en vigtig, betydningsfuld systemdesign-beslutning**, som væsentligt påvirker et systems kapaciteter, så det er vigtig viden.

Databasen er central for de fleste systemer, og at vælge den rigtige — mellem **SQL (relationel)** og de forskellige **NoSQL**-typer — baseret på krav er en vigtig arkitektonisk beslutning.

At forstå **SQL vs NoSQL**-skellet er grundlæggende: SQL-databaser tilbyder stærk konsistens, komplekse forespørgsler og joins, transaktioner og strukturerede skemaer (der passer til relationelle data og traditionelle applikationer), mens NoSQL-databaser tilbyder fleksible skemaer og ofte lettere vandret skalering, med forskellige typer (dokument, nøgle-værdi, bred søjle, graf), der passer til forskellige behov (fleksible data, massiv skalering, høj gennemstrømning, specifikke adgangsmønstre).

At forstå **hvordan man vælger** — baseret på datastruktur (relationel vs fleksibel), adgangsmønstre (komplekse forespørgsler vs simple opslag), skalering (massiv vandret skalering vs moderat) og konsistenskrav (stærk vs eventuel) — er nøglefærdigheden, med det vigtige princip om at vælge den database, der **passer til kravene** snarere end hvad der er trendigt.

At forstå **polyglot persistence** — at bruge forskellige databaser til forskellige behov i ét system (f.eks. PostgreSQL for kernedata, Redis til caching, Elasticsearch til søgning) — afspejler den modne erkendelse af, at ingen enkelt database er bedst til alt, så at bruge det rigtige værktøj til hver opgave er ofte optimalt.

Da databasen er central for de fleste systemer, og at vælge den rigtige (SQL vs NoSQL-typer, baseret på data, adgangsmønstre, skalering og konsistens) væsentligt påvirker systemets kapaciteter og er en vigtig designbeslutning, og da at forstå, hvordan man vælger, og polyglot-persistence-tilgangen er grundlæggende, er forståelse af, hvordan man vælger databaser, vigtig, grundlæggende systemdesign-viden — en vigtig, betydningsfuld beslutning i systemdesign, som kræver forståelse af databasealternativerne og hvordan man matcher dem til krav, og er central for at designe systemer med passende datalagringsløsninger.