Why modeling decisions matter in MongoDB - Challenge Your Understanding

Challenge - 5 Problems

❓ query_result

intermediate

How does embedding affect query results?

Consider a MongoDB collection users where each user document embeds an array of orders. What will be the output of the following query?

db.users.find({ "orders.status": "shipped" })

Choose the correct description of the result.

MongoDB

db.users.find({ "orders.status": "shipped" })

A Returns all users regardless of order status.

B Returns only the orders with status 'shipped' from all users.

C Returns all users who have at least one order with status 'shipped'.

D Returns an error because you cannot query embedded arrays.

💡 Hint

Think about how MongoDB matches documents with embedded arrays.

The query matches user documents where the embedded orders array contains at least one element with status equal to 'shipped'. It returns the whole user document, not just the matching orders.

🧠 Conceptual

intermediate

Why choose referencing over embedding?

In MongoDB, when would referencing documents be a better modeling choice than embedding?

A When you want to avoid using indexes on related fields.

B When related data is large and changes frequently, and you want to avoid duplicating data.

C When you want to store all related data in one document for faster reads.

D When you want to prevent any relationships between collections.

💡 Hint

Think about data size and update frequency.

Referencing is better when related data is large or changes often, so you avoid duplicating data and keep documents smaller. Embedding is better for small, stable related data.

📝 Syntax

advanced

Identify the correct update syntax for embedded documents

Which of the following MongoDB update commands correctly sets the status field to 'delivered' for the order with orderId 123 inside the embedded orders array?

db.users.updateOne({ _id: 1, "orders.orderId": 123 }, ??? )

A { $set: { "orders.$.status": "delivered" } }

B { $set: { "orders.status": "delivered" } }

C { $update: { "orders.$.status": "delivered" } }

D { $set: { "orders[orderId=123].status": "delivered" } }

💡 Hint

Remember how to use the positional operator $ in updates.

The positional operator $ identifies the matched array element in the query filter. Option A correctly uses it to update the status field of the matching order.

❓ optimization

advanced

Optimizing queries with large embedded arrays

You have a products collection where each product document embeds a large array of reviews. Queries filtering by review rating are slow. What is the best way to optimize these queries?

A Move <code>reviews</code> to a separate collection and reference them from <code>products</code>.

B Increase the size limit of documents to hold more reviews.

C Embed more fields inside each review to avoid joins.

D Remove the <code>reviews</code> array and store reviews in a text field.

💡 Hint

Think about document size limits and query performance.

Embedding large arrays can slow queries and hit document size limits. Moving reviews to a separate collection and referencing them improves query speed and scalability.

🔧 Debug

expert

Diagnose the cause of inconsistent data in embedded documents

A MongoDB collection orders embeds customer details inside each order document. After some updates, customer addresses are inconsistent across orders for the same customer. What is the main reason for this inconsistency?

A MongoDB does not support embedded documents for customer data.

B The database automatically synchronizes embedded data, so inconsistency is impossible.

C Referencing customer data inside orders causes inconsistent addresses.

D Embedding customer data causes duplication, so updates to one order do not affect others.

💡 Hint

Consider how embedding duplicates data and update propagation.

Embedding duplicates customer data in each order. If you update the customer address in one order, other orders still have old data, causing inconsistency.