기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# 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, 요청된 기능, 사용 사례를 포함한 이메일을 [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)
+ [Authentication](#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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| 제한 컬렉션 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| cloneCollectionAsCapped | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| collMod | 부분적 | 부분적 | 부분적 | 부분적 | 부분적 |
| collMod: expireAfterSeconds | 예 | 예 | 예 | 예 | 예 |
| convertToCapped | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| copydb | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| create | 예 | 예 | 예 | 예 | 예 |
| 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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| aggregate | 예 | 예 | 예 | 예 | 예 |
| count | 예 | 예 | 예 | 예 | 예 |
| distinct | 예 | 예 | 예 | 예 | 예 |
| mapReduce | 아니요 | 아니요 | 아니요 | 예 | 아니요 |
### Authentication
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| authenticate | 예 | 예 | 예 | 예 | 예 |
| 로그아웃 | 예 | 예 | 예 | 예 | 예 |
### 진단 명령
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| buildInfo | 예 | 예 | 예 | 예 | 예 |
| collStats | 예 | 예 | 예 | 예 | 예 |
| connPoolStats | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| connectionStatus | 예 | 예 | 예 | 예 | 예 |
| dataSize | 예 | 예 | 예 | 예 | 예 |
| dbHash | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| dbStats | 예 | 예 | 예 | 예 | 예 |
| explain | 예 | 예 | 예 | 예 | 예 |
| explain: executionStats | 예 | 예 | 예 | 예 | 예 |
| 기능 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| hostInfo | 예 | 예 | 예 | 예 | 예 |
| listCommands | 예 | 예 | 예 | 예 | 예 |
| profiler | [예](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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| 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) | 아니요 |
| delete | 예 | 예 | 예 | 예 | 예 |
| find | 예 | 예 | 예 | 예 | 예 |
| findAndModify | 예 | 예 | 예 | 예 | 예 |
| getLastError | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| getMore | 예 | 예 | 예 | 예 | 예 |
| getPrevError | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| GridFS | 예 | 예 | 예 | 예 | 아니요 |
| 삽입 | 예 | 예 | 예 | 예 | 예 |
| parallelCollectionScan | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| resetError | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| 업데이트 | 예 | 예 | 예 | 예 | 예 |
| ReplaceOne | 예 | 예 | 예 | 예 | 예 |
### 역할 관리 명령
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| createRole | 예 | 예 | 예 | 예 | 아니요 |
| dropAllRolesFromDatabase | 예 | 예 | 예 | 예 | 아니요 |
| dropRole | 예 | 예 | 예 | 예 | 아니요 |
| grantRolesToRole | 예 | 예 | 예 | 예 | 아니요 |
| revokeRolesFromRole | 예 | 예 | 예 | 예 | 아니요 |
| revokePrivilegesFromRole | 예 | 예 | 예 | 예 | 아니요 |
| rolesInfo | 예 | 예 | 예 | 예 | 아니요 |
| updateRole | 예 | 예 | 예 | 예 | 아니요 |
### 세션 명령
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| abortTransaction | 아니요 | 예 | 예 | 예 | 아니요 |
| commitTransaction | 아니요 | 예 | 예 | 예 | 아니요 |
| endSessions | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| killAllSessions | 아니요 | 예 | 예 | 예 | 아니요 |
| killAllSessionsByPattern | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| killSessions | 아니요 | 예 | 예 | 예 | 아니요 |
| refreshSessions | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| startSession | 아니요 | 예 | 예 | 예 | 아니요 |
### 사용자 관리
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| createUser | 예 | 예 | 예 | 예 | 예 |
| dropAllUsersFromDatabase | 예 | 예 | 예 | 예 | 예 |
| dropUser | 예 | 예 | 예 | 예 | 예 |
| grantRolesToUser | 예 | 예 | 예 | 예 | 예 |
| revokeRolesFromUser | 예 | 예 | 예 | 예 | 예 |
| updateUser | 예 | 예 | 예 | 예 | 예 |
| usersInfo | 예 | 예 | 예 | 예 | 예 |
### 샤딩 명령
| 명령 | 엘라스틱 클러스터 |
| --- | --- |
| 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)
+ [Bitwise 연산자](#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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1all](all.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1elemMatch](elemMatch.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1size](size-query.md) | 예 | 예 | 예 | 예 | 예 |
### Bitwise 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1bitsAllSet](bitsAllSet.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1bitsAnySet](bitsAnySet.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1bitsAllClear](bitsAllClear.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1bitsAnyClear](bitsAnyClear.md) | 예 | 예 | 예 | 예 | 예 |
### 설명 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1comment](comment.md) | 예 | 예 | 예 | 예 | 예 |
### 비교 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1exists](exists.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1type](type.md) | 예 | 예 | 예 | 예 | 예 |
### 평가 쿼리 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1nor](nor.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1not](not.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1or](or.md) | 예 | 예 | 예 | 예 | 예 |
### 프로젝션 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1](dollar-projection.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1elemMatch](elemMatch.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1meta](meta.md) | 아니요 | 아니요 | 예 | 예 | 아니요 |
| [\$1slice](slice-projection.md) | 예 | 예 | 예 | 예 | 예 |
## 업데이트 연산자
**Topics**
+ [배열 연산자](#mongo-apis-update-array)
+ [Bitwise 연산자](#mongo-apis-update-bitwise)
+ [필드 연산자](#mongo-apis-update-field)
+ [업데이트 한정자](#mongo-apis-update-modifiers)
### 배열 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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) | 예 | 예 | 예 | 예 | 예 |
### Bitwise 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1bit](bit.md) | 예 | 예 | 예 | 예 | 예 |
### 필드 연산자
| 연산자 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1each](each.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1position](position.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1slice](slice-update.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1sort](sort-update.md) | 예 | 예 | 예 | 예 | 예 |
## 지리 공간
### 지오메트리 지정자
| 쿼리 선택기 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| \$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1geoIntersects](geoIntersects.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1geoWithin](geoWithin.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1near](near.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1nearSphere](nearSphere.md) | 예 | 예 | 예 | 예 | 예 |
| \$1polygon | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| \$1uniqueDocs | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
## 커서 메서드
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| 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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| \$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1and](and-aggregation.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1not](not-aggregation.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1or](or-aggregation.md) | 예 | 예 | 예 | 예 | 예 |
### 비교 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1cond](cond.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1ifNull](ifNull.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1switch](switch.md) | 아니요 | 예 | 예 | 예 | 아니요 |
### 데이터 유형 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1type](type-aggregation.md) | 예 | 예 | 예 | 예 | 예 |
### 데이터 크기 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| \$1binarySize | - | - | 아니요 | 아니요 | 아니요 |
| \$1bsonSize | - | - | 아니요 | 아니요 | 아니요 |
### 날짜 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1literal](literal.md) | 예 | 예 | 예 | 예 | 예 |
### 병합 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1mergeObjects](mergeObjects.md) | 예 | 예 | 예 | 예 | 예 |
### 자연 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1natural](natural.md) | 예 | 예 | 예 | 예 | 예 |
### 집합 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| \$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1meta](meta-aggregation.md) | 아니요 | 아니요 | 예 | 예 | 아니요 |
| [\$1search](search.md) | 아니요 | 아니요 | 예 | 예 | 아니요 |
### 유형 변환 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$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 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| [\$1let](let.md) | 예 | 예 | 예 | 예 | 예 |
| [\$1map](map.md) | 예 | 예 | 예 | 예 | 예 |
### 기타 연산자
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| \$1getField | - | - | 아니요 | 아니요 | 아니요 |
| [\$1rand](rand.md) | - | - | 아니요 | 예 | 아니요 |
| \$1sampleRate | - | - | 아니요 | 아니요 | 아니요 |
## 데이터 타입
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| 32비트 정수(int) | 예 | 예 | 예 | 예 | 예 |
| 64비트 정수(int) | 예 | 예 | 예 | 예 | 예 |
| 배열 | 예 | 예 | 예 | 예 | 예 |
| 이진 데이터 | 예 | 예 | 예 | 예 | 예 |
| 부울 | 예 | 예 | 예 | 예 | 예 |
| Date | 예 | 예 | 예 | 예 | 예 |
| DBPointer | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| DBRefs | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| Decimal128 | 예 | 예 | 예 | 예 | 예 |
| 배정밀도 실수 | 예 | 예 | 예 | 예 | 예 |
| JavaScript | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| JavaScript(범위 포함) | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| MaxKey | 예 | 예 | 예 | 예 | 예 |
| MinKey | 예 | 예 | 예 | 예 | 예 |
| Null | 예 | 예 | 예 | 예 | 예 |
| 객체 | 예 | 예 | 예 | 예 | 예 |
| ObjectId | 예 | 예 | 예 | 예 | 예 |
| 정규식 | 예 | 예 | 예 | 예 | 예 |
| 문자열 | 예 | 예 | 예 | 예 | 예 |
| Symbol | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| 타임스탬프 | 예 | 예 | 예 | 예 | 예 |
| 정의되지 않음 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
## 인덱스 및 인덱스 속성
**Topics**
+ [인덱스](#mongo-apis-indexes)
+ [인덱스 속성](#mongo-apis-index-properties)
### 인덱스
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| 2dsphere | 예 | 예 | 예 | 예 | 예 |
| 2d 인덱스 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| 복합 인덱스 | 예 | 예 | 예 | 예 | 예 |
| 해시된 인덱스 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| Multikey 인덱스 | 예 | 예 | 예 | 예 | 예 |
| 단일 필드 인덱스 | 예 | 예 | 예 | 예 | 예 |
| 텍스트 인덱스 | 아니요 | 아니요 | 예 | 예 | 아니요 |
| 와일드카드 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
### 인덱스 속성
| 명령 | 3.6 | 4.0 | 5.0 | 8.0 | 엘라스틱 클러스터 |
| --- | --- | --- | --- | --- | --- |
| 배경 | 예 | 예 | 예 | 예 | 예 |
| 대소문자 구분 안 함 | 아니요 | 아니요 | 아니요 | 예 | 아니요 |
| 숨김 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| 부분적 | 아니요 | 아니요 | 예 | 예 | 아니요 |
| 희소 | 예 | 예 | 예 | 예 | 예 |
| 텍스트 | 아니요 | 아니요 | 예 | 예 | 아니요 |
| TTL | 예 | 예 | 예 | 예 | 예 |
| 고유 | 예 | 예 | 예 | 예 | 예 |
| 벡터 | 아니요 | 아니요 | 예 | 예 | 아니요 |
특정 MongoDB 연산자에 대한 자세한 내용은 다음 주제를 참조하세요.
+ [집계 파이프라인 연산자](mongo-apis-aggregation-pipeline-operators.md)
+ [Geospatial](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`: 추가할 두 번째 숫자 또는 날짜입니다.
+ `expression3`: (선택 사항) 추가할 추가 번호 또는 날짜입니다.
## 예제(MongoDB 쉘)
다음 예제에서는 `$add` 연산자를 사용하여 두 숫자를 함께 추가하는 방법을 보여줍니다.
**샘플 문서 생성**
```
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"` 제외됩니다.
## 코드 예제
`$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`: 검색할 요소의 0 기반 인덱스 위치입니다. 이 값은 음수가 아닌 정수여야 합니다.
## 예제(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` 연산자의 역순입니다. 키-값 페어 문서의 배열을 가져와서 단일 문서로 변환합니다. 이는 키-값 페어의 배열을 객체 또는 문서 구조로 다시 변환해야 할 때 특히 유용합니다.
**파라미터**
+ `array expression`: 배열로 확인되는 표현식입니다. 배열 요소는 (키)와 `k` (`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의 새로운 기능
MongoDB와 마찬가지로 Amazon DocumentDB의 `$ceil` 연산자는 숫자를 가장 가까운 정수로 반올림합니다. 이는 숫자 필드에 수학 작업을 수행하고 결과가 정수인지 확인해야 할 때 유용합니다.
**파라미터**
+ `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` 연산자는 두 값을 비교하고 상대 순서를 나타내는 정수 값을 반환하는 데 사용됩니다. 첫 번째 값이 각각 두 번째 값보다 작은지, 같은지 또는 큰지에 따라 두 표현식을 비교하고 -1, 0 또는 1의 정수 값을 반환하는 비교 연산자입니다.
**파라미터**
+ `expression1`: 비교할 첫 번째 표현식입니다.
+ `expression2`: 비교할 두 번째 표현식입니다.
## 예제(MongoDB 쉘)
다음 예제에서는 연`$cmp`산자를 사용하여 두 숫자 값을 비교하는 방법을 보여줍니다.
**샘플 문서 생성**
```
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 Shell 예제와 동일합니다.
```
[
{ "_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`: 연결할 두 번째 문자열입니다.
+ `...`: 연결할 추가 문자열(선택 사항).
## 예제(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` 집계 연산자는 두 개 이상의 배열을 단일 배열로 연결하는 데 사용됩니다. 이는 추가 처리 또는 분석을 위해 여러 데이터 배열을 단일 배열로 결합해야 할 때 유용할 수 있습니다.
**파라미터**
+ `array1`: 연결할 첫 번째 배열입니다.
+ `array2`: 연결할 두 번째 배열입니다.
+ `[array3, ...]`: (선택 사항) 연결할 추가 배열입니다.
## 예제(MongoDB 쉘)
다음 예제에서는 `$concatArrays` 연산자를 사용하여 두 배열을 단일 배열로 결합하는 방법을 보여줍니다.
**샘플 문서 생성**
```
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` 연산자는 조건 표현식을 평가하고 두 개의 가능한 결과 표현식 중 하나를 반환하는 데 사용됩니다.
**파라미터**
+ `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`, `days``hours`, `weeks`에 대한 키가 있는 객체로 지정할 수 `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` 집계 연산자는 지정된 단위로 두 날짜 간의 차이를 계산합니다. 시작 날짜와 종료 날짜 사이에 교차된 단위 경계 수를 반환합니다.
**파라미터**
+ `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'` (를 반환) 또는 `'replace'` ( 값을 `onErrorMessage` 옵션에 지정된 대체 문자열로 대체`null`)입니다.
+ `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` 경우 , 2자리 월의 `%m` 경우 , `%d`2자리 월의 경우와 같은 다양한 형식 지정자가 포함될 수 있습니다.
+ `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`: 하위 추적 표현식의 시간 단위를 지정하는 문자열입니다. 지원되는 단위는 `year`, `quarter`, `month`, `week`, `day`, `hour`, `minute`, 및 `second`입니다`millisecond`.
## 예제(MongoDB 쉘)
다음 예제에서는 `$dateTrunc` 연산자를 사용하여 날짜를 시간으로 자르는 방법을 보여줍니다.
**샘플 문서 생성**
```
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\$131)를 검색합니다. 이 연산자는 문서의 날짜 필드에서 월의 날짜를 그룹화, 필터링 또는 추출하는 데 유용합니다.
**파라미터**
+ `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` 연산자는 지정된 날짜 필드에서 요일을 추출합니다. MongoDB와 동일한 동작인 1(일요일)에서 7(토요일) 사이의 숫자로 요일을 반환합니다.
**파라미터**
+ `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` 연산자를 사용하여 연간 급여 및 연간 근무 시간을 기준으로 직원의 시간당 요금을 계산하는 방법을 보여줍니다.
**샘플 문서 생성**
```
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` 집계 연산자는 두 값을 비교하고 값이 같`true`으면를 반환하고 그렇지 않으면를 반환합니다`false`.
**파라미터**
+ `expression1`: 비교할 첫 번째 값입니다.
+ `expression2`: 비교할 두 번째 값입니다.
## 예제(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` 연산자를 사용하여 십진수 값을 가장 가까운 정수로 반올림하는 방법을 보여줍니다.
**샘플 문서 생성**
```
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`: (선택 사항) 그룹화된 데이터에 적용해야 하는 하나 이상의 누적기 표현식입니다. 이러한 표현식은 위에서 언급한 누적기 연산자를 사용합니다.
## 예제(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` 집계 연산자는 두 값을 비교하고 첫 번째 값이 두 번째 값보다 크`true`면를 반환하고, 그렇지 않으면를 반환합니다`false`.
**파라미터**
+ `expression1`: 비교할 첫 번째 값입니다.
+ `expression2`: 비교할 두 번째 값입니다.
## 예제(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://