Top 10 MongoDB Operators Every Developer Should Know (With Examples)

Ever feel like you're just scratching the surface of your MongoDB data? Operators are the key to unlocking its full potential! They're like the secret ingredients that turn basic queries into powerful data insights. Whether you need to filter, update, or analyze your data, MongoDB query operators are your go-to toolkit.

In this blog, we'll dive into the world of MongoDB query operators, breaking down each category with clear explanations and real-world examples. Let's get started!

Categories of MongoDB Operators

MongoDB operators are classified into various categories based on their functionalities:

1. Comparison Operators
2. Logical Operators
3. Element Operators
4. Array Operators
5. Evaluation Operators
6. Bitwise Operators
7. Projection Operators
8. Geospatial Operators
9. Update Operators
10. Aggregation Operators

Let’s explore each category with its operators, descriptions, and practical examples.

1. Comparison Operators

Comparison operators filter documents by comparing field values against specified values.

Suppose we have a collection of books, and we need to find all the books that have a price exactly equal to 1000

db.products.find({ "price": { "$eq": 1000 } })

$ne (Not Equal)

 Imagine we want to find all products that are not in the "Electronics" category. This query filters out any product with the category "Electronics".

db.products.find({ "category": { "$ne": "Electronics" } })

$gt (Greater Than)

 If we're looking for products with a price higher than 1000, this query will return those documents.

db.products.find({ "price": { "$gt": 1000 } })

$gte (Greater Than or Equal)

This query finds products with a price of 500 or more.

db.products.find({ "price": { "$gte": 500 } })

$lt (Less Than)

 To find products with stock levels below 10, this query is used.

db.products.find({ "stock": { "$lt": 10 } })

$lte (Less Than or Equal)

This query finds products with a rating of 4 or less.

db.products.find({ "rating": { "$lte": 4 } })

$in (Matches Any Value in an Array)

Suppose we want to find all products that belong to either the "Electronics" or "Clothing" categories.

db.products.find({ "category": { "$in": ["Electronics", "Clothing"] } })

$nin (Not in an Array)

This query finds products that are not in the "Furniture" or "Toys" categories.

db.products.find({ "category": { "$nin": ["Furniture", "Toys"] } })

 Key Points:

• Useful for filtering based on numerical comparisons or specific values. 
• $in helps in filtering multiple values at once. 
• $gt and $lt are great for range-based queries.

2. Logical Operators

Logical operators let you combine multiple conditions to create more complex queries.

$and (Logical AND)

If we need to find all products that are in the "Electronics" category and have a price greater than 1000.

db.products.find({ "$and": [ { "category": "Electronics" }, { "price": { "$gt": 1000 } } ] })

$or (Logical OR)

This query finds products that are either in the "Clothing" category or have a stock level greater than 100.

db.products.find({ "$or": [ { "category": "Clothing" }, { "stock": { "$gt": 100 } } ] })

$nor (Logical NOR)

 We want to find products that are neither in the "Electronics" category nor have a price above 2000.

db.products.find({ "$nor": [ { "category": "Electronics" }, { "price": { "$gt": 2000 } } ] })

$not (Logical NOT)

This query finds all products that are not in the "Clothing" category.

db.products.find({ "category": { "$not": { "$eq": "Clothing" } } })

Key Points:

• Allows complex filtering based on multiple criteria.
• Provides flexibility in combining conditions.
• Essential for advanced query logic. 

3. Element Operators

Element operators check if a field exists or if it's of a specific data type.

$exists (Field Exists Check)

This query finds all products where the "discount" field exists, indicating that a discount is applied.

db.products.find({ "discount": { "$exists": true } })

$type (Field Data Type Check)

Suppose we want to find all products where the "stock" field is stored as an integer, ensuring consistency in our stock data.

db.products.find({ "stock": { "$type": "int" } })

Key Points:

• Helps maintain data integrity.
• Useful for handling documents with varying structures.
• Essential for data validation.

4. Array Operators

Array operators let you query fields that are arrays.

$all (Match All Elements in an Array)

Find products that have both "Wireless" and "Bluetooth" in the features array:

db.products.find({ "features": { "$all": ["Wireless", "Bluetooth"] } })

$size (Match Array Size)

Suppose you want to find all products that have exactly three tags associated with them.

db.products.find({ "tags": { "$size": 3 } })

$elemMatch (Match at Least One Array Element with Multiple Conditions)

If we have a collection of products with reviews. You want to find all products where at least one review has a rating greater than 4 and is from a verified buyer.

db.products.find({ "reviews": { "$elemMatch": { "rating": { "$gt": 4 }, "verified": true } } })

Key Points:

• Enables powerful queries on array data.

5. Evaluation Operators

Evaluation operators provide additional query functionality like regex matching, text searching, and more.

$jsonSchema (Validate documents using a JSON schema)

Imagine you want to ensure that all product documents have a "price" field that is a number and a "category" field that is a string. This query uses a JSON schema to validate the structure and data types of the documents.

db.products.find({ "$jsonSchema": { "bsonType": "object", "required": ["price", "category"], "properties": { "price": { "bsonType": "number" }, "category": { "bsonType": "string" } } } })

$mod (Find values with a remainder when divided by a number)

If we  want to find all products where the price is exactly divisible by 500 (i.e., the remainder is 0). 

db.products.find({ "price": { "$mod": [500, 0] } })

$regex (Match a pattern in a string field)

If we want to find all products where the name contains the word "shirt", regardless of case.This query uses a regular expression to perform a case-insensitive search for "shirt" within the "name" field.

db.products.find({ "name": { "$regex": "shirt", "$options": "i" } })

$text (Perform a text search on indexed fields)

If you have a collection of products with a text index, and you want to find all products that contain the word "gaming", this can be used.

db.products.find({ "$text": { "$search": "gaming" } })

$where (Use JavaScript expressions in queries)

If you want to find all products where the stock level is greater than one-tenth of the price, you can use a JavaScript expression in the $where operator to perform this calculation.

db.products.find({ "$where": "this.stock > this.price / 10" })

Key Points:

• Provides advanced query capabilities.
• $regex allows pattern matching.
• $text enables full-text search. (Requires a text index)

6. Bitwise Operators 

Bitwise operators allow performing bitwise comparisons on integer fields. They're useful when you need to work with data at the bit level.

$bitsAllSet (All specified bits must be set to 1)

Imagine your "stock" field stores integer values representing bit flags. This query finds all products where both the 2nd bit (position 1) and the 3rd bit (position 2) are set to 1. 

db.products.find({ "stock": { "$bitsAllSet": [1, 2] } })

$bitsAnySet (At least one specified bit must be set to 1)

This query finds all products where either the 2nd bit (position 1) or the 3rd bit (position 2) or both are set to 1 in the "stock" field.

db.products.find({ "stock": { "$bitsAnySet": [1, 2] } })

$bitsAllClear (All specified bits must be 0)

This query finds all products where both the 2nd bit (position 1) and the 3rd bit (position 2) are set to 0 in the "stock" field.

db.products.find({ "stock": { "$bitsAllClear": [1, 2] } })

$bitsAnyClear (At least one specified bit must be 0)

This query finds all products where either the 2nd bit (position 1) or the 3rd bit (position 2) or both are set to 0 in the "stock" field.

db.products.find({ "stock": { "$bitsAnyClear": [1, 2] } })

Key Points: 

• Useful for working with binary data and flags.
• $bitsAllSet and $bitsAnySet check for set bits.
• $bitsAllClear and $bitsAnyClear check for clear bits.
• Requires understanding of binary representation.

7. Projection Operators

Projection operators allow you to control which fields are included or excluded in your query results, making your data more manageable.

$ (Project the first matching array element)

Suppose you want to find products that have at least one review with a rating of 5, and you only want to retrieve that first matching review. 

db.products.find({ "reviews.rating": 5 }, { "reviews.$": 1 })

$elemMatch (Project matching array elements based on conditions)

If you want to retrieve the product name and only those reviews where the rating is greater than 4, this query is perfect. 

db.products.find({}, { "name": 1, "reviews": { "$elemMatch": { "rating": { "$gt": 4 } } } })

$meta (Retrieve text search metadata)

Find products using a text search and return relevance scores.

db.products.find({ "$text": { "$search": "gadget" } }, { "name": 1, "score": { "$meta": "textScore" } })

$slice (Limit the number of array elements returned)

 If you only want to see the first two reviews for each product, regardless of the total number of reviews, this query uses $slice to limit the "reviews" array to the first two elements

db.products.find({}, { "name": 1, "reviews": { "$slice": 2 } })

Key Points: 

• Controls which fields are included in query results.

8. Geospatial Operators

Geospatial operators are essential for querying location-based data stored in GeoJSON format. These operators rely on 2dsphere indexes to perform efficient geospatial queries.

$geoWithin (Find places within a polygon)

Imagine you have a database of places, and you want to find all the restaurants located within a specific district of a city, defined by a polygon.

db.places.find({ location: { $geoWithin: { $geometry: { type: "Polygon", coordinates: [[[77.58, 12.96], [77.60, 12.96], [77.60, 13.00], [77.58, 13.00], [77.58, 12.96]]] } } } })

$geoIntersects (Find places intersecting a given shape)

Suppose you want to find all places that intersect with a particular street, represented as a line string. This query will return all places that touch or cross that street.

 db.places.find({ location: { $geoIntersects: { $geometry: { type: "LineString", coordinates: [[77.58, 12.96], [77.60, 13.00]] } } } })

$near (Find the closest places within 5 km)

If you want to find the closest restaurants to your current location (a specific point) within a 5-kilometer radius, this query will return the places within a given radius.

 db.places.find({ location: { $near: { $geometry: { type: "Point", coordinates: [77.595, 12.97] }, $maxDistance: 5000 } } })

$nearSphere (Find the closest places considering Earth's curvature within 5 km)

For finding the closest airports to a city, where distances are significant, using $nearSphere provides more accurate results by accounting for the Earth's curvature.

 db.places.find({ location: { $nearSphere: { $geometry: { type: "Point", coordinates: [77.595, 12.97] }, $maxDistance: 5000 } } })

Key Points: 

• GeoJSON format is required (Point, LineString, Polygon).
• 2dsphere index is needed to perform these queries (db.places.createIndex({ location: "2dsphere" })).

9. Update Operators

Update operators are crucial for modifying existing documents in your MongoDB collection. They allow you to add, change, or remove fields, as well as manipulate array elements.

$set (Update or Add a Field)

If we need to update the stock count of a specific product. This query finds the product with _id: 1 and sets its "stock" field to 60.

db.products.updateOne({ _id: 1 }, { "$set": { "stock": 60 } })

$inc (Increment or Decrement a Numeric Value)

Suppose you want to increase the price of a product by 500. This query finds the product with _id: 2 and adds 500 to its "price" field.

db.products.updateOne({ _id: 2 }, { "$inc": { "price": 500 } })

$unset (Remove a Field)

If you need to remove the "discount" field from a product, this query finds the product with _id: 3 and deletes the "discount" field. 

db.products.updateOne({ _id: 3 }, { "$unset": { "discount": "" } })

$rename (Rename a Field)

If you want to change the field name "category" to "productCategory" for a specific product, this query finds the product with _id: 4 and renames the field.

db.products.updateOne({ _id: 4 }, { "$rename": { "category": "productCategory" } })

$push (Add an Element to an Array)

Add "newArrival" to the tags array for the product with _id: 5.

db.products.updateOne({ _id: 5 }, { "$push": { "tags": "newArrival" } })

$pop (Remove First or Last Element from an Array)

Remove the first element from the tags array of the product with _id: 1.
db.products.updateOne({ _id: 1 }, { "$pop": { "tags": -1 } })

Key Points:

• Allows precise modification of document fields.

10. Aggregation Operators

Aggregation operators are powerful tools for transforming and analyzing data in MongoDB. They allow you to perform calculations, group documents, filter, and sort data in a pipeline.

$sum (Compute Sum of Values)

To find the total stock of all products in our collection.

db.products.aggregate([{ "$group": { "_id": null, "totalStock": { "$sum": "$stock" } } }])

$avg (Compute Average of Values)

To find the average price of all products, this query groups all documents into one and calculates the average of the "price" field.

db.products.aggregate([{ "$group": { "_id": null, "averagePrice": { "$avg": "$price" } } }])

$min (Find Minimum Value)

Get the product with the lowest price.

db.products.aggregate([{ "$group": { "_id": null, "minPrice": { "$min": "$price" } } }])

$max (Find Maximum Value)

Get the product with the highest price.

db.products.aggregate([{ "$group": { "_id": null, "maxPrice": { "$max": "$price" } } }])

$group (Group Documents by a Field)

Suppose you want to count the number of products in each category. This query groups the documents by the "category" field and uses $sum to count the number of documents in each group.

db.products.aggregate([{ "$group": { "_id": "$category", "count": { "$sum": 1 } } }])

$match (Filter Documents)

Find the matching products in the "Electronics" category.

db.products.aggregate([{ "$match": { "category": "Electronics" } }])

$sort (Sort Documents)

If you want to sort products by price in descending order, this query can be used.

Key Points: 

• Enables powerful data transformation and analysis.
• Aggregation pipelines provide a sequence of operations.