One-to-many embedding pattern in MongoDB - Mini Project: Build & Apply

One-to-many embedding pattern in MongoDB

📖 Scenario: You are building a simple database for a library. Each book can have multiple reviews from readers. You want to store each book's information along with its reviews inside a single document to keep related data together.

🎯 Goal: Create a MongoDB collection where each book document contains an embedded array of review documents. This shows how to use the one-to-many embedding pattern in MongoDB.

📋 What You'll Learn

Create a collection named books with one book document.

The book document must have fields title and author with exact values.

Add an embedded array field reviews inside the book document.

Each review in reviews must have reviewer and comment fields.

Insert exactly two reviews with specified values.

💡 Why This Matters

🌍 Real World

Embedding related data like reviews inside a book document keeps all information together, making it faster to read and simpler to manage in many applications.

💼 Career

Understanding one-to-many embedding in MongoDB is essential for designing efficient NoSQL databases used in web development, content management, and many data-driven applications.

1

Create the books collection with one book document

Create a MongoDB document for the books collection with the fields title set to 'The Great Gatsby' and author set to 'F. Scott Fitzgerald'. Insert this document into the books collection.

MongoDB

// Insert the book document into the books collection
// Your code here

Hint

Use db.books.insertOne() with an object containing title and author.

2

Add an empty reviews array field to the book document

Update the existing book document in the books collection by adding an empty array field called reviews. Use updateOne with a filter on title and the $set operator.

MongoDB

db.books.insertOne({ title: 'The Great Gatsby', author: 'F. Scott Fitzgerald' })
// Add an empty reviews array to the book document
// Your code here

Hint

Use db.books.updateOne() with a filter on title and $set to add reviews: [].

3

Add two review documents inside the reviews array

Use updateOne with the $push operator and $each to add two review documents to the reviews array of the book with title 'The Great Gatsby'. The first review has reviewer 'Alice' and comment 'Loved the symbolism'. The second review has reviewer 'Bob' and comment 'A timeless classic'.

MongoDB

db.books.insertOne({ title: 'The Great Gatsby', author: 'F. Scott Fitzgerald' })
db.books.updateOne({ title: 'The Great Gatsby' }, { $set: { reviews: [] } })
// Add two reviews to the reviews array
// Your code here

Hint

Use $push with $each to add multiple review objects inside the reviews array.

4

Verify the final embedded document structure

Write a query using findOne to retrieve the book document with title 'The Great Gatsby' from the books collection. This will show the embedded reviews array inside the document.

MongoDB

db.books.insertOne({ title: 'The Great Gatsby', author: 'F. Scott Fitzgerald' })
db.books.updateOne({ title: 'The Great Gatsby' }, { $set: { reviews: [] } })
db.books.updateOne(
  { title: 'The Great Gatsby' },
  { $push: { reviews: { $each: [
    { reviewer: 'Alice', comment: 'Loved the symbolism' },
    { reviewer: 'Bob', comment: 'A timeless classic' }
  ] } } }
)
// Retrieve the book document with embedded reviews
// Your code here

Hint

Use db.books.findOne() with a filter on title to see the full document including embedded reviews.

Practice

1. What is the main advantage of using the one-to-many embedding pattern in MongoDB?

easy

A. It separates related data into different collections for better normalization.

B. It duplicates data across multiple documents to improve write speed.

C. It requires complex joins to retrieve related data.

D. It stores related data inside the main document for faster reads.

Solution

1. Step 1: Understand embedding in MongoDB

   Embedding means storing related data inside the main document instead of separate collections.

2. Step 2: Identify the advantage of embedding

   This approach makes reading related data faster and simpler because all data is in one place.

3. Final Answer:

   It stores related data inside the main document for faster reads. -> Option D

4. Quick Check:

   Embedding = faster reads [OK]

Hint: Embedding means related data inside main document for quick access [OK]

Common Mistakes:

• Confusing embedding with referencing (separate collections)
• Thinking embedding requires joins
• Assuming embedding duplicates data

2. Which of the following is the correct way to embed multiple comments inside a blog post document in MongoDB?

easy

A. { _id: 1, title: 'Post', comments: 'Alice: Nice!, Bob: Great!' }

B. { _id: 1, title: 'Post', comments: { user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' } }

C. { _id: 1, title: 'Post', comments: [{ user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' }] }

D. { _id: 1, title: 'Post', comments: [{ user: 'Alice' }, user: 'Bob', text: 'Great!' ] }

Solution

1. Step 1: Check the structure for embedding multiple comments

   Embedding many comments requires an array of objects inside the main document.

2. Step 2: Identify the correct JSON syntax

   { _id: 1, title: 'Post', comments: [{ user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' }] } correctly uses an array of comment objects inside the comments field.

3. Final Answer:

   { _id: 1, title: 'Post', comments: [{ user: 'Alice', text: 'Nice!' }, { user: 'Bob', text: 'Great!' }] } -> Option C

4. Quick Check:

   Array of objects = correct embedding [OK]

Hint: Embed many items as an array of objects inside the document [OK]

Common Mistakes:

• Using multiple objects without array brackets
• Storing comments as a string instead of objects
• Incorrect JSON syntax with misplaced commas or braces

3. Given the following document in a posts collection:

{ _id: 1, title: 'Hello', comments: [{ user: 'Alice', text: 'Hi' }, { user: 'Bob', text: 'Hello' }] }

What will be the result of the query db.posts.find({ _id: 1 }, { 'comments.user': 1, _id: 0 })?

medium

A. { comments: [{ user: 'Alice' }, { user: 'Bob' }] }

B. { comments: [{ text: 'Hi' }, { text: 'Hello' }] }

C. { _id: 1, comments: [{ user: 'Alice' }, { user: 'Bob' }] }

D. { comments: ['Alice', 'Bob'] }

Solution

1. Step 1: Understand the projection in the query

   The query projects only the comments.user field and excludes _id.

2. Step 2: Determine the output structure

   It returns the comments array with only the user fields inside each comment object.

3. Final Answer:

   { comments: [{ user: 'Alice' }, { user: 'Bob' }] } -> Option A

4. Quick Check:

   Projection of comments.user = array of user objects [OK]

Hint: Projection with dot notation returns array of objects with that field [OK]

Common Mistakes:

• Expecting full comment objects instead of only user fields
• Including _id when excluded in projection
• Getting array of strings instead of objects

4. You have this document:

{ _id: 1, name: 'Store', products: [{ name: 'Pen', price: 1.5 }, { name: 'Pencil', price: 1.0 }] }

Which update query correctly adds a new product { name: 'Eraser', price: 0.5 } to the products array?

medium

A. db.stores.updateOne({ _id: 1 }, { $push: { products: { name: 'Eraser', price: 0.5 } } })

B. db.stores.updateOne({ _id: 1 }, { $addToSet: { products: 'Eraser' } })

C. db.stores.updateOne({ _id: 1 }, { $set: { products: { name: 'Eraser', price: 0.5 } } })

D. db.stores.updateOne({ _id: 1 }, { $push: { products: ['Eraser', 0.5] } })

Solution

1. Step 1: Identify the correct operator to add an object to an array

   The $push operator adds an element to an array field.

2. Step 2: Check the value being pushed

   db.stores.updateOne({ _id: 1 }, { $push: { products: { name: 'Eraser', price: 0.5 } } }) pushes the correct object { name: 'Eraser', price: 0.5 } into the products array.

3. Final Answer:

   db.stores.updateOne({ _id: 1 }, { $push: { products: { name: 'Eraser', price: 0.5 } } }) -> Option A

4. Quick Check:

   $push with object adds to array [OK]

Hint: Use $push with full object to add to embedded array [OK]

Common Mistakes:

• Using $set replaces whole array instead of adding
• Using $addToSet with a string instead of object
• Pushing array instead of object inside array

5. You want to store a user's orders in a single document using one-to-many embedding. Each order has an orderId, date, and a list of items. Which schema design is best to handle up to 100 orders per user efficiently?

hard

A. Separate orders collection with userId reference for each order

B. { _id: userId, name: 'User', orders: [{ orderId, date, items: [{ productId, qty }] }] }

C. { _id: userId, name: 'User', orderIds: [orderId1, orderId2], orders: [] }

D. { _id: userId, name: 'User', orders: { orderId, date, items: [{ productId, qty }] } }

Solution

1. Step 1: Understand embedding for one-to-many with moderate size

   Embedding up to 100 orders inside a user document is reasonable for fast reads.

2. Step 2: Check schema design for correct embedding

   { _id: userId, name: 'User', orders: [{ orderId, date, items: [{ productId, qty }] }] } embeds an array of order objects, each with its own items array, which fits the one-to-many embedding pattern well.

3. Final Answer:

   { _id: userId, name: 'User', orders: [{ orderId, date, items: [{ productId, qty }] }] } -> Option B

4. Quick Check:

   Embed array of orders with nested items for one-to-many [OK]

Hint: Embed arrays of objects for moderate related data size [OK]

Common Mistakes:

• Using object instead of array for multiple orders
• Separating orders into another collection unnecessarily
• Storing only order IDs without details inside user