In MongoDB, il $min l'operatore della pipeline di aggregazione restituisce il valore minimo da un'espressione.
Sintassi
Il $min operatore supporta due sintassi.
Sintassi 1:
{ $min: <expression> }Sintassi 2:
{ $min: [ <expression1>, <expression2> ... ] }La prima sintassi accetta un argomento e la seconda sintassi accetta più argomenti.
Se utilizzato nel $group stage, puoi usare solo la prima sintassi. In questo caso, $min restituisce il valore minimo risultante dall'applicazione di un'espressione a ciascun documento in un gruppo di documenti che condividono lo stesso gruppo per chiave.
Esempi di sintassi 1 (argomento singolo)
Ecco un paio di esempi che utilizzano la sintassi di argomento singolo.
Documenti raggruppati
Questo esempio utilizza $min insieme a $group per restituire il valore minimo da un gruppo di documenti raggruppati per chiave.
Supponiamo di avere una collezione chiamata pets con i seguenti documenti:
{ "_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 }
Possiamo raggruppare questi documenti in base al loro type campo, quindi utilizzare $min per restituire il valore minimo del weight campo per ogni gruppo:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$weight" }
}
}
]
)Risultato:
{ "_id" : "Kangaroo", "min" : 100 }
{ "_id" : "Dog", "min" : 10 }
{ "_id" : "Cat", "min" : 7 } Array
Questo esempio si applica a $min in un singolo documento che contiene un campo con una matrice di valori.
Questa opzione è disponibile solo quando si utilizza la sintassi di argomento singolo. Gli array vengono ignorati quando si utilizza la sintassi multi-argomento (ne parleremo più avanti).
Supponiamo di avere una collezione chiamata players con i seguenti documenti:
{ "_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" }
Possiamo applicare $min ai scores campo in ogni documento:
db.players.aggregate(
[
{
$project:
{
player: 1,
min: { $min: "$scores" }
}
}
]
)Risultato:
{ "_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 questo caso, i primi quattro documenti hanno restituito il valore minimo dai vari numeri che erano nei rispettivi array.
Nel caso del documento 4, questo era lo stesso del numero, perché c'era un solo numero nell'array.
Il documento 5 ha restituito null perché abbiamo fornito un array vuoto.
Il documento 6 ha restituito null perché abbiamo fornito null come argomento.
Il documento 7 ha restituito null perché il campo non esisteva nemmeno.
Esempio di sintassi 2 (argomenti multipli)
La seconda sintassi prevede di fornire $min con più di un argomento. $min quindi restituisce il valore minimo da tutti gli argomenti forniti.
Supponiamo di avere una raccolta chiamata data con il seguente documento:
{ "_id" : 1, "a" : 10, "b" : 500, "c" : -900, "d" : 4 }
Possiamo usare $min per restituire il valore minimo da a , b , c e d campi:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Risultato:
{ "_id" : 1, "min" : -900 }
In questo caso, -900 era il valore minimo.
Campi mancanti
Quando si utilizza la sintassi multi-argomento, $min ignora tutti i campi mancanti. Cioè, se fornisci un campo che non esiste, lo ignora. Se nessuno dei campi esiste, restituisce null .
Esempio:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Risultato:
{ "_id" : 1, "min" : -900 }
In questo caso ho fornito un campo aggiuntivo ($e ) che non esiste nel documento. $min calcolato il valore minimo in base ai campi rimanenti che fanno esistono.
Tuttavia, ecco cosa succede quando nessuno dei campi esistono:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
result: { $min: [ "$x", "$y", "$z" ] }
}
}
]
)Risultato:
{ "_id" : 1, "result" : null }
Il risultato è null .
Come abbiamo visto in precedenza, quando si utilizza la sintassi a argomento singolo, un campo mancante risulta null .
Esempio:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
min: { $min: "$oops!" }
}
}
]
)Risultato:
{ "_id" : "Dog", "min" : null }
{ "_id" : "Cat", "min" : null }
{ "_id" : "Kangaroo", "min" : null } Confronto di diversi tipi
Il $min l'operatore confronta sia il valore che il tipo. Quando i valori sono di tipo diverso, $min calcola il valore minimo in base all'ordine di confronto BSON.
Supponiamo che la nostra collezione contenga i seguenti documenti:
{ "_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"
} Ad eccezione del documento 4, ciascuno di questi documenti utilizza tipi misti (ne esiste almeno un tipo diverso dagli altri nei campi dati). Il documento 4 utilizza le stringhe in tutti e quattro i campi.
Ecco cosa succede quando applichiamo $min a quei documenti:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
min: { $min: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Risultato:
{ "_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" }
Riguardo al documento con un _id di 2 , i numeri sono minori degli array, quindi il numero 1 viene restituito (anche se l'array contiene un numero inferiore a tutti gli altri numeri).
Documento 3:i numeri sono minori delle stringhe, quindi viene restituito il numero più basso.
Documento 4:Tutti i campi sono stringhe, quindi Four è la stringa minima.
Documento 5:vengono fornite due date e quindi viene restituita la data precedente.
Documento 6:In questo caso vengono forniti un oggetto Date e una stringa di data. Le stringhe sono minori degli oggetti Date, quindi la stringa viene restituita (anche se la sua data è successiva a quella dell'oggetto Date).
Stadi disponibili
$min è disponibile nelle seguenti fasi:
$group$project$addFields$set$replaceRoot$replaceWith$matchfase che include un$exprespressione
