MongoDB $max Aggregation Pipeline Operator

I MongoDB er $max aggregeringspipeline-operator returnerer den maksimale værdi fra et udtryk.

Syntaks

$max operatoren understøtter to syntakser.

Syntaks 1:

{ $max: <expression> }

Syntaks 2:

{ $max: [ <expression1>, <expression2> ... ] }

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 $max returnerer den maksimale væ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 $max i forbindelse med $group for at returnere den maksimale værdi 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 $max for at returnere den maksimale værdi af weight felt for hver gruppe:

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

Resultat:

{ "_id" :"Kænguru", "max" :200 }{ "_id" :"Kat", "max" :12 }{ "_id" :"Hund", "max" :30 } Arrays
 
 Dette eksempel gælder $max 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 $max til scores felt i hvert dokument:
 db.players.aggregate(
   [
     {
       $project:
          {
            player: 1,
            max: { $max: "$scores" }
          }
     }
   ]
) 
 
 Resultat:
 { "_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 } 
 
 I dette tilfælde returnerede de første fire dokumenter den maksimale værdi 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 $max med mere end ét argument. $max returnerer derefter den maksimale værdi 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 $max for at returnere den maksimale værdi fra a , b , c og d felter:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            max: { $max: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 
 Resultat:
 { "_id" :1, "max" :500 }
 
 I dette tilfælde 500 var den maksimale værdi.
 Manglende felter
 
 Når du bruger multi-argument-syntaksen, $max 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:
          {
            max: { $max: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
) 
 
 Resultat:
 { "_id" :1, "max" :500 }
 
 I dette tilfælde har jeg angivet et ekstra felt ($e ), der ikke findes i dokumentet. $max beregnet den maksimale værdi 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: { $max: [ "$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",
            max: { $max: "$oops!" }
          }
     }
   ]
) 
 
 Resultat:
 { "_id" :"Hund", "max" :null }{ "_id" :"Kænguru", "max" :null }{ "_id" :"Kat", "max" :null } Sammenligning af forskellige typer
 
 $max operatør sammenligner både værdi og type. Når værdierne er af forskellige typer, $max beregner den maksimale værdi baseret på BSON-sammenligningsrækkefølgen.
 
 Antag, at vores samling indeholder følgende dokumenter:
 { "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 1 ] }{ "_id" :3, "a" :1, " b" :2, "c" :3, "d" :"1" }{ "_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 $max til disse dokumenter:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
     {
       $project:
          {
            max: { $max: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 
 Resultat:
 { "_id" :2, "max" :[ 1 ] }{ "_id" :3, "max" :"1" }{ "_id" :4, "max" :"To" }{ " _id" :5, "max" :ISODate("2000-01-03T23:30:15.100Z") }{ "_id" :6, "max" :ISODate("1999-01-03T23:30:15.100Z" ) }
 
 dokumentet med en _id af 2 , arrays er større end tal, så arrayet returneres (selvom dets element er et tal, der er mindre end nogle af de andre numre).
 
 Dokument 3:Strenge er større end tal, og derfor returneres strengen.
 
 Dokument 4:Alle felter er strenge, og så Two er den største streng.
 
 Dokument 5:To datoer er leveret, og så den senere dato returneres.
 
 Dokument 6:I dette tilfælde leveres et Dato-objekt og en datostreng. Datoobjekter er større end strenge, og derfor returneres Dato-objektet (selvom dets dato er tidligere end strengens). 
 Tilgængelige stadier
 
 $max er tilgængelig i følgende trin:
  $group 
 $project 
 $addFields 
 $set 
 $replaceRoot 
 $replaceWith 
 $match trin, der inkluderer en $expr udtryk