Cos'è la aggregation pipeline?

Question

Accepted Answer

L'**aggregation pipeline** è il potente framework di MongoDB per l'**elaborazione e l'analisi dei dati** — passa i documenti attraverso una sequenza di **stage**, ognuno dei quali trasforma i dati (filtraggio, raggruppamento, calcoli). È l'equivalente di MongoDB del GROUP BY di SQL e delle query analitiche complesse, ma più flessibile.

## La pipeline concept: gli stage trasformano i dati

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

I documenti scorrono attraverso gli stage in ordine — ogni stage li trasforma e passa i risultati al successivo. Questa pipeline calcola i totali per cliente, ordinati, i top 10 — come una query SQL GROUP BY.

## Stage comuni della pipeline

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

```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` abilita i join (che MongoDB altrimenti evita tramite embedding) — utile quando devi combinare collezioni.

## $unwind — espandere array

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

## Perché è importante

L'aggregation pipeline è una delle caratteristiche più potenti e importanti di MongoDB — è lo strumento principale per l'**analisi dei dati, il reporting e le trasformazioni complesse**, quindi comprenderla è essenziale per il lavoro serio con MongoDB al di là delle query di base.

Il **modello basato su stage** della pipeline (documenti che scorrono attraverso stage di trasformazione sequenziali, ognuno filtrando, raggruppando, ridisegnando o calcolando) è concettualmente elegante e abilita l'elaborazione sofisticata dei dati che le semplici query `find` non possono — è l'equivalente di MongoDB del GROUP BY di SQL e delle query analitiche, ma più flessibile e componibile.

Comprendere gli stage comuni — **`$match`** (filtraggio, idealmente all'inizio per ridurre i dati), **`$group`** (raggruppamento e aggregazione con `$sum`, `$avg`, ecc. — il cuore dell'analytics), **`$sort`/`$limit`** (ordinamento e paginazione), **`$project`** (ridisegno dei documenti), **`$unwind`** (espansione degli array in documenti — importante per analizzare i dati degli array, comune in MongoDB), e **`$lookup`** (joining delle collezioni — abilitando i join che MongoDB altrimenti evita) — copre il toolkit per l'elaborazione reale dei dati.

La pipeline gestisce il reporting, l'analytics, la trasformazione dei dati e le query complesse (aggregazioni, join, elaborazione degli array) che sono esigenze comuni nelle applicazioni.

Poiché l'analisi dei dati e le query complesse sono usi importanti di qualsiasi database, e poiché l'aggregation pipeline è il meccanismo potente e flessibile di MongoDB per loro (andando ben oltre il basic CRUD), comprendere l'aggregation pipeline — il modello di stage e gli stage chiave ($match, $group, $sort, $project, $unwind, $lookup) — è conoscenza MongoDB essenziale e frequentemente applicata per l'analytics, il reporting e le trasformazioni dati complesse, un tratto distintivo delle competenze MongoDB avanzate e uno degli argomenti MongoDB più importanti per ottenere valore analitico reale dal database.