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.
Innholdsfortegnelse
Hva er aggregering i MongoDB og hvordan fungerer det?
Aggregeringsrørledningen er en flertrinnsprosess for å kjøre avanserte 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-operatorstadiene 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.
Vurder for eksempel følgende salgseksempeldata:
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},
}
}
_id: $Section-paret grupperer utdatadokumentet basert på seksjonene. Ved å spesifisere top_sales_count og top_sales-feltene, oppretter MongoDB ferske nøkler basert på operasjonen definert av aggregatoren; dette kan være $sum, $min, $max eller $avg.
$hopp-stadiet
Du kan bruke $hopp-stadiet til å 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 $skip-operasjonen 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-operatoren i 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 $limit-operatøren 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
$prosjektstadiet lar deg forme utdatadokumentet som du vil. Ved å bruke $project-operatoren kan du spesifisere hvilket felt som skal inkluderes i utdataene og tilpasse nøkkelnavnet.
For eksempel ser en prøveutgang uten $project-stadiet slik ut:
La oss se hvordan det ser ut med $prosjektstadiet. Slik legger du $prosjektet til pipelinen:
...,{
"$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 salgsantallet og toppsalget vises i produksjonen som TotalSold og TopSale.
Den endelige utgangen er mye renere sammenlignet med den forrige:
$unwind-scenen
$unwind-stadiet bryter ned en matrise i et dokument til individuelle dokumenter. Ta for eksempel følgende ordredata:
Bruk $unwind-stadiet til å dekonstruere elementarrayen før du bruker andre aggregeringsstadier. For eksempel er det fornuftig å avvikle varegruppen 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.
Ved å bruke det forrige salgsdataeksemplet, la oss ha noen av stadiene diskutert ovenfor i ett stykke for en bredere oversikt 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",}
}
])
Den endelige utgangen ser ut som noe du har sett tidligere:
Aggregasjonsrørlinje vs. MapReduce
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 den mindre effektiv 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.