$facet for multiple pipelines in MongoDB - Step-by-Step Execution

Concept Flow - $facet for multiple pipelines

Input Collection

↓

$facet Stage

↓

Pipeline1

↓

Results1

↓

Combined Output Document

The $facet stage takes the input documents and runs multiple pipelines in parallel, each producing its own result array. These arrays are combined into one output document.

Execution Sample

MongoDB

db.sales.aggregate([
  {
    $facet: {
      "totalSales": [ { $group: { _id: null, total: { $sum: "$amount" } } } ],
      "countByCategory": [ { $group: { _id: "$category", count: { $sum: 1 } } } ]
    }
  }
])

This query runs two pipelines in parallel: one sums all sales amounts, the other counts sales per category.

Execution Table

Step	Input Documents	Pipeline	Action	Intermediate Result	Output Array
1	[{amount: 10, category: 'A'}, {amount: 20, category: 'B'}, {amount: 15, category: 'A'}]	totalSales	Group all, sum amounts	{_id: null, total: 45}	[{_id: null, total: 45}]
2	[{amount: 10, category: 'A'}, {amount: 20, category: 'B'}, {amount: 15, category: 'A'}]	countByCategory	Group by category, count	[{_id: 'A', count: 2}, {_id: 'B', count: 1}]	[{_id: 'A', count: 2}, {_id: 'B', count: 1}]
3	N/A	Combine	Combine pipeline outputs into one document	N/A	{"totalSales": [{"_id": null, "total": 45}], "countByCategory": [{"_id": "A", "count": 2}, {"_id": "B", "count": 1}]}

💡 All pipelines processed input documents; combined output document created with results from each pipeline.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
totalSales	[]	[{_id: null, total: 45}]	[{_id: null, total: 45}]	[{_id: null, total: 45}]
countByCategory	[]	[]	[{_id: 'A', count: 2}, {_id: 'B', count: 1}]	[{_id: 'A', count: 2}, {_id: 'B', count: 1}]
combinedOutput	{}	{}	{}	{"totalSales": [{"_id": null, "total": 45}], "countByCategory": [{"_id": "A", "count": 2}, {"_id": "B", "count": 1}]}

Key Moments - 2 Insights

Why does $facet output a single document with multiple arrays instead of multiple documents?

Because $facet runs multiple pipelines in parallel on the same input and combines their results into one document with fields named after each pipeline, as shown in execution_table row 3.

Can pipelines inside $facet affect each other’s results?

No, each pipeline runs independently on the full input documents, so their results do not affect each other, as seen in execution_table rows 1 and 2.

Visual Quiz - 3 Questions

Look at the execution_table at Step 2, what is the intermediate result of the 'countByCategory' pipeline?

A [{_id: 'A', count: 2}, {_id: 'B', count: 1}]

B [{_id: null, total: 45}]

C [{_id: 'A', total: 25}]

D []

💡 Hint

Check the 'Intermediate Result' column for Step 2 in the execution_table.

At which step does the combined output document get created?

A Step 1

B Step 2

C Step 3

D No combined output is created

💡 Hint

Look for the step where 'Combine pipeline outputs into one document' is the action in execution_table.

If the input collection had no documents, what would the 'totalSales' array contain after Step 1?

A [{_id: null, total: 0}]

B []

C [{_id: null, total: null}]

D null

💡 Hint

Consider how $group behaves with no input documents; check variable_tracker for 'totalSales' initial state.

Concept Snapshot

$facet stage runs multiple pipelines on the same input.
Each pipeline produces an array of results.
All arrays are combined into one output document.
Use $facet to get multiple aggregations in one query.
Each pipeline runs independently and in parallel.

Full Transcript

The $facet stage in MongoDB aggregation lets you run multiple pipelines on the same input documents at once. Each pipeline processes the documents independently and produces its own array of results. These arrays are then combined into a single output document with fields named after each pipeline. For example, one pipeline can sum all sales amounts while another counts sales by category. The execution table shows how input documents flow through each pipeline step by step, and how the final combined output document is created. Variables track the results of each pipeline separately until they are combined. Beginners often wonder why $facet outputs one document with arrays instead of multiple documents, and why pipelines do not affect each other. The key is that $facet runs pipelines in parallel and merges their results into one document. This makes $facet very useful for getting multiple summaries or analyses in a single query.

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