MongoDB में indexes कैसे काम करते हैं?

Question

Accepted Answer

MongoDB में **indexes** database को पूरे collection को scan किए बिना documents खोजने देकर queries को तेज करते हैं — ठीक वैसे ही जैसे relational databases में। Indexes के बिना, queries एक **collection scan** करती हैं (प्रत्येक document की जाँच); उनके साथ, lookups तेज होते हैं। MongoDB कई index types का समर्थन करता है।

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

डिफ़ॉल्ट `_id` field हमेशा indexed होता है। आप उन fields पर indexes जोड़ते हैं जिन्हें आप बार-बार query, sort, या filter करते हैं।

## Compound indexes (कई 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** कई fields पर queries को कवर करते हैं, लेकिन **field order मायने रखता है** (index उन queries का समर्थन करता है जो इसके fields के leftmost prefix का उपयोग करती हैं — समझने योग्य एक प्रमुख नियम)।

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

## यह क्यों महत्वपूर्ण है

Indexes MongoDB performance के लिए सबसे महत्वपूर्ण विषयों में से एक हैं — वे queries को तेज बनाने के लिए प्राथमिक उपकरण हैं, और सिद्धांत relational databases के समान हैं, इसलिए उन्हें समझना performant MongoDB applications के लिए आवश्यक ज्ञान है।

Indexes के बिना, queries को **collection scans** की आवश्यकता होती है (प्रत्येक document की जाँच — जैसे-जैसे collections बढ़ते हैं विनाशकारी रूप से धीमा), जबकि indexes तेज lookups को सक्षम करते हैं — अक्सर एक query के milliseconds बनाम seconds लेने के बीच का अंतर।

बार-बार query किए जाने वाले/sort किए जाने वाले/filter किए जाने वाले fields पर indexes बनाना समझना मौलिक है। **Compound indexes** (कई-field queries को कवर करना) महत्वपूर्ण हैं, विशेष रूप से यह नियम कि **field order मायने रखता है** (एक index उन queries का समर्थन करता है जो इसके fields के leftmost prefix का उपयोग करती हैं — प्रभावी compound indexes design करने के लिए एक प्रमुख अवधारणा)।

MongoDB-प्रासंगिक index types को जानना मूल्यवान है: **multi-key indexes** (स्वचालित रूप से array elements को indexing करना — MongoDB के array-heavy documents को देखते हुए महत्वपूर्ण), **TTL indexes** (पुराने documents को auto-expiring करना — sessions, logs, अस्थायी डेटा के लिए उपयोगी), **unique indexes** (uniqueness लागू करना), विशिष्ट queries के लिए text और geospatial indexes, और partial/sparse indexes।

**Trade-off** को समझना (indexes reads को तेज करते हैं लेकिन storage खपत करते हैं और writes को धीमा करते हैं, इसलिए जो आप query करते हैं उसे index करें बिना over-indexing के) और queries indexes का उपयोग करती हैं इसे सत्यापित करने के लिए **`explain()`** का उपयोग करना (COLLSCAN = खराब scan, IXSCAN = अच्छा index उपयोग) optimization के लिए प्रमुख व्यावहारिक कौशल है।

चूँकि query performance महत्वपूर्ण है और उचित indexing सबसे प्रभावशाली MongoDB optimization है, indexes को समझना — वे कैसे काम करते हैं, compound index ordering, MongoDB-विशिष्ट types (multi-key, TTL, unique), read/write trade-off, और explain() के साथ सत्यापित करना — performant MongoDB applications के लिए आवश्यक, उच्च-मूल्य ज्ञान है और सबसे महत्वपूर्ण MongoDB विषयों में से एक है, जो SQL databases में indexing के महत्व के समानांतर है।