/ /

$firstN (operador acumulador )

Definição

$firstN

Retorna uma agregação dos primeiros n elementos em um grupo. Os resultados serão significativos somente 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 nos seguintes estágios:

Observação

Desambiguação

Esta página descreve $firstN quando usado como acumulador. Os 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 uma array.
$firstN (window function), que é usado no estágio $setWindowFields para retornar os primeiros valores n 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 sobre cada documento no grupo de entrada, e os primeiros resultados `n` são preservados.
`n`	Expressão	O número de elementos que `$firstN` retorna do grupo. Para obter um exemplo de configuração de `n` dinamicamente com base na chave de grupo, consulte Definir n com base na chave de grupo.

Comportamento

Valores nulos e ausentes

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

Comparação de $firstN e $topN

Os acumuladores $firstN e $topN podem realizar 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

Os exemplos nesta página utilizam a collection movies no conjunto de dados de amostra sample_mflix. Para saber como carregar o conjunto de dados de amostra em sua implantação do MongoDB , consulte Importar dados de amostra para sua implantação do Atlas .

Encontre os três primeiros filmes de 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:

Utiliza $match para filtrar os resultados para filmes onde Horror está incluído na 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.

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

Você pode usar o acumulador $firstN para encontrar os primeiros campos de entrada n 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 na 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 do grupo

Você pode atribuir o valor de n dinamicamente com base na chave do grupo. Neste exemplo, a expressão $cond utiliza 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.
Classifica os resultados alfabeticamente por title.
Agrupa filmes por rated (a classificação do filme).
Usa a expressão $cond para retornar filmes 3 para filmes com classificação PG e filme 1 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.

Saiba mais

Voltar

$first

$last