В MongoDB, $sum Операторът на конвейера за агрегиране изчислява и връща сумата от числови стойности.
Синтаксис
$sum операторът поддържа два синтаксиса.
Синтаксис 1:
{ $sum: <expression> } Синтаксис 2:
{ $sum: [ <expression1>, <expression2> ... ] } Първият синтаксис приема един аргумент, а вторият синтаксис приема множество аргументи.
Когато се използва в $group етап, можете да използвате само първия синтаксис. В този случай $sum връща сборната сума от всички числови стойности, които са резултат от прилагането на посочения израз към всеки документ в група документи, които споделят една и съща група по ключ.
Примери за синтаксис 1 (единичен аргумент)
Ето няколко примера, които използват синтаксис 1.
Групирани документи
Този пример използва $sum във връзка с $group за да върнете сумата в група документи, които са групирани по ключ.
Да предположим, че имаме колекция, наречена pets със следните документи:
{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Куче", "тегло" :10 }{ "_id" :3, "име" :"Мяу", "тип" :"Котка", "тегло" :7 }{ "_id" :4, "име" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Kenguroo", "weight" :100 }{ " _id" :6, "name" :"Hop", "type" :"Kenguroo", "weight" :130 }{ "_id" :7, "name" :"Punch", "type" :"Kenguroo", "weight" :200 }{ "_id" :8, "name" :"Snap", "type" :"Cat", "weight" :12 }{ "_id" :9, "name" :"Ruff", "тип" :"Куче", "тегло" :30 }
Можем да групираме тези документи по техния type поле и след това използвайте $sum за да върне сумата от weight поле за всяка група:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
sum: { $sum: "$weight" }
}
}
]
) Резултат:
{ "_id" :"Кенгуру", "sum" :430 }{ "_id" :"Котка", "sum" :27 }{ "_id" :"Куче", "sum" :60 } Масиви
Този пример се прилага $sum към един документ, който съдържа поле с масив от стойности.
Тази опция е налична само при използване на синтаксис на единичен аргумент. Масивите се игнорират, когато се използва синтаксисът с няколко аргумента (повече за това по-долу).
Да предположим, че имаме колекция, наречена players със следните документи:
{ "_id" :1, "player" :"Homer", "резултати" :[ 1, 7, 2, 3, 8, 7, 1 ] }{ "_id" :2, "player" :" Мардж", "резултати" :[ 0, 1, 8, 17, 18, 8 ] }{ "_id" :3, "играч" :"Барт", "резултати" :[ 15, 11, 8, 0, 1 , 3 ] }{ "_id" :4, "player" :"Brian", "cores" :[ 7 ] }{ "_id" :5, "player" :"Farnsworth", "cores" :[ ] }{ "_id" :6, "player" :"Мег", "резултати" :null }{ "_id" :7, "player" :"Рон" }
Можем да приложим $sum към scores поле във всеки документ:
db.players.aggregate(
[
{
$project:
{
player: 1,
sum: { $sum: "$scores" }
}
}
]
)
Резултат:
{ "_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 }
В този случай първите четири документа върнаха сбора от различните числа, които бяха в съответните им масиви.
В случай на документ 4 това беше същото като числото, защото имаше само едно число в масива.
Документ 5 върна 0 защото предоставихме празен масив.
Документ 6 върна 0 защото предоставихме null като аргумент.
Документ 7 върна 0 защото полето дори не е съществувало.
Пример за синтаксис 2 (множество аргументи)
Вторият синтаксис включва предоставяне на $sum с повече от един аргумент. $sum след това изчислява сумата въз основа на всички предоставени аргументи.
Да предположим, че имаме колекция, наречена data със следните документи:
{ "_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" :"Хей" } { "_id" :4, "a" :"Едно", "b" :"Две", "c" :"Три", "d" :"Четири" }
Можем да използваме $sum за да върне сумата от a , b , c и d полета на всеки документ:
db.data.aggregate(
[
{
$project:
{
sum: { $sum: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Резултат:
{ "_id" :1, "sum" :10 }{ "_id" :2, "sum" :6 }{ "_id" :3, "sum" :6 }{ "_id" :4, " сума" :0 }
Документ 1 връща сбора от входните стойности на 1 , 2 , 3 и 4 .
Следващите два документа обаче върнаха само сумата от входните стойности на 1 , 2 и 3 . $sum операторът игнорира техния d полета.
Това е така, защото $sum игнорира нечислови стойности. Така че в този случай той игнорира "Hey" в документ 3 и изчисли сумата от останалите (числови) полета.
Що се отнася до документ 2, неговият d полето съдържа масив. Както споменахме, $sum операторът игнорира масиви, когато използва синтаксис с няколко аргумента. По-точно, той третира масивите като нечислови стойности, когато се използва в този контекст, и $sum игнорира нечислови стойности.
Ако всички стойности не са числови, тогава $sum връща 0 . Можем да видим това с документ 4.
Липсващи полета
Когато използвате синтаксиса с няколко аргумента, $sum игнорира всички липсващи полета. Тоест, ако предоставите поле, което не съществува, то го игнорира. Ако нито едно от полетата не съществува, то връща 0 .
Пример:
db.data.aggregate(
[
{
$project:
{
sum: { $sum: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)
Резултат:
{ "_id" :1, "sum" :10 }{ "_id" :2, "sum" :6 }{ "_id" :3, "sum" :6 }{ "_id" :4, " сума" :0 }
В този случай предоставих допълнително поле ($e ), което не съществува в документите. $sum изчисли сумата въз основа на останалите полета, които правят съществуват.
Но ето какво се случва, когато няма от полетата съществуват:
db.data.aggregate(
[
{
$project:
{
result: { $sum: [ "$x", "$y", "$z" ] }
}
}
]
)
Резултат:
{ "_id" :1, "резултат" :0 }{ "_id" :2, "резултат" :0 }{ "_id" :3, "резултат" :0 }{ "_id" :4, " резултат" :0 }
Резултатът е 0 за всички документи.
Както видяхме по-рано, когато се използва синтаксисът с един аргумент, липсващо поле води до 0 .
Пример:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
sum: { $sum: "$oops!" }
}
}
]
)
Резултат:
{ "_id" :"Котка", "sum" :0 }{ "_id" :"Куче", "sum" :0 }{ "_id" :"Кенгуру", "sum" :0 } Налични етапи
$sum е наличен в следните етапи:
$group$project$addFields$set$replaceRoot$replaceWith$matchетап, който включва$exprизраз
