$all operator for matching all elements in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find documents where the 'tags' array contains both 'red' and 'blue'

Given a collection with documents containing a 'tags' array, which query returns documents where 'tags' contains both 'red' and 'blue'?

MongoDB

db.collection.find({ tags: { $all: ['red', 'blue'] } })

A db.collection.find({ tags: { $all: ['red', 'blue'] } })

B db.collection.find({ tags: { $in: ['red', 'blue'] } })

C db.collection.find({ tags: { $all: ['red'] } })

D db.collection.find({ tags: { $all: ['blue'] } })

💡 Hint

Use $all to match arrays containing all specified elements.

The $all operator matches arrays that contain all the specified elements. Option A correctly uses $all with both 'red' and 'blue'. Option A uses $in which matches any of the elements, not all. Options C and D only check for one element each.

🧠 Conceptual

intermediate

Understanding $all operator behavior with nested arrays

What does the $all operator do when matching documents where the field contains nested arrays? For example, if a document has field 'values': [[1,2], [3,4]], what does $all: [[1,2], [3,4]] match?

A Matches documents where 'values' contains any of the numbers 1, 2, 3, or 4

B Matches documents where 'values' contains both arrays [1,2] and [3,4] exactly

C Matches documents where 'values' contains arrays with any of the numbers 1, 2, 3, or 4 in any order

D Matches documents where 'values' contains a single array with all numbers 1, 2, 3, and 4

💡 Hint

Think about how $all matches elements exactly, including arrays.

The $all operator matches elements exactly. So if you specify $all: [[1,2], [3,4]], it looks for the array field to contain both arrays [1,2] and [3,4] as elements. It does not flatten or partially match numbers inside nested arrays.

📝 Syntax

advanced

Identify the syntax error in this $all query

Which option contains a syntax error in the MongoDB query using $all to match 'colors' containing 'green' and 'yellow'?

MongoDB

db.collection.find({ colors: { $all: 'green', 'yellow' } })

A db.collection.find({ colors: { $all: ['green', 'yellow'] } })

B db.collection.find({ colors: { $all: ['yellow'] } })

C db.collection.find({ colors: { $all: ['green'] } })

D db.collection.find({ colors: { $all: 'green', 'yellow' } })

💡 Hint

Check the syntax for $all operator's value type.

The $all operator requires an array as its value. Option D incorrectly provides multiple arguments instead of a single array, causing a syntax error. Options A, B, and C correctly use arrays.

❓ optimization

advanced

Optimizing a query using $all with multiple elements

You want to find documents where the 'features' array contains 'wifi', 'parking', and 'pool'. Which query is the most efficient and correct?

A db.collection.find({ $and: [ { features: 'wifi' }, { features: 'parking' }, { features: 'pool' } ] })

B db.collection.find({ features: { $in: ['wifi', 'parking', 'pool'] } })

C db.collection.find({ features: { $all: ['wifi', 'parking', 'pool'] } })

D db.collection.find({ features: 'wifi' }).find({ features: 'parking' }).find({ features: 'pool' })

💡 Hint

Use a single query operator that matches all elements at once.

Option C uses $all to match all specified elements in one query, which is efficient. Option C matches any of the elements, not all. Option C is invalid chaining of find(). Option C works but is less efficient than $all.

🔧 Debug

expert

Why does this $all query return no results?

You run this query: db.collection.find({ tags: { $all: ['apple', 'banana'] } }) but get no results, even though documents have 'tags' arrays with 'apple' and 'banana' but in nested arrays like ['apple', ['banana']] or [['apple'], 'banana']. Why?

A Because $all matches exact elements, nested arrays are not matched as individual elements

B Because $all only matches strings, not arrays

C Because the query syntax is incorrect and causes no matches

D Because $all requires the elements to be in order in the array

💡 Hint

Consider how $all matches elements exactly, including nested arrays.

The $all operator matches elements exactly. If the array contains nested arrays, the elements inside those nested arrays are not considered top-level elements. So 'banana' inside ['banana'] is not matched as 'banana' by $all.

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