En MongoDB, el $mod
El operador de tubería de agregación divide un número por otro y devuelve el resto.
Para usar $mod
, pase los dos números en una matriz. El $mod
el operador dividirá el primer número por el segundo número y devolverá el resto. En otras palabras, el primer número es el dividendo y el segundo número es el divisor.
Los argumentos pueden ser cualquier expresión válida siempre que se resuelvan en números.
Ejemplo
Supongamos que tenemos una colección llamada data
con los siguientes documentos:
{ "_id" : 1, "a" : 10, "b" : 2 } { "_id" : 2, "a" : 10, "b" : 3 } { "_id" : 3, "a" : 10.5, "b" : 2 }
Podemos usar el $mod
operador dentro de una canalización de agregación para dividir el a
campo por el b
y devolver el resto:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$a", "$b" ] } }
}
]
)
Resultado:
{ "a" : 10, "b" : 2, "result" : 0 } { "a" : 10, "b" : 3, "result" : 1 } { "a" : 10.5, "b" : 2, "result" : 0.5 }
En otras palabras, obtenemos a
módulo b
.
Si queremos obtener b
módulo a
, tendríamos que intercambiarlos.
Ejemplo:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$b", "$a" ] } }
}
]
)
Resultado:
{ "a" : 10, "b" : 2, "result" : 2 } { "a" : 10, "b" : 3, "result" : 3 } { "a" : 10.5, "b" : 2, "result" : 2 }
Números negativos
Supongamos que agregamos los siguientes documentos a nuestra colección:
{ "_id" : 4, "a" : -10, "b" : 3 } { "_id" : 5, "a" : 10, "b" : -3 } { "_id" : 6, "a" : -10, "b" : -3 }
Estos incluyen números negativos. Pero eso no es un problema, porque los números negativos siguen siendo números, y ciertamente podemos obtener el módulo cuando trabajamos con números negativos.
Ejemplo:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 4, 5, 6 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$a", "$b" ] } }
}
]
)
Resultado:
{ "a" : -10, "b" : 3, "result" : -1 } { "a" : 10, "b" : -3, "result" : 1 } { "a" : -10, "b" : -3, "result" : -1 }
Tipo de datos incorrecto
Los argumentos proporcionados a $mod
puede ser cualquier expresión válida, siempre que se resuelva en números.
Supongamos que tenemos el siguiente documento:
{ "_id" : 7, "a" : "Ten", "b" : 2 }
Y aplicamos $mod
a ese documento:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 7 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$a", "$b" ] } }
}
]
)
Resultado:
uncaught exception: Error: command failed: { "ok" : 0, "errmsg" : "$mod only supports numeric types, not string and double", "code" : 16611, "codeName" : "Location16611" } : aggregate failed : [email protected]/mongo/shell/utils.js:25:13 [email protected]/mongo/shell/assert.js:18:14 [email protected]/mongo/shell/assert.js:639:17 [email protected]/mongo/shell/assert.js:729:16 [email protected]/mongo/shell/db.js:266:5 [email protected]/mongo/shell/collection.js:1058:12 @(shell):1:1
El error indica que $mod only supports numeric types
.
Valores nulos
Proporcionar null
para cualquiera de los argumentos devuelve null
.
Supongamos que tenemos los siguientes documentos:
{ "_id" : 8, "a" : 10, "b" : null } { "_id" : 9, "a" : null, "b" : 10 } { "_id" : 10, "a" : null, "b" : null }
Y aplicamos $mod
a esos documentos:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9, 10 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$a", "$b" ] } }
}
]
)
Resultado:
{ "a" : 10, "b" : null, "result" : null } { "a" : null, "b" : 10, "result" : null } { "a" : null, "b" : null, "result" : null }
Campos faltantes
Los campos faltantes devuelven null
.
Supongamos que tenemos los siguientes documentos:
{ "_id" : 11, "a" : 10 } { "_id" : 12, "b" : 2 } { "_id" : 13 }
Aplicar $mod
:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 11, 12, 13 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$a", "$b" ] } }
}
]
)
Resultado:
{ "a" : 10, "result" : null } { "b" : 2, "result" : null } { "result" : null }
Agregue su propio número
No está necesariamente restringido a solo los números en el/los documento/s. Puede usar sus propios números si necesita dividir un campo por una cantidad fija.
Ejemplo:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{ $project: {
_id: 0,
a: 1,
b: 1,
result: { $mod: [ "$a", 5.2 ] } }
}
]
)
Resultado:
{ "a" : 10, "b" : 2, "result" : 4.8 } { "a" : 10, "b" : 3, "result" : 4.8 } { "a" : 10.5, "b" : 2, "result" : 0.09999999999999964 }