Hur fungerar index i MongoDB?

Question

Accepted Answer

**Index** i MongoDB snabbar upp frågor genom att låta databasen hitta dokument utan att skanna hela samlingen — precis som i relationsdatabaser. Utan index gör frågor en **collection scan** (kontrollerar varje dokument); med index är sökningar snabba. MongoDB stöder flera indextyper.

## Skapa och använd index

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

Standardfältet `_id` är alltid indexerat. Du lägger till index på fält som du ofta frågar, sorterar eller filtrerar efter.

## Sammansatta index (flera fält)

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

**Sammansatta index** täcker frågor på flera fält, men **fältordningen är viktig** (indexet stöder frågor som använder ett längsta prefix av dess fält — en nyckelregel att förstå).

## Indextyper

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

## Avvägningen (samma som 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).
```

## Varför det spelar roll

Index är ett av de viktigaste ämnena för MongoDB-prestanda — de är det primära verktyget för att göra frågor snabba, och principerna liknar relationsdatabaser, så att förstå dem är väsentlig kunskap för performanta MongoDB-applikationer.

Utan index kräver frågor **collection scans** (kontrollerar varje dokument — katastrofalt långsamt när samlingar växer), medan index möjliggör snabba sökningar — ofta skillnaden mellan en fråga som tar millisekunder kontra sekunder.

Att förstå hur man skapar index på ofta frågade/sorterade/filtrerade fält är grundläggande. **Sammansatta index** (täcka frågor med flera fält) är viktiga, särskilt regeln att **fältordningen spelar roll** (ett index stöder frågor som använder ett längsta prefix av dess fält — ett nyckelbegrep för att utforma effektiva sammansatta index).

Att känna till MongoDB-relevanta indextyper är värdefullt: **multi-key index** (automatiskt indexering av matriselement — viktigt givet Mongodbs matristunga dokument), **TTL index** (auto-utgånget gamla dokument — användbart för sessioner, loggar, temporär data), **unika index** (tvingande unikhet), text- och geospatiala index för specialiserade frågor, och partiella/glesa index.

Att förstå **avvägningen** (index snabbar upp läsningar men förbrukar lagring och saktar ner skrivningar, så indexera vad du frågar utan överindexering) och använda **`explain()`** för att verifiera att frågor använder index (COLLSCAN = dålig skanning, IXSCAN = bra indexanvändning) är den nyckelsakliga praktiska färdigheten för optimering.

Eftersom frågeprestanda är kritisk och korrekt indexering är den mest effektfull MongoDB-optimering, är förståelse av index — hur de fungerar, sammansatt indexordning, MongoDB-specifika typer (multi-key, TTL, unika), läs-/skrivavvägningen, och verifiering med explain() — väsentlig, högvärderad kunskap för performanta MongoDB-applikationer och ett av de viktigaste MongoDB-ämnena, parallellt med indexeringens betydelse i SQL-databaser.