Hvordan fungerer indexes i MongoDB?

Question

Accepted Answer

**Indexes** i MongoDB fremskynder forespørgsler ved at lade databasen finde dokumenter uden at gennemscanne hele samlingen — ligesom i relationelle databaser. Uden indexes udfører forespørgsler en **collection scan** (kontrollerer hvert dokument); med dem er opslag hurtige. MongoDB understøtter flere indekstyper.

## Oprettelse og brug af indexes

```js
// without an index, this scans EVERY document (slow on a big collection)
db.users.find({ email: "ann@x.com" });

// create an index → fast lookups
db.users.createIndex({ email: 1 });        // 1 = ascending (B-tree index)
db.users.find({ email: "ann@x.com" });     // now uses the index

db.users.getIndexes();                      // list indexes
```

Standardfeltet `_id` er altid indekseret. Du tilføjer indexes på felter, du forespørger, sorterer eller filtrerer efter hyppigt.

## Sammensatte indexes (flere felter)

```js
// a compound index on multiple fields — order matters!
db.users.createIndex({ country: 1, age: -1 });
// helps: { country: ? }, { country: ?, age: ? }  (leftmost prefix)
// does NOT help: { age: ? } alone
```

**Sammensatte indexes** dækker forespørgsler på flere felter, men **feltrækkefølgen er vigtig** (indexet understøtter forespørgsler ved hjælp af et venstresidigt præfiks af dets felter — en vigtig regel at forstå).

## Indekstyper

```text
Single field    → { field: 1 }
Compound        → { a: 1, b: -1 } (multiple fields)
Multi-key       → automatically created when indexing an ARRAY field (indexes each element)
Text            → text search on string content
Geospatial      → 2dsphere for location queries
Hashed          → for hashed sharding
TTL             → { createdAt: 1 } with expireAfterSeconds → auto-delete old docs
Unique          → { email: 1 }, { unique: true } → enforce uniqueness
Partial/Sparse  → index only some documents
```

## Afvejningen (samme som SQL)

```text
✓ Indexes speed up reads dramatically (collection scan → index lookup)
✗ But they consume storage and SLOW DOWN writes (each write updates indexes)
→ Index what you query frequently; don't over-index (hurts writes). Use explain()
  to verify queries use indexes (look for COLLSCAN = bad, IXSCAN = good).
```

## Hvorfor det betyder noget

Indexes er et af de vigtigste emner for MongoDB-ydeevne — de er det primære værktøj til at gøre forespørgsler hurtige, og principperne ligner relationelle databaser, så forståelse af dem er væsentlig viden for ydeevnedygtige MongoDB-applikationer.

Uden indexes kræver forespørgsler **collection scans** (kontrollerer hvert dokument — katastrofalt langt når samlingen vokser), mens indexes muliggør hurtige opslag — ofte forskellen mellem en forespørgsel, der tager millisekunder versus sekunder.

Forståelse af, hvordan man opretter indexes på hyppigt forespurgte/sorterede/filtrerede felter, er fundamental. **Sammensatte indexes** (dækkende forespørgsler med flere felter) er vigtige, især reglen om at **feltrækkefølgen betyder noget** (et index understøtter forespørgsler ved hjælp af et venstresidigt præfiks af dets felter — et vigtig koncept for design af effektive sammensatte indexes).

Kendskab til MongoDB-relevante indekstyper er værdifuldt: **multi-key indexes** (automatisk indeksering af array-elementer — vigtig givet MongoDBs array-tunge dokumenter), **TTL indexes** (auto-udløbende gamle dokumenter — nyttigt til sessioner, logs, midlertidigt data), **unique indexes** (påtvinger enestillinger), tekst- og geospatiale indexes til specialiserede forespørgsler, og delvise/sparse indexes.

Forståelse af **afvejningen** (indexes fremskynder læsninger men forbruger lagerplads og bremser skrivninger, så indeksér hvad du forespørger uden over-indeksering) og brug af **`explain()`** til at bekræfte, at forespørgsler bruger indexes (COLLSCAN = dårlig scan, IXSCAN = godt indexbrug) er den vigtigste praktiske færdighed for optimering.

Da forespørgselsydeevne er kritisk, og korrekt indeksering er den mest påvirkende MongoDB-optimering, er forståelse af indexes — hvordan de fungerer, sammensatte indexordning, MongoDB-specifikke typer (multi-key, TTL, unique), lese/skrive-afvejningen, og verifikation med explain() — vigtig, høj-værdi viden for ydeevnedygtige MongoDB-applikationer og et af de vigtigste MongoDB-emner, parallelt med indekseringens betydning i SQL-databaser.