$facet for multiple pipelines in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Output of $facet with two pipelines

Given the following MongoDB aggregation pipeline using $facet, what is the output?

MongoDB

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

A [{ "totalSales": 500, "averageSales": 50 }]

B [{ "totalSales": [{ "_id": null, "total": 500 }], "averageSales": [{ "_id": null, "avg": 50 }] }]

C [{ "totalSales": [{ "total": 500 }], "averageSales": [{ "avg": 50 }] }]

D [{ "totalSales": [{ "_id": null, "total": 50 }], "averageSales": [{ "_id": null, "avg": 500 }] }]

💡 Hint

Remember that each facet pipeline returns an array of documents.

The $facet stage runs multiple pipelines and returns an object with arrays of results for each pipeline. Each pipeline's output is an array, even if it contains a single document.

📝 Syntax

intermediate

Identify the syntax error in $facet usage

Which option contains a syntax error in the use of $facet in MongoDB aggregation?

MongoDB

db.collection.aggregate([
  {
    $facet: {
      pipeline1: [ { $match: { status: "A" } } ],
      pipeline2: { $group: { _id: "$cust_id", total: { $sum: "$amount" } } }
    }
  }
])

A Using $group inside $facet is not allowed

B pipeline1 uses $match which is invalid inside $facet

C Missing comma between pipeline1 and pipeline2

D pipeline2 is not an array of stages, it is a single stage object

💡 Hint

Each pipeline inside $facet must be an array of stages.

In $facet, each pipeline must be an array of aggregation stages. Option D has pipeline2 as a single object, not an array, causing a syntax error.

❓ optimization

advanced

Optimizing $facet pipelines for performance

You have two pipelines inside a $facet stage: one counts documents with status 'A', the other calculates average amount for status 'B'. Which option optimizes performance best?

A Use $match for status 'A' and 'B' inside each pipeline separately

B Use $project to filter status inside each pipeline

C Use a single $match stage before $facet filtering status 'A' or 'B'

D Use $group first then $match inside each pipeline

💡 Hint

Filtering early reduces data processed in later stages.

Applying a $match stage before $facet filters the documents once, reducing the amount of data each pipeline processes, improving performance.

🔧 Debug

advanced

Why does this $facet pipeline return empty arrays?

Given this aggregation, why do both facets return empty arrays?

db.orders.aggregate([
  { $facet: {
      shipped: [ { $match: { status: "shipped" } }, { $count: "count" } ],
      pending: [ { $match: { status: "pending" } }, { $count: "count" } ]
    }
  }
])

A No documents have status 'shipped' or 'pending' in the collection

B The $count stage is misplaced and should be outside $facet

C The $match stages are invalid inside $facet

D The aggregation pipeline is missing a $group stage before $count

💡 Hint

Empty arrays mean no documents matched the filters.

If no documents match the $match conditions inside each facet pipeline, the output arrays will be empty. This usually means the collection has no documents with those statuses.

🧠 Conceptual

expert

Understanding $facet output structure

What is the structure of the output document from a MongoDB aggregation pipeline using $facet with three pipelines named 'A', 'B', and 'C'?

A A single document with keys 'A', 'B', 'C', each containing an array of documents from their respective pipelines

B An array of documents, each containing keys 'A', 'B', 'C' with single documents inside

C Multiple documents, one per pipeline, each with a key named after the pipeline

D A flat array combining all documents from pipelines 'A', 'B', and 'C'

💡 Hint

Think about how $facet groups results from multiple pipelines.

The $facet stage outputs a single document with keys for each pipeline. Each key holds an array of documents resulting from that pipeline.