Hur man använder Aggregation Pipeline i MongoDB

Aggregeringspipelinen är det rekommenderade sättet att köra komplexa frågor i MongoDB. Om du har använt MongoDB: s MapReduce, bör du byta till aggregeringspipelinen för effektivare beräkningar.

Vad är aggregation i MongoDB och hur fungerar det?

Aggregeringspipeline är en flerstegsprocess för att köra avancerad frågor i MongoDB. Den bearbetar data genom olika stadier som kallas en pipeline. Du kan använda resultaten som genereras från en nivå som en operationsmall i en annan.

Du kan till exempel skicka resultatet av en matchningsoperation till ett annat steg för sortering i den ordningen tills du får önskad utdata.

Varje steg i en aggregeringspipeline har en MongoDB-operatör och genererar ett eller flera transformerade dokument. Beroende på din fråga kan en nivå visas flera gånger i pipelinen. Till exempel kan du behöva använda $count eller $sort operatörssteg mer än en gång över aggregeringspipelinen.

Stadier av aggregation Pipeline

Aggregeringspipelinen skickar data genom flera steg i en enda fråga. Det finns flera steg och du kan hitta deras detaljer i MongoDB dokumentation.

Låt oss definiera några av de mest använda nedan.

$match scenen

Det här steget hjälper dig att definiera specifika filtreringsvillkor innan du startar de andra aggregeringsstegen. Du kan använda den för att välja matchande data som du vill inkludera i aggregeringspipelinen.

$gruppsscenen

Gruppsteget separerar data i olika grupper baserat på specifika kriterier med nyckel-värdepar. Varje grupp representerar en nyckel i utdatadokumentet.

Tänk till exempel på följande försäljning stickprov:

Med hjälp av aggregeringspipelinen kan du beräkna det totala försäljningsantalet och toppförsäljningen för varje produktsektion:

{
 $group: {
 _id: $Section,
 total_sales_count: {$sum: $Sold},
 top_sales: {$max: $Amount},
 }
}

De _id: $Sektion pargrupper utdatadokumentet baserat på avsnitten. Genom att specificera top_sales_count och top_sales fält, skapar MongoDB nya nycklar baserat på operationen som definieras av aggregatorn; det här kan vara $summa, $min, $max, eller $genomsnitt.

$hopp-stadiet

Du kan använda $hoppa över steg för att utelämna ett visst antal dokument i utdata. Det brukar komma efter gruppspelet. Till exempel, om du förväntar dig två utdatadokument men hoppar över ett, kommer aggregeringen endast att mata ut det andra dokumentet.

För att lägga till ett överhoppningssteg, infoga $hoppa över operation i aggregationspipelinen:

...,
{
 $skip: 1
 },

$sort-scenen

Sorteringssteget låter dig ordna data i fallande eller stigande ordning. Till exempel kan vi ytterligare sortera data i det föregående frågeexemplet i fallande ordning för att avgöra vilket avsnitt som har den högsta försäljningen.

Lägg till $sort operator till föregående fråga:

...,
{
 $sort: {top_sales: -1}
 },

$limit-stadiet

Begränsningsoperationen hjälper till att minska antalet utdatadokument som du vill att aggregeringspipelinen ska visa. Använd till exempel $gräns operatör för att få avsnittet med den högsta försäljningen som returnerades av föregående steg:

...,
{
 $sort: {top_sales: -1}
 },
{"$limit": 1}

Ovanstående returnerar endast det första dokumentet; detta är den sektion som har högst försäljning, eftersom den visas överst i den sorterade produktionen.

$projektstadiet

De $projekt scenen låter dig forma utdatadokumentet som du vill. Använda $projekt operatör kan du ange vilket fält som ska inkluderas i utdata och anpassa dess nyckelnamn.

Till exempel en provutgång utan $projekt scenen ser ut så här:

Låt oss se hur det ser ut med $projekt skede. För att lägga till $projekt till pipeline:

...,
{
 "$project": {
 "_id": 0,
 "Section": "$_id",
 "TotalSold": "$total_sales_count",
 "TopSale": "$top_sales",
 }
 }

Eftersom vi tidigare har grupperat data baserat på produktsektioner, inkluderar ovanstående varje produktsektion i utdatadokumentet. Det säkerställer också att den aggregerade försäljningsantalet och toppförsäljningen ingår i utdata som Totalt Såld och TopSale.

Den slutliga utgången är mycket renare jämfört med den föregående:

$unwind-scenen

De $varva ner scenen bryter ner en array i ett dokument i enskilda dokument. Ta följande Order data, till exempel:

Använd $varva ner steg för att dekonstruera föremål array innan andra aggregeringssteg tillämpas. Till exempel att varva ner föremål array är vettigt om du vill beräkna den totala intäkten för varje produkt:

db.Orders.aggregate(
[
 {
 "$unwind": "$items"
 },
 {
 "$group": {
 "_id": "$items.product",
 "total_revenue": { "$sum": { "$multiply": ["$items.quantity", "$items.price"] } }
 }
 },
 {
 "$sort": { "total_revenue": -1 }
 },
 {
 "$project": {
 "_id": 0,
 "Product": "$_id",
 "TotalRevenue": "$total_revenue",
 }
 }
])

Här är resultatet av ovanstående aggregeringsfråga:

Hur man skapar en aggregationspipeline i MongoDB

Även om aggregeringspipelinen innehåller flera operationer, ger de tidigare visade stegen dig en uppfattning om hur du tillämpar dem i pipelinen, inklusive den grundläggande frågan för varje.

Använder föregående försäljning dataexempel, låt oss ta några av stegen som diskuterats ovan i ett stycke för en bredare bild av aggregeringspipelinen:

db.sales.aggregate([
 {
 "$match": {
 "Sold": { "$gte": 5 }
 }
 },
 {
 "$group": {
 "_id": "$Section",
 "total_sales_count": { "$sum": "$Sold" },
 "top_sales": { "$max": "$Amount" },

 }
 },
 {
 "$sort": { "top_sales": -1 }
 },
 {"$skip": 0},
 {
 "$project": {
 "_id": 0,
 "Section": "$_id",
 "TotalSold": "$total_sales_count",
 "TopSale": "$top_sales",
 }
 }

])

Det slutliga resultatet ser ut som något du har sett tidigare:

Aggregation Pipeline vs. MapReduce

Fram till dess utfasning från MongoDB 5.0 var det konventionella sättet att aggregera data i MongoDB via MapReduce. Fastän MapReduce har bredare tillämpningar bortom MongoDB är det mindre effektivt än aggregeringspipelinen, vilket kräver tredjepartsskript för att skriva kartan och reducera funktioner separat.

Aggregeringspipelinen, å andra sidan, är endast specifik för MongoDB. Men det ger ett renare och mer effektivt sätt att utföra komplexa frågor. Förutom enkelhet och frågeskalbarhet, gör de presenterade pipeline-stegen utdatan mer anpassningsbar.

Det finns många fler skillnader mellan aggregeringspipeline och MapReduce. Du kommer att se dem när du byter från MapReduce till aggregeringspipelinen.

Gör Big Data Queries effektiva i MongoDB

Din fråga måste vara så effektiv som möjligt om du vill köra djupgående beräkningar på komplexa data i MongoDB. Aggregeringspipelinen är idealisk för avancerad sökning. Istället för att manipulera data i separata operationer, vilket ofta minskar prestandan, låter aggregering dig packa dem alla i en enda presterande pipeline och exekvera dem en gång.

Även om aggregeringspipelinen är mer effektiv än MapReduce, kan du göra aggregeringen snabbare och effektivare genom att indexera dina data. Detta begränsar mängden data som MongoDB behöver skanna under varje aggregeringssteg.