Bagaimana cara kerja indexes di MongoDB?

Question

Accepted Answer

**Indexes** di MongoDB mempercepat queries dengan memungkinkan database menemukan dokumen tanpa memindai seluruh collection — sama seperti di database relasional. Tanpa indexes, queries melakukan **collection scan** (memeriksa setiap dokumen); dengan indexes, lookups menjadi cepat. MongoDB mendukung beberapa tipe index.

## Membuat dan menggunakan 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
```

Field default `_id` selalu diindeks. Anda menambahkan indexes pada field yang sering Anda query, sort, atau filter.

## Compound indexes (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
```

**Compound indexes** mencakup queries pada multiple fields, tetapi **urutan field penting** (index mendukung queries menggunakan leftmost prefix dari field-fieldnya — sebuah rule kunci untuk dipahami).

## Tipe-tipe index

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

## Trade-off (sama seperti 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).
```

## Mengapa ini penting

Indexes adalah salah satu topik paling penting untuk performa MongoDB — mereka adalah alat utama untuk membuat queries cepat, dan prinsip-prinsipnya mirip dengan database relasional, jadi memahami mereka adalah pengetahuan esensial untuk aplikasi MongoDB yang performan.

Tanpa indexes, queries memerlukan **collection scans** (memeriksa setiap dokumen — sangat lambat saat collections berkembang), sedangkan indexes memungkinkan lookups yang cepat — sering kali perbedaan antara query yang memakan waktu milidetik versus detik.

Memahami cara membuat indexes pada field yang sering di-query/sort/filter adalah fundamental. **Compound indexes** (mencakup queries dengan multiple fields) penting, terutama rule bahwa **urutan field penting** (sebuah index mendukung queries menggunakan leftmost prefix dari field-fieldnya — konsep kunci untuk merancang compound indexes yang efektif).

Mengetahui tipe-tipe index yang relevan dengan MongoDB berharga: **multi-key indexes** (secara otomatis mengindeks elemen array — penting mengingat dokumen MongoDB yang heavy pada array), **TTL indexes** (auto-expiring dokumen lama — berguna untuk sessions, logs, data temporary), **unique indexes** (memberlakukan uniqueness), text dan geospatial indexes untuk queries khusus, dan partial/sparse indexes.

Memahami **trade-off** (indexes mempercepat reads tetapi mengkonsumsi storage dan memperlambat writes, jadi index apa yang Anda query tanpa over-indexing) dan menggunakan **`explain()`** untuk memverifikasi queries menggunakan indexes (COLLSCAN = bad scan, IXSCAN = good index use) adalah skill praktis kunci untuk optimization.

Karena performa query adalah kritis dan proper indexing adalah optimization MongoDB paling berdampak, memahami indexes — bagaimana cara kerjanya, compound index ordering, tipe-tipe MongoDB-spesifik (multi-key, TTL, unique), read/write trade-off, dan memverifikasi dengan explain() — adalah pengetahuan esensial dan high-value untuk aplikasi MongoDB yang performan dan salah satu topik MongoDB paling penting, sejajar dengan pentingnya indexing di database SQL.