$facet for multiple pipelines in MongoDB

Introduction

The $facet stage lets you run many different queries on the same data at once. It helps you get multiple results in one go.

You want to get counts and details from the same data without running separate queries.

You need to group data in different ways and see all results together.

You want to save time by running multiple analyses on your data in one step.

Syntax

MongoDB

db.collection.aggregate([
  {
    $facet: {
      pipeline1Name: [ /* stages for first pipeline */ ],
      pipeline2Name: [ /* stages for second pipeline */ ]
    }
  }
])

Each pipeline inside $facet runs independently on the same input data.

The output is one document with fields named after each pipeline, each holding an array of results.

Examples

This example calculates total and average sales in one query.

MongoDB

db.sales.aggregate([
  {
    $facet: {
      totalSales: [ { $group: { _id: null, total: { $sum: "$amount" } } } ],
      averageSales: [ { $group: { _id: null, avg: { $avg: "$amount" } } } ]
    }
  }
])

This example splits products into cheap and expensive lists.

MongoDB

db.products.aggregate([
  {
    $facet: {
      cheapProducts: [ { $match: { price: { $lt: 20 } } } ],
      expensiveProducts: [ { $match: { price: { $gte: 20 } } } ]
    }
  }
])

Sample Program

This query gets three results at once: total number of orders, count of orders by status, and the 3 most recent orders.

MongoDB

db.orders.aggregate([
  {
    $facet: {
      totalOrders: [ { $count: "count" } ],
      ordersByStatus: [ { $group: { _id: "$status", count: { $sum: 1 } } } ],
      recentOrders: [ { $sort: { orderDate: -1 } }, { $limit: 3 } ]
    }
  }
])

Important Notes

Each pipeline inside $facet can have multiple stages like $match, $group, $sort, etc.

The output document always has one field per pipeline, each containing an array of results.

Use $facet to avoid running multiple separate queries when you want different views of the same data.

Summary

$facet runs many pipelines on the same data at once.

It returns one document with results from each pipeline as separate arrays.

Great for getting multiple summaries or lists 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