Operador de pipeline de agregação do MongoDB $min

No MongoDB, o $min operador de pipeline de agregação retorna o valor mínimo de uma expressão.

Sintaxe

O $min O operador suporta duas sintaxes.

Sintaxe 1:

{ $min: <expression> }

Sintaxe 2:

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

A primeira sintaxe aceita um argumento e a segunda sintaxe aceita vários argumentos.

Quando usado no $group stage, você só pode usar a primeira sintaxe. Neste caso, $min retorna o valor mínimo resultante da aplicação de uma expressão a cada documento em um grupo de documentos que compartilham o mesmo grupo por chave.

Exemplos de sintaxe 1 (argumento único)

Aqui estão alguns exemplos que usam a sintaxe de argumento único.

Documentos agrupados

Este exemplo usa $min em conjunto com $group para retornar o valor mínimo de um grupo de documentos agrupados por chave.

Suponha que tenhamos uma coleção chamada pets com os seguintes documentos:

{ "_id" :1, "name" :"Wag", "type" :"Dog", "weight" :20 }{ "_id" :2, "name" :"Latido", "tipo" :"Dog", "weight" :10 }{ "_id" :3, "name" :"Miau", "type" :"Cat", "weight" :7 }{ "_id" :4, "name" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Canguru", "weight" :100 }{ " _id" :6, "name" :"Hop", "type" :"Canguru", "peso" :130 }{ "_id" :7, "name" :"Punch", "type" :"Canguru", "weight" :200 }{ "_id" :8, "name" :"Snap", "type" :"Gato", "weight" :12 }{ "_id" :9, "name" :"Ruff", "type" :"Cão", "peso" :30 }

Podemos agrupar esses documentos por seu type campo e, em seguida, use $min para retornar o valor mínimo do weight campo para cada grupo:

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

Resultado:

{ "_id" :"Canguru", "min" :100 }{ "_id" :"Cão", "min" :10 }{ "_id" :"Gato", "min" :7 } Matrizes
 
 Este exemplo se aplica a $min para um único documento que contém um campo com uma matriz de valores. 
 
 Esta opção só está disponível ao usar a sintaxe de argumento único. As matrizes são ignoradas ao usar a sintaxe de vários argumentos (mais sobre isso abaixo). 
 
 Suponha que tenhamos uma coleção chamada players com os seguintes documentos:
 { "_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" }
 
 Podemos aplicar $min para as scores campo em cada documento:
 db.players.aggregate(
   [
     {
       $project:
          {
            player: 1,
            min: { $min: "$scores" }
          }
     }
   ]
) 
 
 Resultado:
 { "_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 } 
 
 Nesse caso, os quatro primeiros documentos retornaram o valor mínimo dos diversos números que estavam em seus respectivos arrays. 
 
 No caso do documento 4, era o mesmo que o número, pois havia apenas um número no array. 
 
 O documento 5 retornou null porque fornecemos um array vazio. 
 
 O documento 6 retornou null porque fornecemos null como o argumento. 
 
 O documento 7 retornou null porque o campo nem existia. 
 Exemplo de sintaxe 2 (vários argumentos)
 
 A segunda sintaxe envolve fornecer $min com mais de um argumento. $min em seguida, retorna o valor mínimo de todos os argumentos fornecidos. 
 
 Suponha que tenhamos uma coleção chamada data com o seguinte documento:
 { "_id":1, "a":10, "b":500, "c":-900, "d":4 }
 
 Podemos usar $min para retornar o valor mínimo do a , b , c e d Campos:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 
 Resultado:
 { "_id":1, "min":-900 }
 
 Nesse caso, -900 foi o valor mínimo. 
 Campos ausentes
 
 Ao usar a sintaxe de vários argumentos, $min ignora quaisquer campos ausentes. Ou seja, se você fornecer um campo que não existe, ele o ignora. Se nenhum dos campos existir, ele retornará null . 
 
 Exemplo:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
) 
 
 Resultado:
 { "_id":1, "min":-900 }
 
 Neste caso forneci um campo extra ($e ) que não existe no documento. $min calculou o valor mínimo com base nos campos restantes que fazem existir. 
 
 No entanto, veja o que acontece quando nenhum dos campos existem:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            result: { $min: [ "$x", "$y", "$z" ] }
          }
     }
   ]
) 
 
 Resultado:
 { "_id":1, "resultado":null }
 
 O resultado é null . 
 
 Como vimos anteriormente, ao usar a sintaxe de argumento único, um campo ausente resulta em null . 
 
 Exemplo:
 db.pets.aggregate(
   [
     {
       $group:
          {
            _id: "$type",
            min: { $min: "$oops!" }
          }
     }
   ]
) 
 
 Resultado:
 { "_id" :"Cachorro", "min" :null }{ "_id" :"Gato", "min" :null }{ "_id" :"Canguru", "min" :null } Comparação de diferentes tipos
 
 O $min O operador compara valor e tipo. Quando os valores são de tipos diferentes, $min calcula o valor mínimo com base na ordem de comparação BSON. 
 
 Suponha que nossa coleção contenha os seguintes documentos:
 { "_id" :2, "a" :1, "b" :2, "c" :3, "d" :[ 0 ] }{ "_id" :3, "a" :1, " b" :2, "c" :3, "d" :"0" }{ "_id" :4, "a" :"Um", "b" :"Dois", "c" :"Três", "d" :"Quatro" }{ "_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"} 
 Com exceção do documento 4, cada um desses documentos usa tipos mistos (há pelo menos um tipo diferente dos outros nos campos de dados). O Documento 4 usa strings em todos os quatro campos. 
 
 Veja o que acontece quando aplicamos $min a esses documentos:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
     {
       $project:
          {
            min: { $min: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
) 
 
 Resultado:
 { "_id" :2, "min" :1 }{ "_id" :3, "min" :1 }{ "_id" :4, "min" :"Quatro" }{ "_id" :5 , "min" :ISODate("1999-01-03T23:30:15.100Z") }{ "_id" :6, "min" :"2000-01-03T23:30:15.100Z" }
 
 Em relação ao documento com um _id de 2 , os números são menores que os arrays, então o número 1 é retornado (mesmo que a matriz contenha um número menor que todos os outros números). 
 
 Documento 3:Os números são menores que as strings e, portanto, o número mais baixo é retornado. 
 
 Documento 4:Todos os campos são strings, então Four é a sequência mínima. 
 
 Documento 5:São fornecidas duas datas e, portanto, a data anterior é devolvida. 
 
 Documento 6:Neste caso, são fornecidos um objeto Date e uma string de data. Strings são menores que objetos Date e, portanto, a string é retornada (mesmo que sua data seja posterior à do objeto Date). 
 Etapas disponíveis
 
 $min está disponível nas seguintes etapas:
  $group 
 $project 
 $addFields 
 $set 
 $replaceRoot 
 $replaceWith 
 $match estágio que inclui um $expr expressão