Wat is de aggregatie pipeline?

Question

Accepted Answer

De **aggregatie pipeline** is MongoDB's krachtige framework voor **dataverwerking en analyse** — het stuurt documenten door een reeks **stages**, waarbij elk stadium de gegevens transformeert (filteren, groeperen, berekenen). Het is MongoDB's equivalent van SQL's GROUP BY en complexe analytische queries, maar flexibeler.

## The pipeline concept: stages transform 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
```

Documenten stromen in volgorde door de stages — elk stadium transformeert ze en geeft resultaten door aan de volgende. Deze pipeline berekent totalen per klant, gesorteerd, top 10 — zoals een SQL GROUP BY query.

## Common 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 — joining collections

```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` maakt joins mogelijk (wat MongoDB anders vermijdt via embedding) — nuttig wanneer je collecties moet combineren.

## $unwind — expand 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
]);
```

## Waarom het belangrijk is

De aggregatie pipeline is een van MongoDB's meest krachtige en belangrijke functies — het is het primaire gereedschap voor **data analyse, rapportage en complexe transformaties**, dus het begrijpen ervan is essentieel voor serieus MongoDB-werk buiten basisquery's.

De pipeline's **stage-gebaseerde model** (documenten die door opeenvolgende transformatiestages stromen, elk filterend, groepering, herstructurerend of rekenen) is conceptueel elegant en maakt geavanceerde dataverwerking mogelijk die eenvoudige `find` queries niet kunnen — het is MongoDB's equivalent van SQL's GROUP BY en analytische queries, maar flexibeler en samenstelbaar.

Het begrijpen van de algemene stages — **`$match`** (filteren, idealiter vroeg om gegevens te reduceren), **`$group`** (groepering en aggregatie met `$sum`, `$avg`, enz. — de kern van analytics), **`$sort`/`$limit`** (ordening en paginering), **`$project`** (documenten herstructureren), **`$unwind`** (arrays uitbreiden naar documenten — belangrijk voor het analyseren van arraygegevens, gebruikelijk in MongoDB), en **`$lookup`** (collecties samenvoegen — de joins mogelijk makend die MongoDB anders vermijdt) — dekt de toolkit af voor echte dataverwerking.

De pipeline verwerkt rapportage, analyse, datatransformatie en complexe queries (aggregaties, joins, arrayverwerking) die gebruikelijk behoeften in applicaties zijn.

Omdat data analyse en complexe querying belangrijke toepassingen van elke database zijn, en omdat de aggregatie pipeline MongoDB's krachtige, flexibele mechanisme hiervoor is (ver boven basiswerk CRUD), het begrijpen van de aggregatie pipeline — het stage-model en sleutelstages ($match, $group, $sort, $project, $unwind, $lookup) — is essentieel, regelmatig toegepast MongoDB-kennis voor analytics, rapportage en complexe datatransformatie, een kenmerk van geavanceerde MongoDB-vaardigheden en een van de belangrijkste MongoDB-onderwerpen voor het verkrijgen van echte analytische waarde uit de database.