$avg accumulator in MongoDB - Mini Project: Build & Apply

Calculate Average Scores Using $avg Accumulator in MongoDB

📖 Scenario: You are managing a small school's student test scores stored in a MongoDB collection. You want to find the average score of all students to understand overall performance.

🎯 Goal: Build a MongoDB aggregation query that uses the $avg accumulator to calculate the average score of all students in the collection.

📋 What You'll Learn

Create a collection named students with documents containing name and score fields.

Add a configuration variable scoreField to hold the field name score.

Write an aggregation pipeline that uses $group stage with $avg accumulator on the scoreField.

Complete the aggregation query to output the average score with the field name averageScore.

💡 Why This Matters

🌍 Real World

Calculating averages is common in reporting systems, such as finding average sales, test scores, or ratings stored in databases.

💼 Career

Understanding how to use MongoDB aggregation and accumulators like <code>$avg</code> is essential for data analysts and backend developers working with NoSQL databases.

1

Create the students collection with sample data

Create a MongoDB collection called students with these exact documents: { name: "Alice", score: 85 }, { name: "Bob", score: 90 }, and { name: "Charlie", score: 78 }.

MongoDB

// Insert the documents into the students collection
// Your code here

Hint

Use db.students.insertMany([...]) to add multiple documents at once.

2

Add a configuration variable for the score field

Create a variable called scoreField and set it to the string "score" to represent the field name holding the scores.

MongoDB

db.students.insertMany([
  { name: "Alice", score: 85 },
  { name: "Bob", score: 90 },
  { name: "Charlie", score: 78 }
])

// Create the scoreField variable
// Your code here

Hint

Use const scoreField = "score" to store the field name.

3

Write the aggregation pipeline using $avg

Write a MongoDB aggregation pipeline called pipeline that uses a $group stage to calculate the average of the field stored in scoreField. Use $avg: "$" + scoreField to reference the field dynamically. Name the output field averageScore.

MongoDB

db.students.insertMany([
  { name: "Alice", score: 85 },
  { name: "Bob", score: 90 },
  { name: "Charlie", score: 78 }
])

const scoreField = "score";

// Create the aggregation pipeline to calculate average score
// Your code here

Hint

Use $group with _id: null to aggregate all documents together.

4

Complete the aggregation query to get the average score

Run the aggregation query on the students collection using the pipeline variable and assign the result to a variable called result.

MongoDB

db.students.insertMany([
  { name: "Alice", score: 85 },
  { name: "Bob", score: 90 },
  { name: "Charlie", score: 78 }
])

const scoreField = "score";

const pipeline = [
  {
    $group: {
      _id: null,
      averageScore: { $avg: "$" + scoreField }
    }
  }
];

// Run the aggregation and store the result
// Your code here

Hint

Use db.students.aggregate(pipeline) to run the aggregation.

Practice

1. What does the $avg accumulator do in a MongoDB aggregation pipeline?

easy

A. Calculates the average value of numeric fields in grouped documents

B. Counts the total number of documents in a collection

C. Finds the maximum value in a group of documents

D. Sorts documents in ascending order

Solution

1. Step 1: Understand the purpose of $avg

   The $avg accumulator is designed to calculate the mean (average) of numeric values within grouped documents in an aggregation pipeline.

2. Step 2: Compare with other accumulators

   Other accumulators like $sum, $max, and $count perform different tasks, so $avg specifically calculates averages.

3. Final Answer:

   Calculates the average value of numeric fields in grouped documents -> Option A

4. Quick Check:

   $avg = average calculation [OK]

Hint: Remember: $avg means average, not count or max [OK]

Common Mistakes:

• Confusing $avg with $sum or $count
• Thinking $avg sorts data
• Assuming $avg works outside aggregation

2. Which of the following is the correct syntax to calculate the average of the field score in a MongoDB aggregation $group stage?

easy

A. { $group: { _id: null, avgScore: { $average: "$score" } } }

B. { $group: { _id: null, avgScore: { $avg: "$score" } } }

C. { $group: { _id: null, avgScore: { avg: "$score" } } }

D. { $group: { _id: null, avgScore: { $sum: "$score" } } }

Solution

1. Step 1: Identify the correct accumulator name

   The correct MongoDB accumulator for average is $avg, not $average or avg.

2. Step 2: Check the syntax structure

   The syntax requires the field name as a string with a $ prefix inside $avg, and the whole inside a $group stage with an _id.

3. Final Answer:

   { $group: { _id: null, avgScore: { $avg: "$score" } } } -> Option B

4. Quick Check:

   Correct syntax uses $avg with field string [OK]

Hint: Use $avg exactly, with field as "$fieldName" [OK]

Common Mistakes:

• Using $average instead of $avg
• Omitting quotes around field name
• Using $sum instead of $avg

3. Given the collection students with documents:

{ "name": "Alice", "score": 80 }, { "name": "Bob", "score": 90 }, { "name": "Charlie", "score": 70 }

What will be the output of this aggregation?

[{ $group: { _id: null, averageScore: { $avg: "$score" } } }]

medium

A. [{ "_id": null, "averageScore": 240 }]

B. [{ "_id": null, "averageScore": 70 }]

C. [{ "_id": null, "averageScore": 80 }]

D. [{ "_id": null, "averageScore": 90 }]

Solution

1. Step 1: Calculate the sum of scores

   Sum = 80 + 90 + 70 = 240.

2. Step 2: Calculate the average

   Average = 240 / 3 = 80.

3. Final Answer:

   [{ "_id": null, "averageScore": 80 }] -> Option C

4. Quick Check:

   Average of 80, 90, 70 = 80 [OK]

Hint: Add all scores, divide by count for average [OK]

Common Mistakes:

• Using sum instead of average
• Picking minimum or maximum score
• Forgetting to divide by number of documents

4. Consider this aggregation pipeline:

[{ $group: { _id: "$class", avgScore: { $avg: score } } }]

What is the error in this pipeline?

medium

A. Cannot use $avg inside $group

B. Missing $match stage before $group

C. The _id field cannot be "$class"

D. Field name 'score' should be a string with $ prefix: "$score"

Solution

1. Step 1: Check the field reference inside $avg

   The field name must be a string with a $ prefix, so it should be "$score", not score.

2. Step 2: Validate other parts of the pipeline

   Using "$class" as _id is valid, and $avg is allowed inside $group. $match is optional.

3. Final Answer:

   Field name 'score' should be a string with $ prefix: "$score" -> Option D

4. Quick Check:

   Field names in $avg need "$field" format [OK]

Hint: Always quote field names with $ in accumulators [OK]

Common Mistakes:

• Using unquoted field names inside $avg
• Thinking $match is mandatory before $group
• Believing _id cannot be a field name

5. You have a collection sales with documents:

{ "region": "North", "amount": 100 }, { "region": "South", "amount": 200 }, { "region": "North", "amount": 300 }, { "region": "South", "amount": 400 }

Write an aggregation pipeline to find the average sales amount per region and identify the region with the highest average sales.

hard

A. [{ $group: { _id: "$region", avgAmount: { $avg: "$amount" } } }, { $sort: { avgAmount: -1 } }, { $limit: 1 }]

B. [{ $group: { _id: "$region", avgAmount: { $sum: "$amount" } } }, { $sort: { avgAmount: 1 } }]

C. [{ $group: { _id: "$region", avgAmount: { $avg: "$amount" } } }, { $match: { avgAmount: { $gt: 300 } } }]

D. [{ $group: { _id: "$region", avgAmount: { $avg: "$amount" } } }, { $sort: { avgAmount: 1 } }, { $limit: 1 }]

Solution

1. Step 1: Group by region and calculate average

   Use $group with _id: "$region" and $avg: "$amount" to get average sales per region.

2. Step 2: Sort descending by average and limit to top

   Sort by avgAmount descending (-1) to get highest average first, then limit to 1 document.

3. Final Answer:

   [{ $group: { _id: "$region", avgAmount: { $avg: "$amount" } } }, { $sort: { avgAmount: -1 } }, { $limit: 1 }] -> Option A

4. Quick Check:

   Group, sort descending, limit 1 = highest average [OK]

Hint: Group by region, avg, sort desc, limit 1 for highest [OK]

Common Mistakes:

• Using $sum instead of $avg for average
• Sorting ascending to get highest average
• Not limiting results to top 1