On-Demand Materialized Views

Indexes

Standard views use the indexes of the underlying collection. As a result, you cannot create, drop or re-build general indexes on a standard view directly, nor get a list of general indexes on the view.

MongoDB stores search indexes and vector search indexes on disk. Accordingly, you can create MongoDB Search indexes and MongoDB Vector Search indexes on compatible views that contain only the following stages:

• $addFields

• $set

• $match wrapping an $expr operation

You can also create indexes directly on on-demand materialized views because MongoDB stores those indexes on disk.

Performance

On-demand materialized views provide better read performance than standard views because they are read from disk instead of computed as part of the query. This performance benefit increases based on the complexity of the pipeline and size of the data being aggregated.

1. Define the On-Demand Materialized View

The following updateMovieStats function defines a movieYearStats materialized view that contains the count and average IMDb rating of movies by year. The function accepts a startYear parameter to update statistics for movies released from that year forward.

updateMovieStats = function(startYear) {
   db.movies.aggregate( [
      { $match: { year: { $gte: startYear } } },
      { $group: {
           _id: "$year",
           movieCount: { $sum: 1 },
           avgRating: { $avg: "$imdb.rating" }
      } },
      { $merge: { into: "movieYearStats", whenMatched: "replace" } }
   ] );
};

• The $match stage filters movies to process only those with a year value greater than or equal to startYear.

• The $group stage groups movies by year. The documents output by this stage have the form:

  { "_id" : <year>, "movieCount" : <num>, "avgRating" : <num> }

• The $merge stage writes the output to the movieYearStats collection.

  The stage matches on the _id field and checks if each aggregation result matches an existing document:

  • When there is a match (that is, a document with the same year already exists in the collection), the stage replaces the existing document with the document from the aggregation results.

  • When there isn't a match, the stage inserts the document from the aggregation results into the collection (the default behavior when not matched).

2. Perform Initial Run

For the initial run, pass in a starting year to populate movieYearStats with data from that year forward:

updateMovieStats(2015);

After the initial run, db.movieYearStats.find().sort( { _id: 1 } ) returns documents like the following:

{ "_id" : 2015, "movieCount" : <num>, "avgRating" : <num> }
{ "_id" : 2016, "movieCount" : <num>, "avgRating" : <num> }
{ "_id" : 2017, "movieCount" : <num>, "avgRating" : <num> }

3. Refresh Materialized View

Assume a new movie is added to the movies collection for 2016:

db.movies.insertOne( {
   title: "Grove Test Movie",
   year: 2016,
   imdb: { rating: 7.5, votes: 500 }
} )

To refresh movieYearStats for 2016 onward, run the function with a startYear of 2016:

updateMovieStats(2016);

The updated movieYearStats reflects the new movie in the movies collection. db.movieYearStats.find().sort( { _id: 1 } ) returns:

{ "_id" : 2015, "movieCount" : <num>, "avgRating" : <num> }
{ "_id" : 2016, "movieCount" : <num>, "avgRating" : <num> }
{ "_id" : 2017, "movieCount" : <num>, "avgRating" : <num> }