Kepiye carane indexes tansah nganggo ing MongoDB?

Question

Accepted Answer

**Indexes** ing MongoDB nyepetake queries kanthi lumuh database nemoni dokumen tanpa scan kabeh collection — kaya-kaya ing relational databases. Tanpa indexes, queries nggawe **collection scan** (ndeleng saben dokumen); karo indexes, lookups cepet. MongoDB ndhukung pirang-pirang index types.

## Nggawe lan nganggo 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 `_id` standar tansah indexed. Sampeyan nambah indexes ing fields sing sampeyan query, sort, utawa filter frequently.

## Compound indexes (pirang-pirang 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** nutupi queries ing pirang-pirang fields, nanging **field order penting** (index ndhukung queries nganggo leftmost prefix saka fields-ne — aturan kunci kanggo paham).

## Index types

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

## The trade-off (kaya 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).
```

## Napa iki penting

Indexes minangka salah siji topik paling penting kanggo MongoDB performance — iku piranti utama kanggo nggawe queries cepet, lan prinsip-prinsip padha karo relational databases, dadi paham-paham iku knowledge essential kanggo MongoDB applications sing performan.

Tanpa indexes, queries butuh **collection scans** (ndeleng saben dokumen — catastrophically slow nalika collections tuwuh), dene indexes lumuh fast lookups — asring bedane antara query njupuk milliseconds versus seconds.

Paham nggawe indexes ing fields sing frequently-queried/sorted/filtered iku fundamental. **Compound indexes** (nutupi queries multi-field) penting, utamane aturan **field order penting** (index ndhukung queries nganggo leftmost prefix saka fields-ne — konsep kunci kanggo nggambar effective compound indexes).

Narik tekan MongoDB-relevant index types berharga: **multi-key indexes** (automatically indexing array elements — penting amarga MongoDB's array-heavy documents), **TTL indexes** (auto-expiring old documents — useful kanggo sessions, logs, temporary data), **unique indexes** (enforce uniqueness), text lan geospatial indexes kanggo specialized queries, lan partial/sparse indexes.

Paham **trade-off** (indexes nyepetake reads nanging consume storage lan slow writes, dadi index apa sing sampeyan query tanpa over-indexing) lan nganggo **`explain()`** kanggo verify queries nganggo indexes (COLLSCAN = bad scan, IXSCAN = good index use) iku skill practical kunci kanggo optimization.

Sajrone query performance critical lan proper indexing paling impactful MongoDB optimization, paham indexes — kepiye carane tansah, compound index ordering, MongoDB-specific types (multi-key, TTL, unique), read/write trade-off, lan verify karo explain() — iku essential, high-value knowledge kanggo MongoDB applications sing performan lan salah siji topik MongoDB paling penting, parallel-ing importance saka indexing ing SQL databases.