Cum funcționează indexurile în MongoDB?

Question

Accepted Answer

**Indexurile** în MongoDB accelerează cererile permițând bazei de date să găsească documente fără a scaneza întreaga colecție — la fel ca în bazele de date relaționale. Fără indexuri, cererile fac un **collection scan** (verificând fiecare document); cu ele, căutările sunt rapide. MongoDB suportă mai multe tipuri de indexuri.

## Crearea și utilizarea indexurilor

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

Câmpul implicit `_id` este întotdeauna indexat. Adaugi indexuri pe câmpurile pe care le ceri frecvent, le sortezi sau le filtrezi.

## Indexuri compuse (mai multe câmpuri)

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

**Indexurile compuse** acoperă cererile pe mai multe câmpuri, dar **ordinea câmpurilor este importantă** (indexul suportă cererile folosind un prefix din stânga a câmpurilor sale — o regulă cheie de înțeles).

## Tipuri de indexuri

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

## Compromisul (la fel ca 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).
```

## De ce contează

Indexurile sunt unul dintre cele mai importante subiecte pentru performanța MongoDB — sunt instrumentul principal pentru a face cererile rapide, iar principiile sunt similare cu bazele de date relaționale, deci înțelegerea lor este o cunoștință esențială pentru aplicațiile MongoDB performante.

Fără indexuri, cererile necesită **collection scans** (verificând fiecare document — catastrofal de lent pe măsură ce colecțiile cresc), în timp ce indexurile permit căutări rapide — adesea diferența dintre o cerere care durează milisecunde versus secunde.

Înțelegerea modului de creare a indexurilor pe câmpurile cărora li se fac frecvent cereri/sortări/filtrări este fundamentală. **Indexurile compuse** (acoperind cererile pe mai multe câmpuri) sunt importante, în special regula că **ordinea câmpurilor contează** (un index suportă cererile folosind un prefix din stânga a câmpurilor sale — un concept cheie pentru proiectarea indexurilor compuse eficiente).

Cunoașterea tipurilor de indexuri relevante pentru MongoDB este valoroasă: **indexuri multi-key** (indexând automat elemente de matrice — important având în vedere documentele MongoDB bogate în matrice), **indexuri TTL** (expirând automat documentele vechi — utile pentru sesiuni, jurnale, date temporare), **indexuri unice** (impunând unicitate), indexuri text și geospațiale pentru cererile specializate, și indexuri parțiale/sparse.

Înțelegerea **compromisului** (indexurile accelerează citirile dar consumă stocare și încetinesc scrierile, deci indexează ceea ce ceri fără a supra-indexa) și utilizarea **`explain()`** pentru a verifica că cererile folosesc indexuri (COLLSCAN = scan prost, IXSCAN = utilizare bună a indexului) este abilitatea practică cheie pentru optimizare.

Fiind că performanța cererilor este critică și indexarea corespunzătoare este optimizarea MongoDB cea mai impactantă, înțelegerea indexurilor — cum funcționează, ordinea indexării compuse, tipurile specifice MongoDB (multi-key, TTL, unic), compromisul citire/scriere, și verificarea cu explain() — este o cunoștință esențială de valoare înaltă pentru aplicațiile MongoDB performante și unul dintre cele mai importante subiecte MongoDB, paralel cu importanța indexării în bazele de date SQL.