Hvad er aggregation pipeline?

Question

Accepted Answer

**Aggregation pipeline** er Mongodbs kraftfulde framework til **databehandling og analyse** — det sender dokumenter gennem en sekvens af **stages**, som hver transformerer dataene (filtrering, gruppering, beregning). Det er Mongodbs ækvivalent til SQLs GROUP BY og komplekse analytiske forespørgsler, men mere fleksibelt.

## Pipeline-konceptet: stages transformerer 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
```

Dokumenter flyder gennem stages i rækkefølge — hver stage transformerer dem og sender resultaterne til næste. Denne pipeline beregner totaler pr. kunde, sorteret, top 10 — som en SQL GROUP BY-forespørgsel.

## Almindelige pipeline stages

```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 — sammenkædning af samlinger

```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` muliggør joins (som MongoDB ellers undgår via embedding) — nyttigt når du skal kombinere samlinger.

## $unwind — udvidelse af arrays

```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
]);
```

## Hvorfor det betyder noget

Aggregation pipeline er en af Mongodbs mest kraftfulde og vigtige funktioner — det er det primære værktøj til **dataanalyse, rapportering og komplekse transformationer**, så forståelsen heraf er essentiel for seriøst MongoDB-arbejde ud over grundlæggende forespørgsler.

Pipelinens **stage-baserede model** (dokumenter, der flyder gennem sekventielle transformationsstages, som hver filtrerer, grupperer, omformer eller beregner) er konseptuelt elegant og muliggør sofistikeret databehandling, som simple `find`-forespørgsler ikke kan — det er Mongodbs ækvivalent til SQLs GROUP BY og analytiske forespørgsler, men mere fleksibelt og komponeringsbareligt.

Forståelsen af de almindelige stages — **`$match`** (filtrering, ideelt set tidligt for at reducere data), **`$group`** (gruppering og aggregering med `$sum`, `$avg` osv. — kernen i analysearbejde), **`$sort`/`$limit`** (sortering og pagination), **`$project`** (omformning af dokumenter), **`$unwind`** (udvidelse af arrays til dokumenter — vigtig for analyse af array-data, almindelig i MongoDB), og **`$lookup`** (sammenkædning af samlinger — muliggør de joins, som MongoDB ellers undgår) — dækker værktøjskassen til rigtig databehandling.

Pipeline håndterer rapportering, analyse, datatransformation og komplekse forespørgsler (aggregeringer, joins, array-behandling), som er almindelige behov i applikationer.

Da dataanalyse og kompleks forespørgsling er vigtige anvendelser af enhver database, og da aggregation pipeline er Mongodbs kraftfulde, fleksible mekanisme til dem (der går langt ud over grundlæggende CRUD), er forståelsen af aggregation pipeline — stage-modellen og nøglestages ($match, $group, $sort, $project, $unwind, $lookup) — vigtig, hyppigt anvendt MongoDB-viden til analyse, rapportering og kompleks datatransformation, et kendetegn på avanceret MongoDB-kompetence og et af de vigtigste MongoDB-emner for at få rigtig analytisk værdi fra databasen.