$lookup for joining collections in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the $lookup stage do in a MongoDB aggregation pipeline?

It performs a left outer join to another collection in the same database, combining documents from both collections based on a matching field.

beginner

Which fields are required in a basic $lookup stage?

You need from (the collection to join), localField (field from input documents), foreignField (field from the from collection), and as (name of the new array field to add).

beginner

How does $lookup handle documents with no matching join field in the foreign collection?

It still includes the original document but adds an empty array in the as field, showing no matches were found.

intermediate

Can $lookup join collections on fields with different names?

Yes, by specifying localField and foreignField with the respective field names, even if they differ.

beginner

What is the output type of the joined data added by $lookup?

The joined data is added as an array field to each input document, containing all matching documents from the foreign collection.

What does the as field specify in a $lookup stage?

A The name of the new array field to store joined documents

B The foreign collection name

C The local field to match

D The condition to filter documents

The as field defines the name of the array field added to each document to hold the joined documents.

If no matching documents are found in the foreign collection, what does $lookup add?

A A null value

B An empty array in the <code>as</code> field

C No field is added

D An error is thrown

MongoDB adds an empty array in the as field to show no matches were found.

Which of these is NOT a required field in a basic $lookup?

A from

B localField

C pipeline

D foreignField

The pipeline field is optional and used for advanced joins; basic $lookup requires from, localField, and foreignField.

What type of join does $lookup perform?

A Inner join

B Right outer join

C Full outer join

D Left outer join

$lookup performs a left outer join, including all documents from the input collection.

Can $lookup join collections from different databases?

A No, only within the same database

B Yes, always

C Yes, but only with special permissions

D Only if collections have the same name

$lookup can only join collections within the same database.

Explain how the $lookup stage works in MongoDB aggregation pipelines.

Think about how two tables join in SQL but in MongoDB's document style.

Describe a scenario where you would use $lookup and what the result looks like.

Imagine combining customer info with their purchases.

Practice

1. What does the $lookup stage do in a MongoDB aggregation pipeline?

easy

A. It deletes documents from a collection.

B. It joins documents from two collections based on a matching field.

C. It sorts documents in ascending order.

D. It updates documents with new values.

Solution

1. Step 1: Understand the purpose of $lookup

   $lookup is used to combine documents from two collections by matching fields.

2. Step 2: Compare with other options

   Deleting, sorting, or updating documents are different operations and not related to $lookup.

3. Final Answer:

   It joins documents from two collections based on a matching field. -> Option B

4. Quick Check:

   $lookup joins collections = A [OK]

Hint: Remember: $lookup is like a join in SQL [OK]

Common Mistakes:

• Confusing $lookup with update or delete operations
• Thinking $lookup sorts documents
• Assuming $lookup modifies documents instead of joining

2. Which of the following is the correct syntax for a basic $lookup stage in MongoDB?

easy

A. { $lookup: { from: 'other', localField: 'id', foreignField: 'userId', joinAs: 'joinedData' } }

B. { $lookup: { collection: 'other', localKey: 'id', foreignKey: 'userId', output: 'joinedData' } }

C. { $lookup: { from: 'other', localField: 'id', foreignField: 'userId', as: 'joinedData' } }

D. { $lookup: { from: 'other', localField: 'id', foreignField: 'userId' } }

Solution

1. Step 1: Identify correct field names in $lookup

   The correct keys are from, localField, foreignField, and as.

2. Step 2: Check each option

   { $lookup: { from: 'other', localField: 'id', foreignField: 'userId', as: 'joinedData' } } uses all correct keys and syntax. Options A, B, and C have incorrect or missing keys.

3. Final Answer:

   { $lookup: { from: 'other', localField: 'id', foreignField: 'userId', as: 'joinedData' } } -> Option C

4. Quick Check:

   Correct $lookup keys = D [OK]

Hint: Use keys: from, localField, foreignField, as [OK]

Common Mistakes:

• Using wrong key names like collection or joinAs
• Omitting the 'as' field for output array
• Missing foreignField or localField keys

3. Given two collections: orders with documents { _id: 1, productId: 101 } and products with documents { _id: 101, name: 'Pen' }, what will be the result of this aggregation on orders?

{ $lookup: { from: 'products', localField: 'productId', foreignField: '_id', as: 'productInfo' } }

medium

A. [{ _id: 1, productId: 101, productInfo: [{ _id: 101, name: 'Pen' }] }]

B. [{ _id: 1, productId: 101, productInfo: [] }]

C. [{ _id: 1, productId: 101 }]

D. SyntaxError

Solution

1. Step 1: Match localField and foreignField values

   The productId in orders is 101, which matches _id 101 in products.

2. Step 2: Understand $lookup output

   The matching product document is added as an array in productInfo.

3. Final Answer:

   [{ _id: 1, productId: 101, productInfo: [{ _id: 101, name: 'Pen' }] }] -> Option A

4. Quick Check:

   Matching product added in array = B [OK]

Hint: Matched docs appear in array named by 'as' [OK]

Common Mistakes:

• Expecting productInfo to be a single object, not an array
• Thinking no match means error instead of empty array
• Ignoring the 'as' field name in output

4. What is wrong with this $lookup stage?

{ $lookup: { from: 'users', localField: 'userId', foreignField: 'id', as: 'userDetails' } }

Assuming the users collection uses _id as the user ID field.

medium

A. The 'as' field cannot be 'userDetails'.

B. The localField should be 'id' instead of 'userId'.

C. The 'from' field should be 'user' not 'users'.

D. The foreignField should be '_id' instead of 'id'.

Solution

1. Step 1: Check foreignField correctness

   The users collection uses _id as the ID field, so foreignField must be '_id'.

2. Step 2: Verify other fields

   localField and as are valid; collection name 'users' is correct.

3. Final Answer:

   The foreignField should be '_id' instead of 'id'. -> Option D

4. Quick Check:

   foreignField must match actual field = C [OK]

Hint: Match foreignField to actual field name in other collection [OK]

Common Mistakes:

• Using wrong foreignField name
• Changing 'as' field unnecessarily
• Mistaking collection name pluralization

5. You have two collections: students with { _id: 1, name: 'Alice' } and grades with multiple documents per student like { studentId: 1, score: 85 }. How do you write a $lookup to get each student with all their grades in an array called allGrades?

hard

A. { $lookup: { from: 'grades', localField: '_id', foreignField: 'studentId', as: 'allGrades' } }

B. { $lookup: { from: 'grades', localField: 'studentId', foreignField: '_id', as: 'allGrades' } }

C. { $lookup: { from: 'grades', localField: 'name', foreignField: 'studentId', as: 'allGrades' } }

D. { $lookup: { from: 'grades', localField: '_id', foreignField: 'score', as: 'allGrades' } }

Solution

1. Step 1: Identify matching fields between collections

   students._id matches grades.studentId, so these are the fields to join on.

2. Step 2: Write $lookup with correct fields and output array name

   Use from: 'grades', localField: '_id', foreignField: 'studentId', and as: 'allGrades'.

3. Final Answer:

   { $lookup: { from: 'grades', localField: '_id', foreignField: 'studentId', as: 'allGrades' } } -> Option A

4. Quick Check:

   Match student _id to grades studentId = A [OK]

Hint: Join on matching ID fields, output array named by 'as' [OK]

Common Mistakes:

• Swapping localField and foreignField
• Using wrong fields like name or score for join
• Incorrect output array name