No MongoDB, o
$sum operador de pipeline de agregação calcula e retorna a soma dos valores numéricos. Sintaxe
A
$sum O operador suporta duas sintaxes. Sintaxe 1:
{ $sum: <expression> } Sintaxe 2:
{ $sum: [ <expression1>, <expression2> ... ] } A primeira sintaxe aceita um argumento e a segunda sintaxe aceita vários argumentos.
Quando usado no
$group stage, você só pode usar a primeira sintaxe. Neste caso, $sum retorna a soma coletiva de todos os valores numéricos resultantes da aplicação da expressão especificada a cada documento em um grupo de documentos que compartilham o mesmo grupo por chave. Exemplos de sintaxe 1 (argumento único)
Aqui estão alguns exemplos que usam a sintaxe 1.
Documentos agrupados
Este exemplo usa
$sum em conjunto com $group para retornar a soma em um grupo de documentos agrupados por chave. Suponha que tenhamos uma coleção chamada
pets com os seguintes documentos:{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Latido", "tipo" :"Dog", "weight" :10 }{ "_id" :3, "name" :"Miau", "type" :"Cat", "weight" :7 }{ "_id" :4, "name" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Canguru", "weight" :100 }{ " _id" :6, "name" :"Hop", "type" :"Canguru", "peso" :130 }{ "_id" :7, "name" :"Punch", "type" :"Canguru", "weight" :200 }{ "_id" :8, "name" :"Snap", "type" :"Gato", "weight" :12 }{ "_id" :9, "name" :"Ruff", "type" :"Cão", "peso" :30 } Podemos agrupar esses documentos por seu
type campo e, em seguida, use $sum para retornar a soma do weight campo para cada grupo:db.pets.aggregate(
[
{
$group:
{
_id: "$type",
sum: { $sum: "$weight" }
}
}
]
) Resultado:
{ "_id" :"Canguru", "sum" :430 }{ "_id" :"Gato", "sum" :27 }{ "_id" :"Cão", "sum" :60 } Matrizes
Este exemplo se aplica a $sum para um único documento que contém um campo com uma matriz de valores.
Esta opção só está disponível ao usar a sintaxe de argumento único. As matrizes são ignoradas ao usar a sintaxe de vários argumentos (mais sobre isso abaixo).
Suponha que tenhamos uma coleção chamada players com os seguintes documentos:
{ "_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" }
Podemos aplicar $sum para as scores campo em cada documento:
db.players.aggregate(
[
{
$project:
{
player: 1,
sum: { $sum: "$scores" }
}
}
]
)
Resultado:
{ "_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 }
Nesse caso, os quatro primeiros documentos retornaram a soma dos diversos números que estavam em suas respectivas matrizes.
No caso do documento 4, era o mesmo que o número, pois havia apenas um número no array.
O documento 5 retornou 0 porque fornecemos um array vazio.
O documento 6 retornou 0 porque fornecemos null como o argumento.
O documento 7 retornou 0 porque o campo nem existia.
Exemplo de sintaxe 2 (vários argumentos)
A segunda sintaxe envolve fornecer $sum com mais de um argumento. $sum em seguida, calcula a soma com base em todos os argumentos fornecidos.
Suponha que tenhamos uma coleção chamada data com os seguintes documentos:
{ "_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" :"Ei" } { "_id" :4, "a" :"Um", "b" :"Dois", "c" :"Três", "d" :"Quatro" }
Podemos usar $sum para retornar a soma do a , b , c e d campos de cada documento:
db.data.aggregate(
[
{
$project:
{
sum: { $sum: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Resultado:
{ "_id" :1, "sum" :10 }{ "_id" :2, "sum" :6 }{ "_id" :3, "sum" :6 }{ "_id" :4, " soma" :0 }
O documento 1 retorna a soma dos valores de entrada de 1 , 2 , 3 e 4 .
No entanto, os próximos dois documentos retornaram apenas a soma dos valores de entrada de 1 , 2 e 3 . A $sum operador ignorou seu d Campos.
Isso ocorre porque $sum ignora valores não numéricos. Então, neste caso, ele ignorou "Hey" no documento 3 e calculou a soma dos demais campos (numéricos).
Quanto ao documento 2, seu d campo contém uma matriz. Como mencionado, o $sum O operador ignora matrizes ao usar a sintaxe de vários argumentos. Mais precisamente, trata arrays como valores não numéricos quando usados neste contexto, e $sum ignora valores não numéricos.
Se todos os valores não forem numéricos, então $sum retorna 0 . Podemos ver isso com o documento 4.
Campos ausentes
Ao usar a sintaxe de vários argumentos, $sum ignora quaisquer campos ausentes. Ou seja, se você fornecer um campo que não existe, ele o ignora. Se nenhum dos campos existir, ele retornará 0 .
Exemplo:
db.data.aggregate(
[
{
$project:
{
sum: { $sum: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)
Resultado:
{ "_id" :1, "sum" :10 }{ "_id" :2, "sum" :6 }{ "_id" :3, "sum" :6 }{ "_id" :4, " soma" :0 }
Neste caso forneci um campo extra ($e ) que não existe nos documentos. $sum calculou a soma com base nos campos restantes que fazem existir.
No entanto, veja o que acontece quando nenhum dos campos existem:
db.data.aggregate(
[
{
$project:
{
result: { $sum: [ "$x", "$y", "$z" ] }
}
}
]
)
Resultado:
{ "_id":1, "resultado":0 }{ "_id":2, "resultado":0 }{ "_id":3, "resultado":0 }{ "_id":4, " resultado" :0 }
O resultado é 0 para todos os documentos.
Como vimos anteriormente, ao usar a sintaxe de argumento único, um campo ausente resulta em 0 .
Exemplo:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
sum: { $sum: "$oops!" }
}
}
]
)
Resultado:
{ "_id" :"Gato", "sum" :0 }{ "_id" :"Cachorro", "sum" :0 }{ "_id" :"Canguru", "sum" :0 } Etapas disponíveis
$sum está disponível nas seguintes etapas:
$group$project$addFields$set$replaceRoot$replaceWith$matchestágio que inclui um$exprexpressão
