Dans MongoDB, le $min l'opérateur de pipeline d'agrégation renvoie la valeur minimale d'une expression.
Syntaxe
Le $min L'opérateur prend en charge deux syntaxes.
Syntaxe 1 :
{ $min: <expression> } Syntaxe 2 :
{ $min: [ <expression1>, <expression2> ... ] } La première syntaxe accepte un argument et la deuxième syntaxe accepte plusieurs arguments.
Lorsqu'il est utilisé dans le $group étape, vous ne pouvez utiliser que la première syntaxe. Dans ce cas, $min renvoie la valeur minimale résultant de l'application d'une expression à chaque document d'un groupe de documents partageant le même groupe par clé.
Exemples de syntaxe 1 (argument unique)
Voici quelques exemples qui utilisent la syntaxe à argument unique.
Documents groupés
Cet exemple utilise $min en conjonction avec $group pour renvoyer la valeur minimale d'un groupe de documents regroupés par clé.
Supposons que nous ayons une collection appelée pets avec les documents suivants :
{ "_id" :1, "name" :"Wag", "type" :"Chien", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Chien", "poids" :10 }{ "_id" :3, "nom" :"Miaou", "type" :"Chat", "poids" :7 }{ "_id" :4, "nom" :"Scratch", "type" :"Chat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Kangaroo", "weight" :100 }{ " _id" :6, "name" :"Hop", "type" :"Kangaroo", "weight" :130 }{ "_id" :7, "name" :"Punch", "type" :"Kangaroo", "weight" :200 }{ "_id" :8, "name" :"Snap", "type" :"Cat", "weight" :12 }{ "_id" :9, "name" :"Ruff", "type" :"Chien", "poids" :30 }
Nous pouvons regrouper ces documents par leur type champ, puis utilisez $min pour retourner la valeur minimale du weight champ pour chaque groupe :
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$weight" }
}
}
]
) Résultat :
{ "_id" :"Kangourou", "min" :100 }{ "_id" :"Chien", "min" :10 }{ "_id" :"Chat", "min" :7 } Tableaux
Cet exemple applique $min à un seul document qui contient un champ avec un tableau de valeurs.
Cette option n'est disponible que lors de l'utilisation de la syntaxe à argument unique. Les tableaux sont ignorés lors de l'utilisation de la syntaxe multi-arguments (plus d'informations ci-dessous).
Supposons que nous ayons une collection appelée players avec les documents suivants :
{ "_id" :1, "player" :"Homer", "scores" :[ 1, 7, 2, 3, 8, 7, 1 ] }{ "_id" :2, "player" :" Marge", "scores" :[ 0, 1, 8, 17, 18, 8 ] }{ "_id" :3, "player" :"Bart", "scores" :[ 15, 11, 8, 0, 1 , 3 ] }{ "_id" :4, "player" :"Brian", "scores" :[ 7 ] }{ "_id" :5, "player" :"Farnsworth", "scores" :[ ] }{ "_id" :6, "player" :"Meg", "scores" :null }{ "_id" :7, "player" :"Ron" }
Nous pouvons appliquer $min aux scores champ dans chaque document :
db.players.aggregate(
[
{
$project:
{
player: 1,
min: { $min: "$scores" }
}
}
]
)
Résultat :
{ "_id" :1, "player" :"Homer", "min" :1 }{ "_id" :2, "player" :"Marge", "min" :0 }{ "_id" :3, "player" :"Bart", "min" :0 }{ "_id" :4, "player" :"Brian", "min" :7 }{ "_id" :5, "player" :"Farnsworth ", "min" :null }{ "_id" :6, "player" :"Meg", "min" :null }{ "_id" :7, "player" :"Ron", "min" :null }
Dans ce cas, les quatre premiers documents ont renvoyé la valeur minimale des différents nombres qui se trouvaient dans leurs tableaux respectifs.
Dans le cas du document 4, c'était le même que le nombre, car il n'y avait qu'un seul nombre dans le tableau.
Le document 5 a renvoyé null car nous avons fourni un tableau vide.
Le document 6 a renvoyé null car nous avons fourni null comme argument.
Le document 7 a renvoyé null car le champ n'existait même pas.
Exemple de syntaxe 2 (arguments multiples)
La deuxième syntaxe consiste à fournir $min avec plus d'un argument. $min renvoie ensuite la valeur minimale de tous les arguments fournis.
Supposons que nous ayons une collection appelée data avec le document suivant :
{ "_id" :1, "a" :10, "b" :500, "c" :-900, "d" :4 }
Nous pouvons utiliser $min pour renvoyer la valeur minimale du a , b , c , et d champs :
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Résultat :
{ "_id" :1, "min" :-900 }
Dans ce cas, -900 était la valeur minimale.
Champs manquants
Lors de l'utilisation de la syntaxe multi-arguments, $min ignore les champs manquants. Autrement dit, si vous fournissez un champ qui n'existe pas, il l'ignore. Si aucun des champs n'existe, alors il renvoie null .
Exemple :
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)
Résultat :
{ "_id" :1, "min" :-900 }
Dans ce cas, j'ai fourni un champ supplémentaire ($e ) qui n'existe pas dans le document. $min calculé la valeur minimale en fonction des champs restants qui font existent.
Cependant, voici ce qui se passe lorsque aucun des champs existent :
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
result: { $min: [ "$x", "$y", "$z" ] }
}
}
]
)
Résultat :
{ "_id" :1, "result" :null }
Le résultat est null .
Comme nous l'avons vu précédemment, lors de l'utilisation de la syntaxe à argument unique, un champ manquant entraîne null .
Exemple :
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$oops!" }
}
}
]
)
Résultat :
{ "_id" :"Chien", "min" :null }{ "_id" :"Chat", "min" :null }{ "_id" :"Kangourou", "min" :null } Comparer différents types
Le $min L'opérateur compare à la fois la valeur et le type. Lorsque les valeurs sont de types différents, $min calcule la valeur minimale en fonction de l'ordre de comparaison BSON.
Supposons que notre collection contienne les documents suivants :
{ "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 0 ] }{ "_id" :3, "a" :1, " b" :2, "c" :3, "d" :"0" }{ "_id" :4, "a" :"Un", "b" :"Deux", "c" :"Trois", "d" :"Quatre" }{ "_id" :5, "a" :ISODate("1999-01-03T23:30:15.100Z"), "b" :ISODate("2000-01-03T23:30:15.100Z")}{ "_id" :6, "a" :ISODate("1999-01-03T23:30:15.100Z"), "b" :"2000-01-03T23:30:15.100Z"}
À l'exception du document 4, chacun de ces documents utilise des types mixtes (il existe au moins un type différent des autres dans les champs de données). Le document 4 utilise des chaînes dans les quatre champs.
Voici ce qui se passe lorsque nous appliquons $min à ces documents :
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Résultat :
{ "_id" :2, "min" :1 }{ "_id" :3, "min" :1 }{ "_id" :4, "min" :"Quatre" }{ "_id" :5 , "min" :ISODate("1999-01-03T23:30:15.100Z") }{ "_id" :6, "min" :"2000-01-03T23:30:15.100Z" }
Concernant le document avec un _id de 2 , les nombres sont inférieurs aux tableaux, donc le nombre 1 est renvoyé (même si le tableau contient un nombre inférieur à tous les autres nombres).
Document 3 :les nombres sont inférieurs aux chaînes, et le nombre le plus bas est donc renvoyé.
Document 4 :Tous les champs sont des chaînes, et donc Four est la chaîne minimale.
Document 5 :Deux dates sont fournies, la date la plus ancienne est donc renvoyée.
Document 6 :Dans ce cas, un objet Date et une chaîne de date sont fournis. Les chaînes sont inférieures aux objets Date, et la chaîne est donc renvoyée (même si sa date est postérieure à celle de l'objet Date).
Étapes disponibles
$min est disponible dans les étapes suivantes :
$group$project$addFields$set$replaceRoot$replaceWith$matchétape qui inclut un$exprexpression
