🔍 Query Operators: Your Database Superpowers

Imagine you're the librarian of the world's largest library with 1 million books. A student walks in and says:

Without query operators: You'd have to manually check all 1 million books! 📚📚📚 That would take YEARS!

With query operators: You wave your magic wand (MongoDB query) and in 0.5 seconds, you get exactly 23 books that match ALL those criteria! ✨

In this guide, you'll learn ALL the query operators and become a Search Master yourself! Let's dive in! 🏊‍♂️

📊 Visual: How Comparison Works

$and ALL Conditions Must Be True

Finds documents that match ALL specified conditions (intersection).

// Find users aged 25-35 from New York
db.users.find({ 
  $and: [
    { age: { $gte: 25 } },
    { age: { $lte: 35 } },
    { city: "New York" }
  ]
})

// Implicit $and (more common)
db.users.find({ 
  age: { $gte: 25, $lte: 35 },
  city: "New York"
})

// Explicit $and needed when same field appears twice
db.users.find({ 
  $and: [
    { age: { $ne: 25 } },
    { age: { $exists: true } }
  ]
})

Use Case: Multiple requirements - "premium users from NYC" or "products in stock AND under $50".

$or ANY Condition Can Be True

Finds documents that match AT LEAST ONE of the specified conditions (union).

// Find users from NYC OR LA
db.users.find({ 
  $or: [
    { city: "New York" },
    { city: "Los Angeles" }
  ]
})

// Find premium users OR users with 100+ posts
db.users.find({ 
  $or: [
    { isPremium: true },
    { postCount: { $gte: 100 } }
  ]
})

// Complex: (age < 18 OR age > 65) AND city = NYC
db.users.find({ 
  $or: [
    { age: { $lt: 18 } },
    { age: { $gt: 65 } }
  ],
  city: "New York"
})

Use Case: Alternative conditions - "VIP OR spent $1000+" or "email OR phone required".

$not Inverts the Condition

Negates the effect of a query expression.

// Find users NOT aged 25-35
db.users.find({ 
  age: { $not: { $gte: 25, $lte: 35 } }
})

// Find users whose name does NOT start with 'J'
db.users.find({ 
  name: { $not: /^J/ }
})

// Find products NOT in price range $50-$100
db.products.find({ 
  price: { $not: { $gte: 50, $lte: 100 } }
})

Use Case: Negating complex conditions - "not in this range", "doesn't match pattern".

$nor NONE of the Conditions Are True

Finds documents that fail ALL specified conditions (neither this nor that).

// Find users who are NOT from NYC and NOT from LA
db.users.find({ 
  $nor: [
    { city: "New York" },
    { city: "Los Angeles" }
  ]
})

// Find users who are NOT premium AND NOT active
db.users.find({ 
  $nor: [
    { isPremium: true },
    { status: "active" }
  ]
})

Use Case: Excluding multiple conditions - "not this and not that".

$exists Check if Field Exists

Finds documents based on whether a field exists or not.

// Find users who have a phone number
db.users.find({ phone: { $exists: true } })

// Find users who DON'T have a phone number
db.users.find({ phone: { $exists: false } })

// Find products with discount field
db.products.find({ discount: { $exists: true } })

// Find incomplete user profiles (missing email)
db.users.find({ email: { $exists: false } })

Use Case: Data validation - finding incomplete records, optional fields, migration cleanup.

$type Check Field Data Type

Finds documents where field is of the specified BSON type.

// Find users where age is a number
db.users.find({ age: { $type: "number" } })
// or: db.users.find({ age: { $type: 1 } })

// Find users where phone is a string
db.users.find({ phone: { $type: "string" } })

// Find documents where _id is ObjectId
db.users.find({ _id: { $type: "objectId" } })

// Common BSON types:
// "double" (1), "string" (2), "object" (3), 
// "array" (4), "objectId" (7), "bool" (8), 
// "date" (9), "null" (10), "int" (16), "long" (18)

Use Case: Type validation - finding data with wrong types, schema enforcement.

$all Array Contains ALL Elements

Finds documents where array contains ALL specified elements (in any order).

// Find users who have BOTH "coding" and "music" hobbies
db.users.find({ 
  hobbies: { $all: ["coding", "music"] }
})

// Find products with ALL required tags
db.products.find({ 
  tags: { $all: ["electronics", "sale", "featured"] }
})

// Order doesn't matter - this matches:
// hobbies: ["music", "gaming", "coding"]
// hobbies: ["coding", "reading", "music", "travel"]

Use Case: Required skills - "must have Python AND React", required features - "must have all tags".

$elemMatch Array Element Matches Multiple Conditions

Finds documents where at least ONE array element matches ALL specified conditions.

// Find users with a score >= 80 AND <= 100
db.students.find({ 
  scores: { $elemMatch: { $gte: 80, $lte: 100 } }
})

// Find orders with item quantity > 10 AND price < 50
db.orders.find({ 
  items: { 
    $elemMatch: { 
      quantity: { $gt: 10 }, 
      price: { $lt: 50 } 
    }
  }
})

// Find users with comments that have likes > 100
db.users.find({ 
  comments: { 
    $elemMatch: { 
      likes: { $gt: 100 },
      status: "approved"
    }
  }
})

Use Case: Complex array queries - orders with specific item conditions, users with qualifying posts.

$size Array Has Exact Length

Finds documents where array has exactly the specified number of elements.

// Find users with exactly 3 hobbies
db.users.find({ hobbies: { $size: 3 } })

// Find orders with exactly 5 items
db.orders.find({ items: { $size: 5 } })

// Find users with no friends (empty array)
db.users.find({ friends: { $size: 0 } })

// Note: $size doesn't accept ranges
// To find arrays with size > 3, use:
db.users.find({ hobbies.3: { $exists: true } })

Use Case: Exact counts - "users with 3 addresses", "orders with 1 item", validation.

$regex Pattern Matching

Matches documents where field value matches the specified regular expression pattern.

// Find users whose name starts with "J"
db.users.find({ name: { $regex: /^J/ } })
// or: db.users.find({ name: /^J/ })

// Find users whose email ends with "@gmail.com"
db.users.find({ email: { $regex: /@gmail\.com$/ } })

// Case-insensitive search for "john"
db.users.find({ 
  name: { $regex: /john/i }
})

// Find products containing "phone" (case-insensitive)
db.products.find({ 
  name: { $regex: "phone", $options: "i" }
})

// Common patterns:
// ^abc   - starts with "abc"
// abc$   - ends with "abc"
// ^abc$  - exact match "abc"
// abc    - contains "abc"
// [a-z]  - any lowercase letter
// [0-9]  - any digit
// .      - any character
// .*     - any characters (0 or more)

Use Case: Text search - autocomplete, "starts with" filters, email domain checks, partial matching.

⚠️ Performance Warning

Regex queries can be SLOW on large collections without proper indexes! Use anchored patterns (starting with ^) for better performance, and consider text indexes for complex searches.

📊 Sample Database: users collection

📝 Try These Example Queries:

🔄 Query Execution Flow

Requirement: Find laptops priced between $500-$1500, in stock, with at least 8GB RAM, from brands Apple, Dell, or HP.

db.products.find({
  category: "laptop",
  price: { $gte: 500, $lte: 1500 },
  stock: { $gt: 0 },
  specs: { 
    $elemMatch: { 
      name: "RAM", 
      value: { $gte: 8 } 
    }
  },
  brand: { $in: ["Apple", "Dell", "HP"] }
})

Requirement: Find incomplete profiles - users who are active but missing either email verification OR phone number.

db.users.find({
  status: "active",
  $or: [
    { emailVerified: { $ne: true } },
    { phone: { $exists: false } }
  ]
})

Requirement: Find posts with more than 100 likes, containing word "giveaway" (case-insensitive), and tagged with "contest" or "prize".

db.posts.find({
  likes: { $gt: 100 },
  content: { $regex: /giveaway/i },
  tags: { $in: ["contest", "prize"] }
})

Requirement: Find "power users" - registered over 1 year ago, have premium OR made 50+ posts, from US/UK/Canada, and still active.

db.users.find({
  registeredAt: { 
    $lt: new Date(Date.now() - 365*24*60*60*1000) 
  },
  $or: [
    { isPremium: true },
    { postCount: { $gte: 50 } }
  ],
  country: { $in: ["USA", "UK", "Canada"] },
  status: "active",
  lastLogin: { 
    $gte: new Date(Date.now() - 30*24*60*60*1000) 
  }
})