/ /

$firstN (operador acumulador )

Definição

$firstN

Retorna uma agregação dos primeiros n elementos dentro de um grupo. Os resultados só são significativos se os dados de entrada para o estágio de agrupamento tiverem uma ordem de classificação definida. Se o grupo tiver menos de n elementos, $firstN retornará todos os elementos no grupo.

O acumulador $firstN está disponível nestes estágios:

Observação

Desambiguação

Esta página descreve $firstN quando usado como um acumulador. Acumuladores retornam um único valor agregado, como soma, máximo ou mínimo, em um grupo de documentos de entrada.

Você também pode usar $firstN nestes outros contextos:

$firstN (expression), que retorna o número especificado de elementos desde o início de um array.
$firstN (window function), que é usado no $setWindowFields estágio para retornar os primeiros n valores de documentos em uma janela específica.

Sintaxe

{
   $firstN:
      {
         input: <expression>,
         n: <expression>
      }
}

Opções

Campo	Tipo	Descrição
`input`	Expressão	A expressão `input` é avaliada em cada documento no grupo de entrada, e os primeiros `n` resultados são preservados.
`n`	Expressão	The number of elements that `$firstN` returns from the group. For an example of setting `n` dynamically based on the group key, see Set n Based on the Group Key.

Comportamento

Valores nulos e ausentes

$firstN não filtra valores nulos.
$firstN converte valores ausentes em nulo.

Comparação de $firstN e $topN

Ambos os acumuladores $firstN e $topN podem obter resultados semelhantes.

Em geral:

Se os documentos que chegam a $group já estiverem ordenados, você deverá usar $firstN.
Se você estiver classificando e selecionando os n elementos principais, poderá usar $topN para realizar ambas as tarefas com um acumulador.

Exemplos

The examples on this page use the movies collection in the sample_mflix sample dataset. To learn how to load the sample dataset into your MongoDB deployment, see Import Sample Data Into Your Atlas Deployment.

Encontre os três primeiros filmes para um único gênero

Você pode usar o acumulador $firstN para encontrar os três primeiros filmes em um único gênero.

db.movies.aggregate( [
   {
      $match: { genres: "Horror" }
   },
   {    
      $sort: { year: 1 }
   },
   {
      $group:
         {
            _id: "Horror",
            firstThreeMovies:
               {
                  $firstN:
                  {
                     input: [ "$title", "$year" ],
                     n: 3
                  }
               }
         }
   }
] )

[
  {
    _id: 'Horror',
    firstThreeMovies: [
      [ 'Dr. Jekyll and Mr. Hyde', 1931 ],
      [ 'Dracula', 1931 ],
      [ 'The Black Cat', 1934 ]
    ]
  }
]

O pipeline anterior:

Usa $match para filtro os resultados para filmes onde Horror está incluído no array genres.
Classifica os resultados por year em ordem crescente.
Agrupa todos os documentos resultantes em um único grupo.
Especifica os campos que são entrada para $firstN com input : ["$title", "$year"].
Usa $firstN para retornar os três primeiros documentos do gênero Horror com n: 3.

Encontrar os três primeiros filmes em vários gêneros

Você pode usar o acumulador $firstN para encontrar os primeiros n campos de entrada em cada gênero.

db.movies.aggregate( [
   {
      $unwind: "$genres"
   },
   {
      $sort: { year: 1 }
   },
   {
      $group:
         {
            _id: "$genres",
            movies:
               {
                  $firstN:
                     {
                        input: [ "$title", "$year" ],
                        n: 3
                     }
               }
         }
   },
   { $sort: { _id: 1 } },
   { $limit: 5 }
] )

[
  {
    _id: 'Action',
    movies: [
      [ 'The Perils of Pauline', 1914 ],
      [ 'From Hand to Mouth', 1919 ],
      [ "For Heaven's Sake", 1926 ]
    ]
  },
  {
    _id: 'Adventure',
    movies: [
      [ 'Robin Hood', 1922 ],
      [ 'Peter Pan', 1924 ],
      [ 'The Thief of Bagdad', 1924 ]
    ]
  },
  {
    _id: 'Animation',
    movies: [
      [
        'Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics',
        1911
      ],
      [
        'Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics',
        1911
      ],
      [ 'Gertie the Dinosaur', 1914 ]
    ]
  },
  {
    _id: 'Biography',
    movies: [ [ 'Regeneration', 1915 ], [ 'Salomè', 1922 ], [ 'Napoleon', 1927 ] ]
  },
  {
    _id: 'Comedy',
    movies: [
      [
        'Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics',
        1911
      ],
      [
        'Winsor McCay, the Famous Cartoonist of the N.Y. Herald and His Moving Comics',
        1911
      ],
      [ 'Gertie the Dinosaur', 1914 ]
    ]
  }
]

O pipeline anterior:

Usa $unwind para criar um documento separado para cada gênero no array genres.
Classifica os resultados por year em ordem crescente.
Utiliza $group para agrupar os resultados por genres.
Usa $firstN para retornar os três primeiros documentos de cada gênero com n: 3.
Especifica os campos que são entrada para $firstN com input : ["$title", "$year"].
Limita a saída a cinco documentos para melhorar a legibilidade.

Definir n com base na chave de grupo

Você pode atribuir o valor de n dinamicamente com base na chave do grupo. Neste exemplo, a expressão $cond usa o campo rated para alterar o valor de n:

db.movies.aggregate([
   { $match: { rated: { $in: ["G", "PG", "PG-13", "R"] } } },
   { $sort: { title: 1 } },
   {
      $group:
         {
            _id: {"rated": "$rated"},
            movies:
               {
                  $firstN:
                     {
                        input: "$title",
                        n: { $cond: { if: { $eq: ["$rated", "PG"] }, then: 3, else: 1 } }
                     }
               }
         }
   }
] )

[
  { _id: { rated: 'PG-13' }, movies: [ "'night, Mother" ] },
  {
    _id: { rated: 'PG' },
    movies: [ '*batteries not included', '...And God Created Woman', '1776' ]
  },
  { _id: { rated: 'G' }, movies: [ '101 Dalmatians' ] },
  { _id: { rated: 'R' }, movies: [ '$' ] }
]

O pipeline anterior:

Filtros para filmes com classificações de G, PG, PG-13 ou R.
Ordena os resultados alfabeticamente por title.
Agrupa filmes por rated (a classificação do filme).
Usa a expressão $cond para retornar 3 filmes para filmes com classificação PGe 1 filme para todas as outras classificações.

Na saída, a classificação PG retorna 3 filmes, enquanto as classificações G, PG-13 e R retornam 1 filme cada.

Saiba mais

Voltar

$first

$last