One-to-many embedding pattern in MongoDB - Step-by-Step Execution

Concept Flow - One-to-many embedding pattern

Start with main document

↓

Embed array of related documents

↓

Store all data in one document

↓

Query main document with embedded array

↓

Access embedded documents directly

↓

Update embedded documents as needed

↓

End

This flow shows how a main document contains an array of embedded related documents, allowing direct access and updates within a single document.

Execution Sample

MongoDB

db.authors.insertOne({
  name: "Alice",
  books: [
    { title: "Book A", year: 2020 },
    { title: "Book B", year: 2022 }
  ]
})

Insert an author document with an embedded array of book documents.

Execution Table

Step	Action	Document State	Result
1	Prepare author document with embedded books array	{ name: "Alice", books: [{title: "Book A", year: 2020}, {title: "Book B", year: 2022}] }	Document ready for insertion
2	Insert document into 'authors' collection	N/A	Document inserted with _id assigned
3	Query author by name	N/A	Returns document with embedded books array
4	Access embedded books array	{ books: [...] }	Can read all embedded book documents directly
5	Update year of 'Book A' to 2021	N/A	Embedded document updated inside main document
6	Query updated author document	N/A	Returns document with updated embedded book year
7	End of operation	N/A	Process complete

💡 All operations complete; embedded documents accessed and updated within main document.

Variable Tracker

Variable	Start	After Insert	After Update	Final
authorDocument	{}	{ name: "Alice", books: [{title: "Book A", year: 2020}, {title: "Book B", year: 2022}] }	{ name: "Alice", books: [{title: "Book A", year: 2021}, {title: "Book B", year: 2022}] }	{ name: "Alice", books: [{title: "Book A", year: 2021}, {title: "Book B", year: 2022}] }

Key Moments - 2 Insights

Why do we embed the books inside the author document instead of using separate collections?

Embedding keeps related data together, so when you query the author, you get all their books at once without extra queries, as shown in execution_table step 3 and 4.

How do we update a specific embedded book's field?

You update the embedded document inside the main document, as in step 5, by targeting the array element and changing its field directly.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what data structure holds the books?

A A separate collection linked by author ID

B An embedded array inside the author document

C A flat list outside the author document

D A single book document only

💡 Hint

Check the 'Document State' column at step 4 showing books inside the author document.

At which step does the embedded book's year get updated?

A Step 3

B Step 2

C Step 5

D Step 6

💡 Hint

Look at the 'Action' column describing the update operation.

If we added a new book to the embedded array, which step would be similar to that operation?

A Step 5 - updating an embedded document

B Step 3 - querying the document

C Step 1 - preparing the document

D Step 7 - end of operation

💡 Hint

Adding a book is like updating the embedded array, similar to the update in step 5.

Concept Snapshot

One-to-many embedding pattern:
- Store related many documents inside one main document as an array.
- Query returns main document with all embedded data.
- Update embedded documents directly inside main document.
- Good for data accessed together, avoids joins.
- Use when embedded data size is manageable.

Full Transcript

The one-to-many embedding pattern in MongoDB means putting many related items inside one main document as an array. For example, an author document can have an array of book documents inside it. This way, when you get the author, you get all their books at once. You can also update any embedded book directly inside the author document. This pattern is good when you want to keep related data together and avoid multiple queries. The example shows inserting an author with two books, querying the author, and updating a book's year inside the embedded array.

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