MongoDB $min Оператор на конвейер за агрегиране

В MongoDB, $min Операторът на конвейера за агрегиране връща минималната стойност от израз.

Синтаксис

$min операторът поддържа два синтаксиса.

Синтаксис 1:

{ $min: <expression> } 

Синтаксис 2:

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

Първият синтаксис приема един аргумент, а вторият синтаксис приема множество аргументи.

Когато се използва в $group етап, можете да използвате само първия синтаксис. В този случай $min връща минималната стойност, която е резултат от прилагането на израз към всеки документ в група документи, които споделят една и съща група по ключ.

Примери за синтаксис 1 (единичен аргумент)

Ето няколко примера, които използват синтаксиса с един аргумент.

Групирани документи

Този пример използва $min във връзка с $group за да върнете минималната стойност от група документи, които са групирани по ключ.

Да предположим, че имаме колекция, наречена pets със следните документи:

{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Куче", "тегло" :10 }{ "_id" :3, "име" :"Мяу", "тип" :"Котка", "тегло" :7 }{ "_id" :4, "име" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Kenguroo", "weight" :100 }{ " _id" :6, "name" :"Hop", "type" :"Kenguroo", "weight" :130 }{ "_id" :7, "name" :"Punch", "type" :"Kenguroo", "weight" :200 }{ "_id" :8, "name" :"Snap", "type" :"Cat", "weight" :12 }{ "_id" :9, "name" :"Ruff", "тип" :"Куче", "тегло" :30 }

Можем да групираме тези документи по техния type поле и след това използвайте $min за да върне минималната стойност на weight поле за всяка група:

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

Резултат:

{ "_id" :"Кенгуру", "min" :100 }{ "_id" :"Куче", "min" :10 }{ "_id" :"Котка", "мин" :7 } 
Масиви
 

 Този пример се прилага $min към един документ, който съдържа поле с масив от стойности.
 

 Тази опция е налична само при използване на синтаксис на единичен аргумент. Масивите се игнорират, когато се използва синтаксисът с няколко аргумента (повече за това по-долу).
 

 Да предположим, че имаме колекция, наречена players със следните документи:
 
{ "_id" :1, "player" :"Homer", "резултати" :[ 1, 7, 2, 3, 8, 7, 1 ] }{ "_id" :2, "player" :" Мардж", "резултати" :[ 0, 1, 8, 17, 18, 8 ] }{ "_id" :3, "играч" :"Барт", "резултати" :[ 15, 11, 8, 0, 1 , 3 ] }{ "_id" :4, "player" :"Brian", "cores" :[ 7 ] }{ "_id" :5, "player" :"Farnsworth", "cores" :[ ] }{ "_id" :6, "player" :"Мег", "резултати" :null }{ "_id" :7, "player" :"Рон" }
 

 Можем да приложим $min към scores поле във всеки документ:
 
db.players.aggregate(
   [
     {
       $project:
          {
            player: 1,
            min: { $min: "$scores" }
          }
     }
   ]
) 
 

 Резултат:
 
{ "_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 } 
 

 В този случай първите четири документа върнаха минималната стойност от различните числа, които бяха в съответните им масиви.
 

 В случай на документ 4 това беше същото като числото, защото имаше само едно число в масива.
 

 Документ 5 върна null защото предоставихме празен масив.
 

 Документ 6 върна null защото предоставихме null като аргумент.
 

 Документ 7 върна null защото полето дори не е съществувало.
 
Пример за синтаксис 2 (множество аргументи)
 

 Вторият синтаксис включва предоставяне на $min с повече от един аргумент. $min след това връща минималната стойност от всички предоставени аргументи.
 

 Да предположим, че имаме колекция, наречена data със следния документ:
 
{ "_id" :1, "a" :10, "b" :500, "c" :-900, "d" :4 }
 

 Можем да използваме $min за да върне минималната стойност от a , b , c и d полета:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 

 Резултат:
 
{ "_id" :1, "min" :-900 }
 

 В този случай -900 беше минималната стойност.
 
Липсващи полета
 

 Когато използвате синтаксиса с няколко аргумента, $min игнорира всички липсващи полета. Тоест, ако предоставите поле, което не съществува, то го игнорира. Ако нито едно от полетата не съществува, то връща null .
 

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

 Резултат:
 
{ "_id" :1, "min" :-900 }
 

 В този случай предоставих допълнително поле ($e ), който не съществува в документа. $min изчислява минималната стойност въз основа на останалите полета, които правят съществуват.
 

 Но ето какво се случва, когато няма от полетата съществуват:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            result: { $min: [ "$x", "$y", "$z" ] }
          }
     }
   ]
) 
 

 Резултат:
 
{ "_id" :1, "резултат":нула }
 

 Резултатът е null . 
 

 Както видяхме по-рано, когато се използва синтаксисът с един аргумент, липсващо поле води до null .
 

 Пример:
 
db.pets.aggregate(
   [
     {
       $group:
          {
            _id: "$type",
            min: { $min: "$oops!" }
          }
     }
   ]
) 
 

 Резултат:
 
{ "_id" :"Куче", "min" :null }{ "_id" :"Котка", "min" :null }{ "_id" :"Кенгуру", "min" :null } 
Сравняване на различни типове
 

 $min оператор сравнява стойността и типа. Когато стойностите са от различни типове, $min изчислява минималната стойност въз основа на реда за сравнение на BSON.
 

 Да предположим, че нашата колекция съдържа следните документи:
 
{ "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 0 ] }{ "_id" :3, "a" :1, " b" :2, "c" :3, "d" :"0" }{ "_id" :4, "a" :"Едно", "b" :"Две", "c" :"Три", "d" :"Четири" }{ "_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"} 

 С изключение на документ 4, всеки от тези документи използва смесени типове (има поне един тип, който е различен от другите в полетата с данни). Документ 4 използва низове и в четирите полета.
 

 Ето какво се случва, когато приложим $min към тези документи:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 

 Резултат:
 
{ "_id" :2, "min" :1 }{ "_id" :3, "min" :1 }{ "_id" :4, "min" :"Четири" }{ "_id" :5 , "min" :ISODate("1999-01-03T23:30:15.100Z") }{ "_id" :6, "min" :"2000-01-03T23:30:15.100Z" }
 

 По отношение на документа с _id от 2 , числата са по-малки от масивите, така че числото 1 се връща (въпреки че масивът съдържа число, което е по-малко от всички останали числа).
 

 Документ 3:Числата са по-малки от низовете и така се връща най-малкото число.
 

 Документ 4:Всички полета са низове и така Four е минималният низ.
 

 Документ 5:Предоставят се две дати и така се връща по-ранната.
 

 Документ 6:В този случай се предоставят обект Date и низ от дата. Стринговете са по-малко от обектите Date и така низът се връща (въпреки че датата му е по-късна от тази на обекта Date). 
 
Налични етапи
 

 $min е наличен в следните етапи:
 
 
$group 
 
$project 
 
$addFields 
 
$set 
 
$replaceRoot 
 
$replaceWith 
 
$match етап, който включва $expr израз