翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Amazon DocumentDB でサポートされている MongoDB API、オペレーション、およびデータ型
Amazon DocumentDB (MongoDB 互換) は、MongoDB ワークロードをサポートする、高速、スケーラブル、高可用性、完全管理のドキュメントデータベース・サービスです。Amazon DocumentDB は、MongoDB 3.6、4.0、5.0、および 8.0 APIs。このセクションでは、サポートされている機能を一覧表示します。MongoDB API とドライバの使用のサポートについては、MongoDB コミュニティフォーラムを参照してください。Amazon DocumentDB サービスの使用に関するサポートについては、適切な AWS サポートチームにお問い合わせください。Amazon DocumentDB と MongoDB の機能的な違いについては、[機能の違い: Amazon DocumentDB と MongoDB](functional-differences.md) を参照してください。
内部専用であるか、フルマネージドサービスには適用されない、MongoDB コマンドと演算子は、サポートされておらず、サポートされている機能のリストにも含まれていません。
初めてのリリース以来 50 を超える新しい機能を追加しており、今後もお客様が必要とする機能を遡って提供していきます。最新のローンチに関する情報は、「[Amazon DocumentDB に関する発表](https://aws.amazon.com/documentdb/resources/)」を参照してください。
サポート対象外の機能をリクエストしたい場合は、アカウント ID、リクエストする機能、およびユースケースを記載した E メールを [Amazon DocumentDB サービスチーム](mailto:documentdb-feature-request@amazon.com) まで送信してお知らせください。
+ [データベースコマンド](#mongo-apis-database)
+ [クエリおよびプロジェクション演算子](#mongo-apis-query)
+ [更新演算子](#mongo-apis-update)
+ [地理空間](#mongo-apis-geospatial)
+ [カーソルメソッド](#mongo-apis-cursor)
+ [集約パイプライン演算子](#mongo-apis-aggregation-pipeline)
+ [データ型](#mongo-apis-data-types)
+ [インデックス](#mongo-apis-indexes)
## データベースコマンド
**Topics**
+ [管理コマンド](#mongo-apis-dababase-administrative)
+ [集計](#mongo-apis-dababase-aggregation)
+ [認証](#mongo-apis-dababase-authentication)
+ [診断コマンド](#mongo-apis-dababase-diagnostics)
+ [クエリ操作と書き込み操作](#mongo-apis-dababase-query-write)
+ [ロール管理コマンド](#mongo-apis-database-role-management)
+ [セッションコマンド](#mongo-apis-dababase-sessions)
+ [ユーザー管理](#mongo-apis-dababase-user-management)
+ [シャーディングコマンド](#mongo-apis-dababase-sharding)
### 管理コマンド
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| 上限付きコレクション | いいえ | なし | なし | なし | いいえ |
| cloneCollectionAsCapped | いいえ | なし | なし | なし | いいえ |
| collMod | 部分的 | 部分的 | 部分的 | 部分的 | 部分的 |
| collMod: expireAfterSeconds | はい | はい | はい | はい | はい |
| convertToCapped | いいえ | なし | なし | なし | いいえ |
| copydb | いいえ | なし | なし | なし | いいえ |
| 作成 | はい | はい | はい | はい | はい |
| createView | いいえ | なし | なし | あり | なし |
| createIndexes | はい | はい | はい | はい | はい |
| currentOp | はい | はい | はい | はい | はい |
| drop | はい | はい | はい | はい | はい |
| dropDatabase | はい | はい | はい | はい | はい |
| dropIndexes | はい | はい | はい | はい | はい |
| filemd5 | いいえ | なし | なし | なし | いいえ |
| getAuditConfig | いいえ | はい | はい | あり | なし |
| killCursors | はい | はい | はい | はい | はい |
| killOp | はい | はい | はい | はい | はい |
| listCollections\$1 | はい | はい | はい | はい | はい |
| listDatabases | はい | はい | はい | はい | はい |
| listIndexes | はい | はい | はい | はい | はい |
| reIndex | いいえ | なし | はい | あり | なし |
| renameCollection | はい | はい | はい | あり | なし |
| setAuditConfig | いいえ | はい | はい | あり | なし |
\$1 コンソールでは、`type` キーはサポートされていません。
### 集計
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| aggregate | はい | はい | はい | はい | はい |
| count | はい | はい | はい | はい | はい |
| distinct | はい | はい | はい | はい | はい |
| mapReduce | いいえ | なし | なし | あり | なし |
### 認証
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| 認証 | はい | はい | はい | はい | はい |
| ログアウト | はい | はい | はい | はい | はい |
### 診断コマンド
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| buildInfo | はい | はい | はい | はい | はい |
| collStats | はい | はい | はい | はい | はい |
| connPoolStats | いいえ | なし | なし | なし | いいえ |
| connectionStatus | はい | はい | はい | はい | はい |
| dataSize | はい | はい | はい | はい | はい |
| dbHash | いいえ | なし | なし | なし | いいえ |
| dbStats | はい | はい | はい | はい | はい |
| explain | はい | はい | はい | はい | はい |
| 説明: executionStats | はい | はい | はい | はい | はい |
| の機能 | いいえ | なし | なし | なし | いいえ |
| hostInfo | はい | はい | はい | はい | はい |
| listCommands | はい | はい | はい | はい | はい |
| プロファイラー | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/profiling.html) | なし |
| serverStatus | はい | はい | はい | はい | はい |
| top | はい | はい | はい | はい | はい |
### クエリ操作と書き込み操作
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| Change streams | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | [あり](https://docs.aws.amazon.com//documentdb/latest/developerguide/change_streams.html) | なし |
| 削除 | はい | はい | はい | はい | はい |
| find | はい | はい | はい | はい | はい |
| findAndModify | はい | はい | はい | はい | はい |
| getLastError | いいえ | なし | なし | なし | いいえ |
| getMore | はい | はい | はい | はい | はい |
| getPrevError | いいえ | なし | なし | なし | いいえ |
| GridFS | はい | はい | はい | あり | なし |
| insert | はい | はい | はい | はい | はい |
| parallelCollectionScan | いいえ | なし | なし | なし | いいえ |
| resetError | いいえ | なし | なし | なし | いいえ |
| 更新 | はい | はい | はい | はい | はい |
| ReplaceOne | はい | はい | はい | はい | はい |
### ロール管理コマンド
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| createRole | はい | はい | はい | あり | なし |
| dropAllRolesFromDatabase | はい | はい | はい | あり | なし |
| dropRole | はい | はい | はい | あり | なし |
| grantRolesToRole | はい | はい | はい | あり | なし |
| revokeRolesFromRole | はい | はい | はい | あり | なし |
| revokePrivilegesFromRole | はい | はい | はい | あり | なし |
| rolesInfo | はい | はい | はい | あり | なし |
| updateRole | はい | はい | はい | あり | なし |
### セッションコマンド
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| abortTransaction | いいえ | はい | はい | あり | なし |
| commitTransaction | いいえ | はい | はい | あり | なし |
| endSessions | いいえ | なし | なし | なし | いいえ |
| killAllSessions | いいえ | はい | はい | あり | なし |
| killAllSessionsByPattern | いいえ | なし | なし | なし | いいえ |
| killSessions | いいえ | はい | はい | あり | なし |
| refreshSessions | いいえ | なし | なし | なし | いいえ |
| startSession | いいえ | はい | はい | あり | なし |
### ユーザー管理
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| createUser | はい | はい | はい | はい | はい |
| dropAllUsersFromDatabase | はい | はい | はい | はい | はい |
| dropUser | はい | はい | はい | はい | はい |
| grantRolesToUser | はい | はい | はい | はい | はい |
| revokeRolesFromUser | はい | はい | はい | はい | はい |
| updateUser | はい | はい | はい | はい | はい |
| usersInfo | はい | はい | はい | はい | はい |
### シャーディングコマンド
| コマンド | Elastic クラスター |
| --- | --- |
| abortReshardCollection | いいえ |
| addShard | いいえ |
| addShardToZone | いいえ |
| balancerCollectionStatus | いいえ |
| balancerStart | いいえ |
| balancerStatus | いいえ |
| balancerStop | いいえ |
| checkShardingIndex | いいえ |
| clearJumboFlag | いいえ |
| cleanupOrphaned | いいえ |
| cleanupReshardCollection | いいえ |
| commitReshardCollection | いいえ |
| enableSharding | はい |
| flushRouterConfig | いいえ |
| getShardMap | いいえ |
| getShardVersion | いいえ |
| isdbgrid | いいえ |
| ListShards | いいえ |
| medianKey | いいえ |
| moveChunk | いいえ |
| movePrimary | いいえ |
| mergeChunks | いいえ |
| refineCollectionShardKey | いいえ |
| removeShard | いいえ |
| removeShardFromZone | いいえ |
| reshardCollection | いいえ |
| setAllowMigrations | いいえ |
| setShardVersion | いいえ |
| shardCollection | はい |
| shardingState | いいえ |
| split | いいえ |
| splitVector | いいえ |
| unsetSharding | いいえ |
| updateZoneKeyRange | いいえ |
## クエリおよびプロジェクション演算子
**Topics**
+ [配列演算子](#mongo-apis-query-array-operators)
+ [ビット演算子](#mongo-apis-query-bitwise-operators)
+ [コメント演算子](#mongo-apis-query-comment-operator)
+ [比較演算子](#mongo-apis-query-comparison-operators)
+ [要素演算子](#mongo-apis-query-element-operators)
+ [評価クエリ演算子](#mongo-apis-query-evaluation-operators)
+ [論理演算子](#mongo-apis-query-logical-operators)
+ [プロジェクション演算子](#mongo-apis-projection-operators)
### 配列演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | はい | はい | はい | はい | はい |
| [\$1elemMatch](elemMatch.md) | はい | はい | はい | はい | はい |
| [\$1size](size-query.md) | はい | はい | はい | はい | はい |
### ビット演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | はい | はい | はい | はい | はい |
| [\$1bitsAnySet](bitsAnySet.md) | はい | はい | はい | はい | はい |
| [\$1bitsAllClear](bitsAllClear.md) | はい | はい | はい | はい | はい |
| [\$1bitsAnyClear](bitsAnyClear.md) | はい | はい | はい | はい | はい |
### コメント演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | はい | はい | はい | はい | はい |
### 比較演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1eq](eq.md) | はい | はい | はい | はい | はい |
| [\$1gt](gt.md) | はい | はい | はい | はい | はい |
| [\$1gte](gte.md) | はい | はい | はい | はい | はい |
| [\$1in](in.md) | はい | はい | はい | はい | はい |
| [\$1lt](lt.md) | はい | はい | はい | はい | はい |
| [\$1lte](lte.md) | はい | はい | はい | はい | はい |
| [\$1ne](ne.md) | はい | はい | はい | はい | はい |
| [\$1nin](nin.md) | はい | はい | はい | はい | はい |
### 要素演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | はい | はい | はい | はい | はい |
| [\$1type](type.md) | はい | はい | はい | はい | はい |
### 評価クエリ演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1expr](expr.md) | いいえ | はい | はい | あり | なし |
| [\$1jsonSchema](jsonSchema.md) | なし | はい | はい | あり | なし |
| [\$1mod](mod-query.md) | はい | はい | はい | はい | はい |
| [\$1regex](regex.md) | はい | はい | はい | はい | あり |
| [\$1text](text.md) | なし | なし | はい | あり | なし |
| \$1where | いいえ | なし | なし | なし | いいえ |
### 論理演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | はい | はい | はい | はい | はい |
| [\$1nor](nor.md) | はい | はい | はい | はい | はい |
| [\$1not](not.md) | はい | はい | はい | はい | はい |
| [\$1or](or.md) | はい | はい | はい | はい | はい |
### プロジェクション演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | はい | はい | はい | はい | はい |
| [\$1elemMatch](elemMatch.md) | はい | はい | はい | はい | あり |
| [\$1meta](meta.md) | なし | なし | はい | あり | なし |
| [\$1slice](slice-projection.md) | はい | はい | はい | はい | はい |
## 更新演算子
**Topics**
+ [配列演算子](#mongo-apis-update-array)
+ [ビット演算子](#mongo-apis-update-bitwise)
+ [フィールド演算子](#mongo-apis-update-field)
+ [更新修飾子](#mongo-apis-update-modifiers)
### 配列演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-update.md) | はい | はい | はい | はい | はい |
| [\$1[]](dollarBrackets-update.md) | はい | はい | はい | はい | はい |
| [\$1[]](dollarIdentifier-update.md) | はい | はい | はい | はい | はい |
| [\$1addToSet](addToSet.md) | はい | はい | はい | はい | はい |
| [\$1pop](pop.md) | はい | はい | はい | はい | はい |
| [\$1pullAll](pullAll.md) | はい | はい | はい | はい | はい |
| [\$1pull](pull.md) | はい | はい | はい | はい | はい |
| [\$1push](push.md) | はい | はい | はい | はい | はい |
### ビット演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | はい | はい | はい | はい | はい |
### フィールド演算子
| オペレーター | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1currentDate](currentDate.md) | はい | はい | はい | はい | はい |
| [\$1inc](inc.md) | はい | はい | はい | はい | はい |
| [\$1max](max-update.md) | はい | はい | はい | はい | はい |
| [\$1min](min-update.md) | はい | はい | はい | はい | はい |
| [\$1mul](mul.md) | はい | はい | はい | はい | はい |
| [\$1rename](rename.md) | はい | はい | はい | はい | はい |
| [\$1set](set-update.md) | はい | はい | はい | はい | はい |
| [\$1setOnInsert](setOnInsert.md) | はい | はい | はい | はい | はい |
| [\$1unset](unset-update.md) | はい | はい | はい | はい | はい |
### 更新修飾子
| オペレーター | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | はい | はい | はい | はい | はい |
| [\$1position](position.md) | はい | はい | はい | はい | はい |
| [\$1slice](slice-update.md) | はい | はい | はい | はい | はい |
| [\$1sort](sort-update.md) | はい | はい | はい | はい | はい |
## 地理空間
### ジオメトリ指定子
| クエリセレクター | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| \$1box | いいえ | なし | なし | なし | いいえ |
| \$1center | いいえ | なし | なし | なし | いいえ |
| \$1centerSphere | いいえ | なし | なし | なし | なし |
| [\$1geometry](geometry.md) | はい | はい | はい | はい | はい |
| [\$1maxDistance](maxDistance.md) | はい | はい | はい | はい | はい |
| [\$1minDistance](minDistance.md) | はい | はい | はい | はい | はい |
| [\$1nearSphere](nearSphere.md) | はい | はい | はい | はい | はい |
| \$1polygon | いいえ | なし | なし | なし | いいえ |
| \$1uniqueDocs | いいえ | なし | なし | なし | いいえ |
### クエリセレクター
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | はい | はい | はい | はい | はい |
| [\$1geoWithin](geoWithin.md) | はい | はい | はい | はい | はい |
| [\$1near](near.md) | はい | はい | はい | はい | はい |
| [\$1nearSphere](nearSphere.md) | はい | はい | はい | はい | はい |
| \$1polygon | いいえ | なし | なし | なし | いいえ |
| \$1uniqueDocs | いいえ | なし | なし | なし | いいえ |
## カーソルメソッド
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| cursor.batchSize() | はい | はい | はい | はい | はい |
| cursor.close() | はい | はい | はい | はい | はい |
| cursor.collation() | いいえ | なし | なし | あり | なし |
| cursor.comment() | はい | はい | はい | はい | はい |
| cursor.count() | はい | はい | はい | はい | はい |
| cursor.explain() | はい | はい | はい | あり | なし |
| cursor.forEach() | はい | はい | はい | はい | はい |
| cursor.hasNext() | はい | はい | はい | はい | はい |
| cursor.hint() | はい | はい | はい | はい | はい\$1 |
| cursor.isClosed() | はい | はい | はい | はい | はい |
| cursor.isExhausted() | はい | はい | はい | あり | なし |
| cursor.itcount() | はい | はい | はい | あり | なし |
| cursor.limit() | はい | はい | はい | あり | なし |
| cursor.map() | はい | はい | はい | あり | なし |
| cursor.max() | いいえ | なし | なし | なし | いいえ |
| cursor.maxScan() | はい | はい | はい | あり | なし |
| cursor.maxTimeMS() | はい | はい | はい | あり | なし |
| cursor.min() | いいえ | なし | なし | なし | いいえ |
| cursor.next() | はい | はい | はい | はい | はい |
| cursor.noCursorTimeout() | いいえ | なし | なし | なし | いいえ |
| cursor.objsLeftInBatch() | はい | はい | はい | あり | なし |
| cursor.pretty() | はい | はい | はい | あり | なし |
| cursor.readConcern() | はい | はい | はい | あり | なし |
| cursor.readPref() | はい | はい | はい | あり | なし |
| cursor.returnKey() | いいえ | なし | なし | なし | いいえ |
| cursor.showRecordId() | いいえ | なし | なし | なし | いいえ |
| cursor.size() | はい | はい | はい | あり | なし |
| cursor.skip() | はい | はい | はい | あり | なし |
| cursor.sort() | はい | はい | はい | あり | なし |
| cursor.tailable() | いいえ | なし | なし | なし | いいえ |
| cursor.toArray() | はい | はい | はい | あり | なし |
\$1 インデックス `hint` がインデックス式でサポートされるようになりました。例えば、`db.foo.find().hint({x:1})`。
## 集約パイプライン演算子
**Topics**
+ [アキュムレータ式](#mongo-apis-aggregation-pipeline-accumulator-expressions)
+ [算術演算子](#mongo-apis-aggregation-pipeline-arithmetic)
+ [配列演算子](#mongo-apis-aggregation-pipeline-array)
+ [ブール演算子](#mongo-apis-aggregation-pipeline-boolean)
+ [比較演算子](#mongo-apis-aggregation-pipeline-comparison)
+ [条件式演算子](#mongo-apis-aggregation-pipeline-conditional)
+ [データ型演算子](#mongo-apis-aggregation-pipeline-data-type)
+ [データサイズ演算子](#mongo-apis-aggregation-pipeline-data-size)
+ [日付演算子](#mongo-apis-aggregation-pipeline-date)
+ [リテラル演算子](#mongo-apis-aggregation-pipeline-literal)
+ [マージ演算子](#mongo-apis-aggregation-pipeline-merge)
+ [自然演算子](#mongo-apis-aggregation-pipeline-natural)
+ [セット演算子](#mongo-apis-aggregation-pipeline-set)
+ [ステージ演算子](#mongo-apis-aggregation-pipeline-stage)
+ [文字列演算子](#mongo-apis-aggregation-pipeline-string)
+ [システム変数](#mongo-apis-aggregation-pipeline-system-variables)
+ [テキスト検索演算子](#mongo-apis-aggregation-pipeline-text-search)
+ [型変換演算子](#mongo-apis-aggregation-pipeline-type)
+ [変数演算子](#mongo-apis-aggregation-pipeline-variable)
+ [その他の演算子](#mongo-apis-aggregation-pipeline-misc)
### アキュムレータ式
| 式 | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| \$1accumulator | - | - | いいえ | なし | なし |
| [\$1addToSet](addToSet-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1avg](avg.md) | はい | はい | はい | はい | あり |
| [\$1count](count.md) | - | - | なし | なし | いいえ |
| \$1covariancePop | いいえ | なし | なし | なし | いいえ |
| \$1covarianceSamp | いいえ | なし | なし | なし | いいえ |
| \$1denseRank | いいえ | なし | なし | なし | いいえ |
| \$1derivative | いいえ | なし | なし | なし | いいえ |
| \$1documentNumber | いいえ | なし | なし | なし | いいえ |
| \$1expMovingAvg | いいえ | なし | なし | なし | なし |
| [\$1first](first.md) | はい | はい | はい | はい | はい |
| \$1integral | いいえ | なし | なし | なし | なし |
| [\$1last](last.md) | はい | はい | はい | はい | はい |
| [\$1max](max.md) | はい | はい | はい | はい | はい |
| [\$1min](min.md) | はい | はい | はい | はい | はい |
| [\$1push](push-aggregation.md) | はい | はい | はい | はい | はい |
| \$1rank | いいえ | なし | なし | なし | いいえ |
| \$1shift | いいえ | なし | なし | なし | いいえ |
| \$1stdDevPop | いいえ | なし | なし | なし | いいえ |
| \$1stdDevSamp | いいえ | なし | なし | なし | なし |
| [\$1sum](sum.md) | はい | はい | はい | はい | はい |
### 算術演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1abs](abs.md) | はい | はい | はい | はい | はい |
| [\$1add](add.md) | はい | はい | はい | はい | あり |
| [\$1ceil](ceil.md) | なし | はい | はい | はい | はい |
| [\$1divide](divide.md) | はい | はい | はい | はい | あり |
| [\$1exp](exp.md) | なし | はい | はい | はい | あり |
| [\$1floor](floor.md) | なし | はい | はい | はい | あり |
| [\$1ln](ln.md) | なし | はい | はい | はい | あり |
| [\$1log](log.md) | なし | はい | はい | はい | あり |
| [\$1log10](log10.md) | なし | はい | はい | はい | はい |
| [\$1mod](mod.md) | はい | はい | はい | はい | はい |
| [\$1multiply](multiply.md) | はい | はい | はい | はい | あり |
| [\$1pow](pow.md) | なし | なし | なし | あり | なし |
| \$1round | - | - | いいえ | なし | なし |
| [\$1sqrt](sqrt.md) | なし | はい | はい | はい | はい |
| [\$1subtract](subtract.md) | はい | はい | はい | はい | はい |
| \$1trunc | いいえ | なし | なし | なし | いいえ |
### 配列演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1arrayElemAt](arrayElemAt.md) | はい | はい | はい | はい | はい |
| [\$1arrayToObject](arrayToObject.md) | はい | はい | はい | はい | はい |
| [\$1concatArrays](concatArrays.md) | はい | はい | はい | はい | はい |
| [\$1filter](filter.md) | はい | はい | はい | はい | はい |
| [\$1first](first.md) | - | - | はい | あり | なし |
| [\$1in](in-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1indexOfArray](indexOfArray.md) | はい | はい | はい | はい | はい |
| [\$1isArray](isArray.md) | はい | はい | はい | はい | はい |
| [\$1last](last.md) | - | - | はい | あり | なし |
| [\$1objectToArray](objectToArray.md) | はい | はい | はい | はい | はい |
| [\$1range](range.md) | はい | はい | はい | はい | はい |
| [\$1reverseArray](reverseArray.md) | はい | はい | はい | はい | はい |
| [\$1reduce](reduce.md) | はい | はい | はい | はい | はい |
| [\$1size](size.md) | はい | はい | はい | はい | はい |
| [\$1slice](slice.md) | はい | はい | はい | はい | はい |
| [\$1zip](zip.md) | はい | はい | はい | はい | はい |
### ブール演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1not](not-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1or](or-aggregation.md) | はい | はい | はい | はい | はい |
### 比較演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1cmp](cmp.md) | はい | はい | はい | はい | はい |
| [\$1eq](eq-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1gt](gt-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1gte](gte-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1lt](lt-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1lte](lte-aggregation.md) | はい | はい | はい | はい | はい |
| [\$1ne](ne-aggregation.md) | はい | はい | はい | はい | はい |
### 条件式演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | はい | はい | はい | はい | はい |
| [\$1ifNull](ifNull.md) | はい | はい | はい | はい | あり |
| [\$1switch](switch.md) | なし | はい | はい | あり | なし |
### データ型演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | はい | はい | はい | はい | はい |
### データサイズ演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | いいえ | なし | いいえ |
| \$1bsonSize | - | - | いいえ | なし | いいえ |
### 日付演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1dateAdd](dateAdd.md) | いいえ | なし | はい | はい | はい |
| [\$1dateDiff](dateDiff.md) | - | - | はい | あり | なし |
| \$1dateFromParts | いいえ | なし | なし | なし | なし |
| [\$1dateFromString](dateFromString.md) | はい | はい | はい | はい | あり |
| [\$1dateSubtract](dateSubtract.md) | なし | なし | はい | はい | はい |
| \$1dateToParts | いいえ | なし | なし | なし | なし |
| [\$1dateToString](dateToString.md) | はい | はい | はい | はい | あり |
| [\$1dateTrunc](dateTrunc.md) | - | - | なし | あり | なし |
| [\$1dayOfMonth](dayOfMonth.md) | はい | はい | はい | はい | はい |
| [\$1dayOfWeek](dayOfWeek.md) | はい | はい | はい | はい | はい |
| [\$1dayOfYear](dayOfYear.md) | はい | はい | はい | はい | はい |
| [\$1hour](hour.md) | はい | はい | はい | はい | はい |
| [\$1isoDayOfWeek](isoDayOfWeek.md) | はい | はい | はい | はい | はい |
| [\$1isoWeek](isoWeek.md) | はい | はい | はい | はい | はい |
| [\$1isoWeekYear](isoWeekYear.md) | はい | はい | はい | はい | はい |
| [\$1millisecond](millisecond.md) | はい | はい | はい | はい | はい |
| [\$1minute](minute.md) | はい | はい | はい | はい | はい |
| [\$1month](month.md) | はい | はい | はい | はい | はい |
| [\$1second](second.md) | はい | はい | はい | はい | はい |
| [\$1week](week.md) | はい | はい | はい | はい | はい |
| [\$1year](year.md) | はい | はい | はい | はい | はい |
### リテラル演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | はい | はい | はい | はい | はい |
### マージ演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | はい | はい | はい | はい | はい |
### 自然演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1natural](natural.md) | はい | はい | はい | はい | はい |
### セット演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1allElementsTrue](allElementsTrue.md) | いいえ | はい | はい | はい | あり |
| [\$1anyElementTrue](anyElementTrue.md) | なし | はい | はい | はい | あり |
| [\$1setDifference](setDifference.md) | なし | はい | はい | はい | はい |
| [\$1setEquals](setEquals.md) | はい | はい | はい | はい | はい |
| [\$1setIntersection](setIntersection.md) | はい | はい | はい | はい | はい |
| [\$1setIsSubset](setIsSubset.md) | はい | はい | はい | はい | はい |
| [\$1setUnion](setUnion.md) | はい | はい | はい | はい | はい |
| \$1setWindowFields | いいえ | なし | なし | なし | いいえ |
### ステージ演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1addFields](addFields.md) | はい | はい | はい | はい | あり |
| [\$1bucket](bucket.md) | なし | なし | なし | あり | なし |
| \$1bucketAuto | いいえ | なし | なし | なし |
| [\$1changeStream](changeStream.md) | はい | はい | はい | あり | なし |
| [\$1collStats](collStats.md) | なし | はい | はい | あり | なし |
| [\$1count](count.md) | はい | はい | はい | はい | はい |
| [\$1currentOp](currentOp.md) | はい | はい | はい | はい | はい |
| \$1facet | いいえ | なし | なし | なし | なし |
| [\$1geoNear](geoNear.md) | はい | はい | はい | はい | はい |
| \$1graphLookup | いいえ | なし | なし | なし | なし |
| [\$1group](group.md) | はい | はい | はい | はい | はい |
| [\$1indexStats](indexStats.md) | はい | はい | はい | はい | はい |
| [\$1limit](limit.md) | はい | はい | はい | はい | はい |
| \$1listLocalSessions | いいえ | なし | なし | なし | いいえ |
| \$1listSessions | いいえ | なし | なし | なし | なし |
| [\$1lookup](lookup.md) | はい | はい | はい | はい | はい |
| [\$1match](match.md) | はい | はい | はい | はい | あり |
| [\$1merge](merge.md) | - | - | なし | あり | なし |
| [\$1out](out.md) | はい | はい | はい | あり | なし |
| \$1planCacheStats | - | - | いいえ | なし | なし |
| [\$1project](project.md) | はい | はい | はい | はい | はい |
| [\$1redact](redact.md) | はい | はい | はい | はい | はい |
| [\$1replaceRoot](replaceRoot.md) | はい | はい | はい | はい | はい |
| [\$1sample](sample.md) | はい | はい | はい | はい | あり |
| [\$1set](set-stage.md) | - | - | なし | あり | なし |
| \$1setWindowFields | - | - | いいえ | なし | なし |
| [\$1skip](skip.md) | はい | はい | はい | はい | はい |
| [\$1sort](sort.md) | はい | はい | はい | はい | はい |
| \$1sortByCount | いいえ | なし | なし | なし | いいえ |
| \$1unionWith | - | - | いいえ | なし | なし |
| [\$1unset](unset-stage.md) | - | - | なし | あり | なし |
| [\$1unwind](unwind.md) | はい | はい | はい | はい | あり |
| [\$1replaceWith](replaceWith.md) | なし | なし | なし | あり | なし |
| [\$1vectorSearch](vectorSearch.md) | なし | なし | なし | あり | なし |
### 文字列演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1concat](concat.md) | はい | はい | はい | はい | はい |
| [\$1indexOfBytes](indexOfBytes.md) | はい | はい | はい | はい | はい |
| [\$1indexOfCP](indexOfCP.md) | はい | はい | はい | はい | あり |
| [\$1ltrim](ltrim.md) | なし | はい | はい | あり | なし |
| [\$1regexFind](regexFind.md) | - | - | はい | あり | なし |
| [\$1regexFindAll](regexFindAll.md) | - | - | はい | あり | なし |
| [\$1regexMatch](regexMatch.md) | - | - | はい | あり | なし |
| [\$1replaceAll](replaceAll.md) | - | - | はい | あり | なし |
| [\$1replaceOne](replaceOne.md) | - | - | はい | あり | なし |
| [\$1rtrim](rtrim.md) | なし | はい | はい | あり | なし |
| [\$1split](split.md) | はい | はい | はい | はい | はい |
| [\$1strcasecmp](strcasecmp.md) | はい | はい | はい | はい | はい |
| [\$1strLenBytes](strLenBytes.md) | はい | はい | はい | はい | はい |
| [\$1strLenCP](strLenCP.md) | はい | はい | はい | はい | はい |
| [\$1substr](substr.md) | はい | はい | はい | はい | はい |
| [\$1substrBytes](substrBytes.md) | はい | はい | はい | はい | はい |
| [\$1substrCP](substrCP.md) | はい | はい | はい | はい | はい |
| [\$1toLower](toLower.md) | はい | はい | はい | はい | はい |
| [\$1toUpper](toUpper.md) | はい | はい | はい | はい | あり |
| [\$1trim](trim.md) | なし | はい | はい | あり | なし |
### システム変数
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| \$1\$1CURRENT | いいえ | なし | なし | なし | なし |
| [\$1\$1DESCEND](DESCEND.md) | はい | はい | はい | はい | はい |
| [\$1\$1KEEP](KEEP.md) | はい | はい | はい | はい | はい |
| [\$1\$1PRUNE](PRUNE.md) | はい | はい | はい | はい | はい |
| \$1\$1REMOVE | いいえ | なし | なし | なし | なし |
| [\$1ROOT](ROOT.md) | はい | はい | はい | はい | はい |
### テキスト検索演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | いいえ | なし | はい | あり | なし |
| [\$1search](search.md) | なし | なし | はい | あり | なし |
### 型変換演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1convert](convert.md) | いいえ | はい | はい | はい | はい |
| \$1isNumber | - | - | いいえ | なし | なし |
| [\$1toBool](toBool.md) | なし | はい | はい | はい | あり |
| [\$1toDate](toDate.md) | なし | はい | はい | はい | あり |
| [\$1toDecimal](toDecimal.md) | なし | はい | はい | はい | あり |
| [\$1toDouble](toDouble.md) | なし | はい | はい | はい | あり |
| [\$1toInt](toInt.md) | なし | はい | はい | はい | あり |
| [\$1toLong](toLong.md) | なし | はい | はい | はい | あり |
| [\$1toObjectId](toObjectId.md) | なし | はい | はい | はい | あり |
| [\$1toString](toString.md) | なし | はい | はい | はい | はい |
### 変数演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | はい | はい | はい | はい | はい |
| [\$1map](map.md) | はい | はい | はい | はい | はい |
### その他の演算子
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | いいえ | なし | なし |
| [\$1rand](rand.md) | - | - | なし | あり | なし |
| \$1sampleRate | - | - | いいえ | なし | いいえ |
## データ型
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| 32 ビット整数 (int) | はい | はい | はい | はい | はい |
| 64 ビット整数 (long) | はい | はい | はい | はい | はい |
| 配列 | はい | はい | はい | はい | はい |
| バイナリデータ | はい | はい | はい | はい | はい |
| ブール値 | はい | はい | はい | はい | はい |
| 日付 | 可能 | はい | はい | はい | はい |
| DBPointer | いいえ | なし | なし | なし | いいえ |
| DBRefs | いいえ | なし | なし | なし | いいえ |
| Decimal128 | はい | はい | はい | はい | はい |
| Double | はい | はい | はい | はい | はい |
| JavaScript | いいえ | なし | なし | なし | いいえ |
| JavaScript (スコープ付き) | いいえ | なし | なし | なし | いいえ |
| MaxKey | はい | はい | はい | はい | はい |
| MinKey | はい | はい | はい | はい | はい |
| Null | はい | はい | はい | はい | はい |
| オブジェクト | はい | はい | はい | はい | はい |
| ObjectId | はい | はい | はい | はい | はい |
| 正規表現 | はい | はい | はい | はい | 可能 |
| String | 可能 | はい | はい | はい | はい |
| 記号 | いいえ | なし | なし | なし | いいえ |
| タイムスタンプ | はい | はい | はい | はい | はい |
| 未定義 | いいえ | なし | なし | なし | いいえ |
## インデックスとインデックスプロパティ
**Topics**
+ [インデックス](#mongo-apis-indexes)
+ [インデックスプロパティ](#mongo-apis-index-properties)
### インデックス
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | はい | はい | はい | はい | はい |
| 2d インデックス | いいえ | なし | なし | なし | いいえ |
| 複合インデックス | はい | はい | はい | はい | はい |
| ハッシュインデックス | いいえ | なし | なし | なし | いいえ |
| マルチキーインデックス | はい | はい | はい | はい | はい |
| 単一フィールドインデックス | はい | はい | はい | はい | はい |
| テキストインデックス | いいえ | なし | はい | あり | なし |
| ワイルドカード | いいえ | なし | なし | なし | いいえ |
### インデックスプロパティ
| コマンド | 3.6 | 4.0 | 5.0 | 8.0 | Elastic クラスター |
| --- | --- | --- | --- | --- | --- |
| 背景 | はい | はい | はい | はい | はい |
| 大文字と小文字を区別しない | いいえ | なし | なし | あり | なし |
| [非表示] | いいえ | なし | なし | なし | いいえ |
| 部分的 | なし | なし | はい | あり | なし |
| スパース | はい | はい | はい | はい | はい |
| テキスト | いいえ | なし | はい | あり | なし |
| TTL | はい | はい | はい | はい | はい |
| Unique | はい | はい | はい | はい | はい |
| Vector | いいえ | なし | はい | あり | なし |
特定の MongoDB 演算子の詳細については、以下のトピックを参照してください。
+ [集約パイプライン演算子](mongo-apis-aggregation-pipeline-operators.md)
+ [地理空間](mongo-apis-geospatial-operators.md)
+ [プロジェクション演算子](#mongo-apis-projection-operators)
+ [更新演算子](mongo-apis-update-operators.md)
# 集約パイプライン演算子
このセクションでは、Amazon DocumentDB でサポートされている集約パイプライン演算子に関する詳細情報を提供します。
**Topics**
+ [\$1\$1DESCEND](DESCEND.md)
+ [\$1\$1KEEP](KEEP.md)
+ [\$1\$1PRUNE](PRUNE.md)
+ [\$1ROOT](ROOT.md)
+ [\$1abs](abs.md)
+ [\$1add](add.md)
+ [\$1addToSet](addToSet-aggregation.md)
+ [\$1addFields](addFields.md)
+ [\$1allElementsTrue](allElementsTrue.md)
+ [\$1and](and-aggregation.md)
+ [\$1anyElementTrue](anyElementTrue.md)
+ [\$1arrayElemAt](arrayElemAt.md)
+ [\$1arrayToObject](arrayToObject.md)
+ [\$1avg](avg.md)
+ [\$1bucket](bucket.md)
+ [\$1ceil](ceil.md)
+ [\$1changeStream](changeStream.md)
+ [\$1cmp](cmp.md)
+ [\$1collStats](collStats.md)
+ [\$1concat](concat.md)
+ [\$1concatArrays](concatArrays.md)
+ [\$1cond](cond.md)
+ [\$1convert](convert.md)
+ [\$1count](count.md)
+ [\$1currentOp](currentOp.md)
+ [\$1dateAdd](dateAdd.md)
+ [\$1dateDiff](dateDiff.md)
+ [\$1dateFromString](dateFromString.md)
+ [\$1dateSubtract](dateSubtract.md)
+ [\$1dateToString](dateToString.md)
+ [\$1dateTrunc](dateTrunc.md)
+ [\$1dayOfMonth](dayOfMonth.md)
+ [\$1dayOfWeek](dayOfWeek.md)
+ [\$1dayOfYear](dayOfYear.md)
+ [\$1divide](divide.md)
+ [\$1eq](eq-aggregation.md)
+ [\$1exp](exp.md)
+ [\$1filter](filter.md)
+ [\$1first](first.md)
+ [\$1floor](floor.md)
+ [\$1geoNear](geoNear.md)
+ [\$1group](group.md)
+ [\$1gt](gt-aggregation.md)
+ [\$1gte](gte-aggregation.md)
+ [\$1hour](hour.md)
+ [\$1ifNull](ifNull.md)
+ [\$1in](in-aggregation.md)
+ [\$1indexOfArray](indexOfArray.md)
+ [\$1indexOfBytes](indexOfBytes.md)
+ [\$1indexOfCP](indexOfCP.md)
+ [\$1indexStats](indexStats.md)
+ [\$1isArray](isArray.md)
+ [\$1isoDayOfWeek](isoDayOfWeek.md)
+ [\$1isoWeek](isoWeek.md)
+ [\$1isoWeekYear](isoWeekYear.md)
+ [\$1last](last.md)
+ [\$1let](let.md)
+ [\$1limit](limit.md)
+ [\$1literal](literal.md)
+ [\$1ln](ln.md)
+ [\$1log](log.md)
+ [\$1log10](log10.md)
+ [\$1lt](lt-aggregation.md)
+ [\$1lte](lte-aggregation.md)
+ [\$1lookup](lookup.md)
+ [\$1ltrim](ltrim.md)
+ [\$1map](map.md)
+ [\$1match](match.md)
+ [\$1max](max.md)
+ [\$1meta](meta-aggregation.md)
+ [\$1merge](merge.md)
+ [\$1mergeObjects](mergeObjects.md)
+ [\$1millisecond](millisecond.md)
+ [\$1min](min.md)
+ [\$1minute](minute.md)
+ [\$1mod](mod.md)
+ [\$1month](month.md)
+ [\$1multiply](multiply.md)
+ [\$1natural](natural.md)
+ [\$1ne](ne-aggregation.md)
+ [\$1not](not-aggregation.md)
+ [\$1objectToArray](objectToArray.md)
+ [\$1or](or-aggregation.md)
+ [\$1out](out.md)
+ [\$1pow](pow.md)
+ [\$1push](push-aggregation.md)
+ [\$1project](project.md)
+ [\$1rand](rand.md)
+ [\$1range](range.md)
+ [\$1redact](redact.md)
+ [\$1reduce](reduce.md)
+ [\$1regexFind](regexFind.md)
+ [\$1regexFindAll](regexFindAll.md)
+ [\$1regexMatch](regexMatch.md)
+ [\$1replaceAll](replaceAll.md)
+ [\$1replaceOne](replaceOne.md)
+ [\$1replaceRoot](replaceRoot.md)
+ [\$1replaceWith](replaceWith.md)
+ [\$1reverseArray](reverseArray.md)
+ [\$1rtrim](rtrim.md)
+ [\$1sample](sample.md)
+ [\$1search](search.md)
+ [\$1second](second.md)
+ [\$1set](set-stage.md)
+ [\$1setDifference](setDifference.md)
+ [\$1setEquals](setEquals.md)
+ [\$1setIntersection](setIntersection.md)
+ [\$1setIsSubset](setIsSubset.md)
+ [\$1setUnion](setUnion.md)
+ [\$1skip](skip.md)
+ [\$1slice](slice.md)
+ [\$1size](size.md)
+ [\$1sort](sort.md)
+ [\$1split](split.md)
+ [\$1sqrt](sqrt.md)
+ [\$1strLenBytes](strLenBytes.md)
+ [\$1strLenCP](strLenCP.md)
+ [\$1strcasecmp](strcasecmp.md)
+ [\$1substr](substr.md)
+ [\$1substrBytes](substrBytes.md)
+ [\$1substrCP](substrCP.md)
+ [\$1subtract](subtract.md)
+ [\$1sum](sum.md)
+ [\$1switch](switch.md)
+ [\$1toBool](toBool.md)
+ [\$1toDate](toDate.md)
+ [\$1toDecimal](toDecimal.md)
+ [\$1toDouble](toDouble.md)
+ [\$1toInt](toInt.md)
+ [\$1toLong](toLong.md)
+ [\$1toLower](toLower.md)
+ [\$1toObjectId](toObjectId.md)
+ [\$1toString](toString.md)
+ [\$1toUpper](toUpper.md)
+ [\$1trim](trim.md)
+ [\$1type](type-aggregation.md)
+ [\$1unset](unset-stage.md)
+ [\$1unwind](unwind.md)
+ [\$1vectorSearch](vectorSearch.md)
+ [\$1week](week.md)
+ [\$1year](year.md)
+ [\$1zip](zip.md)
# \$1\$1DESCEND
Amazon DocumentDB の `$$DESCEND`演算子は、`$redact`パイプラインステージ内で使用される特殊な位置配列演算子です。集約パイプラインに、ネストレベルに関係なく、現在のドキュメントに降下し、すべてのフィールドを処理するように指示します。
`$redact` ステージが`$$DESCEND`オペレータに遭遇すると、現在のドキュメント内のすべてのフィールドが表示されたままになり、パイプラインのさらに下流で処理されます。これは、ドキュメントの構造を維持しながら、条件に基づいて特定のフィールドを選択的に編集またはプルーニングする場合に便利です。
**パラメータ**
なし。
## 例 (MongoDB シェル)
この例では、 `$$DESCEND` 演算子で `$redact`ステージを使用して、 `code`フィールドが「Reg」と等しいドキュメントを選択的に表示します。
**サンプルドキュメントを作成する**
```
db.patient.insertMany([
{ "_id": 1, "code": "Emp", "patient": "John Doe", "DOB": "1/1/1980", "Hospital": "Main" },
{ "_id": 2, "code": "Reg", "patient": "Jane Doe", "DOB": "3/27/1989", "Hospital": "Cherry Hill" },
{ "_id": 3, "code": "Emp", "patient": "Bob Smith", "DOB": "6/15/1975", "Hospital": "Downtown" }
]);
```
**クエリの例**
```
db.patient.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]);
```
**出力**
```
{
"_id": 2,
"code": "Reg",
"patient": "Jane Doe",
"DOB": "3/27/1989",
"Hospital": "Cherry Hill"
}
```
## コードの例
`$$DESCEND` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function redactPatients() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('patient');
const result = await collection.aggregate([
{ $redact: {
$cond: {
if: { $eq: ["Reg", "$code"] },
then: "$$DESCEND",
else: "$$PRUNE"
}
}}
]).toArray();
console.log(result);
client.close();
}
redactPatients();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def redact_patients():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.patient
result = list(collection.aggregate([
{ "$redact": {
"$cond": {
"if": { "$eq": ["Reg", "$code"] },
"then": "$$DESCEND",
"else": "$$PRUNE"
}
}}
]))
print(result)
client.close()
redact_patients()
```
------
# \$1\$1KEEP
`$$KEEP` システム変数は、現在のドキュメントまたはフィールドを変更せずに出力に含めるために、集約パイプラインの `$redact`ステージで使用されます。
**パラメータ**
なし
## 例 (MongoDB シェル)
次の例は、Amazon DocumentDB 集約パイプライン`$$KEEP`での の使用を示しています。ドキュメントは、アクセスが「パブリック」と等しい場合にのみ保持され、そうでない場合は削除されます。
**サンプルドキュメントを作成する**
```
db.articles.insertMany([
{ title: "Article A", access: "public", content: "Visible content" },
{ title: "Article B", access: "private", content: "Hidden content" }
]);
```
**クエリの例**
```
db.articles.aggregate([
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
]);
```
**出力**
```
[
{
"_id" : ObjectId("..."),
"title" : "Article A",
"access" : "public",
"content" : "Visible content"
}
]
```
## コードの例
`$$KEEP` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function run() {
const client = new MongoClient(
'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0'
);
try {
await client.connect();
const db = client.db('test');
const articles = db.collection('articles');
const pipeline = [
{
$redact: {
$cond: [
{ $eq: ["$access", "public"] },
"$$KEEP",
"$$PRUNE"
]
}
}
];
const results = await articles.aggregate(pipeline).toArray();
console.log(results);
} finally {
await client.close();
}
}
run().catch(console.error);
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient(
"mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0"
)
db = client.test
articles = db.articles
pipeline = [
{
"$redact": {
"$cond": [
{"$eq": ["$access", "public"]},
"$$KEEP",
"$$PRUNE"
]
}
}
]
results = list(articles.aggregate(pipeline))
print(results)
client.close()
```
------
# \$1\$1PRUNE
`$$PRUNE` システム変数は、集計パイプラインの `$redact`ステージとともに使用され、結果からドキュメントまたは埋め込みドキュメントレベルを除外します。条件が に評価されると`$$PRUNE`、現在のドキュメントまたはサブドキュメントが出力から削除されます。通常、 `$$DESCEND` (ドキュメントを保持およびトラバースするため) または `$$KEEP` (ドキュメントをすべてのレベルで保持するため) で使用されます。
**パラメータ**
なし。`$$PRUNE` システム変数はパラメータなしで使用され、 で使用する必要があります`$redact`。
## 例 (MongoDB シェル)
次の例は、 `$$PRUNE`で を使用して 30 年以上前のユーザー`$redact`を結果から除外する方法を示しています。
**サンプルドキュメントを作成する**
```
db.users.insert([
{ _id:1, name: "Carlos Salazar", age: 35, address: { street: "123 Main St", city: "Anytown", state: "CA" } },
{ _id:2, name: "Saanvi Sarkar", age: 28, address: { street: "456 Oak Rd", city: "Someplace", state: "NY" } },
{ _id:3, name: "Li Juan", age: 42, address: { street: "789 Pine Ave", city: "Springfield", state: "TX" } }
])
```
**クエリの例**
```
db.users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
])
```
**出力**
```
[
{
"_id": 2,
"name": "Saanvi Sarkar",
"age": 28,
"address": {
"street": "456 Oak Rd",
"city": "Someplace",
"state": "NY"
}
}
]
```
## コードの例
`$$PRUNE` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
async function main() {
await client.connect();
const db = client.db('test');
const users = db.collection('users');
const result = await users.aggregate([
{
$redact: {
$cond: {
if: { $gt: ["$age", 30] },
then: "$$PRUNE",
else: "$$DESCEND"
}
}
}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
users = db['users']
result = list(users.aggregate([
{
'$redact': {
'$cond': {
'if': { '$gt': ['$age', 30] },
'then': '$$PRUNE',
'else': '$$DESCEND'
}
}
}
]))
print(result)
client.close()
```
------
# \$1ROOT
Amazon DocumentDB の `$ROOT`演算子は、集約パイプライン内の入力ドキュメント全体を参照するために使用されます。これにより、ネストされたすべてのフィールドと構造を含む完全なドキュメントにアクセスして操作できます。
**パラメータ**
なし
## 例 (MongoDB シェル)
この例では`$ROOT`、 を使用して、元のドキュメント全体を、いつ処理されたかについてのメタデータとともにキャプチャする監査ログを作成する方法を示します。
**サンプルドキュメントを作成する**
```
db.orders.insertMany([
{
_id: 1,
orderId: "ORD-2024-001",
customer: "María García",
email: "maría@example.com",
items: [
{ product: "Laptop", quantity: 1, price: 1299.99 }
],
totalAmount: 1299.99
},
{
_id: 2,
orderId: "ORD-2024-002",
customer: "Arnav Desai",
email: "arnav@example.com",
items: [
{ product: "Mouse", quantity: 2, price: 29.99 },
{ product: "Keyboard", quantity: 1, price: 89.99 }
],
totalAmount: 149.97
}
]);
```
**クエリの例**
```
db.orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]);
```
**出力**
```
[
{
_id: 1,
processedAt: ISODate('2025-11-24T20:43:51.492Z'),
originalDocument: {
_id: 1,
orderId: 'ORD-2024-001',
customer: 'María García',
email: 'maría@example.com',
items: [ { product: 'Laptop', quantity: 1, price: 1299.99 } ],
totalAmount: 1299.99
},
summary: 'Order ORD-2024-001 for María García - Total: $1299.99'
},
{
_id: 2,
processedAt: ISODate('2025-11-24T20:43:51.492Z'),
originalDocument: {
_id: 2,
orderId: 'ORD-2024-002',
customer: 'Arnav Desai',
email: 'arnav@example.com',
items: [
{ product: 'Mouse', quantity: 2, price: 29.99 },
{ product: 'Keyboard', quantity: 1, price: 89.99 }
],
totalAmount: 149.97
},
summary: 'Order ORD-2024-002 for Arnav Desai - Total: $149.97'
}
]
```
## コードの例
`$ROOT` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function createAuditLog() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const orders = db.collection('orders');
const result = await orders.aggregate([
{
$project: {
processedAt: new Date(),
originalDocument: "$$ROOT",
summary: {
$concat: [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ $toString: "$totalAmount" }
]
}
}
}
]).toArray();
console.log(result);
await client.close();
}
createAuditLog();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from datetime import datetime
def create_audit_log():
client = MongoClient('mongodb://username:password@docdb-cluster.cluster-123456789.us-east-1.docdb.amazonaws.com:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['orders']
result = list(collection.aggregate([
{
'$project': {
'processedAt': datetime.now(),
'originalDocument': '$$ROOT',
'summary': {
'$concat': [
"Order ",
"$orderId",
" for ",
"$customer",
" - Total: $",
{ '$toString': "$totalAmount" }
]
}
}
}
]))
print(result)
client.close()
create_audit_log()
```
------
# \$1abs
Amazon DocumentDB の `$abs`演算子は、数値の絶対値を返します。集約パイプラインで使用して、数値フィールドで数学演算を実行できます。
**パラメータ**
+ `number`: 絶対値が返される数値式。
## 例 (MongoDB シェル)
この例では、演算子を使用して数値フィールドの絶対値`$abs`を見つける方法を示します。
**サンプルドキュメントを作成する**
```
db.numbers.insertMany([
{ "_id": 1, "value": -5 },
{ "_id": 2, "value": 10 },
{ "_id": 3, "value": -3.14 },
{ "_id": 4, "value": 0 }
]);
```
**クエリの例**
```
db.numbers.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]);
```
**出力**
```
[
{ "_id": 1, "absolute_value": 5 },
{ "_id": 2, "absolute_value": 10 },
{ "_id": 3, "absolute_value": 3.14 },
{ "_id": 4, "absolute_value": 0 }
]
```
## コードの例
`$abs` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function main() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: {
"_id": 1,
"absolute_value": { $abs: "$value" }
}}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def main():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['numbers']
result = list(collection.aggregate([
{ '$project': {
"_id": 1,
"absolute_value": { "$abs": "$value" }
}}
]))
print(result)
client.close()
if __name__ == "__main__":
main()
```
------
# \$1add
Amazon DocumentDB の `$add`演算子は、数値または日付を一緒に追加するために使用されます。数値フィールドで算術演算を実行したり、日付フィールドに複数の時間単位を追加して日付算術を実行したりできます。
**パラメータ**
+ `expression1`: 追加する最初の数値または日付。
+ `expression2`: 追加する 2 番目の数値または日付。
+ `expression3`: (オプション) 追加する追加の数字または日付。
## 例 (MongoDB シェル)
次の例は、 `$add`演算子を使用して 2 つの数値を一緒に追加する方法を示しています。
**サンプルドキュメントを作成する**
```
db.numbers.insertMany([
{ _id: 1, a: 5, b: 3 },
{ _id: 2, a: 10, b: 7 },
{ _id: 3, a: 2, b: 8 }
]);
```
**クエリの例**
```
db.numbers.aggregate([
{ $project: {
_id: 1,
sum: { $add: ["$a", "$b"] }
}}
])
```
**出力**
```
[
{ "_id" : 1, "sum" : 8 },
{ "_id" : 2, "sum" : 17 },
{ "_id" : 3, "sum" : 10 }
]
```
この例では、 `$add`演算子を使用して各ドキュメントの `a`フィールドと `b`フィールドの値を追加し、結果を `sum`フィールドに保存します。
## コードの例
`$add` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: {
_id: 1,
sum: { $add: ['$a', '$b'] }
}}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['numbers']
result = list(collection.aggregate([
{ '$project': {
'_id': 1,
'sum': { '$add': ['$a', '$b'] }
}}
]))
print(result)
client.close()
```
------
# \$1addToSet
`$addToSet` 集計演算子は、各グループの指定された式から一意の値の配列を返します。`$group` ステージ内で使用して個別の値を蓄積し、重複を自動的に排除します。
**パラメータ**
+ `expression`: グループ内の各ドキュメントについて評価する式。
## 例 (MongoDB シェル)
次の例は、 `$addToSet`演算子を使用して、顧客ごとに注文が行われた一意の都市を収集する方法を示しています。
**サンプルドキュメントを作成する**
```
db.orders.insertMany([
{ _id: 1, customer: "Alice", city: "Seattle", amount: 100 },
{ _id: 2, customer: "Alice", city: "Portland", amount: 150 },
{ _id: 3, customer: "Bob", city: "Seattle", amount: 200 },
{ _id: 4, customer: "Alice", city: "Seattle", amount: 75 },
{ _id: 5, customer: "Bob", city: "Boston", amount: 300 }
]);
```
**クエリの例**
```
db.orders.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]);
```
**出力**
```
[
{ _id: 'Bob', cities: [ 'Seattle', 'Boston' ] },
{ _id: 'Alice', cities: [ 'Seattle', 'Portland' ] }
]
```
## コードの例
`$addToSet` 集計演算子を使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('orders');
const result = await collection.aggregate([
{
$group: {
_id: "$customer",
cities: { $addToSet: "$city" }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['orders']
result = list(collection.aggregate([
{
'$group': {
'_id': '$customer',
'cities': { '$addToSet': '$city' }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1addFields
Amazon DocumentDB 集約パイプラインの `$addFields`ステージでは、新しい計算フィールドをドキュメントに追加できます。これは、派生データまたは変換されたデータをドキュメントに追加するのに役立ちます。
**パラメータ**
+ `newField`: 追加する新しいフィールドの名前。
+ `expression`: 新しいフィールドの値に解決される式。
## 例 (MongoDB シェル)
次の例は、 `$addFields`を使用して、 `Inventory.OnHand` および フィールドに基づいてインベントリの合計`TotalInventory`を計算する新しい`Inventory.OrderQnty`フィールドを追加する方法を示しています。
**サンプルドキュメントを作成する**
```
db.example.insertMany([
{
"Item": "Spray Paint",
"Colors": ["Black", "Red", "Green", "Blue"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 50,
"OrderQnty": 36
},
"UnitPrice": 3.99
},
{
"Item": "Ruler",
"Colors": ["Red", "Green", "Blue", "Clear", "Yellow"],
"Inventory": {
"OnHand": 47,
"MinOnHand": 40
},
"UnitPrice": 0.89
}
]);
```
**クエリの例**
```
db.example.aggregate([
{
$addFields: {
TotalInventory: { $add: ["$Inventory.OnHand", "$Inventory.OrderQnty"] }
}
}
])
```
**出力**
```
[
{
"_id" : ObjectId("5bedafbcf65ff161707de24f"),
"Item" : "Ruler",
"Colors" : [ "Red", "Green", "Blue", "Clear", "Yellow" ],
"Inventory" : {
"OnHand" : 47,
"MinOnHand" : 40
},
"UnitPrice" : 0.89,
"TotalInventory" : 47
},
{
"_id" : ObjectId("5bedafbcf65ff161707de250"),
"Item" : "Spray Paint",
"Colors" : [ "Black", "Red", "Green", "Blue" ],
"Inventory" : {
"OnHand" : 47,
"MinOnHand" : 50,
"OrderQnty" : 36
},
"UnitPrice" : 3.99,
"TotalInventory" : 83
}
]
```
## コードの例
`$addFields` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('example');
const result = await collection.aggregate([
{
$addFields: {
TotalInventory: { $add: ['$Inventory.OnHand', '$Inventory.OrderQnty'] }
}
}
]).toArray();
console.log(result);
await client.close();
```
------
#### [ Python ]
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['example']
result = list(collection.aggregate([
{
'$addFields': {
'TotalInventory': { '$add': ['$Inventory.OnHand', '$Inventory.OrderQnty'] }
}
}
]))
print(result)
client.close()
```
------
# \$1allElementsTrue
バージョン 4.0 の新機能
`$allElementsTrue` 演算子は、配列内のすべての要素が true 値に評価されるかどうかを確認するために使用されます。
**パラメータ**
+ `expression`: 配列に評価される式。
## 例 (MongoDB シェル)
次の例は、配列内のすべての要素が true であるかどうかをチェック`$allElementsTrue`するための の使用を示しています。
**サンプルドキュメントを作成する**
```
db.collection.insert([
{ "name": "John", "scores": [100, 90, 80] },
{ "name": "Jane", "scores": [80, 85, 0] },
{ "name": "Bob", "scores": [90, 95, null] }
])
```
**クエリの例**
```
db.collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
})
```
**出力**
```
[
{ "_id" : ObjectId("..."), "name" : "John", "scores" : [ 100, 90, 80 ] },
{ "_id" : ObjectId("..."), "name" : "Bob", "scores" : [ 90, 95, null ] }
]
```
この例では、クエリは`scores`配列内のすべての要素が 0 より大きいかどうかを確認します。`scores` 配列に 0 が含まれているため、 を持つドキュメント`"name": "Jane"`は除外されます。0 は不正な値です。
## コードの例
`$allElementsTrue` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('collection');
const result = await collection.find({
"scores": { "$allElementsTrue": [{ "$gt": 0 }] }
}).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['collection']
result = list(collection.find({
"scores": {"$allElementsTrue": [{"$gt": 0}]}
}))
print(result)
client.close()
example()
```
------
# \$1and
`$and` 集計演算子は複数の式を評価し、すべての式が と評価された`true`場合にのみ を返します`true`。いずれかの式が の場合`false`、 を返します`false`。
**パラメータ**
+ `expressions`: 評価する式の配列。
## 例 (MongoDB シェル)
次の例では、 `$and`演算子を使用して、製品が複数の基準を満たしているかどうかを確認します。
**サンプルドキュメントを作成する**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200, inStock: true },
{ _id: 2, name: "Mouse", price: 25, inStock: false },
{ _id: 3, name: "Keyboard", price: 75, inStock: true }
]);
```
**クエリの例**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]);
```
**出力**
```
[
{ _id: 1, name: 'Laptop', price: 1200, inStock: true, affordable: false },
{ _id: 2, name: 'Mouse', price: 25, inStock: false, affordable: false },
{ _id: 3, name: 'Keyboard', price: 75, inStock: true, affordable: true }
]
```
## コードの例
`$and` 集計演算子を使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('products');
const result = await collection.aggregate([
{
$project: {
name: 1,
price: 1,
inStock: 1,
affordable: {
$and: [
{ $lt: ["$price", 100] },
{ $eq: ["$inStock", true] }
]
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['products']
result = list(collection.aggregate([
{
'$project': {
'name': 1,
'price': 1,
'inStock': 1,
'affordable': {
'$and': [
{ '$lt': ['$price', 100] },
{ '$eq': ['$inStock', True] }
]
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1anyElementTrue
バージョン 4.0 の新機能
`$anyElementTrue` 演算子は、配列内のいずれかの要素が true かどうかを判断するために使用されます。
**パラメータ**
+ `field`: 評価する配列フィールド。
## 例 (MongoDB シェル)
次の例は、配列内の要素が true であるかどうかをチェック`$anyElementTrue`するための の使用を示しています。
**サンプルドキュメントを作成する**
```
db.grades.insertMany([
{ _id: 1, student: 'Tim', scores: [false, false, null] },
{ _id: 2, student: 'Bob', scores: [false, 0, false] },
{ _id: 3, student: 'Ivy', scores: [false, true, 0] }
])
```
**クエリの例**
```
db.grades.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
])
```
**出力**
```
[
{ student: 'Tim', isAnyTrue: false },
{ student: 'Bob', isAnyTrue: false },
{ student: 'Ivy', isAnyTrue: true }
]
```
## コードの例
`$anyElementTrue` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('grades');
const result = await collection.aggregate([
{
$project: {
student: 1,
isAnyTrue: { $anyElementTrue: ["$scores"] },
_id: 0
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['grades']
result = list(collection.aggregate([
{
"$project": {
"student": 1,
"isAnyTrue": { "$anyElementTrue": ["$scores"] },
"_id": 0
}
}
]))
print(result)
client.close()
example()
```
------
# \$1arrayElemAt
Amazon DocumentDB の `$arrayElemAt`演算子を使用すると、インデックス位置によって配列から要素を取得できます。これは、ドキュメントの配列フィールド内の特定の要素にアクセスする必要がある場合に特に便利です。
**パラメータ**
+ `array`: 要素を取得する入力配列。
+ `index`: 取得する要素のゼロベースのインデックス位置。この値は負以外の整数である必要があります。
## 例 (MongoDB シェル)
この例では、 `$arrayElemAt`演算子を使用して`miles`コレクション内の`flight_miles`配列から特定の要素を取得する方法を示します。
**サンプルドキュメントを作成する**
```
db.miles.insertMany([
{ "_id" : 1, "member_since" : ISODate("1987-01-01T00:00:00Z"), "credit_card" : false, "flight_miles" : [ 1205, 2560, 880 ]},
{ "_id" : 2, "member_since" : ISODate("1982-01-01T00:00:00Z"), "credit_card" : true, "flight_miles" : [ 1205, 2560, 890, 2780 ]},
{ "_id" : 3, "member_since" : ISODate("1999-01-01T00:00:00Z"), "credit_card" : true, "flight_miles" : [ 1205, 880 ]}
]);
```
**クエリの例**
```
db.miles.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]);
```
**出力**
```
{ "_id" : 1, "first_mile" : 1205, "last_mile" : 880 }
{ "_id" : 2, "first_mile" : 1205, "last_mile" : 2780 }
{ "_id" : 3, "first_mile" : 1205, "last_mile" : 880 }
```
この例では、 `$arrayElemAt`演算子を使用して、各ドキュメントの`flight_miles`配列の最初と最後の要素を取得します。
## コードの例
`$arrayElemAt` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('miles');
const result = await collection.aggregate([
{ $project: {
"_id": 1,
"first_mile": { $arrayElemAt: [ "$flight_miles", 0 ] },
"last_mile": { $arrayElemAt: [ "$flight_miles", -1 ] }
}}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.mydatabase
collection = db.miles
result = list(collection.aggregate([
{ "$project": {
"_id": 1,
"first_mile": { "$arrayElemAt": [ "$flight_miles", 0 ] },
"last_mile": { "$arrayElemAt": [ "$flight_miles", -1 ] }
}}
]))
print(result)
client.close()
example()
```
------
# \$1arrayToObject
Amazon DocumentDB の `$arrayToObject`演算子は、 `$objectToArray`演算子の逆です。キーと値のペアドキュメントの配列を取得し、1 つのドキュメントに変換します。これは、キーと値のペアの配列をオブジェクトまたはドキュメント構造に変換する必要がある場合に特に便利です。
**パラメータ**
+ `array expression`: 配列に解決される式。配列要素は、 ( キー) と `k` ( 値) の 2 `v` つのフィールドを持つドキュメントである必要があります。
## 例 (MongoDB シェル)
以下の例は、 `$arrayToObject`を使用してキーと値のペアの配列をドキュメントに変換する方法を示しています。
**サンプルドキュメントを作成する**
```
db.videos.insertMany([
{ "_id": 1, "name": "Live Soft", "inventory": { "Des Moines": 1000, "Ames": 500 } },
{ "_id": 2, "name": "Top Pilot", "inventory": { "Mason City": 250, "Des Moines": 1000 } },
{ "_id": 3, "name": "Romancing the Rock", "inventory": { "Mason City": 250, "Ames": 500 } },
{ "_id": 4, "name": "Bravemind", "inventory": { "Mason City": 250, "Des Moines": 1000, "Ames": 500 } }
]);
```
**クエリの例**
```
db.videos.aggregate([
{ $project: { name: 1, videos: { $objectToArray: "$inventory" } } },
{ $project: { name: 1, inventory: { $arrayToObject: "$videos" } } }
]);
```
**出力**
```
{ "_id" : 1, "name" : "Live Soft", "inventory" : { "Des Moines" : 1000, "Ames" : 500 } }
{ "_id" : 2, "name" : "Top Pilot", "inventory" : { "Mason City" : 250, "Des Moines" : 1000 } }
{ "_id" : 3, "name" : "Romancing the Rock", "inventory" : { "Mason City" : 250, "Ames" : 500 } }
{ "_id" : 4, "name" : "Bravemind", "inventory" : { "Mason City" : 250, "Des Moines" : 1000, "Ames" : 500 } }
```
この例では、 `$objectToArray`演算子を使用して`inventory`オブジェクトをキーと値のペアの配列に変換します。次に、 `$arrayToObject`演算子を使用して配列をドキュメントに変換し、元のオブジェクト構造を復元します。
## コードの例
`$arrayToObject` コマンドを使用するためのコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('videos');
const result = await collection.aggregate([
{ $project: { name: 1, videos: { $objectToArray: '$inventory' } } },
{ $project: { name: 1, inventory: { $arrayToObject: '$videos' } } }
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['videos']
result = list(collection.aggregate([
{ '$project': { 'name': 1, 'videos': { '$objectToArray': '$inventory' } } },
{ '$project': { 'name': 1, 'inventory': { '$arrayToObject': '$videos' } } }
]))
print(result)
client.close()
example()
```
------
# \$1avg
Amazon DocumentDB の`$avg`集計演算子は、ステージに入力されるドキュメント全体で指定された式の平均値を計算します。この演算子は、一連のドキュメントにわたる数値フィールドまたは式の平均を計算するのに役立ちます。
**パラメータ**
+ `expression`: 平均の計算に使用する式。これは、フィールドパス (例: `"$field"`) または式 (例: `{ $multiply: ["$field1", "$field2"] }`) です。
## 例 (MongoDB シェル)
次の例は、 `$avg`演算子を使用して、一連の学生ドキュメントの平均スコアを計算する方法を示しています。
**サンプルドキュメントを作成する**
```
db.students.insertMany([
{ name: "John", score: 85 },
{ name: "Jane", score: 92 },
{ name: "Bob", score: 78 },
{ name: "Alice", score: 90 }
]);
```
**クエリの例**
```
db.students.aggregate([
{ $group: {
_id: null,
avgScore: { $avg: "$score" }
}}
]);
```
**出力**
```
[
{
"_id": null,
"avgScore": 86.25
}
]
```
## コードの例
`$avg` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function calculateAvgScore() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const result = await db.collection('students').aggregate([
{ $group: {
_id: null,
avgScore: { $avg: '$score' }
}}
]).toArray();
console.log(result);
await client.close();
}
calculateAvgScore();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def calculate_avg_score():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
result = list(db.students.aggregate([
{ '$group': {
'_id': None,
'avgScore': { '$avg': '$score' }
}}
]))
print(result)
client.close()
calculate_avg_score()
```
------
# \$1bucket
バージョン 8.0 の新機能
Elastic クラスターではサポートされていません。
Amazon DocumentDB の`$bucket`集約ステージでは、指定された式とバケットの境界に基づいて入力ドキュメントをバケットにグループ化できます。これは、特定の値の範囲またはカテゴリに含まれるデータの分析に役立ちます。
**パラメータ**
+ `groupBy` (必須): グループ化する値を指定する式。
+ `boundaries` (必須): バケットの境界を定義する二重値の配列。ドキュメントは、指定された境界内にある`groupBy`式の値に基づいてバケットに割り当てられます。
+ `default` (オプション): `groupBy`式値が指定された境界のいずれにも入らないドキュメントに対して出力されるリテラル値。
+ `output` (オプション): 各バケットに出力する情報を指定するオブジェクト。、`$sum`、`$avg`、 などのアキュムレータ演算子を使用して`$min`、各バケットの集計を`$max`計算できます。
## 例 (MongoDB シェル)
次の例は、 `$bucket`ステージを使用して、価格範囲別に売上データをグループ化する方法を示しています。
**サンプルドキュメントを作成する**
```
db.sales.insertMany([
{ item: "abc", price: 10, quantity: 2, date: new Date("2020-09-01") },
{ item: "def", price: 20, quantity: 1, date: new Date("2020-10-01") },
{ item: "ghi", price: 5, quantity: 3, date: new Date("2020-11-01") },
{ item: "jkl", price: 15, quantity: 2, date: new Date("2020-12-01") },
{ item: "mno", price: 25, quantity: 1, date: new Date("2021-01-01") }
]);
```
**クエリの例**
```
db.sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
])
```
**出力**
```
[
{ _id: 0, count: 1, totalQuantity: 3 },
{ _id: 10, count: 2, totalQuantity: 4 },
{ _id: 20, count: 2, totalQuantity: 2 }
]
```
## コードの例
`$bucket` コマンドを使用するためのコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const sales = db.collection('sales');
const result = await sales.aggregate([
{
$bucket: {
groupBy: "$price",
boundaries: [0, 10, 20, 30],
default: "Other",
output: {
"count": { $sum: 1 },
"totalQuantity": { $sum: "$quantity" }
}
}
},
{
$sort: { _id: 1 }
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&lsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
sales = db['sales']
result = list(sales.aggregate([
{
'$bucket': {
'groupBy': '$price',
'boundaries': [0, 10, 20, 30],
'default': 'Other',
'output': {
'count': {'$sum': 1},
'totalQuantity': {'$sum': '$quantity'}
}
}
},
{
"$sort": { "_id": 1 }
}
]))
print(result)
client.close()
example()
```
------
# \$1ceil
バージョン 4.0 の新機能
Amazon DocumentDB の `$ceil`演算子は、MongoDB と同様に、数値を最も近い整数に切り上げます。これは、数値フィールドで数学演算を実行し、結果が整数であることを確認する必要がある場合に便利です。
**パラメータ**
+ `expression`: 切り上げる数値式。
## 例 (MongoDB シェル)
この例では、 `$ceil`演算子を使用して数値フィールドを四捨五入する方法を示します。
**サンプルドキュメントを作成する**
```
db.numbers.insertMany([
{ "_id": 1, "value": 3.14 },
{ "_id": 2, "value": -2.7 },
{ "_id": 3, "value": 0 }
])
```
**クエリの例**
```
db.numbers.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
])
```
**出力**
```
{ "_id": 1, "roundedUp": 4 }
{ "_id": 2, "roundedUp": -2 }
{ "_id": 3, "roundedUp": 0 }
```
## コードの例
`$ceil` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: {
"roundedUp": { $ceil: "$value" }
}}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.numbers
result = list(collection.aggregate([
{ '$project': {
"roundedUp": { '$ceil': "$value" }
}}
]))
print(result)
client.close()
example()
```
------
# \$1changeStream
Elastic クラスターではサポートされていません。
`$changeStream` 集約ステージは変更ストリームカーソルを開き、コレクションへのリアルタイムの変更をモニタリングします。挿入、更新、置換、または削除オペレーションが発生すると、変更イベントドキュメントが返されます。
**パラメータ**
+ `fullDocument`: 更新オペレーションのために完全なドキュメントを返すかどうかを指定します。オプションは `default` または `updateLookup` です。
+ `resumeAfter`: オプション。トークンを再開して、変更ストリームの特定のポイントから続行します。
+ `startAtOperationTime`: オプション。変更ストリームを開始するタイムスタンプ。
+ `allChangesForCluster`: オプション。ブール値。の場合`true`、 はクラスター全体のすべての変更を監視します (管理者データベース用）。`false` (デフォルト) の場合、 は指定されたコレクションのみを監視します。
## 例 (MongoDB シェル)
次の例は、 `$changeStream`ステージを使用してコレクションの変更をモニタリングする方法を示しています。
**クエリの例**
```
// Open change stream first
const changeStream = db.inventory.aggregate([
{ $changeStream: { fullDocument: "updateLookup" } }
]);
// In another session, insert a document
db.inventory.insertOne({ _id: 1, item: "Widget", qty: 10 });
// Back in the first session, read the change event
if (changeStream.hasNext()) {
print(tojson(changeStream.next()));
}
```
**出力**
```
{
_id: { _data: '...' },
operationType: 'insert',
clusterTime: Timestamp(1, 1234567890),
fullDocument: { _id: 1, item: 'Widget', qty: 10 },
ns: { db: 'test', coll: 'inventory' },
documentKey: { _id: 1 }
}
```
## コードの例
`$changeStream` 集約ステージを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('inventory');
// Open change stream
const changeStream = collection.watch([]);
changeStream.on('change', (change) => {
console.log('Change detected:', change);
});
// Simulate insert in another operation
setTimeout(async () => {
await collection.insertOne({ _id: 1, item: 'Widget', qty: 10 });
}, 1000);
// Keep connection open to receive changes
// In production, handle cleanup appropriately
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
import threading
import time
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['inventory']
# Open change stream
change_stream = collection.watch([])
# Insert document in separate thread after delay
def insert_doc():
time.sleep(1)
collection.insert_one({'_id': 1, 'item': 'Widget', 'qty': 10})
threading.Thread(target=insert_doc).start()
# Watch for changes
for change in change_stream:
print('Change detected:', change)
break # Exit after first change
client.close()
example()
```
------
# \$1cmp
Amazon DocumentDB の `$cmp`演算子は、2 つの値を比較し、相対的な順序を示す整数値を返すために使用されます。これは、2 つの式を比較し、最初の値がそれぞれ 2 番目の値より小さい、等しい、または大きいかどうかに応じて、-1、0、または 1 の整数値を返す比較演算子です。
**パラメータ**
+ `expression1`: 比較する最初の式。
+ `expression2`: 比較する 2 番目の式。
## 例 (MongoDB シェル)
次の例は、`$cmp`演算子を使用して 2 つの数値を比較する方法を示しています。
**サンプルドキュメントを作成する**
```
db.collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
```
**クエリの例**
```
db.collection.find({
$expr: {
$cmp: ["$value1", "$value2"]
}
})
```
**出力**
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
この例では、 `$cmp`演算子は各ドキュメントの フィールド`value1`と `value2`フィールドを比較します。結果は、次のとおりです。
```
- `$cmp: ["$value1", "$value2"]` returns -1 for the first document (10 < 20), 0 for the second document (15 = 15), and 1 for the third document (20 > 10).
```
## コードの例
`$cmp` コマンドを使用するためのコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
`mongodb` ドライバーで Node.js アプリケーションで `$cmp`演算子を使用する例を次に示します。
```
const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
async function main() {
await client.connect();
const db = client.db('test');
const collection = db.collection('mycollection');
// Insert sample documents
await collection.insertMany([
{ _id: 1, value1: 10, value2: 20 },
{ _id: 2, value1: 15, value2: 15 },
{ _id: 3, value1: 20, value2: 10 }
]);
// Query using $cmp operator
const result = await collection.find({
$expr: {
$cmp: ['$value1', '$value2']
}
}).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
`pymongo` ドライバーで Python アプリケーションで `$cmp`演算子を使用する例を次に示します。
```
from pymongo import MongoClient
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['mycollection']
# Insert sample documents
collection.insert_many([
{'_id': 1, 'value1': 10, 'value2': 20},
{'_id': 2, 'value1': 15, 'value2': 15},
{'_id': 3, 'value1': 20, 'value2': 10}
])
# Query using $cmp operator
result = list(collection.find({
'$expr': {
'$cmp': ['$value1', '$value2']
}
}))
print(result)
client.close()
```
Node.js と Python の両方の例の出力は、MongoDB シェルの例と同じになります。
```
[
{ "_id" : 1, "value1" : 10, "value2" : 20 },
{ "_id" : 2, "value1" : 15, "value2" : 15 },
{ "_id" : 3, "value1" : 20, "value2" : 10 }
]
```
------
# \$1collStats
バージョン 4.0 の新機能
Amazon DocumentDB の`$collStats`集約ステージは、MongoDB シェルの `db.collection.stats()` コマンドと同様に、指定されたコレクションに関する統計を提供します。このステージを使用して、ドキュメントの数、コレクションの合計サイズ、さまざまなパフォーマンスメトリクスなど、コレクションに関する情報を取得できます。
**パラメータ**
+ `latencyStats`: (オプション) レイテンシー統計を収集するためのオプションを指定するドキュメント。このパラメータは Amazon DocumentDB ではサポートされていません。
+ `recordStats`: (オプション) レコード統計を収集するためのオプションを指定するドキュメント。このパラメータは Amazon DocumentDB ではサポートされていません。
+ `queryExecStats`: (オプション) クエリ実行統計を収集するためのオプションを指定するドキュメント。このパラメータは Amazon DocumentDB ではサポートされていません。
## 例 (MongoDB シェル)
次の例は、`$collStats`集約ステージを使用して、`db`データベース`test`内の という名前のコレクションに関する統計を取得する方法を示しています。
**サンプルドキュメントを作成する**
```
db.test.insertMany([
{ "name": "John", "age": 30 },
{ "name": "Jane", "age": 25 },
{ "name": "Bob", "age": 35 }
]);
```
**クエリの例**
```
db.test.aggregate([
{ $collStats: {} }
]);
```
**出力**
```
{
"ns" : "db.test",
"count" : 3,
"size" : 87,
"avgObjSize" : 29,
"storageSize" : 40960,
"capped" : false,
"nindexes" : 1,
"totalIndexSize" : 8192,
"indexSizes" : {
"_id_" : 8192
},
"collScans" : 0,
"idxScans" : 0,
"opCounter" : {
"numDocsIns" : 3,
"numDocsUpd" : 0,
"numDocsDel" : 0
},
"cacheStats" : {
"collBlksHit" : 0,
"collBlksRead" : 0,
"collHitRatio" : 0,
"idxBlksHit" : 0,
"idxBlksRead" : 0,
"idxHitRatio" : 0
},
"lastReset" : "2023-04-11T12:00:00Z",
"ok" : 1,
"operationTime" : Timestamp(1681206000, 1)
}
```
## コードの例
`$collStats` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
以下は、公式の MongoDB Node.js ドライバーを使用して Node.js アプリケーションで`$collStats`集約ステージを使用する方法の例です。
```
const { MongoClient } = require('mongodb');
async function runCollStatsExample() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('db');
const collection = db.collection('test');
const result = await collection.aggregate([
{ $collStats: {} }
]).toArray();
console.log(result);
await client.close();
}
runCollStatsExample();
```
------
#### [ Python ]
PyMongo ドライバーを使用して Python アプリケーションで`$collStats`集約ステージを使用する方法の例を次に示します。
```
from pymongo import MongoClient
def run_coll_stats_example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['db']
collection = db['test']
result = list(collection.aggregate([
{ '$collStats': {} }
]))
print(result)
client.close()
run_coll_stats_example()
```
------
# \$1concat
Amazon DocumentDB の`$concat`集計演算子は、ドキュメント内の複数の文字列を連結 (または結合) して、アプリケーションに返すことができる単一の文字列を生成します。これにより、文字列操作がデータベースレベルで実行されるため、アプリケーションで実行される作業が減ります。
**パラメータ**
+ `expression1`: 連結する最初の文字列。
+ `expression2`: 連結する 2 番目の文字列。
+ `...`: 連結する追加の文字列 (オプション）。
## 例 (MongoDB シェル)
この例では、ユーザーの姓名を連結して、各ユーザーのフルネームを生成します。
**サンプルドキュメントを作成する**
```
db.people.insertMany([
{ "_id":1, "first_name":"Jane", "last_name":"Doe", "DOB":"2/1/1999", "Desk": "MSP102-MN"},
{ "_id":2, "first_name":"John", "last_name":"Doe", "DOB":"12/21/1992", "Desk": "DSM301-IA"},
{ "_id":3, "first_name":"Steve", "last_name":"Smith", "DOB":"3/21/1981", "Desk":"MKE233-WI"}
])
```
**クエリの例**
```
db.people.aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
])
```
**出力**
```
{ "_id" : 1, "full_name" : "Jane Doe" }
{ "_id" : 2, "full_name" : "John Doe" }
{ "_id" : 3, "full_name" : "Steve Smith" }
```
## コードの例
`$concat` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function concatenateNames() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const result = await db.collection('people').aggregate([
{ $project: { full_name: { $concat: [ "$first_name", " ", "$last_name"] } } }
]).toArray();
console.log(result);
await client.close();
}
concatenateNames();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def concatenate_names():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
result = list(db.people.aggregate([
{ '$project': { 'full_name': { '$concat': [ '$first_name', ' ', '$last_name' ] } } }
]))
print(result)
client.close()
concatenate_names()
```
------
# \$1concatArrays
Amazon DocumentDB の`$concatArrays`集計演算子は、2 つ以上の配列を 1 つの配列に連結するために使用されます。これは、データの複数の配列を 1 つの配列に結合して、さらに処理または分析する必要がある場合に便利です。
**パラメータ**
+ `array1`: 連結する最初の配列。
+ `array2`: 連結する 2 番目の配列。
+ `[array3, ...]`: (オプション) 連結する追加の配列。
## 例 (MongoDB シェル)
次の例は、 `$concatArrays`演算子を使用して 2 つの配列を 1 つの配列に結合する方法を示しています。
**サンプルドキュメントを作成する**
```
db.collection.insertMany([
{
"_id": 1,
"name": "John Doe",
"hobbies": ["reading", "swimming"],
"skills": ["programming", "design"]
},
{
"_id": 2,
"name": "Jane Smith",
"hobbies": ["hiking", "cooking"],
"skills": ["marketing", "analysis"]
}
]);
```
**クエリの例**
```
db.collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ["$hobbies", "$skills"] }
}
}
]);
```
**出力**
```
[
{
"name": "John Doe",
"all_activities": [
"reading",
"swimming",
"programming",
"design"
]
},
{
"name": "Jane Smith",
"all_activities": [
"hiking",
"cooking",
"marketing",
"analysis"
]
}
]
```
## コードの例
`$concatArrays` コマンドを使用するためのコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('mydb');
const collection = db.collection('mycollection');
const result = await collection.aggregate([
{
$project: {
_id: 0,
name: 1,
all_activities: { $concatArrays: ['$hobbies', '$skills'] }
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['mydb']
collection = db['mycollection']
result = list(collection.aggregate([
{
'$project': {
'_id': 0,
'name': 1,
'all_activities': { '$concatArrays': ['$hobbies', '$skills'] }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1cond
Amazon DocumentDB の `$cond`演算子は、条件式を評価し、2 つの可能な結果式のいずれかを返すために使用されます。
**パラメータ**
+ `if`: 評価するブール式。
+ `then`: 式が true の場合に返される`if`式。
+ `else`: 式が false の場合に返される`if`式。
## 例 (MongoDB シェル)
次の例は、 `$cond`演算子を使用して、人の年齢に基づいて値を返す方法を示しています。
**サンプルドキュメントを作成する**
```
db.people.insertMany([
{ _id: 1, name: "John Doe", age: 35 },
{ _id: 2, name: "Jane Doe", age: 25 },
{ _id: 3, name: "Bob Smith", age: 65 }
]);
```
**クエリの例**
```
db.people.aggregate([
{
$project: {
name: 1,
ageGroup: {
$cond: {
if: { $lt: ["$age", 30] },
then: "young",
else: {
$cond: {
if: { $lt: ["$age", 65] },
then: "middle-aged",
else: "elderly"
}
}
}
}
}
}
])
```
**出力**
```
[
{ "_id" : 1, "name" : "John Doe", "ageGroup" : "middle-aged" },
{ "_id" : 2, "name" : "Jane Doe", "ageGroup" : "young" },
{ "_id" : 3, "name" : "Bob Smith", "ageGroup" : "elderly" }
]
```
## コードの例
`$cond` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('people');
const result = await collection.aggregate([
{ $project: {
name: 1,
ageGroup: {
$cond: {
if: { $lt: ["$age", 30] },
then: "young",
else: {
$cond: {
if: { $lt: ["$age", 65] },
then: "middle-aged",
else: "elderly"
}
}
}
}
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.people
result = list(collection.aggregate([
{
'$project': {
'name': 1,
'ageGroup': {
'$cond': {
'if': { '$lt': ["$age", 30]},
'then': "young",
'else': {
'$cond': {
'if': { '$lt': ["$age", 65]},
'then': "middle-aged",
'else': "elderly"
}
}
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1convert
バージョン 4.0 の新機能
Amazon DocumentDB の `$convert`演算子は、あるデータ型から別のデータ型に値を変換するために使用されます。この演算子は、文字列を数値に変換したり、日付をタイムスタンプに変換したりするなど、さまざまなタイプのデータに対してオペレーションを実行する必要がある場合に便利です。
**パラメータ**
+ `to`: 値を変換するターゲットデータ型。サポートされている値は `"string"`、`"double"`、`"long"`、`"int"`、`"date"`、`"boolean"` です。
+ `from`: 値の現在のデータ型。指定しない場合、Amazon DocumentDB はデータ型を自動的に検出しようとします。
+ `onError`: (オプション) 変換が失敗した場合に返される値。特定の値、または次の特殊な値のいずれかを指定できます: `"null"`、`"zerofill"`、または `"error"`。
+ `onNull`: (オプション) 入力値が の場合に返される値`null`。特定の値、または次の特殊な値のいずれかを指定できます: `"null"`、`"zerofill"`、または `"error"`。
## 例 (MongoDB シェル)
次の例は、 `$convert`演算子を使用して文字列値を日付に変換する方法を示しています。
**サンプルドキュメントを作成する**
```
db.users.insertMany([
{ _id: 1, name: "John Doe", joinedOn: "2022-01-01" },
{ _id: 2, name: "Jane Smith", joinedOn: "2023-02-15" },
{ _id: 3, name: "Bob Johnson", joinedOn: "invalid date" }
]);
```
**クエリの例**
```
db.users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
])
```
**出力**
```
[
{ "_id" : 1, "name" : "John Doe", "joinedOn" : ISODate("2022-01-01T00:00:00Z") },
{ "_id" : 2, "name" : "Jane Smith", "joinedOn" : ISODate("2023-02-15T00:00:00Z") },
{ "_id" : 3, "name" : "Bob Johnson", "joinedOn" : null }
]
```
## コードの例
`$convert` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require("mongodb");
async function example() {
const client = await MongoClient.connect("mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false");
const db = client.db("test");
const users = db.collection("users");
const results = await users.aggregate([
{
$project: {
_id: 1,
name: 1,
joinedOn: {
$convert: {
input: "$joinedOn",
to: "date",
onError: "null",
onNull: "null"
}
}
}
}
]).toArray();
console.log(results);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient("mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false")
db = client["test"]
users = db["users"]
results = list(users.aggregate([
{
"$project": {
"_id": 1,
"name": 1,
"joinedOn": {
"$convert": {
"input": "$joinedOn",
"to": "date",
"onError": "null",
"onNull": "null"
}
}
}
}
]))
print(results)
client.close()
example()
```
------
# \$1count
Amazon DocumentDB の`$count`集約ステージは、ステージに渡すドキュメントの数をカウントするために使用されます。多くの場合、前のステージに一致するドキュメントの合計数を返すために、集約パイプラインの最終ステージとして使用されます。
**パラメータ**
+ `field`: カウントするフィールド。このパラメータはオプションであり、指定しない場合、ステージは入力ドキュメントの総数をカウントします。
## 例 (MongoDB シェル)
次の例は、 `$count`ステージを使用してコレクション内のドキュメントの総数を取得する方法を示しています。
**サンプルドキュメントを作成する**
```
db.users.insertMany([
{ name: "John", age: 30 },
{ name: "Jane", age: 25 },
{ name: "Bob", age: 35 },
{ name: "Alice", age: 28 }
]);
```
**クエリの例**
```
db.users.aggregate([
{ $count: "total" }
]);
```
**出力**
```
{ "total" : 4 }
```
この例では、`users`コレクションを集約し、 `$count`ステージを使用してドキュメントの総数をカウントします。
## コードの例
`$count` コマンドを使用するためのコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function countDocuments() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('mydb');
const collection = db.collection('users');
const result = await collection.aggregate([
{ $count: "total" }
]).toArray();
console.log(result[0].total);
await client.close();
}
countDocuments();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def count_documents():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['mydb']
collection = db['users']
result = list(collection.aggregate([
{ '$count': "total" }
]))
print(result[0]['total'])
client.close()
count_documents()
```
------
# \$1currentOp
`$currentOp` 集約ステージは、データベースで現在実行中のオペレーションに関する情報を返します。このステージは、集約パイプラインでアクティブなクエリとオペレーションをモニタリングするのに役立ちます。
**パラメータ**
+ `allUsers` (オプション): に設定すると`true`、 はすべてのユーザーのオペレーションを返します。デフォルトは `false` です。
+ `idleConnections` (オプション): に設定すると`true`、 にはアイドル接続が含まれます。デフォルトは `false` です。
+ `idleCursors` (オプション): に設定すると`true`、 にはアイドルカーソルに関する情報が含まれます。デフォルトは `false` です。
+ `idleSessions` (オプション): に設定すると`true`、 にはアイドルセッションに関する情報が含まれます。デフォルトは `true` です。
+ `localOps` (オプション): に設定すると`true`、 にはローカルオペレーションが含まれます。デフォルトは `false` です。
## 例 (MongoDB シェル)
次の例は、`$currentOp`集約ステージを使用してアクティブな読み取りオペレーションに関する情報を取得する方法を示しています。
**クエリの例**
```
db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
])
```
**出力**
```
[
{
"opid": "12345",
"active": true,
"op": "query",
"ns": "test.users",
"secs_running": 2
}
]
```
## コードの例
`$currentOp` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('admin');
const result = await db.aggregate([
{ $currentOp: { allUsers: true, idleConnections: false } },
{ $match: { op: "query" } }
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['admin']
result = list(db.aggregate([
{ '$currentOp': { 'allUsers': True, 'idleConnections': False } },
{ '$match': { 'op': 'query' } }
]))
print(result)
client.close()
example()
```
------
# \$1dateAdd
バージョン 5.0 の新機能
Amazon DocumentDB の`$dateAdd`集計演算子を使用すると、日付と時刻の値に期間を追加できます。
**パラメータ**
+ `date`: 期間を追加する日付と時刻の値。
+ `duration`: `date`値に追加する期間。これは、、`years`、、`months`、`weeks`、、`days``hours``minutes`および のキーを持つオブジェクトとして指定できます`seconds`。
+ `timezone`: (オプション) 日付の追加を実行するときに使用するタイムゾーン。指定しない場合、Amazon DocumentDB クラスターのデフォルトのタイムゾーンが使用されます。
## 例 (MongoDB シェル)
次の例は、 `$dateAdd`演算子を使用して日付に 2 日と 12 時間を追加する方法を示しています。
**サンプルドキュメントを作成する**
```
db.events.insertMany([
{ _id: 1, eventDate: ISODate("2023-04-01T10:00:00Z") },
{ _id: 2, eventDate: ISODate("2023-04-02T12:00:00Z") },
{ _id: 3, eventDate: ISODate("2023-04-03T14:00:00Z") }
]);
```
**クエリの例**
```
db.events.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
])
```
**出力**
```
[
{
"_id": 1,
"eventDate": "2023-04-01T10:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-03T22:00:00Z)"
},
{
"_id": 2,
"eventDate": "2023-04-02T12:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-05T00:00:00Z)"
},
{
"_id": 3,
"eventDate": "2023-04-03T14:00:00Z",
"eventDatePlustwodaysandtwelvehours": ISODate("2023-04-06T02:00:00Z)"
}
]
```
## コードの例
`$dateAdd` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('events');
const result = await collection.aggregate([
{
$project: {
_id: 1,
eventDate: 1,
eventDatePlustwodaysandtwelvehours: {
$dateAdd: {
startDate: {
$dateAdd: {
startDate: "$eventDate",
unit: "day",
amount: 2
}
},
unit: "hour",
amount: 12
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from bson.date_time import datetime
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['events']
result = list(collection.aggregate([
{
'$project': {
'_id': 1,
'eventDate': 1,
'eventDatePlustwodaysandtwelvehours': {
'$dateAdd': {
'startDate': {
'$dateAdd' : {
'startDate': '$eventDate',
'unit': 'day',
'amount': 2,
}
},
'unit': 'hour',
'amount': 12,
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateDiff
バージョン 5.0 の新機能
Elastic クラスターではサポートされていません。
`$dateDiff` 集計演算子は、指定された単位で 2 つの日付の差を計算します。開始日と終了日の間の単位境界の数を返します。
**パラメータ**
+ `startDate`: 開始日の式。
+ `endDate`: 終了日式。
+ `unit`: 差の時間単位。サポートされている単位は、`year`、、`quarter`、`month`、`week`、`day`、`hour``minute``second`、、および です`millisecond`。
## 例 (MongoDB シェル)
次の例は、 `$dateDiff`演算子を使用して、注文から配送までの日数を計算する方法を示しています。
**サンプルドキュメントを作成する**
```
db.shipments.insertMany([
{
orderId: 1001,
orderDate: ISODate("2025-01-10T08:00:00Z"),
deliveryDate: ISODate("2025-01-15T14:30:00Z")
},
{
orderId: 1002,
orderDate: ISODate("2025-02-05T10:00:00Z"),
deliveryDate: ISODate("2025-02-12T16:45:00Z")
}
]);
```
**クエリの例**
```
db.shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]);
```
**出力**
```
[
{
_id: ObjectId('6924a5f2d66dcae121d29517'),
orderId: 1001,
orderDate: ISODate('2025-01-10T08:00:00.000Z'),
deliveryDate: ISODate('2025-01-15T14:30:00.000Z'),
daysToDeliver: 5
},
{
_id: ObjectId('6924a5f2d66dcae121d29518'),
orderId: 1002,
orderDate: ISODate('2025-02-05T10:00:00.000Z'),
deliveryDate: ISODate('2025-02-12T16:45:00.000Z'),
daysToDeliver: 7
}
]
```
## コードの例
`$dateDiff` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const shipments = db.collection('shipments');
const result = await shipments.aggregate([
{
$project: {
orderId: 1,
orderDate: 1,
deliveryDate: 1,
daysToDeliver: {
$dateDiff: {
startDate: "$orderDate",
endDate: "$deliveryDate",
unit: "day"
}
}
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
shipments = db['shipments']
result = list(shipments.aggregate([
{
"$project": {
"orderId": 1,
"orderDate": 1,
"deliveryDate": 1,
"daysToDeliver": {
"$dateDiff": {
"startDate": "$orderDate",
"endDate": "$deliveryDate",
"unit": "day"
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateFromString
Amazon DocumentDB の`$dateFromString`集計演算子を使用すると、日時文字列を日付オブジェクトに変換できます。これは、データが文字列として保存されているが、データに対して日付ベースのオペレーションを実行する必要がある場合に便利です。
**パラメータ**
+ `dateString`: 日付と時刻を表す文字列。
+ `format`: (オプション) の形式を指定する文字列`dateString`。指定しない場合、Amazon DocumentDB は ISO-8601 形式で文字列の解析を試みます。
+ `timezone`: (オプション) タイムゾーンを指定する文字列。指定しない場合、Amazon DocumentDB はサーバーのタイムゾーンを使用します。
+ `onError`: (オプション) 変換が失敗した場合に実行するアクションを指定します。指定できる値は、 `'error'` (エラーをスローするデフォルト）、 `'null'` ( を返す`null`)、または `'replace'` ( 値を `onErrorMessage`オプションで指定された置換文字列に置き換えます) です。
+ `onErrorMessage`: (オプション) `onError`が に設定されている場合`'replace'`、このオプションは置き換え文字列を指定します。
## 例 (MongoDB シェル)
次の例は、 `$dateFromString`を使用して Amazon DocumentDB の日付文字列を日付オブジェクトに変換する方法を示しています。
**サンプルドキュメントを作成する**
```
db.missionLog.insertMany([
{ _id: 1, event: "missionStart", logDate: "2020-03-15T13:41:33"},
{ _id: 2, event: "jumpPoint1", logDate: "2020-03-15T13:45:34"},
{ _id: 3, event: "jumpPoint2", logDate: "2020-03-15T13:48:21"},
{ _id: 4, event: "jumpPoint3", logDate: "2020-03-15T13:52:09"},
{ _id: 5, event: "missionEnd", logDate: "2020-03-15T13:58:44"}
]);
```
**クエリの例**
```
db.missionLog.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]);
```
**出力**
```
[
{
"_id": 1,
"event": "missionStart",
"logDate": ISODate("2020-03-15T13:41:33Z")
},
{
"_id": 2,
"event": "jumpPoint1",
"logDate": ISODate("2020-03-15T13:45:34Z")
},
{
"_id": 3,
"event": "jumpPoint2",
"logDate": ISODate("2020-03-15T13:48:21Z")
},
{
"_id": 4,
"event": "jumpPoint3",
"logDate": ISODate("2020-03-15T13:52:09Z")
},
{
"_id": 5,
"event": "missionEnd",
"logDate": ISODate("2020-03-15T13:58:44Z")
}
]
```
## コードの例
`$dateFromString` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('missionLog');
const result = await collection.aggregate([
{
$project: {
event: '$event',
logDate: {
$dateFromString: {
dateString: '$logDate'
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['missionLog']
result = list(collection.aggregate([
{
'$project': {
'event': '$event',
'logDate': {
'$dateFromString': {
'dateString': '$logDate'
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateSubtract
バージョン 5.0 の新機能
Amazon DocumentDB の`$dateSubtract`集計演算子を使用すると、指定された期間を日付値から減算できます。
**パラメータ**
+ `date`: 日付またはタイムスタンプに解決される日付式。
+ `subtrahend`: 式から減算する時間を指定する期間`date`式。
+ `unit`: `subtrahend`式の時間単位を指定する文字列。サポートされている単位は、「年」、「四半期」、「月」、「週」、「日」、「時間」、「分」、「秒」、「ミリ秒」です。
## 例 (MongoDB シェル)
次の例は、 `$dateSubtract`演算子を使用して、現在の日付から 1 年前の日付を計算する方法を示しています。
**サンプルドキュメントを作成する**
```
db.events.insertOne({
eventName: "Player joined",
eventTime: ISODate("2023-04-01T12:00:00Z")
});
```
**クエリの例**
```
db.events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
])
```
**出力**
```
{
"_id" : ObjectId("64567890abcdef012345678"),
"eventName" : "Player joined",
"oneYearAgo" : ISODate("2022-04-01T12:00:00Z")
}
```
## コードの例
`$dateSubtract` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const events = db.collection('events');
const result = await events.aggregate([
{
$project: {
eventName: 1,
oneYearAgo: {
$dateSubtract: {
startDate: "$eventTime",
amount: 1,
unit: "year"
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from bson.date_time import datetime
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
events = db['events']
result = list(events.aggregate([
{
'$project': {
'eventName': 1,
'oneYearAgo': {
'$dateSubtract': {
'startDate': '$eventTime',
'amount': 1,
'unit': 'year'
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dateToString
Amazon DocumentDB の`$dateToString`集計演算子は、日付またはタイムスタンプの値を文字列表現に変換するために使用されます。これは、表示またはさらなる処理のために特定の方法で日付と時刻をフォーマットする必要がある場合に便利です。
**パラメータ**
+ `date`: 文字列に変換される日付またはタイムスタンプの値。
+ `format`: 日付を表す形式を指定する文字列。形式文字列には、4 桁の年`%Y`、`%m`2 桁の月、2 `%d`桁の日など、さまざまな形式指定子を含めることができます。
+ `timezone`: (オプション) 変換に使用するタイムゾーン。指定しない場合、Amazon DocumentDB クラスターをホストするサーバーのタイムゾーンが使用されます。
+ `onNull`: (オプション) `date`パラメータが の場合に返される値`null`。
## 例 (MongoDB シェル)
次の例は、 `$dateToString`演算子を使用して`missionLog`コレクションの `logDate`フィールドをフォーマットする方法を示しています。
**サンプルドキュメントを作成する**
```
db.missionLog.insertMany([
{ _id: 1, "event":"missionStart", logDate: new Date("2020-03-15T13:41:33Z") },
{ _id: 2, "event":"jumpPoint1", logDate: new Date("2020-03-15T13:45:34Z") },
{ _id: 3, "event":"jumpPoint2", logDate: new Date("2020-03-15T13:48:21Z") },
{ _id: 4, "event":"jumpPoint3", logDate: new Date("2020-03-15T13:52:09Z") },
{ _id: 5, "event":"missionEnd", logDate: new Date("2020-03-15T13:58:44Z") }
]);
```
**クエリの例**
```
db.missionLog.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
])
```
**出力**
```
[
{
"_id": 1,
"event": "missionStart",
"logDateFormatted": "2020-03-15 13:41:33"
},
{
"_id": 2,
"event": "jumpPoint1",
"logDateFormatted": "2020-03-15 13:45:34"
},
{
"_id": 3,
"event": "jumpPoint2",
"logDateFormatted": "2020-03-15 13:48:21"
},
{
"_id": 4,
"event": "jumpPoint3",
"logDateFormatted": "2020-03-15 13:52:09"
},
{
"_id": 5,
"event": "missionEnd",
"logDateFormatted": "2020-03-15 13:58:44"
}
]
```
## コードの例
`$dateToString` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
Node.js アプリケーションで `$dateToString`演算子を使用する例を次に示します。
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('missionLog');
const result = await collection.aggregate([
{
$project: {
event: "$event",
logDateFormatted: {
$dateToString: {
format: "%Y-%m-%d %H:%M:%S",
date: "$logDate"
}
}
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
Python アプリケーションで `$dateToString`演算子を使用する例を次に示します。
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['missionLog']
pipeline = [
{
'$project': {
'event': '$event',
'logDateFormatted': {
'$dateToString': {
'format': '%Y-%m-%d %H:%M:%S',
'date': '$logDate'
}
}
}
}
]
result = list(collection.aggregate(pipeline))
print(result)
client.close()
example()
```
------
# \$1dateTrunc
バージョン 8.0 の新機能
Elastic クラスターではサポートされていません。
Amazon DocumentDB の`$dateTrunc`集計演算子は、指定された単位に日付を切り捨てます。
**パラメータ**
+ `date`: 日付またはタイムスタンプに解決される日付式。
+ `unit`: サブtrahend 式の時間単位を指定する文字列。サポートされている単位は、`year`、、`quarter`、`month`、`week`、`day`、`hour``minute``second`、、および です`millisecond`。
## 例 (MongoDB シェル)
次の例は、 `$dateTrunc`演算子を使用して日付を に切り捨てて 1 時間にする方法を示しています。
**サンプルドキュメントを作成する**
```
db.events.insertMany([
{
eventName: "Event 1",
eventTime: ISODate("2025-04-01T12:15:00Z")
},
{
eventName: "Event 2",
eventTime: ISODate("2025-08-15T14:33:22Z")
},
]);
```
**クエリの例**
```
db.events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]);
```
**出力**
```
[
{
_id: ObjectId('6924a258d66dcae121d29515'),
eventName: 'Event 1',
eventTime: ISODate('2025-04-01T12:15:00.000Z'),
truncatedToHour: ISODate('2025-04-01T12:00:00.000Z')
},
{
_id: ObjectId('6924a258d66dcae121d29516'),
eventName: 'Event 2',
eventTime: ISODate('2025-08-15T14:33:22.000Z'),
truncatedToHour: ISODate('2025-08-15T14:00:00.000Z')
}
]
```
## コードの例
`$dateTrunc` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const events = db.collection('events');
const result = await events.aggregate([
{
$project: {
eventName: 1,
eventTime: 1,
truncatedToHour: {
$dateTrunc: {
date: "$eventTime",
unit: "hour"
}
}
}
}
]).toArray();
console.log(result);
client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
events = db['events']
result = list(events.aggregate([
{
"$project": {
"eventName": 1,
"eventTime": 1,
"truncatedToHour": {
"$dateTrunc": {
"date": "$eventTime",
"unit": "hour"
}
}
}
}
]))
print(result)
client.close()
example()
```
------
# \$1dayOfMonth
Amazon DocumentDB の`$dayOfMonth`集計演算子は、特定の日付の日 (1～31) を取得します。この演算子は、ドキュメントの日付フィールドから日付をグループ化、フィルタリング、または抽出するのに役立ちます。
**パラメータ**
+ `date expression`: 日付式は、ドキュメントの日付フィールド、日付オブジェクト、または日付文字列です。
## 例 (MongoDB シェル)
この例では、 `$dayOfMonth`演算子を使用してドキュメントの日付フィールドから日付を抽出する方法を示します。
**サンプルドキュメントを作成する**
```
db.events.insertMany([
{ _id: 1, eventDate: new Date("2022-01-15T12:00:00Z") },
{ _id: 2, eventDate: new Date("2022-02-28T15:30:00Z") },
{ _id: 3, eventDate: new Date("2022-03-01T09:45:00Z") },
{ _id: 4, eventDate: new Date("2022-04-30T23:59:59Z") }
]);
```
**クエリの例**
```
db.events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
])
```
**出力**
```
[
{ "_id" : 1, "eventDay" : 15 },
{ "_id" : 2, "eventDay" : 28 },
{ "_id" : 3, "eventDay" : 1 },
{ "_id" : 4, "eventDay" : 30 }
]
```
## コードの例
`$dayOfMonth` コマンドを使用するためのコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const events = db.collection('events');
const result = await events.aggregate([
{ $project: {
eventDay: { $dayOfMonth: "$eventDate" }
}}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.mydatabase
events = db.events
result = list(events.aggregate([
{ "$project": {
"eventDay": { "$dayOfMonth": "$eventDate" }
}}
]))
print(result)
client.close()
example()
```
------
# \$1dayOfWeek
Amazon DocumentDB の `$dayOfWeek`演算子は、特定の日付フィールドから曜日を抽出します。曜日を 1 (日曜日) から 7 (土曜日) までの数値として返します。これは MongoDB と同じ動作です。
**パラメータ**
+ `date field`: 曜日を抽出する日付フィールド。
## 例 (MongoDB シェル)
この例では、 `$dayOfWeek`演算子を使用して、`weather`コレクションの `date`フィールドから曜日を抽出する方法を示します。
**サンプルドキュメントを作成する**
```
db.weather.insertMany([
{
"temperature": 97.5,
"humidity": 0.60,
"date": new Date("2023-04-01")
},
{
"temperature": 95.2,
"humidity": 0.55,
"date": new Date("2023-04-02")
},
{
"temperature": 92.8,
"humidity": 0.65,
"date": new Date("2023-04-03")
}
]);
```
**クエリの例**
```
db.weather.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: "$date" }
}
}
]).pretty();
```
**出力**
```
{ "_id" : ObjectId("64272c6663f4f8ce422c2d91"), "dayOfWeek" : 7 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d92"), "dayOfWeek" : 1 }
{ "_id" : ObjectId("64272c6663f4f8ce422c2d93"), "dayOfWeek" : 2 }
```
## コードの例
`$dayOfWeek` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function main() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('weather');
const result = await collection.aggregate([
{
$project: {
dayOfWeek: { $dayOfWeek: '$date' }
}
}
]).toArray();
console.log(result);
await client.close();
}
main();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def main():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.weather
result = list(collection.aggregate([
{
'$project': {
'dayOfWeek': { '$dayOfWeek': '$date' }
}
}
]))
print(result)
client.close()
if __name__ == '__main__':
main()
```
------
# \$1dayOfYear
Amazon DocumentDB の`$dayOfYear`演算子は、日付の日を 1～366 (うるう年以外の場合は 365) の数値として返します。
**パラメータ**
+ `expression`: 日を抽出する日付フィールドまたは式。
## 例 (MongoDB シェル)
この例では、 `$dayOfYear`演算子を使用して Amazon DocumentDB コレクションの日付フィールドから日付を抽出する方法を示します。
**サンプルドキュメントを作成する**
```
db.weather.insert([
{
"temperature" : 97.5,
"humidity": 0.60,
"date" : new Date("2023-03-15")
},
{
"temperature" : 82.3,
"humidity": 0.75,
"date" : new Date("2023-12-31")
}
])
```
**クエリの例**
```
db.weather.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).pretty()
```
**出力**
```
{ "_id" : ObjectId("642b86fc7d8e07af279bbe63"), "dayOfYear" : 74 }
{ "_id" : ObjectId("642b86fc7d8e07af279bbe64"), "dayOfYear" : 365 }
```
## コードの例
`$dayOfYear` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('weather');
const result = await collection.aggregate([
{
$project: {
dayOfYear: { $dayOfYear: "$date" }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['weather']
result = list(collection.aggregate([
{
'$project': {
'dayOfYear': { '$dayOfYear': '$date' }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1divide
Amazon DocumentDB 集約パイプラインの `$divide`演算子は、ある数値を別の数値で割るために使用されます。これは、ドキュメント内の数値フィールドに対して数学演算を実行するのに便利な演算子です。
**パラメータ**
+ `numerator`: 分割する分配または数値。
+ `denominator`: 除算器または除算する数値。
## 例 (MongoDB シェル)
この例では、 `$divide`演算子を使用して、年間給与と 1 年あたりの勤務時間数に基づいて従業員の時間単価を計算する方法を示します。
**サンプルドキュメントを作成する**
```
db.employees.insertMany([
{ _id: 1, name: "John Doe", salary: 80000, hoursPerYear: 2080 },
{ _id: 2, name: "Jane Smith", salary: 90000, hoursPerYear: 2080 },
{ _id: 3, name: "Bob Johnson", salary: 75000, hoursPerYear: 2080 }
]);
```
**クエリの例**
```
db.employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
])
```
**出力**
```
[
{ "_id" : 1, "name" : "John Doe", "hourlyRate" : 38.46153846153846 },
{ "_id" : 2, "name" : "Jane Smith", "hourlyRate" : 43.26923076923077 },
{ "_id" : 3, "name" : "Bob Johnson", "hourlyRate" : 36.05769230769231 }
]
```
## コードの例
`$divide` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function calculateHourlyRate() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const employees = db.collection('employees');
const result = await employees.aggregate([
{
$project: {
name: 1,
hourlyRate: { $divide: ["$salary", "$hoursPerYear"] }
}
}
]).toArray();
console.log(result);
client.close();
}
calculateHourlyRate();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def calculate_hourly_rate():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.mydatabase
employees = db.employees
result = list(employees.aggregate([
{
'$project': {
'name': 1,
'hourlyRate': { '$divide': ['$salary', '$hoursPerYear'] }
}
}
]))
print(result)
client.close()
calculate_hourly_rate()
```
------
# \$1eq
`$eq` 集計演算子は 2 つの値を比較し、等しい`true`場合は を返し、そうでない場合は を返します`false`。
**パラメータ**
+ `expression1`: 比較する最初の値。
+ `expression2`: 比較する 2 番目の値。
## 例 (MongoDB シェル)
次の例は、 `$eq`演算子を使用して、製品数量がターゲット値と一致するかどうかを確認する方法を示しています。
**サンプルドキュメントを作成する**
```
db.inventory.insertMany([
{ _id: 1, item: "Widget", qty: 50, target: 50 },
{ _id: 2, item: "Gadget", qty: 30, target: 50 },
{ _id: 3, item: "Tool", qty: 50, target: 40 }
]);
```
**クエリの例**
```
db.inventory.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]);
```
**出力**
```
[
{ _id: 1, item: 'Widget', qty: 50, target: 50, meetsTarget: true },
{ _id: 2, item: 'Gadget', qty: 30, target: 50, meetsTarget: false },
{ _id: 3, item: 'Tool', qty: 50, target: 40, meetsTarget: false }
]
```
## コードの例
`$eq` 集計演算子を使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('inventory');
const result = await collection.aggregate([
{
$project: {
item: 1,
qty: 1,
target: 1,
meetsTarget: { $eq: ["$qty", "$target"] }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['inventory']
result = list(collection.aggregate([
{
'$project': {
'item': 1,
'qty': 1,
'target': 1,
'meetsTarget': { '$eq': ['$qty', '$target'] }
}
}
]))
print(result)
client.close()
example()
```
------
# \$1exp
バージョン 4.0 の新機能
Amazon DocumentDB の `$exp`演算子を使用すると、定数 e を特定の数値に上げることができます。
**パラメータ**
+ `expression`: 評価する式。これは、フィールド参照、算術演算、その他の集計ステージなど、任意の有効な集計式にすることができます。
## 例 (MongoDB シェル)
次の例は、 `$exp`演算子を使用して、 `quantity`フィールドが `price`フィールドより大きいすべてのドキュメントを検索する方法を示しています。
**サンプルドキュメントを作成する**
```
db.items.insertMany([
{ item: "canvas", quantity: 4 },
{ item: "journal", quantity: 2 }
]);
```
**クエリの例**
```
db.items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]);
```
**出力**
```
[
{
_id: ObjectId('6920b785311cf98b79d2950d'),
quantityRaised: 54.598150033144236
},
{
_id: ObjectId('6920b785311cf98b79d2950e'),
quantityRaised: 7.38905609893065
}
]
```
## コードの例
`$exp` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function aggregateExp() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const items = db.collection('items');
const result = await items.aggregate([
{ $project: {
"quantityRaised": {$exp: "$quantity"}}
}
]).toArray();
console.log(result);
client.close();
}
aggregateExp();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def aggregate_exp():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
items = db.items
result = list(items.aggregate([
{ "$project": {
"quantityRaised": {"$exp": "$quantity"}}
}
]))
print(result)
client.close()
aggregate_exp()
```
------
# \$1filter
Amazon DocumentDB の `$filter`演算子は、配列の各要素にフィルター式を適用し、指定された条件に一致する要素のみを含む配列を返すために使用されます。この演算子は、ドキュメント内の配列フィールドに対して複雑なフィルタリングオペレーションを実行する必要がある場合に便利です。
**パラメータ**
+ `input`: フィルタリングする配列フィールド。
+ `as`: `cond`式内の`input`配列の各要素に使用する変数名。
+ `cond`: 特定の要素を出力配列に含めるかどうかを決定するブール式。
## 例 (MongoDB シェル)
次の例は、 `$filter`演算子を使用して各注文の顧客を射影し、価格が 15 より大きい商品配列の商品のみを含む新しい配列フィールド paidItems を作成する方法を示しています。基本的に、各注文の項目をフィルタリングして、コストが 15 を超える製品のみを含めます。
**サンプルドキュメントを作成する**
```
db.orders.insertMany([
{ _id: 1, customer: "abc123", items: [
{ name: "Product A", price: 10, qty: 2 },
{ name: "Product B", price: 20, qty: 1 }
]},
{ _id: 2, customer: "def456", items: [
{ name: "Product C", price: 5, qty: 3 },
{ name: "Product D", price: 15, qty: 4 }
]},
{ _id: 3, customer: "ghi789", items: [
{ name: "Product E", price: 8, qty: 3 },
{ name: "Product F", price: 12, qty: 1 }
]}
]);
```
**クエリの例**
```
db.orders.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).pretty();
```
**出力**
```
[
{
_id: 1,
customer: 'abc123',
paidItems: [ { name: 'Product B', price: 20, qty: 1 } ]
},
{ _id: 2, customer: 'def456', paidItems: [] },
{ _id: 3, customer: 'ghi789', paidItems: [] }
]
```
## コードの例
`$filter` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('orders');
const result = await collection.aggregate([
{
$project: {
customer: 1,
paidItems: {
$filter: {
input: "$items",
as: "item",
cond: { $gt: ["$$item.price", 15] }
}
}
}
}
]).toArray();
console.log(JSON.stringify(result, null, 2));
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false'
with MongoClient(uri) as client:
db = client.test
collection = db.orders
result = list(collection.aggregate([
{
'$project': {
'customer': 1,
'paidItems': {
'$filter': {
'input': '$items',
'as': 'item',
'cond': { '$gt': ['$$item.price', 15] }
}
}
}
}
]))
for doc in result:
pprint(doc)
example()
```
------
# \$1first
バージョン 5.0 の新機能。
Elastic クラスターではサポートされていません。
Amazon DocumentDB の `$first`演算子は、グループ化されたドキュメントセットから最初のドキュメントを返します。集約パイプラインで一般的に使用され、特定の条件に一致する最初のドキュメントを取得します。
**パラメータ**
+ `expression`: 各グループの最初の値として返される式。
## 例 (MongoDB シェル)
次の例は、 `$first`演算子を使用して、集計中に各カテゴリで発生した最初の項目値を取得する方法を示しています。
注: は、パイプライン内のドキュメントの現在の順序に基づいて最初のドキュメント`$first`を返します。特定の順序 (日付、料金など) を確保するには、`$sort`ステージの前に`$group`ステージを使用する必要があります。
**サンプルドキュメントを作成する**
```
db.products.insertMany([
{ _id: 1, item: "abc", price: 10, category: "food" },
{ _id: 2, item: "jkl", price: 20, category: "food" },
{ _id: 3, item: "xyz", price: 5, category: "toy" },
{ _id: 4, item: "abc", price: 5, category: "toy" }
]);
```
**クエリの例**
```
db.products.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]);
```
**出力**
```
[
{ "_id" : "food", "firstItem" : "abc" },
{ "_id" : "toy", "firstItem" : "xyz" }
]
```
## コードの例
`$first` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('products');
const result = await collection.aggregate([
{ $group: { _id: "$category", firstItem: { $first: "$item" } } }
]).toArray();
console.log(result);
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
client = None
try:
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['products']
result = list(collection.aggregate([
{ '$group': { '_id': '$category', 'firstItem': { '$first': '$item' } } }
]))
pprint(result)
except Exception as e:
print(f"An error occurred: {e}")
finally:
if client:
client.close()
example()
```
------
# \$1floor
バージョン 4.0 の新機能。
Amazon DocumentDB の `$floor`演算子は、指定された数以下の最大の整数を返します。この演算子は、数値を四捨五入するのに役立ちます。
**パラメータ**
+ `expression`: 切り捨てる数値式。
## 例 (MongoDB シェル)
次の例は、 `$floor`演算子を使用して 10 進値を最も近い整数に四捨五入する方法を示しています。
**サンプルドキュメントを作成する**
```
db.numbers.insertOne({ value: 3.14 });
```
**クエリの例**
```
db.numbers.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]);
```
**出力**
```
{ "floored" : 3 }
```
## コードの例
`$floor` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const collection = db.collection('numbers');
const result = await collection.aggregate([
{ $project: { _id: 0, floored: { $floor: "$value" } } }
]).toArray();
console.log(result);
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
from pprint import pprint
def example():
client = None
try:
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client.test
collection = db.numbers
result = list(collection.aggregate([
{ '$project': { '_id': 0, 'floored': { '$floor': '$value' }}}
]))
pprint(result)
except Exception as e:
print(f"An error occurred: {e}")
finally:
if client:
client.close()
example()
```
------
# \$1geoNear
`$geoNear` 集約ステージは、指定されたポイントに近接した順序でドキュメントを返します。ポイントからの距離を計算し、出力ドキュメントに距離を含めます。
**パラメータ**
+ `near`: GeoJSON またはレガシー座標として指定された距離を計算するポイント。
+ `distanceField`: 計算された距離を保存するフィールド名。
+ `spherical`: 球形ジオメトリを使用するかどうかを示すブール値 (GeoJSON ポイントに必要）。
+ `maxDistance`: オプション。中心点からの最大距離。
+ `minDistance`: オプション。中心点からの最小距離。
+ `query`: オプション。適用する追加のフィルター条件。
+ `limit`: オプション。返されるドキュメントの最大数。
+ `key`: オプション。複数の地理空間インデックスが存在する場合に地理空間クエリに使用するフィールド。
## 例 (MongoDB シェル)
次の例は、 `$geoNear`ステージを使用して、特定の場所に最も近いストアを検索する方法を示しています。
**サンプルドキュメントを作成する**
```
db.stores.createIndex({ location: "2dsphere" });
db.stores.insertMany([
{ _id: 1, name: "Store A", location: { type: "Point", coordinates: [-122.4, 37.8] } },
{ _id: 2, name: "Store B", location: { type: "Point", coordinates: [-122.5, 37.7] } },
{ _id: 3, name: "Store C", location: { type: "Point", coordinates: [-122.3, 37.9] } }
]);
```
**クエリの例**
```
db.stores.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]);
```
**出力**
```
[
{ _id: 1, name: 'Store A', location: { type: 'Point', coordinates: [ -122.4, 37.8 ] }, distance: 0 },
{ _id: 3, name: 'Store C', location: { type: 'Point', coordinates: [ -122.3, 37.9 ] }, distance: 13877.82 },
{ _id: 2, name: 'Store B', location: { type: 'Point', coordinates: [ -122.5, 37.7 ] }, distance: 15557.89 }
]
```
## コードの例
`$geoNear` 集約ステージを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('stores');
const result = await collection.aggregate([
{
$geoNear: {
near: { type: "Point", coordinates: [-122.4, 37.8] },
distanceField: "distance",
spherical: true
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
db = client['test']
collection = db['stores']
result = list(collection.aggregate([
{
'$geoNear': {
'near': { 'type': 'Point', 'coordinates': [-122.4, 37.8] },
'distanceField': 'distance',
'spherical': True
}
}
]))
print(result)
client.close()
example()
```
------
# \$1group
Amazon DocumentDB の`$group`集約ステージでは、指定された式でドキュメントをグループ化し、グループ化されたデータに対してさまざまな累積オペレーションを実行できます。これは、グループ化されたデータに基づいて合計、平均、またはその他の統計を計算するなどのタスクに役立ちます。
**パラメータ**
+ `_id`: 入力ドキュメントをグループ化する式を指定します。これは、フィールド名、計算式、またはその両方の組み合わせです。
+ `accumulator expressions`: (オプション) グループ化されたデータに適用する必要がある 1 つ以上のアキュムレータ式。これらの式は、上記のアキュムレータ演算子を使用します。
## 例 (MongoDB シェル)
次の例では、顧客を都市別にグループ化し、各都市の合計注文額を計算します。
**サンプルドキュメントを作成する**
```
db.customers.insertMany([
{ name: "John Doe", city: "New York", orders: [{ amount: 100 }, { amount: 200 }] },
{ name: "Jane Smith", city: "Los Angeles", orders: [{ amount: 150 }, { amount: 300 }] },
{ name: "Bob Johnson", city: "New York", orders: [{ amount: 75 }, { amount: 125 }] },
{ name: "Samantha Lee", city: "Chicago", orders: [{ amount: 50 }, { amount: 100 }] }
]);
```
**クエリの例**
```
db.customers.aggregate([
{
$group: {
_id: "$city",
totalOrders: { $sum: { $sum: "$orders.amount" } }
}
}
]);
```
**出力**
```
[
{ _id: 'Chicago', totalOrders: 150 },
{ _id: 'Los Angeles', totalOrders: 450 },
{ _id: 'New York', totalOrders: 500 }
]
```
## コードの例
`$group` コマンドを使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function groupByCity() {
const uri = 'mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false';
const client = new MongoClient(uri);
try {
await client.connect();
const db = client.db('test');
const result = await db.collection('customers').aggregate([
{ $unwind: '$orders' },
{
$group: {
_id: '$city',
totalOrders: { $sum: '$orders.amount' }
}
}
]).toArray();
console.log(result);
} catch (err) {
console.error('Error during aggregation:', err);
} finally {
await client.close();
}
}
groupByCity();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def group_by_city():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
try:
db = client.test
result = list(db.customers.aggregate([
{'$unwind': '$orders'},
{
'$group': {
'_id': '$city',
'totalOrders': {'$sum': '$orders.amount'}
}
}
]))
print(result)
except Exception as e:
print(f"Error during aggregation: {e}")
finally:
client.close()
group_by_city()
```
------
# \$1gt
`$gt` 集計演算子は 2 つの値を比較し、最初の値が 2 番目より大きい`true`場合は を返し、それ以外の場合は を返します`false`。
**パラメータ**
+ `expression1`: 比較する最初の値。
+ `expression2`: 比較する 2 番目の値。
## 例 (MongoDB シェル)
次の例は、 `$gt`演算子を使用して、価格しきい値を超える製品を識別する方法を示しています。
**サンプルドキュメントを作成する**
```
db.products.insertMany([
{ _id: 1, name: "Laptop", price: 1200 },
{ _id: 2, name: "Mouse", price: 25 },
{ _id: 3, name: "Monitor", price: 400 }
]);
```
**クエリの例**
```
db.products.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]);
```
**出力**
```
[
{ _id: 1, name: 'Laptop', price: 1200, expensive: true },
{ _id: 2, name: 'Mouse', price: 25, expensive: false },
{ _id: 3, name: 'Monitor', price: 400, expensive: true }
]
```
## コードの例
`$gt` 集計演算子を使用するコード例を表示するには、使用する言語のタブを選択します。
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = await MongoClient.connect('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
const db = client.db('test');
const collection = db.collection('products');
const result = await collection.aggregate([
{
$project: {
name: 1,
price: 1,
expensive: { $gt: ["$price", 100] }
}
}
]).toArray();
console.log(result);
await client.close();
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://