$all operator for matching all elements in MongoDB - Step-by-Step Execution

Concept Flow - $all operator for matching all elements

Start Query

↓

Check $all Operator

↓

For each element in $all array

↓

Does document array contain element?

↓

Reject Document

↓

All elements matched?

↓

Include

↓

Return matched documents

The $all operator checks if a document's array contains all specified elements. It tests each element and only returns documents matching all.

Execution Sample

MongoDB

db.products.find({ tags: { $all: ["red", "round"] } })

Finds products whose tags array contains both "red" and "round".

Execution Table

Step	Document tags	Check element 'red'	Check element 'round'	Result
1	["red", "round", "small"]	Yes	Yes	Include document
2	["red", "square"]	Yes	No	Reject document
3	["blue", "round"]	No	Yes	Reject document
4	["red", "round"]	Yes	Yes	Include document
5	["round"]	No	Yes	Reject document
Exit	-	-	-	All documents checked

💡 All documents checked; only those with both 'red' and 'round' included.

Variable Tracker

Variable	Start	Doc 1	Doc 2	Doc 3	Doc 4	Doc 5	Final
tags	-	["red", "round", "small"]	["red", "square"]	["blue", "round"]	["red", "round"]	["round"]	-
matches 'red'	-	true	true	false	true	false	-
matches 'round'	-	true	false	true	true	true	-
include document	-	true	false	false	true	false	-

Key Moments - 3 Insights

Why does a document with tags ["red", "square"] get rejected?

Because it does not contain the element 'round' required by $all, as shown in execution_table row 2 where 'Check element round' is No.

Does $all require the array elements to be in order?

No, $all only checks presence of all elements regardless of order, as seen in document 1 with tags ["red", "round", "small"] included despite order.

What happens if the document array is missing one element from $all?

The document is rejected, like document 5 missing 'red' and rejected in execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution table, does the document with tags ["blue", "round"] match the query?

A Yes, because it has 'round'

B No, because it lacks 'red'

C Yes, because it has at least one element

D No, because it has 'blue'

💡 Hint

Check row 3 in the execution_table where 'matches red' is false and document is rejected.

At which step does the condition for including a document become false?

A When any element in $all is missing from the document array

B When the document array is empty

C When the document has extra elements

D When the document array has duplicates

💡 Hint

See execution_table rows 2, 3, and 5 where missing elements cause rejection.

If the query changes to $all: ["round"], which documents would be included?

A Documents with 'red' only

B Only documents with 'red' and 'round'

C Documents with 'round' regardless of 'red'

D All documents

💡 Hint

Focus on the $all array elements and their presence in document arrays.

Concept Snapshot

$all operator syntax:
{ field: { $all: [value1, value2, ...] } }
Returns documents where field array contains all listed values.
Order does not matter.
Useful to match multiple required elements in arrays.

Full Transcript

The $all operator in MongoDB is used to find documents where an array field contains all specified elements. The query checks each element in the $all array against the document's array field. If any element is missing, the document is excluded. Documents that contain all elements are included in the results. This operator does not require elements to be in order, only that all are present. For example, a query with $all: ["red", "round"] returns documents whose tags array includes both 'red' and 'round'. The execution table shows step-by-step checks for each document, confirming which elements are present and whether the document matches. This helps beginners understand how $all works by visualizing the matching process.

Practice

1.

What does the $all operator do in MongoDB queries?

easy

A. Matches documents where an array contains any one of the specified values.

B. Matches documents where an array contains all specified values.

C. Matches documents where an array contains exactly one specified value.

D. Matches documents where an array is empty.

Solution

1. Step 1: Understand the purpose of $all

   The $all operator is used to find documents where an array field contains all the values specified in the query.

2. Step 2: Compare with other operators

   Unlike $in which matches any value, $all requires all values to be present in the array.

3. Final Answer:

   Matches documents where an array contains all specified values. -> Option B

4. Quick Check:

   $all = all values present [OK]

Hint: Remember: $all means every value must be in the array [OK]

Common Mistakes:

• Confusing $all with $in operator
• Thinking $all checks order of elements
• Assuming $all matches partial values

2.

Which of the following is the correct syntax to find documents where the tags array contains both "red" and "blue" using $all?

{ tags: { $all: ["red", "blue"] } }

easy

A. { tags: { $all: ["red", "blue"] } }

B. { tags: { $all: "red", "blue" } }

C. { tags: { $all: "red blue" } }

D. { tags: { $all: { "red", "blue" } } }

Solution

1. Step 1: Check the correct structure for $all

   The $all operator requires an array of values to match all elements.

2. Step 2: Validate each option's syntax

   { tags: { $all: ["red", "blue"] } } correctly uses an array with square brackets. Options A, B, and D use incorrect syntax for arrays or objects.

3. Final Answer:

   { tags: { $all: ["red", "blue"] } } -> Option A

4. Quick Check:

   Correct array syntax for $all [OK]

Hint: Use square brackets [] to list values inside $all [OK]

Common Mistakes:

• Using curly braces {} instead of square brackets []
• Passing values as separate arguments instead of an array
• Using a string instead of an array for $all

3.

Given the collection documents:

[{ "colors": ["red", "green", "blue"] }, { "colors": ["red", "yellow"] }, { "colors": ["blue", "green", "red"] }]

What will the query { colors: { $all: ["red", "blue"] } } return?

medium

A. No documents

B. Document 2 only

C. Documents 1 and 3

D. All three documents

Solution

1. Step 1: Check each document's colors array

   Document 1 has ["red", "green", "blue"] which includes both "red" and "blue". Document 2 has ["red", "yellow"] missing "blue". Document 3 has ["blue", "green", "red"] which includes both.

2. Step 2: Apply $all condition

   The query matches documents where both "red" and "blue" are present, so documents 1 and 3 match.

3. Final Answer:

   Documents 1 and 3 -> Option C

4. Quick Check:

   Both arrays contain "red" and "blue" [OK]

Hint: Check each array contains all values, order doesn't matter [OK]

Common Mistakes:

• Assuming order matters for $all
• Including documents missing one value
• Confusing $all with $in behavior

4.

Identify the error in this query that tries to find documents where features array contains both "wifi" and "parking":

{ features: { $all: "wifi", "parking" } }

medium

A. The field name should be inside quotes.

B. The values should be inside curly braces instead of quotes.

C. The query should use $in instead of $all.

D. The $all operator requires an array of values, not separate arguments.

Solution

1. Step 1: Analyze the $all operator usage

   The $all operator expects a single array containing all values to match.

2. Step 2: Identify the syntax error

   The query incorrectly passes two separate string arguments instead of an array. It should be { $all: ["wifi", "parking"] }.

3. Final Answer:

   The $all operator requires an array of values, not separate arguments. -> Option D

4. Quick Check:

   $all needs an array [OK]

Hint: Always wrap $all values in an array [] [OK]

Common Mistakes:

• Passing multiple values without array brackets
• Using $in when $all is needed
• Misplacing quotes around field names

5.

You have a collection of documents with a field ingredients which is an array of strings. You want to find all recipes that contain both "flour" and "sugar", but not "nuts". Which query correctly uses $all and other operators to achieve this?

hard

A. { ingredients: { $all: ["flour", "sugar"], $nin: ["nuts"] } }

B. { ingredients: { $all: ["flour", "sugar", "nuts"] } }

C. { ingredients: { $in: ["flour", "sugar"], $nin: ["nuts"] } }

D. { ingredients: { $all: ["flour", "sugar"] }, ingredients: { $nin: ["nuts"] } }

Solution

1. Step 1: Use $all to match both "flour" and "sugar"

   The $all operator ensures the array contains both these ingredients.

2. Step 2: Use $nin to exclude "nuts"

   The $nin operator excludes documents where the array contains "nuts".

3. Step 3: Combine both conditions correctly

   { ingredients: { $all: ["flour", "sugar"], $nin: ["nuts"] } } combines $all and $nin inside the same field query, which is valid MongoDB syntax.

4. Final Answer:

   { ingredients: { $all: ["flour", "sugar"], $nin: ["nuts"] } } -> Option A

5. Quick Check:

   All required and no excluded ingredients [OK]

Hint: Combine $all and $nin inside one field object [OK]

Common Mistakes:

• Putting $all and $nin in separate objects for same field
• Using $in instead of $all for required ingredients
• Including excluded items inside $all array