# Supported MongoDB APIs, operations, and data types in Amazon DocumentDB
Amazon DocumentDB (with MongoDB compatibility) is a fast, scalable, highly-available, and fully managed document database service that supports MongoDB workloads. Amazon DocumentDB is compatible with the MongoDB 3.6, 4.0, 5.0, and 8.0 APIs. This section lists the supported functionality. For support using MongoDB APIs and drivers, please consult the MongoDB Community Forums. For support using the Amazon DocumentDB service, please contact the appropriate AWS support team. For functional differences between Amazon DocumentDB and MongoDB, please see [Functional differences: Amazon DocumentDB and MongoDB](functional-differences.md).
MongoDB commands and operators that are internal-only or not applicable to a fully-managed service are not supported and are not included in the list of supported functionality.
We have added over 50\$1 additional capabilities since launch, and will continue to work backwards from our customers to deliver the capabilities that they need. For information on the most recent launches, see [Amazon DocumentDB Announcements](https://aws.amazon.com/documentdb/resources/).
If there is a feature that isn't supported that you'd like us to build, let us know by sending an email with your accountID, the requested features, and use case to the [Amazon DocumentDB service team](mailto:documentdb-feature-request@amazon.com).
+ [Database commands](#mongo-apis-database)
+ [Query and projection operators](#mongo-apis-query)
+ [Update operators](#mongo-apis-update)
+ [Geospatial](#mongo-apis-geospatial)
+ [Cursor methods](#mongo-apis-cursor)
+ [Aggregation pipeline operators](#mongo-apis-aggregation-pipeline)
+ [Data types](#mongo-apis-data-types)
+ [Indexes](#mongo-apis-indexes)
## Database commands
**Topics**
+ [Administrative Commands](#mongo-apis-dababase-administrative)
+ [Aggregation](#mongo-apis-dababase-aggregation)
+ [Authentication](#mongo-apis-dababase-authentication)
+ [Diagnostic commands](#mongo-apis-dababase-diagnostics)
+ [Query and write operations](#mongo-apis-dababase-query-write)
+ [Role management commands](#mongo-apis-database-role-management)
+ [Sessions commands](#mongo-apis-dababase-sessions)
+ [User management](#mongo-apis-dababase-user-management)
+ [Sharding commands](#mongo-apis-dababase-sharding)
### Administrative Commands
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| Capped Collections | No | No | No | No | No |
| cloneCollectionAsCapped | No | No | No | No | No |
| collMod | Partial | Partial | Partial | Partial | Partial |
| collMod: expireAfterSeconds | Yes | Yes | Yes | Yes | Yes |
| convertToCapped | No | No | No | No | No |
| copydb | No | No | No | No | No |
| create | Yes | Yes | Yes | Yes | Yes |
| createView | No | No | No | Yes | No |
| createIndexes | Yes | Yes | Yes | Yes | Yes |
| currentOp | Yes | Yes | Yes | Yes | Yes |
| drop | Yes | Yes | Yes | Yes | Yes |
| dropDatabase | Yes | Yes | Yes | Yes | Yes |
| dropIndexes | Yes | Yes | Yes | Yes | Yes |
| filemd5 | No | No | No | No | No |
| getAuditConfig | No | Yes | Yes | Yes | No |
| killCursors | Yes | Yes | Yes | Yes | Yes |
| killOp | Yes | Yes | Yes | Yes | Yes |
| listCollections\$1 | Yes | Yes | Yes | Yes | Yes |
| listDatabases | Yes | Yes | Yes | Yes | Yes |
| listIndexes | Yes | Yes | Yes | Yes | Yes |
| reIndex | No | No | Yes | Yes | No |
| renameCollection | Yes | Yes | Yes | Yes | No |
| setAuditConfig | No | Yes | Yes | Yes | No |
\$1 The `type` key in the filter option is not supported.
### Aggregation
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| aggregate | Yes | Yes | Yes | Yes | Yes |
| count | Yes | Yes | Yes | Yes | Yes |
| distinct | Yes | Yes | Yes | Yes | Yes |
| mapReduce | No | No | No | Yes | No |
### Authentication
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| authenticate | Yes | Yes | Yes | Yes | Yes |
| logout | Yes | Yes | Yes | Yes | Yes |
### Diagnostic commands
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| buildInfo | Yes | Yes | Yes | Yes | Yes |
| collStats | Yes | Yes | Yes | Yes | Yes |
| connPoolStats | No | No | No | No | No |
| connectionStatus | Yes | Yes | Yes | Yes | Yes |
| dataSize | Yes | Yes | Yes | Yes | Yes |
| dbHash | No | No | No | No | No |
| dbStats | Yes | Yes | Yes | Yes | Yes |
| explain | Yes | Yes | Yes | Yes | Yes |
| explain: executionStats | Yes | Yes | Yes | Yes | Yes |
| features | No | No | No | No | No |
| hostInfo | Yes | Yes | Yes | Yes | Yes |
| listCommands | Yes | Yes | Yes | Yes | Yes |
| profiler | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | No |
| serverStatus | Yes | Yes | Yes | Yes | Yes |
| top | Yes | Yes | Yes | Yes | Yes |
### Query and write operations
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| Change streams | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Yes](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | No |
| delete | Yes | Yes | Yes | Yes | Yes |
| find | Yes | Yes | Yes | Yes | Yes |
| findAndModify | Yes | Yes | Yes | Yes | Yes |
| getLastError | No | No | No | No | No |
| getMore | Yes | Yes | Yes | Yes | Yes |
| getPrevError | No | No | No | No | No |
| GridFS | Yes | Yes | Yes | Yes | No |
| insert | Yes | Yes | Yes | Yes | Yes |
| parallelCollectionScan | No | No | No | No | No |
| resetError | No | No | No | No | No |
| update | Yes | Yes | Yes | Yes | Yes |
| ReplaceOne | Yes | Yes | Yes | Yes | Yes |
### Role management commands
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| createRole | Yes | Yes | Yes | Yes | No |
| dropAllRolesFromDatabase | Yes | Yes | Yes | Yes | No |
| dropRole | Yes | Yes | Yes | Yes | No |
| grantRolesToRole | Yes | Yes | Yes | Yes | No |
| revokeRolesFromRole | Yes | Yes | Yes | Yes | No |
| revokePrivilegesFromRole | Yes | Yes | Yes | Yes | No |
| rolesInfo | Yes | Yes | Yes | Yes | No |
| updateRole | Yes | Yes | Yes | Yes | No |
### Sessions commands
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| abortTransaction | No | Yes | Yes | Yes | No |
| commitTransaction | No | Yes | Yes | Yes | No |
| endSessions | No | No | No | No | No |
| killAllSessions | No | Yes | Yes | Yes | No |
| killAllSessionsByPattern | No | No | No | No | No |
| killSessions | No | Yes | Yes | Yes | No |
| refreshSessions | No | No | No | No | No |
| startSession | No | Yes | Yes | Yes | No |
### User management
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| createUser | Yes | Yes | Yes | Yes | Yes |
| dropAllUsersFromDatabase | Yes | Yes | Yes | Yes | Yes |
| dropUser | Yes | Yes | Yes | Yes | Yes |
| grantRolesToUser | Yes | Yes | Yes | Yes | Yes |
| revokeRolesFromUser | Yes | Yes | Yes | Yes | Yes |
| updateUser | Yes | Yes | Yes | Yes | Yes |
| usersInfo | Yes | Yes | Yes | Yes | Yes |
### Sharding commands
| Command | Elastic cluster |
| --- | --- |
| abortReshardCollection | No |
| addShard | No |
| addShardToZone | No |
| balancerCollectionStatus | No |
| balancerStart | No |
| balancerStatus | No |
| balancerStop | No |
| checkShardingIndex | No |
| clearJumboFlag | No |
| cleanupOrphaned | No |
| cleanupReshardCollection | No |
| commitReshardCollection | No |
| enableSharding | Yes |
| flushRouterConfig | No |
| getShardMap | No |
| getShardVersion | No |
| isdbgrid | No |
| listShards | No |
| medianKey | No |
| moveChunk | No |
| movePrimary | No |
| mergeChunks | No |
| refineCollectionShardKey | No |
| removeShard | No |
| removeShardFromZone | No |
| reshardCollection | No |
| setAllowMigrations | No |
| setShardVersion | No |
| shardCollection | Yes |
| shardingState | No |
| split | No |
| splitVector | No |
| unsetSharding | No |
| updateZoneKeyRange | No |
## Query and projection operators
**Topics**
+ [Array Operators](#mongo-apis-query-array-operators)
+ [Bitwise operators](#mongo-apis-query-bitwise-operators)
+ [Comment operator](#mongo-apis-query-comment-operator)
+ [Comparison operators](#mongo-apis-query-comparison-operators)
+ [Element operators](#mongo-apis-query-element-operators)
+ [Evaluation query operators](#mongo-apis-query-evaluation-operators)
+ [Logical operators](#mongo-apis-query-logical-operators)
+ [Projection operators](#mongo-apis-projection-operators)
### Array Operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1elemMatch](elemMatch.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1size](size-query.md) | Yes | Yes | Yes | Yes | Yes |
### Bitwise operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1bitsAnySet](bitsAnySet.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1bitsAllClear](bitsAllClear.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1bitsAnyClear](bitsAnyClear.md) | Yes | Yes | Yes | Yes | Yes |
### Comment operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | Yes | Yes | Yes | Yes | Yes |
### Comparison operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1gt](gt.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1gte](gte.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1in](in.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1lt](lt.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1lte](lte.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1ne](ne.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1nin](nin.md) | Yes | Yes | Yes | Yes | Yes |
### Element operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1type](type.md) | Yes | Yes | Yes | Yes | Yes |
### Evaluation query operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | No | Yes | Yes | Yes | No |
| [\$1jsonSchema](jsonSchema.md) | No | Yes | Yes | Yes | No |
| [\$1mod](mod-query.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1regex](regex.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1text](text.md) | No | No | Yes | Yes | No |
| \$1where | No | No | No | No | No |
### Logical operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1nor](nor.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1not](not.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1or](or.md) | Yes | Yes | Yes | Yes | Yes |
### Projection operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1elemMatch](elemMatch.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1meta](meta.md) | No | No | Yes | Yes | No |
| [\$1slice](slice-projection.md) | Yes | Yes | Yes | Yes | Yes |
## Update operators
**Topics**
+ [Array operators](#mongo-apis-update-array)
+ [Bitwise operators](#mongo-apis-update-bitwise)
+ [Field operators](#mongo-apis-update-field)
+ [Update modifiers](#mongo-apis-update-modifiers)
### Array operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1[]](dollarBrackets-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1[]](dollarIdentifier-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1addToSet](addToSet.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1pop](pop.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1pullAll](pullAll.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1pull](pull.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1push](push.md) | Yes | Yes | Yes | Yes | Yes |
### Bitwise operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | Yes | Yes | Yes | Yes | Yes |
### Field operators
| Operator | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1inc](inc.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1max](max-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1min](min-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1mul](mul.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1rename](rename.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1set](set-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1setOnInsert](setOnInsert.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1unset](unset-update.md) | Yes | Yes | Yes | Yes | Yes |
### Update modifiers
| Operator | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1position](position.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1slice](slice-update.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1sort](sort-update.md) | Yes | Yes | Yes | Yes | Yes |
## Geospatial
### Geometry specifiers
| Query Selectors | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| \$1box | No | No | No | No | No |
| \$1center | No | No | No | No | No |
| \$1centerSphere | No | No | No | No | No |
| [\$1geometry](geometry.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1maxDistance](maxDistance.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1minDistance](minDistance.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1nearSphere](nearSphere.md) | Yes | Yes | Yes | Yes | Yes |
| \$1polygon | No | No | No | No | No |
| \$1uniqueDocs | No | No | No | No | No |
### Query selectors
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1geoWithin](geoWithin.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1near](near.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1nearSphere](nearSphere.md) | Yes | Yes | Yes | Yes | Yes |
| \$1polygon | No | No | No | No | No |
| \$1uniqueDocs | No | No | No | No | No |
## Cursor methods
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | Yes | Yes | Yes | Yes | Yes |
| cursor.close() | Yes | Yes | Yes | Yes | Yes |
| cursor.collation() | No | No | No | Yes | No |
| cursor.comment() | Yes | Yes | Yes | Yes | Yes |
| cursor.count() | Yes | Yes | Yes | Yes | Yes |
| cursor.explain() | Yes | Yes | Yes | Yes | No |
| cursor.forEach() | Yes | Yes | Yes | Yes | Yes |
| cursor.hasNext() | Yes | Yes | Yes | Yes | Yes |
| cursor.hint() | Yes | Yes | Yes | Yes | Yes\$1 |
| cursor.isClosed() | Yes | Yes | Yes | Yes | Yes |
| cursor.isExhausted() | Yes | Yes | Yes | Yes | No |
| cursor.itcount() | Yes | Yes | Yes | Yes | No |
| cursor.limit() | Yes | Yes | Yes | Yes | No |
| cursor.map() | Yes | Yes | Yes | Yes | No |
| cursor.max() | No | No | No | No | No |
| cursor.maxScan() | Yes | Yes | Yes | Yes | No |
| cursor.maxTimeMS() | Yes | Yes | Yes | Yes | No |
| cursor.min() | No | No | No | No | No |
| cursor.next() | Yes | Yes | Yes | Yes | Yes |
| cursor.noCursorTimeout() | No | No | No | No | No |
| cursor.objsLeftInBatch() | Yes | Yes | Yes | Yes | No |
| cursor.pretty() | Yes | Yes | Yes | Yes | No |
| cursor.readConcern() | Yes | Yes | Yes | Yes | No |
| cursor.readPref() | Yes | Yes | Yes | Yes | No |
| cursor.returnKey() | No | No | No | No | No |
| cursor.showRecordId() | No | No | No | No | No |
| cursor.size() | Yes | Yes | Yes | Yes | No |
| cursor.skip() | Yes | Yes | Yes | Yes | No |
| cursor.sort() | Yes | Yes | Yes | Yes | No |
| cursor.tailable() | No | No | No | No | No |
| cursor.toArray() | Yes | Yes | Yes | Yes | No |
\$1 Index `hint` is supported with index expressions. For example, `db.foo.find().hint({x:1})`.
## Aggregation pipeline operators
**Topics**
+ [Accumulator expressions](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [Arithmetic operators](#mongo-apis-aggregation-pipeline-arithmetic)
+ [Array operators](#mongo-apis-aggregation-pipeline-array)
+ [Boolean operators](#mongo-apis-aggregation-pipeline-boolean)
+ [Comparison operators](#mongo-apis-aggregation-pipeline-comparison)
+ [Conditional expression operators](#mongo-apis-aggregation-pipeline-conditional)
+ [Data type operator](#mongo-apis-aggregation-pipeline-data-type)
+ [Data size operator](#mongo-apis-aggregation-pipeline-data-size)
+ [Date operators](#mongo-apis-aggregation-pipeline-date)
+ [Literal operator](#mongo-apis-aggregation-pipeline-literal)
+ [Merge operator](#mongo-apis-aggregation-pipeline-merge)
+ [Natural operator](#mongo-apis-aggregation-pipeline-natural)
+ [Set operators](#mongo-apis-aggregation-pipeline-set)
+ [Stage operators](#mongo-apis-aggregation-pipeline-stage)
+ [String operators](#mongo-apis-aggregation-pipeline-string)
+ [System variables](#mongo-apis-aggregation-pipeline-system-variables)
+ [Text search operator](#mongo-apis-aggregation-pipeline-text-search)
+ [Type conversion operators](#mongo-apis-aggregation-pipeline-type)
+ [Variable operators](#mongo-apis-aggregation-pipeline-variable)
+ [Miscellaneous operators](#mongo-apis-aggregation-pipeline-misc)
### Accumulator expressions
| Expression | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| \$1accumulator | - | - | No | No | No |
| [\$1addToSet](addToSet-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1avg](avg.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1count](count.md) | - | - | No | No | No |
| \$1covariancePop | No | No | No | No | No |
| \$1covarianceSamp | No | No | No | No | No |
| \$1denseRank | No | No | No | No | No |
| \$1derivative | No | No | No | No | No |
| \$1documentNumber | No | No | No | No | No |
| \$1expMovingAvg | No | No | No | No | No |
| [\$1first](first.md) | Yes | Yes | Yes | Yes | Yes |
| \$1integral | No | No | No | No | No |
| [\$1last](last.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1max](max.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1min](min.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1push](push-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| \$1rank | No | No | No | No | No |
| \$1shift | No | No | No | No | No |
| \$1stdDevPop | No | No | No | No | No |
| \$1stdDevSamp | No | No | No | No | No |
| [\$1sum](sum.md) | Yes | Yes | Yes | Yes | Yes |
### Arithmetic operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1add](add.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1ceil](ceil.md) | No | Yes | Yes | Yes | Yes |
| [\$1divide](divide.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1exp](exp.md) | No | Yes | Yes | Yes | Yes |
| [\$1floor](floor.md) | No | Yes | Yes | Yes | Yes |
| [\$1ln](ln.md) | No | Yes | Yes | Yes | Yes |
| [\$1log](log.md) | No | Yes | Yes | Yes | Yes |
| [\$1log10](log10.md) | No | Yes | Yes | Yes | Yes |
| [\$1mod](mod.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1multiply](multiply.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1pow](pow.md) | No | No | No | Yes | No |
| \$1round | - | - | No | No | No |
| [\$1sqrt](sqrt.md) | No | Yes | Yes | Yes | Yes |
| [\$1subtract](subtract.md) | Yes | Yes | Yes | Yes | Yes |
| \$1trunc | No | No | No | No | No |
### Array operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1arrayToObject](arrayToObject.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1concatArrays](concatArrays.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1filter](filter.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1first](first.md) | - | - | Yes | Yes | No |
| [\$1in](in-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1indexOfArray](indexOfArray.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1isArray](isArray.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1last](last.md) | - | - | Yes | Yes | No |
| [\$1objectToArray](objectToArray.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1range](range.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1reverseArray](reverseArray.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1reduce](reduce.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1size](size.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1slice](slice.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1zip](zip.md) | Yes | Yes | Yes | Yes | Yes |
### Boolean operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1not](not-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1or](or-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
### Comparison operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1eq](eq-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1gt](gt-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1gte](gte-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1lt](lt-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1lte](lte-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1ne](ne-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
### Conditional expression operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1ifNull](ifNull.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1switch](switch.md) | No | Yes | Yes | Yes | No |
### Data type operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | Yes | Yes | Yes | Yes | Yes |
### Data size operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | No | No | No |
| \$1bsonSize | - | - | No | No | No |
### Date operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1dateAdd](dateAdd.md) | No | No | Yes | Yes | Yes |
| [\$1dateDiff](dateDiff.md) | - | - | Yes | Yes | No |
| \$1dateFromParts | No | No | No | No | No |
| [\$1dateFromString](dateFromString.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1dateSubtract](dateSubtract.md) | No | No | Yes | Yes | Yes |
| \$1dateToParts | No | No | No | No | No |
| [\$1dateToString](dateToString.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1dateTrunc](dateTrunc.md) | - | - | No | Yes | No |
| [\$1dayOfMonth](dayOfMonth.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1dayOfWeek](dayOfWeek.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1dayOfYear](dayOfYear.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1hour](hour.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1isoDayOfWeek](isoDayOfWeek.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1isoWeek](isoWeek.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1isoWeekYear](isoWeekYear.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1millisecond](millisecond.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1minute](minute.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1month](month.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1second](second.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1week](week.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1year](year.md) | Yes | Yes | Yes | Yes | Yes |
### Literal operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | Yes | Yes | Yes | Yes | Yes |
### Merge operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | Yes | Yes | Yes | Yes | Yes |
### Natural operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1natural](natural.md) | Yes | Yes | Yes | Yes | Yes |
### Set operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | No | Yes | Yes | Yes | Yes |
| [\$1anyElementTrue](anyElementTrue.md) | No | Yes | Yes | Yes | Yes |
| [\$1setDifference](setDifference.md) | No | Yes | Yes | Yes | Yes |
| [\$1setEquals](setEquals.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1setIntersection](setIntersection.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1setIsSubset](setIsSubset.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1setUnion](setUnion.md) | Yes | Yes | Yes | Yes | Yes |
| \$1setWindowFields | No | No | No | No | No |
### Stage operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1bucket](bucket.md) | No | No | No | Yes | No |
| \$1bucketAuto | No | No | No | No |
| [\$1changeStream](changeStream.md) | Yes | Yes | Yes | Yes | No |
| [\$1collStats](collStats.md) | No | Yes | Yes | Yes | No |
| [\$1count](count.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1currentOp](currentOp.md) | Yes | Yes | Yes | Yes | Yes |
| \$1facet | No | No | No | No | No |
| [\$1geoNear](geoNear.md) | Yes | Yes | Yes | Yes | Yes |
| \$1graphLookup | No | No | No | No | No |
| [\$1group](group.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1indexStats](indexStats.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1limit](limit.md) | Yes | Yes | Yes | Yes | Yes |
| \$1listLocalSessions | No | No | No | No | No |
| \$1listSessions | No | No | No | No | No |
| [\$1lookup](lookup.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1match](match.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1merge](merge.md) | - | - | No | Yes | No |
| [\$1out](out.md) | Yes | Yes | Yes | Yes | No |
| \$1planCacheStats | - | - | No | No | No |
| [\$1project](project.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1redact](redact.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1replaceRoot](replaceRoot.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1sample](sample.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1set](set-stage.md) | - | - | No | Yes | No |
| \$1setWindowFields | - | - | No | No | No |
| [\$1skip](skip.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1sort](sort.md) | Yes | Yes | Yes | Yes | Yes |
| \$1sortByCount | No | No | No | No | No |
| \$1unionWith | - | - | No | No | No |
| [\$1unset](unset-stage.md) | - | - | No | Yes | No |
| [\$1unwind](unwind.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1replaceWith](replaceWith.md) | No | No | No | Yes | No |
| [\$1vectorSearch](vectorSearch.md) | No | No | No | Yes | No |
### String operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1indexOfBytes](indexOfBytes.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1indexOfCP](indexOfCP.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1ltrim](ltrim.md) | No | Yes | Yes | Yes | No |
| [\$1regexFind](regexFind.md) | - | - | Yes | Yes | No |
| [\$1regexFindAll](regexFindAll.md) | - | - | Yes | Yes | No |
| [\$1regexMatch](regexMatch.md) | - | - | Yes | Yes | No |
| [\$1replaceAll](replaceAll.md) | - | - | Yes | Yes | No |
| [\$1replaceOne](replaceOne.md) | - | - | Yes | Yes | No |
| [\$1rtrim](rtrim.md) | No | Yes | Yes | Yes | No |
| [\$1split](split.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1strcasecmp](strcasecmp.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1strLenBytes](strLenBytes.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1strLenCP](strLenCP.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1substr](substr.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1substrBytes](substrBytes.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1substrCP](substrCP.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1toLower](toLower.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1toUpper](toUpper.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1trim](trim.md) | No | Yes | Yes | Yes | No |
### System variables
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | No | No | No | No | No |
| [\$1\$1DESCEND](DESCEND.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1\$1KEEP](KEEP.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1\$1PRUNE](PRUNE.md) | Yes | Yes | Yes | Yes | Yes |
| \$1\$1REMOVE | No | No | No | No | No |
| [\$1ROOT](ROOT.md) | Yes | Yes | Yes | Yes | Yes |
### Text search operator
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | No | No | Yes | Yes | No |
| [\$1search](search.md) | No | No | Yes | Yes | No |
### Type conversion operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1convert](convert.md) | No | Yes | Yes | Yes | Yes |
| \$1isNumber | - | - | No | No | No |
| [\$1toBool](toBool.md) | No | Yes | Yes | Yes | Yes |
| [\$1toDate](toDate.md) | No | Yes | Yes | Yes | Yes |
| [\$1toDecimal](toDecimal.md) | No | Yes | Yes | Yes | Yes |
| [\$1toDouble](toDouble.md) | No | Yes | Yes | Yes | Yes |
| [\$1toInt](toInt.md) | No | Yes | Yes | Yes | Yes |
| [\$1toLong](toLong.md) | No | Yes | Yes | Yes | Yes |
| [\$1toObjectId](toObjectId.md) | No | Yes | Yes | Yes | Yes |
| [\$1toString](toString.md) | No | Yes | Yes | Yes | Yes |
### Variable operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | Yes | Yes | Yes | Yes | Yes |
| [\$1map](map.md) | Yes | Yes | Yes | Yes | Yes |
### Miscellaneous operators
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | No | No | No |
| [\$1rand](rand.md) | - | - | No | Yes | No |
| \$1sampleRate | - | - | No | No | No |
## Data types
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| 32-bit Integer (int) | Yes | Yes | Yes | Yes | Yes |
| 64-bit Integer (long) | Yes | Yes | Yes | Yes | Yes |
| Array | Yes | Yes | Yes | Yes | Yes |
| Binary Data | Yes | Yes | Yes | Yes | Yes |
| Boolean | Yes | Yes | Yes | Yes | Yes |
| Date | Yes | Yes | Yes | Yes | Yes |
| DBPointer | No | No | No | No | No |
| DBRefs | No | No | No | No | No |
| Decimal128 | Yes | Yes | Yes | Yes | Yes |
| Double | Yes | Yes | Yes | Yes | Yes |
| JavaScript | No | No | No | No | No |
| JavaScript (with scope) | No | No | No | No | No |
| MaxKey | Yes | Yes | Yes | Yes | Yes |
| MinKey | Yes | Yes | Yes | Yes | Yes |
| Null | Yes | Yes | Yes | Yes | Yes |
| Object | Yes | Yes | Yes | Yes | Yes |
| ObjectId | Yes | Yes | Yes | Yes | Yes |
| Regular Expression | Yes | Yes | Yes | Yes | Yes |
| String | Yes | Yes | Yes | Yes | Yes |
| Symbol | No | No | No | No | No |
| Timestamp | Yes | Yes | Yes | Yes | Yes |
| Undefined | No | No | No | No | No |
## Indexes and index properties
**Topics**
+ [Indexes](#mongo-apis-indexes)
+ [Index properties](#mongo-apis-index-properties)
### Indexes
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | Yes | Yes | Yes | Yes | Yes |
| 2d Index | No | No | No | No | No |
| Compound Index | Yes | Yes | Yes | Yes | Yes |
| Hashed Index | No | No | No | No | No |
| Multikey Index | Yes | Yes | Yes | Yes | Yes |
| Single Field Index | Yes | Yes | Yes | Yes | Yes |
| Text Index | No | No | Yes | Yes | No |
| Wildcard | No | No | No | No | No |
### Index properties
| Command | 3.6 | 4.0 | 5.0 | 8.0 | Elastic cluster |
| --- | --- | --- | --- | --- | --- |
| Background | Yes | Yes | Yes | Yes | Yes |
| Case Insensitive | No | No | No | Yes | No |
| Hidden | No | No | No | No | No |
| Partial | No | No | Yes | Yes | No |
| Sparse | Yes | Yes | Yes | Yes | Yes |
| Text | No | No | Yes | Yes | No |
| TTL | Yes | Yes | Yes | Yes | Yes |
| Unique | Yes | Yes | Yes | Yes | Yes |
| Vector | No | No | Yes | Yes | No |
For detailed information about specific MongoDB operators, see the following topics:
+ [Aggregation pipeline operators](mongo-apis-aggregation-pipeline-operators.md)
+ [Geospatial](mongo-apis-geospatial-operators.md)
+ [Projection operators](#mongo-apis-projection-operators)
+ [Update operators](mongo-apis-update-operators.md)
# Aggregation pipeline operators
This section provides detailed information about aggregation pipeline operators supported by Amazon DocumentDB.
**Topics**
+ [\$1\$1DESCEND](DESCEND.md)
+ [\$1\$1KEEP](KEEP.md)
+ [\$1\$1PRUNE](PRUNE.md)
+ [\$1ROOT](ROOT.md)
+ [\$1abs](abs.md)
+ [\$1add](add.md)
+ [\$1addToSet](addToSet-aggregation.md)
+ [\$1addFields](addFields.md)
+ [\$1allElementsTrue](allElementsTrue.md)
+ [\$1and](and-aggregation.md)
+ [\$1anyElementTrue](anyElementTrue.md)
+ [\$1arrayElemAt](arrayElemAt.md)
+ [\$1arrayToObject](arrayToObject.md)
+ [\$1avg](avg.md)
+ [\$1bucket](bucket.md)
+ [\$1ceil](ceil.md)
+ [\$1changeStream](changeStream.md)
+ [\$1cmp](cmp.md)
+ [\$1collStats](collStats.md)
+ [\$1concat](concat.md)
+ [\$1concatArrays](concatArrays.md)
+ [\$1cond](cond.md)
+ [\$1convert](convert.md)
+ [\$1count](count.md)
+ [\$1currentOp](currentOp.md)
+ [\$1dateAdd](dateAdd.md)
+ [\$1dateDiff](dateDiff.md)
+ [\$1dateFromString](dateFromString.md)
+ [\$1dateSubtract](dateSubtract.md)
+ [\$1dateToString](dateToString.md)
+ [\$1dateTrunc](dateTrunc.md)
+ [\$1dayOfMonth](dayOfMonth.md)
+ [\$1dayOfWeek](dayOfWeek.md)
+ [\$1dayOfYear](dayOfYear.md)
+ [\$1divide](divide.md)
+ [\$1eq](eq-aggregation.md)
+ [\$1exp](exp.md)
+ [\$1filter](filter.md)
+ [\$1first](first.md)
+ [\$1floor](floor.md)
+ [\$1geoNear](geoNear.md)
+ [\$1group](group.md)
+ [\$1gt](gt-aggregation.md)
+ [\$1gte](gte-aggregation.md)
+ [\$1hour](hour.md)
+ [\$1ifNull](ifNull.md)
+ [\$1in](in-aggregation.md)
+ [\$1indexOfArray](indexOfArray.md)
+ [\$1indexOfBytes](indexOfBytes.md)
+ [\$1indexOfCP](indexOfCP.md)
+ [\$1indexStats](indexStats.md)
+ [\$1isArray](isArray.md)
+ [\$1isoDayOfWeek](isoDayOfWeek.md)
+ [\$1isoWeek](isoWeek.md)
+ [\$1isoWeekYear](isoWeekYear.md)
+ [\$1last](last.md)
+ [\$1let](let.md)
+ [\$1limit](limit.md)
+ [\$1literal](literal.md)
+ [\$1ln](ln.md)
+ [\$1log](log.md)
+ [\$1log10](log10.md)
+ [\$1lt](lt-aggregation.md)
+ [\$1lte](lte-aggregation.md)
+ [\$1lookup](lookup.md)
+ [\$1ltrim](ltrim.md)
+ [\$1map](map.md)
+ [\$1match](match.md)
+ [\$1max](max.md)
+ [\$1meta](meta-aggregation.md)
+ [\$1merge](merge.md)
+ [\$1mergeObjects](mergeObjects.md)
+ [\$1millisecond](millisecond.md)
+ [\$1min](min.md)
+ [\$1minute](minute.md)
+ [\$1mod](mod.md)
+ [\$1month](month.md)
+ [\$1multiply](multiply.md)
+ [\$1natural](natural.md)
+ [\$1ne](ne-aggregation.md)
+ [\$1not](not-aggregation.md)
+ [\$1objectToArray](objectToArray.md)
+ [\$1or](or-aggregation.md)
+ [\$1out](out.md)
+ [\$1pow](pow.md)
+ [\$1push](push-aggregation.md)
+ [\$1project](project.md)
+ [\$1rand](rand.md)
+ [\$1range](range.md)
+ [\$1redact](redact.md)
+ [\$1reduce](reduce.md)
+ [\$1regexFind](regexFind.md)
+ [\$1regexFindAll](regexFindAll.md)
+ [\$1regexMatch](regexMatch.md)
+ [\$1replaceAll](replaceAll.md)
+ [\$1replaceOne](replaceOne.md)
+ [\$1replaceRoot](replaceRoot.md)
+ [\$1replaceWith](replaceWith.md)
+ [\$1reverseArray](reverseArray.md)
+ [\$1rtrim](rtrim.md)
+ [\$1sample](sample.md)
+ [\$1search](search.md)
+ [\$1second](second.md)
+ [\$1set](set-stage.md)
+ [\$1setDifference](setDifference.md)
+ [\$1setEquals](setEquals.md)
+ [\$1setIntersection](setIntersection.md)
+ [\$1setIsSubset](setIsSubset.md)
+ [\$1setUnion](setUnion.md)
+ [\$1skip](skip.md)
+ [\$1slice](slice.md)
+ [\$1size](size.md)
+ [\$1sort](sort.md)
+ [\$1split](split.md)
+ [\$1sqrt](sqrt.md)
+ [\$1strLenBytes](strLenBytes.md)
+ [\$1strLenCP](strLenCP.md)
+ [\$1strcasecmp](strcasecmp.md)
+ [\$1substr](substr.md)
+ [\$1substrBytes](substrBytes.md)
+ [\$1substrCP](substrCP.md)
+ [\$1subtract](subtract.md)
+ [\$1sum](sum.md)
+ [\$1switch](switch.md)
+ [\$1toBool](toBool.md)
+ [\$1toDate](toDate.md)
+ [\$1toDecimal](toDecimal.md)
+ [\$1toDouble](toDouble.md)
+ [\$1toInt](toInt.md)
+ [\$1toLong](toLong.md)
+ [\$1toLower](toLower.md)
+ [\$1toObjectId](toObjectId.md)
+ [\$1toString](toString.md)
+ [\$1toUpper](toUpper.md)
+ [\$1trim](trim.md)
+ [\$1type](type-aggregation.md)
+ [\$1unset](unset-stage.md)
+ [\$1unwind](unwind.md)
+ [\$1vectorSearch](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
The `$$DESCEND` operator in Amazon DocumentDB is a special positional array operator used within the `$redact` pipeline stage. It instructs the aggregation pipeline to descend into the current document and process all fields, regardless of their nesting level.
When the `$redact` stage encounters the `$$DESCEND` operator, it will keep all the fields in the current document visible and process them further down the pipeline. This is useful when you want to selectively redact or prune certain fields based on a condition, while retaining the structure of the document.
**Parameters**
None.
## Example (MongoDB Shell)
In this example, we'll use the `$redact` stage with the `$$DESCEND` operator to selectively display documents where the `code` field is equal to "Reg".
**Create sample documents**
```
db.patient.insertMany([
{ "_id": 1, "code": "Emp", "patient": "John Doe", "DOB": "1/1/1980", "Hospital": "Main" },
{ "_id": 2, "code": "Reg", "patient": "Jane Doe", "DOB": "3/27/1989", "Hospital": "Cherry Hill" },
{ "_id": 3, "code": "Emp", "patient": "Bob Smith", "DOB": "6/15/1975", "Hospital": "Downtown" }
]);
```
**Query example**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**Output**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## Code examples
To view a code example for using the `$$DESCEND` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function redactPatients() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('patient');
const result = await collection.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]).toArray();
console.log(result);
client.close();
}
redactPatients();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def redact_patients():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.patient
result = list(collection.aggregate([
{ "$redact": {
"$cond": {
"if": { "$eq": ["Reg", "$code"] },
"then": "$$DESCEND",
"else": "$$PRUNE"
}
}}
]))
print(result)
client.close()
redact_patients()
```
------
# \$1\$1KEEP
The `$$KEEP` system variable is used with the `$redact` stage in the aggregation pipeline to keep the current document or field unchanged and include it in the output.
**Parameters**
None
## Example (MongoDB Shell)
The following example demonstrates the usage of `$$KEEP` in an Amazon DocumentDB aggregation pipeline. Documents are only kept if access equals "public", otherwise they are removed.
**Create sample documents**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**Query example**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**Output**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## Code examples
To view a code example for using the `$$KEEP` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function run() {
const client = new MongoClient(
'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0'
);
try {
await client.connect();
const db = client.db('test');
const articles = db.collection('articles');
const pipeline = [
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
];
const results = await articles.aggregate(pipeline).toArray();
console.log(results);
} finally {
await client.close();
}
}
run().catch(console.error);
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient(
"mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0"
)
db = client.test
articles = db.articles
pipeline = [
{
"$redact": {
"$cond": [
{"$eq": ["$access", "public"]},
"$$KEEP",
"$$PRUNE"
]
}
}
]
results = list(articles.aggregate(pipeline))
print(results)
client.close()
```
------
# \$1\$1PRUNE
The `$$PRUNE` system variable is used with the `$redact` stage in the aggregation pipeline to exclude documents or embedded document levels from the results. When a condition evaluates to `$$PRUNE`, the current document or subdocument is removed from the output. It is typically used with `$$DESCEND` (to keep and traverse the document) or `$$KEEP` (to keep the document at all levels).
**Parameters**
None. The `$$PRUNE` system variable is used without any parameters and must be used with `$redact`.
## Example (MongoDB Shell)
The following example demonstrates how to use `$$PRUNE` with `$redact` to exclude users over 30 years old from the results.
**Create sample documents**
```
db.users.insert([
{ _id:1, name: "Carlos Salazar", age: 35, address: { street: "123 Main St", city: "Anytown", state: "CA" } },
{ _id:2, name: "Saanvi Sarkar", age: 28, address: { street: "456 Oak Rd", city: "Someplace", state: "NY" } },
{ _id:3, name: "Li Juan", age: 42, address: { street: "789 Pine Ave", city: "Springfield", state: "TX" } }
])
```
**Query example**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**Output**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## Code examples
To view a code example for using the `$$PRUNE` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
async function main() {
await client.connect();
const db = client.db('test');
const users = db.collection('users');
const result = await users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
users = db['users']
result = list(users.aggregate([
{
'$redact': {
'$cond': {
'if': { '$gt': ['$age', 30] },
'then': '$$PRUNE',
'else': '$$DESCEND'
}
}
}
]))
print(result)
client.close()
```
------
# \$1ROOT
The `$ROOT` operator in Amazon DocumentDB is used to reference the entire input document within an aggregation pipeline. It allows you to access and manipulate the complete document, including all its nested fields and structures.
**Parameters**
None
## Example (MongoDB Shell)
This example demonstrates using `$ROOT` to create an audit log that captures the complete original document along with metadata about when it was processed.
**Create sample documents**
```
db.orders.insertMany([
{
_id: 1,
orderId: "ORD-2024-001",
customer: "María García",
email: "maría@example.com",
items: [
{ product: "Laptop", quantity: 1, price: 1299.99 }
],
totalAmount: 1299.99
},
{
_id: 2,
orderId: "ORD-2024-002",
customer: "Arnav Desai",
email: "arnav@example.com",
items: [
{ product: "Mouse", quantity: 2, price: 29.99 },
{ product: "Keyboard", quantity: 1, price: 89.99 }
],
totalAmount: 149.97
}
]);
```
**Query example**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**Output**
```
[
{
_id: 1,
processedAt: ISODate('2025-11-24T20:43:51.492Z'),
originalDocument: {
_id: 1,
orderId: 'ORD-2024-001',
customer: 'María García',
email: 'maría@example.com',
items: [ { product: 'Laptop', quantity: 1, price: 1299.99 } ],
totalAmount: 1299.99
},
summary: 'Order ORD-2024-001 for María García - Total: $1299.99'
},
{
_id: 2,
processedAt: ISODate('2025-11-24T20:43:51.492Z'),
originalDocument: {
_id: 2,
orderId: 'ORD-2024-002',
customer: 'Arnav Desai',
email: 'arnav@example.com',
items: [
{ product: 'Mouse', quantity: 2, price: 29.99 },
{ product: 'Keyboard', quantity: 1, price: 89.99 }
],
totalAmount: 149.97
},
summary: 'Order ORD-2024-002 for Arnav Desai - Total: $149.97'
}
]
```
## Code examples
To view a code example for using the `$ROOT` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function createAuditLog() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const orders = db.collection('orders');
const result = await orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]).toArray();
console.log(result);
await client.close();
}
createAuditLog();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from datetime import datetime
def create_audit_log():
client = MongoClient('mongodb://username:password@docdb-cluster.cluster-123456789.us-east-1.docdb.amazonaws.com:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['orders']
result = list(collection.aggregate([
{
'$project': {
'processedAt': datetime.now(),
'originalDocument': '$$ROOT',
'summary': {
'$concat': [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ '$toString': "$totalAmount" }
]
}
}
}
]))
print(result)
client.close()
create_audit_log()
```
------
# \$1abs
The `$abs` operator in Amazon DocumentDB returns the absolute value of a number. It can be used in the aggregation pipeline to perform mathematical operations on numeric fields.
**Parameters**
+ `number`: The numeric expression for which the absolute value will be returned.
## Example (MongoDB Shell)
This example demonstrates the usage of the `$abs` operator to find the absolute value of a numeric field.
**Create sample documents**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**Query example**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**Output**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## Code examples
To view a code example for using the `$abs` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function main() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def main():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['numbers']
result = list(collection.aggregate([
{ '$project': {
"_id": 1,
"absolute_value": { "$abs": "$value" }
}}
]))
print(result)
client.close()
if __name__ == "__main__":
main()
```
------
# \$1add
The `$add` operator in Amazon DocumentDB is used to add numbers or dates together. It can be used to perform arithmetic operations on numeric fields or to perform date arithmetic by adding a number of time units to a date field.
**Parameters**
+ `expression1`: The first number or date to add.
+ `expression2`: The second number or date to add.
+ `expression3`: (optional) Additional numbers or dates to add.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$add` operator to add two numbers together.
**Create sample documents**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**Query example**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**Output**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
In this example, the `$add` operator is used to add the values of the `a` and `b` fields for each document and store the result in the `sum` field.
## Code examples
To view a code example for using the `$add` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: {
_id: 1,
sum: { $add: ['$a', '$b'] }
}}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['numbers']
result = list(collection.aggregate([
{ '$project': {
'_id': 1,
'sum': { '$add': ['$a', '$b'] }
}}
]))
print(result)
client.close()
```
------
# \$1addToSet
The `$addToSet` aggregation operator returns an array of unique values from a specified expression for each group. It is used within the `$group` stage to accumulate distinct values, automatically eliminating duplicates.
**Parameters**
+ `expression`: The expression to evaluate for each document in the group.
## Example (MongoDB Shell)
The following example demonstrates using the `$addToSet` operator to collect unique cities where orders were placed for each customer.
**Create sample documents**
```
db.orders.insertMany([
{ _id: 1, customer: "Alice", city: "Seattle", amount: 100 },
{ _id: 2, customer: "Alice", city: "Portland", amount: 150 },
{ _id: 3, customer: "Bob", city: "Seattle", amount: 200 },
{ _id: 4, customer: "Alice", city: "Seattle", amount: 75 },
{ _id: 5, customer: "Bob", city: "Boston", amount: 300 }
]);
```
**Query example**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**Output**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## Code examples
To view a code example for using the `$addToSet` aggregation operator, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('orders');
const result = await collection.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['orders']
result = list(collection.aggregate([
{
'$group': {
'_id': '$customer',
'cities': { '$addToSet': '$city' }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1addFields
The `$addFields` stage in the Amazon DocumentDB aggregation pipeline allows you to add new computed fields to documents. This can be useful for adding derived or transformed data to the documents.
**Parameters**
+ `newField`: The name of the new field to add.
+ `expression`: An expression that resolves to the value of the new field.
## Example (MongoDB Shell)
The following example demonstrates how to use `$addFields` to add a new field `TotalInventory` that calculates the total inventory based on the `Inventory.OnHand` and `Inventory.OrderQnty` fields.
**Create sample documents**
```
db.example.insertMany([
{
"Item": "Spray Paint",
"Colors": ["Black", "Red", "Green", "Blue"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50,
"OrderQnty": 36
},
"UnitPrice": 3.99
},
{
"Item": "Ruler",
"Colors": ["Red", "Green", "Blue", "Clear", "Yellow"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 40
},
"UnitPrice": 0.89
}
]);
```
**Query example**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**Output**
```
[
{
"_id" : ObjectId("5bedafbcf65ff161707de24f"),
"Item" : "Ruler",
"Colors" : [ "Red", "Green", "Blue", "Clear", "Yellow" ],
"Inventory" : {
"OnHand" : 47,
"MinOnHand" : 40
},
"UnitPrice" : 0.89,
"TotalInventory" : 47
},
{
"_id" : ObjectId("5bedafbcf65ff161707de250"),
"Item" : "Spray Paint",
"Colors" : [ "Black", "Red", "Green", "Blue" ],
"Inventory" : {
"OnHand" : 47,
"MinOnHand" : 50,
"OrderQnty" : 36
},
"UnitPrice" : 3.99,
"TotalInventory" : 83
}
]
```
## Code examples
To view a code example for using the `$addFields` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('example');
const result = await collection.aggregate([
{
$addFields: {
TotalInventory: { $add: ['$Inventory.OnHand', '$Inventory.OrderQnty'] }
}
}
]).toArray();
console.log(result);
await client.close();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['example']
result = list(collection.aggregate([
{
'$addFields': {
'TotalInventory': { '$add': ['$Inventory.OnHand', '$Inventory.OrderQnty'] }
}
}
]))
print(result)
client.close()
```
------
# \$1allElementsTrue
New from version 4.0
The `$allElementsTrue` operator is used to check if all elements in an array evaluate to a true value.
**Parameters**
+ `expression`: An expression that evaluates to an array.
## Example (MongoDB Shell)
The following example demonstrates the usage of `$allElementsTrue` to check if all elements in an array are true.
**Create sample documents**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**Query example**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**Output**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
In this example, the query checks if all elements in the `scores` array are greater than 0. The document with `"name": "Jane"` is excluded because the `scores` array contains a 0, which is a falsy value.
## Code examples
To view a code example for using the `$allElementsTrue` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('collection');
const result = await collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
}).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['collection']
result = list(collection.find({
"scores": {"$allElementsTrue": [{"$gt": 0}]}
}))
print(result)
client.close()
example()
```
------
# \$1and
The `$and` aggregation operator evaluates multiple expressions and returns `true` only if all expressions evaluate to `true`. If any expression is `false`, it returns `false`.
**Parameters**
+ `expressions`: An array of expressions to evaluate.
## Example (MongoDB Shell)
The following example demonstrates using the `$and` operator to check if products meet multiple criteria.
**Create sample documents**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200, inStock: true },
{ _id: 2, name: "Mouse", price: 25, inStock: false },
{ _id: 3, name: "Keyboard", price: 75, inStock: true }
]);
```
**Query example**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**Output**
```
[
{ _id: 1, name: 'Laptop', price: 1200, inStock: true, affordable: false },
{ _id: 2, name: 'Mouse', price: 25, inStock: false, affordable: false },
{ _id: 3, name: 'Keyboard', price: 75, inStock: true, affordable: true }
]
```
## Code examples
To view a code example for using the `$and` aggregation operator, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('products');
const result = await collection.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['products']
result = list(collection.aggregate([
{
'$project': {
'name': 1,
'price': 1,
'inStock': 1,
'affordable': {
'$and': [
{ '$lt': ['$price', 100] },
{ '$eq': ['$inStock', True] }
]
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1anyElementTrue
New from version 4.0
The `$anyElementTrue` operator is used to determine if any element in an array is true.
**Parameters**
+ `field`: An array field to evaluate.
## Example (MongoDB Shell)
The following example demonstrates the usage of `$anyElementTrue` to check if any element in an array is true.
**Create sample documents**
```
db.grades.insertMany([
{ _id: 1, student: 'Tim', scores: [false, false, null] },
{ _id: 2, student: 'Bob', scores: [false, 0, false] },
{ _id: 3, student: 'Ivy', scores: [false, true, 0] }
])
```
**Query example**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**Output**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## Code examples
To view a code example for using the `$anyElementTrue` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('grades');
const result = await collection.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['grades']
result = list(collection.aggregate([
{
"$project": {
"student": 1,
"isAnyTrue": { "$anyElementTrue": ["$scores"] },
"_id": 0
}
}
]))
print(result)
client.close()
example()
```
------
# \$1arrayElemAt
The `$arrayElemAt` operator in Amazon DocumentDB allows you to retrieve an element from an array by its index position. This is particularly useful when you need to access a specific element within an array field in your documents.
**Parameters**
+ `array`: The input array from which an element is to be retrieved.
+ `index`: The zero-based index position of the element to retrieve. This value must be a non-negative integer.
## Example (MongoDB Shell)
In this example, we'll demonstrate how to use the `$arrayElemAt` operator to retrieve specific elements from the `flight_miles` array in the `miles` collection.
**Create sample documents**
```
db.miles.insertMany([
{ "_id" : 1, "member_since" : ISODate("1987-01-01T00:00:00Z"), "credit_card" : false, "flight_miles" : [ 1205, 2560, 880 ]},
{ "_id" : 2, "member_since" : ISODate("1982-01-01T00:00:00Z"), "credit_card" : true, "flight_miles" : [ 1205, 2560, 890, 2780 ]},
{ "_id" : 3, "member_since" : ISODate("1999-01-01T00:00:00Z"), "credit_card" : true, "flight_miles" : [ 1205, 880 ]}
]);
```
**Query example**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**Output**
```
{ "_id" : 1, "first_mile" : 1205, "last_mile" : 880 }
{ "_id" : 2, "first_mile" : 1205, "last_mile" : 2780 }
{ "_id" : 3, "first_mile" : 1205, "last_mile" : 880 }
```
In this example, we use the `$arrayElemAt` operator to retrieve the first and last elements of the `flight_miles` array for each document.
## Code examples
To view a code example for using the `$arrayElemAt` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('miles');
const result = await collection.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.mydatabase
collection = db.miles
result = list(collection.aggregate([
{ "$project": {
"_id": 1,
"first_mile": { "$arrayElemAt": [ "$flight_miles", 0 ] },
"last_mile": { "$arrayElemAt": [ "$flight_miles", -1 ] }
}}
]))
print(result)
client.close()
example()
```
------
# \$1arrayToObject
The `$arrayToObject` operator in Amazon DocumentDB is the reverse of the `$objectToArray` operator. It takes an array of key-value pair documents and converts it into a single document. This is particularly useful when you need to convert an array of key-value pairs back into an object or document structure.
**Parameters**
+ `array expression`: An expression that resolves to an array. The array elements must be documents with two fields: `k` (the key) and `v` (the value).
## Example (MongoDB Shell)
The example below demonstrates how to use `$arrayToObject` to convert an array of key-value pairs back into a document.
**Create sample documents**
```
db.videos.insertMany([
{ "_id": 1, "name": "Live Soft", "inventory": { "Des Moines": 1000, "Ames": 500 } },
{ "_id": 2, "name": "Top Pilot", "inventory": { "Mason City": 250, "Des Moines": 1000 } },
{ "_id": 3, "name": "Romancing the Rock", "inventory": { "Mason City": 250, "Ames": 500 } },
{ "_id": 4, "name": "Bravemind", "inventory": { "Mason City": 250, "Des Moines": 1000, "Ames": 500 } }
]);
```
**Query example**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**Output**
```
{ "_id" : 1, "name" : "Live Soft", "inventory" : { "Des Moines" : 1000, "Ames" : 500 } }
{ "_id" : 2, "name" : "Top Pilot", "inventory" : { "Mason City" : 250, "Des Moines" : 1000 } }
{ "_id" : 3, "name" : "Romancing the Rock", "inventory" : { "Mason City" : 250, "Ames" : 500 } }
{ "_id" : 4, "name" : "Bravemind", "inventory" : { "Mason City" : 250, "Des Moines" : 1000, "Ames" : 500 } }
```
In this example, the `$objectToArray` operator is used to convert the `inventory` object into an array of key-value pairs. The `$arrayToObject` operator is then used to convert the array back into a document, restoring the original object structure.
## Code examples
To view a code example for using the `$arrayToObject` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('videos');
const result = await collection.aggregate([
{ $project: { name: 1, videos: { $objectToArray: '$inventory' } } },
{ $project: { name: 1, inventory: { $arrayToObject: '$videos' } } }
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['videos']
result = list(collection.aggregate([
{ '$project': { 'name': 1, 'videos': { '$objectToArray': '$inventory' } } },
{ '$project': { 'name': 1, 'inventory': { '$arrayToObject': '$videos' } } }
]))
print(result)
client.close()
example()
```
------
# \$1avg
The `$avg` aggregation operator in Amazon DocumentDB calculates the average value of the specified expression across the documents that are input to the stage. This operator is useful for computing the average of a numeric field or expression across a set of documents.
**Parameters**
+ `expression`: The expression to use to calculate the average. This can be a field path (e.g. `"$field"`) or an expression (e.g. `{ $multiply: ["$field1", "$field2"] }`).
## Example (MongoDB Shell)
The following example demonstrates how to use the `$avg` operator to calculate the average score across a set of student documents.
**Create sample documents**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**Query example**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**Output**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## Code examples
To view a code example for using the `$avg` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function calculateAvgScore() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const result = await db.collection('students').aggregate([
{ $group: {
_id: null,
avgScore: { $avg: '$score' }
}}
]).toArray();
console.log(result);
await client.close();
}
calculateAvgScore();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def calculate_avg_score():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
result = list(db.students.aggregate([
{ '$group': {
'_id': None,
'avgScore': { '$avg': '$score' }
}}
]))
print(result)
client.close()
calculate_avg_score()
```
------
# \$1bucket
New from version 8.0
Not supported by Elastic cluster.
The `$bucket` aggregation stage in Amazon DocumentDB allows you to group input documents into buckets based on a specified expression and bucket boundaries. This can be useful for analyzing data that falls within certain value ranges or categories.
**Parameters**
+ `groupBy` (required): The expression that specifies the value to group by.
+ `boundaries` (required): An array of double values that define the bucket boundaries. Documents are assigned to buckets based on the `groupBy` expression value falling within the specified boundaries.
+ `default` (optional): A literal value that is output for documents whose `groupBy` expression value does not fall into any of the specified boundaries.
+ `output` (optional): An object that specifies the information to output for each bucket. You can use accumulator operators like `$sum`, `$avg`, `$min`, and `$max` to compute aggregations for each bucket.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$bucket` stage to group sales data by price range.
**Create sample documents**
```
db.sales.insertMany([
{ item: "abc", price: 10, quantity: 2, date: new Date("2020-09-01") },
{ item: "def", price: 20, quantity: 1, date: new Date("2020-10-01") },
{ item: "ghi", price: 5, quantity: 3, date: new Date("2020-11-01") },
{ item: "jkl", price: 15, quantity: 2, date: new Date("2020-12-01") },
{ item: "mno", price: 25, quantity: 1, date: new Date("2021-01-01") }
]);
```
**Query example**
```
db.sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
])
```
**Output**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## Code examples
To view a code example for using the `$bucket` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const sales = db.collection('sales');
const result = await sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&lsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
sales = db['sales']
result = list(sales.aggregate([
{
'$bucket': {
'groupBy': '$price',
'boundaries': [0, 10, 20, 30],
'default': 'Other',
'output': {
'count': {'$sum': 1},
'totalQuantity': {'$sum': '$quantity'}
}
}
},
{
"$sort": { "_id": 1 }
}
]))
print(result)
client.close()
example()
```
------
# \$1ceil
New from version 4.0
The `$ceil` operator in Amazon DocumentDB, as in MongoDB, rounds a number up to the nearest integer. This is useful when you need to perform mathematical operations on numeric fields and ensure the result is a whole number.
**Parameters**
+ `expression`: The numeric expression to round up.
## Example (MongoDB Shell)
This example demonstrates how to use the `$ceil` operator to round up a numeric field.
**Create sample documents**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**Query example**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**Output**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## Code examples
To view a code example for using the `$ceil` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.numbers
result = list(collection.aggregate([
{ '$project': {
"roundedUp": { '$ceil': "$value" }
}}
]))
print(result)
client.close()
example()
```
------
# \$1changeStream
Not supported by Elastic cluster.
The `$changeStream` aggregation stage opens a change stream cursor to monitor real-time changes to a collection. It returns change event documents when insert, update, replace, or delete operations occur.
**Parameters**
+ `fullDocument`: Specifies whether to return the full document for update operations. Options are `default` or `updateLookup`.
+ `resumeAfter`: Optional. Resume token to continue from a specific point in the change stream.
+ `startAtOperationTime`: Optional. Timestamp to start the change stream from.
+ `allChangesForCluster`: Optional. Boolean value. When `true`, watches all changes across the cluster (for admin database). When `false` (default), watches only the specified collection.
## Example (MongoDB Shell)
The following example demonstrates using the `$changeStream` stage to monitor changes to a collection.
**Query example**
```
// Open change stream first
const changeStream = db.inventory.aggregate([
{ $changeStream: { fullDocument: "updateLookup" } }
]);
// In another session, insert a document
db.inventory.insertOne({ _id: 1, item: "Widget", qty: 10 });
// Back in the first session, read the change event
if (changeStream.hasNext()) {
print(tojson(changeStream.next()));
}
```
**Output**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## Code examples
To view a code example for using the `$changeStream` aggregation stage, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('inventory');
// Open change stream
const changeStream = collection.watch([]);
changeStream.on('change', (change) => {
console.log('Change detected:', change);
});
// Simulate insert in another operation
setTimeout(async () => {
await collection.insertOne({ _id: 1, item: 'Widget', qty: 10 });
}, 1000);
// Keep connection open to receive changes
// In production, handle cleanup appropriately
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
import threading
import time
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['inventory']
# Open change stream
change_stream = collection.watch([])
# Insert document in separate thread after delay
def insert_doc():
time.sleep(1)
collection.insert_one({'_id': 1, 'item': 'Widget', 'qty': 10})
threading.Thread(target=insert_doc).start()
# Watch for changes
for change in change_stream:
print('Change detected:', change)
break # Exit after first change
client.close()
example()
```
------
# \$1cmp
The `$cmp` operator in Amazon DocumentDB is used to compare two values and return an integer value that indicates their relative order. It is a comparison operator that compares two expressions and returns an integer value of -1, 0, or 1, depending on whether the first value is less than, equal to, or greater than the second value, respectively.
**Parameters**
+ `expression1`: The first expression to compare.
+ `expression2`: The second expression to compare.
## Example (MongoDB Shell)
The following example demonstrates the usage of the `$cmp` operator to compare two numeric values.
**Create sample documents**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**Query example**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**Output**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
In this example, the `$cmp` operator compares the `value1` and `value2` fields for each document. The result is:
```
- `$cmp: ["$value1", "$value2"]` returns -1 for the first document (10 < 20), 0 for the second document (15 = 15), and 1 for the third document (20 > 10).
```
## Code examples
To view a code example for using the `$cmp` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
Here's an example of using the `$cmp` operator in a Node.js application with the `mongodb` driver:
```
const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
async function main() {
await client.connect();
const db = client.db('test');
const collection = db.collection('mycollection');
// Insert sample documents
await collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
// Query using $cmp operator
const result = await collection.find({
$expr: {
$cmp: ['$value1', '$value2']
}
}).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
Here's an example of using the `$cmp` operator in a Python application with the `pymongo` driver:
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['mycollection']
# Insert sample documents
collection.insert_many([
{'_id': 1, 'value1': 10, 'value2': 20},
{'_id': 2, 'value1': 15, 'value2': 15},
{'_id': 3, 'value1': 20, 'value2': 10}
])
# Query using $cmp operator
result = list(collection.find({
'$expr': {
'$cmp': ['$value1', '$value2']
}
}))
print(result)
client.close()
```
The output of both the Node.js and Python examples will be the same as the MongoDB Shell example:
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
New from version 4.0
The `$collStats` aggregation stage in Amazon DocumentDB provides statistics about the specified collection, similar to the `db.collection.stats()` command in the MongoDB shell. This stage can be used to retrieve information about the collection, such as the number of documents, the total size of the collection, and various performance metrics.
**Parameters**
+ `latencyStats`: (optional) A document that specifies the options for collecting latency statistics. This parameter is not supported in Amazon DocumentDB.
+ `recordStats`: (optional) A document that specifies the options for collecting record statistics. This parameter is not supported in Amazon DocumentDB.
+ `queryExecStats`: (optional) A document that specifies the options for collecting query execution statistics. This parameter is not supported in Amazon DocumentDB.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$collStats` aggregation stage to retrieve statistics about a collection named `test` in the `db` database.
**Create sample documents**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**Query example**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**Output**
```
{
"ns" : "db.test",
"count" : 3,
"size" : 87,
"avgObjSize" : 29,
"storageSize" : 40960,
"capped" : false,
"nindexes" : 1,
"totalIndexSize" : 8192,
"indexSizes" : {
"_id_" : 8192
},
"collScans" : 0,
"idxScans" : 0,
"opCounter" : {
"numDocsIns" : 3,
"numDocsUpd" : 0,
"numDocsDel" : 0
},
"cacheStats" : {
"collBlksHit" : 0,
"collBlksRead" : 0,
"collHitRatio" : 0,
"idxBlksHit" : 0,
"idxBlksRead" : 0,
"idxHitRatio" : 0
},
"lastReset" : "2023-04-11T12:00:00Z",
"ok" : 1,
"operationTime" : Timestamp(1681206000, 1)
}
```
## Code examples
To view a code example for using the `$collStats` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
Here's an example of how to use the `$collStats` aggregation stage in a Node.js application using the official MongoDB Node.js driver:
```
const { MongoClient } = require('mongodb');
async function runCollStatsExample() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('db');
const collection = db.collection('test');
const result = await collection.aggregate([
{ $collStats: {} }
]).toArray();
console.log(result);
await client.close();
}
runCollStatsExample();
```
------
#### [ Python ]
Here's an example of how to use the `$collStats` aggregation stage in a Python application using the PyMongo driver:
```
from pymongo import MongoClient
def run_coll_stats_example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['db']
collection = db['test']
result = list(collection.aggregate([
{ '$collStats': {} }
]))
print(result)
client.close()
run_coll_stats_example()
```
------
# \$1concat
The `$concat` aggregation operator in Amazon DocumentDB concatenates (or combines) multiple strings in a document to produce a single string that can be returned to the application. This reduces the work done in the application, as the string manipulation is performed at the database level.
**Parameters**
+ `expression1`: The first string to concatenate.
+ `expression2`: The second string to concatenate.
+ `...`: Additional strings to concatenate (optional).
## Example (MongoDB Shell)
In this example, we concatenate the first and last names of users to produce each person's full name.
**Create sample documents**
```
db.people.insertMany([
{ "_id":1, "first_name":"Jane", "last_name":"Doe", "DOB":"2/1/1999", "Desk": "MSP102-MN"},
{ "_id":2, "first_name":"John", "last_name":"Doe", "DOB":"12/21/1992", "Desk": "DSM301-IA"},
{ "_id":3, "first_name":"Steve", "last_name":"Smith", "DOB":"3/21/1981", "Desk":"MKE233-WI"}
])
```
**Query example**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**Output**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## Code examples
To view a code example for using the `$concat` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function concatenateNames() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const result = await db.collection('people').aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
]).toArray();
console.log(result);
await client.close();
}
concatenateNames();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def concatenate_names():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
result = list(db.people.aggregate([
{ '$project': { 'full_name': { '$concat': [ '$first_name', ' ', '$last_name' ] } } }
]))
print(result)
client.close()
concatenate_names()
```
------
# \$1concatArrays
The `$concatArrays` aggregation operator in Amazon DocumentDB is used to concatenate two or more arrays into a single array. This can be useful when you need to combine multiple arrays of data into a single array for further processing or analysis.
**Parameters**
+ `array1`: The first array to be concatenated.
+ `array2`: The second array to be concatenated.
+ `[array3, ...]`: (optional) Additional arrays to be concatenated.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$concatArrays` operator to combine two arrays into a single array.
**Create sample documents**
```
db.collection.insertMany([
{
"_id": 1,
"name": "John Doe",
"hobbies": ["reading", "swimming"],
"skills": ["programming", "design"]
},
{
"_id": 2,
"name": "Jane Smith",
"hobbies": ["hiking", "cooking"],
"skills": ["marketing", "analysis"]
}
]);
```
**Query example**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**Output**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## Code examples
To view a code example for using the `$concatArrays` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('mydb');
const collection = db.collection('mycollection');
const result = await collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ['$hobbies', '$skills'] }
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['mydb']
collection = db['mycollection']
result = list(collection.aggregate([
{
'$project': {
'_id': 0,
'name': 1,
'all_activities': { '$concatArrays': ['$hobbies', '$skills'] }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1cond
The `$cond` operator in Amazon DocumentDB is used to evaluate a conditional expression and return one of two possible result expressions.
**Parameters**
+ `if`: The boolean expression to evaluate.
+ `then`: The expression to return if the `if` expression is true.
+ `else`: The expression to return if the `if` expression is false.
## Example (MongoDB Shell)
The following example demonstrates the use of the `$cond` operator to return a value based on the age of a person.
**Create sample documents**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**Query example**
```
db.people.aggregate([
{
$project: {
name: 1,
ageGroup: {
$cond: {
if: { $lt: ["$age", 30] },
then: "young",
else: {
$cond: {
if: { $lt: ["$age", 65] },
then: "middle-aged",
else: "elderly"
}
}
}
}
}
}
])
```
**Output**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## Code examples
To view a code example for using the `$cond` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('people');
const result = await collection.aggregate([
{ $project: {
name: 1,
ageGroup: {
$cond: {
if: { $lt: ["$age", 30] },
then: "young",
else: {
$cond: {
if: { $lt: ["$age", 65] },
then: "middle-aged",
else: "elderly"
}
}
}
}
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.people
result = list(collection.aggregate([
{
'$project': {
'name': 1,
'ageGroup': {
'$cond': {
'if': { '$lt': ["$age", 30]},
'then': "young",
'else': {
'$cond': {
'if': { '$lt': ["$age", 65]},
'then': "middle-aged",
'else': "elderly"
}
}
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1convert
New from version 4.0
The `$convert` operator in Amazon DocumentDB is used to convert a value from one data type to another. This operator is useful when you need to perform operations on data of different types, such as converting a string to a number or a date to a timestamp.
**Parameters**
+ `to`: The target data type to convert the value to. Supported values are `"string"`, `"double"`, `"long"`, `"int"`, `"date"`, and `"boolean"`.
+ `from`: The current data type of the value. If not specified, Amazon DocumentDB will attempt to automatically detect the data type.
+ `onError`: (optional) The value to return if the conversion fails. Can be a specific value or one of the following special values: `"null"`, `"zerofill"`, or `"error"`.
+ `onNull`: (optional) The value to return if the input value is `null`. Can be a specific value or one of the following special values: `"null"`, `"zerofill"`, or `"error"`.
## Example (MongoDB Shell)
The following example demonstrates converting a string value to a date using the `$convert` operator.
**Create sample documents**
```
db.users.insertMany([
{ _id: 1, name: "John Doe", joinedOn: "2022-01-01" },
{ _id: 2, name: "Jane Smith", joinedOn: "2023-02-15" },
{ _id: 3, name: "Bob Johnson", joinedOn: "invalid date" }
]);
```
**Query example**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**Output**
```
[
{ "_id" : 1, "name" : "John Doe", "joinedOn" : ISODate("2022-01-01T00:00:00Z") },
{ "_id" : 2, "name" : "Jane Smith", "joinedOn" : ISODate("2023-02-15T00:00:00Z") },
{ "_id" : 3, "name" : "Bob Johnson", "joinedOn" : null }
]
```
## Code examples
To view a code example for using the `$convert` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require("mongodb");
async function example() {
const client = await MongoClient.connect("mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false");
const db = client.db("test");
const users = db.collection("users");
const results = await users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
]).toArray();
console.log(results);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient("mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false")
db = client["test"]
users = db["users"]
results = list(users.aggregate([
{
"$project": {
"_id": 1,
"name": 1,
"joinedOn": {
"$convert": {
"input": "$joinedOn",
"to": "date",
"onError": "null",
"onNull": "null"
}
}
}
}
]))
print(results)
client.close()
example()
```
------
# \$1count
The `$count` aggregation stage in Amazon DocumentDB is used to count the number of documents that pass into the stage. It is often used as the final stage in an aggregation pipeline to return the total count of documents matching the previous stages.
**Parameters**
+ `field`: The field to count. This parameter is optional, and if not provided, the stage will count the total number of input documents.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$count` stage to get the total number of documents in a collection.
**Create sample documents**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**Query example**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**Output**
```
{ "total" : 4 }
```
The example aggregates the `users` collection and uses the `$count` stage to count the total number of documents.
## Code examples
To view a code example for using the `$count` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function countDocuments() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('mydb');
const collection = db.collection('users');
const result = await collection.aggregate([
{ $count: "total" }
]).toArray();
console.log(result[0].total);
await client.close();
}
countDocuments();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def count_documents():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['mydb']
collection = db['users']
result = list(collection.aggregate([
{ '$count': "total" }
]))
print(result[0]['total'])
client.close()
count_documents()
```
------
# \$1currentOp
The `$currentOp` aggregation stage returns information about currently running operations in the database. This stage is useful for monitoring active queries and operations in an aggregation pipeline.
**Parameters**
+ `allUsers` (optional): When set to `true`, returns operations for all users. Default is `false`.
+ `idleConnections` (optional): When set to `true`, includes idle connections. Default is `false`.
+ `idleCursors` (optional): When set to `true`, includes information about idle cursors. Default is `false`.
+ `idleSessions` (optional): When set to `true`, includes information about idle sessions. Default is `true`.
+ `localOps` (optional): When set to `true`, includes local operations. Default is `false`.
## Example (MongoDB Shell)
The following example demonstrates using the `$currentOp` aggregation stage to retrieve information about active read operations.
**Query example**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**Output**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## Code examples
To view a code example for using the `$currentOp` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('admin');
const result = await db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['admin']
result = list(db.aggregate([
{ '$currentOp': { 'allUsers': True, 'idleConnections': False } },
{ '$match': { 'op': 'query' } }
]))
print(result)
client.close()
example()
```
------
# \$1dateAdd
New from version 5.0
The `$dateAdd` aggregation operator in Amazon DocumentDB allows you to add a duration to a date and time value.
**Parameters**
+ `date`: A date and time value to add a duration to.
+ `duration`: The duration to add to the `date` value. This can be specified as an object with keys for `years`, `months`, `weeks`, `days`, `hours`, `minutes`, and `seconds`.
+ `timezone`: (optional) The time zone to use when performing the date addition. If not specified, the default time zone of the Amazon DocumentDB cluster is used.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$dateAdd` operator to add 2 days and 12 hours to a date.
**Create sample documents**
```
db.events.insertMany([
{ _id: 1, eventDate: ISODate("2023-04-01T10:00:00Z") },
{ _id: 2, eventDate: ISODate("2023-04-02T12:00:00Z") },
{ _id: 3, eventDate: ISODate("2023-04-03T14:00:00Z") }
]);
```
**Query example**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**Output**
```
[
{
"_id": 1,
"eventDate": "2023-04-01T10:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-03T22:00:00Z)"
},
{
"_id": 2,
"eventDate": "2023-04-02T12:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-05T00:00:00Z)"
},
{
"_id": 3,
"eventDate": "2023-04-03T14:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-06T02:00:00Z)"
}
]
```
## Code examples
To view a code example for using the `$dateAdd` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('events');
const result = await collection.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from bson.date_time import datetime
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['events']
result = list(collection.aggregate([
{
'$project': {
'_id': 1,
'eventDate': 1,
'eventDatePlustwodaysandtwelvehours': {
'$dateAdd': {
'startDate': {
'$dateAdd' : {
'startDate': '$eventDate',
'unit': 'day',
'amount': 2,
}
},
'unit': 'hour',
'amount': 12,
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateDiff
New from version 5.0
Not supported by Elastic cluster.
The `$dateDiff` aggregation operator calculates the difference between two dates in specified units. It returns the number of unit boundaries crossed between the start and end dates.
**Parameters**
+ `startDate`: The beginning date expression.
+ `endDate`: The ending date expression.
+ `unit`: The time unit for the difference. Supported units are `year`, `quarter`, `month`, `week`, `day`, `hour`, `minute`, `second`, and `millisecond`.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$dateDiff` operator to calculate the number of days between order placement and delivery.
**Create sample documents**
```
db.shipments.insertMany([
{
orderId: 1001,
orderDate: ISODate("2025-01-10T08:00:00Z"),
deliveryDate: ISODate("2025-01-15T14:30:00Z")
},
{
orderId: 1002,
orderDate: ISODate("2025-02-05T10:00:00Z"),
deliveryDate: ISODate("2025-02-12T16:45:00Z")
}
]);
```
**Query example**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**Output**
```
[
{
_id: ObjectId('6924a5f2d66dcae121d29517'),
orderId: 1001,
orderDate: ISODate('2025-01-10T08:00:00.000Z'),
deliveryDate: ISODate('2025-01-15T14:30:00.000Z'),
daysToDeliver: 5
},
{
_id: ObjectId('6924a5f2d66dcae121d29518'),
orderId: 1002,
orderDate: ISODate('2025-02-05T10:00:00.000Z'),
deliveryDate: ISODate('2025-02-12T16:45:00.000Z'),
daysToDeliver: 7
}
]
```
## Code examples
To view a code example for using the `$dateDiff` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const shipments = db.collection('shipments');
const result = await shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
shipments = db['shipments']
result = list(shipments.aggregate([
{
"$project": {
"orderId": 1,
"orderDate": 1,
"deliveryDate": 1,
"daysToDeliver": {
"$dateDiff": {
"startDate": "$orderDate",
"endDate": "$deliveryDate",
"unit": "day"
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateFromString
The `$dateFromString` aggregation operator in Amazon DocumentDB allows you to convert a date-time string into a date object. This is useful when your data is stored as strings but you need to perform date-based operations on the data.
**Parameters**
+ `dateString`: A string that represents a date and time.
+ `format`: (optional) A string that specifies the format of the `dateString`. If not provided, Amazon DocumentDB will attempt to parse the string in the ISO-8601 format.
+ `timezone`: (optional) A string that specifies the time zone. If not provided, Amazon DocumentDB will use the time zone of the server.
+ `onError`: (optional) Specifies the action to take if the conversion fails. Possible values are `'error'` (the default, which throws an error), `'null'` (returns `null`), or `'replace'` (replaces the value with the replacement string specified in the `onErrorMessage` option).
+ `onErrorMessage`: (optional) If `onError` is set to `'replace'`, this option specifies the replacement string.
## Example (MongoDB Shell)
The following example demonstrates how to use `$dateFromString` to convert a date string to a date object in Amazon DocumentDB.
**Create sample documents**
```
db.missionLog.insertMany([
{ _id: 1, event: "missionStart", logDate: "2020-03-15T13:41:33"},
{ _id: 2, event: "jumpPoint1", logDate: "2020-03-15T13:45:34"},
{ _id: 3, event: "jumpPoint2", logDate: "2020-03-15T13:48:21"},
{ _id: 4, event: "jumpPoint3", logDate: "2020-03-15T13:52:09"},
{ _id: 5, event: "missionEnd", logDate: "2020-03-15T13:58:44"}
]);
```
**Query example**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**Output**
```
[
{
"_id": 1,
"event": "missionStart",
"logDate": ISODate("2020-03-15T13:41:33Z")
},
{
"_id": 2,
"event": "jumpPoint1",
"logDate": ISODate("2020-03-15T13:45:34Z")
},
{
"_id": 3,
"event": "jumpPoint2",
"logDate": ISODate("2020-03-15T13:48:21Z")
},
{
"_id": 4,
"event": "jumpPoint3",
"logDate": ISODate("2020-03-15T13:52:09Z")
},
{
"_id": 5,
"event": "missionEnd",
"logDate": ISODate("2020-03-15T13:58:44Z")
}
]
```
## Code examples
To view a code example for using the `$dateFromString` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('missionLog');
const result = await collection.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['missionLog']
result = list(collection.aggregate([
{
'$project': {
'event': '$event',
'logDate': {
'$dateFromString': {
'dateString': '$logDate'
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateSubtract
New from version 5.0
The `$dateSubtract` aggregation operator in Amazon DocumentDB allows you to subtract a specified duration from a date value.
**Parameters**
+ `date`: A date expression that resolves to a date or timestamp.
+ `subtrahend`: A duration expression that specifies the amount of time to subtract from the `date` expression.
+ `unit`: A string that specifies the time unit for the `subtrahend` expression. Supported units are "year", "quarter", "month", "week", "day", "hour", "minute", "second", and "millisecond".
## Example (MongoDB Shell)
The following example demonstrates how to use the `$dateSubtract` operator to calculate the date one year ago from the current date.
**Create sample documents**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**Query example**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**Output**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## Code examples
To view a code example for using the `$dateSubtract` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const events = db.collection('events');
const result = await events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from bson.date_time import datetime
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
events = db['events']
result = list(events.aggregate([
{
'$project': {
'eventName': 1,
'oneYearAgo': {
'$dateSubtract': {
'startDate': '$eventTime',
'amount': 1,
'unit': 'year'
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateToString
The `$dateToString` aggregation operator in Amazon DocumentDB is used to convert a date or timestamp value to a string representation. This is useful when you need to format the date and time in a specific way for display or further processing.
**Parameters**
+ `date`: The date or timestamp value to be converted to a string.
+ `format`: A string that specifies the format in which the date should be represented. The format string can include various format specifiers, such as `%Y` for the four-digit year, `%m` for the two-digit month, `%d` for the two-digit day of the month, etc.
+ `timezone`: (optional) The time zone to use for the conversion. If not specified, the time zone of the server hosting the Amazon DocumentDB cluster is used.
+ `onNull`: (optional) The value to be returned if the `date` parameter is `null`.
## Example (MongoDB Shell)
The following example demonstrates the usage of the `$dateToString` operator to format the `logDate` field of the `missionLog` collection.
**Create sample documents**
```
db.missionLog.insertMany([
{ _id: 1, "event":"missionStart", logDate: new Date("2020-03-15T13:41:33Z") },
{ _id: 2, "event":"jumpPoint1", logDate: new Date("2020-03-15T13:45:34Z") },
{ _id: 3, "event":"jumpPoint2", logDate: new Date("2020-03-15T13:48:21Z") },
{ _id: 4, "event":"jumpPoint3", logDate: new Date("2020-03-15T13:52:09Z") },
{ _id: 5, "event":"missionEnd", logDate: new Date("2020-03-15T13:58:44Z") }
]);
```
**Query example**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**Output**
```
[
{
"_id": 1,
"event": "missionStart",
"logDateFormatted": "2020-03-15 13:41:33"
},
{
"_id": 2,
"event": "jumpPoint1",
"logDateFormatted": "2020-03-15 13:45:34"
},
{
"_id": 3,
"event": "jumpPoint2",
"logDateFormatted": "2020-03-15 13:48:21"
},
{
"_id": 4,
"event": "jumpPoint3",
"logDateFormatted": "2020-03-15 13:52:09"
},
{
"_id": 5,
"event": "missionEnd",
"logDateFormatted": "2020-03-15 13:58:44"
}
]
```
## Code examples
To view a code example for using the `$dateToString` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
Here's an example of using the `$dateToString` operator in a Node.js application:
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('missionLog');
const result = await collection.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
Here's an example of using the `$dateToString` operator in a Python application:
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['missionLog']
pipeline = [
{
'$project': {
'event': '$event',
'logDateFormatted': {
'$dateToString': {
'format': '%Y-%m-%d %H:%M:%S',
'date': '$logDate'
}
}
}
}
]
result = list(collection.aggregate(pipeline))
print(result)
client.close()
example()
```
------
# \$1dateTrunc
New from version 8.0
Not supported by Elastic cluster.
The `$dateTrunc` aggregation operator in Amazon DocumentDB truncates a date to a specified unit.
**Parameters**
+ `date`: A date expression that resolves to a date or timestamp.
+ `unit`: A string that specifies the time unit for the subtrahend expression. Supported units are `year`, `quarter`, `month`, `week`, `day`, `hour`, `minute`, `second`, and `millisecond`.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$dateTrunc` operator to truncate a date to to the hour.
**Create sample documents**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**Query example**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**Output**
```
[
{
_id: ObjectId('6924a258d66dcae121d29515'),
eventName: 'Event 1',
eventTime: ISODate('2025-04-01T12:15:00.000Z'),
truncatedToHour: ISODate('2025-04-01T12:00:00.000Z')
},
{
_id: ObjectId('6924a258d66dcae121d29516'),
eventName: 'Event 2',
eventTime: ISODate('2025-08-15T14:33:22.000Z'),
truncatedToHour: ISODate('2025-08-15T14:00:00.000Z')
}
]
```
## Code examples
To view a code example for using the `$dateTrunc` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const events = db.collection('events');
const result = await events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
events = db['events']
result = list(events.aggregate([
{
"$project": {
"eventName": 1,
"eventTime": 1,
"truncatedToHour": {
"$dateTrunc": {
"date": "$eventTime",
"unit": "hour"
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dayOfMonth
The `$dayOfMonth` aggregation operator in Amazon DocumentDB retrieves the day of the month (from 1 to 31) for a given date. This operator is useful for grouping, filtering, or extracting the day of the month from date fields in your documents.
**Parameters**
+ `date expression`: The date expression can be a date field from the document, a date object, or a date string.
## Example (MongoDB Shell)
This example demonstrates how to use the `$dayOfMonth` operator to extract the day of the month from a date field in the document.
**Create sample documents**
```
db.events.insertMany([
{ _id: 1, eventDate: new Date("2022-01-15T12:00:00Z") },
{ _id: 2, eventDate: new Date("2022-02-28T15:30:00Z") },
{ _id: 3, eventDate: new Date("2022-03-01T09:45:00Z") },
{ _id: 4, eventDate: new Date("2022-04-30T23:59:59Z") }
]);
```
**Query example**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**Output**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## Code examples
To view a code example for using the `$dayOfMonth` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const events = db.collection('events');
const result = await events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.mydatabase
events = db.events
result = list(events.aggregate([
{ "$project": {
"eventDay": { "$dayOfMonth": "$eventDate" }
}}
]))
print(result)
client.close()
example()
```
------
# \$1dayOfWeek
The `$dayOfWeek` operator in Amazon DocumentDB extracts the day of the week from a given date field. It returns the day of the week as a number between 1 (Sunday) and 7 (Saturday), which is the same behavior as in MongoDB.
**Parameters**
+ `date field`: The date field to extract the day of the week from.
## Example (MongoDB Shell)
This example demonstrates how to use the `$dayOfWeek` operator to extract the day of the week from the `date` field in the `weather` collection.
**Create sample documents**
```
db.weather.insertMany([
{
"temperature": 97.5,
"humidity": 0.60,
"date": new Date("2023-04-01")
},
{
"temperature": 95.2,
"humidity": 0.55,
"date": new Date("2023-04-02")
},
{
"temperature": 92.8,
"humidity": 0.65,
"date": new Date("2023-04-03")
}
]);
```
**Query example**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**Output**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## Code examples
To view a code example for using the `$dayOfWeek` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function main() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('weather');
const result = await collection.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: '$date' }
}
}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def main():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.weather
result = list(collection.aggregate([
{
'$project': {
'dayOfWeek': { '$dayOfWeek': '$date' }
}
}
]))
print(result)
client.close()
if __name__ == '__main__':
main()
```
------
# \$1dayOfYear
The `$dayOfYear` operator in Amazon DocumentDB returns the day of the year for a date as a number between 1 and 366 (365 in non-leap years).
**Parameters**
+ `expression`: The date field or expression from which to extract the day of the year.
## Example (MongoDB Shell)
This example demonstrates how to use the `$dayOfYear` operator to extract the day of the year from a date field in an Amazon DocumentDB collection.
**Create sample documents**
```
db.weather.insert([
{
"temperature" : 97.5,
"humidity": 0.60,
"date" : new Date("2023-03-15")
},
{
"temperature" : 82.3,
"humidity": 0.75,
"date" : new Date("2023-12-31")
}
])
```
**Query example**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**Output**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## Code examples
To view a code example for using the `$dayOfYear` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('weather');
const result = await collection.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['weather']
result = list(collection.aggregate([
{
'$project': {
'dayOfYear': { '$dayOfYear': '$date' }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1divide
The `$divide` operator in the Amazon DocumentDB aggregation pipeline is used to divide one number by another. It is a useful operator for performing mathematical operations on numeric fields within your documents.
**Parameters**
+ `numerator`: The dividend or the number to be divided.
+ `denominator`: The divisor or the number to divide by.
## Example (MongoDB Shell)
This example demonstrates how to use the `$divide` operator to calculate the hourly rate for employees based on their yearly salary and the number of working hours per year.
**Create sample documents**
```
db.employees.insertMany([
{ _id: 1, name: "John Doe", salary: 80000, hoursPerYear: 2080 },
{ _id: 2, name: "Jane Smith", salary: 90000, hoursPerYear: 2080 },
{ _id: 3, name: "Bob Johnson", salary: 75000, hoursPerYear: 2080 }
]);
```
**Query example**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**Output**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## Code examples
To view a code example for using the `$divide` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function calculateHourlyRate() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const employees = db.collection('employees');
const result = await employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
]).toArray();
console.log(result);
client.close();
}
calculateHourlyRate();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def calculate_hourly_rate():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.mydatabase
employees = db.employees
result = list(employees.aggregate([
{
'$project': {
'name': 1,
'hourlyRate': { '$divide': ['$salary', '$hoursPerYear'] }
}
}
]))
print(result)
client.close()
calculate_hourly_rate()
```
------
# \$1eq
The `$eq` aggregation operator compares two values and returns `true` if they are equal, otherwise returns `false`.
**Parameters**
+ `expression1`: The first value to compare.
+ `expression2`: The second value to compare.
## Example (MongoDB Shell)
The following example demonstrates using the `$eq` operator to check if product quantities match target values.
**Create sample documents**
```
db.inventory.insertMany([
{ _id: 1, item: "Widget", qty: 50, target: 50 },
{ _id: 2, item: "Gadget", qty: 30, target: 50 },
{ _id: 3, item: "Tool", qty: 50, target: 40 }
]);
```
**Query example**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**Output**
```
[
{ _id: 1, item: 'Widget', qty: 50, target: 50, meetsTarget: true },
{ _id: 2, item: 'Gadget', qty: 30, target: 50, meetsTarget: false },
{ _id: 3, item: 'Tool', qty: 50, target: 40, meetsTarget: false }
]
```
## Code examples
To view a code example for using the `$eq` aggregation operator, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('inventory');
const result = await collection.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['inventory']
result = list(collection.aggregate([
{
'$project': {
'item': 1,
'qty': 1,
'target': 1,
'meetsTarget': { '$eq': ['$qty', '$target'] }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1exp
New from version 4.0
The `$exp` operator in Amazon DocumentDB allows you to raise the constant e to a given number.
**Parameters**
+ `expression`: The expression to evaluate. This can be any valid aggregation expression, including field references, arithmetic operations, and other aggregation stages.
## Example (MongoDB Shell)
The following example demonstrates the use of the `$exp` operator to find all documents where the `quantity` field is greater than the `price` field.
**Create sample documents**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**Query example**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**Output**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## Code examples
To view a code example for using the `$exp` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function aggregateExp() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const items = db.collection('items');
const result = await items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]).toArray();
console.log(result);
client.close();
}
aggregateExp();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def aggregate_exp():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
items = db.items
result = list(items.aggregate([
{ "$project": {
"quantityRaised": {"$exp": "$quantity"}}
}
]))
print(result)
client.close()
aggregate_exp()
```
------
# \$1filter
The `$filter` operator in Amazon DocumentDB is used to apply a filter expression to each element of an array and return an array containing only the elements that match the specified condition. This operator is useful when you need to perform complex filtering operations on array fields within your documents.
**Parameters**
+ `input`: The array field to filter.
+ `as`: The variable name to use for each element of the `input` array within the `cond` expression.
+ `cond`: The boolean expression that determines whether a given element should be included in the output array.
## Example (MongoDB Shell)
The following example demonstrates how to use the `$filter` operator to project each order's customer and create a new array field paidItems containing only the items from the items array where the price is greater than 15. Essentially, it filters each order’s items to include only products that cost more than 15.
**Create sample documents**
```
db.orders.insertMany([
{ _id: 1, customer: "abc123", items: [
{ name: "Product A", price: 10, qty: 2 },
{ name: "Product B", price: 20, qty: 1 }
]},
{ _id: 2, customer: "def456", items: [
{ name: "Product C", price: 5, qty: 3 },
{ name: "Product D", price: 15, qty: 4 }
]},
{ _id: 3, customer: "ghi789", items: [
{ name: "Product E", price: 8, qty: 3 },
{ name: "Product F", price: 12, qty: 1 }
]}
]);
```
**Query example**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**Output**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## Code examples
To view a code example for using the `$filter` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('orders');
const result = await collection.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).toArray();
console.log(JSON.stringify(result, null, 2));
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false'
with MongoClient(uri) as client:
db = client.test
collection = db.orders
result = list(collection.aggregate([
{
'$project': {
'customer': 1,
'paidItems': {
'$filter': {
'input': '$items',
'as': 'item',
'cond': { '$gt': ['$$item.price', 15] }
}
}
}
}
]))
for doc in result:
pprint(doc)
example()
```
------
# \$1first
New from version 5.0.
Not supported by Elastic cluster.
The `$first` operator in Amazon DocumentDB returns the first document from a grouped set of documents. It is commonly used in aggregation pipelines to retrieve the first document that matches a specific condition.
**Parameters**
+ `expression`: The expression to return as the first value in each group.
## Example (MongoDB Shell)
The following example demonstrates the use of the `$first` operator to retrieve the first item value encountered for each category during the aggregation.
Note: `$first` returns the first document based on the current order of documents in the pipeline. To ensure a specific order (e.g., by date, price, etc.), a `$sort` stage should be used before the `$group` stage.
**Create sample documents**
```
db.products.insertMany([
{ _id: 1, item: "abc", price: 10, category: "food" },
{ _id: 2, item: "jkl", price: 20, category: "food" },
{ _id: 3, item: "xyz", price: 5, category: "toy" },
{ _id: 4, item: "abc", price: 5, category: "toy" }
]);
```
**Query example**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**Output**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## Code examples
To view a code example for using the `$first` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('products');
const result = await collection.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]).toArray();
console.log(result);
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
client = None
try:
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['products']
result = list(collection.aggregate([
{ '$group': { '_id': '$category', 'firstItem': { '$first': '$item' } } }
]))
pprint(result)
except Exception as e:
print(f"An error occurred: {e}")
finally:
if client:
client.close()
example()
```
------
# \$1floor
New from version 4.0.
The `$floor` operator in Amazon DocumentDB returns the largest integer that is less than or equal to the specified number. This operator is useful for rounding down numeric values.
**Parameters**
+ `expression`: The numeric expression to round down.
## Example (MongoDB Shell)
The following example demonstrates the use of the `$floor` operator to round a decimal value down to the nearest integer.
**Create sample documents**
```
db.numbers.insertOne({ value: 3.14 });
```
**Query example**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**Output**
```
{ "floored" : 3 }
```
## Code examples
To view a code example for using the `$floor` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]).toArray();
console.log(result);
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
client = None
try:
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.numbers
result = list(collection.aggregate([
{ '$project': { '_id': 0, 'floored': { '$floor': '$value' }}}
]))
pprint(result)
except Exception as e:
print(f"An error occurred: {e}")
finally:
if client:
client.close()
example()
```
------
# \$1geoNear
The `$geoNear` aggregation stage returns documents in order of proximity to a specified point. It calculates the distance from the point and includes the distance in the output documents.
**Parameters**
+ `near`: The point from which to calculate distances, specified as GeoJSON or legacy coordinates.
+ `distanceField`: The field name to store the calculated distance.
+ `spherical`: Boolean indicating whether to use spherical geometry (required for GeoJSON points).
+ `maxDistance`: Optional. Maximum distance from the center point.
+ `minDistance`: Optional. Minimum distance from the center point.
+ `query`: Optional. Additional filter criteria to apply.
+ `limit`: Optional. Maximum number of documents to return.
+ `key`: Optional. Field to use for geospatial query when multiple geospatial indexes exist.
## Example (MongoDB Shell)
The following example demonstrates using the `$geoNear` stage to find stores nearest to a given location.
**Create sample documents**
```
db.stores.createIndex({ location: "2dsphere" });
db.stores.insertMany([
{ _id: 1, name: "Store A", location: { type: "Point", coordinates: [-122.4, 37.8] } },
{ _id: 2, name: "Store B", location: { type: "Point", coordinates: [-122.5, 37.7] } },
{ _id: 3, name: "Store C", location: { type: "Point", coordinates: [-122.3, 37.9] } }
]);
```
**Query example**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**Output**
```
[
{ _id: 1, name: 'Store A', location: { type: 'Point', coordinates: [ -122.4, 37.8 ] }, distance: 0 },
{ _id: 3, name: 'Store C', location: { type: 'Point', coordinates: [ -122.3, 37.9 ] }, distance: 13877.82 },
{ _id: 2, name: 'Store B', location: { type: 'Point', coordinates: [ -122.5, 37.7 ] }, distance: 15557.89 }
]
```
## Code examples
To view a code example for using the `$geoNear` aggregation stage, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('stores');
const result = await collection.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['stores']
result = list(collection.aggregate([
{
'$geoNear': {
'near': { 'type': 'Point', 'coordinates': [-122.4, 37.8] },
'distanceField': 'distance',
'spherical': True
}
}
]))
print(result)
client.close()
example()
```
------
# \$1group
The `$group` aggregation stage in Amazon DocumentDB allows you to group documents by a specified expression and perform various accumulative operations on the grouped data. This can be useful for tasks such as calculating totals, averages, or other statistics based on the grouped data.
**Parameters**
+ `_id`: Specifies the expression by which the input documents should be grouped. This can be a field name, a computed expression, or a combination of both.
+ `accumulator expressions`: (optional) One or more accumulator expressions that should be applied to the grouped data. These expressions use the accumulator operators mentioned above.
## Example (MongoDB Shell)
The following example groups customers by their city and calculates the total order amount for each city.
**Create sample documents**
```
db.customers.insertMany([
{ name: "John Doe", city: "New York", orders: [{ amount: 100 }, { amount: 200 }] },
{ name: "Jane Smith", city: "Los Angeles", orders: [{ amount: 150 }, { amount: 300 }] },
{ name: "Bob Johnson", city: "New York", orders: [{ amount: 75 }, { amount: 125 }] },
{ name: "Samantha Lee", city: "Chicago", orders: [{ amount: 50 }, { amount: 100 }] }
]);
```
**Query example**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**Output**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## Code examples
To view a code example for using the `$group` command, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function groupByCity() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const result = await db.collection('customers').aggregate([
{ $unwind: '$orders' },
{
$group: {
_id: '$city',
totalOrders: { $sum: '$orders.amount' }
}
}
]).toArray();
console.log(result);
} catch (err) {
console.error('Error during aggregation:', err);
} finally {
await client.close();
}
}
groupByCity();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def group_by_city():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
try:
db = client.test
result = list(db.customers.aggregate([
{'$unwind': '$orders'},
{
'$group': {
'_id': '$city',
'totalOrders': {'$sum': '$orders.amount'}
}
}
]))
print(result)
except Exception as e:
print(f"Error during aggregation: {e}")
finally:
client.close()
group_by_city()
```
------
# \$1gt
The `$gt` aggregation operator compares two values and returns `true` if the first value is greater than the second, otherwise returns `false`.
**Parameters**
+ `expression1`: The first value to compare.
+ `expression2`: The second value to compare.
## Example (MongoDB Shell)
The following example demonstrates using the `$gt` operator to identify products exceeding a price threshold.
**Create sample documents**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**Query example**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**Output**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## Code examples
To view a code example for using the `$gt` aggregation operator, choose the tab for the language that you want to use:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('products');
const result = await collection.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://