MongoDB
Revisa expresiones de aggregation para operar números, strings, fechas, arrays, objetos, condicionales y conversiones dentro de stages.
Aggregation expressions calculan valores dentro de stages. Reciben constantes, rutas de campos, variables y otras expressions, y producen un valor por documento o grupo.
{
$set: {
subtotal: {
$multiply: ['$quantity', '$unitPrice']
}
}
}El prefijo $ distingue rutas como '$price' de strings literales. Las variables utilizan $$, por ejemplo $$NOW o $$item.
Las expressions permiten transformar datos donde están almacenados, sin descargar documentos para realizar cálculos repetitivos en la aplicación. Cubren:
Su poder también puede producir pipelines densas y difíciles de verificar. La claridad es una restricción de diseño.
'price' // string literal
'$price' // valor del campo price
'$$NOW' // variable del sistema
'$$item' // variable definida por una expressionPara tratar un valor que comienza con $ como literal, puede necesitarse $literal:
{ $literal: '$100' }{
$set: {
stockStatus: {
$cond: [
{ $lte: ['$stock', '$minimumStock'] },
'low',
'ok'
]
}
}
}La condición debe producir boolean. Ambos caminos deben tener tipos compatibles con el contrato esperado.
Para múltiples ramas:
{
$set: {
priority: {
$switch: {
branches: [
{
case: { $gte: ['$total', Decimal128('500000.00')] },
then: 'high'
},
{
case: { $gte: ['$total', Decimal128('100000.00')] },
then: 'medium'
}
],
default: 'normal'
}
}
}
}El orden de ramas importa. Coloca condiciones más específicas antes de generales.
{
$set: {
displayName: {
$ifNull: ['$name', 'Sin nombre']
}
}
}$ifNull puede tratar null y missing como ausencia. Eso es útil para presentación, pero puede ocultar schema drift. Para una auditoría, conserva información del tipo:
{
$set: {
nameType: { $type: '$name' }
}
}{
$convert: {
input: '$price',
to: 'decimal',
onError: null,
onNull: null
}
}Permite manejar errores sin detener toda la pipeline.
Existen expresiones como $toString, $toDate, $toObjectId y $toDecimal. Suelen fallar si la conversión no es válida, por lo que $convert es preferible en auditorías de datos inconsistentes.
No conviertas un valor inválido a cero: mezclaría errores con datos reales.
{
subtotal: {
$multiply: ['$quantity', '$unitPrice']
},
remaining: {
$subtract: ['$stock', '$reserved']
}
}Para dinero, utiliza tipos consistentes como Decimal128 o unidades menores enteras. Una constante double dentro de una expression puede cambiar precisión:
{ $multiply: ['$total', 0.19] }Es más deliberado usar un decimal compatible cuando el campo es decimal.
{
ratio: {
$cond: [
{ $ne: ['$denominator', 0] },
{ $divide: ['$numerator', '$denominator'] },
null
]
}
}Protege división por cero y tipos missing.
{
fullName: {
$concat: ['$firstName', ' ', '$lastName']
}
}Si un valor es null, el resultado puede ser null. Usa defaults explícitos si corresponde.
Expressions permiten case conversion, trim y reemplazos. No sustituyen una estrategia de collation o search. Normalizar en cada query puede impedir índices y aumentar coste.
{
day: {
$dateTrunc: {
date: '$createdAt',
unit: 'day',
timezone: 'America/Bogota'
}
}
}También existen extracción, suma, diferencia, formato y parsing según versión.
Decisiones necesarias:
Transforma cada elemento y conserva la estructura array:
{
$set: {
items: {
$map: {
input: '$items',
as: 'item',
in: {
productId: '$$item.productId',
quantity: '$$item.quantity',
subtotal: {
$multiply: ['$$item.quantity', '$$item.unitPrice']
}
}
}
}
}
}Es preferible a unwind + group cuando solo necesitas transformar cada elemento dentro del documento.
{
$set: {
pendingItems: {
$filter: {
input: '$items',
as: 'item',
cond: { $eq: ['$$item.status', 'pending'] }
}
}
}
}Conserva elementos que cumplen la condición. Debes manejar input null o no array.
Acumula un array en un valor:
{
$set: {
total: {
$reduce: {
input: '$items',
initialValue: Decimal128('0'),
in: {
$add: [
'$$value',
{
$multiply: ['$$this.quantity', '$$this.unitPrice']
}
]
}
}
}
}
}$$value es el acumulado y $$this el elemento actual.
Una expression muy compleja puede ser menos legible que $unwind + $group. Elige según salida, cardinalidad y mantenimiento.
Nombra variables locales:
{
$set: {
totalWithTax: {
$let: {
vars: {
subtotal: { $sum: '$items.subtotal' },
taxRate: Decimal128('0.19')
},
in: {
$add: [
'$$subtotal',
{ $multiply: ['$$subtotal', '$$taxRate'] }
]
}
}
}
}
}Mejora claridad y evita repetir cálculos, aunque no sustituye dividir stages cuando la lógica es extensa.
Expressions como $getField, $setField, $objectToArray y $arrayToObject permiten trabajar con keys dinámicas según versión.
Schemas con nombres de campos dinámicos pueden ser difíciles de indexar y validar. No utilices estas expressions para justificar un modelo arbitrario sin access patterns claros.
Arrays pueden tratarse como conjuntos con operaciones de unión, intersección o diferencia. La igualdad sigue semántica BSON y el orden del resultado no debe asumirse salvo documentación específica.
$expr permite usar expressions como condición:
{
$match: {
$expr: {
$gt: ['$total', '$creditLimit']
}
}
}El uso de índices depende de la expresión, comparación, constantes y versión. Un filtro simple suele ser más indexable.
Ejemplos:
$$NOW: instante consistente de evaluación para la operación;$$ROOT: documento completo actual;$$CURRENT: contexto actual;$$REMOVE: omite un campo en projection;$$NOW no reemplaza una fecha de negocio almacenada cuando el evento ocurrió antes.
Pipeline difícil:
{
$set: {
result: {
$cond: [/* expression profundamente anidada */]
}
}
}Mejor:
Cada stage debe poder probarse con documentos de ejemplo.
Expressions se ejecutan para los documentos que llegan al stage. Una operación costosa antes de $match se repite innecesariamente.
Evita:
$map, $filter y $reduce requieren semántica compatible.
Puede propagar null.
Puede detener la pipeline sin onError.
Afectan precisión.
Cambia agrupaciones.
Reduce devuelve initialValue; map/filter devuelven array vacío.
Una ruta inexistente no equivale siempre a null explícito.
Difícil de verificar.
Las métricas parecen válidas.
Pierde precisión.
Consume CPU y memoria.
Multiplica coste.
Falla en clusters antiguos.
Expressions son funciones puras sobre valores BSON dentro de la pipeline. La precisión depende de tipos, null, timezone y contexto. $map, $filter, $reduce, $let, conversiones y condiciones permiten modelar transformaciones potentes, pero deben mantenerse legibles y verificables.
'$price' y 'price'?$convert en vez de $toDecimal?$map, $filter y $reduce?Índices.