MongoDB $mod

Dans MongoDB, le $mod l'opérateur de pipeline d'agrégation divise un nombre par un autre et renvoie le reste.

Pour utiliser $mod , passez les deux nombres dans un tableau. Le $mod divisera le premier nombre par le deuxième nombre et renverra le reste. En d'autres termes, le premier nombre est le dividende et le second est le diviseur.

Les arguments peuvent être n'importe quelle expression valide tant qu'ils se résolvent en nombres.

Exemple

Supposons que nous ayons une collection appelée data avec les documents suivants :

{ "_id" : 1, "a" : 10, "b" : 2 }
{ "_id" : 2, "a" : 10, "b" : 3 }
{ "_id" : 3, "a" : 10.5, "b" : 2 }

Nous pouvons utiliser le $mod opérateur dans un pipeline d'agrégation pour diviser le a champ par le b champ, et renvoie le reste :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Résultat :

{ "a" : 10, "b" : 2, "result" : 0 }
{ "a" : 10, "b" : 3, "result" : 1 }
{ "a" : 10.5, "b" : 2, "result" : 0.5 }

En d'autres termes, nous obtenons a module b .

Si nous voulons obtenir b module a , nous aurions besoin de les échanger.

Exemple :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$b", "$a" ] } } 
         }
   ]
)

Résultat :

{ "a" : 10, "b" : 2, "result" : 2 }
{ "a" : 10, "b" : 3, "result" : 3 }
{ "a" : 10.5, "b" : 2, "result" : 2 }

Nombres négatifs

Supposons que nous ajoutions les documents suivants à notre collection :

{ "_id" : 4, "a" : -10, "b" : 3 }
{ "_id" : 5, "a" : 10, "b" : -3 }
{ "_id" : 6, "a" : -10, "b" : -3 }

Ceux-ci incluent les nombres négatifs. Mais ce n'est pas un problème, car les nombres négatifs sont toujours des nombres, et nous pouvons certainement obtenir le modulo lorsque nous travaillons avec des nombres négatifs.

Exemple :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 4, 5, 6 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Résultat :

{ "a" : -10, "b" : 3, "result" : -1 }
{ "a" : 10, "b" : -3, "result" : 1 }
{ "a" : -10, "b" : -3, "result" : -1 }

Type de données incorrect

Les arguments fournis à $mod peut être n'importe quelle expression valide, tant qu'elle se résout en nombres.

Supposons que nous ayons le document suivant :

{ "_id" : 7, "a" : "Ten", "b" : 2 }

Et on applique $mod à ce document :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Résultat :

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

L'erreur indique que $mod only supports numeric types .

Valeurs nulles

Fournir null pour l'un des arguments renvoie null .

Supposons que nous ayons les documents suivants :

{ "_id" : 8, "a" : 10, "b" : null }
{ "_id" : 9, "a" : null, "b" : 10 }
{ "_id" : 10, "a" : null, "b" : null }

Et on applique $mod à ces documents :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Résultat :

{ "a" : 10, "b" : null, "result" : null }
{ "a" : null, "b" : 10, "result" : null }
{ "a" : null, "b" : null, "result" : null }

Champs manquants

Les champs manquants renvoient null .

Supposons que nous ayons les documents suivants :

{ "_id" : 11, "a" : 10 }
{ "_id" : 12, "b" : 2 }
{ "_id" : 13 }

Appliquer $mod :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 11, 12, 13 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", "$b" ] } } 
         }
   ]
)

Résultat :

{ "a" : 10, "result" : null }
{ "b" : 2, "result" : null }
{ "result" : null }

Ajoutez votre propre numéro

Vous n'êtes pas nécessairement limité aux seuls numéros dans le ou les documents. Vous pouvez utiliser vos propres nombres si vous devez diviser un champ par un montant fixe.

Exemple :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $mod: [ "$a", 5.2 ] } } 
         }
   ]
)

Résultat :

{ "a" : 10, "b" : 2, "result" : 4.8 }
{ "a" : 10, "b" : 3, "result" : 4.8 }
{ "a" : 10.5, "b" : 2, "result" : 0.09999999999999964 }