Aggregation Pipeline Operators

The aggregation pipeline operators construct expressions for use in the aggregation pipeline stages. The following are the list of Aggregation Pipeline Operators.

Arithmetic Expression Operators

It is used to perform arithmetic operations on numbers. Some arithmetic expression also supports data arithmetic.

$abs

The abs operator returns the absolute value of a number.

Syntax:

Example:

db.score.aggregate([
   {
     $school: { marks: { $abs: { $subtract: [ "$max", "$min" ] } } }
   }
])

$add

It adds two or more numbers and a date. If one of the arguments is a date, then the date treats the other argument as milliseconds to add to the date.

Syntax:

Example:

db.books.aggregate(
   [
     { $project: { item: 1, total: { $add: [ "$price", "$tax" ] } } }
   ]
)

$ceil

The ceil operator returns the smallest integer that is greater than or equal to the specified number.

Syntax:

Example:

db.samples.aggregate([ { $project: { value: 1, ceilingValue: { $ceil: "$value" } } } ])

$divide

It divides one or more numbers by another and returns the result.

Syntax:

Example:

db.planning.aggregate( [ { $project: { name: 1, workdays: { $divide: [ "$hours", 8 ] } } } ] )

$exp

The exp operator is used to raise Euler's number to the specified exponent and returns the result.

Syntax:

Example:

db.accounts.aggregate( [ { $project: { effectiveRate: { $subtract: [ { $exp: "$rate"}, 1 ] } } } ] )

$floor

The floor operator returns the greatest integer less than or equal to the specified number.

Syntax:

Example:

db.samples.aggregate( [ { $project: { value: 1, floorValue: { $floor: "$value" } } } ] )

$ln

The ln operator calculates the natural logarithm of a number and returns the result as a double.

Syntax:

Example:

$log

The log operator calculates the log of a number for the specified base and returns the result as double.

Syntax:

Example:

db.examples.aggregate([
   { $project: { bitsNeeded:
      {
         $floor: { $add: [ 1, { $log: [ "$positiveInt", 2 ] } ] } } }
      }
])

$log10

The log10 operator calculates the log base 10 of a number and returns the result as a double.

Syntax:

Example:

db.samples.aggregate( [ { $project: { pH: { $multiply: [ -1, { $log10: "$H3O" } ] } } } ] )

$mod

The mod operator divides one number with another and returns the remainder.

Syntax:

Example:

db.planning.aggregate(
   [
     { $project: { remainder: { $mod: [ "$hours", "$tasks" ] } } }
   ]
)

$multiply

The multiply operator gives the product of two or more numbers.

Syntax:

Example:

db.sales.aggregate( [ { $project: { date: 1, item: 1, total: { $multiply: [ "$price", "$quantity" ] } } } ] )

$pow

The pow operator raises the number to the given exponent and returns the result.

Syntax:

Example:

db.quizzes.aggregate( [ { $project: { variance: { $pow: [ { $stdDevPop: "$scores.score" }, 2 ] } } } ] )

$round

The round operator rounds a number to a whole integer or a specified decimal place.

Syntax:

Example:

db.samples.aggregate( [ { $project: { roundedValue: { $round: [ "$value", 1 ] } } } ] )

$sqrt

The sqrt operator returns the square root of a positive number as double.

Syntax:

Example:

db.points.aggregate([
   {
     $project: {
        distance: {
           $sqrt: {
               $add: [
                  { $pow: [ { $subtract: [ "$p2.y", "$p1.y" ] }, 2 ] },
                  { $pow: [ { $subtract: [ "$p2.x", "$p1.x" ] }, 2 ] }
               ]
           }
        }
     }
   }
])

$subtract

The subtract operator subtracts two or more numbers to return the difference of the number.

Syntax:

Example:

db.sales.aggregate( [ { $project: { item: 1, total: { $subtract: [ { $add: [ "$price", "$fee" ] }, "$discount" ] } } } ] )

$trunc

The trunc command deletes the data from the specified decimal place.

Syntax:

Example:

db.samples.aggregate( [ { $project: { truncatedValue: { $trunc: [ "$value", 1 ] } } } ] )

Array Expression Operator

$arrayElemAt

It returns the element at the specified array index.

Syntax:

Example:

db.users.aggregate([
   {
     $project:
      {
         name: 1,
         first: { $arrayElemAt: [ "$favorites", 0 ] },
         last: { $arrayElemAt: [ "$favorites", -1 ] }
      }
   }
])

$arrayToObject

The arrayToObject operator converts an array into a single document.

Syntax:

Example:

db.inventory.aggregate(
   [
      {
         $project: {
            item: 1,
            dimensions: { $arrayToObject: "$dimensions" }
         }
      }
   ]
)

$concatArrays

The concatArrays operator joins the array to return the concatenated array.

Syntax:

Example:

db.warehouses.aggregate([
   { $project: { items: { $concatArrays: [ "$instock", "$ordered" ] } } }
])

$filter

The filter operator selects a subset of an array to return the result based on the specified condition.

Syntax:

Example:

db.sales.aggregate([
   {
      $project: {
         items: {
            $filter: {
               input: "$items",
               as: "item",
               cond: { $gte: [ "$$item.price", 100 ] }
            }
         }
      }
   }
])

$in

The in operator returns a boolean indicating that the specified value is in the array or not.

Syntax:

Example:

db.fruit.aggregate([
  {
    $project: {
      "store location" : "$location",
      "has bananas" : {
        $in: [ "bananas", "$in_stock" ]
      }
    }
  }
])

$indexOfArray

The indexOfArray operator searches the array for the occurrence of a specified value and returns the array index of the first occurrence.

Syntax:

Example:

db.inventory.aggregate(
   [
     {
       $project:
          {
            index: { $indexOfArray: [ "$items", 2 ] },
          }
      }
   ]
)

$isArray

It determines and returns a Boolean value if the operand is an Array.

Syntax:

Example:

db.shop.aggregate( [ { $project: { items: { $cond:
            { if: { $and: [ { $isArray: "$instock" }, { $isArray: "$ordered" } ] }, then: { $concatArrays: [ "$instock", "$ordered" ] },
        else: "One or more fields is not an array." } } } } )

$map

The map operator attaches value to each item in an array and returns an array with the applied result.

Syntax:

Example:

db.grades.aggregate(
   [
      { $project:
         { adjustedGrades:
            {
              $map:
                 {
                   input: "$quizzes",
                   as: "grade",
                   in: { $add: [ "$$grade", 2 ] }
                 }
            }
         }
      }
   ]
}

$objectToArray

This operator converts a document to an array.

Syntax:

Example:

db.inventory.aggregate(
   [
      {
         $project: {
            item: 1,
            dimensions: { $objectToArray: "$dimensions" }
         }
      }
   ]
)

$range

The range operator returns an array whose elements are a generated sequence of numbers.

Syntax:

Example:

db.distances.aggregate([{
    $project: {
        _id: 0,
        city: 1,
        "Rest stops": { $range: [ 0, "$distance", 25 ] } } } ] )

$reduce

The reduce operator applies an expression to each element in an array and combines them into a single value.

Syntax:

{
    $reduce: {
        input: <array>,
        initialValue: <expression>,
        in: <expression>
    }
}

Example:

db.clothes.aggregate( [ { $project: { "discountedPrice": {
          $reduce: { input: "$discounts", initialValue: "$price", in: { $multiply: [ "$$value", { $subtract: [ 1, "$$this" ] } ] } } } } } ] )

$reverseArray

It returns an array with the element in reverse order.

Syntax:

Example:

db.users.aggregate( [ { $project: {name: 1,
reverseFavorites: { $reverseArray: "$favorites" } } } ] )

$size

The size operator counts and returns the total number of items in an array.

Syntax:

Example:

db.books.aggregate( [ { $project: { item: 1, numberOfColors: { $cond: { if: { $isArray: "$colors" }, then: { $size: "$colors" }, else: "NA"} } } } ] )

$slice

The slice operator results in a subset of an array.

Syntax:

Example:

db.books.aggregate( [ { $project: { name: 1, threeFavorites: { $slice: [ "$favorites", 3 ] } } }
])

$zip

The zip operator transposes an array so that the first element of the output array would be an array containing the first element of the first input array.

Syntax:

 {
    $zip: { inputs: [ <array expression1>,  ... ], useLongestLength: <boolean>, defaults:  <array expression> } }

Example:

db.matrices.aggregate([{ $project: {  _id: false,   transposed: { $zip: { inputs: [
          { $arrayElemAt: [ "$matrix", 0 ] },
          { $arrayElemAt: [ "$matrix", 1 ] },
          { $arrayElemAt: [ "$matrix", 2 ] },
        ] } } } } ] )

Next TopicMongoDB limit()

← prev next →