Comment fonctionnent les indexes dans MongoDB ?

Question

Accepted Answer

**Les indexes** dans MongoDB accélèrent les requêtes en permettant à la base de données de trouver des documents sans scanner toute la collection — comme dans les bases de données relationnelles. Sans indexes, les requêtes font un **collection scan** (vérification de chaque document) ; avec eux, les recherches sont rapides. MongoDB supporte plusieurs types d'indexes.

## Créer et utiliser des 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
```

Le champ `_id` par défaut est toujours indexé. Vous ajoutez des indexes sur les champs que vous interrogez, triez ou filtrez fréquemment.

## Indexes composés (plusieurs champs)

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

**Les indexes composés** couvrent les requêtes sur plusieurs champs, mais **l'ordre des champs est important** (l'index supporte les requêtes utilisant un préfixe de ses champs les plus à gauche — une règle clé à comprendre).

## Types d'indexes

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

## Le compromis (identique à 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).
```

## Pourquoi c'est important

Les indexes sont l'un des sujets les plus importants pour la performance MongoDB — ils sont l'outil principal pour accélérer les requêtes, et les principes sont similaires à ceux des bases de données relationnelles, donc les comprendre est une connaissance essentielle pour des applications MongoDB performantes.

Sans indexes, les requêtes exigent des **collection scans** (vérification de chaque document — catastrophiquement lent avec de grandes collections), tandis que les indexes permettent des recherches rapides — souvent la différence entre une requête prenant des millisecondes ou des secondes.

Comprendre comment créer des indexes sur les champs interrogés/triés/filtrés fréquemment est fondamental. **Les indexes composés** (couvrant les requêtes multi-champs) sont importants, en particulier la règle selon laquelle **l'ordre des champs est important** (un index supporte les requêtes utilisant un préfixe de ses champs les plus à gauche — un concept clé pour concevoir des indexes composés efficaces).

Connaître les types d'indexes pertinents pour MongoDB est précieux : **les indexes multi-clés** (indexation automatique des éléments de tableau — important étant donné que les documents MongoDB utilisent beaucoup les tableaux), **les indexes TTL** (expiration automatique des anciens documents — utile pour les sessions, logs, données temporaires), **les indexes uniques** (application d'unicité), les indexes texte et géospatial pour les requêtes spécialisées, et les indexes partiels/sparse.

Comprendre le **compromis** (les indexes accélèrent les lectures mais consomment du stockage et ralentissent les écritures, donc indexez ce que vous interrogez sans sur-indexer) et utiliser **`explain()`** pour vérifier que les requêtes utilisent les indexes (COLLSCAN = mauvais scan, IXSCAN = bon usage d'index) est la compétence pratique clé pour l'optimisation.

Puisque la performance des requêtes est critique et qu'une indexation appropriée est l'optimisation MongoDB la plus impactante, comprendre les indexes — comment ils fonctionnent, l'ordonnancement des indexes composés, les types spécifiques à MongoDB (multi-clés, TTL, uniques), le compromis lecture/écriture, et la vérification avec explain() — est une connaissance essentielle et de grande valeur pour des applications MongoDB performantes et l'un des sujets MongoDB les plus importants, parallèle à l'importance de l'indexation dans les bases de données SQL.