O que é o pipeline de agregação?

Question

Accepted Answer

O **pipeline de agregação** é o poderoso framework do MongoDB para **processamento e análise de dados** — passa documentos através de uma sequência de **estágios**, cada um transformando os dados (filtragem, agrupamento, cálculos). É o equivalente do MongoDB para o GROUP BY do SQL e consultas analíticas complexas, mas mais flexível.

## O conceito do pipeline: estágios transformam dados

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

Os documentos fluem através dos estágios em ordem — cada estágio os transforma e passa resultados para o próximo. Este pipeline calcula totais por cliente, ordena, top 10 — como uma consulta SQL GROUP BY.

## Estágios comuns do 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 — juntando coleções

```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` permite joins (que o MongoDB evita através de embedding) — útil quando você precisa combinar coleções.

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

## Por que isso importa

O pipeline de agregação é um dos recursos mais poderosos e importantes do MongoDB — é a ferramenta principal para **análise de dados, relatórios e transformações complexas**, então entendê-lo é essencial para trabalhos sérios com MongoDB além de consultas básicas.

O **modelo baseado em estágios** do pipeline (documentos fluindo através de estágios de transformação sequenciais, cada um filtrando, agrupando, reformatando ou calculando) é conceitualmente elegante e permite processamento de dados sofisticado que consultas `find` simples não conseguem — é o equivalente do MongoDB para o GROUP BY do SQL e consultas analíticas, mas mais flexível e composável.

Entender os estágios comuns — **`$match`** (filtragem, idealmente cedo para reduzir dados), **`$group`** (agrupamento e agregação com `$sum`, `$avg`, etc. — o núcleo da análise), **`$sort`/`$limit`** (ordenação e paginação), **`$project`** (reformatação de documentos), **`$unwind`** (expandindo arrays em documentos — importante para analisar dados de arrays, comum no MongoDB), e **`$lookup`** (juntando coleções — habilitando os joins que o MongoDB evita) — cobre o conjunto de ferramentas para processamento de dados real.

O pipeline lida com relatórios, análise, transformação de dados e consultas complexas (agregações, joins, processamento de arrays) que são necessidades comuns em aplicações.

Como análise de dados e consultas complexas são usos importantes de qualquer banco de dados, e como o pipeline de agregação é o mecanismo poderoso e flexível do MongoDB para elas (indo bem além do CRUD básico), entender o pipeline de agregação — o modelo de estágios e estágios-chave ($match, $group, $sort, $project, $unwind, $lookup) — é conhecimento essencial do MongoDB, frequentemente aplicado, para análise, relatórios e transformação complexa de dados, uma marca de habilidade avançada em MongoDB e um dos tópicos mais importantes do MongoDB para obter valor analítico real do banco de dados.