Embedded documents (nested objects) in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find documents with a nested field value

Given a collection users where each document has an embedded address object with fields city and zip, which query returns all users living in the city 'Springfield'?

MongoDB

db.users.find({"address.city": "Springfield"})

A db.users.find({"address": {"city": "Springfield"}})

B db.users.find({address: {city: "Springfield"}})

C db.users.find({"address.city": "Springfield"})

D db.users.find({city: "Springfield"})

💡 Hint

Use dot notation to query nested fields inside embedded documents.

Option C uses dot notation correctly to access the nested city field inside the address embedded document. Options B and C try to match the entire embedded document exactly, which will fail if other fields exist. Option C looks for a top-level city field, which does not exist.

❓ query_result

intermediate

Retrieve nested array elements in embedded documents

Consider a collection orders where each document has an embedded array items with objects containing product and quantity. Which query returns all orders that include an item with product equal to 'Pen'?

MongoDB

db.orders.find({"items.product": "Pen"})

A db.orders.find({product: "Pen"})

B db.orders.find({items: {product: "Pen"}})

C db.orders.find({"items": {"product": "Pen"}})

D db.orders.find({"items.product": "Pen"})

💡 Hint

Use dot notation to query fields inside objects within arrays.

Option D correctly uses dot notation to find documents where the items array contains an object with product equal to 'Pen'. Options B and C try to match the entire array or object exactly, which will fail if there are multiple items. Option D looks for a top-level product field, which does not exist.

📝 Syntax

advanced

Identify the syntax error in nested document update

Which update command correctly sets the nested field profile.contact.email to '[e-mail]' for the document with _id 1?

MongoDB

db.users.updateOne({_id: 1}, {$set: {"profile.contact.email": "[e-mail]"}})

A )}}"moc.elpmaxe@resu" :"liame.tcatnoc.eliforp"{ :tes${ ,}1 :di_{(enOetadpu.sresu.bd

B db.users.updateOne({_id: 1}, {$set: {"profile.contact.email": "[e-mail]"}})

C db.users.updateOne({_id: 1}, {$set: {profile: {contact: {email: "[e-mail]"}}}})

D db.users.updateOne({_id: 1}, {$set: {"profile": {"contact": {"email": "[e-mail]"}}}})

💡 Hint

Use quotes around the full nested field path when using dot notation in update operators.

Option B correctly uses quotes around the nested field path in dot notation. Option B is valid syntax but is duplicated here; the original Option B was invalid because keys with dots must be quoted. Options C and D replace the entire profile object, which may overwrite other fields unintentionally.

❓ optimization

advanced

Optimize query on nested fields with indexes

You have a collection products with embedded documents specs containing weight and color. Which index will best optimize queries filtering by specs.color?

A {"specs.color": 1}

B {"specs": 1}

C {"color": 1}

D {"specs.weight": 1}

💡 Hint

Indexes on nested fields use dot notation for the field name.

Option A creates an index on the nested field specs.color, which directly supports queries filtering by that field. Option A indexes the entire specs object, which is less efficient. Option A indexes a top-level color field that does not exist. Option A indexes a different nested field specs.weight.

🧠 Conceptual

expert

Understanding document size limits with embedded documents

MongoDB has a maximum document size of 16MB. Which statement about using embedded documents is true?

A Embedding large nested documents can cause the document to exceed the 16MB limit, so large data should be referenced instead.

B Embedded documents do not count towards the 16MB document size limit.

C MongoDB automatically splits large embedded documents into multiple documents to avoid size limits.

D The 16MB limit applies only to top-level fields, not to embedded documents.

💡 Hint

Consider how document size limits affect embedded data storage.

Option A is correct because the entire document, including embedded documents, counts towards the 16MB limit. Large nested data should be stored separately and referenced. Options B and D are false because embedded documents count fully towards the size limit. Option A is false because MongoDB does not split documents automatically.

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