本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 在 Amazon Document APIs DB 中支持 MongoDB、操作和数据类型
Amazon DocumentDB（与 MongoDB 兼容）是一个快速、可扩展、高度可用且完全托管的文档数据库服务，它支持 MongoDB 工作负载。亚马逊 DocumentDB 与 MongoDB 3.6、4.0、5.0 和 8.0 兼容。 APIs本部分列出了支持的功能。要获得使用 M APIs ongoDB 和驱动程序的支持，请查阅 MongoDB 社区论坛。如需使用亚马逊 DocumentDB 服务的支持，请联系相应的 AWS 支持团队。有关 Amazon DocumentDB 和 MongoDB 之间的功能差异，请参阅 [功能差异：Amazon DocumentDB 和 MongoDB](functional-differences.md)。
仅供内部使用或不适用于完全托管的服务的 MongoDB 命令和运算符不受支持，并且未包含在支持的功能列表中。
自发布以来，我们已添加 50 多种附加功能，并将继续向客户学习以提供他们所需的功能。有关最近发布的信息，请参阅 [Amazon DocumentDB 公告](https://aws.amazon.com/documentdb/resources/)。
如果您希望我们构建一项不受支持的功能，请向 [Amazon DocumentDB 服务团队](mailto:documentdb-feature-request@amazon.com)发送一封包含您的 accountID、请求的功能和使用案例的电子邮件来告知我们此情况。
+ [数据库命令](#mongo-apis-database)
+ [查询和投影运算符](#mongo-apis-query)
+ [更新运算符](#mongo-apis-update)
+ [地理空间](#mongo-apis-geospatial)
+ [游标方法](#mongo-apis-cursor)
+ [聚合管道运算符](#mongo-apis-aggregation-pipeline)
+ [数据类型](#mongo-apis-data-types)
+ [索引](#mongo-apis-indexes)
## 数据库命令
**Topics**
+ [管理命令](#mongo-apis-dababase-administrative)
+ [聚合](#mongo-apis-dababase-aggregation)
+ [身份验证](#mongo-apis-dababase-authentication)
+ [诊断命令](#mongo-apis-dababase-diagnostics)
+ [查询和写入操作](#mongo-apis-dababase-query-write)
+ [角色管理命令](#mongo-apis-database-role-management)
+ [会话命令](#mongo-apis-dababase-sessions)
+ [User management](#mongo-apis-dababase-user-management)
+ [分片命令](#mongo-apis-dababase-sharding)
### 管理命令
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| 受限集合 | 否 | 否 | 否 | 否 | 否 |
| cloneCollectionAs已封顶 | 否 | 否 | 否 | 否 | 否 |
| collMod | 部分 | 部分 | 部分 | 部分 | 部分 |
| collMod： expireAfterSeconds | 支持 | 是 | 是 | 是 | 是 |
| convertToCapped | 否 | 否 | 否 | 否 | 否 |
| copydb | 否 | 否 | 否 | 否 | 否 |
| 创建 | 支持 | 是 | 是 | 是 | 是 |
| createView | 否 | 否 | 否 | 是 | 否 |
| createIndexes | 支持 | 是 | 是 | 是 | 是 |
| currentOp | 支持 | 是 | 是 | 是 | 是 |
| drop | 支持 | 是 | 是 | 是 | 是 |
| dropDatabase | 支持 | 是 | 是 | 是 | 是 |
| dropIndexes | 支持 | 是 | 是 | 是 | 是 |
| filemd5 | 否 | 否 | 否 | 否 | 否 |
| getAuditConfig | 否 | 是 | 是 | 是 | 否 |
| killCursors | 支持 | 是 | 是 | 是 | 是 |
| killOp | 支持 | 是 | 是 | 是 | 是 |
| listCollections\$1 | 支持 | 是 | 是 | 是 | 是 |
| listDatabases | 支持 | 是 | 是 | 是 | 是 |
| listIndexes | 支持 | 是 | 是 | 是 | 是 |
| reIndex | 否 | 否 | 是 | 是 | 否 |
| renameCollection | 支持 | 是 | 是 | 是 | 否 |
| setAuditConfig | 否 | 是 | 是 | 是 | 否 |
\$1 不支持筛选选项中的 `type` 密钥。
### 聚合
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| aggregate | 支持 | 是 | 是 | 是 | 是 |
| count | 支持 | 是 | 是 | 是 | 是 |
| 区分 | 支持 | 是 | 是 | 是 | 是 |
| mapReduce | 否 | 否 | 否 | 是 | 否 |
### 身份验证
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| authenticate | 支持 | 是 | 是 | 是 | 是 |
| 注销 | 支持 | 是 | 是 | 是 | 是 |
### 诊断命令
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| buildInfo | 支持 | 是 | 是 | 是 | 是 |
| collStats | 支持 | 是 | 是 | 是 | 是 |
| connPoolStats | 否 | 否 | 否 | 否 | 否 |
| connectionStatus | 支持 | 是 | 是 | 是 | 是 |
| dataSize | 支持 | 是 | 是 | 是 | 是 |
| dbHash | 否 | 否 | 否 | 否 | 否 |
| dbStats | 支持 | 是 | 是 | 是 | 是 |
| explain | 支持 | 是 | 是 | 是 | 是 |
| 解释：executionStats | 支持 | 是 | 是 | 是 | 是 |
| 功能 | 否 | 否 | 否 | 否 | 否 |
| hostInfo | 支持 | 是 | 是 | 是 | 是 |
| listCommands | 支持 | 是 | 是 | 是 | 是 |
| profiler | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | 否 |
| serverStatus | 支持 | 是 | 是 | 是 | 是 |
| top | 支持 | 是 | 是 | 是 | 是 |
### 查询和写入操作
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| 变更流 | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [是](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | 否 |
| 删除 | 支持 | 是 | 是 | 是 | 是 |
| 查找 | 支持 | 是 | 是 | 是 | 是 |
| findAndModify | 是 | 是 | 是 | 是 | 是 |
| getLastError | 否 | 否 | 否 | 否 | 否 |
| getMore | 支持 | 是 | 是 | 是 | 是 |
| getPrevError | 否 | 否 | 否 | 否 | 否 |
| GridFS | 支持 | 是 | 是 | 是 | 否 |
| insert | 支持 | 是 | 是 | 是 | 是 |
| parallelCollectionScan | 否 | 否 | 否 | 否 | 否 |
| resetError | 否 | 否 | 否 | 否 | 否 |
| 更新 | 支持 | 是 | 是 | 是 | 是 |
| ReplaceOne | 是 | 是 | 是 | 是 | 是 |
### 角色管理命令
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| createRole | 支持 | 是 | 是 | 是 | 否 |
| dropAllRolesFromDatabase | 是 | 是 | 是 | 是 | 否 |
| dropRole | 支持 | 是 | 是 | 是 | 否 |
| grantRolesTo角色 | 支持 | 是 | 是 | 是 | 否 |
| revokeRolesFrom角色 | 支持 | 是 | 是 | 是 | 否 |
| revokePrivilegesFrom角色 | 支持 | 是 | 是 | 是 | 否 |
| rolesInfo | 支持 | 是 | 是 | 是 | 否 |
| updateRole | 支持 | 是 | 是 | 是 | 否 |
### 会话命令
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| abortTransaction | 否 | 是 | 是 | 是 | 否 |
| commitTransaction | 否 | 是 | 是 | 是 | 否 |
| endSessions | 否 | 否 | 否 | 否 | 否 |
| killAllSessions | 否 | 是 | 是 | 是 | 否 |
| killAllSessionsByPattern | 否 | 否 | 否 | 否 | 否 |
| killSessions | 否 | 是 | 是 | 是 | 否 |
| refreshSessions | 否 | 否 | 否 | 否 | 否 |
| startSession | 否 | 是 | 是 | 是 | 否 |
### User management
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| createUser | 支持 | 是 | 是 | 是 | 是 |
| dropAllUsersFromDatabase | 是 | 是 | 是 | 是 | 是 |
| dropUser | 支持 | 是 | 是 | 是 | 是 |
| grantRolesToUser | 是 | 是 | 是 | 是 | 是 |
| revokeRolesFromUser | 是 | 是 | 是 | 是 | 是 |
| updateUser | 支持 | 是 | 是 | 是 | 是 |
| usersInfo | 支持 | 是 | 是 | 是 | 是 |
### 分片命令
| 命令 | 弹性集群 |
| --- | --- |
| abortReshardCollection | 否 |
| addShard | 否 |
| addShardTo区域 | 否 |
| balancerCollectionStatus | 否 |
| balancerStart | 否 |
| balancerStatus | 否 |
| balancerStop | 否 |
| checkShardingIndex | 否 |
| clearJumboFlag | 否 |
| cleanupOrphaned | 否 |
| cleanupReshardCollection | 否 |
| commitReshardCollection | 否 |
| enableSharding | 是 |
| flushRouterConfig | 否 |
| getShardMap | 否 |
| getShardVersion | 否 |
| isdbgrid | 否 |
| listShards | 否 |
| medianKey | 否 |
| moveChunk | 否 |
| movePrimary | 否 |
| mergeChunks | 否 |
| refineCollectionShard钥匙 | 否 |
| removeShard | 否 |
| removeShardFrom区域 | 否 |
| reshardCollection | 否 |
| setAllowMigrations | 否 |
| setShardVersion | 否 |
| shardCollection | 是 |
| shardingState | 否 |
| split | 否 |
| splitVector | 否 |
| unsetSharding | 否 |
| updateZoneKey射程 | 否 |
## 查询和投影运算符
**Topics**
+ [数组运算符](#mongo-apis-query-array-operators)
+ [按位运算符](#mongo-apis-query-bitwise-operators)
+ [注释运算符](#mongo-apis-query-comment-operator)
+ [比较运算符](#mongo-apis-query-comparison-operators)
+ [元素运算符](#mongo-apis-query-element-operators)
+ [评估查询运算符](#mongo-apis-query-evaluation-operators)
+ [逻辑运算符](#mongo-apis-query-logical-operators)
+ [投影运算符](#mongo-apis-projection-operators)
### 数组运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1elemMatch](elemMatch.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1size](size-query.md) | 是 | 是 | 是 | 是 | 是 |
### 按位运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1bitsAnySet](bitsAnySet.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1bitsAllClear](bitsAllClear.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1bitsAnyClear](bitsAnyClear.md) | 是 | 是 | 是 | 是 | 是 |
### 注释运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | 支持 | 是 | 是 | 是 | 是 |
### 比较运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1gt](gt.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1gte](gte.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1in](in.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1lt](lt.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1lte](lte.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1ne](ne.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1nin](nin.md) | 是 | 是 | 是 | 是 | 是 |
### 元素运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1type](type.md) | 是 | 是 | 是 | 是 | 是 |
### 评估查询运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | 否 | 是 | 是 | 是 | 否 |
| [\$1jsonSchema](jsonSchema.md) | 否 | 是 | 是 | 是 | 否 |
| [\$1mod](mod-query.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1regex](regex.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1text](text.md) | 否 | 否 | 是 | 是 | 否 |
| \$1where | 否 | 否 | 否 | 否 | 否 |
### 逻辑运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1nor](nor.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1not](not.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1or](or.md) | 是 | 是 | 是 | 是 | 是 |
### 投影运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1elemMatch](elemMatch.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1meta](meta.md) | 否 | 否 | 是 | 是 | 否 |
| [\$1slice](slice-projection.md) | 是 | 是 | 是 | 是 | 是 |
## 更新运算符
**Topics**
+ [数组运算符](#mongo-apis-update-array)
+ [按位运算符](#mongo-apis-update-bitwise)
+ [字段运算符](#mongo-apis-update-field)
+ [更新修改器](#mongo-apis-update-modifiers)
### 数组运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1[]](dollarBrackets-update.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1[]](dollarIdentifier-update.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1addToSet](addToSet.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1pop](pop.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1pullAll](pullAll.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1pull](pull.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1push](push.md) | 支持 | 是 | 是 | 是 | 是 |
### 按位运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | 支持 | 是 | 是 | 是 | 是 |
### 字段运算符
| 运算符 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1inc](inc.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1max](max-update.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1min](min-update.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1mul](mul.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1rename](rename.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1set](set-update.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1setOnInsert](setOnInsert.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1unset](unset-update.md) | 是 | 是 | 是 | 是 | 是 |
### 更新修改器
| 运算符 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1position](position.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1slice](slice-update.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1sort](sort-update.md) | 是 | 是 | 是 | 是 | 是 |
## 地理空间
### 几何说明符
| 查询选择器 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| BOX | 否 | 否 | 否 | 否 | 否 |
| .center | 否 | 否 | 否 | 否 | 否 |
| \$1centerSphere | 否 | 否 | 否 | 否 | 否 |
| [\$1geometry](geometry.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1maxDistance](maxDistance.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1minDistance](minDistance.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1nearSphere](nearSphere.md) | 是 | 是 | 是 | 是 | 是 |
| \$1polygon | 否 | 否 | 否 | 否 | 否 |
| \$1uniqueDocs | 否 | 否 | 否 | 否 | 否 |
### 查询选择器
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1geoWithin](geoWithin.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1near](near.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1nearSphere](nearSphere.md) | 是 | 是 | 是 | 是 | 是 |
| \$1polygon | 否 | 否 | 否 | 否 | 否 |
| \$1uniqueDocs | 否 | 否 | 否 | 否 | 否 |
## 游标方法
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | 支持 | 是 | 是 | 是 | 是 |
| cursor.close() | 支持 | 是 | 是 | 是 | 是 |
| cursor.collation() | 否 | 否 | 否 | 是 | 否 |
| cursor.comment() | 支持 | 是 | 是 | 是 | 是 |
| cursor.count() | 支持 | 是 | 是 | 是 | 是 |
| cursor.explain() | 支持 | 是 | 是 | 是 | 否 |
| cursor.forEach() | 支持 | 是 | 是 | 是 | 是 |
| cursor.hasNext() | 支持 | 是 | 是 | 是 | 是 |
| cursor.hint() | 支持 | 是 | 是 | 是 | 是\$1 |
| cursor.isClosed() | 支持 | 是 | 是 | 是 | 是 |
| cursor.isExhausted() | 支持 | 是 | 是 | 是 | 否 |
| cursor.itcount() | 支持 | 是 | 是 | 是 | 否 |
| cursor.limit() | 支持 | 是 | 是 | 是 | 否 |
| cursor.map() | 支持 | 是 | 是 | 是 | 否 |
| cursor.max() | 否 | 否 | 否 | 否 | 否 |
| cursor.maxScan() | 支持 | 是 | 是 | 是 | 否 |
| cursor.maxTimeMS() | 支持 | 是 | 是 | 是 | 否 |
| cursor.min() | 否 | 否 | 否 | 否 | 否 |
| cursor.next() | 支持 | 是 | 是 | 是 | 是 |
| 光标。 noCursorTimeout() | 否 | 否 | 否 | 否 | 否 |
| 光标。 objsLeftInBatch () | 支持 | 是 | 是 | 是 | 否 |
| cursor.pretty() | 支持 | 是 | 是 | 是 | 否 |
| cursor.readConcern() | 支持 | 是 | 是 | 是 | 否 |
| cursor.readPref() | 支持 | 是 | 是 | 是 | 否 |
| cursor.returnKey() | 否 | 否 | 否 | 否 | 否 |
| 光标。 showRecordId() | 否 | 否 | 否 | 否 | 否 |
| cursor.size() | 支持 | 是 | 是 | 是 | 否 |
| cursor.skip() | 支持 | 是 | 是 | 是 | 否 |
| cursor.sort() | 支持 | 是 | 是 | 是 | 否 |
| cursor.tailable() | 否 | 否 | 否 | 否 | 否 |
| cursor.toArray() | 支持 | 是 | 是 | 是 | 否 |
\$1 索引 `hint` 表达式支持索引。例如 `db.foo.find().hint({x:1})`。
## 聚合管道运算符
**Topics**
+ [累加器表达式](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [算术运算符](#mongo-apis-aggregation-pipeline-arithmetic)
+ [数组运算符](#mongo-apis-aggregation-pipeline-array)
+ [布尔运算符](#mongo-apis-aggregation-pipeline-boolean)
+ [比较运算符](#mongo-apis-aggregation-pipeline-comparison)
+ [条件表达式运算符](#mongo-apis-aggregation-pipeline-conditional)
+ [数据类型运算符](#mongo-apis-aggregation-pipeline-data-type)
+ [数据大小运算符](#mongo-apis-aggregation-pipeline-data-size)
+ [日期运算符](#mongo-apis-aggregation-pipeline-date)
+ [文字运算符](#mongo-apis-aggregation-pipeline-literal)
+ [合并运算符](#mongo-apis-aggregation-pipeline-merge)
+ [自然运算符](#mongo-apis-aggregation-pipeline-natural)
+ [集合运算符](#mongo-apis-aggregation-pipeline-set)
+ [阶段运算符](#mongo-apis-aggregation-pipeline-stage)
+ [字符串运算符](#mongo-apis-aggregation-pipeline-string)
+ [系统变量](#mongo-apis-aggregation-pipeline-system-variables)
+ [文本搜索运算符](#mongo-apis-aggregation-pipeline-text-search)
+ [类型转换运算符](#mongo-apis-aggregation-pipeline-type)
+ [变量运算符](#mongo-apis-aggregation-pipeline-variable)
+ [其他运算符](#mongo-apis-aggregation-pipeline-misc)
### 累加器表达式
| Expression | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| \$1accumulator | - | - | 否 | 否 | 否 |
| [\$1addToSet](addToSet-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1avg](avg.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1count](count.md) | - | - | 否 | 否 | 否 |
| \$1covariancePop | 否 | 否 | 否 | 否 | 否 |
| \$1covarianceSamp | 否 | 否 | 否 | 否 | 否 |
| \$1denseRank | 否 | 否 | 否 | 否 | 否 |
| \$1derivative | 否 | 否 | 否 | 否 | 否 |
| \$1documentNumber | 否 | 否 | 否 | 否 | 否 |
| \$1expMovingAvg | 否 | 否 | 否 | 否 | 否 |
| [\$1first](first.md) | 是 | 是 | 是 | 是 | 是 |
| \$1integral | 否 | 否 | 否 | 否 | 否 |
| [\$1last](last.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1max](max.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1min](min.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1push](push-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| \$1rank | 否 | 否 | 否 | 否 | 否 |
| \$1shift | 否 | 否 | 否 | 否 | 否 |
| \$1stdDevPop | 否 | 否 | 否 | 否 | 否 |
| \$1stdDevSamp | 否 | 否 | 否 | 否 | 否 |
| [\$1sum](sum.md) | 是 | 是 | 是 | 是 | 是 |
### 算术运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1add](add.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1ceil](ceil.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1divide](divide.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1exp](exp.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1floor](floor.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1ln](ln.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1log](log.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1log10](log10.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1mod](mod.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1multiply](multiply.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1pow](pow.md) | 否 | 否 | 否 | 是 | 否 |
| \$1round | - | - | 否 | 否 | 否 |
| [\$1sqrt](sqrt.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1subtract](subtract.md) | 是 | 是 | 是 | 是 | 是 |
| \$1trunc | 否 | 否 | 否 | 否 | 否 |
### 数组运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1arrayToObject](arrayToObject.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1concatArrays](concatArrays.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1filter](filter.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1first](first.md) | - | - | 是 | 是 | 否 |
| [\$1in](in-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1indexOfArray](indexOfArray.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1isArray](isArray.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1last](last.md) | - | - | 是 | 是 | 否 |
| [\$1objectToArray](objectToArray.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1range](range.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1reverseArray](reverseArray.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1reduce](reduce.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1size](size.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1slice](slice.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1zip](zip.md) | 是 | 是 | 是 | 是 | 是 |
### 布尔运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1not](not-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1or](or-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
### 比较运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1eq](eq-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1gt](gt-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1gte](gte-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1lt](lt-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1lte](lte-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1ne](ne-aggregation.md) | 是 | 是 | 是 | 是 | 是 |
### 条件表达式运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1ifNull](ifNull.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1switch](switch.md) | 否 | 是 | 是 | 是 | 否 |
### 数据类型运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | 支持 | 是 | 是 | 是 | 是 |
### 数据大小运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | 否 | 否 | 否 |
| \$1bsonSize | - | - | 否 | 否 | 否 |
### 日期运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1dateAdd](dateAdd.md) | 否 | 否 | 是 | 是 | 是 |
| [\$1dateDiff](dateDiff.md) | - | - | 是 | 是 | 否 |
| \$1dateFromParts | 否 | 否 | 否 | 否 | 否 |
| [\$1dateFromString](dateFromString.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1dateSubtract](dateSubtract.md) | 否 | 否 | 是 | 是 | 是 |
| \$1dateToParts | 否 | 否 | 否 | 否 | 否 |
| [\$1dateToString](dateToString.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1dateTrunc](dateTrunc.md) | - | - | 否 | 是 | 否 |
| [\$1dayOfMonth](dayOfMonth.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1dayOfWeek](dayOfWeek.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1dayOfYear](dayOfYear.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1hour](hour.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1 isoDayOf 周](isoDayOfWeek.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1isoWeek](isoWeek.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1isoWeekYear](isoWeekYear.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1millisecond](millisecond.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1minute](minute.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1month](month.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1second](second.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1week](week.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1year](year.md) | 是 | 是 | 是 | 是 | 是 |
### 文字运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | 支持 | 是 | 是 | 是 | 是 |
### 合并运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | 支持 | 是 | 是 | 是 | 是 |
### 自然运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1natural](natural.md) | 支持 | 是 | 是 | 是 | 是 |
### 集合运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1anyElementTrue](anyElementTrue.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1setDifference](setDifference.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1setEquals](setEquals.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1setIntersection](setIntersection.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1setIsSubset](setIsSubset.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1setUnion](setUnion.md) | 是 | 是 | 是 | 是 | 是 |
| \$1setWindowFields | 否 | 否 | 否 | 否 | 否 |
### 阶段运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1bucket](bucket.md) | 否 | 否 | 否 | 是 | 否 |
| \$1bucketAuto | 否 | 否 | 否 | 否 |
| [\$1changeStream](changeStream.md) | 是 | 是 | 是 | 是 | 否 |
| [\$1collStats](collStats.md) | 否 | 是 | 是 | 是 | 否 |
| [\$1count](count.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1currentOp](currentOp.md) | 是 | 是 | 是 | 是 | 是 |
| \$1facet | 否 | 否 | 否 | 否 | 否 |
| [\$1geoNear](geoNear.md) | 是 | 是 | 是 | 是 | 是 |
| \$1graphLookup | 否 | 否 | 否 | 否 | 否 |
| [\$1group](group.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1indexStats](indexStats.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1limit](limit.md) | 是 | 是 | 是 | 是 | 是 |
| \$1listLocalSessions | 否 | 否 | 否 | 否 | 否 |
| \$1listSessions | 否 | 否 | 否 | 否 | 否 |
| [\$1lookup](lookup.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1match](match.md) | 是 | 是 | 是 | 是 | 是 |
| [merge](merge.md) | - | - | 否 | 是 | 否 |
| [\$1out](out.md) | 是 | 是 | 是 | 是 | 否 |
| \$1planCacheStats | - | - | 否 | 否 | 否 |
| [\$1project](project.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1redact](redact.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1replaceRoot](replaceRoot.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1sample](sample.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1set](set-stage.md) | - | - | 否 | 是 | 否 |
| \$1setWindowFields | - | - | 否 | 否 | 否 |
| [\$1skip](skip.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1sort](sort.md) | 是 | 是 | 是 | 是 | 是 |
| \$1sortByCount | 否 | 否 | 否 | 否 | 否 |
| \$1unionWith | - | - | 否 | 否 | 否 |
| [\$1unset](unset-stage.md) | - | - | 否 | 是 | 否 |
| [\$1unwind](unwind.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1replaceWith](replaceWith.md) | 否 | 否 | 否 | 是 | 否 |
| [\$1向量搜索](vectorSearch.md) | 否 | 否 | 否 | 是 | 否 |
### 字符串运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1indexOfBytes](indexOfBytes.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1indexOfCP](indexOfCP.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1ltrim](ltrim.md) | 否 | 是 | 是 | 是 | 否 |
| [\$1regexFind](regexFind.md) | - | - | 是 | 是 | 否 |
| [\$1regexFindAll](regexFindAll.md) | - | - | 是 | 是 | 否 |
| [\$1regexMatch](regexMatch.md) | - | - | 是 | 是 | 否 |
| [\$1replaceAll](replaceAll.md) | - | - | 是 | 是 | 否 |
| [\$1replaceOne](replaceOne.md) | - | - | 是 | 是 | 否 |
| [\$1rtrim](rtrim.md) | 否 | 是 | 是 | 是 | 否 |
| [\$1split](split.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1strcasecmp](strcasecmp.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1strLenBytes](strLenBytes.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1strLenCP](strLenCP.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1substr](substr.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1substrBytes](substrBytes.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1substrCP](substrCP.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1toLower](toLower.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1toUpper](toUpper.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1trim](trim.md) | 否 | 是 | 是 | 是 | 否 |
### 系统变量
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | 否 | 否 | 否 | 否 | 否 |
| [\$1\$1DESCEND](DESCEND.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1\$1KEEP](KEEP.md) | 是 | 是 | 是 | 是 | 是 |
| [\$1\$1PRUNE](PRUNE.md) | 是 | 是 | 是 | 是 | 是 |
| \$1\$1REMOVE | 否 | 否 | 否 | 否 | 否 |
| [\$1ROOT](ROOT.md) | 是 | 是 | 是 | 是 | 是 |
### 文本搜索运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | 否 | 否 | 是 | 是 | 否 |
| [\$1search](search.md) | 否 | 否 | 是 | 是 | 否 |
### 类型转换运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1convert](convert.md) | 否 | 是 | 是 | 是 | 是 |
| \$1isNumber | - | - | 否 | 否 | 否 |
| [\$1toBool](toBool.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toDate](toDate.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toDecimal](toDecimal.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toDouble](toDouble.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toInt](toInt.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toLong](toLong.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toObjectId](toObjectId.md) | 否 | 是 | 是 | 是 | 是 |
| [\$1toString](toString.md) | 否 | 是 | 是 | 是 | 是 |
### 变量运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | 支持 | 是 | 是 | 是 | 是 |
| [\$1map](map.md) | 是 | 是 | 是 | 是 | 是 |
### 其他运算符
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | 否 | 否 | 否 |
| [\$1rand](rand.md) | - | - | 否 | 是 | 否 |
| \$1sampleRate | - | - | 否 | 否 | 否 |
## 数据类型
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| 32-bit Integer (int) | 支持 | 是 | 是 | 是 | 是 |
| 64-bit Integer (long) | 支持 | 是 | 是 | 是 | 是 |
| 数组 | 支持 | 是 | 是 | 是 | 是 |
| 二进制数据 | 支持 | 是 | 是 | 是 | 是 |
| 布尔值 | 支持 | 是 | 是 | 是 | 是 |
| 日期 | 支持 | 是 | 是 | 是 | 是 |
| DBPointer | 否 | 否 | 否 | 否 | 否 |
| DBRefs | 否 | 否 | 否 | 否 | 否 |
| Decimal128 | 支持 | 是 | 是 | 是 | 是 |
| 双精度 | 支持 | 是 | 是 | 是 | 是 |
| JavaScript | 否 | 否 | 否 | 否 | 否 |
| JavaScript（带瞄准镜） | 否 | 否 | 否 | 否 | 否 |
| MaxKey | 是 | 是 | 是 | 是 | 是 |
| MinKey | 是 | 是 | 是 | 是 | 是 |
| Null | 支持 | 是 | 是 | 是 | 是 |
| 对象 | 支持 | 是 | 是 | 是 | 是 |
| ObjectId | 是 | 是 | 是 | 是 | 是 |
| 正则表达式 | 支持 | 是 | 是 | 是 | 是 |
| 字符串 | 是 | 是 | 是 | 是 | 是 |
| 符号 | 否 | 否 | 否 | 否 | 否 |
| Timestamp | 支持 | 是 | 是 | 是 | 是 |
| 未定义 | 否 | 否 | 否 | 否 | 否 |
## 索引和索引属性
**Topics**
+ [索引](#mongo-apis-indexes)
+ [索引属性](#mongo-apis-index-properties)
### 索引
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | 支持 | 是 | 是 | 是 | 是 |
| 2d 索引 | 否 | 否 | 否 | 否 | 否 |
| 复合索引 | 支持 | 是 | 是 | 是 | 是 |
| 哈希索引 | 否 | 否 | 否 | 否 | 否 |
| 多键索引 | 支持 | 是 | 是 | 是 | 是 |
| 单个字段索引 | 支持 | 是 | 是 | 是 | 是 |
| 文本索引 | 否 | 否 | 是 | 是 | 否 |
| 通配符 | 否 | 否 | 否 | 否 | 否 |
### 索引属性
| 命令 | 3.6 | 4.0 | 5.0 | 8.0 | 弹性集群 |
| --- | --- | --- | --- | --- | --- |
| 背景 | 支持 | 是 | 是 | 是 | 是 |
| 区分大小写 | 否 | 否 | 否 | 是 | 否 |
| 隐藏 | 否 | 否 | 否 | 否 | 否 |
| 部分 | 否 | 否 | 是 | 是 | 否 |
| 稀疏 | 支持 | 是 | 是 | 是 | 是 |
| 文本 | 否 | 否 | 是 | 是 | 否 |
| TTL | 支持 | 是 | 是 | 是 | 是 |
| Unique | 支持 | 是 | 是 | 是 | 是 |
| 向量 | 否 | 否 | 是 | 是 | 否 |
有关特定 MongoDB 运算符的详细信息，请参阅以下主题：
+ [聚合管道运算符](mongo-apis-aggregation-pipeline-operators.md)
+ [地理空间](mongo-apis-geospatial-operators.md)
+ [投影运算符](#mongo-apis-projection-operators)
+ [更新运算符](mongo-apis-update-operators.md)
# 聚合管道运算符
本节提供有关 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)
+ [\$1 isoDayOf 周](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)
+ [merge](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)
+ [\$1向量搜索](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
Amazon DocumentDB 中的`$$DESCEND`运算符是管道阶段中使用的特殊位置数组运算符。`$redact`它指示聚合管道进入当前文档并处理所有字段，无论其嵌套级别如何。
当`$redact`舞台遇到`$$DESCEND`操作员时，它将保持当前文档中的所有字段可见，并在管道中进一步处理它们。当你想根据条件有选择地编辑或修剪某些字段，同时保留文档的结构时，这很有用。
**参数**
无。
## 示例（MongoDB 外壳）
在此示例中，我们将使用带有`$$DESCEND`运算符的`$redact`舞台来有选择地显示`code`字段等于 “Reg” 的文档。
**创建示例文档**
```
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" }
]);
```
**查询示例**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**输出**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## 代码示例
要查看使用该`$$DESCEND`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$$KEEP`系统变量与聚合管道中的`$redact`阶段一起使用，以保持当前文档或字段不变，并将其包含在输出中。
**参数**
无
## 示例（MongoDB 外壳）
以下示例演示了在 Amazon DocumentDB 聚合管道`$$KEEP`中的用法。只有当访问权限等于 “公开” 时，才会保留文档，否则它们将被删除。
**创建示例文档**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**查询示例**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**输出**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## 代码示例
要查看使用该`$$KEEP`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$$PRUNE`系统变量与聚合管道中的`$redact`阶段一起使用，从结果中排除文档或嵌入式文档级别。当条件计算为时`$$PRUNE`，当前文档或子文档将从输出中删除。它通常与`$$DESCEND`（用于保留和遍历文档）或`$$KEEP`（将文档保持在所有级别）一起使用。
**参数**
无。`$$PRUNE`系统变量不带任何参数，必须与一起使用`$redact`。
## 示例（MongoDB 外壳）
以下示例演示如何`$$PRUNE`使用和将 30 岁`$redact`以上的用户排除在结果之外。
**创建示例文档**
```
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" } }
])
```
**查询示例**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**输出**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## 代码示例
要查看使用该`$$PRUNE`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$ROOT`运算符用于引用聚合管道中的整个输入文档。它允许您访问和操作完整的文档，包括其所有嵌套字段和结构。
**参数**
无
## 示例（MongoDB 外壳）
此示例演示`$ROOT`如何使用创建审核日志，该日志可捕获完整的原始文档以及有关文档处理时间的元数据。
**创建示例文档**
```
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
}
]);
```
**查询示例**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**输出**
```
[
{
_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'
}
]
```
## 代码示例
要查看使用该`$ROOT`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$abs`运算符返回数字的绝对值。它可以在聚合管道中用于对数值字段执行数学运算。
**参数**
+ `number`：将返回其绝对值的数值表达式。
## 示例（MongoDB 外壳）
此示例演示如何使用`$abs`运算符来查找数值字段的绝对值。
**创建示例文档**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**查询示例**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**输出**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## 代码示例
要查看使用该`$abs`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$add`运算符用于将数字或日期相加。它可用于对数值字段执行算术运算，或者通过向日期字段添加多个时间单位来执行日期算术。
**参数**
+ `expression1`：要添加的第一个数字或日期。
+ `expression2`：要添加的第二个数字或日期。
+ `expression3`:（可选）要添加的其他数字或日期。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$add`运算符将两个数字相加。
**创建示例文档**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**查询示例**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**输出**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
在此示例中，`$add`运算符用于为每个文档添加`a`和`b`字段的值，并将结果存储在`sum`字段中。
## 代码示例
要查看使用该`$add`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$addToSet`聚合运算符从每个组的指定表达式中返回一个由唯一值组成的数组。它在`$group`舞台中用于累积不同的值，从而自动消除重复值。
**参数**
+ `expression`：要为组中的每个文档计算的表达式。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$addToSet`运算符收集为每个客户下单的独特城市。
**创建示例文档**
```
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 }
]);
```
**查询示例**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**输出**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## 代码示例
要查看使用`$addToSet`聚合运算符的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 聚合管道中的`$addFields`阶段允许您向文档添加新的计算字段。这对于向文档中添加派生或转换后的数据非常有用。
**参数**
+ `newField`：要添加的新字段的名称。
+ `expression`：解析为新字段值的表达式。
## 示例（MongoDB 外壳）
以下示例演示`$addFields`如何使用添加新字段`TotalInventory`，该字段根据`Inventory.OnHand`和`Inventory.OrderQnty`字段计算总库存。
**创建示例文档**
```
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
}
]);
```
**查询示例**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**输出**
```
[
{
"_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
}
]
```
## 代码示例
要查看使用该`$addFields`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
4.0 版的新增内容
该`$allElementsTrue`运算符用于检查数组中所有元素的计算结果是否为真值。
**参数**
+ `expression`: 计算结果为数组的表达式。
## 示例（MongoDB 外壳）
以下示例演示了检查数组中所有元素是否为真时的用法。`$allElementsTrue`
**创建示例文档**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**查询示例**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**输出**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
在此示例中，查询检查`scores`数组中的所有元素是否都大于 0。之所以排除带的`"name": "Jane"`文档，是因为该`scores`数组包含一个 0，这是一个虚假值。
## 代码示例
要查看使用该`$allElementsTrue`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$and`聚合运算符计算多个表达式，并且`true`仅当所有表达式的计算结果均为`true`时才返回。如果有任何表达式`false`，则返回`false`。
**参数**
+ `expressions`：要计算的表达式数组。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$and`运算符来检查产品是否满足多个标准。
**创建示例文档**
```
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 }
]);
```
**查询示例**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**输出**
```
[
{ _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 }
]
```
## 代码示例
要查看使用`$and`聚合运算符的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
4.0 版的新增内容
该`$anyElementTrue`运算符用于确定数组中是否有任何元素为真。
**参数**
+ `field`: 要评估的数组字段。
## 示例（MongoDB 外壳）
以下示例演示了检查数`$anyElementTrue`组中是否有任何元素为真值的用法。
**创建示例文档**
```
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] }
])
```
**查询示例**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**输出**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## 代码示例
要查看使用该`$anyElementTrue`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$arrayElemAt`运算符允许您按索引位置从数组中检索元素。当您需要访问文档中数组字段中的特定元素时，这特别有用。
**参数**
+ `array`: 要从中检索元素的输入数组。
+ `index`：要检索的元素从零开始的索引位置。此值必须是非负整数。
## 示例（MongoDB 外壳）
在此示例中，我们将演示如何使用`$arrayElemAt`运算符从`miles`集合中的`flight_miles`数组中检索特定元素。
**创建示例文档**
```
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 ]}
]);
```
**查询示例**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**输出**
```
{ "_id" : 1, "first_mile" : 1205, "last_mile" : 880 }
{ "_id" : 2, "first_mile" : 1205, "last_mile" : 2780 }
{ "_id" : 3, "first_mile" : 1205, "last_mile" : 880 }
```
在此示例中，我们使用`$arrayElemAt`运算符为每个文档检索`flight_miles`数组的第一个和最后一个元素。
## 代码示例
要查看使用该`$arrayElemAt`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$arrayToObject`运算符与运算符相反。`$objectToArray`它接受一组键值对文档并将其转换为单个文档。当你需要将一组键值对转换回对象或文档结构时，这特别有用。
**参数**
+ `array expression`: 解析为数组的表达式。数组元素必须是包含两个字段的文档：`k`（键）和`v`（值）。
## 示例（MongoDB 外壳）
下面的示例演示了`$arrayToObject`如何使用将键值对数组转换回文档。
**创建示例文档**
```
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 } }
]);
```
**查询示例**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**输出**
```
{ "_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 } }
```
在此示例中，`$objectToArray`运算符用于将`inventory`对象转换为键值对数组。然后使用该`$arrayToObject`运算符将数组转换回文档，从而恢复原始对象结构。
## 代码示例
要查看使用该`$arrayToObject`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$avg`聚合运算符计算输入到舞台的文档中指定表达式的平均值。此运算符可用于计算一组文档中数值字段或表达式的平均值。
**参数**
+ `expression`：用于计算平均值的表达式。这可以是字段路径（例如`"$field"`）或表达式（例如`{ $multiply: ["$field1", "$field2"] }`）。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$avg`运算符计算一组学生文档的平均分数。
**创建示例文档**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**查询示例**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**输出**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## 代码示例
要查看使用该`$avg`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
8.0 版的新增内容
弹性集群不支持。
Amazon DocumentDB 中的`$bucket`聚合阶段允许您根据指定的表达式和存储桶边界将输入文档分组到存储桶中。这对于分析属于特定值范围或类别的数据非常有用。
**参数**
+ `groupBy`（必填）：指定分组依据的值的表达式。
+ `boundaries`（必填）：定义存储桶边界的双精度值数组。根据位于指定边界内的`groupBy`表达式值将文档分配给存储桶。
+ `default`（可选）：为`groupBy`表达式值不属于任何指定边界的文档输出的文字值。
+ `output`（可选）：一个对象，它指定要为每个存储桶输出的信息。您可以使用诸如`$sum`、`$avg``$min`、和之类的累加器运算符`$max`来计算每个存储桶的聚合。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$bucket`舞台按价格区间对销售数据进行分组。
**创建示例文档**
```
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") }
]);
```
**查询示例**
```
db.sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
])
```
**输出**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## 代码示例
要查看使用该`$bucket`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
4.0 版的新增内容
与 MongoDB 一样，Amazon DocumentDB 中的`$ceil`运算符将数字向上舍入到最接近的整数。当您需要对数值字段执行数学运算并确保结果为整数时，这很有用。
**参数**
+ `expression`: 要向上舍入的数值表达式。
## 示例（MongoDB 外壳）
此示例演示如何使用`$ceil`运算符向上舍入数值字段。
**创建示例文档**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**查询示例**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**输出**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## 代码示例
要查看使用该`$ceil`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
弹性集群不支持。
`$changeStream`聚合阶段会打开更改流游标，以监视集合的实时更改。当进行插入、更新、替换或删除操作时，它会返回更改事件文档。
**参数**
+ `fullDocument`：指定是否返回完整文档以进行更新操作。选项有 `default` 或 `updateLookup`。
+ `resumeAfter`: 可选。恢复令牌以从变更流中的特定点继续。
+ `startAtOperationTime`: 可选。开始变更流的时间戳。
+ `allChangesForCluster`: 可选。布尔值。何时`true`，监视集群中的所有更改（对于管理员数据库）。当`false`（默认）时，仅监视指定的集合。
## 示例（MongoDB 外壳）
以下示例演示了如何使用`$changeStream`舞台来监视集合的更改。
**查询示例**
```
// 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()));
}
```
**输出**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## 代码示例
要查看使用`$changeStream`聚合阶段的代码示例，请选择要使用的语言对应的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$cmp`运算符用于比较两个值并返回一个表示其相对顺序的整数值。它是一个比较运算符，它比较两个表达式并分别返回 -1、0 或 1 的整数值，具体取决于第一个值是小于、等于还是大于第二个值。
**参数**
+ `expression1`：第一个要比较的表达式。
+ `expression2`：第二个要比较的表达式。
## 示例（MongoDB 外壳）
以下示例演示如何使用运`$cmp`算符比较两个数值。
**创建示例文档**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**查询示例**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**输出**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
在此示例中，`$cmp`运算符比较每个文档的`value1`和`value2`字段。结果是：
```
- `$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).
```
## 代码示例
要查看使用该`$cmp`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ Node.js ]
以下是在带有`mongodb`驱动程序的 Node.js 应用程序中使用`$cmp`运算符的示例：
```
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 ]
以下是在带`pymongo`驱动程序的 Python 应用程序中使用`$cmp`运算符的示例：
```
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()
```
Node.js 和 Python 示例的输出都将与 MongoDB Shell 示例的输出相同：
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
4.0 版的新增内容
Amazon DocumentDB 中的`$collStats`聚合阶段提供有关指定集合的统计信息，类似于 MongoDB 外壳中的`db.collection.stats()`命令。此阶段可用于检索有关集合的信息，例如文档数量、集合的总大小以及各种性能指标。
**参数**
+ `latencyStats`:（可选）指定收集延迟统计信息的选项的文档。Amazon DocumentDB 不支持此参数。
+ `recordStats`:（可选）指定收集记录统计信息的选项的文档。Amazon DocumentDB 不支持此参数。
+ `queryExecStats`:（可选）一个文档，它指定了用于收集查询执行统计信息的选项。Amazon DocumentDB 不支持此参数。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$collStats`聚合阶段检索有关`db`数据库`test`中名为的集合的统计信息。
**创建示例文档**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**查询示例**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**输出**
```
{
"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)
}
```
## 代码示例
要查看使用该`$collStats`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ Node.js ]
以下是如何使用官方 MongoDB Node.js 驱动程序在 Node.js 应用程序中使用`$collStats`聚合阶段的示例：
```
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 ]
以下是如何使用 PyMongo 驱动程序在 Python 应用程序中使用`$collStats`聚合阶段的示例：
```
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
Amazon DocumentDB 中的`$concat`聚合运算符连接（或组合）文档中的多个字符串，生成一个可以返回给应用程序的字符串。这减少了在应用程序中完成的工作，因为字符串操作是在数据库级别执行的。
**参数**
+ `expression1`: 要连接的第一个字符串。
+ `expression2`: 要连接的第二个字符串。
+ `...`：要连接的其他字符串（可选）。
## 示例（MongoDB 外壳）
在此示例中，我们将用户的名字和姓氏连接起来生成每个人的全名。
**创建示例文档**
```
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"}
])
```
**查询示例**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**输出**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## 代码示例
要查看使用该`$concat`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$concatArrays`聚合运算符用于将两个或多个数组连接成一个数组。当您需要将多个数据数组组合成一个数组以进行进一步处理或分析时，这可能很有用。
**参数**
+ `array1`: 第一个要连接的数组。
+ `array2`: 要连接的第二个数组。
+ `[array3, ...]`:（可选）要连接的其他数组。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$concatArrays`运算符将两个数组合并为一个数组。
**创建示例文档**
```
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"]
}
]);
```
**查询示例**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**输出**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## 代码示例
要查看使用该`$concatArrays`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$cond`运算符用于计算条件表达式并返回两个可能的结果表达式之一。
**参数**
+ `if`: 要计算的布尔表达式。
+ `then`：如果表达式为真则返回的`if`表达式。
+ `else`：如果表达式为假则返回的`if`表达式。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$cond`运算符根据一个人的年龄返回值。
**创建示例文档**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**查询示例**
```
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"
}
}
}
}
}
}
])
```
**输出**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## 代码示例
要查看使用该`$cond`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
4.0 版的新增内容
Amazon DocumentDB 中的`$convert`运算符用于将值从一种数据类型转换为另一种数据类型。当您需要对不同类型的数据执行操作时，此运算符很有用，例如将字符串转换为数字或将日期转换为时间戳。
**参数**
+ `to`：要将值转换为的目标数据类型。支持的值有 `"string"`、`"double"`、`"long"`、`"int"`、`"date"` 和 `"boolean"`。
+ `from`：该值的当前数据类型。如果未指定，Amazon DocumentDB 将尝试自动检测数据类型。
+ `onError`:（可选）转换失败时要返回的值。可以是特定值或以下特殊值之一：`"null"``"zerofill"`、或`"error"`。
+ `onNull`:（可选）如果输入值为，则返回的值`null`。可以是特定值或以下特殊值之一：`"null"``"zerofill"`、或`"error"`。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$convert`运算符将字符串值转换为日期。
**创建示例文档**
```
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" }
]);
```
**查询示例**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**输出**
```
[
{ "_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 }
]
```
## 代码示例
要查看使用该`$convert`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$count`聚合阶段用于计算进入该阶段的文档数量。它通常用作聚合管道的最后一个阶段，用于返回与前几个阶段匹配的文档总数。
**参数**
+ `field`：要计数的字段。此参数是可选的，如果未提供，则该阶段将计算输入文档的总数。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$count`舞台获取集合中的文档总数。
**创建示例文档**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**查询示例**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**输出**
```
{ "total" : 4 }
```
该示例汇总了`users`集合，并使用`$count`舞台来计算文档的总数。
## 代码示例
要查看使用该`$count`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$currentOp`聚合阶段返回有关数据库中当前正在运行的操作的信息。此阶段对于监控聚合管道中的活动查询和操作非常有用。
**参数**
+ `allUsers`（可选）：如果设置为`true`，则返回所有用户的操作。默认值为 `false`。
+ `idleConnections`（可选）：设置为时`true`，包括空闲连接。默认值为 `false`。
+ `idleCursors`（可选）：如果设置为`true`，则包含有关空闲光标的信息。默认值为 `false`。
+ `idleSessions`（可选）：如果设置为`true`，则包含有关空闲会话的信息。默认值为 `true`。
+ `localOps`（可选）：设置为时`true`，包括本地操作。默认值为 `false`。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$currentOp`聚合阶段检索有关活动读取操作的信息。
**查询示例**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**输出**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## 代码示例
要查看使用该`$currentOp`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
5.0 版的新增内容
Amazon DocumentDB 中的`$dateAdd`聚合运算符允许您在日期和时间值中添加持续时间。
**参数**
+ `date`：用于添加持续时间的日期和时间值。
+ `duration`：要添加到该`date`值中的持续时间。可以将其指定为带有`years`、、、、`months``weeks``days``hours``minutes`、和键的对象`seconds`。
+ `timezone`:（可选）执行日期添加时要使用的时区。如果未指定，则使用 Amazon DocumentDB 集群的默认时区。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$dateAdd`运算符为日期添加 2 天零 12 小时。
**创建示例文档**
```
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") }
]);
```
**查询示例**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**输出**
```
[
{
"_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)"
}
]
```
## 代码示例
要查看使用该`$dateAdd`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
5.0 版的新增内容
弹性集群不支持。
`$dateDiff`聚合运算符以指定单位计算两个日期之间的差。它返回开始日期和结束日期之间跨越单位边界的数量。
**参数**
+ `startDate`：开始日期表达式。
+ `endDate`：结束日期表达式。
+ `unit`: 差异的时间单位。支持的单位是`year`、`quarter`、`month`、`week`、`day`、`hour`、`minute`、`second`、和`millisecond`。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$dateDiff`运算符来计算从下单到交货之间的天数。
**创建示例文档**
```
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")
}
]);
```
**查询示例**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**输出**
```
[
{
_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
}
]
```
## 代码示例
要查看使用该`$dateDiff`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$dateFromString`聚合运算符允许您将日期时间字符串转换为日期对象。当您的数据存储为字符串但需要对数据执行基于日期的操作时，这很有用。
**参数**
+ `dateString`：表示日期和时间的字符串。
+ `format`:（可选）指定格式的字符串`dateString`。如果未提供，Amazon DocumentDB 将尝试以 ISO-8601 格式解析字符串。
+ `timezone`:（可选）指定时区的字符串。如果未提供，Amazon DocumentDB 将使用服务器的时区。
+ `onError`:（可选）指定转换失败时要采取的操作。可能的值是`'error'`（默认值，会引发错误）、`'null'`（返回`null`）或`'replace'`（用`onErrorMessage`选项中指定的替换字符串替换值）。
+ `onErrorMessage`:（可选）如果设置`onError`为`'replace'`，则此选项指定替换字符串。
## 示例（MongoDB 外壳）
以下示例演示了`$dateFromString`如何使用在 Amazon DocumentDB 中将日期字符串转换为日期对象。
**创建示例文档**
```
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"}
]);
```
**查询示例**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**输出**
```
[
{
"_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")
}
]
```
## 代码示例
要查看使用该`$dateFromString`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
5.0 版的新增内容
Amazon DocumentDB 中的`$dateSubtract`聚合运算符允许您从日期值中减去指定的持续时间。
**参数**
+ `date`：解析为日期或时间戳的日期表达式。
+ `subtrahend`：一个持续时间表达式，它指定要从表达`date`式中减去的时间长度。
+ `unit`：一个字符串，它指定`subtrahend`表达式的时间单位。支持的单位为 “年”、“季度”、“月”、“周”、“天”、“小时”、“分钟”、“秒” 和 “毫秒”。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$dateSubtract`运算符从当前日期开始计算一年前的日期。
**创建示例文档**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**查询示例**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**输出**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## 代码示例
要查看使用该`$dateSubtract`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$dateToString`聚合运算符用于将日期或时间戳值转换为字符串表示形式。当您需要以特定方式格式化日期和时间以进行显示或进一步处理时，这很有用。
**参数**
+ `date`：要转换为字符串的日期或时间戳值。
+ `format`：一个字符串，它指定应以何种格式表示日期。格式字符串可以包含各种格式说明符，例如`%Y`四位数年份、`%m`两位数月份、`%d`两位数月份的日期等。
+ `timezone`:（可选）用于转换的时区。如果未指定，则使用托管 Amazon DocumentDB 集群的服务器的时区。
+ `onNull`:（可选）如果`date`参数为，则返回的值`null`。
## 示例（MongoDB 外壳）
以下示例演示了如何使用运`$dateToString`算符来格式化`missionLog`集合的`logDate`字段。
**创建示例文档**
```
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") }
]);
```
**查询示例**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**输出**
```
[
{
"_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"
}
]
```
## 代码示例
要查看使用该`$dateToString`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ Node.js ]
以下是在 Node.js 应用程序中使用`$dateToString`运算符的示例：
```
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 ]
以下是在 Python 应用程序中使用`$dateToString`运算符的示例：
```
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
8.0 版的新增内容
弹性集群不支持。
Amazon DocumentDB 中的`$dateTrunc`聚合运算符将日期截断为指定单位。
**参数**
+ `date`：解析为日期或时间戳的日期表达式。
+ `unit`：一个字符串，它为子集表达式指定时间单位。支持的单位是`year`、`quarter`、`month`、`week`、`day`、`hour`、`minute`、`second`、和`millisecond`。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$dateTrunc`运算符将日期截断为小时。
**创建示例文档**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**查询示例**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**输出**
```
[
{
_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')
}
]
```
## 代码示例
要查看使用该`$dateTrunc`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$dayOfMonth`聚合运算符检索给定日期的当月中的某一天（从 1 到 31）。此运算符可用于对文档中的日期字段进行分组、筛选或提取月份中的某一天。
**参数**
+ `date expression`：日期表达式可以是文档中的日期字段、日期对象或日期字符串。
## 示例（MongoDB 外壳）
此示例演示如何使用`$dayOfMonth`运算符从文档的日期字段中提取月份中的某一天。
**创建示例文档**
```
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") }
]);
```
**查询示例**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**输出**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## 代码示例
要查看使用该`$dayOfMonth`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$dayOfWeek`运算符从给定的日期字段中提取一周中的某一天。它以 1（星期日）和 7（星期六）之间的数字返回一周中的某一天，这与 MongoDB 中的行为相同。
**参数**
+ `date field`: 要从中提取一周中的某天的日期字段。
## 示例（MongoDB 外壳）
此示例演示如何使用`$dayOfWeek`运算符从`weather`集合中的`date`字段中提取星期几。
**创建示例文档**
```
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")
}
]);
```
**查询示例**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**输出**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## 代码示例
要查看使用该`$dayOfWeek`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$dayOfYear`运算符以 1 到 366 之间的数字返回日期的一年中的某一天（非闰年为 365）。
**参数**
+ `expression`：要从中提取一年中的某天的日期字段或表达式。
## 示例（MongoDB 外壳）
此示例演示如何使用`$dayOfYear`运算符从 Amazon DocumentDB 集合中的日期字段中提取一年中的某一天。
**创建示例文档**
```
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")
}
])
```
**查询示例**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**输出**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## 代码示例
要查看使用该`$dayOfYear`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 聚合管道中的`$divide`运算符用于将一个数字除以另一个数字。它是对文档中的数值字段执行数学运算的有用运算符。
**参数**
+ `numerator`：股息或要分割的数字。
+ `denominator`: 除数或要除以的数字。
## 示例（MongoDB 外壳）
此示例演示如何使用`$divide`运算符根据员工的年薪和每年的工作时数计算员工的小时工资。
**创建示例文档**
```
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 }
]);
```
**查询示例**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**输出**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## 代码示例
要查看使用该`$divide`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$eq`聚合运算符比较两个值，`true`如果它们相等，则返回，否则返回`false`。
**参数**
+ `expression1`：要比较的第一个值。
+ `expression2`: 第二个要比较的值。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$eq`运算符来检查产品数量是否与目标值匹配。
**创建示例文档**
```
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 }
]);
```
**查询示例**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**输出**
```
[
{ _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 }
]
```
## 代码示例
要查看使用`$eq`聚合运算符的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
4.0 版的新增内容
Amazon DocumentDB 中的`$exp`运算符允许您将常数 e 提高到给定的数字。
**参数**
+ `expression`：要计算的表达式。这可以是任何有效的聚合表达式，包括字段引用、算术运算和其他聚合阶段。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$exp`运算符来查找`quantity`字段大于该`price`字段的所有文档。
**创建示例文档**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**查询示例**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**输出**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## 代码示例
要查看使用该`$exp`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$filter`运算符用于将筛选表达式应用于数组的每个元素，并返回一个仅包含符合指定条件的元素的数组。当您需要对文档中的数组字段执行复杂的筛选操作时，此运算符很有用。
**参数**
+ `input`: 要筛选的数组字段。
+ `as`：用于`cond`表达式中数组中每个`input`元素的变量名。
+ `cond`: 布尔表达式，用于确定是否应将给定元素包含在输出数组中。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$filter`运算符来预测每个订单的客户，并创建一个新的数组字段 paidItems，其中仅包含价格大于 15 的 items 数组中的商品。从本质上讲，它会筛选每个订单的商品，仅包括价格超过15的产品。
**创建示例文档**
```
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 }
]}
]);
```
**查询示例**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**输出**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## 代码示例
要查看使用该`$filter`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
5.0 版的新增内容。
弹性集群不支持。
Amazon DocumentDB 中的`$first`操作员返回一组分组文档中的第一个文档。它通常在聚合管道中用来检索与特定条件匹配的第一个文档。
**参数**
+ `expression`：作为每个组中第一个值返回的表达式。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$first`运算符检索聚合期间每个类别遇到的第一个项目值。
注意：根据管道中文档的当前顺序`$first`返回第一个文档。为了确保特定的顺序（例如按日期、价格等），应在`$sort`舞台之前使用`$group`舞台。
**创建示例文档**
```
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" }
]);
```
**查询示例**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**输出**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## 代码示例
要查看使用该`$first`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
4.0 版的新增内容。
Amazon DocumentDB 中的`$floor`运算符返回小于或等于指定数字的最大整数。此运算符对于向下舍入数值很有用。
**参数**
+ `expression`: 要向下舍入的数值表达式。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$floor`运算符将十进制值向下舍入到最接近的整数。
**创建示例文档**
```
db.numbers.insertOne({ value: 3.14 });
```
**查询示例**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**输出**
```
{ "floored" : 3 }
```
## 代码示例
要查看使用该`$floor`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$geoNear`聚合阶段按接近指定点的顺序返回文档。它计算与该点的距离，并将该距离包括在输出文档中。
**参数**
+ `near`：计算距离的起点，指定为 geoJSON 或传统坐标。
+ `distanceField`：用于存储计算距离的字段名称。
+ `spherical`: 表示是否使用球面几何图形的布尔值（GeoJSON 点是必需的）。
+ `maxDistance`: 可选。距离中心点的最大距离。
+ `minDistance`: 可选。距离中心点的最小距离。
+ `query`: 可选。要应用的其他筛选条件。
+ `limit`: 可选。要返回的最大文档数。
+ `key`: 可选。存在多个地理空间索引时用于地理空间查询的字段。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$geoNear`舞台查找离给定位置最近的门店。
**创建示例文档**
```
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] } }
]);
```
**查询示例**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**输出**
```
[
{ _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 }
]
```
## 代码示例
要查看使用`$geoNear`聚合阶段的代码示例，请选择要使用的语言对应的选项卡：
------
#### [ 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
Amazon DocumentDB 中的`$group`聚合阶段允许您按指定的表达式对文档进行分组，并对分组的数据执行各种累积操作。这对于诸如根据分组数据计算总计、平均值或其他统计数据之类的任务非常有用。
**参数**
+ `_id`：指定对输入文档进行分组时应采用的表达式。这可以是字段名、计算表达式或两者的组合。
+ `accumulator expressions`:（可选）应应用于分组数据的一个或多个累加器表达式。这些表达式使用上面提到的累加器运算符。
## 示例（MongoDB 外壳）
以下示例按城市对客户进行分组，并计算每个城市的总订单金额。
**创建示例文档**
```
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 }] }
]);
```
**查询示例**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**输出**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## 代码示例
要查看使用该`$group`命令的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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
`$gt`聚合运算符比较两个值，`true`如果第一个值大于第二个值，则返回，否则返回`false`。
**参数**
+ `expression1`：要比较的第一个值。
+ `expression2`: 第二个要比较的值。
## 示例（MongoDB 外壳）
以下示例演示如何使用`$gt`运算符来识别超过价格阈值的产品。
**创建示例文档**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**查询示例**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**输出**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## 代码示例
要查看使用`$gt`聚合运算符的代码示例，请选择要使用的语言的选项卡：
------
#### [ 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://