In MongoDB ist der $min Der Aggregations-Pipeline-Operator gibt den Mindestwert eines Ausdrucks zurück.
Syntax
Der $min Operator unterstützt zwei Syntaxen.
Syntax 1:
{ $min: <expression> } Syntax 2:
{ $min: [ <expression1>, <expression2> ... ] } Die erste Syntax akzeptiert ein Argument und die zweite Syntax akzeptiert mehrere Argumente.
Bei Verwendung in $group Phase können Sie nur die erste Syntax verwenden. In diesem Fall $min gibt den Mindestwert zurück, der sich aus der Anwendung eines Ausdrucks auf jedes Dokument in einer Gruppe von Dokumenten ergibt, die denselben Group-by-Schlüssel verwenden.
Beispiele für Syntax 1 (Einzelargument)
Hier sind ein paar Beispiele, die die Syntax mit einem einzigen Argument verwenden.
Gruppierte Dokumente
Dieses Beispiel verwendet $min in Verbindung mit $group um den Mindestwert aus einer Gruppe von Dokumenten zurückzugeben, die nach Schlüsseln gruppiert sind.
Angenommen, wir haben eine Sammlung namens pets mit folgenden Dokumenten:
{ "_id" :1, "name" :"Wag", "type" :"Hund", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :„Hund“, „Gewicht“ :10 }{ „_id“ :3, „Name“ :„Miau“, „Typ“ :„Katze“, „Gewicht“ :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“, „Gewicht“ :200 }{ „_id“ :8, „Name“ :„Snap“, „Typ“ :„Katze“, „Gewicht“ :12 }{ „_id“ :9, „Name“ :„Ruff“, „Typ“ :„Hund“, „Gewicht“ :30 }
Wir können diese Dokumente nach ihrem type gruppieren Feld und verwenden Sie dann $min um den Mindestwert des weight zurückzugeben Feld für jede Gruppe:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$weight" }
}
}
]
) Ergebnis:
{ "_id" :"Känguru", "min" :100 }{ "_id" :"Hund", "min" :10 }{ "_id" :"Katze", "min" :7 } Arrays
Dieses Beispiel wendet $min an zu einem einzelnen Dokument, das ein Feld mit einem Array von Werten enthält.
Diese Option ist nur verfügbar, wenn die Syntax mit einem einzigen Argument verwendet wird. Arrays werden ignoriert, wenn die Syntax mit mehreren Argumenten verwendet wird (mehr dazu weiter unten).
Angenommen, wir haben eine Sammlung namens players mit folgenden Dokumenten:
{ "_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“ }
Wir können $min anwenden zu den scores Feld in jedem Dokument:
db.players.aggregate(
[
{
$project:
{
player: 1,
min: { $min: "$scores" }
}
}
]
)
Ergebnis:
{ "_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 diesem Fall haben die ersten vier Dokumente den Mindestwert aus den verschiedenen Zahlen zurückgegeben, die sich in ihren jeweiligen Arrays befanden.
Im Fall von Dokument 4 war dies dasselbe wie die Zahl, da es nur eine Zahl im Array gab.
Dokument 5 hat null zurückgegeben weil wir ein leeres Array bereitgestellt haben.
Dokument 6 hat null zurückgegeben weil wir null bereitgestellt haben als Argument.
Dokument 7 hat null zurückgegeben weil das Feld gar nicht existierte.
Beispiel für Syntax 2 (mehrere Argumente)
Die zweite Syntax beinhaltet die Bereitstellung von $min mit mehr als einem Argument. $min gibt dann den Mindestwert aus allen angegebenen Argumenten zurück.
Angenommen, wir haben eine Sammlung namens data mit folgendem Dokument:
{ "_id" :1, "a" :10, "b" :500, "c" :-900, "d" :4 }
Wir können $min verwenden um den Minimalwert von a zurückzugeben , b , c , und d Felder:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Ergebnis:
{ "_id" :1, "min" :-900 }
In diesem Fall -900 war der Mindestwert.
Fehlende Felder
Bei Verwendung der Syntax mit mehreren Argumenten $min ignoriert alle fehlenden Felder. Das heißt, wenn Sie ein Feld angeben, das nicht vorhanden ist, wird es ignoriert. Wenn keines der Felder vorhanden ist, wird null zurückgegeben .
Beispiel:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)
Ergebnis:
{ "_id" :1, "min" :-900 }
In diesem Fall habe ich ein zusätzliches Feld bereitgestellt ($e ), die im Dokument nicht vorhanden ist. $min Berechnet den Mindestwert basierend auf den verbleibenden Feldern, die tun existieren.
Folgendes passiert jedoch, wenn keine der Felder existieren:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
result: { $min: [ "$x", "$y", "$z" ] }
}
}
]
)
Ergebnis:
{ "_id" :1, "Ergebnis" :null }
Das Ergebnis ist null .
Wie wir bereits gesehen haben, führt ein fehlendes Feld bei Verwendung der Ein-Argument-Syntax zu null .
Beispiel:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$oops!" }
}
}
]
)
Ergebnis:
{ "_id" :"Hund", "min" :null }{ "_id" :"Katze", "min" :null }{ "_id" :"Känguru", "min" :null } Vergleich verschiedener Typen
Der $min -Operator vergleicht sowohl den Wert als auch den Typ. Wenn die Werte unterschiedlichen Typs sind, $min berechnet den Mindestwert basierend auf der BSON-Vergleichsreihenfolge.
Angenommen, unsere Sammlung enthält die folgenden Dokumente:
{ "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 0 ] }{ "_id" :3, "a" :1, " b“ :2, „c“ :3, „d“ :„0“ }{ „_id“ :4, „a“ :„Eins“, „b“ :„Zwei“, „c“ :„Drei“, "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"}
Mit Ausnahme von Dokument 4 verwendet jedes dieser Dokumente gemischte Typen (es gibt mindestens einen Typ, der sich von den anderen Datenfeldern unterscheidet). Dokument 4 verwendet Strings in allen vier Feldern.
Folgendes passiert, wenn wir $min anwenden zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
Ergebnis:
{ "_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" }
In Bezug auf das Dokument mit einer _id von 2 , Zahlen sind kleiner als Arrays, also die Zahl 1 zurückgegeben wird (obwohl das Array eine Zahl enthält, die kleiner als alle anderen Zahlen ist).
Dokument 3:Zahlen sind kleiner als Zeichenketten, daher wird die niedrigste Zahl zurückgegeben.
Dokument 4:Alle Felder sind Strings, also Four ist die Mindestzeichenfolge.
Dokument 5:Es werden zwei Daten bereitgestellt, daher wird das frühere Datum zurückgegeben.
Dokument 6:In diesem Fall werden ein Datumsobjekt und ein Datumsstring bereitgestellt. Strings sind kleiner als Date-Objekte, und daher wird der String zurückgegeben (obwohl sein Datum nach dem des Date-Objekts liegt).
Verfügbare Stufen
$min ist in den folgenden Stufen verfügbar:
$group$project$addFields$set$replaceRoot$replaceWith$matchStufe, die einen$exprenthält Ausdruck
