Querying nested fields at any depth in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the syntax to query a nested field in MongoDB?

Use dot notation to access nested fields. For example, to query the field address.city, use { "address.city": "New York" }.

intermediate

How do you query a nested field inside an array of objects in MongoDB?

You can use dot notation with the array field name and the nested field. For example, { "orders.product": "Book" } finds documents where any object in the orders array has product equal to "Book".

intermediate

What operator helps to query nested fields at any depth in MongoDB?

The $elemMatch operator helps match documents where at least one element in an array matches the specified query conditions on nested fields.

advanced

How can you query deeply nested fields when the depth is unknown?

MongoDB does not support querying unknown depth directly. You must know the path or use aggregation with $objectToArray and recursion in code to search dynamically.

beginner

What does the query { "profile.contacts.email": "[e-mail]" } do?

It finds documents where the nested field email inside contacts inside profile equals "[e-mail]".

Which syntax correctly queries a nested field 'city' inside 'address' in MongoDB?

A { "city.address": "Seattle" }

B { "address->city": "Seattle" }

C { "address[city]": "Seattle" }

D { "address.city": "Seattle" }

MongoDB uses dot notation to query nested fields, so { "address.city": "Seattle" } is correct.

How do you query an array of objects where one object has 'type' equal to 'home'?

A { "array.type": "home" }

B { "array": { "type": "home" } }

C { "array.$.type": "home" }

D { "array": [ { "type": "home" } ] }

Using dot notation like { "array.type": "home" } matches any object in the array with type 'home'.

What does the $elemMatch operator do in MongoDB?

A Matches documents where an array contains an element that satisfies multiple conditions

B Updates nested fields in documents

C Deletes nested fields from documents

D Sorts documents by nested field values

$elemMatch matches documents where at least one array element meets all specified conditions.

Can MongoDB query nested fields at unknown depth directly?

A No, MongoDB does not support nested fields

B Yes, using dot notation with wildcards

C No, you must know the path or use aggregation with code

D Yes, using $deepQuery operator

MongoDB requires known paths or aggregation pipelines with code to handle unknown depth nesting.

What will this query find? { "profile.contacts.email": "[e-mail]" }

A Documents where profile equals '[e-mail]'

B Documents where email nested inside contacts inside profile equals '[e-mail]'

C Documents where contacts equals '[e-mail]'

D Documents where email is anywhere in the document

The query uses dot notation to match the nested email field inside contacts inside profile.

Explain how to query a nested field inside an array of objects in MongoDB.

Think about how you access nested properties in JavaScript objects.

Describe the limitations of querying nested fields at unknown depth in MongoDB and possible workarounds.

Consider how you might search deeply nested folders on your computer.

Practice

1. Which MongoDB query syntax correctly accesses a nested field named address.city inside a document?

easy

A. { address.city() : "New York" }

B. { address: { city: "New York" } }

C. { "address->city": "New York" }

D. { "address.city": "New York" }

Solution

1. Step 1: Understand dot notation for nested fields

   MongoDB uses dot notation like "address.city" to access nested fields inside documents.

2. Step 2: Identify correct query syntax

   The correct query uses a string key with dot notation: { "address.city": "New York" }.

3. Final Answer:

   { "address.city": "New York" } -> Option D

4. Quick Check:

   Dot notation = { "address.city": value } [OK]

Hint: Use quotes and dot notation to access nested fields [OK]

Common Mistakes:

• Using nested objects instead of dot notation in query
• Using arrow or parentheses instead of dot notation
• Not quoting the nested field path

2. Which of the following is the correct MongoDB query to find documents where the nested field profile.details.age equals 30?

easy

A. { profile.details.age = 30 }

B. { "profile.details.age": 30 }

C. { profile.details.age: 30 }

D. { 'profile.details.age' == 30 }

Solution

1. Step 1: Use string keys with dot notation in MongoDB queries

   MongoDB requires the nested field path as a string key with dots, like "profile.details.age".

2. Step 2: Use colon for key-value pairs in query objects

   The correct syntax uses colon (:), not equals (=) or double equals (==), so { "profile.details.age": 30 } is correct.

3. Final Answer:

   { "profile.details.age": 30 } -> Option B

4. Quick Check:

   Dot notation with colon = correct query [OK]

Hint: Use colon and quotes for nested keys in queries [OK]

Common Mistakes:

• Using = or == instead of colon in query
• Not quoting the nested field path
• Using object notation instead of dot notation

3. Given the collection documents:

{ "user": { "contact": { "email": "[e-mail]" } } }, { "user": { "contact": { "email": "[e-mail]" } } }, { "user": { "contact": { "phone": "12345" } } }

What will the query db.collection.find({ "user.contact.email": { $exists: true } }) return?

medium

A. Documents where user.contact has any field

B. Documents where user.contact.phone exists

C. Documents where user.contact.email exists

D. All documents in the collection

Solution

1. Step 1: Understand $exists operator with nested fields

   The query checks if the nested field "user.contact.email" exists in documents.

2. Step 2: Identify which documents have that nested field

   Only the first two documents have "user.contact.email"; the third has "user.contact.phone" instead.

3. Final Answer:

   Documents where user.contact.email exists -> Option C

4. Quick Check:

   $exists true filters documents with that nested field [OK]

Hint: Use $exists to check nested field presence [OK]

Common Mistakes:

• Assuming $exists checks parent fields
• Confusing email and phone fields
• Expecting all documents to match

4. You wrote this query to find documents where profile.address.zipcode is "12345":

db.users.find({ profile.address.zipcode: "12345" })

But it gives a syntax error. What is the fix?

medium

A. Use quotes around the nested field: { "profile.address.zipcode": "12345" }

B. Replace dots with underscores: { profile_address_zipcode: "12345" }

C. Use double equals: { "profile.address.zipcode" == "12345" }

D. Remove the nested field and query only { zipcode: "12345" }

Solution

1. Step 1: Identify syntax error cause

   MongoDB requires string keys with dot notation quoted in queries to avoid syntax errors.

2. Step 2: Correct query syntax

   Wrap the nested field path in quotes: { "profile.address.zipcode": "12345" } fixes the syntax error.

3. Final Answer:

   Use quotes around the nested field: { "profile.address.zipcode": "12345" } -> Option A

4. Quick Check:

   Quotes fix dot notation syntax errors [OK]

Hint: Always quote nested field keys in queries [OK]

Common Mistakes:

• Not quoting nested field keys
• Using == instead of colon
• Replacing dots with underscores incorrectly

5. You have documents with deeply nested fields like settings.preferences.notifications.email.enabled. How would you write a MongoDB query to find all documents where email notifications are enabled (true), regardless of nesting depth?

hard

A. { "settings.preferences.notifications.email.enabled": true }

B. { settings: { preferences: { notifications: { email: { enabled: true } } } } }

C. { "email.enabled": true }

D. { "settings.preferences.notifications.email.enabled": { $eq: "true" } }

Solution

1. Step 1: Use dot notation string to access deeply nested field

   MongoDB queries use dot notation strings to reach any depth, so "settings.preferences.notifications.email.enabled" is correct.

2. Step 2: Match boolean value correctly

   Use true (boolean) without quotes to match enabled field, so { "settings.preferences.notifications.email.enabled": true } is correct.

3. Final Answer:

   { "settings.preferences.notifications.email.enabled": true } -> Option A

4. Quick Check:

   Dot notation + boolean value = correct query [OK]

Hint: Use full dot path with boolean true (no quotes) [OK]

Common Mistakes:

• Using nested objects instead of dot notation
• Quoting boolean true as string
• Using partial nested paths