Why Embedded documents (nested objects) in MongoDB? - Purpose & Use Cases

The Big Idea

Discover how keeping related data together can save you hours of searching and confusion!

The Scenario

Imagine you have a big filing cabinet with many folders, and each folder has papers about a person and their family members. To find details about a family member, you have to open many folders and shuffle through papers manually.

The Problem

This manual way is slow and confusing. You might lose papers or mix up information. It's hard to keep track of who belongs to which family, and updating details means searching through many folders again and again.

The Solution

Embedded documents let you keep related information together in one place, like putting all family members' details inside one folder. This way, you can find and update everything quickly without searching through many places.

Before vs After

✗ Before

{ name: 'John', family_member1: 'Anna', family_member2: 'Mike' }

✓ After

{ name: 'John', family: [{ name: 'Anna' }, { name: 'Mike' }] }

What It Enables

It enables storing and accessing related data as a single unit, making your database faster and easier to manage.

Real Life Example

Think of a social media app where each user has posts and comments. Embedded documents let you store all posts and comments inside the user's profile, so you can load everything about a user quickly.

Key Takeaways

Embedded documents group related data together.

This reduces searching and speeds up data access.

It simplifies updating and organizing complex information.

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