W MongoDB $min Operator potoku agregacji zwraca minimalną wartość z wyrażenia.
Składnia
$min operator obsługuje dwie składnie.
Składnia 1:
{ $min: <expression> }Składnia 2:
{ $min: [ <expression1>, <expression2> ... ] }Pierwsza składnia akceptuje jeden argument, a druga – wiele argumentów.
W przypadku użycia w grupie $group etapie, możesz użyć tylko pierwszej składni. W tym przypadku $min zwraca minimalną wartość wynikającą z zastosowania wyrażenia do każdego dokumentu w grupie dokumentów, które współdzielą tę samą grupę według klucza.
Przykłady składni 1 (pojedynczy argument)
Oto kilka przykładów, w których zastosowano składnię jednoargumentową.
Dokumenty zgrupowane
W tym przykładzie użyto $min w połączeniu z $group aby zwrócić minimalną wartość z grupy dokumentów pogrupowanych według klucza.
Załóżmy, że mamy kolekcję o nazwie pets z następującymi dokumentami:
{ "_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 }
Możemy pogrupować te dokumenty według ich type pole, a następnie użyj $min aby zwrócić minimalną wartość weight pole dla każdej grupy:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$weight" }
}
}
]
)Wynik:
{ "_id" : "Kangaroo", "min" : 100 }
{ "_id" : "Dog", "min" : 10 }
{ "_id" : "Cat", "min" : 7 } Tablice
Ten przykład dotyczy $min do pojedynczego dokumentu, który zawiera pole z tablicą wartości.
Ta opcja jest dostępna tylko w przypadku używania składni jednoargumentowej. Tablice są ignorowane podczas używania składni wieloargumentowej (więcej na ten temat poniżej).
Załóżmy, że mamy kolekcję o nazwie players z następującymi dokumentami:
{ "_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" }
Możemy zastosować $min do scores pole w każdym dokumencie:
db.players.aggregate(
[
{
$project:
{
player: 1,
min: { $min: "$scores" }
}
}
]
)Wynik:
{ "_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 } W tym przypadku pierwsze cztery dokumenty zwróciły minimalną wartość z różnych liczb, które znajdowały się w ich odpowiednich tablicach.
W przypadku dokumentu 4 było to to samo co liczba, ponieważ w tablicy była tylko jedna liczba.
Dokument 5 zwrócił null ponieważ dostarczyliśmy pustą tablicę.
Dokument 6 zwrócił null ponieważ podaliśmy null jako argument.
Dokument 7 zwrócił null ponieważ pole nawet nie istniało.
Przykład składni 2 (wiele argumentów)
Druga składnia obejmuje podanie $min z więcej niż jednym argumentem. $min następnie zwraca minimalną wartość ze wszystkich dostarczonych argumentów.
Załóżmy, że mamy kolekcję o nazwie data z następującym dokumentem:
{ "_id" : 1, "a" : 10, "b" : 500, "c" : -900, "d" : 4 }
Możemy użyć $min aby zwrócić minimalną wartość z a , b , c i d pola:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Wynik:
{ "_id" : 1, "min" : -900 }
W tym przypadku -900 była wartością minimalną.
Brakujące pola
Używając składni wieloargumentowej, $min ignoruje brakujące pola. Oznacza to, że jeśli podasz pole, które nie istnieje, ignoruje je. Jeśli żadne z pól nie istnieje, zwraca null .
Przykład:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Wynik:
{ "_id" : 1, "min" : -900 }
W tym przypadku dodałem dodatkowe pole ($e ), który nie istnieje w dokumencie. $min obliczył minimalną wartość na podstawie pozostałych pól, które wykonaj istnieje.
Oto jednak, co się dzieje, gdy brak z pól istnieje:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
result: { $min: [ "$x", "$y", "$z" ] }
}
}
]
)Wynik:
{ "_id" : 1, "result" : null }
Wynik to null .
Jak widzieliśmy wcześniej, podczas korzystania ze składni jednoargumentowej brakujące pole daje w wyniku null .
Przykład:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$oops!" }
}
}
]
)Wynik:
{ "_id" : "Dog", "min" : null }
{ "_id" : "Cat", "min" : null }
{ "_id" : "Kangaroo", "min" : null } Porównywanie różnych typów
$min operator porównuje zarówno wartość, jak i typ. Gdy wartości są różnych typów, $min oblicza minimalną wartość na podstawie kolejności porównania BSON.
Załóżmy, że nasza kolekcja zawiera następujące dokumenty:
{ "_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"
} Z wyjątkiem dokumentu 4, każdy z tych dokumentów używa typów mieszanych (istnieje co najmniej jeden typ, który różni się od pozostałych w polach danych). Dokument 4 używa ciągów znaków we wszystkich czterech polach.
Oto, co się dzieje, gdy zastosujemy $min do tych dokumentów:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Wynik:
{ "_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" }
Odnośnie dokumentu z _id z 2 , liczby są mniejsze niż tablice, więc liczba 1 jest zwracana (nawet jeśli tablica zawiera liczbę mniejszą niż wszystkie inne liczby).
Dokument 3:Liczby są mniejsze niż ciągi, dlatego zwracana jest najniższa liczba.
Dokument 4:Wszystkie pola są ciągami, więc Four jest ciągiem minimalnym.
Dokument 5:Podano dwie daty, więc zwracana jest wcześniejsza data.
Dokument 6:W tym przypadku dostarczany jest obiekt Date i ciąg daty. Ciągi są mniejsze niż obiekty Date, więc ciąg jest zwracany (nawet jeśli jego data jest późniejsza niż data obiektu Date).
Dostępne etapy
$min jest dostępny w następujących etapach:
$group$project$addFields$set$replaceRoot$replaceWith$matchetap zawierający$exprwyrażenie
