Aggregation pipeline nedir?

Question

Accepted Answer

**Aggregation pipeline**, MongoDB'nin **veri işleme ve analiz** için güçlü bir çerçevesidir — belgeler bir dizi **stage** (aşama) aracılığıyla geçer ve her biri verileri dönüştürür (filtreleme, gruplama, hesaplama). MongoDB'nin SQL'in GROUP BY ve karmaşık analitik sorgularının dengi olmasıdır, ancak daha esnektir.

## Pipeline konsepti: stageler verileri dönüştürür

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

Belgeler stage'ler aracılığıyla sırasıyla akış — her stage onları dönüştürür ve sonuçları bir sonrakine iletir. Bu pipeline, müşteri başına toplamları, sıralanmış, ilk 10 — SQL GROUP BY sorgusu gibi hesaplar.

## Yaygın pipeline stage'leri

```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 — koleksiyonları birleştirme

```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` birleştirmeleri sağlar (MongoDB aksi takdirde embedding yoluyla kaçınır) — koleksiyonları birleştirmeniz gerektiğinde yararlıdır.

## $unwind — dizileri genişletme

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

## Neden önemli

Aggregation pipeline, MongoDB'nin en güçlü ve en önemli özelliklerinden biridir — **veri analizi, raporlama ve karmaşık dönüşümler** için birincil araçtır; bu nedenle temel sorgularının ötesinde ciddi MongoDB çalışmaları için anlamak gereklidir.

Pipeline'ın **stage tabanlı modeli** (belgeler sıralı dönüştürme stage'leri aracılığıyla akış, her biri filtreleme, gruplama, yeniden şekillendirme veya hesaplama) kavramsal olarak zariftir ve basit `find` sorguların yapamayacağı gelişmiş veri işlemesini sağlar — MongoDB'nin SQL'in GROUP BY ve analitik sorgularının dengi olmasıdır, ancak daha esnek ve bileştirilebilirdir.

Yaygın stage'leri anlamak — **`$match`** (filtreleme, ideal olarak verileri azaltmak için erken), **`$group`** (gruplama ve `$sum`, `$avg` vb. ile toplama — analitiklerin çekirdeği), **`$sort`/`$limit`** (sıralama ve sayfalandırma), **`$project`** (belgeleri yeniden şekillendirme), **`$unwind`** (dizileri belgelere genişletme — MongoDB'de dizi verilerini analiz etmek için önemli, yaygındır) ve **`$lookup`** (koleksiyonları birleştirme — MongoDB'nin aksi takdirde kaçındığı birleştirmeleri etkinleştirme) — gerçek veri işleme için araç setini kapsar.

Pipeline, raporlama, analitik, veri dönüştürme ve uygulamalarda yaygın olan karmaşık sorguları (agregasyonlar, birleştirmeler, dizi işlemesi) işler.

Veri analizi ve karmaşık sorgulama herhangi bir veritabanının önemli kullanımları olduğu ve aggregation pipeline'ın MongoDB'nin bu işler için güçlü, esnek mekanizması olduğu (temel CRUD'ın ötesine giderek) için, aggregation pipeline'ı anlamak — stage modelini ve temel stage'leri ($match, $group, $sort, $project, $unwind, $lookup) — analitik, raporlama ve karmaşık veri dönüştürme için gereklidir; gelişmiş MongoDB becerisinin bir işareti ve veritabanından gerçek analitik değer elde etmek için en önemli MongoDB konularından biridir.