Was ist die Aggregation Pipeline?

Question

Accepted Answer

Die **Aggregation Pipeline** ist MongoDBs mächtiges Framework für **Datenverarbeitung und Analyse** – sie leitet Dokumente durch eine Sequenz von **Stages** (Stufen), von denen jede die Daten transformiert (Filterung, Gruppierung, Berechnung). Sie ist MongoDBs Entsprechung zu SQLs GROUP BY und komplexen analytischen Abfragen, aber flexibler.

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

Dokumente fließen in Reihenfolge durch die Stages – jede Stage transformiert sie und leitet die Ergebnisse an die nächste weiter. Diese Pipeline berechnet Pro-Kunde-Summen, sortiert, die Top 10 – wie eine SQL GROUP BY Abfrage.

## 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` ermöglicht Joins (die MongoDB ansonsten durch Embedding vermeidet) – nützlich, wenn Sie Kollektionen kombinieren müssen.

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

## Warum es wichtig ist

Die Aggregation Pipeline ist eines der mächtigsten und wichtigsten Features von MongoDB – es ist das primäre Tool für **Datenanalyse, Reporting und komplexe Transformationen**, daher ist das Verständnis dafür essentiell für ernsthafte MongoDB-Arbeit jenseits grundlegender Abfragen.

Das **Stage-basierte Modell** der Pipeline (Dokumente fließen durch sequenzielle Transformationsstages, jede filtert, gruppiert, formt um oder berechnet) ist konzeptionell elegant und ermöglicht ausgefeilte Datenverarbeitung, die einfache `find` Abfragen nicht können – es ist MongoDBs Entsprechung zu SQLs GROUP BY und analytischen Abfragen, aber flexibler und zusammensetzbar.

Das Verständnis der gängigen Stages – **`$match`** (Filterung, idealerweise früh, um Daten zu reduzieren), **`$group`** (Gruppierung und Aggregation mit `$sum`, `$avg`, etc. – der Kern der Analytik), **`$sort`/`$limit`** (Sortierung und Paginierung), **`$project`** (Dokumente umformen), **`$unwind`** (Arrays in Dokumente erweitern – wichtig für die Analyse von Array-Daten, häufig in MongoDB), und **`$lookup`** (Kollektionen verbinden – Joins ermöglichen, die MongoDB ansonsten vermeidet) – deckt das Toolkit für echte Datenverarbeitung ab.

Die Pipeline handhabt Reporting, Analytik, Datentransformation und komplexe Abfragen (Aggregationen, Joins, Array-Verarbeitung), die häufige Anforderungen in Anwendungen sind.

Da Datenanalyse und komplexe Abfragen wichtige Anwendungsfälle jeder Datenbank sind, und da die Aggregation Pipeline MongoDBs mächtiger, flexibler Mechanismus dafür ist (weit jenseits grundlegender CRUD), ist das Verständnis der Aggregation Pipeline – das Stage-Modell und Schlüssel-Stages ($match, $group, $sort, $project, $unwind, $lookup) – essentielles, häufig angewendetes MongoDB-Wissen für Analytik, Reporting und komplexe Datentransformation, ein Zeichen von fortgeschrittenem MongoDB-Geschick und eines der wichtigsten MongoDB-Themen zum Extrahieren von echtem analytischem Wert aus der Datenbank.