$size operator for array length in MongoDB - Mini Project: Build & Apply

$size Operator for Array Length in MongoDB

📖 Scenario: You are managing a database for a book club. Each book document stores the title and a list of members who have read it.

🎯 Goal: Build a MongoDB query that finds books with exactly 3 readers using the $size operator.

📋 What You'll Learn

Create a collection named books with documents containing title and readers array fields.

Insert 3 book documents with specific titles and readers arrays.

Write a query using the $size operator to find books with exactly 3 readers.

Add a projection to show only the title field in the query result.

💡 Why This Matters

🌍 Real World

Managing book club data where you want to find books read by a specific number of members.

💼 Career

Filtering documents by array length is common in MongoDB for tasks like user activity tracking, inventory management, and social media data analysis.

1

Create the books collection with 3 documents

Insert 3 documents into the books collection with these exact entries: { title: "The Hobbit", readers: ["Alice", "Bob", "Charlie"] }, { title: "1984", readers: ["Dave", "Eve"] }, and { title: "Dune", readers: ["Frank", "Grace", "Heidi"] }.

MongoDB

// Insert the 3 book documents into the books collection
// Your code here

Hint

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

2

Set the target array length to 3

Create a variable called targetLength and set it to 3 to represent the number of readers to filter by.

MongoDB

db.books.insertMany([
  { title: "The Hobbit", readers: ["Alice", "Bob", "Charlie"] },
  { title: "1984", readers: ["Dave", "Eve"] },
  { title: "Dune", readers: ["Frank", "Grace", "Heidi"] }
])

// Create a variable targetLength and set it to 3
// Your code here

Hint

Use const targetLength = 3 to store the number 3.

3

Write a query using $size to find books with 3 readers

Write a MongoDB query using db.books.find() with a filter that uses { readers: { $size: targetLength } } to find books where the readers array length is exactly 3.

MongoDB

db.books.insertMany([
  { title: "The Hobbit", readers: ["Alice", "Bob", "Charlie"] },
  { title: "1984", readers: ["Dave", "Eve"] },
  { title: "Dune", readers: ["Frank", "Grace", "Heidi"] }
])

const targetLength = 3;

// Write a query to find books with readers array length equal to targetLength
// Your code here

Hint

Use { readers: { $size: targetLength } } inside find() to filter by array length.

4

Add a projection to show only the title field

Modify the query to include a projection that returns only the title field by adding { title: 1, _id: 0 } as the second argument to db.books.find().

MongoDB

db.books.insertMany([
  { title: "The Hobbit", readers: ["Alice", "Bob", "Charlie"] },
  { title: "1984", readers: ["Dave", "Eve"] },
  { title: "Dune", readers: ["Frank", "Grace", "Heidi"] }
])

const targetLength = 3;

db.books.find({ readers: { $size: targetLength } }, { title: 1, _id: 0 })
// Your code here

Hint

Add { title: 1, _id: 0 } as the second argument to find() to show only titles.

Practice

1. What does the $size operator do in MongoDB?

easy

A. Counts the number of elements in an array

B. Calculates the sum of numbers in an array

C. Finds the largest number in an array

D. Sorts the elements of an array

Solution

1. Step 1: Understand the purpose of $size

   The $size operator is used to count how many elements are inside an array field in a MongoDB document.

2. Step 2: Compare with other options

   Other options describe different operations like sum, max, or sort, which are not what $size does.

3. Final Answer:

   Counts the number of elements in an array -> Option A

4. Quick Check:

   $size = count array elements [OK]

Hint: Remember: $size counts array items, not values [OK]

Common Mistakes:

• Confusing $size with sum or max functions
• Thinking $size sorts arrays
• Using $size on non-array fields

2. Which of the following is the correct syntax to use $size in a MongoDB aggregation pipeline to add a field itemCount that counts elements in the items array?

easy

A. { $addFields: { itemCount: { $length: "$items" } } }

B. { $match: { itemCount: { $size: "$items" } } }

C. { $project: { itemCount: { $size: "items" } } }

D. { $addFields: { itemCount: { $size: "$items" } } }

Solution

1. Step 1: Identify correct operator usage in aggregation

   The $size operator is used inside an expression to count array elements. It must be inside a stage like $addFields or $project with the array field referenced as "$items".

2. Step 2: Check syntax correctness

   { $addFields: { itemCount: { $length: "$items" } } } uses a non-existent $length. { $project: { itemCount: { $size: "items" } } } misses the $ before items. { $match: { itemCount: { $size: "$items" } } } misuses $match with $size.

3. Final Answer:

   { $addFields: { itemCount: { $size: "$items" } } } -> Option D

4. Quick Check:

   Use $size inside $addFields with "$arrayField" [OK]

Hint: Use "$arrayField" inside $size in $addFields or $project [OK]

Common Mistakes:

• Using $length instead of $size
• Forgetting the $ before array field name
• Using $size inside $match incorrectly

3. Given the collection documents:

{ "name": "Alice", "tags": ["red", "blue"] }

{ "name": "Bob", "tags": ["green"] }

{ "name": "Carol", "tags": [] }

What will be the result of this aggregation pipeline?

[{ $project: { name: 1, tagCount: { $size: "$tags" } } }]

medium

A. [{ "name": "Alice", "tagCount": 2 }, { "name": "Bob", "tagCount": 1 }, { "name": "Carol", "tagCount": 0 }]

B. [{ "name": "Alice", "tagCount": 3 }, { "name": "Bob", "tagCount": 1 }, { "name": "Carol", "tagCount": 1 }]

C. [{ "name": "Alice", "tagCount": 2 }, { "name": "Bob", "tagCount": 0 }, { "name": "Carol", "tagCount": 0 }]

D. SyntaxError

Solution

1. Step 1: Understand $size counts array elements

   For each document, $size counts how many items are in the tags array: Alice has 2, Bob has 1, Carol has 0.

2. Step 2: Apply $project to include name and tagCount

   The pipeline projects the name and adds tagCount with the counted size.

3. Final Answer:

   [{ "name": "Alice", "tagCount": 2 }, { "name": "Bob", "tagCount": 1 }, { "name": "Carol", "tagCount": 0 }] -> Option A

4. Quick Check:

   Count array lengths with $size = correct counts [OK]

Hint: Count array length per document with $size in $project [OK]

Common Mistakes:

• Assuming empty arrays count as 1
• Mixing up counts for different documents
• Expecting syntax error for correct query

4. You wrote this aggregation stage to filter documents with exactly 3 tags:

{ $match: { tags: { $size: 3 } } }

But it returns an error. What is the problem?

medium

A. The array field name is missing the $ sign

B. The $match stage requires $expr to use $size

C. The number 3 should be in quotes as "3"

D. $size cannot be used inside $match like this

Solution

1. Step 1: Understand $size usage in $match

   Directly using $size inside $match like this is invalid because $size is an aggregation expression, not a query operator.

2. Step 2: Use $expr to evaluate aggregation expressions in $match

   To filter by array length, you must use $expr with $size, like: { $match: { $expr: { $eq: [ { $size: "$tags" }, 3 ] } } }.

3. Final Answer:

   The $match stage requires $expr to use $size -> Option B

4. Quick Check:

   Use $expr for aggregation expressions in $match [OK]

Hint: Use $expr to apply $size inside $match [OK]

Common Mistakes:

• Trying to use $size directly in $match
• Forgetting $expr wrapper
• Using quotes around numbers incorrectly

5. You want to find documents where the comments array has more than 2 elements. Which aggregation pipeline stage correctly filters these documents?

hard

A. { $match: { $size: { $gt: [ "$comments", 2 ] } } }

B. { $match: { comments: { $size: { $gt: 2 } } } }

C. { $match: { $expr: { $gt: [ { $size: "$comments" }, 2 ] } } }

D. { $match: { $expr: { $size: { $gt: [ "$comments", 2 ] } } } }

Solution

1. Step 1: Use $expr to evaluate expressions in $match

   To compare array length, use $expr to allow aggregation expressions inside $match.

2. Step 2: Use $gt with $size to check array length greater than 2

   The correct syntax is { $gt: [ { $size: "$comments" }, 2 ] } inside $expr.

3. Step 3: Eliminate incorrect options

   The incorrect options either lack $expr, misuse $size placement, or have wrong syntax for $gt.

4. Final Answer:

   { $match: { $expr: { $gt: [ { $size: "$comments" }, 2 ] } } } -> Option C

5. Quick Check:

   Filter by array length with $expr and $gt [OK]

Hint: Use $expr with $gt and $size to filter by array length [OK]

Common Mistakes:

• Using $size as a query operator inside $match
• Wrong order or structure of $gt and $size
• Missing $expr wrapper