Array expressions ($size, $arrayElemAt, $filter) in MongoDB - Mini Project: Build & Apply

Working with Array Expressions in MongoDB: $size, $arrayElemAt, $filter

📖 Scenario: You are managing a small online bookstore database. Each book document contains an array of reviews from readers. You want to analyze these reviews to understand how many reviews each book has, pick a specific review, and filter reviews based on rating.

🎯 Goal: Build a MongoDB aggregation pipeline that uses $size to count reviews, $arrayElemAt to pick a specific review, and $filter to select reviews with a rating above a threshold.

📋 What You'll Learn

Create a collection called books with documents containing a title and an array field reviews.

Add a variable minRating to set the minimum rating for filtering reviews.

Write an aggregation pipeline that adds fields: reviewCount using $size, firstReview using $arrayElemAt, and goodReviews using $filter with minRating.

Complete the pipeline by projecting the new fields along with the book title.

💡 Why This Matters

🌍 Real World

Analyzing customer reviews in an online bookstore to understand feedback quantity and quality.

💼 Career

Using MongoDB aggregation with array expressions is common in data analysis and backend development roles.

1

Create the books collection with sample data

Create a MongoDB collection called books with two documents. Each document must have a title string and a reviews array with exactly these objects: { reviewer: "Alice", rating: 5 }, { reviewer: "Bob", rating: 3 }, and { reviewer: "Charlie", rating: 4 } for the first book, and { reviewer: "Dave", rating: 2 }, { reviewer: "Eve", rating: 5 } for the second book.

MongoDB

// Insert the two book documents with the exact titles and reviews arrays
// Your code here

Hint

Use db.books.insertMany([...]) with the exact documents as described.

2

Set the minimum rating threshold

Create a variable called minRating and set it to the number 4. This will be used to filter reviews with ratings 4 or higher.

MongoDB

db.books.insertMany([...])

// Create a variable minRating and set it to 4
// Your code here

Hint

Use const minRating = 4 to define the threshold.

3

Build the aggregation pipeline with $size, $arrayElemAt, and $filter

Write an aggregation pipeline on books that adds three new fields: reviewCount using $size on reviews, firstReview using $arrayElemAt to get the first review (index 0), and goodReviews using $filter to include only reviews with rating greater than or equal to minRating. Use $addFields stage.

MongoDB

db.books.insertMany([...])

const minRating = 4

// Write an aggregation pipeline with $addFields to add reviewCount, firstReview, and goodReviews
// Your code here

Hint

Use $addFields with $size, $arrayElemAt, and $filter as shown.

4

Project the final fields including the title

Complete the aggregation pipeline by adding a $project stage that includes title, reviewCount, firstReview, and goodReviews fields only.

MongoDB

db.books.insertMany([...])

const minRating = 4

db.books.aggregate([
  {
    $addFields: {
      reviewCount: { $size: "$reviews" },
      firstReview: { $arrayElemAt: ["$reviews", 0] },
      goodReviews: {
        $filter: {
          input: "$reviews",
          as: "review",
          cond: { $gte: ["$$review.rating", minRating] }
        }
      }
    }
  },
  // Add a $project stage here to include title, reviewCount, firstReview, goodReviews
  // Your code here
])

Hint

Use $project to include only the specified fields with value 1.

Practice

1. What does the MongoDB expression $size do when used on an array field?

easy

A. Counts how many elements are in the array

B. Returns the first element of the array

C. Filters elements based on a condition

D. Sorts the array elements

Solution

1. Step 1: Understand the purpose of $size

   The $size operator counts the number of elements inside an array.

2. Step 2: Compare with other operators

   $arrayElemAt picks an element by position, $filter selects elements by condition, and sorting is unrelated.

3. Final Answer:

   Counts how many elements are in the array -> Option A

4. Quick Check:

   $size = count elements [OK]

Hint: Remember $size counts array length, not elements themselves [OK]

Common Mistakes:

• Confusing $size with $arrayElemAt
• Thinking $size filters elements
• Assuming $size sorts arrays

2. Which of the following is the correct syntax to get the third element of an array field named items using MongoDB aggregation?

easy

A. { $arrayElemAt: ["items", 3] }

B. { $size: ["$items", 2] }

C. { $arrayElemAt: ["$items", 2] }

D. { $filter: { input: "$items", as: "item", cond: { $eq: ["$$item", 2] } } }

Solution

1. Step 1: Recall zero-based indexing in $arrayElemAt

   The third element is at index 2 because counting starts at 0.

2. Step 2: Check syntax correctness

   The correct syntax uses $arrayElemAt with the array field prefixed by $ and the zero-based index.

3. Final Answer:

   { $arrayElemAt: ["$items", 2] } -> Option C

4. Quick Check:

   Third element index = 2 [OK]

Hint: Remember arrays start at 0, so third element is index 2 [OK]

Common Mistakes:

• Using 1-based index instead of 0-based
• Missing $ before field name
• Confusing $size with $arrayElemAt

3. Given the document { scores: [10, 20, 30, 40] }, what will the aggregation expression { $size: "$scores" } return?

medium

A. 4

B. 30

C. [10, 20, 30, 40]

D. Error

Solution

1. Step 1: Understand what $size does

   $size counts the number of elements in the array.

2. Step 2: Count elements in the array

   The array [10, 20, 30, 40] has 4 elements.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Array length = 4 [OK]

Hint: Count elements inside brackets for $size result [OK]

Common Mistakes:

• Returning the third element instead of count
• Returning the whole array instead of count
• Assuming syntax error

4. Identify the error in this MongoDB aggregation expression: { $arrayElemAt: ["$values", "1"] }

medium

A. Field name missing $ prefix

B. Index must be a number, not a string

C. Array must be inside an object

D. No error, expression is correct

Solution

1. Step 1: Check the type of index in $arrayElemAt

   The index must be a number, but here it is a string "1".

2. Step 2: Confirm correct field referencing

   The field name "$values" is correctly prefixed with $.

3. Final Answer:

   Index must be a number, not a string -> Option B

4. Quick Check:

   Index type = number, not string [OK]

Hint: Use number type for index in $arrayElemAt [OK]

Common Mistakes:

• Using string instead of number for index
• Omitting $ before field name
• Thinking array must be wrapped differently

5. You have documents with a field tags as an array of strings. How would you write a MongoDB aggregation expression to get the count of tags that start with the letter 'a'?

hard

A. { $size: "$tags" }

B. { $arrayElemAt: ["$tags", 0] }

C. { $filter: { input: "$tags", as: "tag", cond: { $eq: ["$$tag", "a"] } } }

D. { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } }

Solution

1. Step 1: Use $filter to select tags starting with 'a'

   The $filter operator creates a new array with tags matching the regex /^a/.

2. Step 2: Use $size to count filtered tags

   $size counts how many tags matched the condition.

3. Final Answer:

   { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } } -> Option D

4. Quick Check:

   Filter then count = correct approach [OK]

Hint: Filter first, then count with $size for conditional counts [OK]

Common Mistakes:

• Using $arrayElemAt instead of $filter
• Filtering with exact match instead of regex
• Counting whole array without filtering