MongoDB
Agrupa documentos por claves y calcula conteos, sumas, promedios, mínimos, máximos, conjuntos y arrays mediante $group y sus acumuladores.
reúne documentos que comparten una clave y produce un documento por grupo. Dentro del stage, los calculan sumas, conteos, promedios, mínimos, máximos, listas y otros resultados.
$group{
$group: {
_id: '$payment.method',
orderCount: { $sum: 1 },
revenue: { $sum: '$total' }
}
}_id dentro de $group no es necesariamente el _id original. Representa la clave de agrupación.
Sin $group, la aplicación tendría que transferir documentos y construir mapas en memoria. Agrupar en el servidor reduce datos devueltos y permite combinarlo con filtros, índices y otras transformaciones.
Ejemplo:
10.000 órdenes
→ agrupar por método de pago
→ 4 documentos de resultadoEl coste depende de la cantidad de documentos y de la cardinalidad de la clave.
_id: '$status'_id: {
day: '$day',
branchId: '$branchId'
}_id: nullAgrupa todos los documentos para un total global.
_id: {
$dateTrunc: {
date: '$confirmedAt',
unit: 'day',
timezone: 'America/Bogota'
}
}Conteo:
orderCount: { $sum: 1 }Suma de campo:
revenue: { $sum: '$total' }Suma condicional:
cancelledCount: {
$sum: {
$cond: [
{ $eq: ['$status', 'cancelled'] },
1,
0
]
}
}Los tipos numéricos importan. Mezclar Decimal128, double y strings puede producir resultados incorrectos o conversiones necesarias.
{
averageTicket: { $avg: '$total' },
smallestOrder: { $min: '$total' },
largestOrder: { $max: '$total' }
}Debes definir qué hacer con null, missing o tipos inválidos. Un promedio sin datos puede no producir el valor esperado por la API.
Estos acumuladores dependen del orden cuando quieres seleccionar el primero o último cronológico.
[
{ $sort: { productId: 1, changedAt: 1 } },
{
$group: {
_id: '$productId',
firstPrice: { $first: '$price' },
latestPrice: { $last: '$price' }
}
}
]Sin un $sort adecuado, “first” significa primero en el orden de entrada disponible, no necesariamente el más antiguo.
Acumula todos los valores, incluyendo duplicados:
orders: {
$push: {
id: '$_id',
total: '$total'
}
}Puede crear arrays enormes y acercar el documento resultado al límite de 16 MiB. No lo uses para reunir millones de elementos.
Acumula valores únicos según igualdad BSON:
customers: { $addToSet: '$customer.id' }El coste de memoria puede ser alto con cardinalidad grande. No garantiza orden.
Según versión, existen acumuladores para top/bottom, primeros o últimos N y otras operaciones. Confirma soporte del servidor y FCV antes de depender de ellos.
Aun con APIs nuevas, el modelo mental se mantiene: ordenar, particionar y limitar cardinalidad.
Agrupar por un campo de baja cardinalidad:
status → 4 gruposAgrupar por una clave casi única:
requestId → millones de gruposEl segundo caso puede consumir mucha memoria y producir un resultado tan grande como la entrada. Pregunta si realmente necesitas grouping o simplemente projection.
$group suele necesitar acumular estado antes de emitir resultados. Esto puede incrementar memoria y latencia inicial.
allowDiskUse puede ayudar según versión y configuración, pero no elimina el coste. Reduce input con $match y evita campos innecesarios.
db.orders.aggregate([
{
$match: {
businessId,
status: 'confirmed',
confirmedAt: { $gte: start, $lt: end }
}
},
{
$set: {
day: {
$dateTrunc: {
date: '$confirmedAt',
unit: 'day',
timezone: 'America/Bogota'
}
}
}
},
{
$group: {
_id: '$day',
orderCount: { $sum: 1 },
revenue: { $sum: '$total' },
averageTicket: { $avg: '$total' }
}
},
{ $sort: { _id: 1 } }
]);La zona horaria define los límites del día comercial. Agrupar en UTC podría mover ventas nocturnas al día incorrecto.
[
{ $match: { businessId, status: 'confirmed' } },
{ $unwind: '$items' },
{
$group: {
_id: '$items.productId',
units: { $sum: '$items.quantity' },
revenue: {
$sum: {
$multiply: [
'$items.quantity',
'$items.unitPrice'
]
}
}
}
},
{ $sort: { revenue: -1 } },
{ $limit: 10 }
]La cardinalidad antes del group es el total de líneas, no órdenes.
Si el mismo reporte se consulta constantemente sobre millones de documentos, recalcular puede ser costoso. Alternativas:
La precomputación introduce consistencia eventual y reconciliación.
En un sharded cluster, parte del grouping puede ejecutarse en shards y combinarse. El coste depende de shard key, distribución y si los datos relacionados están colocados.
Un group por campo no alineado con la shard key puede necesitar intercambio de datos entre nodos.
La pipeline puede devolver array vacío, no un grupo con ceros. La API debe decidir si agrega valores por defecto.
Documentos pueden agruparse juntos bajo null. Si eso es inválido, filtra o separa antes.
'cash' y un valor numérico crean grupos diferentes.
Mantén tipos monetarios coherentes.
Puede superar tamaño de resultado.
$first y $last no representan cronología.
Procesa demasiado.
Crea resultados gigantes.
Selecciona un valor arbitrario respecto al dominio.
Reportes diarios incorrectos.
No reduce cardinalidad.
Puede necesitar materialización.
$group transforma un conjunto en grupos y acumulados. Su coste depende de cardinalidad y estado mantenido. Filtrar temprano, ordenar antes de first/last, controlar arrays acumulados y respetar tipos y zonas horarias son requisitos para resultados confiables.
_id en $group?$first requiere sort?$push?$unwind.