Hogyan működnek az indexek a MongoDB-ben?

Question

Accepted Answer

**Az indexek** a MongoDB-ben felgyorsítják a lekérdezéseket azáltal, hogy a database teljes gyűjtemény átvizsgálása nélkül megtalálja a dokumentumokat — éppen úgy, mint a relációs adatbázisok esetében. Indexek nélkül a lekérdezések **collection scant** végeznek (minden dokumentumot ellenőriznek); indexekkel viszont a keresések gyorsak. A MongoDB több index típust támogat.

## Indexek létrehozása és használata

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

Az alapértelmezett `_id` mező mindig indexelve van. Indexeket adhat hozzá azokhoz a mezőkhöz, amelyeket gyakran kérdez le, rendez vagy szűr.

## Összetett indexek (több mező)

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

Az **összetett indexek** több mező lekérdezéseit lefedik, de a **mezők sorrendje számít** (az index támogatja az indexmezőinek bal szélső előtagját használó lekérdezéseket — ez egy kulcsfontosságú szabály).

## Index típusok

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

## A kompromisszum (ugyanaz, mint az SQL-ben)

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

## Miért számít ez

Az indexek az egyik legfontosabb téma a MongoDB teljesítménye szempontjából — ez az elsődleges eszköz a lekérdezések felgyorsítására, és az alapelvek hasonlóak a relációs adatbázisokéhoz, így ezek megértése elengedhetetlen tudás a hatékony MongoDB alkalmazásokhoz.

Indexek nélkül a lekérdezésekhez **collection scan** szükséges (minden dokumentumot ellenőrizni — katasztrofálisan lassú, ahogy a gyűjtemények nőnek), az indexekkel viszont gyors keresések lehetségesek — gyakran a különbség aközött, hogy egy lekérdezés ezredmásodperc vagy másodperc alatt fut.

A gyakran lekérdezett/rendezett/szűrt mezőkön való indexek létrehozásának megértése alapvető. Az **összetett indexek** (több mezős lekérdezéseket lefedik) fontosak, különösen az a szabály, hogy a **mezők sorrendje számít** (egy index támogatja az indexmezőinek bal szélső előtagját használó lekérdezéseket — kulcsfontosságú koncepció az effektív összetett indexek tervezéséhez).

A MongoDB-re vonatkozó index típusok ismerete értékes: **multi-key indexek** (automatikusan indexelik az elemeket — fontos, mivel a MongoDB array-elemes dokumentumokat tartalmaz), **TTL indexek** (automatikusan lejáró régi dokumentumok — hasznos sessionökhöz, naplókhoz, ideiglenes adatokhoz), **egyedi indexek** (egyediséget kényszerítnek), szöveg- és geospatial indexek speciális lekérdezésekhez, valamint részleges/sparse indexek.

A **kompromisszum** megértése (az indexek felgyorsítják az olvasást, de helyet fogyasztanak és lassítják az írásokat, így csak azokat indexelje, amelyeket lekérdez, túlzott indexelés nélkül) és az **`explain()`** használata a lekérdezések indexhasználatának ellenőrzésére (COLLSCAN = rossz scan, IXSCAN = jó index használat) az optimalizálás kulcsfontosságú praktikus képessége.

Mivel a lekérdezés teljesítménye kritikus fontosságú, és a megfelelő indexelés a leghatásosabb MongoDB optimalizálás, az indexek megértése — hogyan működnek, az összetett indexek sorrendje, a MongoDB-specifikus típusok (multi-key, TTL, egyedi), az olvasás/írás kompromisszum, valamint az explain() segítségével történő ellenőrzés — elengedhetetlen, magas értékű tudás a hatékony MongoDB alkalmazásokhoz és az egyik legfontosabb MongoDB téma, párhuzamosan az indexelés fontosságával az SQL adatbázisokban.