$sum, $avg, $min, $max: agregação numérica
Você calculará totais, médias e extremos dentro de $group e também usará esses acumuladores como operadores de expressão em $project.
$sum, $avg, $min, $max: agregação numérica é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.
Acumuladores numéricos em $group
O estágio $group do MongoDB usa acumuladores para calcular valores agregados a partir de documentos agrupados. Os acumuladores numéricos mais fundamentais são $sum, $avg, $min e $max. Cada acumulador processa todos os documentos de um grupo e produz um único valor de saída. Esses operadores formam a base dos fluxos de análise.
Usando $sum para contar e totalizar
O acumulador $sum tem dois usos comuns: contar documentos, passando um valor literal como 1, e somar um campo, referenciando um campo numérico. Quando um campo está ausente ou é nulo, $sum o trata como zero. Isso permite usá-lo com segurança em campos numéricos opcionais, sem verificações adicionais de nulos.
db.orders.aggregate([
{
$group: {
_id: '$status',
orderCount: { $sum: 1 },
totalRevenue: { $sum: '$amount' }
}
}
])Calculando médias com $avg
O acumulador $avg calcula a média aritmética de um campo numérico em todos os documentos de um grupo. Ele ignora automaticamente os documentos em que o campo está ausente ou é nulo, calculando a média apenas com valores válidos. Isso é útil para métricas como o valor médio dos pedidos ou a avaliação média por produto.
db.reviews.aggregate([
{
$group: {
_id: '$productId',
averageRating: { $avg: '$rating' },
reviewCount: { $sum: 1 }
}
},
{ $sort: { averageRating: -1 } }
])Encontrando extremos com $min e $max
$min e $max retornam, respectivamente, os menores e maiores valores de um grupo. Eles funcionam com qualquer tipo comparável: números, datas e strings. Um caso de uso comum é encontrar os horários do primeiro e do último evento de uma sessão, ou o produto mais barato e o mais caro de uma categoria. Eles ignoram valores nulos e ausentes.
db.sessions.aggregate([
{
$group: {
_id: '$userId',
firstLogin: { $min: '$timestamp' },
lastLogin: { $max: '$timestamp' },
minSessionDuration: { $min: '$durationSeconds' },
maxSessionDuration: { $max: '$durationSeconds' }
}
}
])Agrupando por nulo para obter totais gerais
Para calcular um único agregado sobre toda a coleção, defina _id como null. Isso agrupa todos os documentos em um único grupo. Essa técnica permite calcular totais, médias gerais e extremos globais sem segmentar os dados. Pense nela como o equivalente no MongoDB a um SELECT SUM(*) FROM orders do SQL sem uma cláusula GROUP BY.
db.orders.aggregate([
{
$group: {
_id: null,
totalOrders: { $sum: 1 },
grandTotal: { $sum: '$amount' },
averageOrder: { $avg: '$amount' },
minOrder: { $min: '$amount' },
maxOrder: { $max: '$amount' }
}
}
])Usando estes acumuladores em $project
Um recurso menos conhecido é que $sum, $avg, $min e $max também podem ser usados como operadores de expressão em $project, e não apenas em $group. Nesse contexto, eles operam sobre uma matriz dentro de um único documento, em vez de operar sobre vários documentos. Isso permite calcular a soma dos elementos de um campo de matriz incorporado sem um estágio $group.
db.carts.aggregate([
{
$project: {
userId: 1,
// Sum elements inside the items array
cartTotal: { $sum: '$items.price' },
maxItemPrice: { $max: '$items.price' },
avgItemPrice: { $avg: '$items.price' }
}
}
])Expressões aninhadas dentro de acumuladores
Os acumuladores aceitam qualquer expressão válida, não apenas referências a campos. Você pode usar operadores aritméticos, expressões condicionais e até $cond dentro de um acumulador. Isso permite implementar somas condicionais, como “somar apenas os pedidos concluídos”, ou contagens condicionais, como “contar apenas as transações de alto valor”, em um único estágio do fluxo.
db.orders.aggregate([
{
$group: {
_id: '$customerId',
// Only sum orders that are 'completed'
completedRevenue: {
$sum: {
$cond: [
{ $eq: ['$status', 'completed'] },
'$amount',
0
]
}
}
}
}
])Fluxos de agrupamento multinível
Você pode encadear vários estágios $group para calcular agregações em vários níveis. O primeiro grupo calcula os totais por dia, e o segundo calcula as médias mensais a partir desses totais diários. Esse padrão é mais claro do que fazer tudo em um único estágio e facilita a compreensão da lógica do fluxo.
db.sales.aggregate([
// First group: totals per day
{
$group: {
_id: { year: { $year: '$date' }, month: { $month: '$date' }, day: { $dayOfMonth: '$date' } },
dailyTotal: { $sum: '$amount' }
}
},
// Second group: average daily total per month
{
$group: {
_id: { year: '$_id.year', month: '$_id.month' },
avgDailyRevenue: { $avg: '$dailyTotal' },
totalMonthRevenue: { $sum: '$dailyTotal' }
}
}
])Filtrando antes de agrupar com $match
Sempre coloque um estágio $match antes de $group para filtrar primeiro os documentos relevantes. Isso reduz o número de documentos que o estágio de agrupamento precisa processar e, principalmente, permite que o MongoDB use um índice para atender ao filtro. Um $match depois de $group filtra os resultados dos grupos, o que também é útil, mas não se beneficia dos índices.
db.orders.aggregate([
// Filter first — MongoDB can use an index on createdAt
{
$match: {
createdAt: { $gte: new Date('2024-01-01') },
status: 'completed'
}
},
{
$group: {
_id: '$region',
totalRevenue: { $sum: '$amount' },
avgRevenue: { $avg: '$amount' }
}
},
{ $sort: { totalRevenue: -1 } }
])Tratando valores ausentes e nulos
Quando um campo referenciado em $sum ou $avg está ausente ou é nulo, o comportamento apresenta uma pequena diferença. $sum trata valores ausentes ou nulos como zero, portanto todos os documentos contribuem para a contagem. $avg e $min/$max ignoram completamente valores ausentes ou nulos; eles não participam do cálculo. Compreender essa diferença evita erros sutis nas suas consultas de análise.
// Consider documents where some lack a 'discount' field
// $sum: missing = 0, so it counts in the total
// $avg: missing fields are ignored, avg is over existing values only
db.orders.aggregate([
{
$group: {
_id: '$category',
totalDiscount: { $sum: '$discount' }, // missing = 0
avgDiscount: { $avg: '$discount' } // missing = ignored
}
}
])Exemplo prático: painel de vendas
Combinar $sum, $avg, $min e $max em um único estágio $group é um padrão comum para métricas de painéis. Um único fluxo de agregação pode retornar tudo o que é necessário para preencher um cartão de resumo: total de pedidos, receita, valor médio dos pedidos e intervalo dos tamanhos dos pedidos. Isso evita várias idas e vindas ao banco de dados.
db.orders.aggregate([
{ $match: { status: 'completed' } },
{
$group: {
_id: '$category',
totalOrders: { $sum: 1 },
totalRevenue: { $sum: '$amount' },
avgOrderValue: { $avg: '$amount' },
smallestOrder: { $min: '$amount' },
largestOrder: { $max: '$amount' }
}
},
{ $sort: { totalRevenue: -1 } },
{ $limit: 10 }
])Verificação rápida
Teste sua compreensão dos conceitos de MongoDB e bancos de dados NoSQL apresentados nesta lição.
Revisão da lição
Nesta lição, você aprendeu que: $sum totaliza valores e conta documentos (ausente = 0); $avg/$min/$max ignoram campos ausentes ou nulos; e esses acumuladores funcionam tanto em $group, entre documentos, quanto em $project, dentro de uma matriz. A seguir, exploraremos $push e $addToSet para criar matrizes dentro de grupos.
Aprenda JavaScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “$sum, $avg, $min, $max: agregação numérica” é grátis?
Sim — o texto completo de “$sum, $avg, $min, $max: agregação numérica” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.
O que vou aprender em “$sum, $avg, $min, $max: agregação numérica”?
Você calculará totais, médias e extremos dentro de $group e também usará esses acumuladores como operadores de expressão em $project. Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar MongoDB Academy?
Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “$sum, $avg, $min, $max: agregação numérica”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de MongoDB Academy?
Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- $sum, $avg, $min, $max: agregação numérica
- $push e $addToSet: criando matrizes em grupos
- Acumuladores $first, $last e $top/$bottom
- Funções de janela com $setWindowFields