$facet for multiple pipelines in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

The $facet stage allows running multiple aggregation pipelines within a single stage. It outputs a document where each field contains the results of one pipeline, letting you perform different analyses on the same input data simultaneously.

beginner

How does $facet help when you want to get multiple summaries from the same collection?

$facet runs multiple pipelines in parallel on the same input documents. This means you can get different summaries, like counts, averages, or filtered lists, all in one query without running multiple separate queries.

intermediate

Can you explain the output format of a $facet stage?

The output of $facet is a single document with fields named after each pipeline. Each field contains an array of documents that are the results of that pipeline. For example, { counts: [...], averages: [...] }.

intermediate

Why might you use $facet instead of running multiple aggregation queries?

Using $facet reduces the number of queries to the database, improving performance and consistency. It also simplifies code by combining multiple analyses into one pipeline.

beginner

Give an example use case for $facet in a real-world scenario.

Imagine an online store wanting to see total sales, average order value, and a list of top products all at once. $facet can run these three pipelines in parallel on the orders collection and return all results in one response.

What is the main purpose of the $facet stage in MongoDB?

A Filter documents based on a condition

B Run multiple aggregation pipelines in parallel on the same input

C Sort documents by a field

D Join two collections

$facet runs multiple pipelines simultaneously on the same input documents.

What type of output does $facet produce?

A A document with fields containing arrays of results from each pipeline

B A single array of documents

C A count of documents

D A sorted list of documents

$facet outputs a document where each field holds an array of results from its pipeline.

Which of these is NOT a benefit of using $facet?

A Automatically indexing fields

B Reducing the number of database queries

C Getting consistent results from the same data snapshot

D Combining multiple analyses in one query

$facet does not create indexes; it runs multiple pipelines in one aggregation.

If you want to get both total count and average value from a collection in one query, which stage helps?

A <code>$match</code>

B <code>$group</code>

C <code>$facet</code>

D <code>$sort</code>

$facet can run separate pipelines for count and average simultaneously.

Inside a $facet stage, how do you define each pipeline?

A As a single aggregation stage

B As a query filter

C As a JavaScript function

D As an array of aggregation stages under a named field

Each pipeline is an array of stages assigned to a field name inside $facet.

Describe how the $facet stage works and why it is useful in MongoDB aggregation.

Think about running many analyses on the same data at once.

Explain the structure of the output document from a $facet stage with two pipelines named 'counts' and 'averages'.

Imagine the output as a box with two labeled compartments holding lists.

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