Comparison Operators

# The comparison operator pattern — consistent across all operators

# Basic structure:
# { "field": { "$operator": value } }

# Simple exact match (no operator needed — implicit $eq)
implicit_eq = {"membership": "premium"}

# Explicit $eq — identical result to above
explicit_eq = {"membership": {"$eq": "premium"}}

# Range query — combining two operators on one field
range_query = {"price": {"$gte": 20, "$lte": 100}}

# Operator on a nested field using dot notation
nested_query = {"items.price": {"$gt": 10}}

# Operator combined with a filter — all conditions must match
combined = {"category": "Electronics", "price": {"$lt": 50}}

patterns = [
    ("Implicit eq",  implicit_eq),
    ("Explicit eq",  explicit_eq),
    ("Range",        range_query),
    ("Nested field", nested_query),
    ("Combined",     combined),
]

for label, pattern in patterns:
    print(f"  {label:15} → {pattern}")

# $eq and $ne — equality and inequality

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# $eq — find all premium users (explicit form)
print("Premium users ($eq):")
results = db.users.find(
    {"membership": {"$eq": "premium"}},
    {"name": 1, "membership": 1, "_id": 0}
)
for u in results:
    print(f"  {u['name']} — {u['membership']}")

# $ne — find all orders that are NOT delivered
print("\nNon-delivered orders ($ne):")
results = db.orders.find(
    {"status": {"$ne": "delivered"}},
    {"_id": 1, "status": 1, "total": 1}
)
for o in results:
    print(f"  {o['_id']}  {o['status']:12}  ${o['total']:.2f}")

# $ne also matches documents where the field does not exist
# Adding a document with no membership field to demonstrate
db.users.insert_one({"_id": "u_temp", "name": "Temp User"})
no_membership = db.users.find(
    {"membership": {"$ne": "premium"}},
    {"name": 1, "membership": 1, "_id": 0}
)
print("\nUsers who are not premium (including those with no membership field):")
for u in no_membership:
    print(f"  {u['name']} — {u.get('membership', '[field missing]')}")

# Clean up the temp document
db.users.delete_one({"_id": "u_temp"})

# $gt and $gte — greater than comparisons

from pymongo import MongoClient
from datetime import datetime, timezone

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# Products strictly more expensive than $50
print("Products over $50 ($gt):")
results = db.products.find(
    {"price": {"$gt": 50}},
    {"name": 1, "price": 1, "_id": 0}
)
for p in results:
    print(f"  ${p['price']:>7.2f}  {p['name']}")

# Products $50 or more ($gte includes the boundary)
print("\nProducts $50 or more ($gte):")
results = db.products.find(
    {"price": {"$gte": 50}},
    {"name": 1, "price": 1, "_id": 0}
)
for p in results:
    print(f"  ${p['price']:>7.2f}  {p['name']}")

# Users aged 30 or older
print("\nUsers aged 30+ ($gte):")
results = db.users.find(
    {"age": {"$gte": 30}},
    {"name": 1, "age": 1, "_id": 0}
)
for u in results:
    print(f"  {u['name']} — age {u['age']}")

# Orders placed after a specific date ($gt on a date field)
cutoff = datetime(2024, 2, 1, tzinfo=timezone.utc)
print("\nOrders after 2024-02-01 ($gt on date):")
results = db.orders.find(
    {"date": {"$gt": cutoff.strftime("%Y-%m-%d")}},
    {"_id": 1, "date": 1, "total": 1}
)
for o in results:
    print(f"  {o['_id']}  {o['date']}  ${o['total']:.2f}")

# $lt and $lte — less than comparisons and range queries

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# Budget products — strictly under $10
print("Budget products under $10 ($lt):")
results = db.products.find(
    {"price": {"$lt": 10}},
    {"name": 1, "price": 1, "_id": 0}
)
for p in results:
    print(f"  ${p['price']:>6.2f}  {p['name']}")

# Products $50 or under ($lte includes the boundary)
print("\nProducts $50 and under ($lte):")
results = db.products.find(
    {"price": {"$lte": 50}},
    {"name": 1, "price": 1, "_id": 0}
)
for p in results:
    print(f"  ${p['price']:>6.2f}  {p['name']}")

# Range query — mid-range products between $20 and $100
print("\nMid-range products $20–$100 ($gte + $lte):")
results = db.products.find(
    {"price": {"$gte": 20, "$lte": 100}},
    {"name": 1, "price": 1, "_id": 0}
)
for p in results:
    print(f"  ${p['price']:>6.2f}  {p['name']}")

# Users under 30 years old
print("\nUsers under 30 ($lt):")
results = db.users.find(
    {"age": {"$lt": 30}},
    {"name": 1, "age": 1, "_id": 0}
)
for u in results:
    print(f"  {u['name']} — age {u['age']}")

# $in and $nin — matching against a list of values

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db     = client["dataplexa"]

# $in — users from UK or Spain
print("Users from UK or Spain ($in):")
results = db.users.find(
    {"country": {"$in": ["UK", "Spain"]}},
    {"name": 1, "country": 1, "_id": 0}
)
for u in results:
    print(f"  {u['name']} ({u['country']})")

# $in — multiple specific orders by _id (bulk fetch)
print("\nFetch specific orders by _id list ($in):")
results = db.orders.find(
    {"_id": {"$in": ["o001", "o003", "o005"]}},
    {"_id": 1, "status": 1, "total": 1}
)
for o in results:
    print(f"  {o['_id']}  {o['status']:12}  ${o['total']:.2f}")

# $nin — products NOT in Stationery or Furniture
print("\nProducts not in Stationery or Furniture ($nin):")
results = db.products.find(
    {"category": {"$nin": ["Stationery", "Furniture"]}},
    {"name": 1, "category": 1, "_id": 0}
)
for p in results:
    print(f"  {p['name']} ({p['category']})")

# $in on an array field — find users who have any of these tags
print("\nUsers with 'vip' or 'early_adopter' tag ($in on array):")
results = db.users.find(
    {"tags": {"$in": ["vip", "early_adopter"]}},
    {"name": 1, "tags": 1, "_id": 0}
)
for u in results:
    print(f"  {u['name']} — {u['tags']}")

# BSON comparison order — types compared when mixed types exist in a field

bson_type_order = [
    (1,  "MinKey (internal)"),
    (2,  "Null"),
    (3,  "Numbers — Int32, Int64, Double, Decimal128"),
    (4,  "Symbol, String"),
    (5,  "Object (embedded document)"),
    (6,  "Array"),
    (7,  "BinData (binary)"),
    (8,  "ObjectId"),
    (9,  "Boolean"),
    (10, "Date"),
    (11, "Timestamp"),
    (12, "Regular expression"),
    (13, "MaxKey (internal)"),
]

print("BSON type comparison order (lowest to highest):")
for rank, type_name in bson_type_order:
    print(f"  {rank:2}.  {type_name}")

print("\nPractical implication:")
print("  A field storing '30' (string) is GREATER than 29 (int)")
print("  because strings sort higher than numbers in BSON order.")
print("  Always store values in a consistent type to avoid this.")