Aggregation pipeline är Mongos kraftfulla ramverk för databearbetning och analys — det skickar dokument genom en sekvens av steg, där varje steg transformerar data (filtrering, gruppering, beräkningar). Det är Mongos motsvarighet till SQLs GROUP BY och komplexa analytiska frågor, men mer flexibelt.
Pipeline-konceptet: steg transformerar data
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
Dokument flödar genom stegen i ordning — varje steg transformerar dem och skickar resultaten till nästa. Denna pipeline beräknar totaler per kund, sorterat, topp 10 — ungefär som en SQL GROUP BY-fråga.
Vanliga pipeline-steg
$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 — att koppla samman samlingar
// $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 möjliggör joins (som MongoDB annars undviker via inbäddning) — användbar när du behöver kombinera samlingar.
$unwind — expandera matriser
// 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
]);
Varför det är viktigt
Aggregation pipeline är en av Mongos kraftfullaste och viktigaste funktioner — det är det primära verktyget för dataanalys, rapportering och komplexa transformationer, så att förstå det är väsentligt för seriöst MongoDB-arbete bortom grundläggande frågor.
Pipelinens stegbaserade modell (dokument som flödar genom sekventiella transformationssteg, var och ett filtrerar, grupperar, omformar eller beräknar) är konceptuellt elegant och möjliggör sofistikerad databearbetning som enkla find-frågor inte kan — det är Mongos motsvarighet till SQLs GROUP BY och analytiska frågor, men mer flexibelt och sammansättbart.
Att förstå de vanliga stegen — $match (filtrering, helst tidigt för att minska data), $group (gruppering och aggregering med $sum, $avg, etc. — kärnan i analys), $sort/$limit (sortering och sidindelning), $project (omformning av dokument), $unwind (expandering av matriser till dokument — viktigt för att analysera matrisdata, vanligt i MongoDB), och $lookup (koppling av samlingar — möjliggörande av joins som MongoDB annars undviker) — täcker verktygslådan för faktisk databearbetning.
Pipelinen hanterar rapportering, analys, datatransformation och komplexa frågor (aggregeringar, joins, matrisbearbetning) som är vanliga behov i applikationer.
Eftersom dataanalys och komplex frågning är viktiga användningar av all databaser, och eftersom aggregation pipeline är Mongos kraftfulla, flexibla mekanism för dem (långt bortom grundläggande CRUD), är det väsentligt att förstå aggregation pipeline — stegmodellen och nyckelstegen ($match, $group, $sort, $project, $unwind, $lookup) — är väsentlig, ofta använd MongoDB-kunskap för analys, rapportering och komplex datatransformation, ett kännetecken på avancerad MongoDB-skicklighet och ett av de viktigaste MongoDB-ämnena för att få verkligt analytiskt värde från databasen.