İç İçe Alanları ve Dizileri Sorgulama

One of MongoDB's signature strengths is storing nested sub-documents and arrays inside a document. But this power is only useful if you can also query that nested data efficiently. MongoDB's dot notation lets you reach into any depth of nesting to filter, project, index, and update specific fields.

Without this capability, you would have to load entire documents into your application and filter in code—wasting bandwidth and making indexes useless. Dot notation queries run server-side, benefiting from indexes on nested fields.

Dot notation uses a period (.) to navigate into nested sub-documents. The query { 'address.city': 'Chicago' } matches documents where the address field is an object with a city field equal to 'Chicago'. You can chain dots to any depth: 'address.location.lat'.

The key rule: always wrap dot-notation paths in quotes when used as object keys in JavaScript (because the dot would otherwise be parsed as property access). This is a frequent beginner mistake.

There is an important difference between two ways of querying sub-documents:

• Exact match: { address: { city: 'Chicago', state: 'IL' } } — requires the address field to be exactly that object, no more fields, in that exact field order
• Dot notation: { 'address.city': 'Chicago' } — matches any document where address.city equals 'Chicago', regardless of what other fields address contains

In practice, always use dot notation for sub-document queries. Exact sub-document matches are fragile and rarely what you intend.

When you query an array field with a simple equality filter, MongoDB checks if the array contains the value—not if the array equals the value. This is one of the most intuitive parts of the MongoDB query model.

For example, if a product has tags: ['electronics', '4K', 'HDR'], then { tags: '4K' } returns this document because the array contains '4K'. You do not need a special operator—array containment is the default behavior for equality filters on array fields.

You can query a specific position within an array using dot notation with the array index: 'arrayField.0' targets the first element, 'arrayField.1' the second, and so on (0-indexed).

This is useful when array order is meaningful—for example, a document with scores: [95, 87, 71] where the first score is always the most recent. You can filter documents where the first score exceeds a threshold: { 'scores.0': { $gt: 90 } }. Use this sparingly—positional queries are fragile if array order changes.

Arrays often contain sub-documents—for example, an order document might have items: [{sku:'A1',qty:2},{sku:'B2',qty:1}]. Querying fields within array sub-documents uses dot notation: { 'items.sku': 'A1' } matches any order containing an item with sku 'A1'.

However, this can cause false positives: { 'items.sku': 'A1', 'items.qty': 5 } might match a document where sku='A1' and qty=5 exist in different array elements. To require both conditions on the same element, use $elemMatch (covered in a later lesson).

Creating indexes on nested fields and array fields works exactly like indexing top-level fields—you just use dot notation:

• db.users.createIndex({ 'address.city': 1 }) — index on a nested field
• db.products.createIndex({ tags: 1 }) — multikey index on an array field (indexes each element individually)

MongoDB automatically detects that tags is an array and creates a multikey index. Each array element gets its own entry in the index tree. Multikey indexes cannot be used as shard keys in a sharded cluster, but work perfectly for queries on standalone or replica set deployments.

Projections work with dot notation too, letting you return specific nested fields or array elements without retrieving the entire document. This is especially important when documents have large sub-documents you do not always need.

Use { 'address.city': 1, 'address.state': 1 } to include only the city and state from a nested address object. The response will still contain the address object, but only with the projected fields inside it.

To query documents where an array field has a specific number of elements, use the $size operator: { tags: { $size: 3 } } matches documents where tags has exactly 3 elements. Note that $size does not work with comparison operators—it only matches an exact count.

To find documents where an array has at least n elements, a common workaround is to index by the array field and filter by the nth element's existence: { 'tags.2': { $exists: true } } means the array has at least 3 elements (index 0, 1, 2).

Let's apply nested and array queries to a realistic product catalog document. A typical e-commerce product has nested specifications and an array of category tags.

Combining dot notation conditions with comparison operators lets you build precise filters like: 'find all laptops that are in stock, have more than 16 GB RAM, support Wi-Fi 6, and belong to the premium category'—all in a single efficient server-side query.

Dot notation is not just for querying—it also works in update operators. Use with dot notation to update a specific nested field without overwriting the entire sub-document: { : { 'address.city': 'Boston' } } changes only the city while all other address fields remain intact.

For arrays, combine dot notation with the positional $ operator to update the first array element that matched the filter: db.orders.updateOne({ 'items.sku': 'A1' }, { : { 'items.$.qty': 5 } }). This is safe for updating one matched array element without knowing its index.

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

In this lesson you learned: dot notation uses period-separated paths like 'address.city' to query and project nested sub-document fields at any depth, array equality queries check containment—{ tags: '4K' } matches if the array contains '4K' anywhere, and $size matches arrays of an exact length while positional indexing ('tags.0') targets specific array positions. Next up we connect a Node.js script to MongoDB and perform insert and find operations using the official driver.