Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Unterstützte MongoDB APIs, Operationen und Datentypen in Amazon DocumentDB
Amazon DocumentDB (mit MongoDB-Kompatibilität) ist ein schneller, skalierbarer, hochverfügbarer und vollständig verwalteter Dokumentendatenbankservice, der MongoDB-Workloads unterstützt. Amazon DocumentDB ist mit MongoDB 3.6, 4.0, 5.0 und 8.0 kompatibel. APIs In diesem Abschnitt werden die unterstützten Funktionalitäten aufgeführt. Für Unterstützung bei der Verwendung von MongoDB APIs und Treibern wenden Sie sich bitte an die MongoDB-Community-Foren. Wenn Sie Unterstützung bei der Nutzung des Amazon DocumentDB-Services benötigen, wenden Sie sich bitte an das entsprechende AWS Support-Team. Informationen zu den Funktionsunterschieden zwischen Amazon DocumentDB und MongoDB finden Sie unter. [Funktionale Unterschiede: Amazon DocumentDB und MongoDB](functional-differences.md)
MongoDB-Befehle und -Operatoren, die nur intern oder nicht auf einen verwalteten Service anwendbar sind, werden nicht unterstützt und sind nicht in der Liste der unterstützten Funktionalität enthalten.
Seit der Markteinführung haben wir mehr als 50 zusätzliche Funktionen hinzugefügt und werden uns weiter an den Anforderungen unserer Kunden ausrichten, um ihnen die benötigten Funktionen bereitzustellen. Informationen zu den neuesten Produkteinführungen finden Sie unter [Ankündigungen von Amazon DocumentDB](https://aws.amazon.com/documentdb/resources/).
Wenn es eine Funktion gibt, die nicht unterstützt wird und die Sie von uns erstellen lassen möchten, teilen Sie uns dies mit, indem Sie eine E-Mail mit Ihrer accountID, den angeforderten Funktionen und dem Anwendungsfall an das [Amazon DocumentDB-Serviceteam](mailto:documentdb-feature-request@amazon.com) senden.
+ [Befehle für die Datenbank](#mongo-apis-database)
+ [Abfrage- und Projektionsoperatoren](#mongo-apis-query)
+ [Operatoren aktualisieren](#mongo-apis-update)
+ [Geodaten](#mongo-apis-geospatial)
+ [Cursor-Methoden](#mongo-apis-cursor)
+ [Operatoren für Aggregationspipelines](#mongo-apis-aggregation-pipeline)
+ [Datentypen](#mongo-apis-data-types)
+ [Indizes](#mongo-apis-indexes)
## Befehle für die Datenbank
**Topics**
+ [Administrative Befehle](#mongo-apis-dababase-administrative)
+ [Aggregation](#mongo-apis-dababase-aggregation)
+ [Authentifizierung](#mongo-apis-dababase-authentication)
+ [Diagnosebefehle](#mongo-apis-dababase-diagnostics)
+ [Abfrage- und Schreiboperationen](#mongo-apis-dababase-query-write)
+ [Befehle zur Rollenverwaltung](#mongo-apis-database-role-management)
+ [Befehle für Sessions](#mongo-apis-dababase-sessions)
+ [Benutzerverwaltung](#mongo-apis-dababase-user-management)
+ [Sharding-Befehle](#mongo-apis-dababase-sharding)
### Administrative Befehle
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| Gedeckelte Sammlungen | Nein | Nein | Nein | Nein | Nein |
| cloneCollectionAsGekappt | Nein | Nein | Nein | Nein | Nein |
| collMod | Teilweise | Teilweise | Teilweise | Teilweise | Teilweise |
| collMod: expireAfterSeconds | Ja | Ja | Ja | Ja | Ja |
| convertToCapped | Nein | Nein | Nein | Nein | Nein |
| copydb | Nein | Nein | Nein | Nein | Nein |
| Erstellen | Ja | Ja | Ja | Ja | Ja |
| createView | Nein | Nein | Nein | Ja | Nein |
| createIndexes | Ja | Ja | Ja | Ja | Ja |
| currentOp | Ja | Ja | Ja | Ja | Ja |
| fallen lassen | Ja | Ja | Ja | Ja | Ja |
| dropDatabase | Ja | Ja | Ja | Ja | Ja |
| dropIndexes | Ja | Ja | Ja | Ja | Ja |
| filemd5 | Nein | Nein | Nein | Nein | Nein |
| getAuditConfig | Nein | Ja | Ja | Ja | Nein |
| killCursors | Ja | Ja | Ja | Ja | Ja |
| killOp | Ja | Ja | Ja | Ja | Ja |
| listCollections auflisten\$1 | Ja | Ja | Ja | Ja | Ja |
| listDatabases | Ja | Ja | Ja | Ja | Ja |
| listIndexes | Ja | Ja | Ja | Ja | Ja |
| reIndex | Nein | Nein | Ja | Ja | Nein |
| renameCollection | Ja | Ja | Ja | Ja | Nein |
| setAuditConfig | Nein | Ja | Ja | Ja | Nein |
\$1 Der `type` Schlüssel in der Filteroption wird nicht unterstützt.
### Aggregation
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| aggregate | Ja | Ja | Ja | Ja | Ja |
| count | Ja | Ja | Ja | Ja | Ja |
| distinct | Ja | Ja | Ja | Ja | Ja |
| mapReduce | Nein | Nein | Nein | Ja | Nein |
### Authentifizierung
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| authenticate | Ja | Ja | Ja | Ja | Ja |
| logout | Ja | Ja | Ja | Ja | Ja |
### Diagnosebefehle
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| buildInfo | Ja | Ja | Ja | Ja | Ja |
| collStats | Ja | Ja | Ja | Ja | Ja |
| connPoolStats | Nein | Nein | Nein | Nein | Nein |
| connectionStatus | Ja | Ja | Ja | Ja | Ja |
| dataSize | Ja | Ja | Ja | Ja | Ja |
| dbHash | Nein | Nein | Nein | Nein | Nein |
| dbStats | Ja | Ja | Ja | Ja | Ja |
| explain | Ja | Ja | Ja | Ja | Ja |
| Erklären: executionStats | Ja | Ja | Ja | Ja | Ja |
| features | Nein | Nein | Nein | Nein | Nein |
| hostInfo | Ja | Ja | Ja | Ja | Ja |
| listCommands | Ja | Ja | Ja | Ja | Ja |
| Profiler | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | Nein |
| serverStatus | Ja | Ja | Ja | Ja | Ja |
| top | Ja | Ja | Ja | Ja | Ja |
### Abfrage- und Schreiboperationen
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| Change streams | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [Ja](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | Nein |
| delete | Ja | Ja | Ja | Ja | Ja |
| find | Ja | Ja | Ja | Ja | Ja |
| findAndModify | Ja | Ja | Ja | Ja | Ja |
| getLastError | Nein | Nein | Nein | Nein | Nein |
| getMore | Ja | Ja | Ja | Ja | Ja |
| getPrevError | Nein | Nein | Nein | Nein | Nein |
| GridFS | Ja | Ja | Ja | Ja | Nein |
| insert | Ja | Ja | Ja | Ja | Ja |
| parallelCollectionScan | Nein | Nein | Nein | Nein | Nein |
| resetError | Nein | Nein | Nein | Nein | Nein |
| update | Ja | Ja | Ja | Ja | Ja |
| ReplaceOne | Ja | Ja | Ja | Ja | Ja |
### Befehle zur Rollenverwaltung
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| createRole | Ja | Ja | Ja | Ja | Nein |
| dropAllRolesFromDatabase | Ja | Ja | Ja | Ja | Nein |
| dropRole | Ja | Ja | Ja | Ja | Nein |
| grantRolesToRolle | Ja | Ja | Ja | Ja | Nein |
| revokeRolesFromRolle | Ja | Ja | Ja | Ja | Nein |
| revokePrivilegesFromRolle | Ja | Ja | Ja | Ja | Nein |
| rolesInfo | Ja | Ja | Ja | Ja | Nein |
| updateRole | Ja | Ja | Ja | Ja | Nein |
### Befehle für Sessions
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| Transaktion abbrechen | Nein | Ja | Ja | Ja | Nein |
| commitTransaction | Nein | Ja | Ja | Ja | Nein |
| Sitzungen beenden | Nein | Nein | Nein | Nein | Nein |
| killAllSessions | Nein | Ja | Ja | Ja | Nein |
| killAllSessionsByPattern | Nein | Nein | Nein | Nein | Nein |
| Sitzungen beenden | Nein | Ja | Ja | Ja | Nein |
| Sitzungen aktualisieren | Nein | Nein | Nein | Nein | Nein |
| Sitzung starten | Nein | Ja | Ja | Ja | Nein |
### Benutzerverwaltung
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| createUser | Ja | Ja | Ja | Ja | Ja |
| dropAllUsersFromDatabase | Ja | Ja | Ja | Ja | Ja |
| dropUser | Ja | Ja | Ja | Ja | Ja |
| grantRolesToBenutzer | Ja | Ja | Ja | Ja | Ja |
| revokeRolesFromBenutzer | Ja | Ja | Ja | Ja | Ja |
| updateUser | Ja | Ja | Ja | Ja | Ja |
| Benutzerinformationen | Ja | Ja | Ja | Ja | Ja |
### Sharding-Befehle
| Befehl | Elastischer Cluster |
| --- | --- |
| abortReshardCollection | Nein |
| Fügt Hard hinzu | Nein |
| addShardToZone | Nein |
| balancerCollectionStatus | Nein |
| Balancer starten | Nein |
| Balancer-Status | Nein |
| Balancer Stopp | Nein |
| checkShardingIndex | Nein |
| clearJumboFlag | Nein |
| cleanupOrphaned | Nein |
| cleanupReshardCollection | Nein |
| commitReshardCollection | Nein |
| Sharding aktivieren | Ja |
| flushRouterConfig | Nein |
| getShardMap | Nein |
| getShardVersion | Nein |
| isdbgrid | Nein |
| Listet Scherben auf | Nein |
| Median-Key | Nein |
| Chunk verschieben | Nein |
| Primär verschieben | Nein |
| Chunks zusammenführen | Nein |
| refineCollectionShardSchlüssel | Nein |
| Entfernt Hard | Nein |
| removeShardFromZone | Nein |
| Sammlung Reshard | Nein |
| setAllowMigrations | Nein |
| setShardVersion | Nein |
| Sammlung Shard | Ja |
| Status „Sharding“ | Nein |
| split | Nein |
| Vektor aufteilen | Nein |
| Harding rückgängig machen | Nein |
| updateZoneKeyReichweite | Nein |
## Abfrage- und Projektionsoperatoren
**Topics**
+ [Array-Operatoren](#mongo-apis-query-array-operators)
+ [Bitweise Operatoren](#mongo-apis-query-bitwise-operators)
+ [Operator kommentieren](#mongo-apis-query-comment-operator)
+ [Vergleichsoperatoren](#mongo-apis-query-comparison-operators)
+ [Elementoperatoren](#mongo-apis-query-element-operators)
+ [Operatoren für Bewertungsabfragen](#mongo-apis-query-evaluation-operators)
+ [Logische Operatoren](#mongo-apis-query-logical-operators)
+ [Projektionsoperatoren](#mongo-apis-projection-operators)
### Array-Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1elemMatch](elemMatch.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1size](size-query.md) | Ja | Ja | Ja | Ja | Ja |
### Bitweise Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1bitsAnySet](bitsAnySet.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1bitsAllClear](bitsAllClear.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1bitsAnyClear](bitsAnyClear.md) | Ja | Ja | Ja | Ja | Ja |
### Operator kommentieren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | Ja | Ja | Ja | Ja | Ja |
### Vergleichsoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1gt](gt.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1gte](gte.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1in](in.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1lt](lt.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1lte](lte.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1ne](ne.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1nin](nin.md) | Ja | Ja | Ja | Ja | Ja |
### Elementoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1type](type.md) | Ja | Ja | Ja | Ja | Ja |
### Operatoren für Bewertungsabfragen
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | Nein | Ja | Ja | Ja | Nein |
| [\$1jsonSchema](jsonSchema.md) | Nein | Ja | Ja | Ja | Nein |
| [\$1mod](mod-query.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1regex](regex.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1text](text.md) | Nein | Nein | Ja | Ja | Nein |
| \$1where | Nein | Nein | Nein | Nein | Nein |
### Logische Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1nor](nor.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1not](not.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1or](or.md) | Ja | Ja | Ja | Ja | Ja |
### Projektionsoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1elemMatch](elemMatch.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1meta](meta.md) | Nein | Nein | Ja | Ja | Nein |
| [\$1slice](slice-projection.md) | Ja | Ja | Ja | Ja | Ja |
## Operatoren aktualisieren
**Topics**
+ [Array-Operatoren](#mongo-apis-update-array)
+ [Bitweise Operatoren](#mongo-apis-update-bitwise)
+ [Feldoperatoren](#mongo-apis-update-field)
+ [Modifikatoren aktualisieren](#mongo-apis-update-modifiers)
### Array-Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1[]](dollarBrackets-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1[]](dollarIdentifier-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1addToSet](addToSet.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1pop](pop.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1pullAll](pullAll.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1pull](pull.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1push](push.md) | Ja | Ja | Ja | Ja | Ja |
### Bitweise Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | Ja | Ja | Ja | Ja | Ja |
### Feldoperatoren
| Operator | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1inc](inc.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1max](max-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1min](min-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1mul](mul.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1rename](rename.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1set](set-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1setOnInsert](setOnInsert.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1unset](unset-update.md) | Ja | Ja | Ja | Ja | Ja |
### Modifikatoren aktualisieren
| Operator | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1position](position.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1slice](slice-update.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1sort](sort-update.md) | Ja | Ja | Ja | Ja | Ja |
## Geodaten
### Geometrie-Spezifizierer
| Abfrageauswahl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| \$1box | Nein | Nein | Nein | Nein | Nein |
| \$1center | Nein | Nein | Nein | Nein | Nein |
| \$1centerSphere | Nein | Nein | Nein | Nein | Nein |
| [\$1geometry](geometry.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1maxDistance](maxDistance.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1minDistance](minDistance.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1nearSphere](nearSphere.md) | Ja | Ja | Ja | Ja | Ja |
| \$1polygon | Nein | Nein | Nein | Nein | Nein |
| \$1uniqueDocs | Nein | Nein | Nein | Nein | Nein |
### Selektoren abfragen
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1geoWithin](geoWithin.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1near](near.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1nearSphere](nearSphere.md) | Ja | Ja | Ja | Ja | Ja |
| \$1polygon | Nein | Nein | Nein | Nein | Nein |
| \$1uniqueDocs | Nein | Nein | Nein | Nein | Nein |
## Cursor-Methoden
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | Ja | Ja | Ja | Ja | Ja |
| cursor.close() | Ja | Ja | Ja | Ja | Ja |
| cursor.collation() | Nein | Nein | Nein | Ja | Nein |
| cursor.comment() | Ja | Ja | Ja | Ja | Ja |
| cursor.count() | Ja | Ja | Ja | Ja | Ja |
| cursor.explain() | Ja | Ja | Ja | Ja | Nein |
| cursor.forEach() | Ja | Ja | Ja | Ja | Ja |
| cursor.hasNext() | Ja | Ja | Ja | Ja | Ja |
| cursor.hint() | Ja | Ja | Ja | Ja | Ja\$1 |
| cursor.isClosed() | Ja | Ja | Ja | Ja | Ja |
| cursor.isExhausted() | Ja | Ja | Ja | Ja | Nein |
| cursor.itcount() | Ja | Ja | Ja | Ja | Nein |
| cursor.limit() | Ja | Ja | Ja | Ja | Nein |
| cursor.map() | Ja | Ja | Ja | Ja | Nein |
| cursor.max() | Nein | Nein | Nein | Nein | Nein |
| cursor.maxScan() | Ja | Ja | Ja | Ja | Nein |
| cursor.maxTimeMS() | Ja | Ja | Ja | Ja | Nein |
| cursor.min() | Nein | Nein | Nein | Nein | Nein |
| cursor.next() | Ja | Ja | Ja | Ja | Ja |
| Cursor. noCursorTimeout() | Nein | Nein | Nein | Nein | Nein |
| Cursor. objsLeftInBatch () | Ja | Ja | Ja | Ja | Nein |
| cursor.pretty() | Ja | Ja | Ja | Ja | Nein |
| cursor.readConcern() | Ja | Ja | Ja | Ja | Nein |
| cursor.readPref() | Ja | Ja | Ja | Ja | Nein |
| cursor.returnKey() | Nein | Nein | Nein | Nein | Nein |
| Cursor. showRecordId() | Nein | Nein | Nein | Nein | Nein |
| cursor.size() | Ja | Ja | Ja | Ja | Nein |
| cursor.skip() | Ja | Ja | Ja | Ja | Nein |
| cursor.sort() | Ja | Ja | Ja | Ja | Nein |
| cursor.tailable() | Nein | Nein | Nein | Nein | Nein |
| cursor.toArray() | Ja | Ja | Ja | Ja | Nein |
\$1 Index `hint` wird mit Indexausdrücken unterstützt. Beispiel, `db.foo.find().hint({x:1})`.
## Operatoren für Aggregationspipelines
**Topics**
+ [Akkumulatorausdrücke](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [Arithmetische Operatoren](#mongo-apis-aggregation-pipeline-arithmetic)
+ [Array-Operatoren](#mongo-apis-aggregation-pipeline-array)
+ [Boolesche Operatoren](#mongo-apis-aggregation-pipeline-boolean)
+ [Vergleichsoperatoren](#mongo-apis-aggregation-pipeline-comparison)
+ [Operatoren für bedingte Ausdrücke](#mongo-apis-aggregation-pipeline-conditional)
+ [Datentyp-Operator](#mongo-apis-aggregation-pipeline-data-type)
+ [Operator zur Datengröße](#mongo-apis-aggregation-pipeline-data-size)
+ [Datumsoperatoren](#mongo-apis-aggregation-pipeline-date)
+ [Wörtlicher Operator](#mongo-apis-aggregation-pipeline-literal)
+ [Operator zusammenführen](#mongo-apis-aggregation-pipeline-merge)
+ [Natürlicher Operator](#mongo-apis-aggregation-pipeline-natural)
+ [Satzoperatoren](#mongo-apis-aggregation-pipeline-set)
+ [Betreiber der Bühne](#mongo-apis-aggregation-pipeline-stage)
+ [Zeichenfolgenoperatoren](#mongo-apis-aggregation-pipeline-string)
+ [Systemvariablen](#mongo-apis-aggregation-pipeline-system-variables)
+ [Operator für die Textsuche](#mongo-apis-aggregation-pipeline-text-search)
+ [Geben Sie Konvertierungsoperatoren ein](#mongo-apis-aggregation-pipeline-type)
+ [Variablenoperatoren](#mongo-apis-aggregation-pipeline-variable)
+ [Verschiedene Betreiber](#mongo-apis-aggregation-pipeline-misc)
### Akkumulatorausdrücke
| Expression | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| \$1Akkumulator | - | - | Nein | Nein | Nein |
| [\$1addToSet](addToSet-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1avg](avg.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1count](count.md) | - | - | Nein | Nein | Nein |
| \$1KovarianzPop | Nein | Nein | Nein | Nein | Nein |
| \$1KovarianzAMP | Nein | Nein | Nein | Nein | Nein |
| \$1 DenseRank | Nein | Nein | Nein | Nein | Nein |
| \$1 Ableitung | Nein | Nein | Nein | Nein | Nein |
| \$1 Nummer des Dokuments | Nein | Nein | Nein | Nein | Nein |
| \$1expMovingAvg | Nein | Nein | Nein | Nein | Nein |
| [\$1first](first.md) | Ja | Ja | Ja | Ja | Ja |
| \$1 integral | Nein | Nein | Nein | Nein | Nein |
| [\$1last](last.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1max](max.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1min](min.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1push](push-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| \$1 Rang | Nein | Nein | Nein | Nein | Nein |
| \$1 Schicht | Nein | Nein | Nein | Nein | Nein |
| \$1stdDevPop | Nein | Nein | Nein | Nein | Nein |
| \$1stdDevSamp | Nein | Nein | Nein | Nein | Nein |
| [\$1sum](sum.md) | Ja | Ja | Ja | Ja | Ja |
### Arithmetische Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1add](add.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1ceil](ceil.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1divide](divide.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1exp](exp.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1floor](floor.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1ln](ln.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1log](log.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1log10](log10.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1mod](mod.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1multiply](multiply.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1pow](pow.md) | Nein | Nein | Nein | Ja | Nein |
| \$1rund | - | - | Nein | Nein | Nein |
| [\$1sqrt](sqrt.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1subtract](subtract.md) | Ja | Ja | Ja | Ja | Ja |
| \$1trunc | Nein | Nein | Nein | Nein | Nein |
### Array-Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1arrayToObject](arrayToObject.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1concatArrays](concatArrays.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1filter](filter.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1first](first.md) | - | - | Ja | Ja | Nein |
| [\$1in](in-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1indexOfArray](indexOfArray.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1isArray](isArray.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1last](last.md) | - | - | Ja | Ja | Nein |
| [\$1objectToArray](objectToArray.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1range](range.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1reverseArray](reverseArray.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1reduce](reduce.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1size](size.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1slice](slice.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1zip](zip.md) | Ja | Ja | Ja | Ja | Ja |
### Boolesche Operatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1not](not-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1or](or-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
### Vergleichsoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1eq](eq-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1gt](gt-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1gte](gte-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1lt](lt-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1lte](lte-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1ne](ne-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
### Operatoren für bedingte Ausdrücke
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1ifNull](ifNull.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1switch](switch.md) | Nein | Ja | Ja | Ja | Nein |
### Datentyp-Operator
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | Ja | Ja | Ja | Ja | Ja |
### Operator zur Datengröße
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| \$1BinarySize | - | - | Nein | Nein | Nein |
| \$1 bsonGröße | - | - | Nein | Nein | Nein |
### Datumsoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1DateAdd](dateAdd.md) | Nein | Nein | Ja | Ja | Ja |
| [\$1DateDiff](dateDiff.md) | - | - | Ja | Ja | Nein |
| \$1dateFromParts | Nein | Nein | Nein | Nein | Nein |
| [\$1dateFromString](dateFromString.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1DateSubtrahieren](dateSubtract.md) | Nein | Nein | Ja | Ja | Ja |
| \$1dateToParts | Nein | Nein | Nein | Nein | Nein |
| [\$1dateToString](dateToString.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1DateTrunc](dateTrunc.md) | - | - | Nein | Ja | Nein |
| [\$1dayOfMonth](dayOfMonth.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1dayOfWeek](dayOfWeek.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1dayOfYear](dayOfYear.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1hour](hour.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1 isoDayOf Woche](isoDayOfWeek.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1isoWeek](isoWeek.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1isoWeekYear](isoWeekYear.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1millisecond](millisecond.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1minute](minute.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1month](month.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1second](second.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1week](week.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1year](year.md) | Ja | Ja | Ja | Ja | Ja |
### Wörtlicher Operator
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | Ja | Ja | Ja | Ja | Ja |
### Operator zusammenführen
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | Ja | Ja | Ja | Ja | Ja |
### Natürlicher Operator
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1 natürlich](natural.md) | Ja | Ja | Ja | Ja | Ja |
### Satzoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1anyElementTrue](anyElementTrue.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1setDifference](setDifference.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1setEquals](setEquals.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1setIntersection](setIntersection.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1setIsSubset](setIsSubset.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1setUnion](setUnion.md) | Ja | Ja | Ja | Ja | Ja |
| \$1setWindowFields | Nein | Nein | Nein | Nein | Nein |
### Betreiber der Bühne
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1bucket](bucket.md) | Nein | Nein | Nein | Ja | Nein |
| \$1bucketAuto | Nein | Nein | Nein | Nein |
| [\$1 Stream ändern](changeStream.md) | Ja | Ja | Ja | Ja | Nein |
| [\$1collStats](collStats.md) | Nein | Ja | Ja | Ja | Nein |
| [\$1count](count.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1currentOp](currentOp.md) | Ja | Ja | Ja | Ja | Ja |
| \$1facet | Nein | Nein | Nein | Nein | Nein |
| [\$1geoNear](geoNear.md) | Ja | Ja | Ja | Ja | Ja |
| \$1graphLookup | Nein | Nein | Nein | Nein | Nein |
| [\$1group](group.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1indexStats](indexStats.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1limit](limit.md) | Ja | Ja | Ja | Ja | Ja |
| \$1listLocalSessions | Nein | Nein | Nein | Nein | Nein |
| \$1listSessions | Nein | Nein | Nein | Nein | Nein |
| [\$1lookup](lookup.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1match](match.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1 zusammenführen](merge.md) | - | - | Nein | Ja | Nein |
| [\$1out](out.md) | Ja | Ja | Ja | Ja | Nein |
| \$1planCacheStats | - | - | Nein | Nein | Nein |
| [\$1project](project.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1redact](redact.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1replaceRoot](replaceRoot.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1sample](sample.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1set](set-stage.md) | - | - | Nein | Ja | Nein |
| \$1setWindowFields | - | - | Nein | Nein | Nein |
| [\$1skip](skip.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1sort](sort.md) | Ja | Ja | Ja | Ja | Ja |
| \$1sortByCount | Nein | Nein | Nein | Nein | Nein |
| \$1 Union mit | - | - | Nein | Nein | Nein |
| [\$1unset](unset-stage.md) | - | - | Nein | Ja | Nein |
| [\$1unwind](unwind.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1 ersetzendurch](replaceWith.md) | Nein | Nein | Nein | Ja | Nein |
| [\$1VectorSearch](vectorSearch.md) | Nein | Nein | Nein | Ja | Nein |
### Zeichenfolgenoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1indexOfBytes](indexOfBytes.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1indexOfCP](indexOfCP.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1 ltrim](ltrim.md) | Nein | Ja | Ja | Ja | Nein |
| [\$1RegexFind](regexFind.md) | - | - | Ja | Ja | Nein |
| [\$1regexFindAll](regexFindAll.md) | - | - | Ja | Ja | Nein |
| [\$1RegexMatch](regexMatch.md) | - | - | Ja | Ja | Nein |
| [\$1 Alles ersetzen](replaceAll.md) | - | - | Ja | Ja | Nein |
| [\$1 ersetzenEins](replaceOne.md) | - | - | Ja | Ja | Nein |
| [\$1rtrim](rtrim.md) | Nein | Ja | Ja | Ja | Nein |
| [\$1split](split.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1strcasecmp](strcasecmp.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1strLenBytes](strLenBytes.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1strLenCP](strLenCP.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1substr](substr.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1substrBytes](substrBytes.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1substrCP](substrCP.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1toLower](toLower.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1toUpper](toUpper.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1trim](trim.md) | Nein | Ja | Ja | Ja | Nein |
### Systemvariablen
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | Nein | Nein | Nein | Nein | Nein |
| [\$1\$1DESCEND](DESCEND.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1\$1KEEP](KEEP.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1\$1PRUNE](PRUNE.md) | Ja | Ja | Ja | Ja | Ja |
| \$1\$1REMOVE | Nein | Nein | Nein | Nein | Nein |
| [\$1 WURZEL](ROOT.md) | Ja | Ja | Ja | Ja | Ja |
### Operator für die Textsuche
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | Nein | Nein | Ja | Ja | Nein |
| [\$1suche](search.md) | Nein | Nein | Ja | Ja | Nein |
### Geben Sie Konvertierungsoperatoren ein
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1 konvertieren](convert.md) | Nein | Ja | Ja | Ja | Ja |
| \$1 ist Zahl | - | - | Nein | Nein | Nein |
| [\$1 zu Bool](toBool.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1 bis Datum](toDate.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1 zu Dezimal](toDecimal.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1 bis verdoppeln](toDouble.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1 zu Int](toInt.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1 zu Long](toLong.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1toObjectId](toObjectId.md) | Nein | Ja | Ja | Ja | Ja |
| [\$1 toString](toString.md) | Nein | Ja | Ja | Ja | Ja |
### Variablenoperatoren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | Ja | Ja | Ja | Ja | Ja |
| [\$1map](map.md) | Ja | Ja | Ja | Ja | Ja |
### Verschiedene Betreiber
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | Nein | Nein | Nein |
| [\$1 Rand](rand.md) | - | - | Nein | Ja | Nein |
| \$1Abtastrate | - | - | Nein | Nein | Nein |
## Datentypen
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| 32-Bit-Ganzzahl (int) | Ja | Ja | Ja | Ja | Ja |
| 64-Bit-Ganzzahl (lang) | Ja | Ja | Ja | Ja | Ja |
| Array | Ja | Ja | Ja | Ja | Ja |
| Binäre Daten | Ja | Ja | Ja | Ja | Ja |
| Boolesch | Ja | Ja | Ja | Ja | Ja |
| Date | Ja | Ja | Ja | Ja | Ja |
| DBPointer | Nein | Nein | Nein | Nein | Nein |
| DBRefs | Nein | Nein | Nein | Nein | Nein |
| Decimal128 | Ja | Ja | Ja | Ja | Ja |
| Double | Ja | Ja | Ja | Ja | Ja |
| JavaScript | Nein | Nein | Nein | Nein | Nein |
| JavaScript(mit Gültigkeitsbereich) | Nein | Nein | Nein | Nein | Nein |
| MaxKey | Ja | Ja | Ja | Ja | Ja |
| MinKey | Ja | Ja | Ja | Ja | Ja |
| Null | Ja | Ja | Ja | Ja | Ja |
| Objekt | Ja | Ja | Ja | Ja | Ja |
| ObjectId | Ja | Ja | Ja | Ja | Ja |
| Regulärer Ausdruck | Ja | Ja | Ja | Ja | Ja |
| Zeichenfolge | Ja | Ja | Ja | Ja | Ja |
| Symbol | Nein | Nein | Nein | Nein | Nein |
| Zeitstempel | Ja | Ja | Ja | Ja | Ja |
| Undefined | Nein | Nein | Nein | Nein | Nein |
## Indizes und Indexeigenschaften
**Topics**
+ [Indizes](#mongo-apis-indexes)
+ [Eigenschaften indizieren](#mongo-apis-index-properties)
### Indizes
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | Ja | Ja | Ja | Ja | Ja |
| 2D-Index | Nein | Nein | Nein | Nein | Nein |
| Verbundindex | Ja | Ja | Ja | Ja | Ja |
| Hash-Index | Nein | Nein | Nein | Nein | Nein |
| Multikey-Index | Ja | Ja | Ja | Ja | Ja |
| Einzelfeldindex | Ja | Ja | Ja | Ja | Ja |
| Textindex | Nein | Nein | Ja | Ja | Nein |
| Platzhalter | Nein | Nein | Nein | Nein | Nein |
### Eigenschaften indizieren
| Befehl | 3.6 | 4,0 | 5.0 | 8.0 | Elastischer Cluster |
| --- | --- | --- | --- | --- | --- |
| Hintergrund | Ja | Ja | Ja | Ja | Ja |
| Berücksichtigt Groß- und Kleinschreibung nicht | Nein | Nein | Nein | Ja | Nein |
| Hidden | Nein | Nein | Nein | Nein | Nein |
| Teilweise | Nein | Nein | Ja | Ja | Nein |
| Sparse | Ja | Ja | Ja | Ja | Ja |
| Text | Nein | Nein | Ja | Ja | Nein |
| TTL | Ja | Ja | Ja | Ja | Ja |
| Eindeutig | Ja | Ja | Ja | Ja | Ja |
| Vektor | Nein | Nein | Ja | Ja | Nein |
Ausführliche Informationen zu bestimmten MongoDB-Operatoren finden Sie in den folgenden Themen:
+ [Betreiber von Aggregationspipelines](mongo-apis-aggregation-pipeline-operators.md)
+ [Geodaten](mongo-apis-geospatial-operators.md)
+ [Projektionsoperatoren](#mongo-apis-projection-operators)
+ [Operatoren aktualisieren](mongo-apis-update-operators.md)
# Betreiber von Aggregationspipelines
Dieser Abschnitt enthält detaillierte Informationen zu Aggregationspipeline-Operatoren, die von Amazon DocumentDB unterstützt werden.
**Topics**
+ [\$1\$1DESCEND](DESCEND.md)
+ [\$1\$1KEEP](KEEP.md)
+ [\$1\$1PRUNE](PRUNE.md)
+ [\$1 WURZEL](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)
+ [\$1 Stream ändern](changeStream.md)
+ [\$1cmp](cmp.md)
+ [\$1collStats](collStats.md)
+ [\$1concat](concat.md)
+ [\$1concatArrays](concatArrays.md)
+ [\$1cond](cond.md)
+ [\$1 konvertieren](convert.md)
+ [\$1count](count.md)
+ [\$1currentOp](currentOp.md)
+ [\$1DateAdd](dateAdd.md)
+ [\$1DateDiff](dateDiff.md)
+ [\$1dateFromString](dateFromString.md)
+ [\$1DateSubtrahieren](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 Woche](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)
+ [\$1 ltrim](ltrim.md)
+ [\$1map](map.md)
+ [\$1match](match.md)
+ [\$1max](max.md)
+ [\$1meta](meta-aggregation.md)
+ [\$1 zusammenführen](merge.md)
+ [\$1mergeObjects](mergeObjects.md)
+ [\$1millisecond](millisecond.md)
+ [\$1min](min.md)
+ [\$1minute](minute.md)
+ [\$1mod](mod.md)
+ [\$1month](month.md)
+ [\$1multiply](multiply.md)
+ [\$1 natürlich](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 Alles ersetzen](replaceAll.md)
+ [\$1 ersetzenEins](replaceOne.md)
+ [\$1replaceRoot](replaceRoot.md)
+ [\$1 ersetzendurch](replaceWith.md)
+ [\$1reverseArray](reverseArray.md)
+ [\$1rtrim](rtrim.md)
+ [\$1sample](sample.md)
+ [\$1suche](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 zu Bool](toBool.md)
+ [\$1 bis Datum](toDate.md)
+ [\$1 zu Dezimal](toDecimal.md)
+ [\$1 bis verdoppeln](toDouble.md)
+ [\$1 zu Int](toInt.md)
+ [\$1 zu Long](toLong.md)
+ [\$1toLower](toLower.md)
+ [\$1toObjectId](toObjectId.md)
+ [\$1 toString](toString.md)
+ [\$1toUpper](toUpper.md)
+ [\$1trim](trim.md)
+ [\$1type](type-aggregation.md)
+ [\$1unset](unset-stage.md)
+ [\$1unwind](unwind.md)
+ [\$1VectorSearch](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
Der `$$DESCEND` Operator in Amazon DocumentDB ist ein spezieller Positions-Array-Operator, der in der `$redact` Pipeline-Phase verwendet wird. Er weist die Aggregationspipeline an, in das aktuelle Dokument abzusteigen und alle Felder zu verarbeiten, unabhängig von ihrer Verschachtelungsebene.
Wenn die `$redact` Phase auf den `$$DESCEND` Operator trifft, bleiben alle Felder im aktuellen Dokument sichtbar und werden weiter unten in der Pipeline verarbeitet. Dies ist nützlich, wenn Sie bestimmte Felder anhand einer Bedingung selektiv schwärzen oder beschneiden und dabei die Struktur des Dokuments beibehalten möchten.
**Parameter**
Keine.
## Beispiel (MongoDB Shell)
In diesem Beispiel verwenden wir den `$redact` Schritt mit dem `$$DESCEND` Operator, um selektiv Dokumente anzuzeigen, bei denen das `code` Feld „Reg“ entspricht.
**Erstellen Sie Beispieldokumente**
```
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" }
]);
```
**Beispiel für eine Abfrage**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**Ausgabe**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$$DESCEND` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Die `$$KEEP` Systemvariable wird zusammen mit der `$redact` Phase in der Aggregationspipeline verwendet, um das aktuelle Dokument oder Feld unverändert zu lassen und es in die Ausgabe aufzunehmen.
**Parameter**
Keine
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt die Verwendung von `$$KEEP` in einer Amazon DocumentDB-Aggregationspipeline. Dokumente werden nur aufbewahrt, wenn der Zugriff auf „öffentlich“ steht, andernfalls werden sie entfernt.
**Erstellen Sie Beispieldokumente**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**Beispiel für eine Abfrage**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**Ausgabe**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$$KEEP` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Die `$$PRUNE` Systemvariable wird zusammen mit der `$redact` Phase in der Aggregationspipeline verwendet, um Dokumente oder eingebettete Dokumentebenen aus den Ergebnissen auszuschließen. Wenn eine Bedingung als Ergebnis ausgewertet wird`$$PRUNE`, wird das aktuelle Dokument oder Unterdokument aus der Ausgabe entfernt. Es wird normalerweise zusammen mit `$$DESCEND` (um das Dokument zu behalten und zu durchsuchen) oder `$$KEEP` (um das Dokument auf allen Ebenen beizubehalten) verwendet.
**Parameter**
Keine. Die `$$PRUNE` Systemvariable wird ohne Parameter verwendet und muss mit `$redact` verwendet werden.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie Sie `$$PRUNE` mit with Benutzer`$redact`, die älter als 30 Jahre sind, von den Ergebnissen ausschließen können.
**Erstellen Sie Beispieldokumente**
```
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" } }
])
```
**Beispiel für eine Abfrage**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**Ausgabe**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$$PRUNE` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
async function main() {
await client.connect();
const db = client.db('test');
const users = db.collection('users');
const result = await users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
users = db['users']
result = list(users.aggregate([
{
'$redact': {
'$cond': {
'if': { '$gt': ['$age', 30] },
'then': '$$PRUNE',
'else': '$$DESCEND'
}
}
}
]))
print(result)
client.close()
```
------
# \$1 WURZEL
Der `$ROOT` Operator in Amazon DocumentDB wird verwendet, um auf das gesamte Eingabedokument innerhalb einer Aggregationspipeline zu verweisen. Damit können Sie auf das gesamte Dokument zugreifen und es bearbeiten, einschließlich all seiner verschachtelten Felder und Strukturen.
**Parameter**
Keine
## Beispiel (MongoDB Shell)
Dieses Beispiel zeigt, wie `$ROOT` Sie ein Prüfprotokoll erstellen können, das das vollständige Originaldokument zusammen mit Metadaten darüber, wann es verarbeitet wurde, erfasst.
**Erstellen Sie Beispieldokumente**
```
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
}
]);
```
**Beispiel für eine Abfrage**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**Ausgabe**
```
[
{
_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'
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$ROOT` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$abs` Operator in Amazon DocumentDB gibt den absoluten Wert einer Zahl zurück. Er kann in der Aggregationspipeline verwendet werden, um mathematische Operationen an numerischen Feldern durchzuführen.
**Parameter**
+ `number`: Der numerische Ausdruck, für den der absolute Wert zurückgegeben wird.
## Beispiel (MongoDB Shell)
Dieses Beispiel demonstriert die Verwendung des `$abs` Operators, um den absoluten Wert eines numerischen Feldes zu ermitteln.
**Erstellen Sie Beispieldokumente**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**Beispiel für eine Abfrage**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**Ausgabe**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$abs` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$add` Operator in Amazon DocumentDB wird verwendet, um Zahlen oder Daten zu addieren. Er kann verwendet werden, um arithmetische Operationen an numerischen Feldern durchzuführen oder um Datumsarithmetik durchzuführen, indem einem Datumsfeld eine Anzahl von Zeiteinheiten hinzugefügt wird.
**Parameter**
+ `expression1`: Die erste Zahl oder das erste Datum, das hinzugefügt werden soll.
+ `expression2`: Die zweite Zahl oder das zweite Datum, das hinzugefügt werden soll.
+ `expression3`: (optional) Zusätzliche Zahlen oder Daten, die hinzugefügt werden sollen.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$add` Operator verwendet wird, um zwei Zahlen zu addieren.
**Erstellen Sie Beispieldokumente**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**Beispiel für eine Abfrage**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**Ausgabe**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
In diesem Beispiel wird der `$add` Operator verwendet, um die Werte der `b` Felder `a` und für jedes Dokument hinzuzufügen und das Ergebnis im `sum` Feld zu speichern.
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$add` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$addToSet` Aggregationsoperator gibt für jede Gruppe ein Array von Einzelwerten aus einem angegebenen Ausdruck zurück. Er wird innerhalb der `$group` Phase verwendet, um unterschiedliche Werte zu akkumulieren, wodurch Duplikate automatisch entfernt werden.
**Parameter**
+ `expression`: Der Ausdruck, der für jedes Dokument in der Gruppe ausgewertet werden soll.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$addToSet` Operator verwendet wird, um für jeden Kunden eindeutige Städte zu erfassen, in denen Bestellungen aufgegeben wurden.
**Erstellen Sie Beispieldokumente**
```
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 }
]);
```
**Beispiel für eine Abfrage**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**Ausgabe**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$addToSet` Aggregationsoperators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Die `$addFields` Phase in der Amazon DocumentDB-Aggregationspipeline ermöglicht es Ihnen, neue berechnete Felder zu Dokumenten hinzuzufügen. Dies kann nützlich sein, um den Dokumenten abgeleitete oder transformierte Daten hinzuzufügen.
**Parameter**
+ `newField`: Der Name des neuen Feldes, das hinzugefügt werden soll.
+ `expression`: Ein Ausdruck, der den Wert des neuen Felds ergibt.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie Sie ein neues Feld `$addFields` hinzufügen`TotalInventory`, das den Gesamtbestand auf der Grundlage der Felder `Inventory.OnHand` und `Inventory.OrderQnty` berechnet.
**Erstellen Sie Beispieldokumente**
```
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
}
]);
```
**Beispiel für eine Abfrage**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**Ausgabe**
```
[
{
"_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
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$addFields` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 4.0
Der `$allElementsTrue` Operator wird verwendet, um zu überprüfen, ob alle Elemente in einem Array einen wahren Wert ergeben.
**Parameter**
+ `expression`: Ein Ausdruck, der zu einem Array ausgewertet wird.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt die Verwendung von`$allElementsTrue`, um zu überprüfen, ob alle Elemente in einem Array wahr sind.
**Erstellen Sie Beispieldokumente**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**Beispiel für eine Abfrage**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**Ausgabe**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
In diesem Beispiel prüft die Abfrage, ob alle Elemente im `scores` Array größer als 0 sind. Das Dokument mit `"name": "Jane"` wird ausgeschlossen, weil das `scores` Array eine 0 enthält, was ein falscher Wert ist.
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$allElementsTrue` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$and` Aggregationsoperator wertet mehrere Ausdrücke aus und gibt `true` nur zurück, wenn alle Ausdrücke zu 0 ausgewertet werden. `true` Wenn ein Ausdruck „Ja“ ist`false`, wird er zurückgegeben. `false`
**Parameter**
+ `expressions`: Eine Reihe von Ausdrücken, die ausgewertet werden sollen.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$and` Operator verwendet wird, um zu überprüfen, ob Produkte mehrere Kriterien erfüllen.
**Erstellen Sie Beispieldokumente**
```
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 }
]);
```
**Beispiel für eine Abfrage**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**Ausgabe**
```
[
{ _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 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$and` Aggregationsoperators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 4.0
Der `$anyElementTrue` Operator wird verwendet, um festzustellen, ob ein Element in einem Array wahr ist.
**Parameter**
+ `field`: Ein auszuwertendes Array-Feld.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt die Verwendung von`$anyElementTrue`, um zu überprüfen, ob ein Element in einem Array wahr ist.
**Erstellen Sie Beispieldokumente**
```
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] }
])
```
**Beispiel für eine Abfrage**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**Ausgabe**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$anyElementTrue` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$arrayElemAt` Operator in Amazon DocumentDB ermöglicht es Ihnen, ein Element anhand seiner Indexposition aus einem Array abzurufen. Dies ist besonders nützlich, wenn Sie auf ein bestimmtes Element innerhalb eines Array-Felds in Ihren Dokumenten zugreifen müssen.
**Parameter**
+ `array`: Das Eingabe-Array, aus dem ein Element abgerufen werden soll.
+ `index`: Die auf Null basierende Indexposition des abzurufenden Elements. Dieser Wert muss eine nicht negative Ganzzahl sein.
## Beispiel (MongoDB Shell)
In diesem Beispiel zeigen wir, wie der `$arrayElemAt` Operator verwendet wird, um bestimmte Elemente aus dem `flight_miles` Array in der `miles` Sammlung abzurufen.
**Erstellen Sie Beispieldokumente**
```
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 ]}
]);
```
**Beispiel für eine Abfrage**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**Ausgabe**
```
{ "_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 diesem Beispiel verwenden wir den `$arrayElemAt` Operator, um das erste und das letzte Element des `flight_miles` Arrays für jedes Dokument abzurufen.
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$arrayElemAt` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$arrayToObject` Operator in Amazon DocumentDB ist das Gegenteil des `$objectToArray` Operators. Er nimmt ein Array von Dokumenten mit Schlüssel-Wert-Paaren und konvertiert es in ein einzelnes Dokument. Dies ist besonders nützlich, wenn Sie ein Array von Schlüssel-Wert-Paaren wieder in eine Objekt- oder Dokumentstruktur konvertieren müssen.
**Parameter**
+ `array expression`: Ein Ausdruck, der in ein Array aufgelöst wird. Die Array-Elemente müssen Dokumente mit zwei Feldern sein: `k` (der Schlüssel) und `v` (der Wert).
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie Sie `$arrayToObject` ein Array von Schlüssel-Wert-Paaren wieder in ein Dokument konvertieren können.
**Erstellen Sie Beispieldokumente**
```
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 } }
]);
```
**Beispiel für eine Abfrage**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**Ausgabe**
```
{ "_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 diesem Beispiel wird der `$objectToArray` Operator verwendet, um das `inventory` Objekt in ein Array von Schlüssel-Wert-Paaren umzuwandeln. Der `$arrayToObject` Operator wird dann verwendet, um das Array wieder in ein Dokument zu konvertieren, wodurch die ursprüngliche Objektstruktur wiederhergestellt wird.
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$arrayToObject` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$avg` Aggregationsoperator in Amazon DocumentDB berechnet den Durchschnittswert des angegebenen Ausdrucks für die Dokumente, die in die Phase eingegeben werden. Dieser Operator ist nützlich, um den Durchschnitt eines numerischen Felds oder Ausdrucks in einer Reihe von Dokumenten zu berechnen.
**Parameter**
+ `expression`: Der Ausdruck, der zur Berechnung des Durchschnitts verwendet werden soll. Dies kann ein Feldpfad (z. B.`"$field"`) oder ein Ausdruck (z. B.`{ $multiply: ["$field1", "$field2"] }`) sein.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$avg` Operator verwendet wird, um die durchschnittliche Punktzahl für eine Reihe von Studentendokumenten zu berechnen.
**Erstellen Sie Beispieldokumente**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**Beispiel für eine Abfrage**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**Ausgabe**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$avg` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 8.0
Wird von Elastic Cluster nicht unterstützt.
Die `$bucket` Aggregationsphase in Amazon DocumentDB ermöglicht es Ihnen, Eingabedokumente auf der Grundlage eines bestimmten Ausdrucks und der Bucket-Grenzen in Buckets zu gruppieren. Dies kann nützlich sein, um Daten zu analysieren, die in bestimmte Wertebereiche oder Kategorien fallen.
**Parameter**
+ `groupBy`(erforderlich): Der Ausdruck, der den Wert angibt, nach dem gruppiert werden soll.
+ `boundaries`(erforderlich): Ein Array mit doppelten Werten, die die Bucket-Grenzen definieren. Dokumente werden Buckets auf der Grundlage des `groupBy` Ausdruckswerts zugewiesen, der innerhalb der angegebenen Grenzen liegt.
+ `default`(optional): Ein Literalwert, der für Dokumente ausgegeben wird, deren `groupBy` Ausdruckswert unter keine der angegebenen Grenzen fällt.
+ `output`(optional): Ein Objekt, das die Informationen angibt, die für jeden Bucket ausgegeben werden sollen. Sie können Akkumulatoroperatoren wie`$sum`,, und verwenden `$avg``$min`, `$max` um Aggregationen für jeden Bucket zu berechnen.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie die `$bucket` Phase verwendet wird, um Verkaufsdaten nach Preisklassen zu gruppieren.
**Erstellen Sie Beispieldokumente**
```
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") }
]);
```
**Beispiel für eine Abfrage**
```
db.sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
])
```
**Ausgabe**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$bucket` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 4.0
Der `$ceil` Operator in Amazon DocumentDB rundet wie in MongoDB eine Zahl auf die nächste Ganzzahl auf. Dies ist nützlich, wenn Sie mathematische Operationen an numerischen Feldern ausführen und sicherstellen müssen, dass das Ergebnis eine ganze Zahl ist.
**Parameter**
+ `expression`: Der numerische Ausdruck, der aufgerundet werden soll.
## Beispiel (MongoDB Shell)
Dieses Beispiel zeigt, wie der `$ceil` Operator verwendet wird, um ein numerisches Feld aufzurunden.
**Erstellen Sie Beispieldokumente**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**Beispiel für eine Abfrage**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**Ausgabe**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$ceil` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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()
```
------
# \$1 Stream ändern
Wird von Elastic Cluster nicht unterstützt.
In der `$changeStream` Aggregationsphase wird ein Change-Stream-Cursor geöffnet, um Änderungen an einer Sammlung in Echtzeit zu überwachen. Sie gibt Änderungsereignisdokumente zurück, wenn Einfüge-, Aktualisierungs-, Ersetzungs- oder Löschvorgänge ausgeführt werden.
**Parameter**
+ `fullDocument`: Gibt an, ob bei Aktualisierungsvorgängen das vollständige Dokument zurückgegeben werden soll. Die Optionen lauten `default` oder `updateLookup`.
+ `resumeAfter`: Optional. Setzen Sie das Token fort, um ab einem bestimmten Punkt im Change-Stream fortzufahren.
+ `startAtOperationTime`: Optional. Zeitstempel, ab dem der Change-Stream gestartet werden soll.
+ `allChangesForCluster`: Optional. Boolescher Wert: Wann`true`, überwacht alle Änderungen im gesamten Cluster (für die Admin-Datenbank). Wenn `false` (Standard), wird nur die angegebene Sammlung überwacht.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie die `$changeStream` Bühne verwendet wird, um Änderungen an einer Sammlung zu überwachen.
**Beispiel für eine Abfrage**
```
// 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()));
}
```
**Ausgabe**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung der `$changeStream` Aggregationsphase anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$cmp` Operator in Amazon DocumentDB wird verwendet, um zwei Werte zu vergleichen und einen Ganzzahlwert zurückzugeben, der ihre relative Reihenfolge angibt. Es ist ein Vergleichsoperator, der zwei Ausdrücke vergleicht und einen Ganzzahlwert von -1, 0 oder 1 zurückgibt, je nachdem, ob der erste Wert kleiner, gleich oder größer als der zweite Wert ist.
**Parameter**
+ `expression1`: Der erste Ausdruck, der verglichen werden soll.
+ `expression2`: Der zweite zu vergleichende Ausdruck.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt die Verwendung des `$cmp` Operators, um zwei numerische Werte zu vergleichen.
**Erstellen Sie Beispieldokumente**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**Beispiel für eine Abfrage**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**Ausgabe**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
In diesem Beispiel vergleicht der `$cmp` Operator die `value2` Felder `value1` und für jedes Dokument. Das Ergebnis ist:
```
- `$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).
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$cmp` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ Node.js ]
Hier ist ein Beispiel für die Verwendung des `$cmp` Operators in einer Node.js -Anwendung mit dem `mongodb` Treiber:
```
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 ]
Hier ist ein Beispiel für die Verwendung des `$cmp` Operators in einer Python-Anwendung mit dem `pymongo` Treiber:
```
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()
```
Die Ausgabe der Beispiele Node.js und Python entspricht der des MongoDB-Shell-Beispiels:
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
Neu ab Version 4.0
Die `$collStats` Aggregationsphase in Amazon DocumentDB bietet Statistiken über die angegebene Sammlung, ähnlich dem `db.collection.stats()` Befehl in der MongoDB-Shell. In dieser Phase können Informationen über die Sammlung abgerufen werden, z. B. die Anzahl der Dokumente, die Gesamtgröße der Sammlung und verschiedene Leistungskennzahlen.
**Parameter**
+ `latencyStats`: (optional) Ein Dokument, das die Optionen für die Erfassung von Latenzstatistiken spezifiziert. Dieser Parameter wird in Amazon DocumentDB nicht unterstützt.
+ `recordStats`: (optional) Ein Dokument, das die Optionen für die Erfassung von Datensatzstatistiken festlegt. Dieser Parameter wird in Amazon DocumentDB nicht unterstützt.
+ `queryExecStats`: (optional) Ein Dokument, das die Optionen für die Erfassung von Statistiken zur Abfrageausführung spezifiziert. Dieser Parameter wird in Amazon DocumentDB nicht unterstützt.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie die `$collStats` Aggregationsphase verwendet wird, um Statistiken über eine `test` in der `db` Datenbank benannte Sammlung abzurufen.
**Erstellen Sie Beispieldokumente**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**Beispiel für eine Abfrage**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**Ausgabe**
```
{
"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)
}
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$collStats` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ Node.js ]
Hier ist ein Beispiel für die Verwendung der `$collStats` Aggregationsphase in einer Node.js -Anwendung mit dem offiziellen MongoDB Node.js -Treiber:
```
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 ]
Hier ist ein Beispiel für die Verwendung der `$collStats` Aggregationsphase in einer Python-Anwendung mithilfe des PyMongo Treibers:
```
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
Der `$concat` Aggregationsoperator in Amazon DocumentDB verkettet (oder kombiniert) mehrere Zeichenketten in einem Dokument, um eine einzige Zeichenfolge zu erzeugen, die an die Anwendung zurückgegeben werden kann. Dies reduziert den Arbeitsaufwand in der Anwendung, da die Bearbeitung der Zeichenfolge auf Datenbankebene erfolgt.
**Parameter**
+ `expression1`: Die erste Zeichenfolge, die verkettet werden soll.
+ `expression2`: Die zweite Zeichenfolge, die verkettet werden soll.
+ `...`: Zusätzliche Zeichenketten zum Verketten (optional).
## Beispiel (MongoDB Shell)
In diesem Beispiel verketten wir die Vor- und Nachnamen der Benutzer, um den vollständigen Namen jeder Person zu erhalten.
**Erstellen Sie Beispieldokumente**
```
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"}
])
```
**Beispiel für eine Abfrage**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**Ausgabe**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$concat` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$concatArrays` Aggregationsoperator in Amazon DocumentDB wird verwendet, um zwei oder mehr Arrays zu einem einzigen Array zu verketten. Dies kann nützlich sein, wenn Sie mehrere Datenarrays zur weiteren Verarbeitung oder Analyse zu einem einzigen Array kombinieren müssen.
**Parameter**
+ `array1`: Das erste Array, das verkettet werden soll.
+ `array2`: Das zweite Array, das verkettet werden soll.
+ `[array3, ...]`: (optional) Zusätzliche Arrays, die verkettet werden sollen.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$concatArrays` Operator verwendet wird, um zwei Arrays zu einem einzigen Array zu kombinieren.
**Erstellen Sie Beispieldokumente**
```
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"]
}
]);
```
**Beispiel für eine Abfrage**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**Ausgabe**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$concatArrays` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$cond` Operator in Amazon DocumentDB wird verwendet, um einen bedingten Ausdruck auszuwerten und einen von zwei möglichen Ergebnisausdrücken zurückzugeben.
**Parameter**
+ `if`: Der boolesche Ausdruck, der ausgewertet werden soll.
+ `then`: Der Ausdruck, der zurückgegeben werden soll, wenn der `if` Ausdruck wahr ist.
+ `else`: Der Ausdruck, der zurückgegeben werden soll, wenn der `if` Ausdruck falsch ist.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$cond` Operator verwendet wird, um einen Wert zurückzugeben, der auf dem Alter einer Person basiert.
**Erstellen Sie Beispieldokumente**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**Beispiel für eine Abfrage**
```
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"
}
}
}
}
}
}
])
```
**Ausgabe**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$cond` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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()
```
------
# \$1 konvertieren
Neu ab Version 4.0
Der `$convert` Operator in Amazon DocumentDB wird verwendet, um einen Wert von einem Datentyp in einen anderen zu konvertieren. Dieser Operator ist nützlich, wenn Sie Operationen mit Daten verschiedener Typen ausführen müssen, z. B. die Konvertierung einer Zeichenfolge in eine Zahl oder eines Datums in einen Zeitstempel.
**Parameter**
+ `to`: Der Zieldatentyp, in den der Wert konvertiert werden soll. Unterstützte Werte sind `"string"`, `"double"`, `"long"`, `"int"`, `"date"` und `"boolean"`.
+ `from`: Der aktuelle Datentyp des Werts. Falls nicht angegeben, versucht Amazon DocumentDB, den Datentyp automatisch zu erkennen.
+ `onError`: (optional) Der Wert, der zurückgegeben werden soll, wenn die Konvertierung fehlschlägt. Kann ein bestimmter Wert oder einer der folgenden Sonderwerte sein:`"null"`,`"zerofill"`, oder`"error"`.
+ `onNull`: (optional) Der Wert, der zurückgegeben werden soll, wenn der Eingabewert`null`. Kann ein bestimmter Wert oder einer der folgenden Sonderwerte sein:`"null"`,`"zerofill"`, oder`"error"`.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt die Konvertierung eines Zeichenkettenwerts in ein Datum mithilfe des `$convert` Operators.
**Erstellen Sie Beispieldokumente**
```
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" }
]);
```
**Beispiel für eine Abfrage**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**Ausgabe**
```
[
{ "_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 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$convert` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Die `$count` Aggregationsphase in Amazon DocumentDB wird verwendet, um die Anzahl der Dokumente zu zählen, die in die Phase gelangen. Sie wird häufig als letzte Phase in einer Aggregationspipeline verwendet, um die Gesamtzahl der Dokumente zurückzugeben, die den vorherigen Phasen entsprechen.
**Parameter**
+ `field`: Das zu zählende Feld. Dieser Parameter ist optional. Wenn er nicht angegeben wird, zählt die Phase die Gesamtzahl der Eingabedokumente.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$count` Schritt verwendet wird, um die Gesamtzahl der Dokumente in einer Sammlung abzurufen.
**Erstellen Sie Beispieldokumente**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**Beispiel für eine Abfrage**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**Ausgabe**
```
{ "total" : 4 }
```
Das Beispiel aggregiert die `users` Sammlung und verwendet die `$count` Phase, um die Gesamtzahl der Dokumente zu zählen.
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$count` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Die `$currentOp` Aggregationsphase gibt Informationen über aktuell ausgeführte Operationen in der Datenbank zurück. Diese Phase ist nützlich für die Überwachung aktiver Abfragen und Operationen in einer Aggregationspipeline.
**Parameter**
+ `allUsers`(optional): Wenn auf gesetzt`true`, werden Operationen für alle Benutzer zurückgegeben. Der Standardwert ist `false`.
+ `idleConnections`(optional): Wenn auf gesetzt`true`, schließt dies inaktive Verbindungen ein. Der Standardwert ist `false`.
+ `idleCursors`(optional): Wenn auf gesetzt`true`, enthält dies Informationen über Cursor im Leerlauf. Der Standardwert ist `false`.
+ `idleSessions`(optional): Wenn auf gesetzt`true`, enthält es Informationen über inaktive Sitzungen. Der Standardwert ist `true`.
+ `localOps`(optional): Wenn auf gesetzt`true`, schließt dies lokale Operationen ein. Der Standardwert ist `false`.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie die `$currentOp` Aggregationsphase verwendet wird, um Informationen über aktive Lesevorgänge abzurufen.
**Beispiel für eine Abfrage**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**Ausgabe**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$currentOp` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('admin');
const result = await db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['admin']
result = list(db.aggregate([
{ '$currentOp': { 'allUsers': True, 'idleConnections': False } },
{ '$match': { 'op': 'query' } }
]))
print(result)
client.close()
example()
```
------
# \$1DateAdd
Neu ab Version 5.0
Mit dem `$dateAdd` Aggregationsoperator in Amazon DocumentDB können Sie einem Datums- und Uhrzeitwert eine Dauer hinzufügen.
**Parameter**
+ `date`: Ein Datums- und Uhrzeitwert, dem eine Dauer hinzugefügt werden soll.
+ `duration`: Die Dauer, die dem `date` Wert hinzugefügt werden soll. Dies kann als Objekt mit Schlüsseln für`years`,,`months`, `weeks` `days` `hours``minutes`, und angegeben `seconds` werden.
+ `timezone`: (optional) Die Zeitzone, die beim Hinzufügen des Datums verwendet werden soll. Falls nicht angegeben, wird die Standardzeitzone des Amazon DocumentDB-Clusters verwendet.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$dateAdd` Operator verwendet wird, um einem Datum 2 Tage und 12 Stunden hinzuzufügen.
**Erstellen Sie Beispieldokumente**
```
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") }
]);
```
**Beispiel für eine Abfrage**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**Ausgabe**
```
[
{
"_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)"
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dateAdd` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 5.0
Wird von Elastic Cluster nicht unterstützt.
Der `$dateDiff` Aggregationsoperator berechnet die Differenz zwischen zwei Daten in angegebenen Einheiten. Er gibt die Anzahl der Einheitengrenzen zurück, die zwischen dem Start- und dem Enddatum überschritten wurden.
**Parameter**
+ `startDate`: Der Ausdruck für das Anfangsdatum.
+ `endDate`: Der Ausdruck für das Enddatum.
+ `unit`: Die Zeiteinheit für die Differenz. Unterstützte Einheiten sind `year``quarter`,`month`,`week`,`day`,`hour`,`minute`,`second`, und`millisecond`.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$dateDiff` Operator verwendet wird, um die Anzahl der Tage zwischen Auftragserteilung und Lieferung zu berechnen.
**Erstellen Sie Beispieldokumente**
```
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")
}
]);
```
**Beispiel für eine Abfrage**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**Ausgabe**
```
[
{
_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
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dateDiff` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$dateFromString` Aggregationsoperator in Amazon DocumentDB ermöglicht es Ihnen, eine Datums- und Uhrzeitzeichenfolge in ein Datumsobjekt zu konvertieren. Dies ist nützlich, wenn Ihre Daten als Zeichenketten gespeichert sind, Sie aber datumsbasierte Operationen mit den Daten durchführen müssen.
**Parameter**
+ `dateString`: Eine Zeichenfolge, die ein Datum und eine Uhrzeit darstellt.
+ `format`: (optional) Eine Zeichenfolge, die das Format von angibt`dateString`. Falls nicht angegeben, versucht Amazon DocumentDB, die Zeichenfolge im ISO-8601-Format zu analysieren.
+ `timezone`: (optional) Eine Zeichenfolge, die die Zeitzone angibt. Falls nicht angegeben, verwendet Amazon DocumentDB die Zeitzone des Servers.
+ `onError`: (optional) Gibt die Aktion an, die ausgeführt werden soll, wenn die Konvertierung fehlschlägt. Mögliche Werte sind `'error'` (der Standardwert, der einen Fehler auslöst), `'null'` (Rückgabe`null`) oder `'replace'` (ersetzt den Wert durch die in der `onErrorMessage` Option angegebene Ersatzzeichenfolge).
+ `onErrorMessage`: (optional) Wenn auf gesetzt `onError` ist`'replace'`, gibt diese Option die Ersatzzeichenfolge an.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie Sie `$dateFromString` eine Datumszeichenfolge in Amazon DocumentDB in ein Datumsobjekt konvertieren können.
**Erstellen Sie Beispieldokumente**
```
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"}
]);
```
**Beispiel für eine Abfrage**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**Ausgabe**
```
[
{
"_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")
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dateFromString` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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()
```
------
# \$1DateSubtrahieren
Neu ab Version 5.0
Mit dem `$dateSubtract` Aggregationsoperator in Amazon DocumentDB können Sie eine angegebene Dauer von einem Datumswert subtrahieren.
**Parameter**
+ `date`: Ein Datumsausdruck, der in ein Datum oder einen Zeitstempel aufgelöst wird.
+ `subtrahend`: Ein Ausdruck für die Dauer, der angibt, wie viel Zeit vom Ausdruck abgezogen werden soll. `date`
+ `unit`: Eine Zeichenfolge, die die Zeiteinheit für den `subtrahend` Ausdruck angibt. Unterstützte Einheiten sind „Jahr“, „Quartal“, „Monat“, „Woche“, „Tag“, „Stunde“, „Minute“, „Sekunde“ und „Millisekunde“.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$dateSubtract` Operator verwendet wird, um das Datum vor einem Jahr anhand des aktuellen Datums zu berechnen.
**Erstellen Sie Beispieldokumente**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**Beispiel für eine Abfrage**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**Ausgabe**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dateSubtract` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$dateToString` Aggregationsoperator in Amazon DocumentDB wird verwendet, um einen Datums- oder Zeitstempelwert in eine Zeichenkettendarstellung zu konvertieren. Dies ist nützlich, wenn Sie Datum und Uhrzeit für die Anzeige oder Weiterverarbeitung auf eine bestimmte Weise formatieren müssen.
**Parameter**
+ `date`: Der Datums- oder Zeitstempelwert, der in eine Zeichenfolge konvertiert werden soll.
+ `format`: Eine Zeichenfolge, die das Format angibt, in dem das Datum dargestellt werden soll. Die Formatzeichenfolge kann verschiedene Formatbezeichner enthalten, z. B. `%Y` für das vierstellige Jahr, `%m` für den zweistelligen Monat, `%d` für den zweistelligen Tag des Monats usw.
+ `timezone`: (optional) Die Zeitzone, die für die Konvertierung verwendet werden soll. Falls nicht angegeben, wird die Zeitzone des Servers verwendet, der den Amazon DocumentDB-Cluster hostet.
+ `onNull`: (optional) Der Wert, der zurückgegeben werden soll, wenn der `date` Parameter. `null`
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt die Verwendung des `$dateToString` Operators zur Formatierung des `logDate` Felds der `missionLog` Sammlung.
**Erstellen Sie Beispieldokumente**
```
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") }
]);
```
**Beispiel für eine Abfrage**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**Ausgabe**
```
[
{
"_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"
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dateToString` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ Node.js ]
Hier ist ein Beispiel für die Verwendung des `$dateToString` Operators in einer Node.js -Anwendung:
```
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 ]
Hier ist ein Beispiel für die Verwendung des `$dateToString` Operators in einer Python-Anwendung:
```
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
Neu ab Version 8.0
Wird von Elastic Cluster nicht unterstützt.
Der `$dateTrunc` Aggregationsoperator in Amazon DocumentDB kürzt ein Datum auf eine angegebene Einheit.
**Parameter**
+ `date`: Ein Datumsausdruck, der in ein Datum oder einen Zeitstempel aufgelöst wird.
+ `unit`: Eine Zeichenfolge, die die Zeiteinheit für den Subtrahend-Ausdruck angibt. Unterstützte Einheiten sind`year`,`quarter`,`month`,`week`,, `day` `hour``minute`, `second` und. `millisecond`
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$dateTrunc` Operator verwendet wird, um ein Datum auf die Stunde zu kürzen.
**Erstellen Sie Beispieldokumente**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**Beispiel für eine Abfrage**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**Ausgabe**
```
[
{
_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')
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dateTrunc` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$dayOfMonth` Aggregationsoperator in Amazon DocumentDB ruft den Tag des Monats (von 1 bis 31) für ein bestimmtes Datum ab. Dieser Operator ist nützlich, um den Tag des Monats aus Datumsfeldern in Ihren Dokumenten zu gruppieren, zu filtern oder zu extrahieren.
**Parameter**
+ `date expression`: Der Datumsausdruck kann ein Datumsfeld aus dem Dokument, ein Datumsobjekt oder eine Datumszeichenfolge sein.
## Beispiel (MongoDB Shell)
Dieses Beispiel zeigt, wie der `$dayOfMonth` Operator verwendet wird, um den Tag des Monats aus einem Datumsfeld im Dokument zu extrahieren.
**Erstellen Sie Beispieldokumente**
```
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") }
]);
```
**Beispiel für eine Abfrage**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**Ausgabe**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dayOfMonth` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$dayOfWeek` Operator in Amazon DocumentDB extrahiert den Wochentag aus einem bestimmten Datumsfeld. Es gibt den Wochentag als Zahl zwischen 1 (Sonntag) und 7 (Samstag) zurück, was dem Verhalten in MongoDB entspricht.
**Parameter**
+ `date field`: Das Datumsfeld, aus dem der Wochentag extrahiert werden soll.
## Beispiel (MongoDB Shell)
Dieses Beispiel zeigt, wie der `$dayOfWeek` Operator verwendet wird, um den Wochentag aus dem `date` Feld in der `weather` Sammlung zu extrahieren.
**Erstellen Sie Beispieldokumente**
```
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")
}
]);
```
**Beispiel für eine Abfrage**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**Ausgabe**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dayOfWeek` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$dayOfYear` Operator in Amazon DocumentDB gibt den Tag des Jahres für ein Datum als Zahl zwischen 1 und 366 zurück (365 in Nicht-Schaltjahren).
**Parameter**
+ `expression`: Das Datumsfeld oder der Ausdruck, aus dem der Tag des Jahres extrahiert werden soll.
## Beispiel (MongoDB Shell)
Dieses Beispiel zeigt, wie der `$dayOfYear` Operator verwendet wird, um den Tag des Jahres aus einem Datumsfeld in einer Amazon DocumentDB-Sammlung zu extrahieren.
**Erstellen Sie Beispieldokumente**
```
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")
}
])
```
**Beispiel für eine Abfrage**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**Ausgabe**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$dayOfYear` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$divide` Operator in der Amazon DocumentDB-Aggregationspipeline wird verwendet, um eine Zahl durch eine andere zu dividieren. Es ist ein nützlicher Operator für die Ausführung mathematischer Operationen an numerischen Feldern in Ihren Dokumenten.
**Parameter**
+ `numerator`: Die Dividende oder die Zahl, die geteilt werden soll.
+ `denominator`: Der Divisor oder die Zahl, durch die dividiert werden soll.
## Beispiel (MongoDB Shell)
Dieses Beispiel zeigt, wie der `$divide` Operator verwendet wird, um den Stundensatz für Mitarbeiter auf der Grundlage ihres Jahresgehalts und der Anzahl der Arbeitsstunden pro Jahr zu berechnen.
**Erstellen Sie Beispieldokumente**
```
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 }
]);
```
**Beispiel für eine Abfrage**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**Ausgabe**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$divide` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$eq` Aggregationsoperator vergleicht zwei Werte und gibt zurück, `true` wenn sie gleich sind, andernfalls gibt er zurück`false`.
**Parameter**
+ `expression1`: Der erste zu vergleichende Wert.
+ `expression2`: Der zweite zu vergleichende Wert.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$eq` Operator verwendet wird, um zu überprüfen, ob die Produktmengen den Zielwerten entsprechen.
**Erstellen Sie Beispieldokumente**
```
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 }
]);
```
**Beispiel für eine Abfrage**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**Ausgabe**
```
[
{ _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 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$eq` Aggregationsoperators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 4.0
Mit dem `$exp` Operator in Amazon DocumentDB können Sie die Konstante e auf eine bestimmte Zahl erhöhen.
**Parameter**
+ `expression`: Der auszuwertende Ausdruck. Dies kann ein beliebiger gültiger Aggregationsausdruck sein, einschließlich Feldverweise, arithmetischer Operationen und anderer Aggregationsstufen.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$exp` Operator verwendet wird, um alle Dokumente zu finden, bei denen das `quantity` Feld größer als das `price` Feld ist.
**Erstellen Sie Beispieldokumente**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**Beispiel für eine Abfrage**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**Ausgabe**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$exp` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$filter` Operator in Amazon DocumentDB wird verwendet, um einen Filterausdruck auf jedes Element eines Arrays anzuwenden und ein Array zurückzugeben, das nur die Elemente enthält, die der angegebenen Bedingung entsprechen. Dieser Operator ist nützlich, wenn Sie komplexe Filteroperationen für Array-Felder in Ihren Dokumenten durchführen müssen.
**Parameter**
+ `input`: Das zu filternde Array-Feld.
+ `as`: Der Variablenname, der für jedes Element des `input` Arrays innerhalb des `cond` Ausdrucks verwendet werden soll.
+ `cond`: Der boolesche Ausdruck, der bestimmt, ob ein bestimmtes Element in das Ausgabearray aufgenommen werden soll.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$filter` Operator verwendet wird, um den Kunden jeder Bestellung zu projizieren und ein neues Array-Feld PaidItems zu erstellen, das nur die Artikel aus dem Artikelarray enthält, bei denen der Preis höher als 15 ist. Im Wesentlichen werden die Artikel jeder Bestellung so gefiltert, dass sie nur Produkte enthalten, die mehr als 15€ kosten.
**Erstellen Sie Beispieldokumente**
```
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 }
]}
]);
```
**Beispiel für eine Abfrage**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**Ausgabe**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$filter` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 5.0.
Wird von Elastic Cluster nicht unterstützt.
Der `$first` Operator in Amazon DocumentDB gibt das erste Dokument aus einem gruppierten Satz von Dokumenten zurück. Er wird häufig in Aggregationspipelines verwendet, um das erste Dokument abzurufen, das einer bestimmten Bedingung entspricht.
**Parameter**
+ `expression`: Der Ausdruck, der als erster Wert in jeder Gruppe zurückgegeben werden soll.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$first` Operator verwendet wird, um den ersten Elementwert abzurufen, der während der Aggregation für jede Kategorie gefunden wurde.
Hinweis: `$first` Gibt das erste Dokument auf der Grundlage der aktuellen Reihenfolge der Dokumente in der Pipeline zurück. Um eine bestimmte Reihenfolge sicherzustellen (z. B. nach Datum, Preis usw.), sollte vor der `$sort` Phase eine `$group` Stufe verwendet werden.
**Erstellen Sie Musterdokumente**
```
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" }
]);
```
**Beispiel für eine Abfrage**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**Ausgabe**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$first` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Neu ab Version 4.0.
Der `$floor` Operator in Amazon DocumentDB gibt die größte Ganzzahl zurück, die kleiner oder gleich der angegebenen Zahl ist. Dieser Operator ist nützlich, um numerische Werte abzurunden.
**Parameter**
+ `expression`: Der numerische Ausdruck, der abgerundet werden soll.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$floor` Operator verwendet wird, um einen Dezimalwert auf die nächste Ganzzahl abzurunden.
**Erstellen Sie Beispieldokumente**
```
db.numbers.insertOne({ value: 3.14 });
```
**Beispiel für eine Abfrage**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**Ausgabe**
```
{ "floored" : 3 }
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$floor` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
In der `$geoNear` Aggregationsphase werden Dokumente in der Reihenfolge ihrer Nähe zu einem bestimmten Punkt zurückgegeben. Sie berechnet die Entfernung vom Punkt und bezieht die Entfernung in die Ausgabedokumente ein.
**Parameter**
+ `near`: Der Punkt, von dem aus Entfernungen berechnet werden sollen, angegeben als GeoJSON- oder Legacy-Koordinaten.
+ `distanceField`: Der Feldname zum Speichern der berechneten Entfernung.
+ `spherical`: Boolescher Wert, der angibt, ob sphärische Geometrie verwendet werden soll (erforderlich für GeoJSON-Punkte).
+ `maxDistance`: Optional. Maximaler Abstand vom Mittelpunkt.
+ `minDistance`: Optional. Minimaler Abstand vom Mittelpunkt.
+ `query`: Optional. Zusätzliche anzuwendende Filterkriterien.
+ `limit`: Optional. Maximale Anzahl zurückzugebender Dokumente.
+ `key`: Optional. Feld, das für Geodatenabfragen verwendet werden soll, wenn mehrere Geoindizes vorhanden sind.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie die `$geoNear` Bühne verwendet wird, um Geschäfte zu finden, die einem bestimmten Standort am nächsten sind.
**Erstellen Sie Beispieldokumente**
```
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] } }
]);
```
**Beispiel für eine Abfrage**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**Ausgabe**
```
[
{ _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 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung der `$geoNear` Aggregationsphase anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Die `$group` Aggregationsphase in Amazon DocumentDB ermöglicht es Ihnen, Dokumente nach einem bestimmten Ausdruck zu gruppieren und verschiedene kumulative Operationen mit den gruppierten Daten durchzuführen. Dies kann für Aufgaben wie die Berechnung von Gesamtwerten, Durchschnittswerten oder anderen Statistiken auf der Grundlage der gruppierten Daten nützlich sein.
**Parameter**
+ `_id`: Gibt den Ausdruck an, nach dem die Eingabedokumente gruppiert werden sollen. Dies kann ein Feldname, ein berechneter Ausdruck oder eine Kombination aus beidem sein.
+ `accumulator expressions`: (optional) Ein oder mehrere Akkumulatorausdrücke, die auf die gruppierten Daten angewendet werden sollen. Diese Ausdrücke verwenden die oben genannten Akkumulatoroperatoren.
## Beispiel (MongoDB Shell)
Im folgenden Beispiel werden Kunden nach ihrer Stadt gruppiert und der Gesamtbestellbetrag für jede Stadt berechnet.
**Erstellen Sie Beispieldokumente**
```
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 }] }
]);
```
**Beispiel für eine Abfrage**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**Ausgabe**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$group` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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
Der `$gt` Aggregationsoperator vergleicht zwei Werte und gibt zurück, `true` wenn der erste Wert größer als der zweite ist, andernfalls kehrt `false` er zurück.
**Parameter**
+ `expression1`: Der erste zu vergleichende Wert.
+ `expression2`: Der zweite zu vergleichende Wert.
## Beispiel (MongoDB Shell)
Das folgende Beispiel zeigt, wie der `$gt` Operator verwendet wird, um Produkte zu identifizieren, die einen Preisschwellenwert überschreiten.
**Erstellen Sie Beispieldokumente**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**Beispiel für eine Abfrage**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**Ausgabe**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## Codebeispiele
Um ein Codebeispiel für die Verwendung des `$gt` Aggregationsoperators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:
------
#### [ 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://