Sådan bruges aggregationsrørledningen i MongoDB

Aggregeringspipelinen er den anbefalede måde at køre komplekse forespørgsler på i MongoDB. Hvis du har brugt MongoDB's MapReduce, skal du hellere skifte til aggregeringspipelinen for mere effektive beregninger.

Hvad er aggregation i MongoDB, og hvordan fungerer det?

Aggregeringspipelinen er en flertrinsproces til at køre avanceret forespørgsler i MongoDB. Den behandler data gennem forskellige stadier kaldet en pipeline. Du kan bruge resultaterne genereret fra ét niveau som en operationsskabelon på et andet.

For eksempel kan du overføre resultatet af en match-operation til et andet trin for sortering i den rækkefølge, indtil du får det ønskede output.

Hvert trin i en aggregeringspipeline har en MongoDB-operatør og genererer et eller flere transformerede dokumenter. Afhængigt af din forespørgsel kan et niveau vises flere gange i pipelinen. Det kan for eksempel være nødvendigt at bruge

$tæller eller $sort operatørfaser mere end én gang på tværs af aggregeringspipelinen.

Stadier af aggregation Pipeline

Aggregeringspipelinen sender data gennem flere stadier i en enkelt forespørgsel. Der er flere stadier, og du kan finde deres detaljer i MongoDB dokumentation.

Lad os definere nogle af de mest brugte nedenfor.

$match-stadiet

Dette trin hjælper dig med at definere specifikke filtreringsbetingelser, før du starter de andre aggregeringsstadier. Du kan bruge den til at vælge de matchende data, du vil inkludere i aggregeringspipelinen.

$gruppescenen

Gruppefasen adskiller data i forskellige grupper baseret på specifikke kriterier ved hjælp af nøgle-værdi-par. Hver gruppe repræsenterer en nøgle i outputdokumentet.

Overvej f.eks. følgende salg eksempeldata:

Ved hjælp af aggregeringspipelinen kan du beregne det samlede salgstal og topsalg for hver produktsektion:

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

Det _id: $Sektion par grupperer outputdokumentet baseret på sektionerne. Ved at specificere top_salg_antal og top_salg felter opretter MongoDB nye nøgler baseret på operationen defineret af aggregatoren; dette kan være $sum, $min, $max, eller $gennemsnit.

$spring-stadiet

Du kan bruge $spring trin for at udelade et bestemt antal dokumenter i outputtet. Det kommer normalt efter gruppespillet. For eksempel, hvis du forventer to outputdokumenter, men springer et over, vil aggregeringen kun outputte det andet dokument.

For at tilføje et springtrin skal du indsætte $spring drift i aggregeringsrørledningen:

...,
{
 $skip: 1
 },

$sort-scenen

Sorteringsstadiet lader dig arrangere data i faldende eller stigende rækkefølge. For eksempel kan vi yderligere sortere dataene i det foregående forespørgselseksempel i faldende rækkefølge for at bestemme, hvilken sektion der har det højeste salg.

Tilføj $sort operatør til den forrige forespørgsel:

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

$limit-stadiet

Begrænsningsoperationen hjælper med at reducere antallet af outputdokumenter, du ønsker, at aggregeringspipelinen skal vise. Brug f.eks $grænse operatør for at få sektionen med det højeste salg returneret af det foregående trin:

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

Ovenstående returnerer kun det første dokument; dette er den sektion med det højeste salg, som det vises øverst i det sorterede output.

$projektstadiet

Det $projekt fase giver dig mulighed for at forme outputdokumentet, som du vil. Bruger $projekt operatør, kan du angive, hvilket felt der skal inkluderes i outputtet og tilpasse dets nøglenavn.

For eksempel en prøveudgang uden $projekt scenen ser sådan ud:

Lad os se, hvordan det ser ud med $projekt scene. For at tilføje $projekt til rørledningen:

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

Da vi tidligere har grupperet dataene baseret på produktsektioner, inkluderer ovenstående hver produktsektion i outputdokumentet. Det sikrer også, at det aggregerede salgstal og topsalg indgår i outputtet som TotalSolgt og TopSale.

Det endelige output er meget renere sammenlignet med det forrige:

$unwind-scenen

Det $slappe af fase opdeler et array i et dokument i individuelle dokumenter. Tag følgende Ordre:% s data, for eksempel:

Brug $slappe af fase for at dekonstruere genstande array, før du anvender andre aggregeringstrin. For eksempel at afvikle genstande array giver mening, hvis du vil beregne den samlede omsætning for hvert 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",
 }
 }
])

Her er resultatet af ovenstående aggregeringsforespørgsel:

Sådan opretter du en aggregationspipeline i MongoDB

Mens aggregeringspipelinen omfatter flere operationer, giver de tidligere fremhævede faser dig en idé om, hvordan du anvender dem i pipelinen, inklusive den grundlæggende forespørgsel for hver.

Bruger det forrige salg dataeksempel, lad os få nogle af faserne diskuteret ovenfor i ét stykke for at få et bredere overblik over 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 endelige output ligner noget, du har set tidligere:

Aggregation Pipeline vs. KortReducer

Indtil dens udfasning fra MongoDB 5.0, var den konventionelle måde at aggregere data i MongoDB på via MapReduce. Selvom MapReduce har bredere applikationer ud over MongoDB er det mindre effektivt end aggregeringspipelinen, hvilket kræver tredjepartsscripting for at skrive kortet og reducere funktionerne separat.

Aggregeringspipelinen er på den anden side kun specifik for MongoDB. Men det giver en renere og mere effektiv måde at udføre komplekse forespørgsler på. Udover enkelhed og forespørgselsskalerbarhed gør de fremhævede pipeline-trin outputtet mere tilpasseligt.

Der er mange flere forskelle mellem aggregeringspipelinen og MapReduce. Du vil se dem, når du skifter fra MapReduce til aggregeringspipelinen.

Gør Big Data Queries effektive i MongoDB

Din forespørgsel skal være så effektiv som muligt, hvis du ønsker at køre dybdegående beregninger på komplekse data i MongoDB. Aggregeringspipelinen er ideel til avanceret forespørgsel. I stedet for at manipulere data i separate operationer, hvilket ofte reducerer ydeevnen, giver aggregering dig mulighed for at pakke dem alle inde i en enkelt performant pipeline og udføre dem én gang.

Mens aggregeringspipelinen er mere effektiv end MapReduce, kan du gøre aggregering hurtigere og mere effektiv ved at indeksere dine data. Dette begrænser mængden af ​​data, som MongoDB skal scanne under hvert aggregeringstrin.