Hvordan bruke aggregasjonsrørledningen i MongoDB

Aggregeringsrørledningen er den anbefalte måten å kjøre komplekse spørringer i MongoDB. Hvis du har brukt MongoDBs MapReduce, bør du bytte til aggregeringsrørledningen for mer effektive beregninger.

Hva er aggregering i MongoDB og hvordan fungerer det?

Aggregeringsrørledningen er en flertrinnsprosess for å kjøre avansert spørringer i MongoDB. Den behandler data gjennom forskjellige stadier kalt en rørledning. Du kan bruke resultatene generert fra ett nivå som en operasjonsmal i et annet.

Du kan for eksempel overføre resultatet av en matchoperasjon til et annet trinn for sortering i den rekkefølgen til du får ønsket utgang.

Hvert trinn i en aggregeringsrørledning har en MongoDB-operatør og genererer ett eller flere transformerte dokumenter. Avhengig av søket ditt, kan et nivå vises flere ganger i pipelinen. Det kan for eksempel hende du må bruke $count eller $sort operatørstadier mer enn én gang på tvers av aggregeringsrørledningen.

Stadiene av aggregasjonsrørledningen

Aggregeringsrørledningen sender data gjennom flere stadier i en enkelt spørring. Det er flere stadier, og du kan finne detaljene deres i MongoDB dokumentasjon.

La oss definere noen av de mest brukte nedenfor.

$match-stadiet

Dette stadiet hjelper deg med å definere spesifikke filtreringsbetingelser før du starter de andre aggregeringsstadiene. Du kan bruke den til å velge samsvarende data du vil inkludere i aggregeringspipelinen.

$gruppescenen

Gruppestadiet skiller data inn i ulike grupper basert på spesifikke kriterier ved hjelp av nøkkelverdi-par. Hver gruppe representerer en nøkkel i utdatadokumentet.

Tenk for eksempel på følgende salg eksempeldata:

Ved å bruke aggregeringspipelinen kan du beregne det totale salgsantallet og toppsalget for hver produktseksjon:

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

De _id: $Section pargrupper utdatadokumentet basert på seksjonene. Ved å spesifisere topp_salg_antall og topp_salg felt, oppretter MongoDB nye nøkler basert på operasjonen definert av aggregatoren; dette kan være $sum, $min, $maks, eller $avg.

$hopp-stadiet

Du kan bruke $hopp trinn for å utelate et spesifisert antall dokumenter i utdataene. Det kommer vanligvis etter gruppespillet. For eksempel, hvis du forventer to utdatadokumenter, men hopper over ett, vil aggregeringen bare gi ut det andre dokumentet.

For å legge til et hoppstadium, sett inn $hopp operasjon inn i aggregeringsrørledningen:

...,
{
 $skip: 1
 },

$sort-scenen

Sorteringstrinnet lar deg ordne data i synkende eller stigende rekkefølge. For eksempel kan vi sortere dataene i det forrige spørringseksemplet i synkende rekkefølge for å finne ut hvilken del som har det høyeste salget.

Legg til $sort operatør til forrige spørring:

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

$limit-stadiet

Begrensningsoperasjonen bidrar til å redusere antallet utdatadokumenter du vil at aggregeringsrørledningen skal vise. Bruk for eksempel $grense operatør for å få seksjonen med det høyeste salget returnert fra forrige trinn:

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

Ovennevnte returnerer bare det første dokumentet; dette er seksjonen med høyest salg, slik den vises på toppen av den sorterte produksjonen.

$prosjektstadiet

De $prosjekt trinn lar deg forme utdatadokumentet slik du vil. Bruker $prosjekt operatør, kan du spesifisere hvilket felt som skal inkluderes i utdataene og tilpasse nøkkelnavnet.

For eksempel en prøveutgang uten $prosjekt scenen ser slik ut:

La oss se hvordan det ser ut med $prosjekt scene. For å legge til $prosjekt til rørledningen:

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

Siden vi tidligere har gruppert dataene basert på produktseksjoner, inkluderer ovenstående hver produktseksjon i utdatadokumentet. Det sikrer også at det aggregerte antall salg og toppsalg vises i produksjonen som TotalSold og Toppsalg.

Den endelige utgangen er mye renere sammenlignet med den forrige:

$unwind-scenen

De $slappe av scenen bryter ned en matrise i et dokument til individuelle dokumenter. Ta følgende Bestillinger data, for eksempel:

Bruke $slappe av scenen for å dekonstruere gjenstander array før du bruker andre aggregeringsstadier. For eksempel å slappe av gjenstander array er fornuftig hvis du vil beregne den totale inntekten 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 av aggregeringsspørringen ovenfor:

Hvordan lage en aggregasjonsrørledning i MongoDB

Mens aggregeringspipelinen inkluderer flere operasjoner, gir de tidligere omtalte stadiene deg en ide om hvordan du bruker dem i pipelinen, inkludert den grunnleggende spørringen for hver.

Bruker den forrige salg dataeksempel, la oss ha noen av stadiene diskutert ovenfor i ett stykke for et bredere syn på aggregeringsrørledningen:

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",
 }
 }

])

Den endelige utgangen ser ut som noe du har sett tidligere:

Aggregasjonsrørledning vs. Kart reduksjon

Inntil den ble avviklet fra MongoDB 5.0, var den konvensjonelle måten å samle data i MongoDB på via MapReduce. Selv om MapReduce har bredere applikasjoner utover MongoDB er det mindre effektivt enn aggregeringsrørledningen, og krever tredjeparts skripting for å skrive kartet og redusere funksjoner separat.

Aggregeringsrørledningen, derimot, er kun spesifikk for MongoDB. Men det gir en renere og mer effektiv måte å utføre komplekse spørringer på. I tillegg til enkelhet og skalerbarhet for spørringer, gjør de omtalte pipeline-trinnene utdataene mer tilpassbare.

Det er mange flere forskjeller mellom aggregeringsrørledningen og MapReduce. Du vil se dem når du bytter fra MapReduce til aggregeringsrørledningen.

Gjør Big Data Queries effektive i MongoDB

Din spørring må være så effektiv som mulig hvis du ønsker å kjøre dybdeberegninger på komplekse data i MongoDB. Aggregeringsrørledningen er ideell for avansert spørring. I stedet for å manipulere data i separate operasjoner, som ofte reduserer ytelsen, lar aggregering deg pakke dem alle inne i en enkelt ytelsespipeline og utføre dem én gang.

Mens aggregeringsrørledningen er mer effektiv enn MapReduce, kan du gjøre aggregeringen raskere og mer effektiv ved å indeksere dataene dine. Dette begrenser mengden data MongoDB trenger å skanne under hvert aggregeringstrinn.