$lookup for joining collections in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this $lookup aggregation?

Given two collections, orders and customers, what will be the result of this aggregation on orders?

MongoDB

db.orders.aggregate([
  {
    $lookup: {
      from: "customers",
      localField: "customerId",
      foreignField: "_id",
      as: "customer_info"
    }
  }
])

A The aggregation will fail with a syntax error due to missing pipeline stages.

B Each customer document will have an array of orders under 'customer_info'.

C Each order document will have a new field 'customer_info' containing an array with matching customer documents.

D The aggregation will return only orders that have no matching customer documents.

💡 Hint

Think about which collection the aggregation runs on and what $lookup does.

The $lookup stage adds a new array field to each input document (orders) containing matching documents from the 'from' collection (customers).

📝 Syntax

intermediate

Which $lookup syntax is correct?

Identify the valid $lookup stage syntax to join 'products' with 'categories' on 'categoryId' and '_id'.

A { $lookup: { from: 'categories', localField: 'categoryId', foreignField: '_id', as: 'category_info' } }

B { $lookup: { from: 'categories', localField: 'categoryId', foreignField: '_id' } }

C { $lookup: { from: 'categories', localField: 'categoryId', foreignField: 'categoryId', as: 'category_info' } }

D { $lookup: { from: 'categories', localField: '_id', foreignField: 'categoryId', as: 'category_info' } }

💡 Hint

localField is from the current collection, foreignField is from the joined collection.

Option A correctly matches 'categoryId' in products to '_id' in categories and specifies 'as' field.

❓ optimization

advanced

How to optimize $lookup for large collections?

You have two large collections: 'sales' and 'products'. Which approach optimizes $lookup performance best?

A Ensure 'products._id' is indexed and use $lookup with localField and foreignField.

B Use $lookup with pipeline and $match inside it to filter 'products' before joining.

C Load all 'products' into application memory and join manually.

D Use $lookup without indexes and rely on MongoDB to optimize automatically.

💡 Hint

Filtering early reduces data processed in join.

Using $lookup with a pipeline and $match filters the joined collection before joining, improving performance on large datasets.

🔧 Debug

advanced

Why does this $lookup return empty arrays?

Given these collections, why does this aggregation return empty arrays in 'joined_docs'?

MongoDB

db.collection1.aggregate([
  {
    $lookup: {
      from: "collection2",
      localField: "id",
      foreignField: "_id",
      as: "joined_docs"
    }
  }
])

A The aggregation pipeline is missing a $match stage.

B The 'from' collection name is misspelled.

C MongoDB does not support joining on '_id' fields.

D The 'id' field in collection1 and '_id' in collection2 have different data types.

💡 Hint

Check if the fields used for joining have the same type.

If the join fields have different types (e.g., string vs ObjectId), no matches occur, resulting in empty arrays.

🧠 Conceptual

expert

What is the main limitation of $lookup in MongoDB?

Which statement best describes a key limitation of $lookup when joining collections?

A $lookup requires both collections to be in the same database and cannot join across databases.

B $lookup can only perform left outer joins and cannot do inner joins directly.

C $lookup automatically indexes foreign fields for faster joins.

D $lookup can join collections with different data types without issues.

💡 Hint

Think about database boundaries and $lookup capabilities.

$lookup can only join collections within the same database; cross-database joins are not supported.