Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# APIsMongoDB, operazioni e tipi di dati supportati in Amazon DocumentDB
Amazon DocumentDB (compatibile con MongoDB) è un servizio di database di documenti veloce, scalabile, ad alta disponibilità e completamente gestito che supporta i carichi di lavoro MongoDB. Amazon DocumentDB è compatibile con MongoDB 3.6, 4.0, 5.0 e 8.0. APIs In questa sezione sono elencate le funzionalità supportate. Per assistenza sull'uso di APIs MongoDB e dei driver, consulta i forum della community di MongoDB. Per ricevere assistenza sull'utilizzo del servizio Amazon DocumentDB, contatta il team di AWS supporto appropriato. Per le differenze funzionali tra Amazon DocumentDB e MongoDB, consulta. [Differenze funzionali: Amazon DocumentDB e MongoDB](functional-differences.md)
Gli operatori e i comandi MongoDB solo interni o non applicabili a un servizio completamente gestito non sono supportati e non sono inclusi nell'elenco delle funzionalità supportate.
Abbiamo aggiunto oltre 50 funzionalità aggiuntive dal lancio e continueremo a lavorare procedendo a ritroso dai nostri clienti per fornire le funzionalità necessarie. Per informazioni sui lanci più recenti, consulta [Amazon DocumentDB](https://aws.amazon.com/documentdb/resources/) Announcements.
Se c'è una funzionalità non supportata che vorresti che creassimo, faccelo sapere inviando un'e-mail con il tuo AccountID, le funzionalità richieste e il caso d'uso al team di assistenza di [Amazon DocumentDB](mailto:documentdb-feature-request@amazon.com).
+ [Comandi del database](#mongo-apis-database)
+ [Operatori di interrogazione e proiezione](#mongo-apis-query)
+ [Aggiorna gli operatori](#mongo-apis-update)
+ [Dati geospaziali](#mongo-apis-geospatial)
+ [Metodi del cursore](#mongo-apis-cursor)
+ [Operatori della pipeline di aggregazione](#mongo-apis-aggregation-pipeline)
+ [Tipi di dati](#mongo-apis-data-types)
+ [Indici](#mongo-apis-indexes)
## Comandi del database
**Topics**
+ [Comandi amministrativi](#mongo-apis-dababase-administrative)
+ [Aggregazione](#mongo-apis-dababase-aggregation)
+ [Autenticazione](#mongo-apis-dababase-authentication)
+ [Comandi diagnostici](#mongo-apis-dababase-diagnostics)
+ [Operazioni di interrogazione e scrittura](#mongo-apis-dababase-query-write)
+ [Comandi di gestione dei ruoli](#mongo-apis-database-role-management)
+ [Comandi delle sessioni](#mongo-apis-dababase-sessions)
+ [Gestione degli utenti](#mongo-apis-dababase-user-management)
+ [Comandi di sharding](#mongo-apis-dababase-sharding)
### Comandi amministrativi
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| Capped Collections | No | No | No | No | No |
| cloneCollectionAsCon cappuccio | No | No | No | No | No |
| collMod | Parziale | Parziale | Parziale | Parziale | Parziale |
| CollMod: expireAfterSeconds | Sì | Sì | Sì | Sì | Sì |
| convertToCapped | No | No | No | No | No |
| copydb | No | No | No | No | No |
| creazione | Sì | Sì | Sì | Sì | Sì |
| createView | No | No | No | Sì | No |
| createIndexes | Sì | Sì | Sì | Sì | Sì |
| currentOp | Sì | Sì | Sì | Sì | Sì |
| drop | Sì | Sì | Sì | Sì | Sì |
| dropDatabase | Sì | Sì | Sì | Sì | Sì |
| dropIndexes | Sì | Sì | Sì | Sì | Sì |
| filemd5 | No | No | No | No | No |
| getAuditConfig | No | Sì | Sì | Sì | No |
| killCursors | Sì | Sì | Sì | Sì | Sì |
| killOp | Sì | Sì | Sì | Sì | Sì |
| Elenco delle collezioni\$1 | Sì | Sì | Sì | Sì | Sì |
| listDatabases | Sì | Sì | Sì | Sì | Sì |
| listIndexes | Sì | Sì | Sì | Sì | Sì |
| reIndex | No | No | Sì | Sì | No |
| renameCollection | Sì | Sì | Sì | Sì | No |
| setAuditConfig | No | Sì | Sì | Sì | No |
\$1 La `type` chiave nell'opzione di filtro non è supportata.
### Aggregazione
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| aggregate | Sì | Sì | Sì | Sì | Sì |
| count | Sì | Sì | Sì | Sì | Sì |
| distinct | Sì | Sì | Sì | Sì | Sì |
| mapReduce | No | No | No | Sì | No |
### Autenticazione
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| authenticate | Sì | Sì | Sì | Sì | Sì |
| Logout | Sì | Sì | Sì | Sì | Sì |
### Comandi diagnostici
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| buildInfo | Sì | Sì | Sì | Sì | Sì |
| collStats | Sì | Sì | Sì | Sì | Sì |
| connPoolStats | No | No | No | No | No |
| connectionStatus | Sì | Sì | Sì | Sì | Sì |
| dataSize | Sì | Sì | Sì | Sì | Sì |
| dbHash | No | No | No | No | No |
| dbStats | Sì | Sì | Sì | Sì | Sì |
| explain | Sì | Sì | Sì | Sì | Sì |
| explain: executionStats | Sì | Sì | Sì | Sì | Sì |
| caratteristiche | No | No | No | No | No |
| hostInfo | Sì | Sì | Sì | Sì | Sì |
| listCommands | Sì | Sì | Sì | Sì | Sì |
| profiler | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | No |
| serverStatus | Sì | Sì | Sì | Sì | Sì |
| top | Sì | Sì | Sì | Sì | Sì |
### Operazioni di interrogazione e scrittura
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| Change streams | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Sì](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | No |
| Elimina | Sì | Sì | Sì | Sì | Sì |
| find | Sì | Sì | Sì | Sì | Sì |
| findAndModify | Sì | Sì | Sì | Sì | Sì |
| getLastError | No | No | No | No | No |
| getMore | Sì | Sì | Sì | Sì | Sì |
| getPrevError | No | No | No | No | No |
| GridFS | Sì | Sì | Sì | Sì | No |
| insert | Sì | Sì | Sì | Sì | Sì |
| parallelCollectionScan | No | No | No | No | No |
| resetError | No | No | No | No | No |
| aggiorna | Sì | Sì | Sì | Sì | Sì |
| ReplaceOne | Sì | Sì | Sì | Sì | Sì |
### Comandi di gestione dei ruoli
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| createRole | Sì | Sì | Sì | Sì | No |
| dropAllRolesFromDatabase | Sì | Sì | Sì | Sì | No |
| dropRole | Sì | Sì | Sì | Sì | No |
| grantRolesToRuolo | Sì | Sì | Sì | Sì | No |
| revokeRolesFromRuolo | Sì | Sì | Sì | Sì | No |
| revokePrivilegesFromRuolo | Sì | Sì | Sì | Sì | No |
| rolesInfo | Sì | Sì | Sì | Sì | No |
| updateRole | Sì | Sì | Sì | Sì | No |
### Comandi delle sessioni
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| Transazione interrotta | No | Sì | Sì | Sì | No |
| commitTransaction | No | Sì | Sì | Sì | No |
| Termina le sessioni | No | No | No | No | No |
| killAllSessions | No | Sì | Sì | Sì | No |
| killAllSessionsByPattern | No | No | No | No | No |
| Uccidi sessioni | No | Sì | Sì | Sì | No |
| Aggiorna le sessioni | No | No | No | No | No |
| Avvia sessione | No | Sì | Sì | Sì | No |
### Gestione degli utenti
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| createUser | Sì | Sì | Sì | Sì | Sì |
| dropAllUsersFromDatabase | Sì | Sì | Sì | Sì | Sì |
| dropUser | Sì | Sì | Sì | Sì | Sì |
| grantRolesToUser | Sì | Sì | Sì | Sì | Sì |
| revokeRolesFromUser | Sì | Sì | Sì | Sì | Sì |
| updateUser | Sì | Sì | Sì | Sì | Sì |
| Informazioni sugli utenti | Sì | Sì | Sì | Sì | Sì |
### Comandi di sharding
| Comando | Cluster elastico |
| --- | --- |
| abortReshardCollection | No |
| Aggiunge Shard | No |
| addShardToZona | No |
| balancerCollectionStatus | No |
| Balancer Start | No |
| Stato del bilanciatore | No |
| Balancer Stop | No |
| checkShardingIndex | No |
| clearJumboFlag | No |
| cleanupOrphaned | No |
| cleanupReshardCollection | No |
| commitReshardCollection | No |
| Abilita la condivisione | Sì |
| flushRouterConfig | No |
| getShardMap | No |
| getShardVersion | No |
| isdbgrid | No |
| Elenca i frammenti | No |
| Chiave mediana | No |
| Sposta Chunk | No |
| Sposta il primario | No |
| Unisci blocchi | No |
| refineCollectionShardChiave | No |
| Rimuove Shard | No |
| removeShardFromZona | No |
| Collezione ResHard | No |
| setAllowMigrations | No |
| setShardVersion | No |
| Collezione SHARD | Sì |
| Stato di condivisione | No |
| dividi | No |
| Vettore diviso | No |
| Annulla lo sharding | No |
| updateZoneKeyIntervallo | No |
## Operatori di interrogazione e proiezione
**Topics**
+ [Operatori per matrice](#mongo-apis-query-array-operators)
+ [Operatori bit a bit](#mongo-apis-query-bitwise-operators)
+ [Operatore di commento](#mongo-apis-query-comment-operator)
+ [Operatori di confronto](#mongo-apis-query-comparison-operators)
+ [Operatori di elementi](#mongo-apis-query-element-operators)
+ [Operatori di interrogazione di valutazione](#mongo-apis-query-evaluation-operators)
+ [Operatori logici](#mongo-apis-query-logical-operators)
+ [Operatori di proiezione](#mongo-apis-projection-operators)
### Operatori per matrice
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1elemMatch](elemMatch.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1size](size-query.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori bit a bit
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1bitsAnySet](bitsAnySet.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1bitsAllClear](bitsAllClear.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1bitsAnyClear](bitsAnyClear.md) | Sì | Sì | Sì | Sì | Sì |
### Operatore di commento
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori di confronto
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1gt](gt.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1gte](gte.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1in](in.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1lt](lt.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1lte](lte.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1ne](ne.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1nin](nin.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori di elementi
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1type](type.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori di interrogazione di valutazione
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | No | Sì | Sì | Sì | No |
| [\$1jsonSchema](jsonSchema.md) | No | Sì | Sì | Sì | No |
| [\$1mod](mod-query.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1regex](regex.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1text](text.md) | No | No | Sì | Sì | No |
| \$1where | No | No | No | No | No |
### Operatori logici
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1nor](nor.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1not](not.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1or](or.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori di proiezione
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1elemMatch](elemMatch.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1meta](meta.md) | No | No | Sì | Sì | No |
| [\$1slice](slice-projection.md) | Sì | Sì | Sì | Sì | Sì |
## Aggiorna gli operatori
**Topics**
+ [Operatori di array](#mongo-apis-update-array)
+ [Operatori bit a bit](#mongo-apis-update-bitwise)
+ [Operatori sul campo](#mongo-apis-update-field)
+ [Aggiorna modificatori](#mongo-apis-update-modifiers)
### Operatori di array
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1[]](dollarBrackets-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1[]](dollarIdentifier-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1addToSet](addToSet.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1pop](pop.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1pullAll](pullAll.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1pull](pull.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1push](push.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori bit a bit
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori sul campo
| Operatore | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1inc](inc.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1max](max-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1min](min-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1mul](mul.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1rename](rename.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1set](set-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1setOnInsert](setOnInsert.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1unset](unset-update.md) | Sì | Sì | Sì | Sì | Sì |
### Aggiorna modificatori
| Operatore | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1position](position.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1slice](slice-update.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1sort](sort-update.md) | Sì | Sì | Sì | Sì | Sì |
## Dati geospaziali
### Specificatori di geometria
| Selettori di query | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| \$1box | No | No | No | No | No |
| \$1center | No | No | No | No | No |
| \$1centerSphere | No | No | No | No | No |
| [\$1geometry](geometry.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1maxDistance](maxDistance.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1minDistance](minDistance.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1nearSphere](nearSphere.md) | Sì | Sì | Sì | Sì | Sì |
| \$1polygon | No | No | No | No | No |
| \$1uniqueDocs | No | No | No | No | No |
### Selettori di interrogazione
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1geoWithin](geoWithin.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1near](near.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1nearSphere](nearSphere.md) | Sì | Sì | Sì | Sì | Sì |
| \$1polygon | No | No | No | No | No |
| \$1uniqueDocs | No | No | No | No | No |
## Metodi del cursore
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | Sì | Sì | Sì | Sì | Sì |
| cursor.close() | Sì | Sì | Sì | Sì | Sì |
| cursor.collation() | No | No | No | Sì | No |
| cursor.comment() | Sì | Sì | Sì | Sì | Sì |
| cursor.count() | Sì | Sì | Sì | Sì | Sì |
| cursor.explain() | Sì | Sì | Sì | Sì | No |
| cursor.forEach() | Sì | Sì | Sì | Sì | Sì |
| cursor.hasNext() | Sì | Sì | Sì | Sì | Sì |
| cursor.hint() | Sì | Sì | Sì | Sì | Sì\$1 |
| cursor.isClosed() | Sì | Sì | Sì | Sì | Sì |
| cursor.isExhausted() | Sì | Sì | Sì | Sì | No |
| cursor.itcount() | Sì | Sì | Sì | Sì | No |
| cursor.limit() | Sì | Sì | Sì | Sì | No |
| cursor.map() | Sì | Sì | Sì | Sì | No |
| cursor.max() | No | No | No | No | No |
| cursor.maxScan() | Sì | Sì | Sì | Sì | No |
| cursor.maxTimeMS() | Sì | Sì | Sì | Sì | No |
| cursor.min() | No | No | No | No | No |
| cursor.next() | Sì | Sì | Sì | Sì | Sì |
| cursore. noCursorTimeout() | No | No | No | No | No |
| cursore. objsLeftInBatch () | Sì | Sì | Sì | Sì | No |
| cursor.pretty() | Sì | Sì | Sì | Sì | No |
| cursor.readConcern() | Sì | Sì | Sì | Sì | No |
| cursor.readPref() | Sì | Sì | Sì | Sì | No |
| cursor.returnKey() | No | No | No | No | No |
| cursore. showRecordId() | No | No | No | No | No |
| cursor.size() | Sì | Sì | Sì | Sì | No |
| cursor.skip() | Sì | Sì | Sì | Sì | No |
| cursor.sort() | Sì | Sì | Sì | Sì | No |
| cursor.tailable() | No | No | No | No | No |
| cursor.toArray() | Sì | Sì | Sì | Sì | No |
\$1 L'indice `hint` è supportato con le espressioni di indice. Ad esempio, `db.foo.find().hint({x:1})`.
## Operatori della pipeline di aggregazione
**Topics**
+ [Espressioni dell'accumulatore](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [Operatori aritmetici](#mongo-apis-aggregation-pipeline-arithmetic)
+ [Operatori di matrice](#mongo-apis-aggregation-pipeline-array)
+ [Operatori booleani](#mongo-apis-aggregation-pipeline-boolean)
+ [Operatori di confronto](#mongo-apis-aggregation-pipeline-comparison)
+ [Operatori di espressione condizionale](#mongo-apis-aggregation-pipeline-conditional)
+ [Operatore del tipo di dati](#mongo-apis-aggregation-pipeline-data-type)
+ [Operatore di dimensione dei dati](#mongo-apis-aggregation-pipeline-data-size)
+ [Operatori di data](#mongo-apis-aggregation-pipeline-date)
+ [Operatore letterale](#mongo-apis-aggregation-pipeline-literal)
+ [Operatore di unione](#mongo-apis-aggregation-pipeline-merge)
+ [Operatore naturale](#mongo-apis-aggregation-pipeline-natural)
+ [Operatori su set](#mongo-apis-aggregation-pipeline-set)
+ [Operatori sul palco](#mongo-apis-aggregation-pipeline-stage)
+ [Operatori di stringa](#mongo-apis-aggregation-pipeline-string)
+ [Variabili di sistema](#mongo-apis-aggregation-pipeline-system-variables)
+ [Operatore di ricerca testuale](#mongo-apis-aggregation-pipeline-text-search)
+ [Operatori di conversione dei tipi](#mongo-apis-aggregation-pipeline-type)
+ [Operatori variabili](#mongo-apis-aggregation-pipeline-variable)
+ [Operatori vari](#mongo-apis-aggregation-pipeline-misc)
### Espressioni dell'accumulatore
| Expression | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| \$1accumulatore | - | - | No | No | No |
| [\$1addToSet](addToSet-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1avg](avg.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1count](count.md) | - | - | No | No | No |
| \$1 covariancePOP | No | No | No | No | No |
| \$1covarianceAmp | No | No | No | No | No |
| \$1 DenseRank | No | No | No | No | No |
| \$1 derivato | No | No | No | No | No |
| \$1 numero di documento | No | No | No | No | No |
| \$1expMovingAvg | No | No | No | No | No |
| [\$1first](first.md) | Sì | Sì | Sì | Sì | Sì |
| \$1 integrale | No | No | No | No | No |
| [\$1last](last.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1max](max.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1min](min.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1push](push-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| \$1rango | No | No | No | No | No |
| \$1 turno | No | No | No | No | No |
| \$1stdDevPop | No | No | No | No | No |
| \$1stdDevSamp | No | No | No | No | No |
| [\$1sum](sum.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori aritmetici
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1add](add.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1ceil](ceil.md) | No | Sì | Sì | Sì | Sì |
| [\$1divide](divide.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1exp](exp.md) | No | Sì | Sì | Sì | Sì |
| [\$1floor](floor.md) | No | Sì | Sì | Sì | Sì |
| [\$1ln](ln.md) | No | Sì | Sì | Sì | Sì |
| [\$1log](log.md) | No | Sì | Sì | Sì | Sì |
| [\$1log10](log10.md) | No | Sì | Sì | Sì | Sì |
| [\$1mod](mod.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1multiply](multiply.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1pow](pow.md) | No | No | No | Sì | No |
| \$1 rotondo | - | - | No | No | No |
| [\$1sqrt](sqrt.md) | No | Sì | Sì | Sì | Sì |
| [\$1subtract](subtract.md) | Sì | Sì | Sì | Sì | Sì |
| \$1trunc | No | No | No | No | No |
### Operatori di matrice
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1arrayToObject](arrayToObject.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1concatArrays](concatArrays.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1filter](filter.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1first](first.md) | - | - | Sì | Sì | No |
| [\$1in](in-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1indexOfArray](indexOfArray.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1isArray](isArray.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1last](last.md) | - | - | Sì | Sì | No |
| [\$1objectToArray](objectToArray.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1range](range.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1reverseArray](reverseArray.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1reduce](reduce.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1size](size.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1slice](slice.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1zip](zip.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori booleani
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1not](not-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1or](or-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori di confronto
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1eq](eq-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1gt](gt-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1gte](gte-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1lt](lt-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1lte](lte-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1ne](ne-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori di espressione condizionale
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1ifNull](ifNull.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1switch](switch.md) | No | Sì | Sì | Sì | No |
### Operatore del tipo di dati
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | Sì | Sì | Sì | Sì | Sì |
### Operatore di dimensione dei dati
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | No | No | No |
| \$1bsonSize | - | - | No | No | No |
### Operatori di data
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1dataAggiungi](dateAdd.md) | No | No | Sì | Sì | Sì |
| [\$1dateDiff](dateDiff.md) | - | - | Sì | Sì | No |
| \$1dateFromParts | No | No | No | No | No |
| [\$1dateFromString](dateFromString.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1dateSottrai](dateSubtract.md) | No | No | Sì | Sì | Sì |
| \$1dateToParts | No | No | No | No | No |
| [\$1dateToString](dateToString.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1dateTrunc](dateTrunc.md) | - | - | No | Sì | No |
| [\$1dayOfMonth](dayOfMonth.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1dayOfWeek](dayOfWeek.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1dayOfYear](dayOfYear.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1hour](hour.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1 isoDayOf Settimana](isoDayOfWeek.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1isoWeek](isoWeek.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1isoWeekYear](isoWeekYear.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1millisecond](millisecond.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1minute](minute.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1month](month.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1second](second.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1week](week.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1year](year.md) | Sì | Sì | Sì | Sì | Sì |
### Operatore letterale
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | Sì | Sì | Sì | Sì | Sì |
### Operatore di unione
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | Sì | Sì | Sì | Sì | Sì |
### Operatore naturale
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1naturale](natural.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori su set
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | No | Sì | Sì | Sì | Sì |
| [\$1anyElementTrue](anyElementTrue.md) | No | Sì | Sì | Sì | Sì |
| [\$1setDifference](setDifference.md) | No | Sì | Sì | Sì | Sì |
| [\$1setEquals](setEquals.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1setIntersection](setIntersection.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1setIsSubset](setIsSubset.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1setUnion](setUnion.md) | Sì | Sì | Sì | Sì | Sì |
| \$1setWindowFields | No | No | No | No | No |
### Operatori sul palco
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1bucket](bucket.md) | No | No | No | Sì | No |
| \$1bucketAuto | No | No | No | No |
| [\$1changeStream](changeStream.md) | Sì | Sì | Sì | Sì | No |
| [\$1collStats](collStats.md) | No | Sì | Sì | Sì | No |
| [\$1count](count.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1currentOp](currentOp.md) | Sì | Sì | Sì | Sì | Sì |
| \$1facet | No | No | No | No | No |
| [\$1geoNear](geoNear.md) | Sì | Sì | Sì | Sì | Sì |
| \$1graphLookup | No | No | No | No | No |
| [\$1group](group.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1indexStats](indexStats.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1limit](limit.md) | Sì | Sì | Sì | Sì | Sì |
| \$1listLocalSessions | No | No | No | No | No |
| \$1listSessions | No | No | No | No | No |
| [\$1lookup](lookup.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1match](match.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1unisci](merge.md) | - | - | No | Sì | No |
| [\$1out](out.md) | Sì | Sì | Sì | Sì | No |
| \$1planCacheStats | - | - | No | No | No |
| [\$1project](project.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1redact](redact.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1replaceRoot](replaceRoot.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1sample](sample.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1set](set-stage.md) | - | - | No | Sì | No |
| \$1setWindowFields | - | - | No | No | No |
| [\$1skip](skip.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1sort](sort.md) | Sì | Sì | Sì | Sì | Sì |
| \$1sortByCount | No | No | No | No | No |
| \$1unionWith | - | - | No | No | No |
| [\$1unset](unset-stage.md) | - | - | No | Sì | No |
| [\$1unwind](unwind.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1sostituisci con](replaceWith.md) | No | No | No | Sì | No |
| [\$1 Ricerca vettoriale](vectorSearch.md) | No | No | No | Sì | No |
### Operatori di stringa
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1indexOfBytes](indexOfBytes.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1indexOfCP](indexOfCP.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1ltrim](ltrim.md) | No | Sì | Sì | Sì | No |
| [\$1regexFind](regexFind.md) | - | - | Sì | Sì | No |
| [\$1regexFindAll](regexFindAll.md) | - | - | Sì | Sì | No |
| [\$1RegexMatch](regexMatch.md) | - | - | Sì | Sì | No |
| [\$1 Sostituisci tutto](replaceAll.md) | - | - | Sì | Sì | No |
| [\$1 Sostituisci uno](replaceOne.md) | - | - | Sì | Sì | No |
| [\$1rtrim](rtrim.md) | No | Sì | Sì | Sì | No |
| [\$1split](split.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1strcasecmp](strcasecmp.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1strLenBytes](strLenBytes.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1strLenCP](strLenCP.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1substr](substr.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1substrBytes](substrBytes.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1substrCP](substrCP.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1toLower](toLower.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1toUpper](toUpper.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1trim](trim.md) | No | Sì | Sì | Sì | No |
### Variabili di sistema
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | No | No | No | No | No |
| [\$1\$1DESCEND](DESCEND.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1\$1KEEP](KEEP.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1\$1PRUNE](PRUNE.md) | Sì | Sì | Sì | Sì | Sì |
| \$1\$1REMOVE | No | No | No | No | No |
| [\$1RADICE](ROOT.md) | Sì | Sì | Sì | Sì | Sì |
### Operatore di ricerca testuale
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | No | No | Sì | Sì | No |
| [\$1ricerca](search.md) | No | No | Sì | Sì | No |
### Operatori di conversione dei tipi
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1converti](convert.md) | No | Sì | Sì | Sì | Sì |
| \$1isNumber | - | - | No | No | No |
| [\$1 a BOOL](toBool.md) | No | Sì | Sì | Sì | Sì |
| [\$1 fino ad oggi](toDate.md) | No | Sì | Sì | Sì | Sì |
| [\$1 a Decimal](toDecimal.md) | No | Sì | Sì | Sì | Sì |
| [\$1 a Double](toDouble.md) | No | Sì | Sì | Sì | Sì |
| [\$1 a INT](toInt.md) | No | Sì | Sì | Sì | Sì |
| [\$1 a Long](toLong.md) | No | Sì | Sì | Sì | Sì |
| [\$1toObjectId](toObjectId.md) | No | Sì | Sì | Sì | Sì |
| [\$1toString](toString.md) | No | Sì | Sì | Sì | Sì |
### Operatori variabili
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | Sì | Sì | Sì | Sì | Sì |
| [\$1map](map.md) | Sì | Sì | Sì | Sì | Sì |
### Operatori vari
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | No | No | No |
| [\$1 rand](rand.md) | - | - | No | Sì | No |
| \$1sampleRate | - | - | No | No | No |
## Tipi di dati
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| Numero intero a 32 bit (int) | Sì | Sì | Sì | Sì | Sì |
| Numero intero a 64 bit (lungo) | Sì | Sì | Sì | Sì | Sì |
| Array | Sì | Sì | Sì | Sì | Sì |
| Dati binari | Sì | Sì | Sì | Sì | Sì |
| Booleano | Sì | Sì | Sì | Sì | Sì |
| Data | Sì | Sì | Sì | Sì | Sì |
| DBPointer | No | No | No | No | No |
| DBRefs | No | No | No | No | No |
| Decimal128 | Sì | Sì | Sì | Sì | Sì |
| Double | Sì | Sì | Sì | Sì | Sì |
| JavaScript | No | No | No | No | No |
| JavaScript(con ambito) | No | No | No | No | No |
| MaxKey | Sì | Sì | Sì | Sì | Sì |
| MinKey | Sì | Sì | Sì | Sì | Sì |
| Null | Sì | Sì | Sì | Sì | Sì |
| Oggetto | Sì | Sì | Sì | Sì | Sì |
| ObjectId | Sì | Sì | Sì | Sì | Sì |
| Espressione regolare | Sì | Sì | Sì | Sì | Sì |
| Stringa | Sì | Sì | Sì | Sì | Sì |
| Symbol | No | No | No | No | No |
| Time stamp | Sì | Sì | Sì | Sì | Sì |
| Undefined | No | No | No | No | No |
## Indici e proprietà degli indici
**Topics**
+ [Indici](#mongo-apis-indexes)
+ [Proprietà dell'indice](#mongo-apis-index-properties)
### Indici
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | Sì | Sì | Sì | Sì | Sì |
| Indice 2d | No | No | No | No | No |
| Indice composto | Sì | Sì | Sì | Sì | Sì |
| Indice con hash | No | No | No | No | No |
| Indice con più chiavi | Sì | Sì | Sì | Sì | Sì |
| Indice con campo singolo | Sì | Sì | Sì | Sì | Sì |
| Indice di testo | No | No | Sì | Sì | No |
| Carattere jolly | No | No | No | No | No |
### Proprietà dell'indice
| Comando | 3.6 | 4.0 | 5.0 | 8.0 | Cluster elastico |
| --- | --- | --- | --- | --- | --- |
| Contesto | Sì | Sì | Sì | Sì | Sì |
| Senza distinzione tra maiuscole e minuscole | No | No | No | Sì | No |
| Hidden | No | No | No | No | No |
| Parziale | No | No | Sì | Sì | No |
| Sparse | Sì | Sì | Sì | Sì | Sì |
| Testo | No | No | Sì | Sì | No |
| TTL | Sì | Sì | Sì | Sì | Sì |
| Unique | Sì | Sì | Sì | Sì | Sì |
| Vettore | No | No | Sì | Sì | No |
Per informazioni dettagliate su operatori MongoDB specifici, consulta i seguenti argomenti:
+ [Operatori di pipeline di aggregazione](mongo-apis-aggregation-pipeline-operators.md)
+ [Dati geospaziali](mongo-apis-geospatial-operators.md)
+ [Operatori di proiezione](#mongo-apis-projection-operators)
+ [Aggiorna operatori](mongo-apis-update-operators.md)
# Operatori di pipeline di aggregazione
Questa sezione fornisce informazioni dettagliate sugli operatori di pipeline di aggregazione supportati da Amazon DocumentDB.
**Topics**
+ [\$1\$1DESCEND](DESCEND.md)
+ [\$1\$1KEEP](KEEP.md)
+ [\$1\$1PRUNE](PRUNE.md)
+ [\$1RADICE](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)
+ [\$1converti](convert.md)
+ [\$1count](count.md)
+ [\$1currentOp](currentOp.md)
+ [\$1dataAggiungi](dateAdd.md)
+ [\$1dateDiff](dateDiff.md)
+ [\$1dateFromString](dateFromString.md)
+ [\$1dateSottrai](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 Settimana](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)
+ [\$1unisci](merge.md)
+ [\$1mergeObjects](mergeObjects.md)
+ [\$1millisecond](millisecond.md)
+ [\$1min](min.md)
+ [\$1minute](minute.md)
+ [\$1mod](mod.md)
+ [\$1month](month.md)
+ [\$1multiply](multiply.md)
+ [\$1naturale](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)
+ [\$1 rand](rand.md)
+ [\$1range](range.md)
+ [\$1redact](redact.md)
+ [\$1reduce](reduce.md)
+ [\$1regexFind](regexFind.md)
+ [\$1regexFindAll](regexFindAll.md)
+ [\$1RegexMatch](regexMatch.md)
+ [\$1 Sostituisci tutto](replaceAll.md)
+ [\$1 Sostituisci uno](replaceOne.md)
+ [\$1replaceRoot](replaceRoot.md)
+ [\$1sostituisci con](replaceWith.md)
+ [\$1reverseArray](reverseArray.md)
+ [\$1rtrim](rtrim.md)
+ [\$1sample](sample.md)
+ [\$1ricerca](search.md)
+ [\$1second](second.md)
+ [\$1set](set-stage.md)
+ [\$1setDifference](setDifference.md)
+ [\$1setEquals](setEquals.md)
+ [\$1setIntersection](setIntersection.md)
+ [\$1setIsSubset](setIsSubset.md)
+ [\$1setUnion](setUnion.md)
+ [\$1skip](skip.md)
+ [\$1slice](slice.md)
+ [\$1size](size.md)
+ [\$1sort](sort.md)
+ [\$1split](split.md)
+ [\$1sqrt](sqrt.md)
+ [\$1strLenBytes](strLenBytes.md)
+ [\$1strLenCP](strLenCP.md)
+ [\$1strcasecmp](strcasecmp.md)
+ [\$1substr](substr.md)
+ [\$1substrBytes](substrBytes.md)
+ [\$1substrCP](substrCP.md)
+ [\$1subtract](subtract.md)
+ [\$1sum](sum.md)
+ [\$1switch](switch.md)
+ [\$1 a BOOL](toBool.md)
+ [\$1 fino ad oggi](toDate.md)
+ [\$1 a Decimal](toDecimal.md)
+ [\$1 a Double](toDouble.md)
+ [\$1 a INT](toInt.md)
+ [\$1 a Long](toLong.md)
+ [\$1toLower](toLower.md)
+ [\$1toObjectId](toObjectId.md)
+ [\$1toString](toString.md)
+ [\$1toUpper](toUpper.md)
+ [\$1trim](trim.md)
+ [\$1type](type-aggregation.md)
+ [\$1unset](unset-stage.md)
+ [\$1unwind](unwind.md)
+ [\$1 Ricerca vettoriale](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
L'`$$DESCEND`operatore in Amazon DocumentDB è uno speciale operatore di array posizionale utilizzato nella `$redact` fase di pipeline. Indica alla pipeline di aggregazione di scendere nel documento corrente ed elaborare tutti i campi, indipendentemente dal loro livello di nidificazione.
Quando lo `$redact` stage incontra l'`$$DESCEND`operatore, manterrà visibili tutti i campi del documento corrente e li elaborerà ulteriormente lungo la pipeline. Ciò è utile quando si desidera oscurare o eliminare selettivamente determinati campi in base a una condizione, mantenendo al contempo la struttura del documento.
**Parametri**
Nessuna.
## Esempio (MongoDB Shell)
In questo esempio, useremo lo `$redact` stage con l'`$$DESCEND`operatore per visualizzare selettivamente i documenti in cui il `code` campo è uguale a «Reg».
**Crea documenti di esempio**
```
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" }
]);
```
**Esempio di interrogazione**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**Output**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$$DESCEND` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function redactPatients() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('patient');
const result = await collection.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]).toArray();
console.log(result);
client.close();
}
redactPatients();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def redact_patients():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.patient
result = list(collection.aggregate([
{ "$redact": {
"$cond": {
"if": { "$eq": ["Reg", "$code"] },
"then": "$$DESCEND",
"else": "$$PRUNE"
}
}}
]))
print(result)
client.close()
redact_patients()
```
------
# \$1\$1KEEP
La variabile di `$$KEEP` sistema viene utilizzata con lo `$redact` stage nella pipeline di aggregazione per mantenere invariato il documento o il campo corrente e includerlo nell'output.
**Parametri**
Nessuno
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo di `$$KEEP` in una pipeline di aggregazione Amazon DocumentDB. I documenti vengono conservati solo se l'accesso è uguale a «pubblico», altrimenti vengono rimossi.
**Crea documenti di esempio**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**Esempio di query**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**Output**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$$KEEP` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function run() {
const client = new MongoClient(
'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0'
);
try {
await client.connect();
const db = client.db('test');
const articles = db.collection('articles');
const pipeline = [
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
];
const results = await articles.aggregate(pipeline).toArray();
console.log(results);
} finally {
await client.close();
}
}
run().catch(console.error);
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient(
"mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0"
)
db = client.test
articles = db.articles
pipeline = [
{
"$redact": {
"$cond": [
{"$eq": ["$access", "public"]},
"$$KEEP",
"$$PRUNE"
]
}
}
]
results = list(articles.aggregate(pipeline))
print(results)
client.close()
```
------
# \$1\$1PRUNE
La variabile di `$$PRUNE` sistema viene utilizzata con la `$redact` fase della pipeline di aggregazione per escludere documenti o livelli di documento incorporati dai risultati. Quando una condizione restituisce un risultato positivo`$$PRUNE`, il documento o il documento secondario corrente viene rimosso dall'output. In genere viene utilizzato con `$$DESCEND` (per conservare e scorrere il documento) o `$$KEEP` (per conservare il documento a tutti i livelli).
**Parametri**
Nessuna. La variabile di `$$PRUNE` sistema viene utilizzata senza parametri e deve essere utilizzata con. `$redact`
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare `$$PRUNE` with per escludere gli utenti di età superiore `$redact` ai 30 anni dai risultati.
**Crea documenti di esempio**
```
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" } }
])
```
**Esempio di interrogazione**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**Output**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$$PRUNE` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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()
```
------
# \$1RADICE
L'`$ROOT`operatore in Amazon DocumentDB viene utilizzato per fare riferimento all'intero documento di input all'interno di una pipeline di aggregazione. Consente di accedere e manipolare l'intero documento, inclusi tutti i campi e le strutture annidati.
**Parametri**
Nessuno
## Esempio (MongoDB Shell)
Questo esempio dimostra l'utilizzo `$ROOT` per creare un registro di controllo che acquisisca il documento originale completo insieme ai metadati relativi a quando è stato elaborato.
**Crea documenti di esempio**
```
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
}
]);
```
**Esempio di query**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**Output**
```
[
{
_id: 1,
processedAt: ISODate('2025-11-24T20:43:51.492Z'),
originalDocument: {
_id: 1,
orderId: 'ORD-2024-001',
customer: 'María García',
email: 'maría@example.com',
items: [ { product: 'Laptop', quantity: 1, price: 1299.99 } ],
totalAmount: 1299.99
},
summary: 'Order ORD-2024-001 for María García - Total: $1299.99'
},
{
_id: 2,
processedAt: ISODate('2025-11-24T20:43:51.492Z'),
originalDocument: {
_id: 2,
orderId: 'ORD-2024-002',
customer: 'Arnav Desai',
email: 'arnav@example.com',
items: [
{ product: 'Mouse', quantity: 2, price: 29.99 },
{ product: 'Keyboard', quantity: 1, price: 89.99 }
],
totalAmount: 149.97
},
summary: 'Order ORD-2024-002 for Arnav Desai - Total: $149.97'
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$ROOT` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$abs`operatore in Amazon DocumentDB restituisce il valore assoluto di un numero. Può essere utilizzato nella pipeline di aggregazione per eseguire operazioni matematiche su campi numerici.
**Parametri**
+ `number`: L'espressione numerica per la quale verrà restituito il valore assoluto.
## Esempio (MongoDB Shell)
Questo esempio dimostra l'utilizzo dell'`$abs`operatore per trovare il valore assoluto di un campo numerico.
**Crea documenti di esempio**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**Esempio di query**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**Output**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$abs` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$add`operatore in Amazon DocumentDB viene utilizzato per sommare numeri o date. Può essere utilizzato per eseguire operazioni aritmetiche su campi numerici o per eseguire operazioni aritmetiche di date aggiungendo un numero di unità di tempo a un campo di data.
**Parametri**
+ `expression1`: Il primo numero o data da aggiungere.
+ `expression2`: Il secondo numero o data da aggiungere.
+ `expression3`: (opzionale) Numeri o date aggiuntivi da aggiungere.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$add`operatore per sommare due numeri.
**Crea documenti di esempio**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**Esempio di interrogazione**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**Output**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
In questo esempio, l'`$add`operatore viene utilizzato per aggiungere i valori dei `b` campi `a` e per ogni documento e memorizzare il risultato nel `sum` campo.
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$add` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$addToSet` aggregazione restituisce una matrice di valori univoci da un'espressione specificata per ogni gruppo. Viene utilizzato all'interno dello `$group` stage per accumulare valori distinti, eliminando automaticamente i duplicati.
**Parametri**
+ `expression`: L'espressione da valutare per ogni documento del gruppo.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo dell'`$addToSet`operatore per raccogliere città uniche in cui sono stati effettuati gli ordini per ogni cliente.
**Crea documenti di esempio**
```
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 }
]);
```
**Esempio di interrogazione**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**Output**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo dell'operatore di `$addToSet` aggregazione, scegli la scheda relativa alla lingua che desideri utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('orders');
const result = await collection.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['orders']
result = list(collection.aggregate([
{
'$group': {
'_id': '$customer',
'cities': { '$addToSet': '$city' }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1addFields
La `$addFields` fase della pipeline di aggregazione di Amazon DocumentDB consente di aggiungere nuovi campi calcolati ai documenti. Questo può essere utile per aggiungere dati derivati o trasformati ai documenti.
**Parametri**
+ `newField`: nome del nuovo campo da aggiungere.
+ `expression`: espressione che si risolve nel valore del nuovo campo.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come `$addFields` aggiungere un nuovo campo `TotalInventory` che calcola l'inventario totale in base ai campi and. `Inventory.OnHand` `Inventory.OrderQnty`
**Crea documenti di esempio**
```
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
}
]);
```
**Esempio di interrogazione**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**Output**
```
[
{
"_id" : ObjectId("5bedafbcf65ff161707de24f"),
"Item" : "Ruler",
"Colors" : [ "Red", "Green", "Blue", "Clear", "Yellow" ],
"Inventory" : {
"OnHand" : 47,
"MinOnHand" : 40
},
"UnitPrice" : 0.89,
"TotalInventory" : 47
},
{
"_id" : ObjectId("5bedafbcf65ff161707de250"),
"Item" : "Spray Paint",
"Colors" : [ "Black", "Red", "Green", "Blue" ],
"Inventory" : {
"OnHand" : 47,
"MinOnHand" : 50,
"OrderQnty" : 36
},
"UnitPrice" : 3.99,
"TotalInventory" : 83
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$addFields` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Novità dalla versione 4.0
L'`$allElementsTrue`operatore viene utilizzato per verificare se tutti gli elementi di un array restituiscono un valore vero.
**Parametri**
+ `expression`: espressione che restituisce un array.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo di `$allElementsTrue` per verificare se tutti gli elementi di un array sono veri.
**Crea documenti di esempio**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**Esempio di interrogazione**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**Output**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
In questo esempio, la query verifica se tutti gli elementi dell'`scores`array sono maggiori di 0. Il documento con `"name": "Jane"` è escluso perché l'`scores`array contiene uno 0, che è un valore falso.
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$allElementsTrue` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$and` aggregazione valuta più espressioni e restituisce `true` solo se tutte le espressioni restituiscono a. `true` Se un'espressione lo è`false`, restituisce. `false`
**Parametri**
+ `expressions`: Una serie di espressioni da valutare.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo `$and` dell'operatore per verificare se i prodotti soddisfano più criteri.
**Crea documenti di esempio**
```
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 }
]);
```
**Esempio di interrogazione**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**Output**
```
[
{ _id: 1, name: 'Laptop', price: 1200, inStock: true, affordable: false },
{ _id: 2, name: 'Mouse', price: 25, inStock: false, affordable: false },
{ _id: 3, name: 'Keyboard', price: 75, inStock: true, affordable: true }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo dell'operatore di `$and` aggregazione, scegli la scheda relativa alla lingua che desideri utilizzare:
------
#### [ 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
Novità dalla versione 4.0
L'`$anyElementTrue`operatore viene utilizzato per determinare se un elemento di un array è vero.
**Parametri**
+ `field`: un campo di matrice da valutare.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo di `$anyElementTrue` per verificare se un elemento in un array è vero.
**Crea documenti di esempio**
```
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] }
])
```
**Esempio di interrogazione**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**Output**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$anyElementTrue` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$arrayElemAt`operatore in Amazon DocumentDB consente di recuperare un elemento da un array in base alla sua posizione di indice. Ciò è particolarmente utile quando è necessario accedere a un elemento specifico all'interno di un campo di matrice nei documenti.
**Parametri**
+ `array`: L'array di input da cui deve essere recuperato un elemento.
+ `index`: la posizione dell'indice a base zero dell'elemento da recuperare. Questo valore deve essere un numero intero non negativo.
## Esempio (MongoDB Shell)
In questo esempio, dimostreremo come utilizzare l'`$arrayElemAt`operatore per recuperare elementi specifici dall'`flight_miles`array della raccolta. `miles`
**Crea documenti di esempio**
```
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 ]}
]);
```
**Esempio di interrogazione**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**Output**
```
{ "_id" : 1, "first_mile" : 1205, "last_mile" : 880 }
{ "_id" : 2, "first_mile" : 1205, "last_mile" : 2780 }
{ "_id" : 3, "first_mile" : 1205, "last_mile" : 880 }
```
In questo esempio, utilizziamo l'`$arrayElemAt`operatore per recuperare il primo e l'ultimo elemento dell'`flight_miles`array per ogni documento.
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$arrayElemAt` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$arrayToObject`operatore in Amazon DocumentDB è l'opposto dell'`$objectToArray`operatore. Prende una serie di documenti di coppia chiave-valore e li converte in un unico documento. Ciò è particolarmente utile quando è necessario riconvertire una serie di coppie chiave-valore in una struttura di oggetto o documento.
**Parametri**
+ `array expression`: espressione che si risolve in un array. Gli elementi dell'array devono essere documenti con due campi: `k` (la chiave) e `v` (il valore).
## Esempio (MongoDB Shell)
L'esempio seguente mostra come `$arrayToObject` riconvertire una matrice di coppie chiave-valore in un documento.
**Crea documenti di esempio**
```
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 } }
]);
```
**Esempio di interrogazione**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**Output**
```
{ "_id" : 1, "name" : "Live Soft", "inventory" : { "Des Moines" : 1000, "Ames" : 500 } }
{ "_id" : 2, "name" : "Top Pilot", "inventory" : { "Mason City" : 250, "Des Moines" : 1000 } }
{ "_id" : 3, "name" : "Romancing the Rock", "inventory" : { "Mason City" : 250, "Ames" : 500 } }
{ "_id" : 4, "name" : "Bravemind", "inventory" : { "Mason City" : 250, "Des Moines" : 1000, "Ames" : 500 } }
```
In questo esempio, l'`$objectToArray`operatore viene utilizzato per convertire l'`inventory`oggetto in una matrice di coppie chiave-valore. L'`$arrayToObject`operatore viene quindi utilizzato per riconvertire l'array in un documento, ripristinando la struttura originale dell'oggetto.
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$arrayToObject` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$avg` aggregazione in Amazon DocumentDB calcola il valore medio dell'espressione specificata tra i documenti che vengono inseriti nella fase. Questo operatore è utile per calcolare la media di un campo o di un'espressione numerica in un insieme di documenti.
**Parametri**
+ `expression`: L'espressione da utilizzare per calcolare la media. Può essere un percorso di campo (ad esempio`"$field"`) o un'espressione (ad esempio`{ $multiply: ["$field1", "$field2"] }`).
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$avg`operatore per calcolare il punteggio medio su una serie di documenti degli studenti.
**Crea documenti di esempio**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**Esempio di query**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**Output**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$avg` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Novità dalla versione 8.0
Non supportato dal cluster Elastic.
La fase di `$bucket` aggregazione in Amazon DocumentDB consente di raggruppare i documenti di input in bucket in base a un'espressione e ai limiti del bucket specificati. Ciò può essere utile per analizzare dati che rientrano in determinati intervalli di valori o categorie.
**Parametri**
+ `groupBy`(obbligatorio): L'espressione che specifica il valore in base al quale raggruppare.
+ `boundaries`(obbligatorio): Una matrice di valori doppi che definiscono i limiti del bucket. I documenti vengono assegnati ai bucket in base al valore dell'`groupBy`espressione che rientra nei limiti specificati.
+ `default`(opzionale): Un valore letterale che viene emesso per i documenti il cui valore di `groupBy` espressione non rientra in nessuno dei limiti specificati.
+ `output`(opzionale): Un oggetto che specifica le informazioni da restituire per ogni bucket. È possibile utilizzare operatori di accumulazione come`$sum`, `$avg``$min`, e `$max` per calcolare aggregazioni per ogni bucket.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare lo `$bucket` stage per raggruppare i dati di vendita per fascia di prezzo.
**Crea documenti di esempio**
```
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") }
]);
```
**Esempio di query**
```
db.sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
])
```
**Output**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$bucket` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Novità dalla versione 4.0
L'`$ceil`operatore in Amazon DocumentDB, come in MongoDB, arrotonda un numero al numero intero più vicino. Ciò è utile quando è necessario eseguire operazioni matematiche su campi numerici e garantire che il risultato sia un numero intero.
**Parametri**
+ `expression`: L'espressione numerica da arrotondare.
## Esempio (MongoDB Shell)
Questo esempio dimostra come utilizzare l'`$ceil`operatore per arrotondare un campo numerico.
**Crea documenti di esempio**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**Esempio di query**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**Output**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$ceil` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Non supportato dal cluster Elastic.
La fase di `$changeStream` aggregazione apre un cursore del flusso di modifiche per monitorare le modifiche in tempo reale a una raccolta. Restituisce i documenti degli eventi di modifica quando si verificano operazioni di inserimento, aggiornamento, sostituzione o eliminazione.
**Parametri**
+ `fullDocument`: specifica se restituire il documento completo per le operazioni di aggiornamento. Le opzioni sono `default` o `updateLookup`.
+ `resumeAfter`: facoltativo. Il token Resume proseguirà da un punto specifico del flusso di modifiche.
+ `startAtOperationTime`: facoltativo. Timestamp da cui iniziare il flusso di modifiche.
+ `allChangesForCluster`: facoltativo. Valore booleano. Quando`true`, controlla tutte le modifiche nel cluster (per il database di amministrazione). Quando `false` (impostazione predefinita), controlla solo la raccolta specificata.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo dello `$changeStream` stage per monitorare le modifiche a una raccolta.
**Esempio di interrogazione**
```
// Open change stream first
const changeStream = db.inventory.aggregate([
{ $changeStream: { fullDocument: "updateLookup" } }
]);
// In another session, insert a document
db.inventory.insertOne({ _id: 1, item: "Widget", qty: 10 });
// Back in the first session, read the change event
if (changeStream.hasNext()) {
print(tojson(changeStream.next()));
}
```
**Output**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo della fase di `$changeStream` aggregazione, scegli la scheda relativa alla lingua che desideri utilizzare:
------
#### [ 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
L'`$cmp`operatore in Amazon DocumentDB viene utilizzato per confrontare due valori e restituire un valore intero che indica il loro ordine relativo. È un operatore di confronto che confronta due espressioni e restituisce un valore intero di -1, 0 o 1, a seconda che il primo valore sia rispettivamente minore, uguale o maggiore del secondo valore.
**Parametri**
+ `expression1`: la prima espressione da confrontare.
+ `expression2`: La seconda espressione da confrontare.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo dell'`$cmp`operatore per confrontare due valori numerici.
**Crea documenti di esempio**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**Esempio di query**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**Output**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
In questo esempio, l'`$cmp`operatore confronta i `value2` campi `value1` e di ogni documento. Il risultato è:
```
- `$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).
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$cmp` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
Ecco un esempio di utilizzo dell'`$cmp`operatore in un'applicazione Node.js con il `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 ]
Ecco un esempio di utilizzo dell'`$cmp`operatore in un'applicazione Python con il `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()
```
L'output di entrambi gli esempi Node.js e Python sarà lo stesso dell'esempio di MongoDB Shell:
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
Novità dalla versione 4.0
La fase di `$collStats` aggregazione in Amazon DocumentDB fornisce statistiche sulla raccolta specificata, in modo simile al comando `db.collection.stats()` nella shell MongoDB. Questa fase può essere utilizzata per recuperare informazioni sulla raccolta, come il numero di documenti, la dimensione totale della raccolta e vari parametri prestazionali.
**Parametri**
+ `latencyStats`: (opzionale) Un documento che specifica le opzioni per la raccolta delle statistiche sulla latenza. Questo parametro non è supportato in Amazon DocumentDB.
+ `recordStats`: (opzionale) Un documento che specifica le opzioni per la raccolta di statistiche sui record. Questo parametro non è supportato in Amazon DocumentDB.
+ `queryExecStats`: (opzionale) Un documento che specifica le opzioni per la raccolta delle statistiche sull'esecuzione delle query. Questo parametro non è supportato in Amazon DocumentDB.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare la fase di `$collStats` aggregazione per recuperare statistiche su una raccolta denominata nel database. `test` `db`
**Crea documenti di esempio**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**Esempio di interrogazione**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**Output**
```
{
"ns" : "db.test",
"count" : 3,
"size" : 87,
"avgObjSize" : 29,
"storageSize" : 40960,
"capped" : false,
"nindexes" : 1,
"totalIndexSize" : 8192,
"indexSizes" : {
"_id_" : 8192
},
"collScans" : 0,
"idxScans" : 0,
"opCounter" : {
"numDocsIns" : 3,
"numDocsUpd" : 0,
"numDocsDel" : 0
},
"cacheStats" : {
"collBlksHit" : 0,
"collBlksRead" : 0,
"collHitRatio" : 0,
"idxBlksHit" : 0,
"idxBlksRead" : 0,
"idxHitRatio" : 0
},
"lastReset" : "2023-04-11T12:00:00Z",
"ok" : 1,
"operationTime" : Timestamp(1681206000, 1)
}
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$collStats` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
Ecco un esempio di come utilizzare la fase di `$collStats` aggregazione in un'applicazione Node.js utilizzando il driver ufficiale 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 ]
Ecco un esempio di come utilizzare la fase di `$collStats` aggregazione in un'applicazione Python utilizzando PyMongo il 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
L'operatore di `$concat` aggregazione in Amazon DocumentDB concatena (o combina) più stringhe in un documento per produrre una singola stringa che può essere restituita all'applicazione. Ciò riduce il lavoro svolto nell'applicazione, poiché la manipolazione delle stringhe viene eseguita a livello di database.
**Parametri**
+ `expression1`: la prima stringa da concatenare.
+ `expression2`: La seconda stringa da concatenare.
+ `...`: stringhe aggiuntive da concatenare (opzionale).
## Esempio (MongoDB Shell)
In questo esempio, concateniamo il nome e il cognome degli utenti per produrre il nome completo di ogni persona.
**Crea documenti di esempio**
```
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"}
])
```
**Esempio di interrogazione**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**Output**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$concat` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$concatArrays` aggregazione in Amazon DocumentDB viene utilizzato per concatenare due o più array in un unico array. Questo può essere utile quando è necessario combinare più array di dati in un unico array per ulteriori elaborazioni o analisi.
**Parametri**
+ `array1`: il primo array da concatenare.
+ `array2`: Il secondo array da concatenare.
+ `[array3, ...]`: (opzionale) Matrici aggiuntive da concatenare.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$concatArrays`operatore per combinare due array in un unico array.
**Crea documenti di esempio**
```
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"]
}
]);
```
**Esempio di interrogazione**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**Output**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$concatArrays` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$cond`operatore in Amazon DocumentDB viene utilizzato per valutare un'espressione condizionale e restituire una delle due possibili espressioni di risultato.
**Parametri**
+ `if`: L'espressione booleana da valutare.
+ `then`: L'espressione da restituire se l'`if`espressione è vera.
+ `else`: L'espressione da restituire se l'`if`espressione è falsa.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'uso dell'`$cond`operatore per restituire un valore basato sull'età di una persona.
**Crea documenti di esempio**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**Esempio di query**
```
db.people.aggregate([
{
$project: {
name: 1,
ageGroup: {
$cond: {
if: { $lt: ["$age", 30] },
then: "young",
else: {
$cond: {
if: { $lt: ["$age", 65] },
then: "middle-aged",
else: "elderly"
}
}
}
}
}
}
])
```
**Output**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$cond` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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()
```
------
# \$1converti
Nuovo dalla versione 4.0
L'`$convert`operatore in Amazon DocumentDB viene utilizzato per convertire un valore da un tipo di dati a un altro. Questo operatore è utile quando è necessario eseguire operazioni su dati di diverso tipo, come convertire una stringa in un numero o una data in un timestamp.
**Parametri**
+ `to`: il tipo di dati di destinazione in cui convertire il valore. I valori supportati sono `"string"`, `"double"`, `"long"`, `"int"`, `"date"` e `"boolean"`.
+ `from`: il tipo di dati corrente del valore. Se non specificato, Amazon DocumentDB tenterà di rilevare automaticamente il tipo di dati.
+ `onError`: (opzionale) Il valore da restituire se la conversione fallisce. Può essere un valore specifico o uno dei seguenti valori speciali:`"null"`,`"zerofill"`, o`"error"`.
+ `onNull`: (opzionale) Il valore da restituire se il valore di input è`null`. Può essere un valore specifico o uno dei seguenti valori speciali:`"null"`,`"zerofill"`, o`"error"`.
## Esempio (MongoDB Shell)
L'esempio seguente mostra la conversione di un valore di stringa in una data utilizzando l'operatore. `$convert`
**Crea documenti di esempio**
```
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" }
]);
```
**Esempio di interrogazione**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**Output**
```
[
{ "_id" : 1, "name" : "John Doe", "joinedOn" : ISODate("2022-01-01T00:00:00Z") },
{ "_id" : 2, "name" : "Jane Smith", "joinedOn" : ISODate("2023-02-15T00:00:00Z") },
{ "_id" : 3, "name" : "Bob Johnson", "joinedOn" : null }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$convert` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require("mongodb");
async function example() {
const client = await MongoClient.connect("mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false");
const db = client.db("test");
const users = db.collection("users");
const results = await users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
]).toArray();
console.log(results);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient("mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false")
db = client["test"]
users = db["users"]
results = list(users.aggregate([
{
"$project": {
"_id": 1,
"name": 1,
"joinedOn": {
"$convert": {
"input": "$joinedOn",
"to": "date",
"onError": "null",
"onNull": "null"
}
}
}
}
]))
print(results)
client.close()
example()
```
------
# \$1count
La fase di `$count` aggregazione in Amazon DocumentDB viene utilizzata per contare il numero di documenti che entrano nella fase. Viene spesso utilizzata come fase finale di una pipeline di aggregazione per restituire il numero totale di documenti corrispondenti alle fasi precedenti.
**Parametri**
+ `field`: Il campo da contare. Questo parametro è facoltativo e, se non viene fornito, la fase conterà il numero totale di documenti di input.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare lo `$count` stage per ottenere il numero totale di documenti in una raccolta.
**Crea documenti di esempio**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**Esempio di interrogazione**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**Output**
```
{ "total" : 4 }
```
L'esempio aggrega la `users` raccolta e utilizza lo `$count` stage per contare il numero totale di documenti.
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$count` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function countDocuments() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('mydb');
const collection = db.collection('users');
const result = await collection.aggregate([
{ $count: "total" }
]).toArray();
console.log(result[0].total);
await client.close();
}
countDocuments();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def count_documents():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['mydb']
collection = db['users']
result = list(collection.aggregate([
{ '$count': "total" }
]))
print(result[0]['total'])
client.close()
count_documents()
```
------
# \$1currentOp
La fase `$currentOp` di aggregazione restituisce informazioni sulle operazioni attualmente in esecuzione nel database. Questa fase è utile per monitorare le interrogazioni e le operazioni attive in una pipeline di aggregazione.
**Parametri**
+ `allUsers`(opzionale): se impostato su`true`, restituisce le operazioni per tutti gli utenti. Il valore predefinito è “`false`”.
+ `idleConnections`(opzionale): se impostato su`true`, include le connessioni inattive. Il valore predefinito è “`false`”.
+ `idleCursors`(opzionale): Se impostato su`true`, include informazioni sui cursori inattivi. Il valore predefinito è “`false`”.
+ `idleSessions`(opzionale): se impostato su`true`, include informazioni sulle sessioni inattive. Il valore predefinito è “`true`”.
+ `localOps`(opzionale): se impostato su`true`, include le operazioni locali. Il valore predefinito è “`false`”.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo della fase di `$currentOp` aggregazione per recuperare informazioni sulle operazioni di lettura attive.
**Esempio di interrogazione**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**Output**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$currentOp` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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()
```
------
# \$1dataAggiungi
Nuovo dalla versione 5.0
L'operatore di `$dateAdd` aggregazione in Amazon DocumentDB consente di aggiungere una durata a un valore di data e ora.
**Parametri**
+ `date`: Un valore di data e ora a cui aggiungere una durata.
+ `duration`: La durata da aggiungere al `date` valore. Può essere specificato come oggetto con le chiavi per`years`,`months`, `weeks``days`,`hours`,`minutes`, e`seconds`.
+ `timezone`: (opzionale) Il fuso orario da utilizzare quando si esegue l'aggiunta della data. Se non specificato, viene utilizzato il fuso orario predefinito del cluster Amazon DocumentDB.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$dateAdd`operatore per aggiungere 2 giorni e 12 ore a una data.
**Crea documenti di esempio**
```
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") }
]);
```
**Esempio di query**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**Output**
```
[
{
"_id": 1,
"eventDate": "2023-04-01T10:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-03T22:00:00Z)"
},
{
"_id": 2,
"eventDate": "2023-04-02T12:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-05T00:00:00Z)"
},
{
"_id": 3,
"eventDate": "2023-04-03T14:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-06T02:00:00Z)"
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dateAdd` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Nuovo dalla versione 5.0
Non supportato dal cluster Elastic.
L'operatore `$dateDiff` di aggregazione calcola la differenza tra due date in unità specificate. Restituisce il numero di limiti di unità superati tra le date di inizio e di fine.
**Parametri**
+ `startDate`: L'espressione della data di inizio.
+ `endDate`: L'espressione della data di fine.
+ `unit`: L'unità di tempo per la differenza. Le unità supportate sono `year` `quarter``month`,`week`,`day`,`hour`,`minute`,`second`, e`millisecond`.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$dateDiff`operatore per calcolare il numero di giorni tra l'immissione dell'ordine e la consegna.
**Crea documenti di esempio**
```
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")
}
]);
```
**Esempio di interrogazione**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**Output**
```
[
{
_id: ObjectId('6924a5f2d66dcae121d29517'),
orderId: 1001,
orderDate: ISODate('2025-01-10T08:00:00.000Z'),
deliveryDate: ISODate('2025-01-15T14:30:00.000Z'),
daysToDeliver: 5
},
{
_id: ObjectId('6924a5f2d66dcae121d29518'),
orderId: 1002,
orderDate: ISODate('2025-02-05T10:00:00.000Z'),
deliveryDate: ISODate('2025-02-12T16:45:00.000Z'),
daysToDeliver: 7
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dateDiff` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$dateFromString` aggregazione in Amazon DocumentDB consente di convertire una stringa data-ora in un oggetto data. Ciò è utile quando i dati sono archiviati come stringhe, ma è necessario eseguire operazioni basate sulla data sui dati.
**Parametri**
+ `dateString`: Una stringa che rappresenta una data e un'ora.
+ `format`: (opzionale) Una stringa che specifica il formato di. `dateString` Se non viene fornito, Amazon DocumentDB tenterà di analizzare la stringa nel formato ISO-8601.
+ `timezone`: (opzionale) Una stringa che specifica il fuso orario. Se non viene fornito, Amazon DocumentDB utilizzerà il fuso orario del server.
+ `onError`: (opzionale) Speciifica l'azione da intraprendere se la conversione fallisce. I valori possibili sono `'error'` (impostazione predefinita, che genera un errore), `'null'` (restituisce`null`) o `'replace'` (sostituisce il valore con la stringa di sostituzione specificata nell'`onErrorMessage`opzione).
+ `onErrorMessage`: (opzionale) Se `onError` è impostata su`'replace'`, questa opzione specifica la stringa sostitutiva.
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare per `$dateFromString` convertire una stringa di data in un oggetto data in Amazon DocumentDB.
**Crea documenti di esempio**
```
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"}
]);
```
**Esempio di interrogazione**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**Output**
```
[
{
"_id": 1,
"event": "missionStart",
"logDate": ISODate("2020-03-15T13:41:33Z")
},
{
"_id": 2,
"event": "jumpPoint1",
"logDate": ISODate("2020-03-15T13:45:34Z")
},
{
"_id": 3,
"event": "jumpPoint2",
"logDate": ISODate("2020-03-15T13:48:21Z")
},
{
"_id": 4,
"event": "jumpPoint3",
"logDate": ISODate("2020-03-15T13:52:09Z")
},
{
"_id": 5,
"event": "missionEnd",
"logDate": ISODate("2020-03-15T13:58:44Z")
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dateFromString` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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()
```
------
# \$1dateSottrai
Nuovo dalla versione 5.0
L'operatore di `$dateSubtract` aggregazione in Amazon DocumentDB consente di sottrarre una durata specificata da un valore di data.
**Parametri**
+ `date`: espressione di data che si risolve in una data o un timestamp.
+ `subtrahend`: espressione di durata che specifica la quantità di tempo da sottrarre dall'espressione. `date`
+ `unit`: Una stringa che specifica l'unità di tempo per l'espressione. `subtrahend` Le unità supportate sono «anno», «trimestre», «mese», «settimana», «giorno», «ora», «minuto», «secondo» e «millisecondo».
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$dateSubtract`operatore per calcolare la data di un anno fa dalla data corrente.
**Crea documenti di esempio**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**Esempio di query**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**Output**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dateSubtract` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$dateToString` aggregazione in Amazon DocumentDB viene utilizzato per convertire un valore di data o timestamp in una rappresentazione di stringa. Ciò è utile quando è necessario formattare la data e l'ora in un modo specifico per la visualizzazione o l'ulteriore elaborazione.
**Parametri**
+ `date`: Il valore della data o del timestamp da convertire in una stringa.
+ `format`: Una stringa che specifica il formato in cui deve essere rappresentata la data. La stringa di formato può includere diversi specificatori di formato, ad esempio `%Y` per l'anno a quattro cifre, per il mese a due cifre, `%m` per il giorno del mese a due cifre, `%d` ecc.
+ `timezone`: (opzionale) Il fuso orario da utilizzare per la conversione. Se non specificato, viene utilizzato il fuso orario del server che ospita il cluster Amazon DocumentDB.
+ `onNull`: (opzionale) Il valore da restituire se il `date` parametro è`null`.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo dell'`$dateToString`operatore per formattare il `logDate` campo della raccolta. `missionLog`
**Crea documenti di esempio**
```
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") }
]);
```
**Esempio di query**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**Output**
```
[
{
"_id": 1,
"event": "missionStart",
"logDateFormatted": "2020-03-15 13:41:33"
},
{
"_id": 2,
"event": "jumpPoint1",
"logDateFormatted": "2020-03-15 13:45:34"
},
{
"_id": 3,
"event": "jumpPoint2",
"logDateFormatted": "2020-03-15 13:48:21"
},
{
"_id": 4,
"event": "jumpPoint3",
"logDateFormatted": "2020-03-15 13:52:09"
},
{
"_id": 5,
"event": "missionEnd",
"logDateFormatted": "2020-03-15 13:58:44"
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dateToString` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
Ecco un esempio di utilizzo dell'`$dateToString`operatore in un'applicazione 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 ]
Ecco un esempio di utilizzo dell'`$dateToString`operatore in un'applicazione 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
Nuovo dalla versione 8.0
Non supportato dal cluster Elastic.
L'operatore di `$dateTrunc` aggregazione in Amazon DocumentDB tronca una data in un'unità specificata.
**Parametri**
+ `date`: espressione di data che si risolve in una data o un timestamp.
+ `unit`: Una stringa che specifica l'unità di tempo per l'espressione sottraend. Le unità supportate sono`year`,`quarter`,`month`,,`week`, `day``hour`, `minute` e. `second` `millisecond`
## Esempio (MongoDB Shell)
L'esempio seguente mostra come utilizzare l'`$dateTrunc`operatore per troncare una data all'ora.
**Crea documenti di esempio**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**Esempio di interrogazione**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**Output**
```
[
{
_id: ObjectId('6924a258d66dcae121d29515'),
eventName: 'Event 1',
eventTime: ISODate('2025-04-01T12:15:00.000Z'),
truncatedToHour: ISODate('2025-04-01T12:00:00.000Z')
},
{
_id: ObjectId('6924a258d66dcae121d29516'),
eventName: 'Event 2',
eventTime: ISODate('2025-08-15T14:33:22.000Z'),
truncatedToHour: ISODate('2025-08-15T14:00:00.000Z')
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dateTrunc` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$dayOfMonth` aggregazione in Amazon DocumentDB recupera il giorno del mese (da 1 a 31) per una determinata data. Questo operatore è utile per raggruppare, filtrare o estrarre il giorno del mese dai campi della data nei documenti.
**Parametri**
+ `date expression`: L'espressione della data può essere un campo data dal documento, un oggetto data o una stringa di data.
## Esempio (MongoDB Shell)
Questo esempio dimostra come utilizzare l'`$dayOfMonth`operatore per estrarre il giorno del mese da un campo data nel documento.
**Crea documenti di esempio**
```
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") }
]);
```
**Esempio di interrogazione**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**Output**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dayOfMonth` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$dayOfWeek`operatore in Amazon DocumentDB estrae il giorno della settimana da un determinato campo data. Restituisce il giorno della settimana come numero compreso tra 1 (domenica) e 7 (sabato), che è lo stesso comportamento di MongoDB.
**Parametri**
+ `date field`: Il campo della data da cui estrarre il giorno della settimana.
## Esempio (MongoDB Shell)
Questo esempio dimostra come utilizzare l'`$dayOfWeek`operatore per estrarre il giorno della settimana dal `date` campo della raccolta. `weather`
**Crea documenti di esempio**
```
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")
}
]);
```
**Esempio di query**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**Output**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dayOfWeek` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$dayOfYear`operatore in Amazon DocumentDB restituisce il giorno dell'anno per una data con un numero compreso tra 1 e 366 (365 negli anni non bisestili).
**Parametri**
+ `expression`: Il campo o l'espressione della data da cui estrarre il giorno dell'anno.
## Esempio (MongoDB Shell)
Questo esempio dimostra come utilizzare l'`$dayOfYear`operatore per estrarre il giorno dell'anno da un campo data in una raccolta Amazon DocumentDB.
**Crea documenti di esempio**
```
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")
}
])
```
**Esempio di interrogazione**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**Output**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$dayOfYear` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$divide`operatore nella pipeline di aggregazione di Amazon DocumentDB viene utilizzato per dividere un numero per un altro. È un operatore utile per eseguire operazioni matematiche su campi numerici all'interno dei documenti.
**Parametri**
+ `numerator`: Il dividendo o il numero da dividere.
+ `denominator`: Il divisore o il numero per cui dividere.
## Esempio (MongoDB Shell)
Questo esempio dimostra come utilizzare l'`$divide`operatore per calcolare la tariffa oraria per i dipendenti in base al loro stipendio annuale e al numero di ore lavorative all'anno.
**Crea documenti di esempio**
```
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 }
]);
```
**Esempio di interrogazione**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**Output**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$divide` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$eq` aggregazione confronta due valori e restituisce `true` se sono uguali, altrimenti restituisce. `false`
**Parametri**
+ `expression1`: Il primo valore da confrontare.
+ `expression2`: Il secondo valore da confrontare.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo `$eq` dell'operatore per verificare se le quantità di prodotto corrispondono ai valori target.
**Crea documenti di esempio**
```
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 }
]);
```
**Esempio di query**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**Output**
```
[
{ _id: 1, item: 'Widget', qty: 50, target: 50, meetsTarget: true },
{ _id: 2, item: 'Gadget', qty: 30, target: 50, meetsTarget: false },
{ _id: 3, item: 'Tool', qty: 50, target: 40, meetsTarget: false }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo dell'operatore di `$eq` aggregazione, scegli la scheda relativa alla lingua che desideri utilizzare:
------
#### [ 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
Novità dalla versione 4.0
L'`$exp`operatore in Amazon DocumentDB consente di elevare la costante e a un determinato numero.
**Parametri**
+ `expression`: L'espressione da valutare. Può trattarsi di qualsiasi espressione di aggregazione valida, inclusi riferimenti di campo, operazioni aritmetiche e altre fasi di aggregazione.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'uso dell'`$exp`operatore per trovare tutti i documenti in cui il `quantity` campo è maggiore del campo. `price`
**Crea documenti di esempio**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**Esempio di interrogazione**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**Output**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$exp` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'`$filter`operatore in Amazon DocumentDB viene utilizzato per applicare un'espressione di filtro a ciascun elemento di un array e restituire un array contenente solo gli elementi che corrispondono alla condizione specificata. Questo operatore è utile quando è necessario eseguire operazioni di filtraggio complesse sui campi di matrice all'interno dei documenti.
**Parametri**
+ `input`: Il campo dell'array da filtrare.
+ `as`: il nome della variabile da utilizzare per ogni elemento dell'`input`array all'interno dell'`cond`espressione.
+ `cond`: L'espressione booleana che determina se un determinato elemento deve essere incluso nell'array di output.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra come utilizzare l'`$filter`operatore per proiettare il cliente di ogni ordine e creare un nuovo campo di matrice PaidItems contenente solo gli articoli dell'array items il cui prezzo è maggiore di 15. In sostanza, filtra gli articoli di ciascun ordine per includere solo i prodotti che costano più di 15€.
**Crea documenti di esempio**
```
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 }
]}
]);
```
**Esempio di interrogazione**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**Output**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$filter` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Novità dalla versione 5.0.
Non supportato dal cluster Elastic.
L'`$first`operatore in Amazon DocumentDB restituisce il primo documento da un insieme raggruppato di documenti. Viene comunemente utilizzato nelle pipeline di aggregazione per recuperare il primo documento che corrisponde a una condizione specifica.
**Parametri**
+ `expression`: L'espressione da restituire come primo valore in ogni gruppo.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'uso dell'`$first`operatore per recuperare il valore del primo elemento rilevato per ogni categoria durante l'aggregazione.
Nota: `$first` restituisce il primo documento in base all'ordine corrente dei documenti nella pipeline. Per garantire un ordine specifico (ad esempio, per data, prezzo, ecc.), è necessario utilizzare una `$sort` fase prima della `$group` fase.
**Crea documenti di esempio**
```
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" }
]);
```
**Esempio di interrogazione**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**Output**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$first` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
Novità dalla versione 4.0.
L'`$floor`operatore in Amazon DocumentDB restituisce il numero intero più grande inferiore o uguale al numero specificato. Questo operatore è utile per arrotondare i valori numerici.
**Parametri**
+ `expression`: L'espressione numerica da arrotondare per difetto.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'uso dell'`$floor`operatore per arrotondare un valore decimale al numero intero più vicino.
**Crea documenti di esempio**
```
db.numbers.insertOne({ value: 3.14 });
```
**Esempio di interrogazione**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**Output**
```
{ "floored" : 3 }
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$floor` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]).toArray();
console.log(result);
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
client = None
try:
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.numbers
result = list(collection.aggregate([
{ '$project': { '_id': 0, 'floored': { '$floor': '$value' }}}
]))
pprint(result)
except Exception as e:
print(f"An error occurred: {e}")
finally:
if client:
client.close()
example()
```
------
# \$1geoNear
La fase di `$geoNear` aggregazione restituisce i documenti in ordine di prossimità a un punto specificato. Calcola la distanza dal punto e include la distanza nei documenti di output.
**Parametri**
+ `near`: il punto da cui calcolare le distanze, specificato come coordinate GeoJSON o legacy.
+ `distanceField`: Il nome del campo per memorizzare la distanza calcolata.
+ `spherical`: valore booleano che indica se utilizzare la geometria sferica (obbligatorio per i punti GeoJSON).
+ `maxDistance`: facoltativo. Distanza massima dal punto centrale.
+ `minDistance`: facoltativo. Distanza minima dal punto centrale.
+ `query`: facoltativo. Criteri di filtro aggiuntivi da applicare.
+ `limit`: facoltativo. Numero massimo di documenti da restituire.
+ `key`: facoltativo. Campo da utilizzare per l'interrogazione geospaziale quando esistono più indici geospaziali.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo `$geoNear` dello stage per trovare i negozi più vicini a una determinata posizione.
**Create documenti di esempio**
```
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] } }
]);
```
**Esempio di interrogazione**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**Output**
```
[
{ _id: 1, name: 'Store A', location: { type: 'Point', coordinates: [ -122.4, 37.8 ] }, distance: 0 },
{ _id: 3, name: 'Store C', location: { type: 'Point', coordinates: [ -122.3, 37.9 ] }, distance: 13877.82 },
{ _id: 2, name: 'Store B', location: { type: 'Point', coordinates: [ -122.5, 37.7 ] }, distance: 15557.89 }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo della fase di `$geoNear` aggregazione, scegli la scheda relativa alla lingua che desideri utilizzare:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('stores');
const result = await collection.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['stores']
result = list(collection.aggregate([
{
'$geoNear': {
'near': { 'type': 'Point', 'coordinates': [-122.4, 37.8] },
'distanceField': 'distance',
'spherical': True
}
}
]))
print(result)
client.close()
example()
```
------
# \$1group
La fase di `$group` aggregazione in Amazon DocumentDB consente di raggruppare i documenti in base a un'espressione specificata ed eseguire varie operazioni cumulative sui dati raggruppati. Ciò può essere utile per attività come il calcolo di totali, medie o altre statistiche basate sui dati raggruppati.
**Parametri**
+ `_id`: specifica l'espressione in base alla quale devono essere raggruppati i documenti di input. Può essere un nome di campo, un'espressione calcolata o una combinazione di entrambi.
+ `accumulator expressions`: (opzionale) Una o più espressioni di accumulazione da applicare ai dati raggruppati. Queste espressioni utilizzano gli operatori di accumulazione sopra menzionati.
## Esempio (MongoDB Shell)
L'esempio seguente raggruppa i clienti per città e calcola l'importo totale dell'ordine per ogni città.
**Crea documenti di esempio**
```
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 }] }
]);
```
**Esempio di query**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**Output**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo del `$group` comando, scegliete la scheda relativa alla lingua che desiderate utilizzare:
------
#### [ 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
L'operatore di `$gt` aggregazione confronta due valori e restituisce `true` se il primo valore è maggiore del secondo, altrimenti restituisce. `false`
**Parametri**
+ `expression1`: il primo valore da confrontare.
+ `expression2`: Il secondo valore da confrontare.
## Esempio (MongoDB Shell)
L'esempio seguente dimostra l'utilizzo `$gt` dell'operatore per identificare i prodotti che superano una soglia di prezzo.
**Crea documenti di esempio**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**Esempio di interrogazione**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**Output**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## Esempi di codice
Per visualizzare un esempio di codice per l'utilizzo dell'operatore di `$gt` aggregazione, scegli la scheda relativa alla lingua che desideri utilizzare:
------
#### [ 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://