$maxN (accumulator operator)

Result Type

When $maxN compares values of different types, the ordering of types follows the BSON comparison order.

Null and Missing Values

$maxN filters out null and missing values.

The following aggregation demonstrates how $maxN handles null and missing values:

db.aggregate( [
   {
      $documents: [
         { title: "Fight Club", genre: "Drama", rating: 8.9 },
         { title: "The Matrix", genre: "Drama", rating: 8.7 },
         { title: "The Green Mile", genre: "Drama", rating: 8.5 },
         { title: "Magnolia", genre: "Drama" },
         { title: "Dogma", genre: "Drama", rating: null }
      ]
   },
   {
      $group: {
         _id: "$genre",
         topFourRatings: {
            $maxN: {
               input: "$rating",
               n: 4
            }
         }
      }
   }
] )

[
   {
      _id: 'Drama',
      topFourRatings: [ 8.9, 8.7, 8.5 ]
   }
]

In this example:

• $documents creates the literal documents that contain movie ratings.

• $group groups the documents by genre. This example has only one genre, Drama.

• Magnolia has a missing rating and Dogma has a null rating. Both values are filtered out.

• Since only 3 documents have valid ratings, $maxN returns 3 values even though n = 4.

Comparison of $maxN and $topN Accumulators

You can use $maxN or $topN to return the highest-ranked n elements from a group. The choice between them depends on whether your input documents are already sorted.

• If the input documents are already sorted, use $maxN to return the maximum n values.

• If you need to sort and select the top n elements at the same time, use $topN to accomplish both with a single accumulator.

Find the Three Highest Rated Movies for a Single Year

You can use the $maxN accumulator to find the three highest IMDb ratings for movies released in a single year.

db.movies.aggregate( [
   {
      $match: {
         year: 1999,
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: 1999,
         topThreeRatings: {
            $maxN: {
               input: "$imdb.rating",
               n: 3
            }
         }
      }
   }
] )

[ { _id: 1999, topThreeRatings: [ 8.9, 8.7, 8.7 ] } ]

The preceding pipeline:

• Uses $match to filter for movies released in 1999 that have an imdb.rating field.

• Groups all matching documents into a single group with _id: 1999.

• Specifies "$imdb.rating" as the input for $maxN.

• Uses $maxN to return the three highest ratings with n: 3.

Find the Three Highest Rated Movies Across Multiple Years

You can use the $maxN accumulator to find the three highest rated movies for each year in a set of years.

db.movies.aggregate( [
   {
      $match: {
         year: { $in: [ 1999, 2000, 2001 ] },
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: "$year",
         topThreeRatings: {
            $maxN: {
               input: "$imdb.rating",
               n: 3
            }
         }
      }
   },
   { $sort: { _id: 1 } }
] )

[
  { _id: 1999, topThreeRatings: [ 8.9, 8.7, 8.7 ] },
  { _id: 2000, topThreeRatings: [ 8.5, 8.5, 8.5 ] },
  { _id: 2001, topThreeRatings: [ 9.6, 9.2, 8.8 ] }
]

The preceding pipeline:

• Uses $match to filter for movies released in 1999, 2000, or 2001 that have an imdb.rating field.

• Uses $group to group movies by year.

• Specifies "$imdb.rating" as the input for $maxN.

• Uses $maxN to return the three highest ratings per year with n: 3.

• Sorts the results by year in ascending order.

Set n Based on the Group Key

You can assign the value of n dynamically based on the group key. In this example, the $cond expression uses the year field to change the value of n:

db.movies.aggregate( [
   {
      $match: {
         year: { $in: [ 1999, 2000, 2001 ] },
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: { year: "$year" },
         topRatedMovies: {
            $maxN: {
               input: "$imdb.rating",
               n: { $cond: {
                  if: { $eq: [ "$year", 2001 ] },
                  then: 3,
                  else: 1
               } }
            }
         }
      }
   },
   { $sort: { "_id.year": 1 } }
] )

[
  { _id: { year: 1999 }, topRatedMovies: [ 8.9 ] },
  { _id: { year: 2000 }, topRatedMovies: [ 8.5 ] },
  { _id: { year: 2001 }, topRatedMovies: [ 9.6, 9.2, 8.8 ] }
]

The preceding pipeline:

• Filters for movies released in 1999, 2000, or 2001 that have an imdb.rating field.

• Groups movies by year.

• Uses the $cond expression to return 3 ratings for the year 2001 and 1 rating for all other years.

In the output, 2001 returns three ratings while 1999 and 2000 each return one rating.