In MongoDB is de $max aggregatiepijplijnoperator retourneert de maximale waarde van een uitdrukking.
Syntaxis
De $max operator ondersteunt twee syntaxis.
Syntaxis 1:
{ $max: <expression> }Syntaxis 2:
{ $max: [ <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 $max geeft de maximale waarde 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 $max in combinatie met $group om de maximale waarde terug te geven 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 $max om de maximale waarde van het weight terug te geven veld voor elke groep:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
max: { $max: "$weight" }
}
}
]
)Resultaat:
{ "_id" : "Kangaroo", "max" : 200 }
{ "_id" : "Cat", "max" : 12 }
{ "_id" : "Dog", "max" : 30 } Arrays
Dit voorbeeld is van toepassing op $max 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 $max apply toepassen naar de scores veld in elk document:
db.players.aggregate(
[
{
$project:
{
player: 1,
max: { $max: "$scores" }
}
}
]
)Resultaat:
{ "_id" : 1, "player" : "Homer", "max" : 8 }
{ "_id" : 2, "player" : "Marge", "max" : 18 }
{ "_id" : 3, "player" : "Bart", "max" : 15 }
{ "_id" : 4, "player" : "Brian", "max" : 7 }
{ "_id" : 5, "player" : "Farnsworth", "max" : null }
{ "_id" : 6, "player" : "Meg", "max" : null }
{ "_id" : 7, "player" : "Ron", "max" : null } In dit geval gaven de eerste vier documenten de maximale waarde 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 $max met meer dan één argument. $max retourneert vervolgens de maximale waarde 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 $max . gebruiken om de maximale waarde terug te geven van de a , b , c , en d velden:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
max: { $max: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "max" : 500 }
In dit geval 500 was de maximale waarde.
Ontbrekende velden
Bij gebruik van de syntaxis met meerdere argumenten, $max 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:
{
max: { $max: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "max" : 500 }
In dit geval heb ik een extra veld ($e ) die niet in het document voorkomt. $max berekende de maximale waarde 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: { $max: [ "$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",
max: { $max: "$oops!" }
}
}
]
)Resultaat:
{ "_id" : "Dog", "max" : null }
{ "_id" : "Kangaroo", "max" : null }
{ "_id" : "Cat", "max" : null } Verschillende soorten vergelijken
De $max operator vergelijkt zowel waarde als type. Als de waarden van verschillende typen zijn, $max berekent de maximale waarde op basis van de BSON-vergelijkingsvolgorde.
Stel dat onze collectie de volgende documenten bevat:
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 1 ] }
{ "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "1" }
{ "_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 $max toepassen naar die documenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
max: { $max: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultaat:
{ "_id" : 2, "max" : [ 1 ] }
{ "_id" : 3, "max" : "1" }
{ "_id" : 4, "max" : "Two" }
{ "_id" : 5, "max" : ISODate("2000-01-03T23:30:15.100Z") }
{ "_id" : 6, "max" : ISODate("1999-01-03T23:30:15.100Z") }
het document met een _id van 2 , arrays zijn groter dan getallen, dus de array wordt geretourneerd (ook al is het element een getal dat kleiner is dan sommige van de andere getallen).
Document 3:Strings zijn groter dan getallen, en dus wordt de string geretourneerd.
Document 4:Alle velden zijn strings, dus Two is de grootste reeks.
Document 5:Er worden twee datums opgegeven, dus de latere datum wordt teruggegeven.
Document 6:In dit geval wordt een Date-object en een date-string aangeleverd. Date-objecten zijn groter dan strings, en dus wordt het Date-object geretourneerd (ook al is de datum eerder dan die van de string).
Beschikbare stadia
$max is beschikbaar in de volgende fasen:
$group$project$addFields$set$replaceRoot$replaceWith$matchfase met een$expruitdrukking