Embedded documents (nested objects) in MongoDB - Step-by-Step Execution

Concept Flow - Embedded documents (nested objects)

Start with main document

↓

Add embedded document as a field

↓

Store nested object inside main document

↓

Query main document

↓

Access nested fields via dot notation

↓

Use or update nested data

↓

End

This flow shows how a main document contains an embedded document as a nested object, which can be accessed or updated using dot notation.

Execution Sample

MongoDB

db.users.insertOne({
  name: "Alice",
  address: { city: "NY", zip: "10001" }
})

Insert a user document with an embedded address object containing city and zip.

Execution Table

Step	Action	Document State	Result
1	Prepare main document with name field	{ name: "Alice" }	Document ready for insertion
2	Add embedded document 'address' with city and zip	{ name: "Alice", address: { city: "NY", zip: "10001" } }	Document now has nested object
3	Insert document into 'users' collection	Stored document	Document saved with nested address
4	Query document by name	Find document with name 'Alice'	{ name: "Alice", address: { city: "NY", zip: "10001" } }
5	Access nested field 'address.city'	Access field	"NY"
6	Update nested field 'address.zip' to '10002'	Modify nested field	Updated document with zip '10002'
7	Query updated document	Find document	{ name: "Alice", address: { city: "NY", zip: "10002" } }

💡 All steps complete; document inserted, queried, and updated with embedded document.

Variable Tracker

Variable	Start	After Step 2	After Step 6	Final
document	{}	{ name: "Alice", address: { city: "NY", zip: "10001" } }	{ name: "Alice", address: { city: "NY", zip: "10002" } }	{ name: "Alice", address: { city: "NY", zip: "10002" } }

Key Moments - 2 Insights

Why do we use dot notation to access nested fields?

Dot notation lets us reach inside the embedded document fields, like 'address.city', as shown in execution_table step 5.

Can we update just one field inside the embedded document without replacing the whole object?

Yes, as in step 6, we update 'address.zip' directly without changing 'address.city' or the whole document.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the value of 'address.city'?

A "NY"

B "10001"

C "Alice"

D null

💡 Hint

Check the 'Result' column at step 5 in execution_table.

At which step does the zip code change from '10001' to '10002'?

A Step 3

B Step 4

C Step 6

D Step 7

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for the update operation.

If we remove the embedded document 'address', what would the document look like after insertion?

A { address: { city: "NY", zip: "10001" } }

B { name: "Alice" }

C {}

D { name: "Alice", address: null }

💡 Hint

Refer to the initial document state before adding the embedded document in execution_table step 1.

Concept Snapshot

Embedded documents store nested objects inside a main document.
Use dot notation to access or update nested fields.
Insert documents with embedded objects as normal fields.
Updates can target nested fields without replacing whole objects.
Queries can filter or project nested fields using dot notation.

Full Transcript

This visual execution trace shows how embedded documents work in MongoDB. We start with a main document containing a name field. Then we add an embedded document called address with city and zip fields. The document is inserted into the users collection. We query the document by name and access the nested city field using dot notation. We update the zip field inside the embedded address document without replacing the entire address. Finally, we query the updated document to see the changes. This demonstrates how nested objects are stored, accessed, and updated inside MongoDB documents.

Practice

1. What is an embedded document in MongoDB?

easy

A. A document stored inside another document as a nested object

B. A separate collection linked by an ID

C. A document stored in a different database

D. A document stored as a file on disk

Solution

1. Step 1: Understand MongoDB document structure

   MongoDB stores data in documents, which can contain nested objects called embedded documents.

2. Step 2: Identify embedded document meaning

   An embedded document is a document inside another document, not a separate collection or file.

3. Final Answer:

   A document stored inside another document as a nested object -> Option A

4. Quick Check:

   Embedded document = nested object inside document [OK]

Hint: Think of a box inside another box holding related info [OK]

Common Mistakes:

• Confusing embedded documents with references
• Thinking embedded documents are separate collections
• Assuming embedded documents are stored outside the database

2. Which of the following is the correct way to insert an embedded document in MongoDB?

easy

A. db.collection.insertOne([{name: 'Alice'}, {address: {city: 'NY', zip: 10001}}])

B. db.collection.insertOne({name: 'Alice'}, {address: {city: 'NY', zip: 10001}})

C. db.collection.insertOne(name: 'Alice', address: {city: 'NY', zip: 10001})

D. db.collection.insertOne({name: 'Alice', address: {city: 'NY', zip: 10001}})

Solution

1. Step 1: Review MongoDB insertOne syntax

   insertOne takes a single document object with fields and values, including nested objects.

2. Step 2: Check each option's syntax

   db.collection.insertOne({name: 'Alice', address: {city: 'NY', zip: 10001}}) correctly nests the address object inside the main document. Others have syntax errors or wrong structure.

3. Final Answer:

   db.collection.insertOne({name: 'Alice', address: {city: 'NY', zip: 10001}}) -> Option D

4. Quick Check:

   Nested object inside one document = correct insert [OK]

Hint: Use one object with nested braces for embedded docs [OK]

Common Mistakes:

• Passing multiple objects instead of one
• Missing curly braces around nested document
• Using array instead of object for embedded document

3. Given the document { name: 'Bob', contact: { email: '[e-mail]', phone: '1234' } }, what will the query db.users.find({ 'contact.email': '[e-mail]' }) return?

medium

A. No documents, because nested fields can't be queried

B. All documents where contact.email equals '[e-mail]'

C. Documents where name equals '[e-mail]'

D. Documents where contact is exactly '[e-mail]'

Solution

1. Step 1: Understand dot notation in queries

   MongoDB uses dot notation to query fields inside embedded documents.

2. Step 2: Analyze the query

   The query looks for documents where the embedded field contact.email matches the given value.

3. Final Answer:

   All documents where contact.email equals '[e-mail]' -> Option B

4. Quick Check:

   Dot notation queries embedded fields correctly [OK]

Hint: Use dot notation to access nested fields in queries [OK]

Common Mistakes:

• Trying to match entire embedded document instead of field
• Using wrong field name without dot notation
• Assuming nested fields can't be queried

4. What is wrong with this update query to change the city in an embedded address document?
db.users.updateOne({name: 'Eve'}, {address.city: 'LA'})

medium

A. The field name should not use dot notation

B. The query filter is incorrect

C. The update document is missing the $set operator

D. updateOne cannot update embedded documents

Solution

1. Step 1: Recall updateOne syntax

   updateOne requires an update operator like $set to specify fields to change.

2. Step 2: Identify missing $set operator

   The query tries to update address.city directly without $set, which is invalid syntax.

3. Final Answer:

   The update document is missing the $set operator -> Option C

4. Quick Check:

   Updates need $set for field changes [OK]

Hint: Always use $set to update fields, including nested ones [OK]

Common Mistakes:

• Forgetting $set in update document
• Using dot notation incorrectly in filter
• Thinking updateOne can't change nested fields

5. You want to store multiple phone numbers inside a user's document using embedded documents. Which schema design is best?

hard

A. { name: 'Sam', phones: [{ type: 'home', number: '111' }, { type: 'work', number: '222' }] }

B. { name: 'Sam', phone1: '111', phone2: '222' }

C. { name: 'Sam', phones: { home: '111', work: '222' } }

D. { name: 'Sam', phones: '111,222' }

Solution

1. Step 1: Understand storing multiple embedded documents

   To store multiple related items, use an array of embedded documents for flexibility and clarity.

2. Step 2: Compare options

   { name: 'Sam', phones: [{ type: 'home', number: '111' }, { type: 'work', number: '222' }] } uses an array of objects with type and number, which is clear and scalable. Others are less flexible or harder to query.

3. Final Answer:

   { name: 'Sam', phones: [{ type: 'home', number: '111' }, { type: 'work', number: '222' }] } -> Option A

4. Quick Check:

   Array of embedded docs best for multiple related items [OK]

Hint: Use arrays of objects for multiple related embedded documents [OK]

Common Mistakes:

• Storing multiple values as comma-separated string
• Using separate fields for each phone number
• Using a single object without array for multiple items