How to use Aggregate in mongoose

Mongoose is a MongoDB object modeling tool designed for asynchronous environments and supports MongoDB's aggregation pipeline. The aggregation pipeline is a powerful data processing tool that enables you to perform complex data transformations and calculations directly at the database level. Using Mongoose for aggregation queries typically involves the following steps:

1. Define Schema and Model

First, define your data model and schema. For example, consider a model for storing product information:

javascript
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const productSchema = new Schema({
  name: String,
  price: Number,
  category: String
});

const Product = mongoose.model('Product', productSchema);

2. Use the Aggregation Pipeline

After defining the model, you can use the .aggregate() method to construct aggregation queries. This method accepts an array where each element represents a stage in the aggregation pipeline.

Example: Calculate the Average Price per Category

javascript
Product.aggregate([
  {
    $match: {}  // Add conditions to filter data
  },
  {
    $group: {
      _id: "$category",  // Group by category
      averagePrice: { $avg: "$price" }  // Calculate the average price for each category
    }
  }
]).then(result => {
  console.log(result);  // Output the result
}).catch(err => {
  console.error(err);
});

In this example, no filtering conditions are specified in the $match stage, so it processes all documents. The $group stage groups by the 'category' field and calculates the average price for each group.

3. Handle Aggregation Results

Aggregation queries return a promise, which you can handle using .then() or async/await. In the above example, we used .then() to output the result.

Advanced Usage

Mongoose's aggregation pipeline is highly flexible, allowing you to use multiple stages such as $sort, $limit, and $project to further process data. For example, if you want to retrieve the top three products from different categories based on price, you can add additional stages:

javascript
Product.aggregate([
  { $sort: { price: -1 } },
  { $group: { _id: "$category", topProduct: { $first: "$ROOT" } } },
  { $limit: 3 }
]).then(result => {
  console.log(result);
});

Summary

Using Mongoose's aggregation pipeline enables highly efficient complex data processing, performing calculations directly at the database level to reduce the application layer's burden and is suitable for data analysis and statistics. By properly designing aggregation queries, you can maximize the utilization of MongoDB's powerful data processing capabilities.