MongoDB Query Operations: A Detailed Guide

MongoDB provides a powerful query language with a variety of operators to filter, project, and manipulate data. In this article, we will explore various query operations in MongoDB, covering projections, comparisons, arrays, elements, and logical operators.

1. Projections in MongoDB

Projection operators allow us to include or exclude specific fields when retrieving documents.

1.1 $project

The $project stage in aggregation helps reshape documents by including, excluding, or computing new fields.

Example:

db.users.aggregate([
  {
    $project: {
      name: 1,
      email: 1,
      age: 1,
      isAdult: { $gte: ["$age", 18] } // New computed field
    }
  }
])        

Here, we include name, email, age, and create a new field isAdult.

1.2 $include and $exclude

MongoDB does not have explicit $include and $exclude operators, but we can achieve the same using projections.

Example: Including Specific Fields

db.users.find({}, { name: 1, email: 1 })        

This retrieves only the name and email fields.

Example: Excluding Specific Fields

db.users.find({}, { password: 0, sensitiveInfo: 0 })        

This retrieves all fields except password and sensitiveInfo.

1.3 $slice

The $slice operator limits the number of elements in an array field.

Example: Retrieving the first 3 elements of an array

db.posts.find({}, { comments: { $slice: 3 } })        

This returns only the first three comments in each post's comments array.

2. Comparison Operators

MongoDB supports various comparison operators to filter documents based on field values.

2.1 $eq (Equals)

Finds documents where a field is equal to a given value.

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

2.2 $gt (Greater Than)

Finds documents where a field is greater than a given value.

db.orders.find({ totalAmount: { $gt: 100 } })        

2.3 $lt (Less Than)

Finds documents where a field is less than a given value.

db.users.find({ age: { $lt: 25 } })        

2.4 $lte (Less Than or Equal To)

Finds documents where a field is less than or equal to a value.

db.users.find({ age: { $lte: 30 } })        

2.5 $gte (Greater Than or Equal To)

Finds documents where a field is greater than or equal to a value.

db.orders.find({ totalAmount: { $gte: 50 } })        

2.6 $ne (Not Equal)

Finds documents where a field is not equal to a value.

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

3. Array Operators

MongoDB allows filtering based on array values.

3.1 $in

Matches documents where a field's value is in an array.

db.users.find({ role: { $in: ["admin", "editor"] } })        

3.2 $nin (Not In)

Matches documents where a field's value is not in an array.

db.users.find({ role: { $nin: ["admin", "editor"] } })        

3.3 $all

Matches documents where an array contains all specified elements.

db.orders.find({ tags: { $all: ["urgent", "high-priority"] } })        

3.4 $elemMatch

Matches documents where at least one array element satisfies multiple conditions.

db.students.find({
  scores: { $elemMatch: { subject: "Math", score: { $gte: 90 } } }
})        

3.5 $size

Matches documents where an array contains exactly a specified number of elements.

db.posts.find({ comments: { $size: 5 } })        

4. Element Operators

These operators help filter documents based on field existence and types.

4.1 $exists

Checks whether a field exists.

db.users.find({ phoneNumber: { $exists: true } })        

This retrieves documents where phoneNumber is present.

4.2 $type

Matches documents where a field is of a specified type.

db.users.find({ age: { $type: "number" } })        

4.3 $regex

Matches string fields using regular expressions.

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

This retrieves products where name starts with "Samsung" (case-insensitive).

5. Logical Operators

Logical operators combine multiple conditions in queries.

5.1 $and

Matches documents that satisfy all conditions.

db.users.find({ $and: [{ age: { $gte: 18 } }, { country: "India" }] })        

5.2 $or

Matches documents that satisfy at least one condition.

db.users.find({ $or: [{ age: { $lt: 18 } }, { country: "India" }] })        

5.3 $not

Negates a condition.

db.users.find({ age: { $not: { $gte: 18 } } })        

This retrieves users where age is not greater than or equal to 18.

5.4 $nor

Matches documents where none of the conditions are met.

db.users.find({ $nor: [{ age: { $gte: 30 } }, { country: "India" }] })        

This retrieves users who are not 30 or older and not from the India.

Conclusion

MongoDB provides a powerful set of query operators to filter and manipulate data efficiently. From simple comparisons to complex logical conditions, these operators enable precise data retrieval. Understanding these query operations can significantly enhance your MongoDB querying skills.

Thank you for taking the time to read! Follow me for more insights and updates, and let’s continue to grow and learn together.