Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# APIsMongoDB, operaciones y tipos de datos compatibles en Amazon DocumentDB
Amazon DocumentDB (compatible con MongoDB) es un servicio de base de datos de documentos rápido, completamente administrado, de alta disponibilidad y escala ajustable que admite cargas de trabajo de MongoDB. Amazon DocumentDB es compatible con MongoDB 3.6, 4.0, 5.0 y 8.0. APIs Esta sección muestra la funcionalidad admitida. Para obtener asistencia sobre el uso de APIs MongoDB y los controladores, consulte los foros de la comunidad de MongoDB. Para obtener asistencia con el servicio Amazon DocumentDB, póngase en contacto con el equipo de AWS soporte correspondiente. Para las diferencias funcionales entre Amazon DocumentDB y MongoDB, consulte [Diferencias funcionales: Amazon DocumentDB y MongoDB](functional-differences.md).
Los comandos y operadores de MongoDB que son solo para uso interno o que no se aplican a un servicio completamente administrado no se admiten ni están incluidos en la lista de funcionalidades admitidas.
Hemos agregado más de 50 capacidades adicionales desde el lanzamiento y seguiremos trabajando con versiones anteriores de nuestros clientes para ofrecer las capacidades que necesitan. Para obtener información sobre los lanzamientos más recientes, consulte [Anuncios de Amazon DocumentDB](https://aws.amazon.com/documentdb/resources/).
Si hay una característica que no es compatible que desea que creemos, háganoslo saber enviando un correo electrónico con su ID de cuenta, las características solicitadas y el caso de uso al [equipo de servicio de Amazon DocumentDB](mailto:documentdb-feature-request@amazon.com).
+ [Comandos de la base de datos](#mongo-apis-database)
+ [Operadores de consulta y proyección](#mongo-apis-query)
+ [Operadores de actualización](#mongo-apis-update)
+ [Geospatial (Geoespacial)](#mongo-apis-geospatial)
+ [Métodos de cursor](#mongo-apis-cursor)
+ [Operadores de canalización de agregación](#mongo-apis-aggregation-pipeline)
+ [Tipos de datos](#mongo-apis-data-types)
+ [Índices](#mongo-apis-indexes)
## Comandos de la base de datos
**Topics**
+ [Comandos administrativos](#mongo-apis-dababase-administrative)
+ [Agregación](#mongo-apis-dababase-aggregation)
+ [Autenticación](#mongo-apis-dababase-authentication)
+ [Comandos de diagnóstico](#mongo-apis-dababase-diagnostics)
+ [Operaciones de consulta y escritura](#mongo-apis-dababase-query-write)
+ [Comandos para la administración de roles](#mongo-apis-database-role-management)
+ [Comandos de sesiones](#mongo-apis-dababase-sessions)
+ [Administración de usuarios](#mongo-apis-dababase-user-management)
+ [Comandos de partición](#mongo-apis-dababase-sharding)
### Comandos administrativos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| Colecciones limitadas | No | No | No | No | No |
| cloneCollectionAsTapado | No | No | No | No | No |
| collMod | Parcial | Parcial | Parcial | Parcial | Parcial |
| CollMod: expireAfterSeconds | Sí | Sí | Sí | Sí | Sí |
| convertToCapped | No | No | No | No | No |
| copydb | No | No | No | No | No |
| crear | Sí | Sí | Sí | Sí | Sí |
| createView | No | No | No | Sí | No |
| createIndexes | Sí | Sí | Sí | Sí | Sí |
| currentOp | Sí | Sí | Sí | Sí | Sí |
| drop | Sí | Sí | Sí | Sí | Sí |
| dropDatabase | Sí | Sí | Sí | Sí | Sí |
| dropIndexes | Sí | Sí | Sí | Sí | Sí |
| filemd5 | No | No | No | No | No |
| getAuditConfig | No | Sí | Sí | Sí | No |
| killCursors | Sí | Sí | Sí | Sí | Sí |
| killOp | Sí | Sí | Sí | Sí | Sí |
| listCollections\$1 | Sí | Sí | Sí | Sí | Sí |
| listDatabases | Sí | Sí | Sí | Sí | Sí |
| listIndexes | Sí | Sí | Sí | Sí | Sí |
| reIndex | No | No | Sí | Sí | No |
| renameCollection | Sí | Sí | Sí | Sí | No |
| setAuditConfig | No | Sí | Sí | Sí | No |
\$1 No se admite la clave `type` de la opción de filtro.
### Agregación
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| aggregate | Sí | Sí | Sí | Sí | Sí |
| count | Sí | Sí | Sí | Sí | Sí |
| distinct | Sí | Sí | Sí | Sí | Sí |
| mapReduce | No | No | No | Sí | No |
### Autenticación
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| authenticate | Sí | Sí | Sí | Sí | Sí |
| logout | Sí | Sí | Sí | Sí | Sí |
### Comandos de diagnóstico
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| buildInfo | Sí | Sí | Sí | Sí | Sí |
| collStats | Sí | Sí | Sí | Sí | Sí |
| connPoolStats | No | No | No | No | No |
| connectionStatus | Sí | Sí | Sí | Sí | Sí |
| dataSize | Sí | Sí | Sí | Sí | Sí |
| dbHash | No | No | No | No | No |
| dbStats | Sí | Sí | Sí | Sí | Sí |
| explain | Sí | Sí | Sí | Sí | Sí |
| explain: executionStats | Sí | Sí | Sí | Sí | Sí |
| Características de | No | No | No | No | No |
| hostInfo | Sí | Sí | Sí | Sí | Sí |
| listCommands | Sí | Sí | Sí | Sí | Sí |
| profiler | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | No |
| serverStatus | Sí | Sí | Sí | Sí | Sí |
| top | Sí | Sí | Sí | Sí | Sí |
### Operaciones de consulta y escritura
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| Change streams | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sí](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | No |
| eliminar | Sí | Sí | Sí | Sí | Sí |
| find | Sí | Sí | Sí | Sí | Sí |
| findAndModify | Sí | Sí | Sí | Sí | Sí |
| getLastError | No | No | No | No | No |
| getMore | Sí | Sí | Sí | Sí | Sí |
| getPrevError | No | No | No | No | No |
| GridFS | Sí | Sí | Sí | Sí | No |
| inserción | Sí | Sí | Sí | Sí | Sí |
| parallelCollectionScan | No | No | No | No | No |
| resetError | No | No | No | No | No |
| actualización | Sí | Sí | Sí | Sí | Sí |
| ReplaceOne | Sí | Sí | Sí | Sí | Sí |
### Comandos para la administración de roles
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| createRole | Sí | Sí | Sí | Sí | No |
| dropAllRolesFromDatabase | Sí | Sí | Sí | Sí | No |
| dropRole | Sí | Sí | Sí | Sí | No |
| grantRolesToRol | Sí | Sí | Sí | Sí | No |
| revokeRolesFromRol | Sí | Sí | Sí | Sí | No |
| revokePrivilegesFromRol | Sí | Sí | Sí | Sí | No |
| rolesInfo | Sí | Sí | Sí | Sí | No |
| updateRole | Sí | Sí | Sí | Sí | No |
### Comandos de sesiones
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| Abortar transacción | No | Sí | Sí | Sí | No |
| commitTransaction | No | Sí | Sí | Sí | No |
| Finalizar sesiones | No | No | No | No | No |
| killAllSessions | No | Sí | Sí | Sí | No |
| killAllSessionsByPattern | No | No | No | No | No |
| Mata a Sessions | No | Sí | Sí | Sí | No |
| Actualizar sesiones | No | No | No | No | No |
| StartSession | No | Sí | Sí | Sí | No |
### Administración de usuarios
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| createUser | Sí | Sí | Sí | Sí | Sí |
| dropAllUsersFromDatabase | Sí | Sí | Sí | Sí | Sí |
| dropUser | Sí | Sí | Sí | Sí | Sí |
| grantRolesToUser | Sí | Sí | Sí | Sí | Sí |
| revokeRolesFromUser | Sí | Sí | Sí | Sí | Sí |
| updateUser | Sí | Sí | Sí | Sí | Sí |
| usersInfo | Sí | Sí | Sí | Sí | Sí |
### Comandos de partición
| Comando | Clúster elástico |
| --- | --- |
| abortReshardCollection | No |
| Añadir partición | No |
| addShardToZona | No |
| balancerCollectionStatus | No |
| Balancer Start | No |
| Estado del equilibrador | No |
| BalancerStop | No |
| checkShardingIndex | No |
| clearJumboFlag | No |
| cleanupOrphaned | No |
| cleanupReshardCollection | No |
| commitReshardCollection | No |
| Habilitar Sharding | Sí |
| flushRouterConfig | No |
| getShardMap | No |
| getShardVersion | No |
| isdbgrid | No |
| ListShards | No |
| Clave mediana | No |
| Mueva Chunk | No |
| Mueva el modo principal | No |
| MergeChunks | No |
| refineCollectionShardClave | No |
| Elimina Hard | No |
| removeShardFromZona | No |
| Colección ReShard | No |
| setAllowMigrations | No |
| setShardVersion | No |
| Colección Shard | Sí |
| Estado de partición | No |
| dividir | No |
| Vector dividido | No |
| UnsetSharding | No |
| updateZoneKeyAlcance | No |
## Operadores de consulta y proyección
**Topics**
+ [Operadores de matrices](#mongo-apis-query-array-operators)
+ [Operadores Bitwise](#mongo-apis-query-bitwise-operators)
+ [Operador de comentarios](#mongo-apis-query-comment-operator)
+ [Operadores de comparación](#mongo-apis-query-comparison-operators)
+ [Operadores de elementos](#mongo-apis-query-element-operators)
+ [Operadores de consulta de evaluación](#mongo-apis-query-evaluation-operators)
+ [Logical operators (Operadores lógicos)](#mongo-apis-query-logical-operators)
+ [Operadores de proyección](#mongo-apis-projection-operators)
### Operadores de matrices
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1elemMatch](elemMatch.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1size](size-query.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores Bitwise
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1bitsAnySet](bitsAnySet.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1bitsAllClear](bitsAllClear.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1bitsAnyClear](bitsAnyClear.md) | Sí | Sí | Sí | Sí | Sí |
### Operador de comentarios
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de comparación
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1gt](gt.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1gte](gte.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1in](in.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1lt](lt.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1lte](lte.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1ne](ne.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1nin](nin.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de elementos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1type](type.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de consulta de evaluación
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | No | Sí | Sí | Sí | No |
| [\$1jsonSchema](jsonSchema.md) | No | Sí | Sí | Sí | No |
| [\$1mod](mod-query.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1regex](regex.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1text](text.md) | No | No | Sí | Sí | No |
| \$1where | No | No | No | No | No |
### Logical operators (Operadores lógicos)
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1nor](nor.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1not](not.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1or](or.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de proyección
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1elemMatch](elemMatch.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1meta](meta.md) | No | No | Sí | Sí | No |
| [\$1slice](slice-projection.md) | Sí | Sí | Sí | Sí | Sí |
## Operadores de actualización
**Topics**
+ [Operadores de matrices](#mongo-apis-update-array)
+ [Operadores Bitwise](#mongo-apis-update-bitwise)
+ [Operadores de campo](#mongo-apis-update-field)
+ [Modificadores de actualización](#mongo-apis-update-modifiers)
### Operadores de matrices
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1[]](dollarBrackets-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1[]](dollarIdentifier-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1addToSet](addToSet.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1pop](pop.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1pullAll](pullAll.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1pull](pull.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1push](push.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores Bitwise
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de campo
| Operador | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1inc](inc.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1max](max-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1min](min-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1mul](mul.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1rename](rename.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1set](set-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1setOnInsert](setOnInsert.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1unset](unset-update.md) | Sí | Sí | Sí | Sí | Sí |
### Modificadores de actualización
| Operador | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1position](position.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1slice](slice-update.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1sort](sort-update.md) | Sí | Sí | Sí | Sí | Sí |
## Geospatial (Geoespacial)
### Especificadores de geometría
| Selectores de consultas | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1box | No | No | No | No | No |
| \$1center | No | No | No | No | No |
| \$1centerSphere | No | No | No | No | No |
| [\$1geometry](geometry.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1maxDistance](maxDistance.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1minDistance](minDistance.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1nearSphere](nearSphere.md) | Sí | Sí | Sí | Sí | Sí |
| \$1polygon | No | No | No | No | No |
| \$1uniqueDocs | No | No | No | No | No |
### Selectores de consultas
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1geoWithin](geoWithin.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1near](near.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1nearSphere](nearSphere.md) | Sí | Sí | Sí | Sí | Sí |
| \$1polygon | No | No | No | No | No |
| \$1uniqueDocs | No | No | No | No | No |
## Métodos de cursor
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | Sí | Sí | Sí | Sí | Sí |
| cursor.close() | Sí | Sí | Sí | Sí | Sí |
| cursor.collation() | No | No | No | Sí | No |
| cursor.comment() | Sí | Sí | Sí | Sí | Sí |
| cursor.count() | Sí | Sí | Sí | Sí | Sí |
| cursor.explain() | Sí | Sí | Sí | Sí | No |
| cursor.forEach() | Sí | Sí | Sí | Sí | Sí |
| cursor.hasNext() | Sí | Sí | Sí | Sí | Sí |
| cursor.hint() | Sí | Sí | Sí | Sí | Sí\$1 |
| cursor.isClosed() | Sí | Sí | Sí | Sí | Sí |
| cursor.isExhausted() | Sí | Sí | Sí | Sí | No |
| cursor.itcount() | Sí | Sí | Sí | Sí | No |
| cursor.limit() | Sí | Sí | Sí | Sí | No |
| cursor.map() | Sí | Sí | Sí | Sí | No |
| cursor.max() | No | No | No | No | No |
| cursor.maxScan() | Sí | Sí | Sí | Sí | No |
| cursor.maxTimeMS() | Sí | Sí | Sí | Sí | No |
| cursor.min() | No | No | No | No | No |
| cursor.next() | Sí | Sí | Sí | Sí | Sí |
| cursor. noCursorTimeout() | No | No | No | No | No |
| cursor. objsLeftInBatch () | Sí | Sí | Sí | Sí | No |
| cursor.pretty() | Sí | Sí | Sí | Sí | No |
| cursor.readConcern() | Sí | Sí | Sí | Sí | No |
| cursor.readPref() | Sí | Sí | Sí | Sí | No |
| cursor.returnKey() | No | No | No | No | No |
| cursor. showRecordId() | No | No | No | No | No |
| cursor.size() | Sí | Sí | Sí | Sí | No |
| cursor.skip() | Sí | Sí | Sí | Sí | No |
| cursor.sort() | Sí | Sí | Sí | Sí | No |
| cursor.tailable() | No | No | No | No | No |
| cursor.toArray() | Sí | Sí | Sí | Sí | No |
\$1 El índice `hint` es compatible con las expresiones de índice. Por ejemplo, `db.foo.find().hint({x:1})`.
## Operadores de canalización de agregación
**Topics**
+ [Expresiones de acumulación](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [Operadores aritméticos](#mongo-apis-aggregation-pipeline-arithmetic)
+ [Operadores de matrices](#mongo-apis-aggregation-pipeline-array)
+ [Operadores booleanos](#mongo-apis-aggregation-pipeline-boolean)
+ [Operadores de comparación](#mongo-apis-aggregation-pipeline-comparison)
+ [Operadores de expresiones condicionales](#mongo-apis-aggregation-pipeline-conditional)
+ [Operador de tipos de datos](#mongo-apis-aggregation-pipeline-data-type)
+ [Operador de tamaño de datos](#mongo-apis-aggregation-pipeline-data-size)
+ [Operadores de fechas](#mongo-apis-aggregation-pipeline-date)
+ [Operador literal](#mongo-apis-aggregation-pipeline-literal)
+ [Operador de combinación](#mongo-apis-aggregation-pipeline-merge)
+ [Operador natural](#mongo-apis-aggregation-pipeline-natural)
+ [Operadores de establecimiento](#mongo-apis-aggregation-pipeline-set)
+ [Operadores de etapa](#mongo-apis-aggregation-pipeline-stage)
+ [Operadores de cadena](#mongo-apis-aggregation-pipeline-string)
+ [Variables del sistema](#mongo-apis-aggregation-pipeline-system-variables)
+ [Operador de búsqueda de texto](#mongo-apis-aggregation-pipeline-text-search)
+ [Operadores de conversión de tipos](#mongo-apis-aggregation-pipeline-type)
+ [Operadores de variables](#mongo-apis-aggregation-pipeline-variable)
+ [Operadores misceláneos](#mongo-apis-aggregation-pipeline-misc)
### Expresiones de acumulación
| Expression | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1 acumulador | - | - | No | No | No |
| [\$1addToSet](addToSet-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1avg](avg.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1count](count.md) | - | - | No | No | No |
| \$1covariancePop | No | No | No | No | No |
| \$1covarianceSamp | No | No | No | No | No |
| \$1denseRank | No | No | No | No | No |
| \$1derivative | No | No | No | No | No |
| \$1documentNumber | No | No | No | No | No |
| \$1expMovingAvg | No | No | No | No | No |
| [\$1first](first.md) | Sí | Sí | Sí | Sí | Sí |
| \$1integral | No | No | No | No | No |
| [\$1last](last.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1max](max.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1min](min.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1push](push-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| \$1rank | No | No | No | No | No |
| \$1shift | No | No | No | No | No |
| \$1stdDevPop | No | No | No | No | No |
| \$1stdDevSamp | No | No | No | No | No |
| [\$1sum](sum.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores aritméticos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1add](add.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1ceil](ceil.md) | No | Sí | Sí | Sí | Sí |
| [\$1divide](divide.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1exp](exp.md) | No | Sí | Sí | Sí | Sí |
| [\$1floor](floor.md) | No | Sí | Sí | Sí | Sí |
| [\$1ln](ln.md) | No | Sí | Sí | Sí | Sí |
| [\$1log](log.md) | No | Sí | Sí | Sí | Sí |
| [\$1log10](log10.md) | No | Sí | Sí | Sí | Sí |
| [\$1mod](mod.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1multiply](multiply.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1pow](pow.md) | No | No | No | Sí | No |
| \$1round | - | - | No | No | No |
| [\$1sqrt](sqrt.md) | No | Sí | Sí | Sí | Sí |
| [\$1subtract](subtract.md) | Sí | Sí | Sí | Sí | Sí |
| \$1trunc | No | No | No | No | No |
### Operadores de matrices
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1arrayToObject](arrayToObject.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1concatArrays](concatArrays.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1filter](filter.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1first](first.md) | - | - | Sí | Sí | No |
| [\$1in](in-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1indexOfArray](indexOfArray.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1isArray](isArray.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1last](last.md) | - | - | Sí | Sí | No |
| [\$1objectToArray](objectToArray.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1range](range.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1reverseArray](reverseArray.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1reduce](reduce.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1size](size.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1slice](slice.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1zip](zip.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores booleanos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1not](not-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1or](or-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de comparación
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1eq](eq-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1gt](gt-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1gte](gte-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1lt](lt-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1lte](lte-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1ne](ne-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de expresiones condicionales
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1ifNull](ifNull.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1switch](switch.md) | No | Sí | Sí | Sí | No |
### Operador de tipos de datos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | Sí | Sí | Sí | Sí | Sí |
### Operador de tamaño de datos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | No | No | No |
| \$1bsonSize | - | - | No | No | No |
### Operadores de fechas
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1dateAdd](dateAdd.md) | No | No | Sí | Sí | Sí |
| [\$1dateDiff](dateDiff.md) | - | - | Sí | Sí | No |
| \$1dateFromParts | No | No | No | No | No |
| [\$1dateFromString](dateFromString.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1dateSubtract](dateSubtract.md) | No | No | Sí | Sí | Sí |
| \$1dateToParts | No | No | No | No | No |
| [\$1dateToString](dateToString.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1dateTrunc](dateTrunc.md) | - | - | No | Sí | No |
| [\$1dayOfMonth](dayOfMonth.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1dayOfWeek](dayOfWeek.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1dayOfYear](dayOfYear.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1hour](hour.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1 isoDayOf Semana](isoDayOfWeek.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1isoWeek](isoWeek.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1isoWeekYear](isoWeekYear.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1millisecond](millisecond.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1minute](minute.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1month](month.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1second](second.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1week](week.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1year](year.md) | Sí | Sí | Sí | Sí | Sí |
### Operador literal
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | Sí | Sí | Sí | Sí | Sí |
### Operador de combinación
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | Sí | Sí | Sí | Sí | Sí |
### Operador natural
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1natural](natural.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores de establecimiento
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | No | Sí | Sí | Sí | Sí |
| [\$1anyElementTrue](anyElementTrue.md) | No | Sí | Sí | Sí | Sí |
| [\$1setDifference](setDifference.md) | No | Sí | Sí | Sí | Sí |
| [\$1setEquals](setEquals.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1setIntersection](setIntersection.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1setIsSubset](setIsSubset.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1setUnion](setUnion.md) | Sí | Sí | Sí | Sí | Sí |
| \$1setWindowFields | No | No | No | No | No |
### Operadores de etapa
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1bucket](bucket.md) | No | No | No | Sí | No |
| \$1bucketAuto | No | No | No | No |
| [\$1changeStream](changeStream.md) | Sí | Sí | Sí | Sí | No |
| [\$1collStats](collStats.md) | No | Sí | Sí | Sí | No |
| [\$1count](count.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1currentOp](currentOp.md) | Sí | Sí | Sí | Sí | Sí |
| \$1facet | No | No | No | No | No |
| [\$1geoNear](geoNear.md) | Sí | Sí | Sí | Sí | Sí |
| \$1graphLookup | No | No | No | No | No |
| [\$1group](group.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1indexStats](indexStats.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1limit](limit.md) | Sí | Sí | Sí | Sí | Sí |
| \$1listLocalSessions | No | No | No | No | No |
| \$1listSessions | No | No | No | No | No |
| [\$1lookup](lookup.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1match](match.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1merge](merge.md) | - | - | No | Sí | No |
| [\$1out](out.md) | Sí | Sí | Sí | Sí | No |
| \$1planCacheStats | - | - | No | No | No |
| [\$1project](project.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1redact](redact.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1replaceRoot](replaceRoot.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1sample](sample.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1set](set-stage.md) | - | - | No | Sí | No |
| \$1setWindowFields | - | - | No | No | No |
| [\$1skip](skip.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1sort](sort.md) | Sí | Sí | Sí | Sí | Sí |
| \$1sortByCount | No | No | No | No | No |
| \$1UnionWith | - | - | No | No | No |
| [\$1unset](unset-stage.md) | - | - | No | Sí | No |
| [\$1unwind](unwind.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1 Reemplazar con](replaceWith.md) | No | No | No | Sí | No |
| [\$1 VectorSearch](vectorSearch.md) | No | No | No | Sí | No |
### Operadores de cadena
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1indexOfBytes](indexOfBytes.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1indexOfCP](indexOfCP.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1ltrim](ltrim.md) | No | Sí | Sí | Sí | No |
| [\$1regexFind](regexFind.md) | - | - | Sí | Sí | No |
| [\$1regexFindAll](regexFindAll.md) | - | - | Sí | Sí | No |
| [\$1 RegexMatch](regexMatch.md) | - | - | Sí | Sí | No |
| [\$1ReplaceAll](replaceAll.md) | - | - | Sí | Sí | No |
| [\$1 ReplaceOne](replaceOne.md) | - | - | Sí | Sí | No |
| [\$1rtrim](rtrim.md) | No | Sí | Sí | Sí | No |
| [\$1split](split.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1strcasecmp](strcasecmp.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1strLenBytes](strLenBytes.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1strLenCP](strLenCP.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1substr](substr.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1substrBytes](substrBytes.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1substrCP](substrCP.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1toLower](toLower.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1toUpper](toUpper.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1trim](trim.md) | No | Sí | Sí | Sí | No |
### Variables del sistema
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | No | No | No | No | No |
| [\$1\$1DESCEND](DESCEND.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1\$1KEEP](KEEP.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1\$1PRUNE](PRUNE.md) | Sí | Sí | Sí | Sí | Sí |
| \$1\$1REMOVE | No | No | No | No | No |
| [\$1 RAÍZ](ROOT.md) | Sí | Sí | Sí | Sí | Sí |
### Operador de búsqueda de texto
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | No | No | Sí | Sí | No |
| [\$1search](search.md) | No | No | Sí | Sí | No |
### Operadores de conversión de tipos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1convert](convert.md) | No | Sí | Sí | Sí | Sí |
| \$1es un número | - | - | No | No | No |
| [\$1 a Bool](toBool.md) | No | Sí | Sí | Sí | Sí |
| [\$1toDate](toDate.md) | No | Sí | Sí | Sí | Sí |
| [\$1 a Decimal](toDecimal.md) | No | Sí | Sí | Sí | Sí |
| [\$1 a doble](toDouble.md) | No | Sí | Sí | Sí | Sí |
| [\$1toInt](toInt.md) | No | Sí | Sí | Sí | Sí |
| [\$1 a Long](toLong.md) | No | Sí | Sí | Sí | Sí |
| [\$1toObjectId](toObjectId.md) | No | Sí | Sí | Sí | Sí |
| [\$1toString](toString.md) | No | Sí | Sí | Sí | Sí |
### Operadores de variables
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | Sí | Sí | Sí | Sí | Sí |
| [\$1map](map.md) | Sí | Sí | Sí | Sí | Sí |
### Operadores misceláneos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | No | No | No |
| [\$1rand](rand.md) | - | - | No | Sí | No |
| \$1sampleRate | - | - | No | No | No |
## Tipos de datos
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| 32-bit Integer (int) | Sí | Sí | Sí | Sí | Sí |
| Entero de 64 bits (largo) | Sí | Sí | Sí | Sí | Sí |
| Matriz | Sí | Sí | Sí | Sí | Sí |
| Datos Binary | Sí | Sí | Sí | Sí | Sí |
| Booleano | Sí | Sí | Sí | Sí | Sí |
| Date | Sí | Sí | Sí | Sí | Sí |
| DBPointer | No | No | No | No | No |
| DBRefs | No | No | No | No | No |
| Decimal128 | Sí | Sí | Sí | Sí | Sí |
| Double | Sí | Sí | Sí | Sí | Sí |
| JavaScript | No | No | No | No | No |
| JavaScript(con alcance) | No | No | No | No | No |
| MaxKey | Sí | Sí | Sí | Sí | Sí |
| MinKey | Sí | Sí | Sí | Sí | Sí |
| Nulo | Sí | Sí | Sí | Sí | Sí |
| Objeto | Sí | Sí | Sí | Sí | Sí |
| ObjectId | Sí | Sí | Sí | Sí | Sí |
| Expresión regular | Sí | Sí | Sí | Sí | Sí |
| Cadena | Sí | Sí | Sí | Sí | Sí |
| Símbolo | No | No | No | No | No |
| Timestamp | Sí | Sí | Sí | Sí | Sí |
| Sin definir | No | No | No | No | No |
## Índices y propiedades de índices
**Topics**
+ [Índices](#mongo-apis-indexes)
+ [Propiedades de índices](#mongo-apis-index-properties)
### Índices
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | Sí | Sí | Sí | Sí | Sí |
| Índice 2d | No | No | No | No | No |
| Índice compuesto | Sí | Sí | Sí | Sí | Sí |
| Índice hash | No | No | No | No | No |
| Índice de varias claves | Sí | Sí | Sí | Sí | Sí |
| Índice de campo único | Sí | Sí | Sí | Sí | Sí |
| Índice de texto | No | No | Sí | Sí | No |
| Comodín | No | No | No | No | No |
### Propiedades de índices
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Clúster elástico |
| --- | --- | --- | --- | --- | --- |
| Introducción | Sí | Sí | Sí | Sí | Sí |
| No distingue entre mayúsculas y minúsculas | No | No | No | Sí | No |
| Oculto | No | No | No | No | No |
| Parcial | No | No | Sí | Sí | No |
| Sparse | Sí | Sí | Sí | Sí | Sí |
| Texto | No | No | Sí | Sí | No |
| TTL | Sí | Sí | Sí | Sí | Sí |
| Unique | Sí | Sí | Sí | Sí | Sí |
| Vector | No | No | Sí | Sí | No |
Para obtener información detallada sobre operadores específicos de MongoDB, consulte los siguientes temas:
+ [Operadores de canalización de agregación](mongo-apis-aggregation-pipeline-operators.md)
+ [Geospatial (Geoespacial)](mongo-apis-geospatial-operators.md)
+ [Operadores de proyección](#mongo-apis-projection-operators)
+ [Operadores de actualización](mongo-apis-update-operators.md)
# Operadores de canalización de agregación
En esta sección se proporciona información detallada sobre los operadores de canalización de agregación compatibles con Amazon DocumentDB.
**Topics**
+ [\$1\$1DESCEND](DESCEND.md)
+ [\$1\$1KEEP](KEEP.md)
+ [\$1\$1PRUNE](PRUNE.md)
+ [\$1 RAÍZ](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 Semana](isoDayOfWeek.md)
+ [\$1isoWeek](isoWeek.md)
+ [\$1isoWeekYear](isoWeekYear.md)
+ [\$1last](last.md)
+ [\$1let](let.md)
+ [\$1limit](limit.md)
+ [\$1literal](literal.md)
+ [\$1ln](ln.md)
+ [\$1log](log.md)
+ [\$1log10](log10.md)
+ [\$1lt](lt-aggregation.md)
+ [\$1lte](lte-aggregation.md)
+ [\$1lookup](lookup.md)
+ [\$1ltrim](ltrim.md)
+ [\$1map](map.md)
+ [\$1match](match.md)
+ [\$1max](max.md)
+ [\$1meta](meta-aggregation.md)
+ [\$1merge](merge.md)
+ [\$1mergeObjects](mergeObjects.md)
+ [\$1millisecond](millisecond.md)
+ [\$1min](min.md)
+ [\$1minute](minute.md)
+ [\$1mod](mod.md)
+ [\$1month](month.md)
+ [\$1multiply](multiply.md)
+ [\$1natural](natural.md)
+ [\$1ne](ne-aggregation.md)
+ [\$1not](not-aggregation.md)
+ [\$1objectToArray](objectToArray.md)
+ [\$1or](or-aggregation.md)
+ [\$1out](out.md)
+ [\$1pow](pow.md)
+ [\$1push](push-aggregation.md)
+ [\$1project](project.md)
+ [\$1rand](rand.md)
+ [\$1range](range.md)
+ [\$1redact](redact.md)
+ [\$1reduce](reduce.md)
+ [\$1regexFind](regexFind.md)
+ [\$1regexFindAll](regexFindAll.md)
+ [\$1 RegexMatch](regexMatch.md)
+ [\$1ReplaceAll](replaceAll.md)
+ [\$1 ReplaceOne](replaceOne.md)
+ [\$1replaceRoot](replaceRoot.md)
+ [\$1 Reemplazar con](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)
+ [\$1 a Bool](toBool.md)
+ [\$1toDate](toDate.md)
+ [\$1 a Decimal](toDecimal.md)
+ [\$1 a doble](toDouble.md)
+ [\$1toInt](toInt.md)
+ [\$1 a Long](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](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
El `$$DESCEND` operador de Amazon DocumentDB es un operador de matriz posicional especial que se utiliza en la `$redact` fase de canalización. Indica a la canalización de agregación que descienda al documento actual y procese todos los campos, independientemente de su nivel de anidación.
Cuando la `$redact` etapa se encuentre con el `$$DESCEND` operador, mantendrá visibles todos los campos del documento actual y los procesará más adelante. Esto resulta útil cuando se desea redactar o eliminar determinados campos de forma selectiva en función de una condición y, al mismo tiempo, conservar la estructura del documento.
**Parámetros**
Ninguna.
## Ejemplo (MongoDB Shell)
En este ejemplo, utilizaremos la `$redact` etapa con el `$$DESCEND` operador para mostrar de forma selectiva los documentos en los que el `code` campo sea igual a «Reg».
**Crea documentos de muestra**
```
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" }
]);
```
**Ejemplo de consulta**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**Salida**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$$DESCEND` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
La variable de `$$KEEP` sistema se usa con la `$redact` etapa de la canalización de agregación para mantener el documento o campo actual sin cambios e incluirlo en la salida.
**Parámetros**
Ninguno
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra el uso de `$$KEEP` en una canalización de agregación de Amazon DocumentDB. Los documentos solo se conservan si el acceso es igual a «público»; de lo contrario, se eliminan.
**Cree documentos de muestra**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**Ejemplo de consulta**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**Salida**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$$KEEP` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
La variable de `$$PRUNE` sistema se usa con la `$redact` etapa de la canalización de agregación para excluir los documentos o los niveles de documentos incrustados de los resultados. Cuando una condición se evalúa como`$$PRUNE`, el documento o subdocumento actual se elimina de la salida. Por lo general, se usa con `$$DESCEND` (para conservar y recorrer el documento) o `$$KEEP` (para mantener el documento en todos los niveles).
**Parámetros**
Ninguna. La variable de `$$PRUNE` sistema se utiliza sin ningún parámetro y se debe utilizar con`$redact`.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra cómo utilizar `$$PRUNE` with `$redact` para excluir de los resultados a los usuarios mayores de 30 años.
**Cree documentos de muestra**
```
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" } }
])
```
**Ejemplo de consulta**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**Salida**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$$PRUNE` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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()
```
------
# \$1 RAÍZ
El `$ROOT` operador de Amazon DocumentDB se utiliza para hacer referencia a todo el documento de entrada dentro de una canalización de agregación. Le permite acceder a todo el documento y manipularlo, incluidos todos sus campos y estructuras anidados.
**Parámetros**
Ninguno
## Ejemplo (MongoDB Shell)
En este ejemplo se muestra cómo `$ROOT` crear un registro de auditoría que capture el documento original completo junto con los metadatos sobre el momento en que se procesó.
**Cree documentos de muestra**
```
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
}
]);
```
**Ejemplo de consulta**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**Salida**
```
[
{
_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'
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$ROOT` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$abs` operador de Amazon DocumentDB devuelve el valor absoluto de un número. Se puede usar en la canalización de agregación para realizar operaciones matemáticas en campos numéricos.
**Parámetros**
+ `number`: La expresión numérica para la que se devolverá el valor absoluto.
## Ejemplo (MongoDB Shell)
En este ejemplo se muestra el uso del `$abs` operador para encontrar el valor absoluto de un campo numérico.
**Cree documentos de muestra**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**Ejemplo de consulta**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**Salida**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$abs` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$add` operador de Amazon DocumentDB se utiliza para sumar números o fechas. Se puede utilizar para realizar operaciones aritméticas en campos numéricos o para realizar operaciones aritméticas de fechas añadiendo varias unidades de tiempo a un campo de fecha.
**Parámetros**
+ `expression1`: el primer número o fecha que se va a añadir.
+ `expression2`: El segundo número o fecha que se va a añadir.
+ `expression3`: (opcional) Números o fechas adicionales para añadir.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$add` operador para sumar dos números.
**Cree documentos de muestra**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**Ejemplo de consulta**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**Salida**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
En este ejemplo, el `$add` operador se utiliza para añadir los valores de los `b` campos `a` y de cada documento y almacenar el resultado en el `sum` campo.
## Ejemplos de código
Para ver un ejemplo de código para usar el `$add` comando, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
El operador de `$addToSet` agregación devuelve una matriz de valores únicos de una expresión especificada para cada grupo. Se usa dentro de la `$group` etapa para acumular valores distintos, eliminando automáticamente los duplicados.
**Parámetros**
+ `expression`: La expresión que se va a evaluar para cada documento del grupo.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra el uso del `$addToSet` operador para recopilar ciudades únicas en las que se realizaron los pedidos de cada cliente.
**Cree documentos de muestra**
```
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 }
]);
```
**Ejemplo de consulta**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**Salida**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el operador de `$addToSet` agregación, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
La `$addFields` etapa del proceso de agregación de Amazon DocumentDB le permite añadir nuevos campos calculados a los documentos. Esto puede resultar útil para añadir datos derivados o transformados a los documentos.
**Parámetros**
+ `newField`: el nombre del nuevo campo que se va a añadir.
+ `expression`: una expresión que se resuelve en el valor del nuevo campo.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra cómo `$addFields` añadir un nuevo campo `TotalInventory` que calcule el inventario total en función de los campos `Inventory.OnHand` y`Inventory.OrderQnty`.
**Cree documentos de muestra**
```
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
}
]);
```
**Ejemplo de consulta**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**Salida**
```
[
{
"_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
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$addFields` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 4.0
El `$allElementsTrue` operador se utiliza para comprobar si todos los elementos de una matriz tienen un valor verdadero.
**Parámetros**
+ `expression`: expresión que da como resultado una matriz.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso de `$allElementsTrue` para comprobar si todos los elementos de una matriz son verdaderos.
**Cree documentos de muestra**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**Ejemplo de consulta**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**Salida**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
En este ejemplo, la consulta comprueba si todos los elementos de la `scores` matriz son mayores que 0. `"name": "Jane"`Se excluye el documento con porque la `scores` matriz contiene un 0, que es un valor falso.
## Ejemplos de código
Para ver un ejemplo de código para usar el `$allElementsTrue` comando, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
El operador de `$and` agregación evalúa varias expresiones y retorna `true` solo si todas las expresiones tienen una evaluación igual a`true`. Si alguna expresión lo es`false`, retorna`false`.
**Parámetros**
+ `expressions`: Un conjunto de expresiones para evaluar.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra el uso del `$and` operador para comprobar si los productos cumplen varios criterios.
**Cree documentos de muestra**
```
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 }
]);
```
**Ejemplo de consulta**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**Salida**
```
[
{ _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 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el operador de `$and` agregación, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
Novedades de la versión 4.0
El `$anyElementTrue` operador se usa para determinar si algún elemento de una matriz es verdadero.
**Parámetros**
+ `field`: un campo de matriz para evaluar.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso de `$anyElementTrue` para comprobar si algún elemento de una matriz es verdadero.
**Cree documentos de muestra**
```
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] }
])
```
**Ejemplo de consulta**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**Salida**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$anyElementTrue` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$arrayElemAt` operador de Amazon DocumentDB le permite recuperar un elemento de una matriz por su posición en el índice. Esto resulta especialmente útil cuando necesita acceder a un elemento específico dentro de un campo matricial de sus documentos.
**Parámetros**
+ `array`: La matriz de entrada de la que se va a recuperar un elemento.
+ `index`: la posición de índice basada en cero del elemento que se va a recuperar. Este valor debe ser un número entero no negativo.
## Ejemplo (MongoDB Shell)
En este ejemplo, demostraremos cómo usar el `$arrayElemAt` operador para recuperar elementos específicos de la `flight_miles` matriz de la `miles` colección.
**Cree documentos de muestra**
```
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 ]}
]);
```
**Ejemplo de consulta**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**Salida**
```
{ "_id" : 1, "first_mile" : 1205, "last_mile" : 880 }
{ "_id" : 2, "first_mile" : 1205, "last_mile" : 2780 }
{ "_id" : 3, "first_mile" : 1205, "last_mile" : 880 }
```
En este ejemplo, utilizamos el `$arrayElemAt` operador para recuperar el primer y el último elemento de la `flight_miles` matriz de cada documento.
## Ejemplos de código
Para ver un ejemplo de código para usar el `$arrayElemAt` comando, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
El `$arrayToObject` operador de Amazon DocumentDB es el inverso del `$objectToArray` operador. Toma una matriz de documentos de pares clave-valor y la convierte en un único documento. Esto resulta especialmente útil cuando se necesita volver a convertir una matriz de pares clave-valor en una estructura de objeto o documento.
**Parámetros**
+ `array expression`: expresión que se resuelve en una matriz. Los elementos de la matriz deben ser documentos con dos campos: `k` (la clave) y `v` (el valor).
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra cómo `$arrayToObject` convertir una matriz de pares clave-valor en un documento.
**Cree documentos de muestra**
```
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 } }
]);
```
**Ejemplo de consulta**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**Salida**
```
{ "_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 } }
```
En este ejemplo, el `$objectToArray` operador se utiliza para convertir el `inventory` objeto en una matriz de pares clave-valor. A continuación, el `$arrayToObject` operador se utiliza para volver a convertir la matriz en un documento, restaurando la estructura original del objeto.
## Ejemplos de código
Para ver un ejemplo de código para usar el `$arrayToObject` comando, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
El operador de `$avg` agregación de Amazon DocumentDB calcula el valor medio de la expresión especificada en todos los documentos que se introducen en la etapa. Este operador es útil para calcular el promedio de un campo numérico o una expresión en un conjunto de documentos.
**Parámetros**
+ `expression`: la expresión que se utilizará para calcular el promedio. Puede ser una ruta de campo (p. ej.`"$field"`) o una expresión (p. ej.`{ $multiply: ["$field1", "$field2"] }`).
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$avg` operador para calcular la puntuación media de un conjunto de documentos de los estudiantes.
**Cree documentos de muestra**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**Ejemplo de consulta**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**Salida**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$avg` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 8.0
No es compatible con el clúster de Elastic.
La etapa de `$bucket` agregación de Amazon DocumentDB le permite agrupar los documentos de entrada en cubos en función de una expresión específica y de los límites de los cubos. Esto puede resultar útil para analizar los datos que se encuentran dentro de determinados rangos de valores o categorías.
**Parámetros**
+ `groupBy`(obligatorio): la expresión que especifica el valor por el que se va a agrupar.
+ `boundaries`(obligatorio): matriz de valores dobles que definen los límites de los cubos. Los documentos se asignan a los cubos en función del valor de `groupBy` expresión que se encuentra dentro de los límites especificados.
+ `default`(opcional): un valor literal que se genera para los documentos cuyo valor de `groupBy` expresión no se encuentra dentro de ninguno de los límites especificados.
+ `output`(opcional): objeto que especifica la información que se va a generar para cada segmento. Puede usar operadores acumuladores como`$sum`, `$avg``$min`, y `$max` para calcular las agregaciones de cada segmento.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$bucket` escenario para agrupar los datos de ventas por rango de precios.
**Cree documentos de muestra**
```
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") }
]);
```
**Ejemplo de consulta**
```
db.sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
])
```
**Salida**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$bucket` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 4.0
El `$ceil` operador de Amazon DocumentDB, al igual que en MongoDB, redondea un número al entero más cercano. Esto resulta útil cuando necesita realizar operaciones matemáticas en campos numéricos y asegurarse de que el resultado es un número entero.
**Parámetros**
+ `expression`: la expresión numérica que se va a redondear.
## Ejemplo (MongoDB Shell)
En este ejemplo se muestra cómo utilizar el `$ceil` operador para redondear un campo numérico.
**Cree documentos de muestra**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**Ejemplo de consulta**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**Salida**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$ceil` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
No es compatible con el clúster de Elastic.
La etapa de `$changeStream` agregación abre un cursor de flujo de cambios para monitorear los cambios en tiempo real en una colección. Devuelve los documentos de los eventos de cambio cuando se realizan operaciones de inserción, actualización, reemplazo o eliminación.
**Parámetros**
+ `fullDocument`: Especifica si se debe devolver el documento completo para las operaciones de actualización. Las opciones son `default` y `updateLookup`.
+ `resumeAfter`: opcional. Reanude el token para continuar desde un punto específico del flujo de cambios.
+ `startAtOperationTime`: opcional. Marca de tiempo desde la que se inicia el flujo de cambios.
+ `allChangesForCluster`: opcional. Valor booleano. Cuando`true`, observa todos los cambios en el clúster (para la base de datos de administración). Cuando `false` (predeterminado), solo observa la colección especificada.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$changeStream` escenario para supervisar los cambios en una colección.
**Ejemplo de consulta**
```
// 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()));
}
```
**Salida**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## Ejemplos de código
Para ver un ejemplo de código para usar la etapa de `$changeStream` agregación, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
El `$cmp` operador de Amazon DocumentDB se utiliza para comparar dos valores y devolver un valor entero que indica su orden relativo. Es un operador de comparación que compara dos expresiones y devuelve un valor entero de -1, 0 o 1, dependiendo de si el primer valor es menor, igual o mayor que el segundo valor, respectivamente.
**Parámetros**
+ `expression1`: la primera expresión que se va a comparar.
+ `expression2`: La segunda expresión que se va a comparar.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$cmp` operador para comparar dos valores numéricos.
**Cree documentos de muestra**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**Ejemplo de consulta**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**Salida**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
En este ejemplo, el `$cmp` operador compara los `value2` campos `value1` y de cada documento. El resultado es:
```
- `$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).
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$cmp` comando, elija la pestaña del idioma que desee usar:
------
#### [ Node.js ]
A continuación, se muestra un ejemplo del uso `$cmp` del operador en una aplicación de Node.js con el `mongodb` controlador:
```
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 ]
Este es un ejemplo del uso del `$cmp` operador en una aplicación de Python con el `pymongo` controlador:
```
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()
```
El resultado de los ejemplos de Node.js y Python será el mismo que el del ejemplo de MongoDB Shell:
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
Novedades de la versión 4.0
La etapa de `$collStats` agregación de Amazon DocumentDB proporciona estadísticas sobre la colección especificada, de forma similar al `db.collection.stats()` comando del shell de MongoDB. Esta etapa se puede utilizar para recuperar información sobre la recopilación, como la cantidad de documentos, el tamaño total de la colección y varias métricas de rendimiento.
**Parámetros**
+ `latencyStats`: (opcional) Un documento que especifica las opciones para recopilar estadísticas de latencia. Este parámetro no se admite en Amazon DocumentDB.
+ `recordStats`: (opcional) Documento que especifica las opciones para recopilar estadísticas de registros. Este parámetro no se admite en Amazon DocumentDB.
+ `queryExecStats`: (opcional) Documento que especifica las opciones para recopilar estadísticas de ejecución de consultas. Este parámetro no se admite en Amazon DocumentDB.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar la etapa de `$collStats` agregación para recuperar estadísticas sobre una colección nombrada `test` en la `db` base de datos.
**Cree documentos de muestra**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**Ejemplo de consulta**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**Salida**
```
{
"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)
}
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$collStats` comando, elija la pestaña del idioma que desee usar:
------
#### [ Node.js ]
A continuación, se muestra un ejemplo de cómo utilizar la etapa de `$collStats` agregación en una aplicación de Node.js con el controlador Node.js oficial de MongoDB:
```
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 ]
A continuación, se muestra un ejemplo de cómo utilizar la etapa de `$collStats` agregación en una aplicación de Python mediante el PyMongo controlador:
```
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
El operador de `$concat` agregación de Amazon DocumentDB concatena (o combina) varias cadenas de un documento para producir una sola cadena que se puede devolver a la aplicación. Esto reduce el trabajo realizado en la aplicación, ya que la manipulación de las cadenas se realiza a nivel de la base de datos.
**Parámetros**
+ `expression1`: La primera cadena que se va a concatenar.
+ `expression2`: La segunda cadena que se va a concatenar.
+ `...`: cadenas adicionales para concatenar (opcional).
## Ejemplo (MongoDB Shell)
En este ejemplo, concatenamos los nombres y apellidos de los usuarios para obtener el nombre completo de cada persona.
**Cree documentos de muestra**
```
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"}
])
```
**Ejemplo de consulta**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**Salida**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$concat` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El operador de `$concatArrays` agregación de Amazon DocumentDB se utiliza para concatenar dos o más matrices en una sola matriz. Esto puede resultar útil cuando necesite combinar varias matrices de datos en una sola matriz para su posterior procesamiento o análisis.
**Parámetros**
+ `array1`: La primera matriz que se va a concatenar.
+ `array2`: La segunda matriz que se va a concatenar.
+ `[array3, ...]`: (opcional) Matrices adicionales que se van a concatenar.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$concatArrays` operador para combinar dos matrices en una sola matriz.
**Cree documentos de muestra**
```
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"]
}
]);
```
**Ejemplo de consulta**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**Salida**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$concatArrays` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$cond` operador de Amazon DocumentDB se utiliza para evaluar una expresión condicional y devolver una de las dos posibles expresiones de resultado.
**Parámetros**
+ `if`: La expresión booleana que se va a evaluar.
+ `then`: La expresión que se devolverá si la `if` expresión es verdadera.
+ `else`: La expresión que se devolverá si la `if` expresión es falsa.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$cond` operador para devolver un valor basado en la edad de una persona.
**Cree documentos de muestra**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**Ejemplo de consulta**
```
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"
}
}
}
}
}
}
])
```
**Salida**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$cond` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 4.0
El `$convert` operador de Amazon DocumentDB se utiliza para convertir un valor de un tipo de datos a otro. Este operador resulta útil cuando necesita realizar operaciones con datos de distintos tipos, como convertir una cadena en un número o una fecha en una marca de tiempo.
**Parámetros**
+ `to`: el tipo de datos de destino al que se va a convertir el valor. Los valores admitidos son `"string"`, `"double"`, `"long"`, `"int"` y `"date"` y `"boolean"`.
+ `from`: el tipo de datos actual del valor. Si no se especifica, Amazon DocumentDB intentará detectar automáticamente el tipo de datos.
+ `onError`: (opcional) El valor que se devolverá si se produce un error en la conversión. Puede ser un valor específico o uno de los siguientes valores especiales:`"null"`,`"zerofill"`, o`"error"`.
+ `onNull`: (opcional) El valor que se devolverá si el valor de entrada es`null`. Puede ser un valor específico o uno de los siguientes valores especiales:`"null"`,`"zerofill"`, o`"error"`.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra la conversión de un valor de cadena en una fecha mediante el `$convert` operador.
**Cree documentos de muestra**
```
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" }
]);
```
**Ejemplo de consulta**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**Salida**
```
[
{ "_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 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$convert` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
La etapa de `$count` agregación de Amazon DocumentDB se utiliza para contar el número de documentos que pasan a la etapa. Suele utilizarse como la etapa final de un proceso de agregación para devolver el recuento total de documentos que coinciden con las etapas anteriores.
**Parámetros**
+ `field`: El campo que se va a contar. Este parámetro es opcional y, si no se proporciona, la etapa contará el número total de documentos ingresados.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$count` escenario para obtener el número total de documentos de una colección.
**Cree documentos de muestra**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**Ejemplo de consulta**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**Salida**
```
{ "total" : 4 }
```
El ejemplo agrega la `users` colección y usa el `$count` escenario para contar el número total de documentos.
## Ejemplos de código
Para ver un ejemplo de código para usar el `$count` comando, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
La etapa de `$currentOp` agregación devuelve información sobre las operaciones que se están ejecutando actualmente en la base de datos. Esta etapa es útil para supervisar las consultas y operaciones activas en una canalización de agregación.
**Parámetros**
+ `allUsers`(opcional): si se establece en`true`, devuelve las operaciones de todos los usuarios. El valor predeterminado es `false`.
+ `idleConnections`(opcional): si se establece en`true`, incluye las conexiones inactivas. El valor predeterminado es `false`.
+ `idleCursors`(opcional): cuando se establece en`true`, incluye información sobre los cursores inactivos. El valor predeterminado es `false`.
+ `idleSessions`(opcional): si se establece en`true`, incluye información sobre las sesiones inactivas. El valor predeterminado es `true`.
+ `localOps`(opcional): si se establece en`true`, incluye las operaciones locales. El valor predeterminado es `false`.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso de la etapa de `$currentOp` agregación para recuperar información sobre las operaciones de lectura activas.
**Ejemplo de consulta**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**Salida**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$currentOp` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 5.0
El operador de `$dateAdd` agregación de Amazon DocumentDB le permite añadir una duración a un valor de fecha y hora.
**Parámetros**
+ `date`: un valor de fecha y hora al que añadir una duración.
+ `duration`: la duración que se va a añadir al `date` valor. Se puede especificar como un objeto con claves para `years``months`,`weeks`, `days``hours`,`minutes`, y`seconds`.
+ `timezone`: (opcional) La zona horaria que se utilizará al realizar la suma de fechas. Si no se especifica, se utiliza la zona horaria predeterminada del clúster de Amazon DocumentDB.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$dateAdd` operador para añadir 2 días y 12 horas a una fecha.
**Cree documentos de muestra**
```
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") }
]);
```
**Ejemplo de consulta**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**Salida**
```
[
{
"_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)"
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dateAdd` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 5.0
No es compatible con el clúster de Elastic.
El operador de `$dateDiff` agregación calcula la diferencia entre dos fechas en unidades específicas. Devuelve el número de límites de unidades cruzados entre las fechas de inicio y finalización.
**Parámetros**
+ `startDate`: la expresión de fecha de inicio.
+ `endDate`: La expresión de fecha final.
+ `unit`: La unidad de tiempo de la diferencia. Las unidades compatibles son `year` `quarter``month`,`week`,`day`, `hour``minute`,`second`, y`millisecond`.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$dateDiff` operador para calcular el número de días entre la realización del pedido y la entrega.
**Cree documentos de muestra**
```
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")
}
]);
```
**Ejemplo de consulta**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**Salida**
```
[
{
_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
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dateDiff` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El operador de `$dateFromString` agregación de Amazon DocumentDB le permite convertir una cadena de fecha y hora en un objeto de fecha. Esto resulta útil cuando los datos se almacenan como cadenas, pero necesita realizar operaciones basadas en fechas con los datos.
**Parámetros**
+ `dateString`: cadena que representa una fecha y una hora.
+ `format`: (opcional) Una cadena que especifica el formato de`dateString`. Si no se proporciona, Amazon DocumentDB intentará analizar la cadena en el formato ISO-8601.
+ `timezone`: (opcional) Una cadena que especifica la zona horaria. Si no se proporciona, Amazon DocumentDB utilizará la zona horaria del servidor.
+ `onError`: (opcional) Especifica la acción que se debe realizar en caso de que se produzca un error en la conversión. Los valores posibles son `'error'` (el valor predeterminado, que genera un error), `'null'` (devuelve`null`) o `'replace'` (reemplaza el valor por la cadena de reemplazo especificada en la `onErrorMessage` opción).
+ `onErrorMessage`: (opcional) Si `onError` se establece en`'replace'`, esta opción especifica la cadena de reemplazo.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo `$dateFromString` convertir una cadena de fecha en un objeto de fecha en Amazon DocumentDB.
**Cree documentos de muestra**
```
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"}
]);
```
**Ejemplo de consulta**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**Salida**
```
[
{
"_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")
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dateFromString` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Novedades de la versión 5.0
El operador de `$dateSubtract` agregación de Amazon DocumentDB le permite restar una duración específica de un valor de fecha.
**Parámetros**
+ `date`: expresión de fecha que se convierte en una fecha o una marca de tiempo.
+ `subtrahend`: una expresión de duración que especifica la cantidad de tiempo que se va a restar de la expresión. `date`
+ `unit`: cadena que especifica la unidad de tiempo de la `subtrahend` expresión. Las unidades admitidas son «año», «trimestre», «mes», «semana», «día», «hora», «minuto», «segundo» y «milisegundo».
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$dateSubtract` operador para calcular la fecha de hace un año a partir de la fecha actual.
**Cree documentos de muestra**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**Ejemplo de consulta**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**Salida**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dateSubtract` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El operador de `$dateToString` agregación de Amazon DocumentDB se utiliza para convertir un valor de fecha o marca horaria en una representación de cadena. Esto resulta útil cuando necesita formatear la fecha y la hora de una manera específica para mostrarlas o procesarlas posteriormente.
**Parámetros**
+ `date`: el valor de fecha o marca horaria que se va a convertir en una cadena.
+ `format`: cadena que especifica el formato en el que debe representarse la fecha. La cadena de formato puede incluir varios especificadores de formato, por ejemplo, `%Y` para el año de cuatro dígitos, `%m` para el mes de dos dígitos, `%d` para el día del mes de dos dígitos, etc.
+ `timezone`: (opcional) La zona horaria que se utilizará para la conversión. Si no se especifica, se utiliza la zona horaria del servidor que aloja el clúster de Amazon DocumentDB.
+ `onNull`: (opcional) El valor que se devolverá si el `date` parámetro es`null`.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$dateToString` operador para formatear el `logDate` campo de la `missionLog` colección.
**Cree documentos de muestra**
```
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") }
]);
```
**Ejemplo de consulta**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**Salida**
```
[
{
"_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"
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dateToString` comando, elija la pestaña del idioma que desee usar:
------
#### [ Node.js ]
A continuación, se muestra un ejemplo del uso del `$dateToString` operador en una aplicación de 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",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
Este es un ejemplo del uso del `$dateToString` operador en una aplicación de 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']
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
Novedades de la versión 8.0
No es compatible con el clúster de Elastic.
El operador de `$dateTrunc` agregación de Amazon DocumentDB trunca una fecha a una unidad específica.
**Parámetros**
+ `date`: expresión de fecha que se convierte en una fecha o una marca de tiempo.
+ `unit`: cadena que especifica la unidad de tiempo de la expresión de sustracción. Las unidades admitidas son `year``quarter`,`month`,`week`,`day`, `hour` `minute``second`, y. `millisecond`
## Ejemplo (MongoDB Shell)
El siguiente ejemplo muestra cómo utilizar el `$dateTrunc` operador para truncar una fecha y convertirla en una hora.
**Cree documentos de muestra**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**Ejemplo de consulta**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**Salida**
```
[
{
_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')
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dateTrunc` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El operador de `$dayOfMonth` agregación de Amazon DocumentDB recupera el día del mes (del 1 al 31) de una fecha determinada. Este operador resulta útil para agrupar, filtrar o extraer el día del mes de los campos de fecha de los documentos.
**Parámetros**
+ `date expression`: la expresión de fecha puede ser un campo de fecha del documento, un objeto de fecha o una cadena de fecha.
## Ejemplo (MongoDB Shell)
En este ejemplo se muestra cómo utilizar el `$dayOfMonth` operador para extraer el día del mes de un campo de fecha del documento.
**Cree documentos de muestra**
```
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") }
]);
```
**Ejemplo de consulta**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**Salida**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dayOfMonth` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$dayOfWeek` operador de Amazon DocumentDB extrae el día de la semana de un campo de fecha determinado. Devuelve el día de la semana como un número entre 1 (domingo) y 7 (sábado), que es el mismo comportamiento que en MongoDB.
**Parámetros**
+ `date field`: el campo de fecha del que se extrae el día de la semana.
## Ejemplo (MongoDB Shell)
En este ejemplo se muestra cómo utilizar el `$dayOfWeek` operador para extraer el día de la semana del `date` campo de la colección. `weather`
**Cree documentos de muestra**
```
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")
}
]);
```
**Ejemplo de consulta**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**Salida**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dayOfWeek` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$dayOfYear` operador de Amazon DocumentDB devuelve el día del año de una fecha como un número entre 1 y 366 (365 en los años no bisiestos).
**Parámetros**
+ `expression`: el campo o expresión de fecha del que se extrae el día del año.
## Ejemplo (MongoDB Shell)
En este ejemplo, se muestra cómo utilizar el `$dayOfYear` operador para extraer el día del año de un campo de fecha de una colección de Amazon DocumentDB.
**Cree documentos de muestra**
```
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")
}
])
```
**Ejemplo de consulta**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**Salida**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$dayOfYear` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$divide` operador de la canalización de agregación de Amazon DocumentDB se utiliza para dividir un número por otro. Es un operador útil para realizar operaciones matemáticas en campos numéricos de sus documentos.
**Parámetros**
+ `numerator`: El dividendo o el número a dividir.
+ `denominator`: El divisor o el número por el que se va a dividir.
## Ejemplo (MongoDB Shell)
En este ejemplo se muestra cómo utilizar el `$divide` operador para calcular la tarifa horaria de los empleados en función de su salario anual y del número de horas de trabajo al año.
**Cree documentos de muestra**
```
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 }
]);
```
**Ejemplo de consulta**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**Salida**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$divide` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El operador de `$eq` agregación compara dos valores y devuelve `true` si son iguales; de lo contrario, devuelve`false`.
**Parámetros**
+ `expression1`: El primer valor que se va a comparar.
+ `expression2`: El segundo valor que se va a comparar.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra el uso del `$eq` operador para comprobar si las cantidades de producto coinciden con los valores objetivo.
**Cree documentos de muestra**
```
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 }
]);
```
**Ejemplo de consulta**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**Salida**
```
[
{ _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 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el operador de `$eq` agregación, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
Novedades de la versión 4.0
El `$exp` operador de Amazon DocumentDB le permite elevar la constante e a un número determinado.
**Parámetros**
+ `expression`: La expresión que se va a evaluar. Puede ser cualquier expresión de agregación válida, incluidas las referencias de campo, las operaciones aritméticas y otras etapas de agregación.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$exp` operador para buscar todos los documentos en los que el `quantity` campo es mayor que el `price` campo.
**Cree documentos de muestra**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**Ejemplo de consulta**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**Salida**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$exp` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El `$filter` operador de Amazon DocumentDB se utiliza para aplicar una expresión de filtro a cada elemento de una matriz y devolver una matriz que contiene solo los elementos que cumplen la condición especificada. Este operador resulta útil cuando necesita realizar operaciones de filtrado complejas en los campos matriciales de sus documentos.
**Parámetros**
+ `input`: El campo de matriz que se va a filtrar.
+ `as`: el nombre de la variable que se utilizará para cada elemento de la `input` matriz dentro de la `cond` expresión.
+ `cond`: La expresión booleana que determina si un elemento determinado debe incluirse en la matriz de salida.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra cómo utilizar el `$filter` operador para proyectar el cliente de cada pedido y crear un nuevo campo matricial paiItems que contenga únicamente los artículos de la matriz items cuyo precio sea superior a 15. Básicamente, filtra los artículos de cada pedido para incluir solo los productos que cuestan más de 15€.
**Crea documentos de muestra**
```
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 }
]}
]);
```
**Ejemplo de consulta**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**Salida**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$filter` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Nuevo desde la versión 5.0.
No es compatible con el clúster de Elastic.
El `$first` operador de Amazon DocumentDB devuelve el primer documento de un conjunto agrupado de documentos. Se suele utilizar en las canalizaciones de agregación para recuperar el primer documento que cumple una condición específica.
**Parámetros**
+ `expression`: La expresión que se devolverá como el primer valor de cada grupo.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$first` operador para recuperar el primer valor de elemento encontrado para cada categoría durante la agregación.
Nota: `$first` devuelve el primer documento en función del orden actual de los documentos en proceso. Para garantizar un orden específico (por ejemplo, por fecha, precio, etc.), se debe utilizar una `$sort` etapa antes de la `$group` etapa.
**Cree documentos de muestra**
```
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" }
]);
```
**Ejemplo de consulta**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**Salida**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$first` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
Nuevo desde la versión 4.0.
El `$floor` operador de Amazon DocumentDB devuelve el entero más grande que sea menor o igual que el número especificado. Este operador es útil para redondear valores numéricos.
**Parámetros**
+ `expression`: la expresión numérica que se va a redondear hacia abajo.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$floor` operador para redondear un valor decimal al entero más cercano.
**Cree documentos de muestra**
```
db.numbers.insertOne({ value: 3.14 });
```
**Ejemplo de consulta**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**Salida**
```
{ "floored" : 3 }
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$floor` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
La etapa de `$geoNear` agregación devuelve los documentos en orden de proximidad a un punto específico. Calcula la distancia desde el punto e incluye la distancia en los documentos de salida.
**Parámetros**
+ `near`: el punto desde el que se calculan las distancias, especificado como GeoJSON o coordenadas heredadas.
+ `distanceField`: el nombre del campo para almacenar la distancia calculada.
+ `spherical`: booleano que indica si se debe utilizar geometría esférica (obligatorio para los puntos GeoJSON).
+ `maxDistance`: opcional. Distancia máxima desde el punto central.
+ `minDistance`: opcional. Distancia mínima desde el punto central.
+ `query`: opcional. Criterios de filtro adicionales que se deben aplicar.
+ `limit`: opcional. Número máximo de documentos a devolver.
+ `key`: opcional. Campo que se utilizará para la consulta geoespacial cuando existen varios índices geoespaciales.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se muestra el uso del `$geoNear` escenario para buscar las tiendas más cercanas a una ubicación determinada.
**Cree documentos de muestra**
```
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] } }
]);
```
**Ejemplo de consulta**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**Salida**
```
[
{ _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 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar la etapa de `$geoNear` agregación, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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
La etapa de `$group` agregación de Amazon DocumentDB le permite agrupar los documentos según una expresión específica y realizar diversas operaciones acumulativas en los datos agrupados. Esto puede resultar útil para tareas como calcular totales, promedios u otras estadísticas en función de los datos agrupados.
**Parámetros**
+ `_id`: especifica la expresión con la que se deben agrupar los documentos de entrada. Puede ser un nombre de campo, una expresión calculada o una combinación de ambos.
+ `accumulator expressions`: (opcional) Una o más expresiones acumulativas que se deben aplicar a los datos agrupados. Estas expresiones utilizan los operadores acumuladores mencionados anteriormente.
## Ejemplo (MongoDB Shell)
En el siguiente ejemplo, se agrupan los clientes por ciudad y se calcula el importe total del pedido para cada ciudad.
**Cree documentos de muestra**
```
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 }] }
]);
```
**Ejemplo de consulta**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**Salida**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el `$group` comando, elija la pestaña del idioma que desee usar:
------
#### [ 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
El operador de `$gt` agregación compara dos valores y devuelve `true` si el primer valor es mayor que el segundo; de lo contrario, devuelve`false`.
**Parámetros**
+ `expression1`: El primer valor que se va a comparar.
+ `expression2`: El segundo valor que se va a comparar.
## Ejemplo (MongoDB Shell)
El siguiente ejemplo demuestra el uso del `$gt` operador para identificar los productos que superan un umbral de precio.
**Cree documentos de muestra**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**Ejemplo de consulta**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**Salida**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## Ejemplos de código
Para ver un ejemplo de código para usar el operador de `$gt` agregación, elija la pestaña correspondiente al idioma que desee usar:
------
#### [ 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://