Computed pattern for pre-aggregation in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the computed pattern for pre-aggregation in MongoDB?

It is a technique where you calculate and store summary data ahead of time to speed up queries, instead of computing it on the fly each time.

beginner

Why use pre-aggregation in MongoDB?

To improve query speed by avoiding repeated calculations and reduce load on the database during read operations.

intermediate

Which MongoDB feature helps implement computed pre-aggregation?

The aggregation pipeline, combined with update operations to store computed results in a separate collection or document.

intermediate

How does the computed pattern handle data updates?

When source data changes, the pre-aggregated values are recalculated and updated to keep summaries accurate.

beginner

Give an example use case for computed pattern pre-aggregation.

Calculating total sales per day and storing it, so queries for daily sales totals are fast without scanning all sales records each time.

What is the main benefit of using computed pattern for pre-aggregation in MongoDB?

A Faster query response by using pre-calculated summaries

B Storing raw data only

C Avoiding any data updates

D Increasing storage space by duplicating all data

Pre-aggregation stores computed summaries to speed up queries, improving performance.

Which MongoDB feature is essential for creating pre-aggregated data?

A Aggregation pipeline

B MapReduce only

C Indexing

D Sharding

The aggregation pipeline allows computing summaries that can be stored for pre-aggregation.

When source data changes, what must happen to pre-aggregated data?

A It is deleted

B It must be recalculated and updated

C It stays the same

D It is ignored

To keep summaries accurate, pre-aggregated data must be updated when source data changes.

Which of these is NOT a reason to use pre-aggregation?

A Reduce query time

B Avoid repeated calculations

C Store raw detailed data only

D Lower database load during reads

Pre-aggregation stores summaries, not just raw data, to improve performance.

What is a common example of pre-aggregation?

A Backing up the database

B Storing every single transaction without summary

C Deleting old data

D Storing daily total sales instead of all individual sales

Summarizing daily sales totals is a typical pre-aggregation use case.

Explain the computed pattern for pre-aggregation and why it is useful in MongoDB.

Think about how storing results ahead helps queries run faster.

Describe how you would keep pre-aggregated data accurate when the original data changes.

Consider what happens when new data is added or existing data is modified.

Practice

1. What is the main purpose of using a computed pattern for pre-aggregation in MongoDB?

easy

A. To delete all raw data after aggregation

B. To create indexes on every field automatically

C. To calculate and store summary data ahead of time for faster queries

D. To replicate data across multiple servers

Solution

1. Step 1: Understand pre-aggregation concept

   Pre-aggregation means computing summary data before queries run, so queries are faster.

2. Step 2: Identify the main goal

   The goal is to store computed summaries to avoid recalculating on every query.

3. Final Answer:

   To calculate and store summary data ahead of time for faster queries -> Option C

4. Quick Check:

   Pre-aggregation = faster queries [OK]

Hint: Pre-aggregation means compute summaries before queries [OK]

Common Mistakes:

• Confusing pre-aggregation with data deletion
• Thinking it automatically creates indexes
• Mixing it with data replication

2. Which MongoDB aggregation stage is primarily used to compute grouped summary data for pre-aggregation?

easy

A. $match

B. $group

C. $project

D. $sort

Solution

1. Step 1: Recall aggregation stages

   $group is used to group documents and compute summary values like sums or counts.

2. Step 2: Identify correct stage for pre-aggregation

   Pre-aggregation requires grouping and computing, so $group is the right stage.

3. Final Answer:

   $group -> Option B

4. Quick Check:

   $group = grouping and computing summaries [OK]

Hint: Use $group to compute grouped summaries [OK]

Common Mistakes:

• Choosing $match which filters but does not compute
• Confusing $project with grouping
• Selecting $sort which only orders data

3. Given the following aggregation pipeline, what will be the output?

[{ $group: { _id: "$category", total: { $sum: "$amount" } } }]

Assuming the collection has documents: {category: "A", amount: 10}, {category: "B", amount: 5}, {category: "A", amount: 15}.

medium

A. [{_id: null, total: 30}]

B. [{_id: "A", total: 10}, {_id: "B", total: 5}, {_id: "A", total: 15}]

C. [{_id: "A", total: 15}, {_id: "B", total: 5}]

D. [{_id: "A", total: 25}, {_id: "B", total: 5}]

Solution

1. Step 1: Group documents by category

   Documents with category "A" are grouped together, and category "B" separately.

2. Step 2: Sum amounts per group

   For "A": 10 + 15 = 25; for "B": 5.

3. Final Answer:

   [{_id: "A", total: 25}, {_id: "B", total: 5}] -> Option D

4. Quick Check:

   Sum amounts by category = correct totals [OK]

Hint: Sum amounts grouped by _id field [OK]

Common Mistakes:

• Not grouping sums correctly
• Returning individual documents instead of grouped
• Using null _id which sums all documents

4. Identify the error in this aggregation pipeline for pre-aggregation:

[{ $group: { _id: "$category", total: { $sum: "amount" } } }]

medium

A. Missing $ before amount in $sum operator

B. Incorrect use of $group stage

C. Missing $match stage before $group

D. Using _id field incorrectly

Solution

1. Step 1: Check $sum operator syntax

   $sum requires a field path starting with $, but "amount" is missing the $.

2. Step 2: Confirm correct syntax

   It should be $sum: "$amount" to sum the amount field values.

3. Final Answer:

   Missing $ before amount in $sum operator -> Option A

4. Quick Check:

   $sum needs $field syntax [OK]

Hint: Field names in aggregation need $ prefix [OK]

Common Mistakes:

• Forgetting $ before field names in operators
• Assuming $match is mandatory before $group
• Misusing _id field in $group

5. You want to pre-aggregate sales data by month and product category, storing total sales and average price. Which aggregation pipeline correctly computes these values?

hard

A. [{ $group: { _id: { month: { $month: "$date" }, category: "$category" }, totalSales: { $sum: "$amount" }, avgPrice: { $avg: "$price" } } }]

B. [{ $group: { _id: "$date", totalSales: { $sum: "$amount" }, avgPrice: { $avg: "$price" } } }]

C. [{ $group: { _id: { month: "$date", category: "$category" }, totalSales: { $sum: "$amount" }, avgPrice: { $avg: "$price" } } }]

D. [{ $group: { _id: { month: { $month: "$date" }, category: "$category" }, totalSales: { $sum: "$price" }, avgPrice: { $avg: "$amount" } } }]

Solution

1. Step 1: Group by month and category correctly

   Use $month operator on "$date" to extract month, and include "$category" as second key.

2. Step 2: Compute total sales and average price correctly

   Sum the "$amount" field for totalSales and average the "$price" field for avgPrice.

3. Final Answer:

   [{ $group: { _id: { month: { $month: "$date" }, category: "$category" }, totalSales: { $sum: "$amount" }, avgPrice: { $avg: "$price" } } }] -> Option A

4. Quick Check:

   Group by month+category, sum amount, avg price [OK]

Hint: Use $month for date grouping and correct fields for sum/avg [OK]

Common Mistakes:

• Grouping by full date instead of month
• Swapping sum and avg fields
• Not using $month operator for month extraction