In MongoDB is de $min aggregatiepijplijnoperator retourneert de minimumwaarde van een uitdrukking.
Syntaxis
De $min operator ondersteunt twee syntaxis.
Syntaxis 1:
{ $min: <expression> }Syntaxis 2:
{ $min: [ <expression1>, <expression2> ... ] }De eerste syntaxis accepteert één argument en de tweede syntaxis accepteert meerdere argumenten.
Bij gebruik in de $group stadium, kunt u alleen de eerste syntaxis gebruiken. In dit geval $min geeft de minimumwaarde terug die het resultaat is van het toepassen van een uitdrukking op elk document in een groep documenten die dezelfde groep op sleutel delen.
Voorbeelden van syntaxis 1 (enkel argument)
Hier zijn een paar voorbeelden die de syntaxis van één argument gebruiken.
Gegroepeerde documenten
Dit voorbeeld gebruikt $min in combinatie met $group om de minimumwaarde te retourneren van een groep documenten die op sleutel zijn gegroepeerd.
Stel dat we een verzameling hebben met de naam pets met de volgende documenten:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "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" : "Dog", "weight" : 30 }
We kunnen deze documenten groeperen op hun type veld, en gebruik dan $min om de minimumwaarde van het weight terug te geven veld voor elke groep:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$weight" }
}
}
]
)Resultaat:
{ "_id" : "Kangaroo", "min" : 100 }
{ "_id" : "Dog", "min" : 10 }
{ "_id" : "Cat", "min" : 7 } Arrays
Dit voorbeeld is van toepassing op $min naar een enkel document dat een veld met een reeks waarden bevat.
Deze optie is alleen beschikbaar bij gebruik van de syntaxis voor één argument. Arrays worden genegeerd bij gebruik van de syntaxis met meerdere argumenten (meer hierover hieronder).
Stel dat we een verzameling hebben met de naam players met de volgende documenten:
{ "_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" }
We kunnen $min apply toepassen naar de scores veld in elk document:
db.players.aggregate(
[
{
$project:
{
player: 1,
min: { $min: "$scores" }
}
}
]
)Resultaat:
{ "_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 } In dit geval gaven de eerste vier documenten de minimumwaarde terug van de verschillende getallen die in hun respectievelijke arrays stonden.
In het geval van document 4 was dit hetzelfde als het nummer, omdat er maar één nummer in de array was.
Document 5 retourneerde null omdat we een lege array hebben opgegeven.
Document 6 retourneerde null omdat we null . hebben opgegeven als het argument.
Document 7 retourneerde null omdat het veld niet eens bestond.
Voorbeeld van syntaxis 2 (meerdere argumenten)
De tweede syntaxis omvat het verstrekken van $min met meer dan één argument. $min retourneert vervolgens de minimumwaarde van alle opgegeven argumenten.
Stel dat we een verzameling hebben met de naam data met het volgende document:
{ "_id" : 1, "a" : 10, "b" : 500, "c" : -900, "d" : 4 }
We kunnen $min . gebruiken om de minimumwaarde van de a . te retourneren , b , c , en d velden:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "min" : -900 }
In dit geval -900 was de minimumwaarde.
Ontbrekende velden
Bij gebruik van de syntaxis met meerdere argumenten, $min negeert eventuele ontbrekende velden. Dat wil zeggen, als u een veld opgeeft dat niet bestaat, wordt dit genegeerd. Als geen van de velden bestaat, retourneert het null .
Voorbeeld:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "min" : -900 }
In dit geval heb ik een extra veld ($e ) die niet in het document voorkomt. $min berekende de minimumwaarde op basis van de resterende velden die doen bestaan.
Dit is echter wat er gebeurt als geen van de velden bestaat:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
result: { $min: [ "$x", "$y", "$z" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "result" : null }
Het resultaat is null .
Zoals we eerder zagen, resulteert een ontbrekend veld bij gebruik van de syntaxis van één argument in null .
Voorbeeld:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$oops!" }
}
}
]
)Resultaat:
{ "_id" : "Dog", "min" : null }
{ "_id" : "Cat", "min" : null }
{ "_id" : "Kangaroo", "min" : null } Verschillende soorten vergelijken
De $min operator vergelijkt zowel waarde als type. Als de waarden van verschillende typen zijn, $min berekent de minimumwaarde op basis van de BSON-vergelijkingsvolgorde.
Stel dat onze collectie de volgende documenten bevat:
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 0 ] }
{ "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "0" }
{ "_id" : 4, "a" : "One", "b" : "Two", "c" : "Three", "d" : "Four" }
{
"_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"
} Met uitzondering van document 4, gebruikt elk van die documenten gemengde typen (er is ten minste één type dat verschilt van de andere in gegevensvelden). Document 4 gebruikt tekenreeksen in alle vier de velden.
Dit is wat er gebeurt als we $min toepassen naar die documenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultaat:
{ "_id" : 2, "min" : 1 }
{ "_id" : 3, "min" : 1 }
{ "_id" : 4, "min" : "Four" }
{ "_id" : 5, "min" : ISODate("1999-01-03T23:30:15.100Z") }
{ "_id" : 6, "min" : "2000-01-03T23:30:15.100Z" }
Betreffende het document met een _id van 2 , getallen zijn kleiner dan arrays, dus het getal 1 wordt geretourneerd (ook al bevat de array een getal dat kleiner is dan alle andere getallen).
Document 3:Getallen zijn kleiner dan strings, en dus wordt het laagste getal geretourneerd.
Document 4:Alle velden zijn strings, en dus Four is de minimale tekenreeks.
Document 5:Er worden twee datums opgegeven, dus de eerdere datum wordt geretourneerd.
Document 6:In dit geval wordt een Date-object en een date-string aangeleverd. Strings zijn kleiner dan Date-objecten, en dus wordt de string geretourneerd (ook al is de datum later dan die van het Date-object).
Beschikbare stadia
$min is beschikbaar in de volgende fasen:
$group$project$addFields$set$replaceRoot$replaceWith$matchfase met een$expruitdrukking