I MongoDB er $sum aggregeringspipeline-operatør beregner og returnerer summen af numeriske værdier.
Syntaks
$sum operatoren understøtter to syntakser.
Syntaks 1:
{ $sum: <expression> } Syntaks 2:
{ $sum: [ <expression1>, <expression2> ... ] } Den første syntaks accepterer ét argument, og den anden syntaks accepterer flere argumenter.
Når det bruges i $group fase, kan du kun bruge den første syntaks. I dette tilfælde $sum returnerer den samlede sum af alle de numeriske værdier, der er resultatet af at anvende det angivne udtryk på hvert dokument i en gruppe af dokumenter, der deler den samme gruppe efter nøgle.
Eksempler på syntaks 1 (enkelt argument)
Her er et par eksempler, der bruger syntaks 1.
Grupperte dokumenter
Dette eksempel bruger $sum i forbindelse med $group for at returnere summen på tværs af en gruppe dokumenter, der er grupperet efter nøgle.
Antag, at vi har en samling kaldet pets med følgende dokumenter:
{ "_id" :1, "name" :"Wag", "type" :"Hund", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Hund", "vægt" :10 }{ "_id" :3, "name" :"Mjav", "type" :"Kat", "vægt" :7 }{ "_id" :4, "navn" :"Scratch", "type" :"Kat", "vægt" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Kænguru", "vægt" :100 }{ " _id" :6, "name" :"Hop", "type" :"Kænguru", "vægt" :130 }{ "_id" :7, "name" :"Punch", "type" :"Kænguru", "vægt" :200 }{ "_id" :8, "name" :"Snap", "type" :"Kat", "vægt" :12 }{ "_id" :9, "name" :"Ruff", "type" :"Hund", "vægt" :30 }
Vi kan gruppere disse dokumenter efter deres type felt, og brug derefter $sum for at returnere summen af weight felt for hver gruppe:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
sum: { $sum: "$weight" }
}
}
]
) Resultat:
{ "_id" :"Kænguru", "sum" :430 }{ "_id" :"Kat", "sum" :27 }{ "_id" :"Hund", "sum" :60 } Arrays
Dette eksempel gælder $sum til et enkelt dokument, der indeholder et felt med en række værdier.
Denne indstilling er kun tilgængelig, når du bruger syntaksen for enkelt argument. Arrays ignoreres, når du bruger multi-argument-syntaksen (mere om dette nedenfor).
Antag, at vi har en samling kaldet players med følgende dokumenter:
{ "_id" :1, "player" :"Homer", "scores" :[ 1, 7, 2, 3, 8, 7, 1 ] }{ "_id" :2, "player" :" Marge", "scores" :[ 0, 1, 8, 17, 18, 8 ] }{ "_id" :3, "player" :"Bart", "scores" :[ 15, 11, 8, 0, 1 , 3 ] }{ "_id" :4, "player" :"Brian", "scores" :[ 7 ] }{ "_id" :5, "player" :"Farnsworth", "scores" :[ ] }{ "_id" :6, "player" :"Meg", "scores" :null }{ "_id" :7, "player" :"Ron" }
Vi kan anvende $sum til scores felt i hvert dokument:
db.players.aggregate(
[
{
$project:
{
player: 1,
sum: { $sum: "$scores" }
}
}
]
)
Resultat:
{ "_id" :1, "player" :"Homer", "sum" :29 }{ "_id" :2, "player" :"Marge", "sum" :52 }{ "_id" :3, "player" :"Bart", "sum" :38 }{ "_id" :4, "player" :"Brian", "sum" :7 }{ "_id" :5, "player" :"Farnsworth ", "sum" :0 }{ "_id" :6, "player" :"Meg", "sum" :0 }{ "_id" :7, "player" :"Ron", "sum" :0 }
I dette tilfælde returnerede de første fire dokumenter summen af de forskellige tal, der var i deres respektive arrays.
I dokument 4s tilfælde var dette det samme som nummeret, fordi der kun var ét tal i arrayet.
Dokument 5 returnerede 0 fordi vi leverede et tomt array.
Dokument 6 returnerede 0 fordi vi har leveret null som argumentet.
Dokument 7 returnerede 0 fordi feltet ikke engang eksisterede.
Eksempel på syntaks 2 (flere argumenter)
Den anden syntaks involverer at give $sum med mere end ét argument. $sum beregner derefter summen baseret på alle de leverede argumenter.
Antag, at vi har en samling kaldet data med følgende dokumenter:
{ "_id" :1, "a" :1, "b" :2, "c" :3, "d" :4 }{ "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 4 ] }{ "_id" :3, "a" :1, "b" :2, "c" :3, "d" :"Hej" } { "_id" :4, "a" :"Én", "b" :"To", "c" :"Tre", "d" :"Fire" }
Vi kan bruge $sum for at returnere summen af a , b , c og d felter i hvert dokument:
db.data.aggregate(
[
{
$project:
{
sum: { $sum: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Resultat:
{ "_id" :1, "sum" :10 }{ "_id" :2, "sum" :6 }{ "_id" :3, "sum" :6 }{ "_id" :4, " sum" :0 }
Dokument 1 returnerer summen af inputværdierne for 1 , 2 , 3 og 4 .
De næste to dokumenter returnerede dog kun summen af inputværdierne for 1 , 2 og 3 . $sum operatør ignorerede deres d felter.
Dette er fordi $sum ignorerer ikke-numeriske værdier. Så i dette tilfælde ignorerede den "Hey" i dokument 3 og beregnede summen ud fra de resterende (numeriske) felter.
Hvad angår dokument 2, er dets d felt indeholder en matrix. Som nævnt er $sum operatør ignorerer arrays, når der bruges multi-argument syntaks. Mere præcist behandler den arrays som ikke-numeriske værdier, når de bruges i denne sammenhæng, og $sum ignorerer ikke-numeriske værdier.
Hvis alle værdier er ikke-numeriske, så $sum returnerer 0 . Det kan vi se med dokument 4.
Manglende felter
Når du bruger multi-argument-syntaksen, $sum ignorerer eventuelle manglende felter. Det vil sige, at hvis du angiver et felt, der ikke eksisterer, ignorerer det det. Hvis ingen af felterne eksisterer, returnerer det 0 .
Eksempel:
db.data.aggregate(
[
{
$project:
{
sum: { $sum: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)
Resultat:
{ "_id" :1, "sum" :10 }{ "_id" :2, "sum" :6 }{ "_id" :3, "sum" :6 }{ "_id" :4, " sum" :0 }
I dette tilfælde har jeg angivet et ekstra felt ($e ), som ikke findes i dokumenterne. $sum beregnede summen baseret på de resterende felter, der gør eksisterer.
Men her er, hvad der sker, når ingen af felterne findes:
db.data.aggregate(
[
{
$project:
{
result: { $sum: [ "$x", "$y", "$z" ] }
}
}
]
)
Resultat:
{ "_id" :1, "result" :0 }{ "_id" :2, "result" :0 }{ "_id" :3, "result" :0 }{ "_id" :4, " resultat" :0 }
Resultatet er 0 for alle dokumenter.
Som vi så tidligere, resulterer et manglende felt i 0 ved brug af enkeltargumentsyntaksen .
Eksempel:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
sum: { $sum: "$oops!" }
}
}
]
)
Resultat:
{ "_id" :"Kat", "sum" :0 }{ "_id" :"Hund", "sum" :0 }{ "_id" :"Kænguru", "sum" :0 } Tilgængelige stadier
$sum er tilgængelig i følgende trin:
$group$project$addFields$set$replaceRoot$replaceWith$matchtrin, der inkluderer en$exprudtryk