Aggregation Pipeline Quick Reference

On this page

Note

For details on specific operator, including syntax and examples, click on the specific operator to go to its reference page.

Stages

Stages (db.collection.aggregate)

In the db.collection.aggregate method, pipeline stages appear in an array. Documents pass through the stages in sequence. All except the $out and $geoNear stages can appear multiple times in a pipeline.

db.collection.aggregate( [ { <stage> }, ... ] )
StageDescription
$addFieldsAdds new fields to documents. Similar to $project, $addFields reshapes each document in the stream; specifically, by adding new fields to to output documents that contain both the existing fields from the input documents and the newly added fields.
$bucketCategorizes incoming documents into groups, called buckets, based on a specified expression and bucket boundaries.
$bucketAutoCategorizes incoming documents into a specific number of groups, called buckets, based on a specified expression. Bucket boundaries are automatically determined in an attempt to evenly distribute the documents into the specified number of buckets.
$collStatsReturns statistics regarding a collection or view.
$countReturns a count of the number of documents at this stage of the aggregation pipeline.
$facetProcesses multiple aggregation pipelines within a single stage on the same set of input documents. Enables the creation of multi-faceted aggregations capable of characterizing data across multiple dimensions, or facets, in a single stage.
$geoNearReturns 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.
$graphLookupPerforms a recursive search on a collection. To each output document, adds a new array field that contains the traversal results of the recursive search for that document.
$groupGroups 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.
$indexStatsReturns statistics regarding the use of each index for the collection.
$limitPasses 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).
$listSessionsLists all sessions that have been active long enough to propagate to the system.sessions collection.
$lookupPerforms a left outer join to another collection in the same database to filter in documents from the “joined” collection for processing.
$matchFilters 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).
$outWrites the resulting documents of the aggregation pipeline to a collection. To use the $out stage, it must be the last stage in the pipeline.
$projectReshapes each document in the stream, such as by adding new fields or removing existing fields. For each input document, outputs one document.
$redactReshapes 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 documents.
$replaceRootReplaces a document with the specified embedded document. The operation replaces all existing fields in the input document, including the _id field. Specify a document embedded in the input document to promote the embedded document to the top level.
$sampleRandomly selects the specified number of documents from its input.
$skipSkips 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).
$sortReorders the document stream by a specified sort key. Only the order changes; the documents remain unmodified. For each input document, outputs one document.
$sortByCountGroups incoming documents based on the value of a specified expression, then computes the count of documents in each distinct group.
$unwindDeconstructs 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.

Stages (db.aggregate)

Starting in version 3.6, MongoDB also provides the db.aggregate method:

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

The following stages use the db.aggregate() method and not the db.collection.aggregate() method.

StageDescription
$currentOpReturns information on active and/or dormant operations for the MongoDB deployment.
$listLocalSessionsLists all active sessions recently in use on the currently connected mongos or mongod instance. These sessions may have not yet propagated to the system.sessions collection.

Expressions

Expressions can include field paths and system variables, literals, expression objects, and expression operators. Expressions can be nested.

Field Path and System Variables

Aggregation expressions use field path to access fields in the input documents. To specify a field path, use a string that prefixes with a dollar sign $ the field name or the dotted field name, if the field is in the embedded document. For example, "$user" to specify the field path for the user field or "$user.name" to specify the field path to "user.name" field.

"$<field>" is equivalent to "$$CURRENT.<field>" where the CURRENT is a system variable that defaults to the root of the current object in the most stages, unless stated otherwise in specific stages. CURRENT can be rebound.

Along with the CURRENT system variable, other system variables are also available for use in expressions. To access variables in expressions, prefix the variable name with $$ .

Literals

Literals can be of any type. However, MongoDB parses string literals that start with a dollar sign $ as a path to a field and numeric/boolean literals in expression objects as projection flags. To avoid parsing literals, use the $literal expression.

Expression Objects

Expression objects have the following form:

{ <field1>: <expression1>, ... }

If the expressions are numeric or boolean literals, MongoDB treats the literals as projection flags (e.g. 1 or true to include the field), valid only in the $project stage. To avoid treating numeric or boolean literals as projection flags, use the $literal expression to wrap the numeric or boolean literals.

Operator Expressions

In this section

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.

Arithmetic Expression Operators

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

NameDescription
$absReturns the absolute value of a number.
$addAdds 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.
$ceilReturns the smallest integer greater than or equal to the specified number.
$divideReturns the result of dividing the first number by the second. Accepts two argument expressions.
$expRaises e to the specified exponent.
$floorReturns the largest integer less than or equal to the specified number.
$lnCalculates the natural log of a number.
$logCalculates the log of a number in the specified base.
$log10Calculates the log base 10 of a number.
$modReturns the remainder of the first number divided by the second. Accepts two argument expressions.
$multiplyMultiplies numbers to return the product. Accepts any number of argument expressions.
$powRaises a number to the specified exponent.
$sqrtCalculates the square root.
$subtractReturns 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.
$truncTruncates a number to its integer.

Array Expression Operators

$arrayElemAtReturns the element at the specified array index.
$arrayToObjectConverts an array of key value pairs to a document.
$concatArraysConcatenates arrays to return the concatenated array.
$filterSelects a subset of the array to return an array with only the elements that match the filter condition.
$inReturns a boolean indicating whether a specified value is in an array.
$indexOfArraySearches an array for an occurrence of a specified value and returns the array index of the first occurrence. If the substring is not found, returns -1 .
$isArrayDetermines if the operand is an array. Returns a boolean.
$mapApplies a subexpression to each element of an array and returns the array of resulting values in order. Accepts named parameters.
$objectToArrayConverts a document to an array of documents representing key-value pairs.
$rangeOutputs an array containing a sequence of integers according to user-defined inputs.
$reduceApplies an expression to each element in an array and combines them into a single value.
$reverseArrayReturns an array with the elements in reverse order.
$sizeReturns the number of elements in the array. Accepts a single expression as argument.
$sliceReturns a subset of an array.
$zipMerge two arrays together.

Boolean Expression 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.

NameDescription
$andReturns true only when all its expressions evaluate to true . Accepts any number of argument expressions.
$notReturns the boolean value that is the opposite of its argument expression. Accepts a single argument expression.
$orReturns true when any of its expressions evaluates to true . Accepts any number of argument expressions.

Comparison Expression 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.

$cmpReturns 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.
$eqReturns true if the values are equivalent.
$gtReturns true if the first value is greater than the second.
$gteReturns true if the first value is greater than or equal to the second.
$ltReturns true if the first value is less than the second.
$lteReturns true if the first value is less than or equal to the second.
$neReturns true if the values are not equivalent.

Conditional Expression Operators

NameDescription
$condA 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.
$ifNullReturns 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.
$switchEvaluates a series of case expressions. When it finds an expression which evaluates to true , $switch executes a specified expression and breaks out of the control flow.

Date Expression Operators

The following operators returns date objects or components of a date object:

NameDescription
$dateFromPartsConstructs a BSON Date object given the date’s constituent parts.
$dateFromStringConverts a date/time string to a date object.
$dateToPartsReturns a document containing the constituent parts of a date.
$dateToStringReturns the date as a formatted string.
$dayOfMonthReturns the day of the month for a date as a number between 1 and 31.
$dayOfWeekReturns the day of the week for a date as a number between 1 (Sunday) and 7 (Saturday).
$dayOfYearReturns the day of the year for a date as a number between 1 and 366 (leap year).
$hourReturns the hour for a date as a number between 0 and 23.
$isoDayOfWeekReturns the weekday number in ISO 8601 format, ranging from 1 (for Monday) to 7 (for Sunday).
$isoWeekReturns the week number in ISO 8601 format, ranging from 1 to 53 . Week numbers start at 1 with the week (Monday through Sunday) that contains the year’s first Thursday.
$isoWeekYearReturns the year number in ISO 8601 format. The year starts with the Monday of week 1 (ISO 8601) and ends with the Sunday of the last week (ISO 8601).
$millisecondReturns the milliseconds of a date as a number between 0 and 999.
$minuteReturns the minute for a date as a number between 0 and 59.
$monthReturns the month for a date as a number between 1 (January) and 12 (December).
$secondReturns the seconds for a date as a number between 0 and 60 (leap seconds).
$weekReturns 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).
$yearReturns the year for a date as a number (e.g. 2014).

The following arithmetic operators can take date operands:

NameDescription
$addAdds 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.
$subtractReturns the result of subtracting the second value from the first. 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.

Literal Expression Operator

NameDescription
$literalReturn 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.

Object Expression Operators

NameDescription
$mergeObjectsCombines multiple documents into a single document.
New in version 3.6.
$objectToArrayConverts a document to an array of documents representing key-value pairs.
New in version 3.6.

Set Expression 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.

NameDescription
$allElementsTrueReturns true if no element of a set evaluates to false , otherwise, returns false . Accepts a single argument expression.
$anyElementTrueReturns true if any elements of a set evaluate to true ; otherwise, returns false . Accepts a single argument expression.
$setDifferenceReturns 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.
$setEqualsReturns true if the input sets have the same distinct elements. Accepts two or more argument expressions.
$setIntersectionReturns a set with elements that appear in all of the input sets. Accepts any number of argument expressions.
$setIsSubsetReturns 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.
$setUnionReturns a set with elements that appear in any of the input sets.

String Expression 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.

NameDescription
$concatConcatenates any number of strings.
$dateFromStringConverts a date/time string to a date object.
$dateToStringReturns the date as a formatted string.
$indexOfBytesSearches a string for an occurrence of a substring and returns the UTF-8 byte index of the first occurrence. If the substring is not found, returns -1 .
$indexOfCPSearches a string for an occurrence of a substring and returns the UTF-8 code point index of the first occurrence. If the substring is not found, returns -1
$splitSplits a string into substrings based on a delimiter. Returns an array of substrings. If the delimiter is not found within the string, returns an array containing the original string.
$strLenBytesReturns the number of UTF-8 encoded bytes in a string.
$strLenCPReturns the number of UTF-8 code points in a string.
$strcasecmpPerforms 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.
$substrDeprecated. Use $substrBytes or $substrCP.
$substrBytesReturns the substring of a string. Starts with the character at the specified UTF-8 byte index (zero-based) in the string and continues for the specified number of bytes.
$substrCPReturns the substring of a string. Starts with the character at the specified UTF-8 code point (CP) index (zero-based) in the string and continues for the number of code points specified.
$toLowerConverts a string to lowercase. Accepts a single argument expression.
$toUpperConverts a string to uppercase. Accepts a single argument expression.

Text Expression Operator

NameDescription
$metaAccess text search metadata.

Type Expression Operators

NameDescription
$typeReturn the BSON data type of the field.

Accumulators ($group)

Available for use in the $group stage, accumulators are operators that maintain their state (e.g. totals, maximums, minimums, and related data) as documents progress through the pipeline.

When used as accumulators in the $group stage, these operators 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.

NameDescription
$addToSetReturns an array of unique expression values for each group. Order of the array elements is undefined.
$avgReturns an average of numerical values. Ignores non-numeric values.
$firstReturns a value from the first document for each group. Order is only defined if the documents are in a defined order.
$lastReturns a value from the last document for each group. Order is only defined if the documents are in a defined order.
$maxReturns the highest expression value for each group.
$mergeObjectsReturns a document created by combining the input documents for each group.
$minReturns the lowest expression value for each group.
$pushReturns an array of expression values for each group.
$stdDevPopReturns the population standard deviation of the input values.
$stdDevSampReturns the sample standard deviation of the input values.
$sumReturns a sum of numerical values. Ignores non-numeric values.

Accumulators ($project and $addFields)

Some operators that are available as accumulators for the $group stage are also available for use in the $project and $addFields stages but not as accumulators. When used in the $project and $addFields stages, these operators do not maintain their state and can take as input either a single argument or multiple arguments.

Changed in version 3.2.

The following accumulator operators are also available in the $project and $addFields stages.

NameDescription
$avgReturns an average of the specified expression or list of expressions for each document. Ignores non-numeric values.
$maxReturns the maximum of the specified expression or list of expressions for each document
$minReturns the minimum of the specified expression or list of expressions for each document
$stdDevPopReturns the population standard deviation of the input values.
$stdDevSampReturns the sample standard deviation of the input values.
$sumReturns a sum of numerical values. Ignores non-numeric values.

Variable Expression Operators

NameDescription
$letDefines variables for use within the scope of a subexpression and returns the result of the subexpression. Accepts named parameters.
Accepts any number of argument expressions.

Index of Expression Operators

$abs
$add
$addToSet
$allElementsTrue
$and
$anyElementTrue
$arrayElemAt
$arrayToObject
$avg
$cmp
$concat
$concatArrays
$cond
$dateFromParts
$dateToParts
$dateFromString
$dateToString
$dayOfMonth
$dayOfWeek
$dayOfYear
$divide
$eq
$exp
$filter
$first
$floor
$gt
$gte
$hour
$ifNull
$in
$indexOfArray
$indexOfBytes
$indexOfCP
$isArray
$isoDayOfWeek
$isoWeek
$isoWeekYear
$last
$let
$literal
$ln
$log
$log10
$lt
$lte
$map
$max
$mergeObjects
$meta
$min
$millisecond
$minute
$mod
$month
$multiply
$ne
$not
$objectToArray
$or
$pow
$push
$range
$reduce
$reverseArray
$second
$setDifference
$setEquals
$setIntersection
$setIsSubset
$setUnion
$size
$slice
$split
$sqrt
$stdDevPop
$stdDevSamp
$strcasecmp
$strLenBytes
$strLenCP
$substr
$substrBytes
$substrCP
$subtract
$sum
$switch
$toLower
$toUpper
$trunc
$type
$week
$year
$zip