aggregation pipeline என்றால் என்ன?

Question

Accepted Answer

**aggregation pipeline** என்பது MongoDB-ன் சக்திশালி **data processing மற்றும் analysis** framework — இது documents-ஐ **stages** என்ற sequence வழியாக அனுப்புகிறது, ஒவ்வொரு stage-ம் data-ஐ transform செய்கிறது (filtering, grouping, computing). இது SQL-ன் GROUP BY மற்றும் complex analytical queries-க்கு equivalent ஆகும், ஆனால் இது மிகவும் flexible.

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

Documents stages வழியாக order-ல் flow செய்யும் — ஒவ்வொரு stage-ம் அவற்றை transform செய்து results-ஐ அடுத்த stage-க்கு அனுப்புகிறது. இந்த pipeline per-customer totals compute செய்கிறது, sorted, top 10 — 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 — collections-ஐ join செய்தல்

```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` joins-ஐ enable செய்கிறது (MongoDB இல் இல்லாவிட்டால் embedding வழியாக தவிர்க்கப்படும்) — collections-ஐ combine செய்ய வேண்டியிருக்கும் போது useful.

## $unwind — arrays expand செய்தல்

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

## ஏன் இது முக்கியமாக உள்ளது

Aggregation pipeline MongoDB-ன் மிகவும் சக்திशளि மற்றும் முக்கியமான features-ல் ஒன்றாகும் — இது **data analysis, reporting, மற்றும் complex transformations**-க்கான primary tool ஆகும், எனவே basic queries-க்கு மேலான serious MongoDB work-க்கு இதை புரிந்துகொள்வது essential.

Pipeline-ன் **stage-based model** (documents sequential transformation stages வழியாக flowing செய்து, ஒவ்வொன்றும் filtering, grouping, reshaping, அல்லது computing செய்யும்) conceptually elegant ஆகும் மற்றும் simple `find` queries-ஐ செய்ய முடியாத sophisticated data processing-ஐ enable செய்கிறது — இது SQL-ன் GROUP BY மற்றும் analytical queries-க்கு MongoDB equivalent ஆகும், ஆனால் மிகவும் flexible மற்றும் composable.

Common stages-ஐ புரிந்துகொள்வது — **`$match`** (filtering, ideally early data reduce செய்ய), **`$group`** (grouping மற்றும் aggregating with `$sum`, `$avg`, etc. — analytics-ன் core), **`$sort`/`$limit`** (ordering மற்றும் pagination), **`$project`** (documents reshape செய்தல்), **`$unwind`** (arrays-ஐ documents-ஆ expand செய்தல் — array data analyze செய்ய important, MongoDB-ல் common), மற்றும் **`$lookup`** (collections join செய்தல் — MongoDB இல் அन்யதா தவிர்க்கப்படும் joins enable செய்தல்) — real data processing-க்கான toolkit cover செய்யுங்கள்.

Pipeline reporting, analytics, data transformation, மற்றும் complex queries (aggregations, joins, array processing) handle செய்கிறது — இவை applications-ல் common needs.

Data analysis மற்றும் complex querying any database-ஐ महत्वपूर्ण uses ஆக இருப்பதாலும், aggregation pipeline MongoDB-ன் analytical value-ஐ பெற basic CRUD-க்கு மேலே போய் செய்யும் powerful, flexible mechanism ஆக இருப்பதாலும் (வெகு நன்றாக), aggregation pipeline-ஐ புரிந்துகொள்வது — stage model மற்றும் key stages ($match, $group, $sort, $project, $unwind, $lookup) — essential, frequently-applied MongoDB knowledge for analytics, reporting, மற்றும் complex data transformation, advanced MongoDB skill-ன் hallmark மற்றும் database-ல் real analytical value பெற most important MongoDB topics-ல் ஒன்றாகும்.