Mongoose Query.prototype.in() API

In MongoDB, querying documents based on specific conditions is an essential part of data retrieval. The Mongoose Query.prototype.in() API offers a powerful method to perform queries that check if a field's value is contained within an array of values. This API simplifies the process of matching values to a list of possibilities and is commonly used for filtering documents that contain any of the specified values in a field.

In this article, we’ll cover the Mongoose in() API, providing a thorough explanation, syntax, examples, and step-by-step instructions on how to use it to filter your MongoDB documents efficiently.

What is the Mongoose in() Method?

The in() method in Mongoose is used to filter documents from a collection where the value of a specific field matches any value from an array. It's an efficient way to query multiple values for a single field. The method is often used in scenarios where you need to check if a particular field matches any item in a predefined list of possible values.

Syntax:

Query.prototype.in(path, val)

Parameters:

• path: It is a string that identifies the attribute name in the mongoose schema
• val: It is an array that determines the range of values to scan and find all the documents whose paths have values lying in the array

Return type

• The in() method returns a Query object, which can then be executed using .exec() or await to retrieve the results.

When to Use the in() Method

The in() method is ideal for scenarios where you need to:

• Query multiple possible values for a specific field.
• Optimize query performance by filtering documents with multiple values without needing to chain multiple queries together.
• Search large datasets efficiently when checking for multiple potential matches in a field.

It is commonly used for filtering data like:

• User roles (admin, user, guest)
• Product categories
• Age groups or date ranges
• Tags and labels

Setting Up Node.js Application with Mongoose

Before diving into the examples, let’s set up a simple Node.js application and install Mongoose.

Step 1: Create a Node.js Application

Create a node application using the following command:

mkdir folder_name
cd folder_name
npm init -y
touch main.js

Step 2: Install Mongoose

After completing the Node.js application, Install the required module using the following command:

npm install mongoose

Example 1: Filtering by Age Using the in() Method

In this example, we will filter documents based on the age field, looking for all documents where the age is either 35 or 40.

Filename: main.js

// Importing the module
const mongoose = require('mongoose');

// Creating the connection
mongoose.connect('mongodb://localhost:27017/query-helpers', {
  dbName: 'event_db',
  useNewUrlParser: true,
  useUnifiedTopology: true
}, err => err ? console.log(err) : console.log('Connected to database'));

// Defining a Schema
const personSchema = new mongoose.Schema({
  name: {
    type: String
  },
  age: {
    type: Number
  }
});

// Sample data to insert
const personsArray = [
  { name: 'Luffy', age: 20 },
  { name: 'Nami', age: 20 },
  { name: 'Zoro', age: 35 }
];

// Creating the Model
const Person = mongoose.model('Person', personSchema);

// Inserting sample data and querying using `in()`
(async () => {
  await Person.insertMany(personsArray);  // Insert sample data
  const res = await Person.find().in('age', [35, 40]);  // Query by age
  console.log({ res });
})();

Step to Run Application: Run the application using the following command from the root directory of the project:

node main.js

Output: 

GUI Representation of the  Database using MongoDB Compass:

Example 2: Filtering by Name Using the in() Method

In this example, we will filter documents based on the name field, looking for documents where the name is either Zoro or Usorp.

Filename: main.js

//Importing the module
const mongoose = require('mongoose')

// Creating the connection
mongoose.connect('mongodb://localhost:27017/query-helpers',
    {
        dbName: 'event_db',
        useNewUrlParser: true,
        useUnifiedTopology: true
    }, err => err ? console.log(err)
        : console.log('Connected to database'));

let personSchema = new mongoose.Schema({
    name: {
        type: String,
    },
    age: {
        type: Number,
    }
});

let personsArray = [
    {
        name: 'Luffy',
        age: 20
    },
    {
        name: 'Nami',
        age: 20,
    },
    {
        name: 'Zoro',
        age: 35
    }
]

let Person = mongoose.model('Person', personSchema);

(async () => {
    await Person.insertMany(personsArray)
    const res = await Person.find().in(
        'name', ['Zoro', 'Usorp']
    )
    console.log({ res });
})();

Step to Run Application: Run the application using the following command from the root directory of the project:

node main.js

Output:

GUI Representation of the  Database using MongoDB Compass

To visualize the data in your MongoDB database, you can use MongoDB Compass, a graphical interface for MongoDB. After running the above queries, you can view your filtered data using Compass by connecting to your database at mongodb://localhost:27017/query-helpers and navigating to the event_db collection.

Conclusion

The Mongoose in() method is an efficient way to query documents based on a set of possible values for a specific field. It simplifies data retrieval by checking if a field’s value matches any in a provided array, improving both performance and code simplicity. This method is particularly useful for filtering large datasets, making it ideal for applications that require dynamic queries on multiple values. Using indexed fields can further optimize the query performance.