One-to-many referencing pattern in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find all orders for a specific customer

Given two collections, customers and orders, where orders references customers by customer_id, which query returns all orders for the customer with _id equal to 123?

A db.orders.find({ _id: 123 })

B db.customers.find({ _id: 123 }).orders

C db.orders.find({ customer_id: 123 })

D db.orders.aggregate([{ $match: { _id: 123 } }])

💡 Hint

Think about which collection stores the orders and how they link to customers.

Orders reference customers by customer_id, so to find orders for customer 123, filter orders where customer_id is 123.

📝 Syntax

intermediate

Correct syntax for referencing in MongoDB

Which of the following is the correct way to store a one-to-many reference from a customer document to multiple order documents using ObjectId references?

A { _id: ObjectId('abc'), orders: { o1: ObjectId('o1'), o2: ObjectId('o2') } }

B { _id: ObjectId('abc'), orders: 'o1,o2' }

C { _id: ObjectId('abc'), orders: ObjectId('o1') }

D { _id: ObjectId('abc'), orders: [ObjectId('o1'), ObjectId('o2')] }

💡 Hint

Think about how to store multiple references in an array.

An array of ObjectIds correctly represents multiple references; options A and D use wrong types, C only stores one reference.

❓ optimization

advanced

Efficiently retrieving customer with their orders

You want to retrieve a customer document along with all their orders in one query. Which MongoDB aggregation pipeline stage should you use to join customers and orders collections on _id and customer_id?

A { $group: { _id: '$customer_id', orders: { $push: '$$ROOT' } } }

B { $lookup: { from: 'orders', localField: '_id', foreignField: 'customer_id', as: 'orders' } }

C { $match: { customer_id: '_id' } }

D { $project: { orders: 1 } }

💡 Hint

Look for the stage that performs a left outer join.

$lookup performs a join between collections; other options do not join or filter correctly.

🔧 Debug

advanced

Why does this query return no orders?

A developer runs this query to find orders for customer with _id 'abc123': db.orders.find({ customer_id: 'abc123' }). But it returns no results, even though orders exist. What is the likely cause?

A customer_id is stored as ObjectId, but query uses string 'abc123'

B The orders collection is empty

C The query syntax is invalid

D The customer _id is incorrect

💡 Hint

Check the data types of the fields used in the query.

MongoDB matches types strictly; querying with a string won't match ObjectId fields.

🧠 Conceptual

expert

Best practice for one-to-many referencing in MongoDB

In a one-to-many relationship where a customer can have thousands of orders, what is the best practice for storing references in MongoDB?

A Store customer ObjectId inside each order document and query orders by customer_id

B Store an array of all order ObjectIds inside the customer document

C Embed all order documents inside the customer document

D Duplicate customer data inside each order document

💡 Hint

Consider document size limits and query efficiency.

Storing customer_id in orders avoids large arrays in customer documents and supports efficient queries.

Practice

1. What is the main purpose of the one-to-many referencing pattern in MongoDB?

easy

A. To create a backup of documents automatically

B. To store all related data inside a single document

C. To link one document to many related documents using their IDs

D. To encrypt documents for security

Solution

1. Step 1: Understand one-to-many referencing

   It connects one document to many others by storing their IDs, not embedding all data.

2. Step 2: Compare options

   Only To link one document to many related documents using their IDs describes linking documents by IDs, which is the core of one-to-many referencing.

3. Final Answer:

   To link one document to many related documents using their IDs -> Option C

4. Quick Check:

   One-to-many referencing = linking documents by IDs [OK]

Hint: One-to-many means one document points to many IDs [OK]

Common Mistakes:

• Thinking all data is stored inside one document
• Confusing referencing with embedding
• Assuming it creates backups automatically

2. Which of the following is the correct way to reference many comments in a post document using one-to-many referencing in MongoDB?

easy

A. { _id: 1, title: 'Post', comments: [ObjectId('abc123'), ObjectId('def456')] }

B. { _id: 1, title: 'Post', comments: { text: 'Nice post!' } }

C. { _id: 1, title: 'Post', comments: 'This is a comment' }

D. { _id: 1, title: 'Post', comments: ObjectId('abc123') }

Solution

1. Step 1: Identify referencing format

   One-to-many referencing stores an array of ObjectIds pointing to related documents.

2. Step 2: Check each option

   { _id: 1, title: 'Post', comments: [ObjectId('abc123'), ObjectId('def456')] } uses an array of ObjectIds, which is correct. Others embed data or use a single ID incorrectly.

3. Final Answer:

   { _id: 1, title: 'Post', comments: [ObjectId('abc123'), ObjectId('def456')] } -> Option A

4. Quick Check:

   Array of ObjectIds = correct referencing [OK]

Hint: Use array of ObjectIds to reference many documents [OK]

Common Mistakes:

• Embedding comment text instead of IDs
• Using a single ObjectId for many comments
• Storing comments as plain strings

3. Given these two collections:
posts: [{ _id: 1, title: 'Hello', comments: [101, 102] }]
comments: [{ _id: 101, text: 'Nice!' }, { _id: 102, text: 'Great!' }]
What will be the result of this query to find comments for post with _id 1?
db.comments.find({ _id: { $in: db.posts.findOne({ _id: 1 }).comments } })

medium

A. [] (empty array)

B. [{ _id: 1, title: 'Hello', comments: [101, 102] }]

C. SyntaxError due to nested query

D. [{ _id: 101, text: 'Nice!' }, { _id: 102, text: 'Great!' }]

Solution

1. Step 1: Understand the query

   The inner findOne gets the comments array [101, 102] from post _id 1.

2. Step 2: Use $in to find matching comments

   The outer find returns comments with _id in [101, 102], so both comment documents are returned.

3. Final Answer:

   [{ _id: 101, text: 'Nice!' }, { _id: 102, text: 'Great!' }] -> Option D

4. Quick Check:

   Find comments by IDs in post = matching comment docs [OK]

Hint: Use $in with IDs array to get related documents [OK]

Common Mistakes:

• Expecting post document instead of comments
• Thinking nested query causes syntax error
• Getting empty result by mistake

4. You have this post document:
{ _id: 1, title: 'Test', comments: ['abc', 'def'] }
But when you run db.comments.find({ _id: { $in: post.comments } }), it returns no results. What is the most likely problem?

medium

A. ObjectIds in post.comments are strings, not ObjectId type

B. The comments collection has no documents with those ObjectIds

C. The query syntax is incorrect for $in operator

D. The post document is missing the comments field

Solution

1. Step 1: Check data types of referenced IDs

   If post.comments contains strings instead of ObjectId objects, the query won't match.

2. Step 2: Confirm query correctness

   The query syntax is correct, so the mismatch is likely due to type difference.

3. Final Answer:

   ObjectIds in post.comments are strings, not ObjectId type -> Option A

4. Quick Check:

   Type mismatch in IDs causes no matches [OK]

Hint: Ensure referenced IDs are ObjectId type, not strings [OK]

Common Mistakes:

• Assuming empty results mean syntax error
• Ignoring data type differences
• Thinking missing field causes this error

5. You want to design a blog system with users, posts, and comments. Each user can write many posts, and each post can have many comments. Using one-to-many referencing, which is the best way to organize references?

hard

A. comments store userId; posts store arrays of commentIds

B. posts store userId; comments store postId; users do not store references

C. users embed all posts; posts embed all comments

D. users store arrays of postIds; posts store arrays of commentIds

Solution

1. Step 1: Understand one-to-many referencing best practice

   Usually, the 'many' side stores the reference to the 'one' side to avoid large arrays.

2. Step 2: Apply to blog system

   Posts store userId (one user, many posts), comments store postId (one post, many comments), users don't store arrays.

3. Final Answer:

   posts store userId; comments store postId; users do not store references -> Option B

4. Quick Check:

   Many side stores reference to one side [OK]

Hint: Store reference on 'many' side to 'one' side document [OK]

Common Mistakes:

• Embedding all posts or comments inside users or posts
• Storing large arrays on 'one' side documents
• Confusing which side stores the reference