$lookup with pipeline (advanced join) in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this $lookup with pipeline?

Given two collections orders and products, what will be the result of the following aggregation on orders?

{
  $lookup: {
    from: "products",
    let: { product_id: "$productId" },
    pipeline: [
      { $match: { $expr: { $eq: ["$_id", "$$product_id"] } } },
      { $project: { name: 1, price: 1, _id: 0 } }
    ],
    as: "productDetails"
  }
}

Assume orders has a document { _id: 1, productId: 101, quantity: 2 } and products has { _id: 101, name: "Pen", price: 1.5 }.

A [{ _id: 1, productId: 101, quantity: 2, productDetails: [{ name: "Pen", price: 1.5 }] }]

B [{ _id: 1, productId: 101, quantity: 2, productDetails: [{ _id: 101, name: "Pen", price: 1.5 }] }]

C [{ _id: 1, productId: 101, quantity: 2, productDetails: [] }]

D SyntaxError: Invalid $lookup pipeline syntax

💡 Hint

Remember that $project can exclude _id by setting it to 0.

The $lookup uses a pipeline to match products._id with orders.productId. The $project excludes _id, so the embedded productDetails array contains only name and price.

📝 Syntax

intermediate

Which $lookup pipeline syntax is invalid?

Identify the option that will cause a syntax error in a MongoDB aggregation $lookup stage using a pipeline.

A { $lookup: { from: "items", let: { id: "$itemId" }, pipeline: [ { $match: { $expr: { $eq: ["$_id", "$id"] } } } ], as: "details" } }

B } } "sliated" :sa ,] } } } ]"di$$" ,"di_$"[ :qe$ { :rpxe$ { :hctam$ { [ :enilepip ,} "dImeti$" :di { :tel ,"smeti" :morf { :pukool$ {

C { $lookup: { from: "items", let: { id: "$itemId" }, pipeline: [ { $match: { $expr: { $eq: ["$_id", "$$id"] } } } ], as: "details" } }

D $lookup: { from: "items", let: { id: "$itemId" }, pipeline: [ { $match: { $expr: { $eq: ["$_id", "$$id"] } } } ], as: "details" } }

💡 Hint

Check how variables are referenced inside the pipeline with let.

Variables defined in let must be referenced inside the pipeline with $$ prefix, e.g., "$$id". Option A uses "$id" which is invalid and causes a syntax error.

❓ optimization

advanced

How to optimize $lookup pipeline for large collections?

You have a $lookup with a pipeline joining orders to products. The products collection is very large. Which option best improves performance?

A Use $group in the pipeline to aggregate all products before matching

B Use $unwind on the <code>products</code> collection before $lookup

C Remove the pipeline and use simple localField/foreignField matching

D Add an index on <code>products._id</code> and use $match with $expr in the pipeline

💡 Hint

Indexes help queries run faster, especially on large collections.

Adding an index on products._id helps the $match stage inside the pipeline run efficiently. Using $expr with indexed fields is optimal. Other options either do not improve or degrade performance.

🔧 Debug

advanced

Why does this $lookup pipeline return empty arrays?

Given this aggregation on orders:

{
  $lookup: {
    from: "products",
    let: { pid: "$productId" },
    pipeline: [
      { $match: { $expr: { $eq: ["$_id", "$pid"] } } }
    ],
    as: "productInfo"
  }
}

It returns productInfo as empty arrays even though matching documents exist. What is the cause?

A The <code>productId</code> field does not exist in <code>orders</code>

B Variable <code>pid</code> is referenced incorrectly without <code>$$</code> prefix inside $expr

C The <code>from</code> collection name is misspelled

D The <code>$match</code> stage is missing a $project

💡 Hint

Check how variables from let are used inside the pipeline.

Variables defined in let must be referenced with $$ inside the pipeline. Here, "$pid" is incorrect; it should be "$$pid". Without this, the match fails and returns empty arrays.

🧠 Conceptual

expert

What is the main advantage of using $lookup with a pipeline over localField/foreignField?

Choose the best explanation for why you would use $lookup with a pipeline instead of the simpler localField/foreignField syntax.

A It automatically indexes the joined fields for better performance

B It always runs faster than localField/foreignField joins

C It allows complex filtering, transformations, and multiple stages on the joined collection before embedding results

D It returns results as a flat list instead of an array

💡 Hint

Think about flexibility and control over the joined data.

The pipeline form of $lookup lets you apply multiple aggregation stages like $match, $project, $group, etc., on the joined collection. This is not possible with the simple localField/foreignField syntax, which only matches equality.