$facet for multiple pipelines in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use $facet to run multiple pipelines in one aggregation.

MongoDB

db.collection.aggregate([{ $facet: { results: [[1]] } }])

Drag options to blanks, or click blank then click option'

A{ $limit: 5 }

B{ $match: { status: 'A' } }

C{ $sort: { score: -1 } }

D{ $group: { _id: '$status' } }

Attempts:

3 left

💡 Hint

Common Mistakes

Using a single stage object instead of an array.

Not wrapping the pipeline stages in an array.

The $facet stage requires an array of pipeline stages. Here, we start with a $match stage inside the 'results' pipeline.

2fill in blank

medium

Complete the code to add a second pipeline named 'counts' inside $facet.

MongoDB

db.collection.aggregate([{ $facet: { results: [{ $match: { status: 'A' } }], counts: [[1]] } }])

Drag options to blanks, or click blank then click option'

A{ $sort: { total: -1 } }

B{ $group: { _id: null } }

C{ $limit: 10 }

D{ $count: 'total' }

Attempts:

3 left

💡 Hint

Common Mistakes

Using $group without specifying an accumulator.

Using $sort or $limit instead of $count.

The $count stage counts the number of documents passing through the pipeline and outputs a document with the count.

3fill in blank

hard

Fix the error in the $facet stage by completing the missing pipeline for 'averageScore'.

MongoDB

db.collection.aggregate([{ $facet: { averageScore: [[1]] } }])

Drag options to blanks, or click blank then click option'

A{ $group: { _id: null, avgScore: { $avg: '$score' } } }

B{ $match: { score: { $exists: true } } }

C{ $sort: { score: 1 } }

D{ $limit: 1 }

Attempts:

3 left

💡 Hint

Common Mistakes

Using $match instead of $group for aggregation.

Not specifying the _id field in $group.

The $group stage with $avg accumulator calculates the average score across documents.

4fill in blank

hard

Fill both blanks to create two pipelines inside $facet: one for filtering active users and one for counting them.

MongoDB

db.users.aggregate([{ $facet: { activeUsers: [[1]], activeCount: [[2]] } }])

Drag options to blanks, or click blank then click option'

A{ $match: { active: true } }

B{ $count: 'count' }

C{ $group: { _id: '$active' } }

D{ $sort: { name: 1 } }

Attempts:

3 left

💡 Hint

Common Mistakes

Using $group instead of $count for counting.

Not filtering active users before counting.

The first pipeline filters active users with $match. The second pipeline counts them with $count.

5fill in blank

hard

Fill all three blanks to create pipelines inside $facet: one to sort by age, one to group by city, and one to count total documents.

MongoDB

db.people.aggregate([{ $facet: { sortedByAge: [[1]], groupedByCity: [[2]], totalCount: [[3]] } }])

Drag options to blanks, or click blank then click option'

A{ $sort: { age: 1 } }

B{ $group: { _id: '$city' } }

C{ $count: 'total' }

D{ $match: { age: { $gt: 18 } } }

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up $group and $count stages.

Not using $sort correctly for ordering.

The first pipeline sorts documents by age ascending. The second groups documents by city. The third counts total documents.

Practice

1. What does the $facet stage do in a MongoDB aggregation pipeline?

easy

A. Sorts documents in ascending or descending order.

B. Filters documents based on a condition.

C. Joins two collections together.

D. Runs multiple pipelines on the same input data and returns results in one document.

Solution

1. Step 1: Understand the purpose of $facet

   $facet allows running multiple aggregation pipelines on the same input data simultaneously.

2. Step 2: Identify the output structure

   The output is a single document containing separate arrays for each pipeline's results.

3. Final Answer:

   Runs multiple pipelines on the same input data and returns results in one document. -> Option D

4. Quick Check:

   $facet = multiple pipelines, one output document [OK]

Hint: Remember: $facet runs many pipelines at once [OK]

Common Mistakes:

• Thinking $facet filters or sorts data
• Confusing $facet with $lookup
• Assuming it returns multiple documents instead of one

2. Which of the following is the correct syntax to use $facet in a MongoDB aggregation pipeline?

easy

A. { $facet: { pipeline1: [ { $match: {} } ], pipeline2: [ { $group: {} } ] } }

B. { $facet: [ { $match: {} }, { $group: {} } ] }

C. { $facet: { $match: {}, $group: {} } }

D. { $facet: { pipeline1: { $match: {} }, pipeline2: { $group: {} } } }

Solution

1. Step 1: Recall $facet syntax

   $facet expects an object where each key is a pipeline name and the value is an array of pipeline stages.

2. Step 2: Check each option

   { $facet: { pipeline1: [ { $match: {} } ], pipeline2: [ { $group: {} } ] } } correctly uses an object with arrays of stages. Options A, C, and D misuse arrays or objects for stages.

3. Final Answer:

   { $facet: { pipeline1: [ { $match: {} } ], pipeline2: [ { $group: {} } ] } } -> Option A

4. Quick Check:

   $facet needs named pipelines with arrays of stages [OK]

Hint: Use named keys with arrays of stages inside $facet [OK]

Common Mistakes:

• Using arrays directly instead of named pipelines
• Putting stages as objects instead of arrays
• Missing pipeline names inside $facet

3. Given the collection sales with documents like { item: 'apple', price: 10, quantity: 2 }, what will be the output of this aggregation?

{ $facet: { totalSales: [ { $group: { _id: null, total: { $sum: { $multiply: ["$price", "$quantity"] } } } } ], items: [ { $group: { _id: "$item", count: { $sum: "$quantity" } } } ] } }

medium

A. [{ totalSales: [{ _id: null, total: 20 }], items: [{ _id: 'apple', count: 2 }] }]

B. [{ totalSales: 20, items: [{ _id: 'apple', count: 2 }] }]

C. [{ totalSales: [{ total: 20 }], items: [{ _id: 'apple', count: 2 }] }]

D. [{ totalSales: [{ _id: null, total: 12 }], items: [{ _id: 'apple', count: 2 }] }]

Solution

1. Step 1: Calculate totalSales pipeline

   Multiply price (10) by quantity (2) = 20, sum is 20, grouped with _id null.

2. Step 2: Calculate items pipeline

   Group by item 'apple', sum quantity 2, so count is 2.

3. Final Answer:

   [{ totalSales: [{ _id: null, total: 20 }], items: [{ _id: 'apple', count: 2 }] }] -> Option A

4. Quick Check:

   Each pipeline returns array with grouped results [OK]

Hint: Remember $facet outputs arrays for each pipeline [OK]

Common Mistakes:

• Expecting direct values instead of arrays
• Mixing up _id values in group results
• Forgetting $multiply inside $sum

4. You wrote this aggregation but get an error:

{ $facet: { sales: { $group: { _id: "$item", total: { $sum: "$quantity" } } } } }

What is the mistake?

medium

A. The $facet stage must be the last stage in the pipeline.

B. You cannot use $group inside $facet.

C. Pipeline stages inside $facet must be arrays, not objects.

D. The field names inside $group are incorrect.

Solution

1. Step 1: Check $facet syntax requirements

   Each pipeline inside $facet must be an array of stages, not a single object.

2. Step 2: Identify the error in the given code

   The pipeline 'sales' is given as an object with $group, missing array brackets.

3. Final Answer:

   Pipeline stages inside $facet must be arrays, not objects. -> Option C

4. Quick Check:

   $facet pipelines = arrays of stages [OK]

Hint: Always wrap pipeline stages in arrays inside $facet [OK]

Common Mistakes:

• Using object instead of array for pipeline stages
• Assuming $group is disallowed inside $facet
• Thinking $facet must be last stage

5. You want to get both the average price and a list of unique items from a products collection in one query. Which $facet pipeline correctly achieves this?

hard

A. { $facet: [ { $group: { _id: null, avg: { $avg: "$price" } } }, { $group: { _id: "$item" } } ] }

B. { $facet: { avgPrice: [ { $group: { _id: null, avg: { $avg: "$price" } } } ], uniqueItems: [ { $group: { _id: "$item" } } ] } }

C. { $facet: { avgPrice: { $avg: "$price" }, uniqueItems: { $addToSet: "$item" } } }

D. { $facet: { avgPrice: [ { $avg: "$price" } ], uniqueItems: [ { $addToSet: "$item" } ] } }

Solution

1. Step 1: Understand $facet structure

   Each facet must be a named pipeline with an array of stages.

2. Step 2: Check each option

   { $facet: { avgPrice: [ { $group: { _id: null, avg: { $avg: "$price" } } } ], uniqueItems: [ { $group: { _id: "$item" } } ] } } correctly uses two pipelines: one groups to get average price, the other groups by item to get unique items. Options B, C, and D misuse arrays or operators incorrectly.

3. Final Answer:

   { $facet: { avgPrice: [ { $group: { _id: null, avg: { $avg: "$price" } } } ], uniqueItems: [ { $group: { _id: "$item" } } ] } } -> Option B

4. Quick Check:

   Named pipelines with arrays of stages = correct $facet usage [OK]

Hint: Use separate pipelines with arrays for each facet [OK]

Common Mistakes:

• Using $facet with arrays instead of named pipelines
• Trying to use aggregation operators directly inside $facet
• Not grouping properly to get unique items