$not operator behavior in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find documents where the field 'age' is NOT equal to 30.

MongoDB

db.collection.find({ age: { $not: { $eq: [1] } } })

Drag options to blanks, or click blank then click option'

A25

Btrue

C30

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using $not without a condition inside, like { $not: 30 } which is invalid.

Confusing $not with $ne (not equal).

The $not operator negates the condition inside it. Here, { $eq: 30 } means age equals 30, so $not finds ages not equal to 30.

2fill in blank

medium

Complete the code to find documents where the 'status' field does NOT start with the letter 'A'.

MongoDB

db.collection.find({ status: { $not: { $regex: /^[1]/ } } })

Drag options to blanks, or click blank then click option'

AZ

BA

CB

Da

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase 'a' when the data is uppercase 'A' (case sensitive).

Not using the caret ^ to specify start of string.

The regular expression /^A/ matches strings starting with 'A'. Using $not negates this, so it finds strings not starting with 'A'.

3fill in blank

hard

Fix the error in the query to find documents where 'score' is NOT greater than 50.

MongoDB

db.collection.find({ score: { $not: { $gt: [1] } } })

Drag options to blanks, or click blank then click option'

A60

B40

C30

D50

Attempts:

3 left

💡 Hint

Common Mistakes

Using a number other than 50 inside $gt changes the meaning.

Trying to use $not: 50 directly, which is invalid.

The query uses $gt: 50 to find scores greater than 50. $not negates this, so it finds scores less than or equal to 50.

4fill in blank

hard

Fill both blanks to find documents where 'category' is NOT 'electronics' and 'price' is NOT less than 100.

MongoDB

db.collection.find({ category: { $not: { $eq: "[1]" } }, price: { $not: { $lt: [2] } } })

Drag options to blanks, or click blank then click option'

Aelectronics

Bbooks

C100

D50

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the price threshold value.

Using $ne instead of $not with $eq or $lt.

The query excludes documents where category equals 'electronics' and price is less than 100 by negating those conditions with $not.

5fill in blank

hard

Fill all three blanks to find documents where the 'name' field does NOT contain 'Pro', 'rating' is NOT equal to 5, and 'stock' is NOT less than 10.

MongoDB

db.collection.find({ name: { $not: { $regex: [1] } }, rating: { $not: { $eq: [2] } }, stock: { $not: { $lt: [3] } } })

Drag options to blanks, or click blank then click option'

A/Pro/

B5

C10

D/Pro/i

Attempts:

3 left

💡 Hint

Common Mistakes

Using case-sensitive regex when case-insensitive is needed.

Mixing up the numeric values for rating and stock.

The regex /Pro/i matches 'Pro' case-insensitively. Using $not excludes names containing 'Pro'. Similarly, $not excludes ratings equal to 5 and stock less than 10.

Practice

1. What does the $not operator do in MongoDB queries?

easy

A. It selects documents where the condition inside $not is false.

B. It selects documents where the condition inside $not is true.

C. It deletes documents that match the condition.

D. It updates documents that do not match the condition.

Solution

1. Step 1: Understand the purpose of $not

   The $not operator reverses the condition it wraps, so it matches documents where the condition is false.

2. Step 2: Apply this understanding to the options

   It selects documents where the condition inside $not is false. correctly states that $not selects documents where the condition inside it is false, which is the correct behavior.

3. Final Answer:

   It selects documents where the condition inside $not is false. -> Option A

4. Quick Check:

   $not flips condition = false [OK]

Hint: Remember: $not means 'not matching' condition [OK]

Common Mistakes:

• Thinking $not selects where condition is true
• Confusing $not with delete or update operations
• Using $not without a condition inside

2. Which of the following is the correct syntax to use $not with a comparison operator in MongoDB?

easy

A. { field: { $not: { $gt: 10 } } }

B. { field: { $gt: { $not: 10 } } }

C. { $not: { field: $gt: 10 } }

D. { field: { $not: $gt: 10 } }

Solution

1. Step 1: Review correct $not syntax

   The $not operator must wrap another operator inside the field, like { field: { $not: { $gt: 10 } } }.

2. Step 2: Check each option

   { field: { $not: { $gt: 10 } } } matches the correct syntax. Options A, B, and D misuse the placement or structure of $not.

3. Final Answer:

   { field: { $not: { $gt: 10 } } } -> Option A

4. Quick Check:

   Correct $not syntax wraps operator inside field [OK]

Hint: Wrap operator inside $not within the field object [OK]

Common Mistakes:

• Placing $not outside the field
• Not wrapping the operator inside $not
• Using invalid JSON structure with $not

3. Given the collection documents:

[{ "score": 5 }, { "score": 10 }, { "score": 15 }]

What will be the result of this query?

{ "score": { "$not": { "$gt": 10 } } }

medium

A. []

B. [{ "score": 15 }]

C. [{ "score": 5 }]

D. [{ "score": 5 }, { "score": 10 }]

Solution

1. Step 1: Understand the query condition

   The query uses $not with $gt: 10, so it matches documents where score is NOT greater than 10.

2. Step 2: Check each document against the condition

   Documents with scores 5 and 10 are not greater than 10, so they match. The document with 15 does not match.

3. Final Answer:

   [{ "score": 5 }, { "score": 10 }] -> Option D

4. Quick Check:

   Scores ≤ 10 match $not $gt 10 [OK]

Hint: Think: $not $gt 10 means ≤ 10 [OK]

Common Mistakes:

• Selecting documents where score > 10 instead
• Confusing $not with $ne
• Ignoring the nested operator inside $not

4. You wrote this query but it returns an error:

{ "name": { "$not": "^A" } }

What is the problem?

medium

A. The query is missing a closing brace.

B. $not must be used with another operator like $regex.

C. $not cannot be used on string fields.

D. The regex pattern is invalid without slashes.

Solution

1. Step 1: Analyze the use of $not with a string

   The $not operator expects an operator expression, not a direct string.

2. Step 2: Correct usage with regex

   To negate a regex, you must use { "$not": { "$regex": "^A" } }. The given query misses $regex.

3. Final Answer:

   $not must be used with another operator like $regex. -> Option B

4. Quick Check:

   $not needs operator, not raw value [OK]

Hint: Always pair $not with an operator like $regex [OK]

Common Mistakes:

• Using raw string inside $not without operator
• Assuming regex needs slashes in MongoDB
• Thinking $not works on any value directly

5. You want to find documents where the status field does NOT start with the letter 'P'. Which query correctly uses $not with a regex to achieve this?

hard

A. { "status": { "$regex": { "$not": "^P" } } }

B. { "$not": { "status": $regex: "^P" } }

C. { "status": { "$not": { "$regex": "^P" } } }

D. { "status": { "$not": "^P" } }

Solution

1. Step 1: Understand the goal

   You want documents where status does NOT start with 'P', so negate the regex ^P.

2. Step 2: Use $not with $regex inside the field

   The correct syntax is { "status": { "$not": { "$regex": "^P" } } }. This matches documents where status does not match the regex.

3. Final Answer:

   { "status": { "$not": { "$regex": "^P" } } } -> Option C

4. Quick Check:

   $not wraps $regex inside field [OK]

Hint: Wrap regex inside $not within the field object [OK]

Common Mistakes:

• Placing $not outside the field
• Using $not directly on string without $regex
• Incorrect nesting of $not and $regex