Vad är aggregation pipeline?

Question

IT Interview Practice · Accepted Answer

**Aggregation pipeline** är Mongos kraftfulla ramverk för **databearbetning och analys** — det skickar dokument genom en sekvens av **steg**, där varje steg transformerar data (filtrering, gruppering, beräkningar). Det är Mongos motsvarighet till SQLs GROUP BY och komplexa analytiska frågor, men mer flexibelt.

## Pipeline-konceptet: steg transformerar data

```js
db.orders.aggregate([
  { $match: { status: "completed" } },          // 1. FILTER (like WHERE)
  { $group: {                                    // 2. GROUP and aggregate
      _id: "$customerId",                         //    group by customerId
      total: { $sum: "$amount" },                 //    sum amounts per customer
      count: { $sum: 1 }                          //    count orders
  }},
  { $sort: { total: -1 } },                       // 3. SORT by total
  { $limit: 10 }                                  // 4. top 10
]);
// documents flow through each stage; each stage's output feeds the next
```

Dokument flödar genom stegen i ordning — varje steg transformerar dem och skickar resultaten till nästa. Denna pipeline beräknar totaler per kund, sorterat, topp 10 — ungefär som en SQL GROUP BY-fråga.

## Vanliga pipeline-steg

```text
$match    → filter documents (like WHERE) — put EARLY to reduce data
$group    → group by a key and aggregate ($sum, $avg, $max, $min, $push, etc.)
$sort     → order documents
$project  → reshape documents (include/exclude/compute fields)
$limit / $skip → pagination
$unwind   → deconstruct an array field into multiple documents (one per element)
$lookup   → JOIN with another collection
$addFields → add computed fields
$count    → count documents
```

## $lookup — att koppla samman samlingar

```js
// $lookup performs a left-outer JOIN to another collection
db.orders.aggregate([
  { $lookup: {
      from: "customers",
      localField: "customerId",
      foreignField: "_id",
      as: "customer"           // joined customer data added as an array field
  }}
]);
```

`$lookup` möjliggör joins (som MongoDB annars undviker via inbäddning) — användbar när du behöver kombinera samlingar.

## $unwind — expandera matriser

```js
// turn one document with an array into multiple documents (one per array element)
db.posts.aggregate([
  { $unwind: "$tags" },                           // one doc per tag
  { $group: { _id: "$tags", count: { $sum: 1 } } } // count posts per tag
]);
```

## Varför det är viktigt

Aggregation pipeline är en av Mongos kraftfullaste och viktigaste funktioner — det är det primära verktyget för **dataanalys, rapportering och komplexa transformationer**, så att förstå det är väsentligt för seriöst MongoDB-arbete bortom grundläggande frågor.

Pipelinens **stegbaserade modell** (dokument som flödar genom sekventiella transformationssteg, var och ett filtrerar, grupperar, omformar eller beräknar) är konceptuellt elegant och möjliggör sofistikerad databearbetning som enkla `find`-frågor inte kan — det är Mongos motsvarighet till SQLs GROUP BY och analytiska frågor, men mer flexibelt och sammansättbart.

Att förstå de vanliga stegen — **`$match`** (filtrering, helst tidigt för att minska data), **`$group`** (gruppering och aggregering med `$sum`, `$avg`, etc. — kärnan i analys), **`$sort`/`$limit`** (sortering och sidindelning), **`$project`** (omformning av dokument), **`$unwind`** (expandering av matriser till dokument — viktigt för att analysera matrisdata, vanligt i MongoDB), och **`$lookup`** (koppling av samlingar — möjliggörande av joins som MongoDB annars undviker) — täcker verktygslådan för faktisk databearbetning.

Pipelinen hanterar rapportering, analys, datatransformation och komplexa frågor (aggregeringar, joins, matrisbearbetning) som är vanliga behov i applikationer.

Eftersom dataanalys och komplex frågning är viktiga användningar av all databaser, och eftersom aggregation pipeline är Mongos kraftfulla, flexibla mekanism för dem (långt bortom grundläggande CRUD), är det väsentligt att förstå aggregation pipeline — stegmodellen och nyckelstegen ($match, $group, $sort, $project, $unwind, $lookup) — är väsentlig, ofta använd MongoDB-kunskap för analys, rapportering och komplex datatransformation, ett kännetecken på avancerad MongoDB-skicklighet och ett av de viktigaste MongoDB-ämnena för att få verkligt analytiskt värde från databasen.

Pipeline-konceptet: steg transformerar data

Vanliga pipeline-steg

$lookup — att koppla samman samlingar

$unwind — expandera matriser

Varför det är viktigt

Relaterade frågor