MongoDB ਵਿੱਚ indexes ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**Indexes** MongoDB ਵਿੱਚ queries ਨੂੰ ਤੇਜ਼ ਕਰਦੇ ਹਨ ਕਿਉਂਕਿ ਡਾਟਾਬੇਸ ਨੂੰ ਪੂਰੀ collection ਨੂੰ scan ਕੀਤੇ ਬਿਨਾਂ documents ਨੂੰ ਲੱਭਣ ਦਿੰਦੇ ਹਨ — relational ਡਾਟਾਬੇਸਿਜ਼ ਦੀ ਤਰ੍ਹਾਂ। Indexes ਤੋਂ ਬਿਨਾਂ, queries **collection scan** ਕਰਦੇ ਹਨ (ਹਰ document ਨੂੰ check ਕਰਨਾ); ਉਨ੍ਹਾਂ ਦੇ ਨਾਲ, lookups ਤੇਜ਼ ਹਨ। MongoDB ਕਈ index ਕਿਸਮਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।

## 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 ਸ਼ਾਮਲ ਕਰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ frequently 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 ਨੂੰ cover ਕਰਦੇ ਹਨ, ਪਰ **field ਦੀ ਤਰਤੀਬ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ** (index ਆਪਣੀਆਂ fields ਦੇ leftmost prefix ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ queries ਨੂੰ support ਕਰਦਾ ਹੈ — ਸਮਝਣ ਲਈ ਮੁੱਖ rule)।

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

## ਟ੍ਰੇਡ-ਆਫ (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 ਡਾਟਾਬੇਸਿਜ਼ ਦੇ ਸਮਾਨ ਹਨ, ਇਸ ਲਈ ਉਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ performant MongoDB applications ਲਈ ਜ਼ਰੂਰੀ ਗਿਆਨ ਹੈ।

Indexes ਤੋਂ ਬਿਨਾਂ, queries ਨੂੰ **collection scans** ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ (ਹਰ document ਨੂੰ check ਕਰਨਾ — catastrophically slow ਕਿਉਂਕਿ collections ਵੱਡੇ ਹੋ ਜਾਂਦੇ ਹਨ), ਜਦੋਂ ਕਿ indexes ਤੇਜ਼ lookups enable ਕਰਦੇ ਹਨ — ਅਕਸਰ ਇੱਕ query ਮਿਲੀਸਕਿੰਡ ਬਨਾਮ ਸਕਿੰਡਾਂ ਵਿੱਚ ਲੈਣ ਵਾਲਾ ਫਰਕ।

Frequently-queried/sorted/filtered fields ਉੱਤੇ indexes ਕਿਵੇਂ ਬਣਾਉਣੇ ਹਨ ਇਹ ਸਮਝਣਾ ਬੁਨਿਆਦੀ ਹੈ। **Compound indexes** (ਮਲਟੀਪਲ-field queries ਨੂੰ cover ਕਰਨਾ) ਮਹੱਤਵਪੂਰਨ ਹਨ, ਖਾਸ ਤੌਰ ਉੱਤੇ rule ਕਿ **field ਦੀ ਤਰਤੀਬ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ** (ਇੱਕ index ਆਪਣੀਆਂ fields ਦੇ leftmost prefix ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ queries ਨੂੰ support ਕਰਦਾ ਹੈ — effective compound indexes ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਮੁੱਖ ਸੰਕਲਪ)।

MongoDB-relevant index ਦੀਆਂ ਕਿਸਮਾਂ ਬਾਰੇ ਜਾਣਨਾ ਮੁੱਲਵਾਨ ਹੈ: **multi-key indexes** (automatically array elements ਨੂੰ index ਕਰਨਾ — MongoDB ਦੀਆਂ array-heavy documents ਦੀ ਵਜ਼ਾਹ ਤੋਂ ਮਹੱਤਵਪੂਰਨ), **TTL indexes** (ਪੁਰਾਣੇ documents ਨੂੰ auto-expiring ਕਰਨਾ — sessions, logs, temporary data ਲਈ ਉਪਯੋਗੀ), **unique indexes** (uniqueness enforce ਕਰਨਾ), text ਅਤੇ geospatial indexes specialized queries ਲਈ, ਅਤੇ partial/sparse indexes।

**Trade-off** (indexes reads ਨੂੰ ਤੇਜ਼ ਕਰਦੇ ਹਨ ਪਰ storage ਖਾ ਜਾਂਦੇ ਹਨ ਅਤੇ writes ਨੂੰ ਸਲੋ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ ਉਹ index ਕਰੋ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ query ਕਰਦੇ ਹੋ ਬਿਨਾ over-indexing ਦੇ) ਅਤੇ **`explain()`** ਵਰਤ ਕੇ verify ਕਰਨਾ ਕਿ queries indexes use ਕਰਦੇ ਹਨ (COLLSCAN = bad scan, IXSCAN = good index use) ਆਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਲਈ ਮੁੱਖ practical skill ਹੈ।

ਕਿਉਂਕਿ query performance ਮਹੱਤਵਪੂਰਨ ਹੈ ਅਤੇ ਸਹੀ indexing ਸਭ ਤੋਂ impactful MongoDB optimization ਹੈ, indexes ਨੂੰ ਸਮਝਣਾ — ਉਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ, compound index ordering, MongoDB-specific ਕਿਸਮਾਂ (multi-key, TTL, unique), read/write trade-off, ਅਤੇ explain() ਨਾਲ verify ਕਰਨਾ — performant MongoDB applications ਲਈ ਜ਼ਰੂਰੀ, ਉੱਚ-ਮੁੱਲ ਦਾ ਗਿਆਨ ਹੈ ਅਤੇ ਇਹ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ MongoDB ਵਿਸ਼ਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, SQL ਡਾਟਾਬੇਸਿਜ਼ ਵਿੱਚ indexing ਦੀ ਮਹੱਤਤਾ ਦੇ ਬਰਾਬਰ।