What does the filter { "items.price": { $gt: 100 } } match when items is an array of subdocuments?

## What a dotted path means MongoDB stores nested structure, and a query reaches into it with a dotted path written as a quoted key: `{ "address.city": "Berlin" }`. The quoting is a syntax requirement of the shell and of JSON generally — a dot is not legal in a bare key. The path is resolved left to right against each candidate document. For plain embedded documents this is unsurprising: ``` { _id: 1, address: { city: "Berlin", zip: "10115" } } ``` `{ "address.city": "Berlin" }` matches. Note the contrast with `{ address: { city: "Berlin" } }`, which is whole-document equality: it requires `address` to be exactly that document, with exactly those fields in that order, so the example above would **not** match because `zip` is also present. Dotted paths are what you almost always want; bare embedded-document literals are exact-shape comparisons. ## Crossing an array The interesting rule is what happens when a path component lands on an array. The engine applies the remainder of the path to every element and succeeds if any element satisfies the predicate. Given: ``` { _id: 1, items: [ { sku: "A", price: 200 }, { sku: "B", price: 5 } ] } { _id: 2, items: [ { sku: "C", price: 50 } ] } ``` `{ "items.price": { $gt: 100 } }` matches document 1 (element A qualifies) and not document 2. The predicate never tells you *which* element matched, and it does not restrict the returned document — the whole document comes back, all elements included. Shaping the output is a projection concern, not a filter concern. This implicit fan-out works at any depth and across more than one array level, so `"orders.items.sku"` resolves through an array of orders, each containing an array of items. ## Positional components A numeric path component addresses a specific index. `{ "items.0.price": { $gt: 100 } }` tests only the first element. `{ "items.0": { sku: "A", price: 200 } }` compares the whole first element for equality. This is how you write "the newest entry" when the array is maintained in a known order, and it is the basis of the length trick `{ "tags.2": { $exists: true } }`, which is true only when a third element exists. The ambiguity is real: if an embedded document literally has a field named `"0"`, the same path matches that field too. MongoDB cannot distinguish "array index 0" from "key named 0" in a dotted path, so avoid numeric keys in document fields entirely. ## Independent predicates, again The most consequential interaction is with multiple conditions. `{ "items.price": { $gt: 100 }, "items.qty": { $lt: 5 } }` is a conjunction of two independent predicates, each free to find its own witness element. A document whose first item is expensive and whose second item is nearly out of stock satisfies it. If the intent is "one item that is both", the filter must be `{ items: { $elemMatch: { price: { $gt: 100 }, qty: { $lt: 5 } } } }`. Reviewing dotted-path filters for this is worth doing routinely, because the wrong form usually passes tests built on single-element arrays. ## Missing intermediate levels If any component of the path is absent, the path simply does not resolve and the document does not match a positive predicate. A negative predicate behaves differently: `{ "address.city": { $ne: "Berlin" } }` matches documents with no `address` at all, because "no value" is not equal to "Berlin". Combine with `$exists` when you mean "has an address, in a different city". ## Indexing You index a dotted path exactly as written: `createIndex({ "items.price": 1 })`. Because the path crosses an array, that becomes a multikey index with one entry per element, which is what lets element-level predicates be answered from the index. A single compound index cannot be multikey on two different array paths, so indexing `"items.price"` and `"orders.total"` together is only possible when at most one of them traverses an array — a constraint that should influence how deeply you nest arrays in the first place. ## Practical guidance Prefer dotted paths to embedded-document literals unless you truly want exact-shape equality. Quote every dotted key. Avoid numeric field names. And every time a dotted path crosses an array and the filter has more than one condition on that array, decide explicitly whether the conditions must share an element.