$not operator behavior in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the $not operator do in MongoDB?

The $not operator in MongoDB inverts the condition it is applied to. It matches documents where the specified condition is not true.

intermediate

How do you use $not with a regular expression in MongoDB?

You can use $not with a regular expression to find documents where a field does not match the pattern. For example: { field: { $not: /pattern/ } } finds documents where field does not match pattern.

beginner

Can $not be used alone without another operator?

No. $not must be used with another operator or expression. It cannot be used alone because it needs a condition to invert.

intermediate

What is the difference between $not and $ne in MongoDB?

$not inverts any condition, while $ne specifically means "not equal to" a value. $not can be used with other operators like $gt, $regex, etc., to negate them.

beginner

Example: What does this query do? { age: { $not: { $gt: 30 } } }

This query finds documents where the age field is NOT greater than 30. So it matches documents where age is 30 or less, or where age does not exist.

What does { field: { $not: { $eq: 5 } } } match?

A Documents where field equals 5

B Documents where field is less than 5

C Documents where field is greater than 5

D Documents where field does not equal 5

$not inverts the $eq condition, so it matches documents where field is not equal to 5.

Can $not be used without another operator?

A No, it requires another operator

B Only with regular expressions

C Only with <code>$eq</code>

D Yes, it works alone

$not must be used with another operator or expression to invert its condition.

Which query finds documents where name does NOT start with 'A'?

A { name: { $not: { $eq: 'A' } } }

B { name: { $ne: /^A/ } }

C { name: { $not: /^A/ } }

D { name: { $regex: '^A' } }

Using $not with a regex /^A/ matches documents where name does not start with 'A'.

What does { score: { $not: { $gt: 50 } } } select?

A Scores greater than 50

B Scores less than or equal to 50

C Scores equal to 50 only

D Scores not equal to 50

It selects documents where score is NOT greater than 50, meaning 50 or less.

How does $not differ from $ne?

A <code>$not</code> negates any condition; <code>$ne</code> means not equal

B They are the same

C <code>$ne</code> negates any condition; <code>$not</code> means not equal

D Neither negates conditions

$not negates any operator condition; $ne specifically means 'not equal to' a value.

Explain how the $not operator works in MongoDB queries.

Think about how 'not' works in everyday language.

Describe a scenario where you would use $not with a regular expression in a MongoDB query.

Consider searching for things that do not match a pattern.

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