One-to-one embedding pattern in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find the embedded document in a one-to-one pattern

Given a collection users where each user document embeds a single profile document, what will be the output of the following query?

{ _id: 1, name: "Alice", profile: { age: 30, city: "NY" } }

Query:

db.users.findOne({ _id: 1 }, { "profile.city": 1, _id: 0 })

MongoDB

db.users.findOne({ _id: 1 }, { "profile.city": 1, _id: 0 })

A {"profile.city": "NY"}

B {"profile": {"city": "NY"}}

C {"city": "NY"}

D {"profile": {"age": 30, "city": "NY"}}

💡 Hint

Projection returns the embedded document fields as nested objects.

The projection { "profile.city": 1, _id: 0 } returns the profile field with only the city subfield included. The result nests city inside profile.

📝 Syntax

intermediate

Identify the correct syntax for embedding one-to-one documents

Which of the following MongoDB insert statements correctly embeds a one-to-one address document inside a customer document?

A db.customers.insertOne({ _id: 101, name: "Bob" }, { address: { street: "Main St", number: 123 } })

B db.customers.insertOne({ _id: 101, name: "Bob" }, { $set: { address: { street: "Main St", number: 123 } } })

C db.customers.insertOne({ _id: 101, name: "Bob", address: [ { street: "Main St", number: 123 } ] })

D db.customers.insertOne({ _id: 101, name: "Bob", address: { street: "Main St", number: 123 } })

💡 Hint

Embedding means nesting the document inside the main document in one insert.

Option D correctly nests the address document inside the customer document in a single insert. Options B and D use incorrect syntax for insertOne. Option D uses an array which is not one-to-one embedding.

❓ optimization

advanced

Optimize query performance for one-to-one embedded documents

You have a products collection where each product embeds a specs document. You want to frequently query products by a field inside specs, for example specs.weight. What is the best way to optimize these queries?

A Create an index on <code>specs.weight</code> field

B Create a text index on the entire <code>specs</code> document

C Split <code>specs</code> into a separate collection and use references

D Use aggregation pipeline to filter <code>specs.weight</code> after fetching all products

💡 Hint

Indexes speed up queries on specific fields.

Creating an index on specs.weight allows MongoDB to quickly find products by that field inside the embedded document. Text indexes are for string search, splitting collections adds complexity, and filtering after fetching all data is inefficient.

🔧 Debug

advanced

Debug why embedded document is missing in query result

You have documents with embedded profile in users. You run this query:

db.users.find({}, { name: 1 })

But the profile field is missing in the results. Why?

MongoDB

db.users.find({}, { name: 1 })

A Because projection only includes <code>name</code> and excludes all other fields including <code>profile</code>

B Because the query syntax is invalid and returns no fields

C Because <code>profile</code> field is empty in all documents

D Because <code>profile</code> is not embedded but referenced

💡 Hint

Projection controls which fields appear in results.

When projection specifies only name: 1, MongoDB returns only the name field and excludes all others by default, including profile. To include profile, it must be explicitly projected.

🧠 Conceptual

expert

Why choose one-to-one embedding over referencing?

In MongoDB, when designing a schema for a one-to-one relationship, why might embedding the related document be better than using references?

A Embedding enforces stronger data consistency by using foreign key constraints

B Embedding allows unlimited growth of the embedded document without size limits

C Embedding reduces the need for joins and improves read performance by storing related data together

D Embedding automatically creates indexes on all embedded fields

💡 Hint

Think about how data is stored and accessed in MongoDB.

Embedding stores related data in the same document, so queries can retrieve all data in one read without joins. MongoDB documents have size limits, no foreign key constraints, and indexes must be created explicitly.

Practice

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

easy

A. It requires complex joins to retrieve related data.

B. It splits data into multiple collections to reduce document size.

C. It stores related data inside a single document for faster reads.

D. It duplicates data across collections for backup.

Solution

1. Step 1: Understand one-to-one embedding

   One-to-one embedding stores related data inside the same document instead of separate collections.

2. Step 2: Identify the advantage

   This approach simplifies queries and improves read speed by avoiding joins.

3. Final Answer:

   It stores related data inside a single document for faster reads. -> Option C

4. Quick Check:

   Embedding = faster reads [OK]

Hint: Embedding keeps related data together for quick access [OK]

Common Mistakes:

• Thinking embedding splits data into multiple collections
• Assuming embedding requires joins
• Confusing embedding with data duplication

2. Which of the following is the correct way to embed a profile document inside a user document in MongoDB?

easy

A. { _id: 1, name: 'Alice' }, profile: { age: 30, city: 'NY' }

B. { _id: 1, name: 'Alice', profile: { age: 30, city: 'NY' } }

C. { _id: 1, name: 'Alice', profile: [ { age: 30, city: 'NY' } ] }

D. { _id: 1, name: 'Alice', profile: 'age:30, city:NY' }

Solution

1. Step 1: Check embedding syntax

   Embedding means nesting a document inside another document as a field with an object value.

2. Step 2: Identify correct JSON structure

   { _id: 1, name: 'Alice', profile: { age: 30, city: 'NY' } } correctly nests the profile as an object inside user. { _id: 1, name: 'Alice' }, profile: { age: 30, city: 'NY' } separates profile outside user. { _id: 1, name: 'Alice', profile: [ { age: 30, city: 'NY' } ] } uses an array unnecessarily. { _id: 1, name: 'Alice', profile: 'age:30, city:NY' } stores profile as a string, not an object.

3. Final Answer:

   { _id: 1, name: 'Alice', profile: { age: 30, city: 'NY' } } -> Option B

4. Quick Check:

   Embedded document = nested object [OK]

Hint: Embed as nested object, not separate or string [OK]

Common Mistakes:

• Placing embedded document outside main document
• Using array instead of object for one-to-one
• Storing embedded data as string

3. Given the document { _id: 1, name: 'Bob', address: { street: 'Main St', city: 'LA' } }, what will be the result of the query db.users.findOne({ _id: 1 })?

medium

A. { _id: 1, name: 'Bob' }

B. null

C. { address: { street: 'Main St', city: 'LA' } }

D. { _id: 1, name: 'Bob', address: { street: 'Main St', city: 'LA' } }

Solution

1. Step 1: Understand findOne query

   The query searches for a document with _id equal to 1 and returns the whole document.

2. Step 2: Check document structure

   The document includes embedded address inside user, so the full document is returned.

3. Final Answer:

   { _id: 1, name: 'Bob', address: { street: 'Main St', city: 'LA' } } -> Option D

4. Quick Check:

   findOne returns full document [OK]

Hint: findOne returns entire matching document including embedded [OK]

Common Mistakes:

• Expecting only top-level fields returned
• Thinking embedded fields are separate documents
• Assuming query returns null if embedded exists

4. You have this document: { _id: 2, name: 'Carol', profile: { age: 25, city: 'Chicago' } }. Which update command correctly changes the city to 'Boston' using one-to-one embedding?

medium

A. db.users.updateOne({ _id: 2 }, { $set: { 'profile.city': 'Boston' } })

B. db.users.updateOne({ _id: 2 }, { $set: { profile: 'Boston' } })

C. db.users.updateOne({ _id: 2 }, { $set: { city: 'Boston' } })

D. db.users.updateOne({ _id: 2 }, { $set: { 'profile[city]': 'Boston' } })

Solution

1. Step 1: Identify correct update syntax for embedded field

   To update a nested field, use dot notation like 'profile.city'.

2. Step 2: Check each option

   db.users.updateOne({ _id: 2 }, { $set: { 'profile.city': 'Boston' } }) uses correct dot notation. db.users.updateOne({ _id: 2 }, { $set: { profile: 'Boston' } }) replaces entire profile with string. db.users.updateOne({ _id: 2 }, { $set: { city: 'Boston' } }) tries to set city at top level, which doesn't exist. db.users.updateOne({ _id: 2 }, { $set: { 'profile[city]': 'Boston' } }) uses invalid bracket notation.

3. Final Answer:

   db.users.updateOne({ _id: 2 }, { $set: { 'profile.city': 'Boston' } }) -> Option A

4. Quick Check:

   Use dot notation to update embedded fields [OK]

Hint: Use dot notation to update embedded fields [OK]

Common Mistakes:

• Replacing whole embedded document instead of one field
• Using incorrect field path without dot notation
• Using invalid bracket notation in update

5. You want to design a MongoDB schema for users and their passports using one-to-one embedding. Which design is best and why?

hard

A. Embed passport details inside user document because passports are small and tightly linked.

B. Store passports in a separate collection and reference user IDs to avoid large documents.

C. Duplicate passport data in both user and passport collections for faster writes.

D. Store passport as a string field inside user document to simplify queries.

Solution

1. Step 1: Analyze data relationship and size

   Passports are small and tightly connected to users, perfect for embedding.

2. Step 2: Choose embedding benefits

   Embedding keeps related data together, simplifies queries, and improves read speed.

3. Step 3: Evaluate other options

   Store passports in a separate collection and reference user IDs to avoid large documents adds complexity with references. Duplicate passport data in both user and passport collections for faster writes duplicates data causing inconsistency. Store passport as a string field inside user document to simplify queries stores data as string losing structure.

4. Final Answer:

   Embed passport details inside user document because passports are small and tightly linked. -> Option A

5. Quick Check:

   Small, tightly linked data = embed [OK]

Hint: Embed small, tightly linked data for simplicity and speed [OK]

Common Mistakes:

• Choosing references for small one-to-one data
• Duplicating data causing inconsistency
• Storing structured data as plain string