Hoe werken indexen in MongoDB?

Question

Accepted Answer

**Indexen** in MongoDB versnellen query's door de database in staat te stellen om documenten te vinden zonder de hele collectie te scannen — net zoals in relationele databases. Zonder indexen voeren query's een **collectie scan** uit (elk document controleren); met indexen zijn lookups snel. MongoDB ondersteunt verschillende indextypen.

## Indexen maken en gebruiken

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

Het standaard `_id` veld is altijd geïndexeerd. Je voegt indexen toe op velden die je frequent queryt, sorteert of filtert.

## Samengestelde indexen (meerdere velden)

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

**Samengestelde indexen** dekken query's op meerdere velden, maar de **veldvolgorde is belangrijk** (de index ondersteunt query's die een linkse prefix van zijn velden gebruiken — een sleutelregel om te begrijpen).

## Indextypen

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

## De afweging (hetzelfde als 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).
```

## Waarom het belangrijk is

Indexen zijn een van de meest belangrijke onderwerpen voor MongoDB-prestaties — ze zijn het primaire hulpmiddel voor het versnellen van query's, en de principes lijken op relationele databases, dus het begrijpen ervan is essentiële kennis voor performante MongoDB-toepassingen.

Zonder indexen vereisen query's **collectie scans** (elk document controleren — catastrofaal traag naarmate collecties groeien), terwijl indexen snelle lookups mogelijk maken — vaak het verschil tussen een query die milliseconden versus seconden duurt.

Begrijpen hoe je indexen maakt op frequently-queried/sorted/filtered velden is fundamenteel. **Samengestelde indexen** (die query's met meerdere velden dekken) zijn belangrijk, vooral de regel dat **veldvolgorde uitmaakt** (een index ondersteunt query's die een linkse prefix van zijn velden gebruiken — een sleutelconcept voor het ontwerpen van effectieve samengestelde indexen).

De relevante MongoDB-indextypen kennen is waardevol: **multi-key indexen** (automatisch indexeren van array-elementen — belangrijk gezien MongoDB's array-zware documenten), **TTL-indexen** (auto-expiring oude documenten — nuttig voor sessies, logs, tijdelijke gegevens), **unieke indexen** (het afdwingen van uniciteit), tekst- en geospaciale indexen voor gespecialiseerde query's, en partiële/sparse indexen.

De **afweging** begrijpen (indexen versnellen lezen maar verbruiken opslag en vertragen schrijfbewerkingen, dus index wat je queryt zonder te veel indexeren) en **`explain()`** gebruiken om te verifiëren dat query's indexen gebruiken (COLLSCAN = slecht scan, IXSCAN = goed indexgebruik) is de sleutel praktische vaardigheid voor optimalisatie.

Aangezien queryprestaties kritiek zijn en correcte indexering de meest impactvolle MongoDB-optimalisatie is, het begrijpen van indexen — hoe ze werken, samengestelde indexvolgorde, de MongoDB-specifieke typen (multi-key, TTL, uniek), de lees-/schrijfafweging, en verificatie met explain() — is essentiële, waardevol kennis voor performante MongoDB-toepassingen en een van de meest belangrijke MongoDB-onderwerpen, evenals indexering in SQL-databases.