$not operator behavior in MongoDB - Mini Project: Build & Apply

$not Operator Behavior in MongoDB Queries

📖 Scenario: You are managing a small online store's product database using MongoDB. You want to find products that do not match certain conditions, such as products that are not in a specific category or do not have a certain price range.

🎯 Goal: Build MongoDB queries using the $not operator to filter products that do not meet specific criteria.

📋 What You'll Learn

Create a collection named products with specific product documents.

Define a filter condition using $not to exclude products matching a condition.

Write a query that uses $not with a comparison operator inside.

Write a query that uses $not with a regular expression.

💡 Why This Matters

🌍 Real World

Filtering data in a database to exclude unwanted records is common in real-world applications like e-commerce, inventory management, and user data filtering.

💼 Career

Understanding how to use MongoDB query operators like <code>$not</code> is essential for backend developers, data engineers, and database administrators working with NoSQL databases.

1

Create the products collection with sample data

Create a MongoDB collection named products and insert these exact documents: { name: "Pen", category: "Stationery", price: 1.5 }, { name: "Notebook", category: "Stationery", price: 3 }, { name: "Coffee Mug", category: "Kitchenware", price: 7 }, { name: "Desk Lamp", category: "Electronics", price: 20 }, and { name: "Headphones", category: "Electronics", price: 50 }.

MongoDB

// Insert the specified documents into the products collection
// Your code here

Hint

Use db.products.insertMany([...]) with the exact documents listed.

2

Define a filter to find products not in the Electronics category

Create a filter object named notElectronicsFilter that uses the $not operator to find products where the category is not equal to "Electronics".

MongoDB

db.products.insertMany([
  { name: "Pen", category: "Stationery", price: 1.5 },
  { name: "Notebook", category: "Stationery", price: 3 },
  { name: "Coffee Mug", category: "Kitchenware", price: 7 },
  { name: "Desk Lamp", category: "Electronics", price: 20 },
  { name: "Headphones", category: "Electronics", price: 50 }
])

// Define a filter named notElectronicsFilter using $not to exclude Electronics category
// Your code here

Hint

Use { category: { $not: { $eq: "Electronics" } } } to exclude Electronics.

3

Write a query using $not to find products not priced above 10

Write a MongoDB query named notExpensiveProducts that finds products where the price is not greater than 10 using the $not operator with $gt.

MongoDB

db.products.insertMany([
  { name: "Pen", category: "Stationery", price: 1.5 },
  { name: "Notebook", category: "Stationery", price: 3 },
  { name: "Coffee Mug", category: "Kitchenware", price: 7 },
  { name: "Desk Lamp", category: "Electronics", price: 20 },
  { name: "Headphones", category: "Electronics", price: 50 }
])

const notElectronicsFilter = { category: { $not: { $eq: "Electronics" } } }

// Write a query named notExpensiveProducts to find products with price not greater than 10
// Your code here

Hint

Use { price: { $not: { $gt: 10 } } } inside db.products.find().

4

Use $not with a regular expression to exclude products with names starting with 'D'

Write a query named notStartingWithD that finds products whose name does not start with the letter D using $not with a regular expression /^D/.

MongoDB

db.products.insertMany([
  { name: "Pen", category: "Stationery", price: 1.5 },
  { name: "Notebook", category: "Stationery", price: 3 },
  { name: "Coffee Mug", category: "Kitchenware", price: 7 },
  { name: "Desk Lamp", category: "Electronics", price: 20 },
  { name: "Headphones", category: "Electronics", price: 50 }
])

const notElectronicsFilter = { category: { $not: { $eq: "Electronics" } } }

const notExpensiveProducts = db.products.find({ price: { $not: { $gt: 10 } } })

// Write a query named notStartingWithD to find products whose name does NOT start with 'D'
// Your code here

Hint

Use { name: { $not: /^D/ } } inside db.products.find().

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