As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# APIsMongoDB, operações e tipos de dados compatíveis no Amazon DocumentDB
O Amazon DocumentDB (compativel com MongoDB) é um serviço de banco de dados de documentos rápido, escalável, totalmente gerenciado e altamente disponível que oferece suporte a workloads. O Amazon DocumentDB é compatível com o MongoDB 3.6, 4.0, 5.0 e 8.0. APIs Esta seção lista as funcionalidades com suporte. Para obter suporte ao uso do APIs MongoDB e dos drivers, consulte os fóruns da comunidade do MongoDB. Para obter suporte usando o serviço Amazon DocumentDB, entre em contato com a equipe de AWS suporte apropriada. Para diferenças funcionais entre Amazon DocumentDB e MongoDB, consulte [Diferenças funcionais: Amazon DocumentDB e MongoDB](functional-differences.md).
Os comandos e operadores do MongoDB somente para uso interno ou não aplicáveis a um serviço totalmente gerenciado não têm suporte e não são incluídos na lista de funcionalidades com suporte.
Adicionamos mais de 50 recursos desde o lançamento e continuaremos trabalhando para oferecer os recursos de que nossos clientes precisam. Para obter informações sobre os lançamentos mais recentes, consulte [Anúncios do Amazon DocumentDB](https://aws.amazon.com/documentdb/resources/).
Se você quiser que um recurso passe a ter suporte, envie um e-mail informando seu ID de conta, os atributos solicitados e o caso de uso para a [equipe de serviço do Amazon DocumentDB](mailto:documentdb-feature-request@amazon.com).
+ [Comandos do banco de dados](#mongo-apis-database)
+ [Operadores de consulta e projeção](#mongo-apis-query)
+ [Operadores de atualização](#mongo-apis-update)
+ [Geoespacial](#mongo-apis-geospatial)
+ [Métodos de cursor](#mongo-apis-cursor)
+ [Operadores de pipeline de agregação](#mongo-apis-aggregation-pipeline)
+ [Tipos de dados](#mongo-apis-data-types)
+ [Índices](#mongo-apis-indexes)
## Comandos do banco de dados
**Topics**
+ [Comandos administrativos](#mongo-apis-dababase-administrative)
+ [Agregação](#mongo-apis-dababase-aggregation)
+ [Autenticação](#mongo-apis-dababase-authentication)
+ [Comandos de diagnóstico](#mongo-apis-dababase-diagnostics)
+ [Operações de gravação e de consulta](#mongo-apis-dababase-query-write)
+ [Comandos de gerenciamento de perfis](#mongo-apis-database-role-management)
+ [Comandos de sessão](#mongo-apis-dababase-sessions)
+ [Gerenciamento de usuários](#mongo-apis-dababase-user-management)
+ [Comandos de fragmentação](#mongo-apis-dababase-sharding)
### Comandos administrativos
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| Coleções limitadas | Não | Não | Não | Não | Não |
| cloneCollectionAsTampado | Não | Não | Não | Não | Não |
| collMod | Parcial | Parcial | Parcial | Parcial | Parcial |
| CollMod: expireAfterSeconds | Sim | Sim | Sim | Sim | Sim |
| convertToCapped | Não | Não | Não | Não | Não |
| copydb | Não | Não | Não | Não | Não |
| criar | Sim | Sim | Sim | Sim | Sim |
| createView | Não | Não | Não | Sim | Não |
| createIndexes | Sim | Sim | Sim | Sim | Sim |
| currentOp | Sim | Sim | Sim | Sim | Sim |
| drop | Sim | Sim | Sim | Sim | Sim |
| dropDatabase | Sim | Sim | Sim | Sim | Sim |
| dropIndexes | Sim | Sim | Sim | Sim | Sim |
| filemd5 | Não | Não | Não | Não | Não |
| getAuditConfig | Não | Sim | Sim | Sim | Não |
| killCursors | Sim | Sim | Sim | Sim | Sim |
| killOp | Sim | Sim | Sim | Sim | Sim |
| listCollections\$1 | Sim | Sim | Sim | Sim | Sim |
| listDatabases | Sim | Sim | Sim | Sim | Sim |
| listIndexes | Sim | Sim | Sim | Sim | Sim |
| reIndex | Não | Não | Sim | Sim | Não |
| renameCollection | Sim | Sim | Sim | Sim | Não |
| setAuditConfig | Não | Sim | Sim | Sim | Não |
\$1 A chave `type` na opção de filtro não é compatível.
### Agregação
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| aggregate | Sim | Sim | Sim | Sim | Sim |
| contagem | Sim | Sim | Sim | Sim | Sim |
| distinct | Sim | Sim | Sim | Sim | Sim |
| mapReduce | Não | Não | Não | Sim | Não |
### Autenticação
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| authenticate | Sim | Sim | Sim | Sim | Sim |
| logout | Sim | Sim | Sim | Sim | Sim |
### Comandos de diagnóstico
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| buildInfo | Sim | Sim | Sim | Sim | Sim |
| collStats | Sim | Sim | Sim | Sim | Sim |
| connPoolStats | Não | Não | Não | Não | Não |
| connectionStatus | Sim | Sim | Sim | Sim | Sim |
| dataSize | Sim | Sim | Sim | Sim | Sim |
| dbHash | Não | Não | Não | Não | Não |
| dbStats | Sim | Sim | Sim | Sim | Sim |
| explain | Sim | Sim | Sim | Sim | Sim |
| explain: executionStats | Sim | Sim | Sim | Sim | Sim |
| recursos | Não | Não | Não | Não | Não |
| hostInfo | Sim | Sim | Sim | Sim | Sim |
| listCommands | Sim | Sim | Sim | Sim | Sim |
| profiler | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | Não |
| serverStatus | Sim | Sim | Sim | Sim | Sim |
| top | Sim | Sim | Sim | Sim | Sim |
### Operações de gravação e de consulta
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| Change streams | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sim](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | Não |
| excluir | Sim | Sim | Sim | Sim | Sim |
| find | Sim | Sim | Sim | Sim | Sim |
| findAndModify | Sim | Sim | Sim | Sim | Sim |
| getLastError | Não | Não | Não | Não | Não |
| getMore | Sim | Sim | Sim | Sim | Sim |
| getPrevError | Não | Não | Não | Não | Não |
| GridFS | Sim | Sim | Sim | Sim | Não |
| insert | Sim | Sim | Sim | Sim | Sim |
| parallelCollectionScan | Não | Não | Não | Não | Não |
| resetError | Não | Não | Não | Não | Não |
| atualizar | Sim | Sim | Sim | Sim | Sim |
| ReplaceOne | Sim | Sim | Sim | Sim | Sim |
### Comandos de gerenciamento de perfis
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| createRole | Sim | Sim | Sim | Sim | Não |
| dropAllRolesFromDatabase | Sim | Sim | Sim | Sim | Não |
| dropRole | Sim | Sim | Sim | Sim | Não |
| grantRolesToFunção | Sim | Sim | Sim | Sim | Não |
| revokeRolesFromFunção | Sim | Sim | Sim | Sim | Não |
| revokePrivilegesFromFunção | Sim | Sim | Sim | Sim | Não |
| rolesInfo | Sim | Sim | Sim | Sim | Não |
| updateRole | Sim | Sim | Sim | Sim | Não |
### Comandos de sessão
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| abortTransaction | Não | Sim | Sim | Sim | Não |
| commitTransaction | Não | Sim | Sim | Sim | Não |
| endSessions | Não | Não | Não | Não | Não |
| killAllSessions | Não | Sim | Sim | Sim | Não |
| killAllSessionsByPattern | Não | Não | Não | Não | Não |
| killSessions | Não | Sim | Sim | Sim | Não |
| refreshSessions | Não | Não | Não | Não | Não |
| startSession | Não | Sim | Sim | Sim | Não |
### Gerenciamento de usuários
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| createUser | Sim | Sim | Sim | Sim | Sim |
| dropAllUsersFromDatabase | Sim | Sim | Sim | Sim | Sim |
| dropUser | Sim | Sim | Sim | Sim | Sim |
| grantRolesToUsuário | Sim | Sim | Sim | Sim | Sim |
| revokeRolesFromUsuário | Sim | Sim | Sim | Sim | Sim |
| updateUser | Sim | Sim | Sim | Sim | Sim |
| usersInfo | Sim | Sim | Sim | Sim | Sim |
### Comandos de fragmentação
| Command | Cluster elástico |
| --- | --- |
| abortReshardCollection | Não |
| addShard | Não |
| addShardToZona | Não |
| balancerCollectionStatus | Não |
| balancerStart | Não |
| balancerStatus | Não |
| balancerStop | Não |
| checkShardingIndex | Não |
| clearJumboFlag | Não |
| cleanupOrphaned | Não |
| cleanupReshardCollection | Não |
| commitReshardCollection | Não |
| enableSharding | Sim |
| flushRouterConfig | Não |
| getShardMap | Não |
| getShardVersion | Não |
| isdbgrid | Não |
| listShards | Não |
| medianKey | Não |
| moveChunk | Não |
| movePrimary | Não |
| mergeChunks | Não |
| refineCollectionShardChave | Não |
| removeShard | Não |
| removeShardFromZona | Não |
| reshardCollection | Não |
| setAllowMigrations | Não |
| setShardVersion | Não |
| shardCollection | Sim |
| shardingState | Não |
| dividir | Não |
| splitVector | Não |
| unsetSharding | Não |
| updateZoneKeyAlcance | Não |
## Operadores de consulta e projeção
**Topics**
+ [Operadores de matriz](#mongo-apis-query-array-operators)
+ [Operadores bitwise](#mongo-apis-query-bitwise-operators)
+ [Operador de comentários](#mongo-apis-query-comment-operator)
+ [Operadores de comparação](#mongo-apis-query-comparison-operators)
+ [Operadores de elemento](#mongo-apis-query-element-operators)
+ [Operadores de consulta de avaliação](#mongo-apis-query-evaluation-operators)
+ [Operadores lógicos](#mongo-apis-query-logical-operators)
+ [Operadores de projeção](#mongo-apis-projection-operators)
### Operadores de matriz
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1elemMatch](elemMatch.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1size](size-query.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores bitwise
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1bitsAnySet](bitsAnySet.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1bitsAllClear](bitsAllClear.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1bitsAnyClear](bitsAnyClear.md) | Sim | Sim | Sim | Sim | Sim |
### Operador de comentários
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de comparação
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1gt](gt.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1gte](gte.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1in](in.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1lt](lt.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1lte](lte.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1ne](ne.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1nin](nin.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de elemento
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1type](type.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de consulta de avaliação
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | Não | Sim | Sim | Sim | Não |
| [\$1jsonSchema](jsonSchema.md) | Não | Sim | Sim | Sim | Não |
| [\$1mod](mod-query.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1regex](regex.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1text](text.md) | Não | Não | Sim | Sim | Não |
| \$1where | Não | Não | Não | Não | Não |
### Operadores lógicos
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1nor](nor.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1not](not.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1or](or.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de projeção
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1elemMatch](elemMatch.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1meta](meta.md) | Não | Não | Sim | Sim | Não |
| [\$1slice](slice-projection.md) | Sim | Sim | Sim | Sim | Sim |
## Operadores de atualização
**Topics**
+ [Operadores de matriz](#mongo-apis-update-array)
+ [Operadores bitwise](#mongo-apis-update-bitwise)
+ [Operadores de campo](#mongo-apis-update-field)
+ [Modificadores de atualização](#mongo-apis-update-modifiers)
### Operadores de matriz
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1[]](dollarBrackets-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1[]](dollarIdentifier-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1addToSet](addToSet.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1pop](pop.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1pullAll](pullAll.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1pull](pull.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1push](push.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores bitwise
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de campo
| Operador | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1inc](inc.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1max](max-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1min](min-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1mul](mul.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1rename](rename.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1set](set-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1setOnInsert](setOnInsert.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1unset](unset-update.md) | Sim | Sim | Sim | Sim | Sim |
### Modificadores de atualização
| Operador | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1position](position.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1slice](slice-update.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1sort](sort-update.md) | Sim | Sim | Sim | Sim | Sim |
## Geoespacial
### Especificadores de geometria
| Seletores de consulta | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1box | Não | Não | Não | Não | Não |
| \$1center | Não | Não | Não | Não | Não |
| \$1centerSphere | Não | Não | Não | Não | Não |
| [\$1geometry](geometry.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1maxDistance](maxDistance.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1minDistance](minDistance.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1nearSphere](nearSphere.md) | Sim | Sim | Sim | Sim | Sim |
| \$1polygon | Não | Não | Não | Não | Não |
| \$1uniqueDocs | Não | Não | Não | Não | Não |
### Seletores de consulta
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1geoWithin](geoWithin.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1near](near.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1nearSphere](nearSphere.md) | Sim | Sim | Sim | Sim | Sim |
| \$1polygon | Não | Não | Não | Não | Não |
| \$1uniqueDocs | Não | Não | Não | Não | Não |
## Métodos de cursor
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | Sim | Sim | Sim | Sim | Sim |
| cursor.close() | Sim | Sim | Sim | Sim | Sim |
| cursor.collation() | Não | Não | Não | Sim | Não |
| cursor.comment() | Sim | Sim | Sim | Sim | Sim |
| cursor.count() | Sim | Sim | Sim | Sim | Sim |
| cursor.explain() | Sim | Sim | Sim | Sim | Não |
| cursor.forEach() | Sim | Sim | Sim | Sim | Sim |
| cursor.hasNext() | Sim | Sim | Sim | Sim | Sim |
| cursor.hint() | Sim | Sim | Sim | Sim | Sim\$1 |
| cursor.isClosed() | Sim | Sim | Sim | Sim | Sim |
| cursor.isExhausted() | Sim | Sim | Sim | Sim | Não |
| cursor.itcount() | Sim | Sim | Sim | Sim | Não |
| cursor.limit() | Sim | Sim | Sim | Sim | Não |
| cursor.map() | Sim | Sim | Sim | Sim | Não |
| cursor.max() | Não | Não | Não | Não | Não |
| cursor.maxScan() | Sim | Sim | Sim | Sim | Não |
| cursor.maxTimeMS() | Sim | Sim | Sim | Sim | Não |
| cursor.min() | Não | Não | Não | Não | Não |
| cursor.next() | Sim | Sim | Sim | Sim | Sim |
| cursor. noCursorTimeout() | Não | Não | Não | Não | Não |
| cursor. objsLeftInBatch () | Sim | Sim | Sim | Sim | Não |
| cursor.pretty() | Sim | Sim | Sim | Sim | Não |
| cursor.readConcern() | Sim | Sim | Sim | Sim | Não |
| cursor.readPref() | Sim | Sim | Sim | Sim | Não |
| cursor.returnKey() | Não | Não | Não | Não | Não |
| cursor. showRecordId() | Não | Não | Não | Não | Não |
| cursor.size() | Sim | Sim | Sim | Sim | Não |
| cursor.skip() | Sim | Sim | Sim | Sim | Não |
| cursor.sort() | Sim | Sim | Sim | Sim | Não |
| cursor.tailable() | Não | Não | Não | Não | Não |
| cursor.toArray() | Sim | Sim | Sim | Sim | Não |
\$1 O `hint` de índice é compatível com expressões de índice. Por exemplo, .`db.foo.find().hint({x:1})`
## Operadores de pipeline de agregação
**Topics**
+ [Expressões do acumulador](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [Operadores aritméticos](#mongo-apis-aggregation-pipeline-arithmetic)
+ [Operadores de matriz](#mongo-apis-aggregation-pipeline-array)
+ [Operadores booleanos](#mongo-apis-aggregation-pipeline-boolean)
+ [Operadores de comparação](#mongo-apis-aggregation-pipeline-comparison)
+ [Operadores de expressão condicional](#mongo-apis-aggregation-pipeline-conditional)
+ [Operador de tipo de dados](#mongo-apis-aggregation-pipeline-data-type)
+ [Operador de tamanho de dados](#mongo-apis-aggregation-pipeline-data-size)
+ [Operadores de data](#mongo-apis-aggregation-pipeline-date)
+ [Operador literal](#mongo-apis-aggregation-pipeline-literal)
+ [Operador de mesclagem](#mongo-apis-aggregation-pipeline-merge)
+ [Operador natural](#mongo-apis-aggregation-pipeline-natural)
+ [Configurar operadores](#mongo-apis-aggregation-pipeline-set)
+ [Operadores de estágio](#mongo-apis-aggregation-pipeline-stage)
+ [Operadores de string](#mongo-apis-aggregation-pipeline-string)
+ [Variáveis do sistema](#mongo-apis-aggregation-pipeline-system-variables)
+ [Operador de pesquisa de texto](#mongo-apis-aggregation-pipeline-text-search)
+ [Operadores de conversão de tipo](#mongo-apis-aggregation-pipeline-type)
+ [Operadores variáveis](#mongo-apis-aggregation-pipeline-variable)
+ [Operadores diversos](#mongo-apis-aggregation-pipeline-misc)
### Expressões do acumulador
| Expressão | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1accumulator | - | - | Não | Não | Não |
| [\$1addToSet](addToSet-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1avg](avg.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1count](count.md) | - | - | Não | Não | Não |
| \$1covariancePop | Não | Não | Não | Não | Não |
| \$1covarianceSamp | Não | Não | Não | Não | Não |
| \$1denseRank | Não | Não | Não | Não | Não |
| \$1derivative | Não | Não | Não | Não | Não |
| \$1documentNumber | Não | Não | Não | Não | Não |
| \$1expMovingAvg | Não | Não | Não | Não | Não |
| [\$1first](first.md) | Sim | Sim | Sim | Sim | Sim |
| \$1integral | Não | Não | Não | Não | Não |
| [\$1last](last.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1max](max.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1min](min.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1push](push-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| \$1rank | Não | Não | Não | Não | Não |
| \$1shift | Não | Não | Não | Não | Não |
| \$1stdDevPop | Não | Não | Não | Não | Não |
| \$1stdDevSamp | Não | Não | Não | Não | Não |
| [\$1sum](sum.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores aritméticos
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1add](add.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1ceil](ceil.md) | Não | Sim | Sim | Sim | Sim |
| [\$1divide](divide.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1exp](exp.md) | Não | Sim | Sim | Sim | Sim |
| [\$1floor](floor.md) | Não | Sim | Sim | Sim | Sim |
| [\$1ln](ln.md) | Não | Sim | Sim | Sim | Sim |
| [\$1log](log.md) | Não | Sim | Sim | Sim | Sim |
| [\$1log10](log10.md) | Não | Sim | Sim | Sim | Sim |
| [\$1mod](mod.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1multiply](multiply.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1pow](pow.md) | Não | Não | Não | Sim | Não |
| \$1round | - | - | Não | Não | Não |
| [\$1sqrt](sqrt.md) | Não | Sim | Sim | Sim | Sim |
| [\$1subtract](subtract.md) | Sim | Sim | Sim | Sim | Sim |
| \$1trunc | Não | Não | Não | Não | Não |
### Operadores de matriz
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1arrayToObject](arrayToObject.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1concatArrays](concatArrays.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1filter](filter.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1first](first.md) | - | - | Sim | Sim | Não |
| [\$1in](in-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1indexOfArray](indexOfArray.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1isArray](isArray.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1last](last.md) | - | - | Sim | Sim | Não |
| [\$1objectToArray](objectToArray.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1range](range.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1reverseArray](reverseArray.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1reduce](reduce.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1size](size.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1slice](slice.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1zip](zip.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores booleanos
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1not](not-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1or](or-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de comparação
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1eq](eq-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1gt](gt-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1gte](gte-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1lt](lt-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1lte](lte-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1ne](ne-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores de expressão condicional
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1ifNull](ifNull.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1switch](switch.md) | Não | Sim | Sim | Sim | Não |
### Operador de tipo de dados
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | Sim | Sim | Sim | Sim | Sim |
### Operador de tamanho de dados
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | Não | Não | Não |
| \$1bsonSize | - | - | Não | Não | Não |
### Operadores de data
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1dateAdd](dateAdd.md) | Não | Não | Sim | Sim | Sim |
| [\$1dateDiff](dateDiff.md) | - | - | Sim | Sim | Não |
| \$1dateFromParts | Não | Não | Não | Não | Não |
| [\$1dateFromString](dateFromString.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1dateSubtract](dateSubtract.md) | Não | Não | Sim | Sim | Sim |
| \$1dateToParts | Não | Não | Não | Não | Não |
| [\$1dateToString](dateToString.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1dateTrunc](dateTrunc.md) | - | - | Não | Sim | Não |
| [\$1dayOfMonth](dayOfMonth.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1dayOfWeek](dayOfWeek.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1dayOfYear](dayOfYear.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1hour](hour.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1 isoDayOf Semana](isoDayOfWeek.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1isoWeek](isoWeek.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1isoWeekYear](isoWeekYear.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1millisecond](millisecond.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1minute](minute.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1month](month.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1second](second.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1week](week.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1year](year.md) | Sim | Sim | Sim | Sim | Sim |
### Operador literal
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | Sim | Sim | Sim | Sim | Sim |
### Operador de mesclagem
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | Sim | Sim | Sim | Sim | Sim |
### Operador natural
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1natural](natural.md) | Sim | Sim | Sim | Sim | Sim |
### Configurar operadores
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | Não | Sim | Sim | Sim | Sim |
| [\$1anyElementTrue](anyElementTrue.md) | Não | Sim | Sim | Sim | Sim |
| [\$1setDifference](setDifference.md) | Não | Sim | Sim | Sim | Sim |
| [\$1setEquals](setEquals.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1setIntersection](setIntersection.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1setIsSubset](setIsSubset.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1setUnion](setUnion.md) | Sim | Sim | Sim | Sim | Sim |
| \$1setWindowFields | Não | Não | Não | Não | Não |
### Operadores de estágio
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1bucket](bucket.md) | Não | Não | Não | Sim | Não |
| \$1bucketAuto | Não | Não | Não | Não |
| [\$1changeStream](changeStream.md) | Sim | Sim | Sim | Sim | Não |
| [\$1collStats](collStats.md) | Não | Sim | Sim | Sim | Não |
| [\$1count](count.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1currentOp](currentOp.md) | Sim | Sim | Sim | Sim | Sim |
| \$1facet | Não | Não | Não | Não | Não |
| [\$1geoNear](geoNear.md) | Sim | Sim | Sim | Sim | Sim |
| \$1graphLookup | Não | Não | Não | Não | Não |
| [\$1group](group.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1indexStats](indexStats.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1limit](limit.md) | Sim | Sim | Sim | Sim | Sim |
| \$1listLocalSessions | Não | Não | Não | Não | Não |
| \$1listSessions | Não | Não | Não | Não | Não |
| [\$1lookup](lookup.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1match](match.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1merge](merge.md) | - | - | Não | Sim | Não |
| [\$1out](out.md) | Sim | Sim | Sim | Sim | Não |
| \$1planCacheStats | - | - | Não | Não | Não |
| [\$1project](project.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1redact](redact.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1replaceRoot](replaceRoot.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1sample](sample.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1set](set-stage.md) | - | - | Não | Sim | Não |
| \$1setWindowFields | - | - | Não | Não | Não |
| [\$1skip](skip.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1sort](sort.md) | Sim | Sim | Sim | Sim | Sim |
| \$1sortByCount | Não | Não | Não | Não | Não |
| \$1unionWith | - | - | Não | Não | Não |
| [\$1unset](unset-stage.md) | - | - | Não | Sim | Não |
| [\$1unwind](unwind.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1 substituir por](replaceWith.md) | Não | Não | Não | Sim | Não |
| [\$1VectorSearch](vectorSearch.md) | Não | Não | Não | Sim | Não |
### Operadores de string
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1indexOfBytes](indexOfBytes.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1indexOfCP](indexOfCP.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1ltrim](ltrim.md) | Não | Sim | Sim | Sim | Não |
| [\$1regexFind](regexFind.md) | - | - | Sim | Sim | Não |
| [\$1regexFindAll](regexFindAll.md) | - | - | Sim | Sim | Não |
| [\$1regexMatch](regexMatch.md) | - | - | Sim | Sim | Não |
| [\$1replaceAll](replaceAll.md) | - | - | Sim | Sim | Não |
| [\$1replaceOne](replaceOne.md) | - | - | Sim | Sim | Não |
| [\$1rtrim](rtrim.md) | Não | Sim | Sim | Sim | Não |
| [\$1split](split.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1strcasecmp](strcasecmp.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1strLenBytes](strLenBytes.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1strLenCP](strLenCP.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1substr](substr.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1substrBytes](substrBytes.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1substrCP](substrCP.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1toLower](toLower.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1toUpper](toUpper.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1trim](trim.md) | Não | Sim | Sim | Sim | Não |
### Variáveis do sistema
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | Não | Não | Não | Não | Não |
| [\$1\$1DESCEND](DESCEND.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1\$1KEEP](KEEP.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1\$1PRUNE](PRUNE.md) | Sim | Sim | Sim | Sim | Sim |
| \$1\$1REMOVE | Não | Não | Não | Não | Não |
| [\$1 ROOT](ROOT.md) | Sim | Sim | Sim | Sim | Sim |
### Operador de pesquisa de texto
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | Não | Não | Sim | Sim | Não |
| [\$1search](search.md) | Não | Não | Sim | Sim | Não |
### Operadores de conversão de tipo
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1convert](convert.md) | Não | Sim | Sim | Sim | Sim |
| \$1isNumber | - | - | Não | Não | Não |
| [\$1toBool](toBool.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toDate](toDate.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toDecimal](toDecimal.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toDouble](toDouble.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toInt](toInt.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toLong](toLong.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toObjectId](toObjectId.md) | Não | Sim | Sim | Sim | Sim |
| [\$1toString](toString.md) | Não | Sim | Sim | Sim | Sim |
### Operadores variáveis
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | Sim | Sim | Sim | Sim | Sim |
| [\$1map](map.md) | Sim | Sim | Sim | Sim | Sim |
### Operadores diversos
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | Não | Não | Não |
| [\$1rand](rand.md) | - | - | Não | Sim | Não |
| \$1sampleRate | - | - | Não | Não | Não |
## Tipos de dados
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| Inteiro de 32 bit (int) | Sim | Sim | Sim | Sim | Sim |
| Inteiro de 64 bits (longo) | Sim | Sim | Sim | Sim | Sim |
| Array | Sim | Sim | Sim | Sim | Sim |
| Dados binários | Sim | Sim | Sim | Sim | Sim |
| Booleano | Sim | Sim | Sim | Sim | Sim |
| Data | Sim | Sim | Sim | Sim | Sim |
| DBPointer | Não | Não | Não | Não | Não |
| DBRefs | Não | Não | Não | Não | Não |
| Decimal128 | Sim | Sim | Sim | Sim | Sim |
| Duplo | Sim | Sim | Sim | Sim | Sim |
| JavaScript | Não | Não | Não | Não | Não |
| JavaScript(com escopo) | Não | Não | Não | Não | Não |
| MaxKey | Sim | Sim | Sim | Sim | Sim |
| MinKey | Sim | Sim | Sim | Sim | Sim |
| Null | Sim | Sim | Sim | Sim | Sim |
| Objeto | Sim | Sim | Sim | Sim | Sim |
| ObjectId | Sim | Sim | Sim | Sim | Sim |
| Expressão Regular | Sim | Sim | Sim | Sim | Sim |
| String | Sim | Sim | Sim | Sim | Sim |
| Símbolo | Não | Não | Não | Não | Não |
| Timestamp | Sim | Sim | Sim | Sim | Sim |
| Não definido | Não | Não | Não | Não | Não |
## Índices e propriedades de índice
**Topics**
+ [Índices](#mongo-apis-indexes)
+ [Propriedades de índice](#mongo-apis-index-properties)
### Índices
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | Sim | Sim | Sim | Sim | Sim |
| Índice 2d | Não | Não | Não | Não | Não |
| Índice Composto | Sim | Sim | Sim | Sim | Sim |
| Índice com hash | Não | Não | Não | Não | Não |
| Índice de várias chaves | Sim | Sim | Sim | Sim | Sim |
| Índice de campo único | Sim | Sim | Sim | Sim | Sim |
| Índice de texto | Não | Não | Sim | Sim | Não |
| Curinga | Não | Não | Não | Não | Não |
### Propriedades de índice
| Command | 3.6 | 4,0 | 5,0 | 8.0 | Cluster elástico |
| --- | --- | --- | --- | --- | --- |
| Contexto | Sim | Sim | Sim | Sim | Sim |
| Diferenciação entre maiúsculas e minúsculas | Não | Não | Não | Sim | Não |
| Oculto | Não | Não | Não | Não | Não |
| Parcial | Não | Não | Sim | Sim | Não |
| Sparse | Sim | Sim | Sim | Sim | Sim |
| Texto | Não | Não | Sim | Sim | Não |
| TTL | Sim | Sim | Sim | Sim | Sim |
| Exclusivo | Sim | Sim | Sim | Sim | Sim |
| Vector | Não | Não | Sim | Sim | Não |
Para obter informações detalhadas sobre operadores específicos do MongoDB, consulte os tópicos a seguir:
+ [Operadores de pipeline de agregação](mongo-apis-aggregation-pipeline-operators.md)
+ [Geoespacial](mongo-apis-geospatial-operators.md)
+ [Operadores de projeção](#mongo-apis-projection-operators)
+ [Operadores de atualização](mongo-apis-update-operators.md)
# Operadores de pipeline de agregação
Esta seção fornece informações detalhadas sobre operadores de pipeline de agregação suportados pelo Amazon DocumentDB.
**Topics**
+ [\$1\$1DESCEND](DESCEND.md)
+ [\$1\$1KEEP](KEEP.md)
+ [\$1\$1PRUNE](PRUNE.md)
+ [\$1 ROOT](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)
+ [\$1regexMatch](regexMatch.md)
+ [\$1replaceAll](replaceAll.md)
+ [\$1replaceOne](replaceOne.md)
+ [\$1replaceRoot](replaceRoot.md)
+ [\$1 substituir por](replaceWith.md)
+ [\$1reverseArray](reverseArray.md)
+ [\$1rtrim](rtrim.md)
+ [\$1sample](sample.md)
+ [\$1search](search.md)
+ [\$1second](second.md)
+ [\$1set](set-stage.md)
+ [\$1setDifference](setDifference.md)
+ [\$1setEquals](setEquals.md)
+ [\$1setIntersection](setIntersection.md)
+ [\$1setIsSubset](setIsSubset.md)
+ [\$1setUnion](setUnion.md)
+ [\$1skip](skip.md)
+ [\$1slice](slice.md)
+ [\$1size](size.md)
+ [\$1sort](sort.md)
+ [\$1split](split.md)
+ [\$1sqrt](sqrt.md)
+ [\$1strLenBytes](strLenBytes.md)
+ [\$1strLenCP](strLenCP.md)
+ [\$1strcasecmp](strcasecmp.md)
+ [\$1substr](substr.md)
+ [\$1substrBytes](substrBytes.md)
+ [\$1substrCP](substrCP.md)
+ [\$1subtract](subtract.md)
+ [\$1sum](sum.md)
+ [\$1switch](switch.md)
+ [\$1toBool](toBool.md)
+ [\$1toDate](toDate.md)
+ [\$1toDecimal](toDecimal.md)
+ [\$1toDouble](toDouble.md)
+ [\$1toInt](toInt.md)
+ [\$1toLong](toLong.md)
+ [\$1toLower](toLower.md)
+ [\$1toObjectId](toObjectId.md)
+ [\$1toString](toString.md)
+ [\$1toUpper](toUpper.md)
+ [\$1trim](trim.md)
+ [\$1type](type-aggregation.md)
+ [\$1unset](unset-stage.md)
+ [\$1unwind](unwind.md)
+ [\$1VectorSearch](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
O `$$DESCEND` operador no Amazon DocumentDB é um operador especial de matriz posicional usado no estágio do `$redact` pipeline. Ele instrui o pipeline de agregação a descer até o documento atual e processar todos os campos, independentemente do nível de aninhamento.
Quando o `$redact` estágio encontra o `$$DESCEND` operador, ele mantém todos os campos do documento atual visíveis e os processa mais adiante. Isso é útil quando você deseja redigir ou remover seletivamente determinados campos com base em uma condição, mantendo a estrutura do documento.
**Parâmetros**
Nenhum.
## Exemplo (MongoDB Shell)
Neste exemplo, usaremos o `$redact` estágio com o `$$DESCEND` operador para exibir seletivamente documentos em que o `code` campo é igual a “Reg”.
**Crie documentos de amostra**
```
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" }
]);
```
**Exemplo de consulta**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**Saída**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## Exemplos de código
Para ver um exemplo de código para usar o `$$DESCEND` comando, escolha a guia do idioma que você deseja 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
A variável `$$KEEP` do sistema é usada com o `$redact` estágio no pipeline de agregação para manter o documento ou campo atual inalterado e incluí-lo na saída.
**Parâmetros**
Nenhum
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso de `$$KEEP` em um pipeline de agregação do Amazon DocumentDB. Os documentos só são mantidos se o acesso for igual a “público”, caso contrário, eles serão removidos.
**Crie documentos de amostra**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**Exemplo de consulta**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**Saída**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$$KEEP` comando, escolha a guia do idioma que você deseja 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
A variável `$$PRUNE` do sistema é usada com o `$redact` estágio no pipeline de agregação para excluir documentos ou níveis de documentos incorporados dos resultados. Quando uma condição é avaliada como`$$PRUNE`, o documento ou subdocumento atual é removido da saída. Geralmente é usado com `$$DESCEND` (para manter e percorrer o documento) ou `$$KEEP` (para manter o documento em todos os níveis).
**Parâmetros**
Nenhum. A variável `$$PRUNE` do sistema é usada sem nenhum parâmetro e deve ser usada com`$redact`.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar `$$PRUNE` with `$redact` para excluir usuários com mais de 30 anos dos resultados.
**Crie documentos de amostra**
```
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" } }
])
```
**Exemplo de consulta**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**Saída**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$$PRUNE` comando, escolha a guia do idioma que você deseja 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 ROOT
O `$ROOT` operador no Amazon DocumentDB é usado para referenciar todo o documento de entrada em um pipeline de agregação. Ele permite que você acesse e manipule o documento completo, incluindo todos os seus campos e estruturas aninhados.
**Parâmetros**
Nenhum
## Exemplo (MongoDB Shell)
Este exemplo demonstra o uso `$ROOT` para criar um registro de auditoria que captura o documento original completo junto com os metadados sobre quando ele foi processado.
**Crie documentos de amostra**
```
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
}
]);
```
**Exemplo de consulta**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**Saída**
```
[
{
_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'
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$ROOT` comando, escolha a guia do idioma que você deseja 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
O `$abs` operador no Amazon DocumentDB retorna o valor absoluto de um número. Ele pode ser usado no pipeline de agregação para realizar operações matemáticas em campos numéricos.
**Parâmetros**
+ `number`: a expressão numérica para a qual o valor absoluto será retornado.
## Exemplo (MongoDB Shell)
Este exemplo demonstra o uso do `$abs` operador para encontrar o valor absoluto de um campo numérico.
**Crie documentos de amostra**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**Exemplo de consulta**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**Saída**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$abs` comando, escolha a guia do idioma que você deseja 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
O `$add` operador no Amazon DocumentDB é usado para somar números ou datas. Ele pode ser usado para realizar operações aritméticas em campos numéricos ou para realizar aritmética de data adicionando várias unidades de tempo a um campo de data.
**Parâmetros**
+ `expression1`: o primeiro número ou data a ser adicionado.
+ `expression2`: o segundo número ou data a ser adicionado.
+ `expression3`: (opcional) Números ou datas adicionais a serem adicionados.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$add` operador para somar dois números.
**Crie documentos de amostra**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**Exemplo de consulta**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**Saída**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
Neste exemplo, o `$add` operador é usado para adicionar os valores dos `b` campos `a` e para cada documento e armazenar o resultado no `sum` campo.
## Exemplos de código
Para ver um exemplo de código para usar o `$add` comando, escolha a guia do idioma que você deseja 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
O operador `$addToSet` de agregação retorna uma matriz de valores exclusivos de uma expressão especificada para cada grupo. Ele é usado dentro do `$group` estágio para acumular valores distintos, eliminando automaticamente as duplicatas.
**Parâmetros**
+ `expression`: a expressão a ser avaliada para cada documento no grupo.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$addToSet` operador para coletar cidades exclusivas onde os pedidos foram feitos para cada cliente.
**Crie documentos de amostra**
```
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 }
]);
```
**Exemplo de consulta**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**Saída**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o operador de `$addToSet` agregação, escolha a guia do idioma que você deseja 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
O `$addFields` estágio no pipeline de agregação do Amazon DocumentDB permite que você adicione novos campos computados aos documentos. Isso pode ser útil para adicionar dados derivados ou transformados aos documentos.
**Parâmetros**
+ `newField`: o nome do novo campo a ser adicionado.
+ `expression`: uma expressão que se resolve com o valor do novo campo.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar `$addFields` para adicionar um novo campo `TotalInventory` que calcula o estoque total com base nos campos `Inventory.OnHand` e. `Inventory.OrderQnty`
**Crie documentos de amostra**
```
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
}
]);
```
**Exemplo de consulta**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**Saída**
```
[
{
"_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
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$addFields` comando, escolha a guia do idioma que você deseja 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
Novo da versão 4.0
O `$allElementsTrue` operador é usado para verificar se todos os elementos em uma matriz são avaliados como um valor verdadeiro.
**Parâmetros**
+ `expression`: uma expressão que é avaliada como uma matriz.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso de `$allElementsTrue` para verificar se todos os elementos em uma matriz são verdadeiros.
**Crie documentos de amostra**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**Exemplo de consulta**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**Saída**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
Neste exemplo, a consulta verifica se todos os elementos na `scores` matriz são maiores que 0. O documento com `"name": "Jane"` é excluído porque a `scores` matriz contém um 0, que é um valor falso.
## Exemplos de código
Para ver um exemplo de código para usar o `$allElementsTrue` comando, escolha a guia do idioma que você deseja 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
O operador `$and` de agregação avalia várias expressões e retorna `true` somente se todas as expressões forem avaliadas como. `true` Se alguma expressão for`false`, ela retornará`false`.
**Parâmetros**
+ `expressions`: uma matriz de expressões para avaliar.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$and` operador para verificar se os produtos atendem a vários critérios.
**Crie documentos de amostra**
```
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 }
]);
```
**Exemplo de consulta**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**Saída**
```
[
{ _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 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o operador de `$and` agregação, escolha a guia do idioma que você deseja 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
Novo da versão 4.0
O `$anyElementTrue` operador é usado para determinar se algum elemento em uma matriz é verdadeiro.
**Parâmetros**
+ `field`: um campo de matriz para avaliar.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso de `$anyElementTrue` para verificar se algum elemento em uma matriz é verdadeiro.
**Crie documentos de amostra**
```
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] }
])
```
**Exemplo de consulta**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**Saída**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$anyElementTrue` comando, escolha a guia do idioma que você deseja 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
O `$arrayElemAt` operador no Amazon DocumentDB permite que você recupere um elemento de uma matriz de acordo com sua posição no índice. Isso é particularmente útil quando você precisa acessar um elemento específico em um campo de matriz em seus documentos.
**Parâmetros**
+ `array`: a matriz de entrada da qual um elemento deve ser recuperado.
+ `index`: a posição do índice com base em zero do elemento a ser recuperado. Esse valor deve ser um número inteiro não negativo.
## Exemplo (MongoDB Shell)
Neste exemplo, demonstraremos como usar o `$arrayElemAt` operador para recuperar elementos específicos da `flight_miles` matriz na `miles` coleção.
**Crie documentos de amostra**
```
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 ]}
]);
```
**Exemplo de consulta**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**Saída**
```
{ "_id" : 1, "first_mile" : 1205, "last_mile" : 880 }
{ "_id" : 2, "first_mile" : 1205, "last_mile" : 2780 }
{ "_id" : 3, "first_mile" : 1205, "last_mile" : 880 }
```
Neste exemplo, usamos o `$arrayElemAt` operador para recuperar o primeiro e o último elementos da `flight_miles` matriz para cada documento.
## Exemplos de código
Para ver um exemplo de código para usar o `$arrayElemAt` comando, escolha a guia do idioma que você deseja 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
O `$arrayToObject` operador no Amazon DocumentDB é o inverso do `$objectToArray` operador. Ele pega uma matriz de documentos de pares de valores-chave e os converte em um único documento. Isso é particularmente útil quando você precisa converter uma matriz de pares de valores-chave novamente em uma estrutura de objeto ou documento.
**Parâmetros**
+ `array expression`: uma expressão que se resolve em uma matriz. Os elementos da matriz devem ser documentos com dois campos: `k` (a chave) e `v` (o valor).
## Exemplo (MongoDB Shell)
O exemplo abaixo demonstra como usar `$arrayToObject` para converter uma matriz de pares de valores-chave em um documento.
**Crie documentos de amostra**
```
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 } }
]);
```
**Exemplo de consulta**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**Saída**
```
{ "_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 } }
```
Neste exemplo, o `$objectToArray` operador é usado para converter o `inventory` objeto em uma matriz de pares de valores-chave. O `$arrayToObject` operador é então usado para converter a matriz novamente em um documento, restaurando a estrutura original do objeto.
## Exemplos de código
Para ver um exemplo de código para usar o `$arrayToObject` comando, escolha a guia do idioma que você deseja 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
O operador `$avg` de agregação no Amazon DocumentDB calcula o valor médio da expressão especificada nos documentos que são inseridos no palco. Esse operador é útil para calcular a média de um campo ou expressão numérica em um conjunto de documentos.
**Parâmetros**
+ `expression`: a expressão a ser usada para calcular a média. Isso pode ser um caminho de campo (por exemplo`"$field"`) ou uma expressão (por exemplo`{ $multiply: ["$field1", "$field2"] }`).
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$avg` operador para calcular a pontuação média em um conjunto de documentos do aluno.
**Crie documentos de amostra**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**Exemplo de consulta**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**Saída**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$avg` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 8.0
Não é compatível com o cluster elástico.
O estágio `$bucket` de agregação no Amazon DocumentDB permite agrupar documentos de entrada em buckets com base em uma expressão e limites de bucket especificados. Isso pode ser útil para analisar dados que se enquadram em determinadas faixas de valores ou categorias.
**Parâmetros**
+ `groupBy`(obrigatório): a expressão que especifica o valor pelo qual agrupar.
+ `boundaries`(obrigatório): uma matriz de valores duplos que define os limites do intervalo. Os documentos são atribuídos a compartimentos com base no valor da `groupBy` expressão que está dentro dos limites especificados.
+ `default`(opcional): um valor literal que é gerado para documentos cujo valor de `groupBy` expressão não se enquadra em nenhum dos limites especificados.
+ `output`(opcional): um objeto que especifica as informações a serem enviadas para cada bucket. Você pode usar operadores de acumulador como`$sum`, `$avg``$min`, e `$max` para calcular agregações para cada bucket.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$bucket` estágio para agrupar dados de vendas por faixa de preço.
**Crie documentos de amostra**
```
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") }
]);
```
**Exemplo 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 }
}
])
```
**Saída**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$bucket` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 4.0
O `$ceil` operador no Amazon DocumentDB, assim como no MongoDB, arredonda um número até o número inteiro mais próximo. Isso é útil quando você precisa realizar operações matemáticas em campos numéricos e garantir que o resultado seja um número inteiro.
**Parâmetros**
+ `expression`: A expressão numérica a ser arredondada para cima.
## Exemplo (MongoDB Shell)
Este exemplo demonstra como usar o `$ceil` operador para arredondar um campo numérico.
**Crie documentos de amostra**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**Exemplo de consulta**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**Saída**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## Exemplos de código
Para ver um exemplo de código para usar o `$ceil` comando, escolha a guia do idioma que você deseja 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
Não é compatível com o cluster elástico.
O estágio `$changeStream` de agregação abre um cursor de fluxo de alterações para monitorar as alterações em tempo real em uma coleção. Ele retorna documentos de eventos de alteração quando ocorrem operações de inserção, atualização, substituição ou exclusão.
**Parâmetros**
+ `fullDocument`: especifica se o documento completo deve ser retornado para operações de atualização. As opções são `default` ou `updateLookup`.
+ `resumeAfter`: opcional. Retomar o token para continuar a partir de um ponto específico no fluxo de mudança.
+ `startAtOperationTime`: opcional. Carimbo de data/hora a partir do qual iniciar o fluxo de mudança.
+ `allChangesForCluster`: opcional. Valor booleano. Quando`true`, observa todas as alterações no cluster (para banco de dados administrativo). Quando `false` (padrão), observa somente a coleção especificada.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$changeStream` palco para monitorar as alterações em uma coleção.
**Exemplo 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()));
}
```
**Saída**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## Exemplos de código
Para ver um exemplo de código para usar o estágio de `$changeStream` agregação, escolha a guia do idioma que você deseja 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
O `$cmp` operador no Amazon DocumentDB é usado para comparar dois valores e retornar um valor inteiro que indica sua ordem relativa. É um operador de comparação que compara duas expressões e retorna um valor inteiro de -1, 0 ou 1, dependendo se o primeiro valor é menor, igual ou maior que o segundo valor, respectivamente.
**Parâmetros**
+ `expression1`: A primeira expressão a ser comparada.
+ `expression2`: A segunda expressão a ser comparada.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$cmp` operador para comparar dois valores numéricos.
**Crie documentos de amostra**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**Exemplo de consulta**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**Saída**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
Neste exemplo, o `$cmp` operador compara os `value2` campos `value1` e de cada documento. O resultado é:
```
- `$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).
```
## Exemplos de código
Para ver um exemplo de código para usar o `$cmp` comando, escolha a guia do idioma que você deseja usar:
------
#### [ Node.js ]
Aqui está um exemplo de uso do `$cmp` operador em um aplicativo Node.js com o `mongodb` driver:
```
const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
async function main() {
await client.connect();
const db = client.db('test');
const collection = db.collection('mycollection');
// Insert sample documents
await collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
// Query using $cmp operator
const result = await collection.find({
$expr: {
$cmp: ['$value1', '$value2']
}
}).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
Aqui está um exemplo de uso do `$cmp` operador em um aplicativo Python com o `pymongo` driver:
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['mycollection']
# Insert sample documents
collection.insert_many([
{'_id': 1, 'value1': 10, 'value2': 20},
{'_id': 2, 'value1': 15, 'value2': 15},
{'_id': 3, 'value1': 20, 'value2': 10}
])
# Query using $cmp operator
result = list(collection.find({
'$expr': {
'$cmp': ['$value1', '$value2']
}
}))
print(result)
client.close()
```
A saída dos exemplos do Node.js e do Python será a mesma do exemplo do MongoDB Shell:
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
Novo a partir da versão 4.0
O estágio `$collStats` de agregação no Amazon DocumentDB fornece estatísticas sobre a coleção especificada, semelhante ao comando `db.collection.stats()` no shell do MongoDB. Esse estágio pode ser usado para recuperar informações sobre a coleção, como o número de documentos, o tamanho total da coleção e várias métricas de desempenho.
**Parâmetros**
+ `latencyStats`: (opcional) Um documento que especifica as opções para coletar estatísticas de latência. Esse parâmetro não é suportado no Amazon DocumentDB.
+ `recordStats`: (opcional) Um documento que especifica as opções para coletar estatísticas de registros. Esse parâmetro não é suportado no Amazon DocumentDB.
+ `queryExecStats`: (opcional) Um documento que especifica as opções para coletar estatísticas de execução da consulta. Esse parâmetro não é suportado no Amazon DocumentDB.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o estágio de `$collStats` agregação para recuperar estatísticas sobre uma coleção nomeada `test` no banco de dados. `db`
**Crie documentos de amostra**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**Exemplo de consulta**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**Saída**
```
{
"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)
}
```
## Exemplos de código
Para ver um exemplo de código para usar o `$collStats` comando, escolha a guia do idioma que você deseja usar:
------
#### [ Node.js ]
Aqui está um exemplo de como usar o estágio de `$collStats` agregação em um aplicativo Node.js usando o driver oficial do MongoDB Node.js:
```
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 ]
Aqui está um exemplo de como usar o estágio de `$collStats` agregação em um aplicativo Python usando o PyMongo driver:
```
from pymongo import MongoClient
def run_coll_stats_example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['db']
collection = db['test']
result = list(collection.aggregate([
{ '$collStats': {} }
]))
print(result)
client.close()
run_coll_stats_example()
```
------
# \$1concat
O operador de `$concat` agregação no Amazon DocumentDB concatena (ou combina) várias sequências de caracteres em um documento para produzir uma única sequência de caracteres que pode ser retornada ao aplicativo. Isso reduz o trabalho realizado no aplicativo, pois a manipulação de strings é realizada no nível do banco de dados.
**Parâmetros**
+ `expression1`: a primeira string a ser concatenada.
+ `expression2`: a segunda string a ser concatenada.
+ `...`: sequências adicionais para concatenar (opcional).
## Exemplo (MongoDB Shell)
Neste exemplo, concatenamos o nome e o sobrenome dos usuários para produzir o nome completo de cada pessoa.
**Crie documentos de amostra**
```
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"}
])
```
**Exemplo de consulta**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**Saída**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## Exemplos de código
Para ver um exemplo de código para usar o `$concat` comando, escolha a guia do idioma que você deseja 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
O operador `$concatArrays` de agregação no Amazon DocumentDB é usado para concatenar duas ou mais matrizes em uma única matriz. Isso pode ser útil quando você precisa combinar várias matrizes de dados em uma única matriz para processamento ou análise adicionais.
**Parâmetros**
+ `array1`: a primeira matriz a ser concatenada.
+ `array2`: a segunda matriz a ser concatenada.
+ `[array3, ...]`: (opcional) Matrizes adicionais a serem concatenadas.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$concatArrays` operador para combinar duas matrizes em uma única matriz.
**Crie documentos de amostra**
```
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"]
}
]);
```
**Exemplo de consulta**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**Saída**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$concatArrays` comando, escolha a guia do idioma que você deseja 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
O `$cond` operador no Amazon DocumentDB é usado para avaliar uma expressão condicional e retornar uma das duas expressões de resultado possíveis.
**Parâmetros**
+ `if`: A expressão booleana a ser avaliada.
+ `then`: a expressão a ser retornada se a `if` expressão for verdadeira.
+ `else`: a expressão a ser retornada se a `if` expressão for falsa.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$cond` operador para retornar um valor com base na idade de uma pessoa.
**Crie documentos de amostra**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**Exemplo 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"
}
}
}
}
}
}
])
```
**Saída**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$cond` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 4.0
O `$convert` operador no Amazon DocumentDB é usado para converter um valor de um tipo de dados para outro. Esse operador é útil quando você precisa realizar operações em dados de diferentes tipos, como converter uma string em um número ou uma data em um timestamp.
**Parâmetros**
+ `to`: o tipo de dados de destino para o qual converter o valor. Os valores compatíveis são `"string"`, `"double"`, `"long"`, `"int"`, `"date"` e `"boolean"`.
+ `from`: o tipo de dados atual do valor. Se não for especificado, o Amazon DocumentDB tentará detectar automaticamente o tipo de dados.
+ `onError`: (opcional) O valor a ser retornado se a conversão falhar. Pode ser um valor específico ou um dos seguintes valores especiais:`"null"`,`"zerofill"`, ou`"error"`.
+ `onNull`: (opcional) O valor a ser retornado se o valor de entrada for`null`. Pode ser um valor específico ou um dos seguintes valores especiais:`"null"`,`"zerofill"`, ou`"error"`.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra a conversão de um valor de string em uma data usando o `$convert` operador.
**Crie documentos de amostra**
```
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" }
]);
```
**Exemplo de consulta**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**Saída**
```
[
{ "_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 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$convert` comando, escolha a guia do idioma que você deseja 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
O estágio `$count` de agregação no Amazon DocumentDB é usado para contar o número de documentos que passam para o estágio. Geralmente é usado como o estágio final em um pipeline de agregação para retornar a contagem total de documentos correspondentes aos estágios anteriores.
**Parâmetros**
+ `field`: O campo a ser contado. Esse parâmetro é opcional e, se não for fornecido, o estágio contará o número total de documentos de entrada.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$count` palco para obter o número total de documentos em uma coleção.
**Crie documentos de amostra**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**Exemplo de consulta**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**Saída**
```
{ "total" : 4 }
```
O exemplo agrega a `users` coleção e usa o `$count` estágio para contar o número total de documentos.
## Exemplos de código
Para ver um exemplo de código para usar o `$count` comando, escolha a guia do idioma que você deseja 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
O estágio `$currentOp` de agregação retorna informações sobre as operações atualmente em execução no banco de dados. Esse estágio é útil para monitorar consultas e operações ativas em um pipeline de agregação.
**Parâmetros**
+ `allUsers`(opcional): quando definido como`true`, retorna as operações para todos os usuários. O padrão é `false`.
+ `idleConnections`(opcional): quando definido como`true`, inclui conexões inativas. O padrão é `false`.
+ `idleCursors`(opcional): quando definido como`true`, inclui informações sobre cursores inativos. O padrão é `false`.
+ `idleSessions`(opcional): quando definido como`true`, inclui informações sobre sessões ociosas. O padrão é `true`.
+ `localOps`(opcional): quando definido como`true`, inclui operações locais. O padrão é `false`.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do estágio de `$currentOp` agregação para recuperar informações sobre operações de leitura ativas.
**Exemplo de consulta**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**Saída**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$currentOp` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 5.0
O operador `$dateAdd` de agregação no Amazon DocumentDB permite que você adicione uma duração a um valor de data e hora.
**Parâmetros**
+ `date`: um valor de data e hora ao qual adicionar uma duração.
+ `duration`: a duração a ser adicionada ao `date` valor. Isso pode ser especificado como um objeto com chaves para `years``months`, `weeks``days`,`hours`,`minutes`,, `seconds` e.
+ `timezone`: (opcional) O fuso horário a ser usado ao realizar a adição da data. Se não for especificado, o fuso horário padrão do cluster Amazon DocumentDB será usado.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$dateAdd` operador para adicionar 2 dias e 12 horas a uma data.
**Crie documentos de amostra**
```
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") }
]);
```
**Exemplo de consulta**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**Saída**
```
[
{
"_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)"
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dateAdd` comando, escolha a guia do idioma que você deseja 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
Novo da versão 5.0
Não é compatível com o cluster elástico.
O operador `$dateDiff` de agregação calcula a diferença entre duas datas em unidades especificadas. Ele retorna o número de limites de unidades cruzados entre as datas de início e término.
**Parâmetros**
+ `startDate`: A expressão da data inicial.
+ `endDate`: A expressão da data final.
+ `unit`: A unidade de tempo para a diferença. As unidades suportadas são `year` `quarter``month`,`week`,`day`, `hour``minute`,`second`,, `millisecond` e.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$dateDiff` operador para calcular o número de dias entre a realização do pedido e a entrega.
**Crie documentos de amostra**
```
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")
}
]);
```
**Exemplo de consulta**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**Saída**
```
[
{
_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
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dateDiff` comando, escolha a guia do idioma que você deseja 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
O operador `$dateFromString` de agregação no Amazon DocumentDB permite que você converta uma string de data e hora em um objeto de data. Isso é útil quando seus dados são armazenados como cadeias de caracteres, mas você precisa realizar operações com base em datas nos dados.
**Parâmetros**
+ `dateString`: uma sequência de caracteres que representa uma data e hora.
+ `format`: (opcional) Uma string que especifica o formato do`dateString`. Se não for fornecido, o Amazon DocumentDB tentará analisar a string no formato ISO-8601.
+ `timezone`: (opcional) Uma string que especifica o fuso horário. Se não for fornecido, o Amazon DocumentDB usará o fuso horário do servidor.
+ `onError`: (opcional) Especifica a ação a ser tomada se a conversão falhar. Os valores possíveis são `'error'` (o padrão, que gera um erro), `'null'` (retorna`null`) ou `'replace'` (substitui o valor pela string de substituição especificada na `onErrorMessage` opção).
+ `onErrorMessage`: (opcional) Se `onError` estiver definida como`'replace'`, essa opção especifica a sequência de caracteres de substituição.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar `$dateFromString` para converter uma string de data em um objeto de data no Amazon DocumentDB.
**Crie documentos de amostra**
```
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"}
]);
```
**Exemplo de consulta**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**Saída**
```
[
{
"_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")
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dateFromString` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 5.0
O operador `$dateSubtract` de agregação no Amazon DocumentDB permite que você subtraia uma duração especificada de um valor de data.
**Parâmetros**
+ `date`: uma expressão de data que se transforma em uma data ou carimbo de data/hora.
+ `subtrahend`: uma expressão de duração que especifica a quantidade de tempo a ser subtraída da `date` expressão.
+ `unit`: uma string que especifica a unidade de tempo para a `subtrahend` expressão. As unidades suportadas são “ano”, “trimestre”, “mês”, “semana”, “dia”, “hora”, “minuto”, “segundo” e “milissegundo”.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$dateSubtract` operador para calcular a data de um ano atrás a partir da data atual.
**Crie documentos de amostra**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**Exemplo de consulta**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**Saída**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dateSubtract` comando, escolha a guia do idioma que você deseja 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
O operador `$dateToString` de agregação no Amazon DocumentDB é usado para converter um valor de data ou timestamp em uma representação de string. Isso é útil quando você precisa formatar a data e a hora de uma forma específica para exibição ou processamento posterior.
**Parâmetros**
+ `date`: o valor da data ou do carimbo de data/hora a ser convertido em uma string.
+ `format`: uma string que especifica o formato no qual a data deve ser representada. A string de formato pode incluir vários especificadores de formato, como `%Y` para o ano de quatro dígitos, `%m` para o mês de dois dígitos, para o dia do mês com dois dígitos etc. `%d`
+ `timezone`: (opcional) O fuso horário a ser usado para a conversão. Se não for especificado, o fuso horário do servidor que hospeda o cluster Amazon DocumentDB será usado.
+ `onNull`: (opcional) O valor a ser retornado se o `date` parâmetro for`null`.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$dateToString` operador para formatar o `logDate` campo da `missionLog` coleção.
**Crie documentos de amostra**
```
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") }
]);
```
**Exemplo de consulta**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**Saída**
```
[
{
"_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"
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dateToString` comando, escolha a guia do idioma que você deseja usar:
------
#### [ Node.js ]
Aqui está um exemplo de uso do `$dateToString` operador em um aplicativo 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 ]
Aqui está um exemplo de uso do `$dateToString` operador em um aplicativo 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
Novo da versão 8.0
Não é compatível com o cluster elástico.
O operador `$dateTrunc` de agregação no Amazon DocumentDB trunca uma data para uma unidade especificada.
**Parâmetros**
+ `date`: uma expressão de data que se transforma em uma data ou carimbo de data/hora.
+ `unit`: uma string que especifica a unidade de tempo para a expressão subtrahend. As unidades suportadas são `year` `quarter``month`,`week`,`day`, `hour``minute`,`second`,, `millisecond` e.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$dateTrunc` operador para truncar uma data até a hora.
**Crie documentos de amostra**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**Exemplo de consulta**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**Saída**
```
[
{
_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')
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dateTrunc` comando, escolha a guia do idioma que você deseja 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
O operador `$dayOfMonth` de agregação no Amazon DocumentDB recupera o dia do mês (de 1 a 31) de uma determinada data. Esse operador é útil para agrupar, filtrar ou extrair o dia do mês dos campos de data em seus documentos.
**Parâmetros**
+ `date expression`: a expressão de data pode ser um campo de data do documento, um objeto de data ou uma string de data.
## Exemplo (MongoDB Shell)
Este exemplo demonstra como usar o `$dayOfMonth` operador para extrair o dia do mês de um campo de data no documento.
**Crie documentos de amostra**
```
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") }
]);
```
**Exemplo de consulta**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**Saída**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dayOfMonth` comando, escolha a guia do idioma que você deseja 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
O `$dayOfWeek` operador no Amazon DocumentDB extrai o dia da semana de um determinado campo de data. Ele retorna o dia da semana como um número entre 1 (domingo) e 7 (sábado), que é o mesmo comportamento do MongoDB.
**Parâmetros**
+ `date field`: O campo de data do qual extrair o dia da semana.
## Exemplo (MongoDB Shell)
Este exemplo demonstra como usar o `$dayOfWeek` operador para extrair o dia da semana do `date` campo na `weather` coleção.
**Crie documentos de amostra**
```
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")
}
]);
```
**Exemplo de consulta**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**Saída**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dayOfWeek` comando, escolha a guia do idioma que você deseja 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
O `$dayOfYear` operador no Amazon DocumentDB retorna o dia do ano de uma data como um número entre 1 e 366 (365 em anos não bissextos).
**Parâmetros**
+ `expression`: o campo de data ou expressão do qual extrair o dia do ano.
## Exemplo (MongoDB Shell)
Este exemplo demonstra como usar o `$dayOfYear` operador para extrair o dia do ano de um campo de data em uma coleção do Amazon DocumentDB.
**Crie documentos de amostra**
```
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")
}
])
```
**Exemplo de consulta**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**Saída**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## Exemplos de código
Para ver um exemplo de código para usar o `$dayOfYear` comando, escolha a guia do idioma que você deseja 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
O `$divide` operador no pipeline de agregação do Amazon DocumentDB é usado para dividir um número por outro. É um operador útil para realizar operações matemáticas em campos numéricos em seus documentos.
**Parâmetros**
+ `numerator`: O dividendo ou o número a ser dividido.
+ `denominator`: O divisor ou o número pelo qual dividir.
## Exemplo (MongoDB Shell)
Este exemplo demonstra como usar o `$divide` operador para calcular a taxa horária dos funcionários com base no salário anual e no número de horas de trabalho por ano.
**Crie documentos de amostra**
```
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 }
]);
```
**Exemplo de consulta**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**Saída**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$divide` comando, escolha a guia do idioma que você deseja 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
O operador `$eq` de agregação compara dois valores e retorna `true` se eles forem iguais, caso contrário, retorna. `false`
**Parâmetros**
+ `expression1`: o primeiro valor a ser comparado.
+ `expression2`: O segundo valor a ser comparado.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$eq` operador para verificar se as quantidades do produto correspondem aos valores-alvo.
**Crie documentos de amostra**
```
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 }
]);
```
**Exemplo de consulta**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**Saída**
```
[
{ _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 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o operador de `$eq` agregação, escolha a guia do idioma que você deseja 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
Novo a partir da versão 4.0
O `$exp` operador no Amazon DocumentDB permite que você eleve a constante e para um determinado número.
**Parâmetros**
+ `expression`: A expressão a ser avaliada. Isso pode ser qualquer expressão de agregação válida, incluindo referências de campo, operações aritméticas e outros estágios de agregação.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$exp` operador para encontrar todos os documentos em que o `quantity` campo é maior que o `price` campo.
**Crie documentos de amostra**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**Exemplo de consulta**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**Saída**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$exp` comando, escolha a guia do idioma que você deseja 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
O `$filter` operador no Amazon DocumentDB é usado para aplicar uma expressão de filtro a cada elemento de uma matriz e retornar uma matriz contendo somente os elementos que correspondem à condição especificada. Esse operador é útil quando você precisa realizar operações de filtragem complexas em campos de matriz em seus documentos.
**Parâmetros**
+ `input`: o campo de matriz a ser filtrado.
+ `as`: o nome da variável a ser usada para cada elemento da `input` matriz na `cond` expressão.
+ `cond`: a expressão booleana que determina se um determinado elemento deve ser incluído na matriz de saída.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra como usar o `$filter` operador para projetar o cliente de cada pedido e criar um novo campo de matriz PaidItems contendo somente os itens da matriz de itens em que o preço é maior que 15. Essencialmente, ele filtra os itens de cada pedido para incluir apenas produtos que custam mais de 15.
**Crie documentos de amostra**
```
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 }
]}
]);
```
**Exemplo de consulta**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**Saída**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$filter` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 5.0.
Não é compatível com o cluster elástico.
O `$first` operador no Amazon DocumentDB retorna o primeiro documento de um conjunto agrupado de documentos. É comumente usado em pipelines de agregação para recuperar o primeiro documento que corresponda a uma condição específica.
**Parâmetros**
+ `expression`: a expressão a ser retornada como o primeiro valor em cada grupo.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$first` operador para recuperar o primeiro valor do item encontrado para cada categoria durante a agregação.
Nota: `$first` retorna o primeiro documento com base na ordem atual dos documentos no pipeline. Para garantir um pedido específico (por exemplo, por data, preço etc.), um `$sort` estágio deve ser usado antes do `$group` estágio.
**Crie documentos de amostra**
```
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" }
]);
```
**Exemplo de consulta**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**Saída**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$first` comando, escolha a guia do idioma que você deseja 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
Novo a partir da versão 4.0.
O `$floor` operador no Amazon DocumentDB retorna o maior número inteiro menor ou igual ao número especificado. Esse operador é útil para arredondar valores numéricos.
**Parâmetros**
+ `expression`: A expressão numérica a ser arredondada para baixo.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$floor` operador para arredondar um valor decimal até o número inteiro mais próximo.
**Crie documentos de amostra**
```
db.numbers.insertOne({ value: 3.14 });
```
**Exemplo de consulta**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**Saída**
```
{ "floored" : 3 }
```
## Exemplos de código
Para ver um exemplo de código para usar o `$floor` comando, escolha a guia do idioma que você deseja 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
O estágio `$geoNear` de agregação retorna os documentos em ordem de proximidade a um ponto especificado. Ele calcula a distância do ponto e inclui a distância nos documentos de saída.
**Parâmetros**
+ `near`: o ponto a partir do qual calcular distâncias, especificado como GeoJSON ou coordenadas legadas.
+ `distanceField`: o nome do campo para armazenar a distância calculada.
+ `spherical`: Booleano indicando se a geometria esférica deve ser usada (necessária para pontos GeoJSON).
+ `maxDistance`: opcional. Distância máxima do ponto central.
+ `minDistance`: opcional. Distância mínima do ponto central.
+ `query`: opcional. Critérios de filtro adicionais a serem aplicados.
+ `limit`: opcional. Número máximo de documentos a serem devolvidos.
+ `key`: opcional. Campo a ser usado para consulta geoespacial quando existirem vários índices geoespaciais.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$geoNear` palco para encontrar as lojas mais próximas de um determinado local.
**Crie documentos de amostra**
```
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] } }
]);
```
**Exemplo de consulta**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**Saída**
```
[
{ _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 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o estágio de `$geoNear` agregação, escolha a guia do idioma que você deseja 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
O estágio `$group` de agregação no Amazon DocumentDB permite agrupar documentos por meio de uma expressão especificada e realizar várias operações cumulativas nos dados agrupados. Isso pode ser útil para tarefas como calcular totais, médias ou outras estatísticas com base nos dados agrupados.
**Parâmetros**
+ `_id`: especifica a expressão pela qual os documentos de entrada devem ser agrupados. Isso pode ser um nome de campo, uma expressão computada ou uma combinação de ambos.
+ `accumulator expressions`: (opcional) Uma ou mais expressões acumuladoras que devem ser aplicadas aos dados agrupados. Essas expressões usam os operadores acumuladores mencionados acima.
## Exemplo (MongoDB Shell)
O exemplo a seguir agrupa os clientes por cidade e calcula o valor total do pedido para cada cidade.
**Crie documentos de amostra**
```
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 }] }
]);
```
**Exemplo de consulta**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**Saída**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o `$group` comando, escolha a guia do idioma que você deseja 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
O operador `$gt` de agregação compara dois valores e retorna `true` se o primeiro valor for maior que o segundo, caso contrário, retorna. `false`
**Parâmetros**
+ `expression1`: o primeiro valor a ser comparado.
+ `expression2`: O segundo valor a ser comparado.
## Exemplo (MongoDB Shell)
O exemplo a seguir demonstra o uso do `$gt` operador para identificar produtos que excedem um limite de preço.
**Crie documentos de amostra**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**Exemplo de consulta**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**Saída**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## Exemplos de código
Para ver um exemplo de código para usar o operador de `$gt` agregação, escolha a guia do idioma que você deseja 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://