Mongoose Aggregate.prototype.exec() API

Mongoose, a popular MongoDB ODM (Object Data Modeling) library for Node.js, provides a powerful API to perform advanced aggregation operations. One such method is Aggregate.prototype.exec(), which allows you to execute an aggregation pipeline and return a promise or use a callback to handle the results. This article will explain how to use the exec() method effectively in your Mongoose applications, helping you fetch and manipulate data with ease.

What is the exec() Method in Mongoose Aggregation?

The exec() method in Mongoose’s aggregation API executes the aggregation pipeline on the current model, either returning a promise (for async/await) or accepting a callback function to handle the result. This gives you flexibility in managing database queries, making it easy to handle asynchronous tasks.

Syntax:

aggregate.exec( callback )

• callback: A function that handles the result of the aggregation. If not provided, the exec() method returns a promise, which can be handled using then() or async/await.

Parameters

callback: The callback function receives two parameters:

• error: Error object if any occurs during aggregation.
• result: The resulting array from the aggregation query.

Return Value:

• With Callback: The callback is invoked with two parameters, error and result.
• With Promise: If no callback is provided, exec() returns a promise that resolves with the aggregation result or rejects with an error.

Setting up Node.js Application

To set up the Mongoose aggregation pipeline with exec(), follow these steps:

Step 1: Create a Node.js application

Run the following command in your terminal

npm init

Step 2: Install Mongoose

After creating the NodeJS application, Install the required module using the following command:

npm install mongoose

Step 3: Structure of Your Project

The project structure will look like this: 

Database Structure: The database structure will look like this, the following documents are present in the collection.

Example 1: Using exec() with a Callback

In this example, we have established a database connection using mongoose and defined model over cricketerSchema, having three columns or fields "_id", "name", and "nationality". At the end, we have added pipeline operation to select name field from the collection. And we are calling exec() method to get the result set.

Filename: app.js

Step to run the program: To run the application execute the below command from the root directory of the project:

node app.js

Output:

[
 { _id: 3, name: 'Ben Stokes' }, 
 { _id: 2, name: 'David Warner' }, 
 { _id: 5, name: 'Aaron Finch' }, 
 { _id: 7, name: 'K L Rahul' }, 
 { _id: 6, name: 'Hardik Pandya' },
 { _id: 1, name: 'Virat Kohli' }, 
 { _id: 4, name: 'Rohit Sharma' } 
]

Example 2: Using exec() with async/await

In this example, we have established a database connection using mongoose and defined model over cricketerSchema, having three columns or fields "_id", "name", and "nationality". At the end, we are handling the promise returned by exec() method using asynchronous function and await keyword.

Filename: app.js

Step to run the program: To run the application execute the below command from the root directory of the project:

node app.js

Output:

[
 { name: 'Ben Stokes', nationality: 'England ' }, 
 { name: 'David Warner', nationality: 'Australia' },
 { name: 'Aaron Finch', nationality: 'Australia ' },
 { name: 'K L Rahul', nationality: 'India ' }, 
 { name: 'Hardik Pandya', nationality: 'India ' }, 
 { name: 'Virat Kohli', nationality: 'India' }, 
 { name: 'Rohit Sharma', nationality: 'India ' } 
]

Why Use exec()?

The exec() method provides flexibility in how you handle results from the aggregation pipeline. It allows you to:

1. Handle Results Asynchronously: With promises and async/await, exec() makes handling complex queries simpler and more readable.
2. Error Handling: Easily manage errors in aggregation queries by using callback functions or try-catch blocks in async functions.
3. Code Clarity: The explicit handling of callback functions or promises improves code maintainability and readability.

When to Use exec()?

You should use exec() in the following cases:

• When you want to execute an aggregation pipeline and handle results asynchronously using callback functions or async/await.
• When you need to optimize database queries and want to improve readability and maintainability.
• When you are building applications that need to execute complex MongoDB queries or perform aggregation tasks like sorting, grouping, or filtering.

Conclusion

Mongoose’s aggregate.exec() method is an essential tool for executing aggregation pipelines and handling results efficiently. Whether you prefer using callback functions or async/await, this method provides a flexible and easy-to-understand way to interact with MongoDB aggregation results. By using exec(), you can easily handle complex aggregation tasks and improve the performance and scalability of your Node.js applications.