Hvordan fungerer indekser i MongoDB?

Question

Accepted Answer

**Indekser** i MongoDB akselererer spørringer ved å la databasen finne dokumenter uten å skanne hele samlingen — akkurat som i relasjonsdatabaser. Uten indekser gjør spørringer en **collection scan** (sjekker alle dokumenter); med dem er oppslag raske. MongoDB støtter flere indekstyper.

## Opprette og bruke indekser

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

Standard `_id`-feltet er alltid indeksert. Du legger til indekser på felt du spør på, sorterer eller filtrerer hyppig.

## Sammensatte indekser (flere felt)

```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 indekser** dekker spørringer på flere felt, men **feltrekkefølgen betyr noe** (indeksen støtter spørringer som bruker et venstreste prefiks av feltene — en nøkkelregel å 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
```

## Avveiningen (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 betyr noe

Indekser er ett av de viktigste temaene for MongoDB-ytelse — de er det primære verktøyet for å gjøre spørringer raske, og prinsippene er like relasjonsdatabaser, så å forstå dem er essensiell kunnskap for velytende MongoDB-applikasjoner.

Uten indekser krever spørringer **collection scans** (sjekker alle dokumenter — katastrofalt langsomt når samlinger vokser), mens indekser muliggjør raske oppslag — ofte forskjellen mellom en spørring som tar millisekunder versus sekunder.

Å forstå hvordan man oppretter indekser på hyppig-spurt/sortert/filtrert felt er grunnleggende. **Sammensatte indekser** (som dekker multi-felt-spørringer) er viktige, spesielt regelen at **feltrekkefølgen betyr noe** (en indeks støtter spørringer som bruker et venstreste prefiks av feltene — et nøkkelbegrep for å designe effektive sammensatte indekser).

Å kjenne MongoDB-relevante indekstyper er verdifullt: **multi-key indekser** (automatisk indeksering av array-elementer — viktig gitt MongoDBs array-tunge dokumenter), **TTL indekser** (auto-utløpende gamle dokumenter — nyttig for sesjoner, logger, midlertidige data), **unike indekser** (som håndhever unikhet), tekst- og geospatiale indekser for spesialiserte spørringer, og delvise/sparse indekser.

Å forstå **avveiningen** (indekser akselererer lesing men bruker lagring og bremser skrivinger, så indekser hva du spør etter uten å over-indeksere) og bruke **`explain()`** for å bekrefte spørringer bruker indekser (COLLSCAN = dårlig scan, IXSCAN = god indeksbruk) er nøkkelferdigheten for optimalisering.

Siden spørringsstytelse er kritisk og riktig indeksering er den mest virkningsfulle MongoDB-optimaliseringen, er forståelse av indekser — hvordan de fungerer, rekkefølge for sammensatte indekser, MongoDB-spesifikke typer (multi-key, TTL, unik), lese-/skrive-avveiningen, og verifisering med explain() — essensiell, høy-verdi kunnskap for velytende MongoDB-applikasjoner og ett av de viktigste MongoDB-temaene, parallelt med indekseringstemaets betydning i SQL-databaser.