Jak działają indeksy w MongoDB?

Question

Accepted Answer

**Indeksy** w MongoDB przyspieszają zapytania, pozwalając bazie danych znaleźć dokumenty bez skanowania całej kolekcji — tak jak w relacyjnych bazach danych. Bez indeksów zapytania wykonują **collection scan** (sprawdzają każdy dokument); z nimi lookup-i są szybkie. MongoDB obsługuje kilka typów indeksów.

## Tworzenie i używanie indeksów

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

Domyślne pole `_id` jest zawsze indeksowane. Dodajesz indeksy na polach, które często pytasz, sortujesz lub filtrujesz.

## Indeksy złożone (multiple fields)

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

**Indeksy złożone** pokrywają zapytania na wielu polach, ale **kolejność pól ma znaczenie** (indeks wspiera zapytania używające lewostronnego prefiksu jego pól — kluczowa reguła do zrozumienia).

## Typy indeksów

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

## Kompromis (podobnie jak 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).
```

## Dlaczego to ważne

Indeksy są jednym z najważniejszych tematów dla wydajności MongoDB — są głównym narzędziem do przyspieszania zapytań, a zasady są podobne do baz relacyjnych, więc ich zrozumienie jest niezbędną wiedzą dla wydajnych aplikacji MongoDB.

Bez indeksów zapytania wymagają **collection scans** (sprawdzenie każdego dokumentu — katastrofalnie wolne dla dużych kolekcji), podczas gdy indeksy umożliwiają szybkie lookup-i — często różnica między zapytaniem trwającym milisekundy a sekundami.

Zrozumienie, jak tworzyć indeksy na często pytanych/sortowanych/filtrowanych polach, jest fundamentalne. **Indeksy złożone** (pokrywające zapytania na wielu polach) są ważne, szczególnie reguła, że **kolejność pól ma znaczenie** (indeks wspiera zapytania używające lewostronnego prefiksu jego pól — kluczowa koncepcja do projektowania efektywnych indeksów złożonych).

Znajomość typów indeksów istotnych dla MongoDB jest wartościowa: **multi-key indexes** (automatyczne indeksowanie elementów tablicy — ważne ze względu na obfitość tablic w dokumentach MongoDB), **TTL indexes** (auto-wygaszające stare dokumenty — przydatne dla sesji, logów, danych tymczasowych), **unique indexes** (wymuszające unikalność), indeksy tekstowe i geoprzestrzenne dla specjalistycznych zapytań, oraz indeksy częściowe/rzadkie.

Zrozumienie **kompromisu** (indeksy przyspieszają odczyty, ale konsumują pamięć i spowalniają zapisy, więc indeksuj to, co pytasz bez przeindesowania) i używanie **`explain()`** do weryfikacji, że zapytania używają indeksów (COLLSCAN = zły scan, IXSCAN = dobry index use) jest kluczową praktyczną umiejętnością do optymalizacji.

Ponieważ wydajność zapytań jest krytyczna i prawidłowe indeksowanie jest najbardziej wpływową optymalizacją MongoDB, zrozumienie indeksów — jak działają, kolejność pól w indeksach złożonych, typy specyficzne dla MongoDB (multi-key, TTL, unique), kompromis między odczytami a zapisami, i weryfikacja za pomocą explain() — jest niezbędną, wysokowartościową wiedzą dla wydajnych aplikacji MongoDB i jednym z najważniejszych tematów MongoDB, paralela do znaczenia indeksowania w bazach SQL.