MongoDB $min Aggregation Pipeline Operator

Den første syntaks accepterer ét argument, og den anden syntaks accepterer flere argumenter.

Når det bruges i $group fase, kan du kun bruge den første syntaks. I dette tilfælde $min returnerer den minimumsværdi, der er resultatet af at anvende et udtryk på hvert dokument i en gruppe af dokumenter, der deler den samme gruppe efter nøgle.

Eksempler på syntaks 1 (enkelt argument)

Her er et par eksempler, der bruger syntaksen for enkelt argument.

Grupperte dokumenter

Dette eksempel bruger $min i forbindelse med $group for at returnere minimumsværdien fra en gruppe dokumenter, der er grupperet efter nøgle.

Antag, at vi har en samling kaldet pets med følgende dokumenter:

{ "_id" :1, "name" :"Wag", "type" :"Hund", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Hund", "vægt" :10 }{ "_id" :3, "name" :"Mjav", "type" :"Kat", "vægt" :7 }{ "_id" :4, "navn" :"Scratch", "type" :"Kat", "vægt" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Kænguru", "vægt" :100 }{ " _id" :6, "name" :"Hop", "type" :"Kænguru", "vægt" :130 }{ "_id" :7, "name" :"Punch", "type" :"Kænguru", "vægt" :200 }{ "_id" :8, "name" :"Snap", "type" :"Kat", "vægt" :12 }{ "_id" :9, "name" :"Ruff", "type" :"Hund", "vægt" :30 }

Vi kan gruppere disse dokumenter efter deres type felt, og brug derefter $min for at returnere minimumsværdien af ​​weight felt for hver gruppe:

db.pets.aggregate(
   [
     {
       $group:
          {
            _id: "$type",
            min: { $min: "$weight" }
          }
     }
   ]
) 

Resultat:

{ "_id" :"Kænguru", "min" :100 }{ "_id" :"Hund", "min" :10 }{ "_id" :"Kat", "min" :7 } 
Arrays
 

 Dette eksempel gælder $min til et enkelt dokument, der indeholder et felt med en række værdier.
 

 Denne indstilling er kun tilgængelig, når du bruger syntaksen for enkelt argument. Arrays ignoreres, når du bruger multi-argument-syntaksen (mere om dette nedenfor).
 

 Antag, at vi har en samling kaldet players med følgende dokumenter:
 
{ "_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" }
 

 Vi kan anvende $min til scores felt i hvert dokument:
 
db.players.aggregate(
   [
     {
       $project:
          {
            player: 1,
            min: { $min: "$scores" }
          }
     }
   ]
) 
 

 Resultat:
 
{ "_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 } 
 

 I dette tilfælde returnerede de første fire dokumenter minimumsværdien fra de forskellige tal, der var i deres respektive arrays.
 

 I dokument 4s tilfælde var dette det samme som nummeret, fordi der kun var ét tal i arrayet.
 

 Dokument 5 returnerede null fordi vi leverede et tomt array.
 

 Dokument 6 returnerede null fordi vi har leveret null som argumentet.
 

 Dokument 7 returnerede null fordi feltet ikke engang eksisterede.
 
Eksempel på syntaks 2 (flere argumenter)
 

 Den anden syntaks involverer at give $min med mere end ét argument. $min returnerer derefter minimumsværdien fra alle de leverede argumenter.
 

 Antag, at vi har en samling kaldet data med følgende dokument:
 
{ "_id" :1, "a" :10, "b" :500, "c" :-900, "d" :4 }
 

 Vi kan bruge $min for at returnere minimumsværdien fra a , b , c og d felter:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "_id" :1, "min" :-900 }
 

 I dette tilfælde -900 var minimumsværdien.
 
Manglende felter
 

 Når du bruger multi-argument-syntaksen, $min ignorerer eventuelle manglende felter. Det vil sige, at hvis du angiver et felt, der ikke eksisterer, ignorerer det det. Hvis ingen af ​​felterne eksisterer, returnerer det null .
 

 Eksempel:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "_id" :1, "min" :-900 }
 

 I dette tilfælde har jeg angivet et ekstra felt ($e ), der ikke findes i dokumentet. $min beregnet minimumsværdien baseret på de resterende felter, der gør eksisterer.
 

 Men her er, hvad der sker, når ingen af felterne findes:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            result: { $min: [ "$x", "$y", "$z" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "_id" :1, "result" :null }
 

 Resultatet er null . 
 

 Som vi så tidligere, resulterer et manglende felt i null ved brug af enkeltargumentsyntaksen .
 

 Eksempel:
 
db.pets.aggregate(
   [
     {
       $group:
          {
            _id: "$type",
            min: { $min: "$oops!" }
          }
     }
   ]
) 
 

 Resultat:
 
{ "_id" :"Hund", "min" :null }{ "_id" :"Kat", "min" :null }{ "_id" :"Kænguru", "min" :null } 
Sammenligning af forskellige typer
 

 $min operatør sammenligner både værdi og type. Når værdierne er af forskellige typer, $min beregner minimumsværdien baseret på BSON-sammenligningsrækkefølgen.
 

 Antag, at vores samling indeholder følgende dokumenter:
 
{ "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 0 ] }{ "_id" :3, "a" :1, " b" :2, "c" :3, "d" :"0" }{ "_id" :4, "a" :"Én", "b" :"To", "c" :"Tre", "d" :"Fire" }{ "_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"}
 

 Med undtagelse af dokument 4 bruger hvert af disse dokumenter blandede typer (der er mindst én type, der er forskellig fra de andre på tværs af datafelter). Dokument 4 bruger strenge i alle fire felter.
 

 Her er, hvad der sker, når vi anvender $min til disse dokumenter:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "_id" :2, "min" :1 }{ "_id" :3, "min" :1 }{ "_id" :4, "min" :"Fire" }{ "_id" :5 , "min" :ISODate("1999-01-03T23:30:15.100Z") }{ "_id" :6, "min" :"2000-01-03T23:30:15.100Z" }
 

 Angående dokumentet med en _id af 2 , tal er mindre end arrays, så tallet 1 returneres (selvom arrayet indeholder et tal, der er mindre end alle de andre tal).
 

 Dokument 3:Tal er mindre end strenge, og derfor returneres det laveste tal.
 

 Dokument 4:Alle felter er strenge, og så Four er minimumsstrengen.
 

 Dokument 5:To datoer er leveret, og derfor returneres den tidligere dato.
 

 Dokument 6:I dette tilfælde leveres et Dato-objekt og en datostreng. Strenge er mindre end Dato-objekter, og derfor returneres strengen (selvom dens dato er senere end Dato-objektets). 
 
Tilgængelige stadier
 

 $min er tilgængelig i følgende trin:
 
 
$group 
 
$project 
 
$addFields 
 
$set 
 
$replaceRoot 
 
$replaceWith 
 
$match trin, der inkluderer en $expr udtryk