• Reference >
• Operators >
• Aggregation Pipeline Operators

Aggregation Pipeline Operators

Stage Operators

In the db.collection.aggregate method, pipeline stages appear in an array. Documents pass through the stages in sequence.

db.collection.aggregate( [ { <stage> }, ... ] )

Name	Description
$project	Reshapes each document in the stream, such as by adding new fields or removing existing fields. For each input document, outputs one document.
$match	Filters the document stream to allow only matching documents to pass unmodified into the next pipeline stage. $match uses standard MongoDB queries. For each input document, outputs either one document (a match) or zero documents (no match).
$redact	Reshapes each document in the stream by restricting the content for each document based on information stored in the documents themselves. Incorporates the functionality of $project and $match. Can be used to implement field level redaction. For each input document, outputs either one or zero document.
$limit	Passes the first n documents unmodified to the pipeline where n is the specified limit. For each input document, outputs either one document (for the first n documents) or zero documents (after the first n documents).
$skip	Skips the first n documents where n is the specified skip number and passes the remaining documents unmodified to the pipeline. For each input document, outputs either zero documents (for the first n documents) or one document (if after the first n documents).
$unwind	Deconstructs an array field from the input documents to output a document for each element. Each output document replaces the array with an element value. For each input document, outputs n documents where n is the number of array elements and can be zero for an empty array.
$group	Groups input documents by a specified identifier expression and applies the accumulator expression(s), if specified, to each group. Consumes all input documents and outputs one document per each distinct group. The output documents only contain the identifier field and, if specified, accumulated fields.
$sample	Randomly selects the specified number of documents from its input.
$sort	Reorders the document stream by a specified sort key. Only the order changes; the documents remain unmodified. For each input document, outputs one document.
$geoNear	Returns an ordered stream of documents based on the proximity to a geospatial point. Incorporates the functionality of $match, $sort, and $limit for geospatial data. The output documents include an additional distance field and can include a location identifier field.
$lookup	Performs a left outer join to another collection in the same database to filter in documents from the “joined” collection for processing.
$out	Writes the resulting documents of the aggregation pipeline to a collection. To use the $out stage, it must be the last stage in the pipeline.
$indexStats	Returns statistics regarding the use of each index for the collection.

• Pipeline Aggregation Stages
  • $project (aggregation)
  • $match (aggregation)
  • $redact (aggregation)
  • $limit (aggregation)
  • $skip (aggregation)
  • $unwind (aggregation)
  • $group (aggregation)
  • $sample (aggregation)
  • $sort (aggregation)
  • $geoNear (aggregation)
  • $lookup (aggregation)
  • $out (aggregation)
  • $indexStats (aggregation)

Expression Operators

These expression operators are available to construct expressions for use in the aggregation pipeline.

Operator expressions are similar to functions that take arguments. In general, these expressions take an array of arguments and have the following form:

{ <operator>: [ <argument1>, <argument2> ... ] }

If operator accepts a single argument, you can omit the outer array designating the argument list:

{ <operator>: <argument> }

To avoid parsing ambiguity if the argument is a literal array, you must wrap the literal array in a $literal expression or keep the outer array that designates the argument list.

Boolean Operators

Boolean expressions evaluate their argument expressions as booleans and return a boolean as the result.

In addition to the false boolean value, Boolean expression evaluates as false the following: null, 0, and undefined values. The Boolean expression evaluates all other values as true, including non-zero numeric values and arrays.

Name	Description
$and	Returns true only when all its expressions evaluate to true. Accepts any number of argument expressions.
$or	Returns true when any of its expressions evaluates to true. Accepts any number of argument expressions.
$not	Returns the boolean value that is the opposite of its argument expression. Accepts a single argument expression.

• Boolean Aggregation Operators
  • $and (aggregation)
  • $or (aggregation)
  • $not (aggregation)

Set Operators

Set expressions performs set operation on arrays, treating arrays as sets. Set expressions ignores the duplicate entries in each input array and the order of the elements.

If the set operation returns a set, the operation filters out duplicates in the result to output an array that contains only unique entries. The order of the elements in the output array is unspecified.

If a set contains a nested array element, the set expression does not descend into the nested array but evaluates the array at top-level.

Name	Description
$setEquals	Returns true if the input sets have the same distinct elements. Accepts two or more argument expressions.
$setIntersection	Returns a set with elements that appear in all of the input sets. Accepts any number of argument expressions.
$setUnion	Returns a set with elements that appear in any of the input sets. Accepts any number of argument expressions.
$setDifference	Returns a set with elements that appear in the first set but not in the second set; i.e. performs a relative complement of the second set relative to the first. Accepts exactly two argument expressions.
$setIsSubset	Returns true if all elements of the first set appear in the second set, including when the first set equals the second set; i.e. not a strict subset. Accepts exactly two argument expressions.
$anyElementTrue	Returns true if any elements of a set evaluate to true; otherwise, returns false. Accepts a single argument expression.
$allElementsTrue	Returns true if no element of a set evaluates to false, otherwise, returns false. Accepts a single argument expression.

• Set Operators (Aggregation)
  • $setEquals (aggregation)
  • $setIntersection (aggregation)
  • $setUnion (aggregation)
  • $setDifference (aggregation)
  • $setIsSubset (aggregation)
  • $anyElementTrue (aggregation)
  • $allElementsTrue (aggregation)

Comparison Operators

Comparison expressions return a boolean except for $cmp which returns a number.

The comparison expressions take two argument expressions and compare both value and type, using the specified BSON comparison order for values of different types.

Name	Description
$cmp	Returns: 0 if the two values are equivalent, 1 if the first value is greater than the second, and -1 if the first value is less than the second.
$eq	Returns true if the values are equivalent.
$gt	Returns true if the first value is greater than the second.
$gte	Returns true if the first value is greater than or equal to the second.
$lt	Returns true if the first value is less than the second.
$lte	Returns true if the first value is less than or equal to the second.
$ne	Returns true if the values are not equivalent.

• Comparison Aggregation Operators
  • $cmp (aggregation)
  • $eq (aggregation)
  • $gt (aggregation)
  • $gte (aggregation)
  • $lt (aggregation)
  • $lte (aggregation)
  • $ne (aggregation)

Arithmetic Operators

Arithmetic expressions perform mathematic operations on numbers. Some arithmetic expressions can also support date arithmetic.

Name	Description
$abs	Returns the absolute value of a number.
$add	Adds numbers to return the sum, or adds numbers and a date to return a new date. If adding numbers and a date, treats the numbers as milliseconds. Accepts any number of argument expressions, but at most, one expression can resolve to a date.
$ceil	Returns the smallest integer greater than or equal to the specified number.
$divide	Returns the result of dividing the first number by the second. Accepts two argument expressions.
$exp	Raises e to the specified exponent.
$floor	Returns the largest integer less than or equal to the specified number.
$ln	Calculates the natural log of a number.
$log	Calculates the log of a number in the specified base.
$log10	Calculates the log base 10 of a number.
$mod	Returns the remainder of the first number divided by the second. Accepts two argument expressions.
$multiply	Multiplies numbers to return the product. Accepts any number of argument expressions.
$pow	Raises a number to the specified exponent.
$sqrt	Calculates the square root.
$subtract	Returns the result of subtracting the second value from the first. If the two values are numbers, return the difference. If the two values are dates, return the difference in milliseconds. If the two values are a date and a number in milliseconds, return the resulting date. Accepts two argument expressions. If the two values are a date and a number, specify the date argument first as it is not meaningful to subtract a date from a number.
$trunc	Truncates a number to its integer.

• Arithmetic Aggregation Operators
  • $abs (aggregation)
  • $add (aggregation)
  • $ceil (aggregation)
  • $divide (aggregation)
  • $exp (aggregation)
  • $floor (aggregation)
  • $ln (aggregation)
  • $log (aggregation)
  • $log10 (aggregation)
  • $mod (aggregation)
  • $multiply (aggregation)
  • $pow (aggregation)
  • $sqrt (aggregation)
  • $subtract (aggregation)
  • $trunc (aggregation)

String Operators

String expressions, with the exception of $concat, only have a well-defined behavior for strings of ASCII characters.

$concat behavior is well-defined regardless of the characters used.

Name	Description
$concat	Concatenates any number of strings.
$substr	Returns a substring of a string, starting at a specified index position up to a specified length. Accepts three expressions as arguments: the first argument must resolve to a string, and the second and third arguments must resolve to integers.
$toLower	Converts a string to lowercase. Accepts a single argument expression.
$toUpper	Converts a string to uppercase. Accepts a single argument expression.
$strcasecmp	Performs case-insensitive string comparison and returns: 0 if two strings are equivalent, 1 if the first string is greater than the second, and -1 if the first string is less than the second.

• String Aggregation Operators
  • $concat (aggregation)
  • $substr (aggregation)
  • $toLower (aggregation)
  • $toUpper (aggregation)
  • $strcasecmp (aggregation)

Text Search Operators

Name	Description
$meta	Access text search metadata.

• Text Search Aggregation Operators
  • $meta (aggregation)

Array Operators

Name	Description
$arrayElemAt	Returns the element at the specified array index.
$concatArrays	Concatenates arrays to return the concatenated array.
$filter	Selects a subset of the array to return an array with only the elements that match the filter condition.
$isArray	Determines if the operand is an array. Returns a boolean.
$size	Returns the number of elements in the array. Accepts a single expression as argument.
$slice	Returns a subset of an array.

• Array Aggregation Operators
  • $arrayElemAt (aggregation)
  • $concatArrays (aggregation)
  • $filter (aggregation)
  • $isArray (aggregation)
  • $size (aggregation)
  • $slice (aggregation)

Variable Operators

Name	Description
$map	Applies a subexpression to each element of an array and returns the array of resulting values in order. Accepts named parameters.
$let	Defines variables for use within the scope of a subexpression and returns the result of the subexpression. Accepts named parameters.

• Aggregation Variable Operators
  • $map (aggregation)
  • $let (aggregation)

Literal Operators

Name	Description
$literal	Return a value without parsing. Use for values that the aggregation pipeline may interpret as an expression. For example, use a $literal expression to a string that starts with a $ to avoid parsing as a field path.

• Aggregation Literal Operators
  • $literal (aggregation)

Date Operators

Name	Description
$dayOfYear	Returns the day of the year for a date as a number between 1 and 366 (leap year).
$dayOfMonth	Returns the day of the month for a date as a number between 1 and 31.
$dayOfWeek	Returns the day of the week for a date as a number between 1 (Sunday) and 7 (Saturday).
$year	Returns the year for a date as a number (e.g. 2014).
$month	Returns the month for a date as a number between 1 (January) and 12 (December).
$week	Returns the week number for a date as a number between 0 (the partial week that precedes the first Sunday of the year) and 53 (leap year).
$hour	Returns the hour for a date as a number between 0 and 23.
$minute	Returns the minute for a date as a number between 0 and 59.
$second	Returns the seconds for a date as a number between 0 and 60 (leap seconds).
$millisecond	Returns the milliseconds of a date as a number between 0 and 999.
$dateToString	Returns the date as a formatted string.

• Date Aggregation Operators
  • $dayOfYear (aggregation)
  • $dayOfMonth (aggregation)
  • $dayOfWeek (aggregation)
  • $year (aggregation)
  • $month (aggregation)
  • $week (aggregation)
  • $hour (aggregation)
  • $minute (aggregation)
  • $second (aggregation)
  • $millisecond (aggregation)
  • $dateToString (aggregation)

Conditional Expressions

Name	Description
$cond	A ternary operator that evaluates one expression, and depending on the result, returns the value of one of the other two expressions. Accepts either three expressions in an ordered list or three named parameters.
$ifNull	Returns either the non-null result of the first expression or the result of the second expression if the first expression results in a null result. Null result encompasses instances of undefined values or missing fields. Accepts two expressions as arguments. The result of the second expression can be null.

• Conditional Aggregation Operators
  • $cond (aggregation)
  • $ifNull (aggregation)

Accumulators

Changed in version 3.2: Some accumulators are now available in the $project stage. In previous versions of MongoDB , accumulators are available only for the $group stage.

Accumulators, when used in the $group stage, maintain their state (e.g. totals, maximums, minimums, and related data) as documents progress through the pipeline.

When used in the $group stage, accumulators take as input a single expression, evaluating the expression once for each input document, and maintain their stage for the group of documents that share the same group key.

When used in the $project stage, the accumulators do not maintain their state. When used in the $project stage, accumulators take as input either a single argument or multiple arguments.

Name	Description
$sum	Returns a sum of numerical values. Ignores non-numeric values. Changed in version 3.2: Available in both $group and $project stages.
$avg	Returns an average of numerical values. Ignores non-numeric values. Changed in version 3.2: Available in both $group and $project stages.
$first	Returns a value from the first document for each group. Order is only defined if the documents are in a defined order. Available in $group stage only.
$last	Returns a value from the last document for each group. Order is only defined if the documents are in a defined order. Available in $group stage only.
$max	Returns the highest expression value for each group. Changed in version 3.2: Available in both $group and $project stages.
$min	Returns the lowest expression value for each group. Changed in version 3.2: Available in both $group and $project stages.
$push	Returns an array of expression values for each group. Available in $group stage only.
$addToSet	Returns an array of unique expression values for each group. Order of the array elements is undefined. Available in $group stage only.
$stdDevPop	Returns the population standard deviation of the input values. Changed in version 3.2: Available in both $group and $project stages.
$stdDevSamp	Returns the sample standard deviation of the input values. Changed in version 3.2: Available in both $group and $project stages.

• Group Accumulator Operators
  • $sum (aggregation)
  • $avg (aggregation)
  • $first (aggregation)
  • $last (aggregation)
  • $max (aggregation)
  • $min (aggregation)
  • $push (aggregation)
  • $addToSet (aggregation)
  • $stdDevPop (aggregation)
  • $stdDevSamp (aggregation)

←   $isolated Pipeline Aggregation Stages  →

Was this page helpful?

Yes No

Thank you for your feedback!

We're sorry! You can Report a Problem to help us improve this page.

© MongoDB, Inc 2008-2016. MongoDB, Mongo, and the leaf logo are registered trademarks of MongoDB, Inc.