การค้นหาอาร์เรย์: $all, $size และการจับคู่สมาชิก

In MongoDB, arrays are a native BSON type that can be stored directly in a document field. Unlike relational databases where arrays require a separate junction table, MongoDB lets you embed arrays of any type—scalars, sub-documents, or mixed—directly in the document. This makes arrays one of the most useful features but also one of the most nuanced to query correctly.

A simple equality filter on an array field checks whether the array contains the specified value as an element. You don't need a special operator—just write the filter as if the field were a scalar. MongoDB will match any document where the array contains that exact value anywhere in it.

The $all operator matches documents where the array contains all of the specified values, in any order. Unlike a plain equality check (which matches a single element), $all enforces that every specified element is present. Think of it as multiple AND conditions on array membership.

The $size operator matches documents where the array field has exactly the specified number of elements. It accepts a literal integer—you cannot use range comparisons like $gt with $size directly. For range-based length checks, use a field that stores the array length alongside the array, or use an aggregation with $where.

You can query by a specific position in an array using dot notation with an index number. For example, { 'scores.0': 100 } matches documents where the first element of the scores array is 100. This is useful when array order is meaningful, such as a ranked list or time-ordered sequence.

A subtle gotcha: when you filter an array of sub-documents with multiple conditions on different fields, MongoDB applies each condition independently across all array elements—not to a single element. This is called the spread field problem. For example, { 'scores.value': { $gt: 90 }, 'scores.grade': 'A' } matches if any element has value > 90 AND any element has grade 'A'—they don't have to be the same element.

The $elemMatch query operator solves the spread field problem by requiring all conditions to be satisfied by the same single array element. Wrap your conditions in { $elemMatch: { condition1, condition2 } } and MongoDB will only return documents where at least one array element satisfies all the specified conditions simultaneously.

$elemMatch can also be applied to arrays of scalar values (strings, numbers) when you need to apply multiple operators to the same element. For example, finding elements that are both greater than 10 and less than 20—without $elemMatch, these conditions could be satisfied by two different elements.

You can use $all with $elemMatch expressions inside it to require multiple complex conditions across multiple distinct array elements. Each $elemMatch inside $all must be satisfied by a different element. This pattern is rarely needed but is available for complex multi-condition, multi-element requirements.

An index on an array field automatically becomes a multikey index in MongoDB, with one index entry per array element. This means queries like { tags: 'electronics' } and { tags: { $all: ['electronics', 'portable'] } } both benefit from the index. However, a compound index cannot have multikey on more than one array field per document—attempting to do so throws an error.

Array queries with $all and $elemMatch can sometimes surprise you with their index usage. Always verify with explain('executionStats'). A $size filter will show IXSCAN on the multikey index but still examine all index entries (since size is not stored in the index). An $elemMatch on indexed fields will use IXSCAN on the matching element conditions.

In this lesson you learned: $all requires an array to contain all specified values, $size matches arrays with an exact number of elements, and $elemMatch ensures multiple conditions apply to the same single array element, solving the spread field problem. Next up we dive deeper into $elemMatch for matching array sub-documents.