정의
참고
이 페이지에서는 집계 파이프라인 결과를 컬렉션으로 출력하는 $merge 단계를 설명합니다. 문서를 단일 문서로 병합하는 $mergeObjects 연산자에 대해서는 $mergeObjects를 참조하세요.
$merge집계 파이프라인의 결과를 지정된 컬렉션에 씁니다.
$merge연산자는 반드시 파이프라인의 마지막 단계여야 합니다.다음은
$merge단계입니다.동일하거나 다른 데이터베이스의 컬렉션으로 출력할 수 있습니다.
집계 중인 동일한 컬렉션으로 출력할 수 있습니다. 자세한 내용은 집계 중인 동일한 컬렉션에 출력하기를 참조하세요.
출력 컬렉션이 아직 존재하지 않는 경우 새 컬렉션을 생성합니다.
결과(새 문서 삽입, 문서 병합, 문서 교체, 기존 문서 유지, 작업 실패, 사용자 지정 업데이트 파이프라인으로 문서 처리)를 기존 컬렉션에 통합할 수 있습니다.
샤드된 컬렉션으로 출력할 수 있습니다. 입력 컬렉션도 샤딩할 수 있습니다.
집계 결과를 컬렉션으로 출력하는
$out단계와 비교하려면$merge및$out비교를 참조하세요.
참고
온디맨드 구체화된 보기
$merge 컬렉션을 완전히 교체하는 대신 파이프라인 결과를 기존 출력 컬렉션에 통합할 수 있습니다. 이 기능을 사용하면 파이프라인이 실행될 때 출력 컬렉션의 콘텐츠가 점진적으로 업데이트되는 온디맨드 구체화된 보기를 만들 수 있습니다.
이 사용 사례에 대한 자세한 내용은 이 페이지의 예시 및 온디맨드 구체화된 뷰를 참조하세요.
구체화된 보기는 읽기 전용 보기와 별개입니다. 읽기 전용 보기를 만드는 방법에 대한 자세한 내용은 읽기 전용 보기를 참조하십시오.
호환성
다음 환경에서 호스팅되는 배포에 $merge 사용할 수 있습니다.
- MongoDB Atlas: 클라우드에서의 MongoDB 배포를 위한 완전 관리형 서비스
MongoDB Enterprise: MongoDB의 구독 기반 자체 관리 버전
MongoDB Community: MongoDB의 소스 사용 가능 무료 자체 관리 버전
구문
$merge 의 구문은 다음과 같습니다:
{ $merge: { into: <collection> -or- { db: <db>, coll: <collection> }, on: <identifier field> -or- [ <identifier field1>, ...], // Optional let: <variables>, // Optional whenMatched: <replace|keepExisting|merge|fail|pipeline>, // Optional whenNotMatched: <insert|discard|fail> // Optional } }
예를 들면 다음과 같습니다.
{ $merge: { into: "myOutput", on: "_id", whenMatched: "replace", whenNotMatched: "insert" } }
동일한 데이터베이스의 컬렉션에 쓰는 것을 포함하여 $merge에 대한 모든 기본 옵션을 사용하는 경우 간소화된 양식을 사용할 수 있습니다.
{ $merge: <collection> } // Output collection is in the same database
$merge는 다음 필드가 포함된 문서를 사용합니다.
필드 | 설명 | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
선택 사항입니다. 문서의 고유 식별자 역할을 하는 하나 이상의 필드입니다. 식별자는 결과 문서가 출력 컬렉션의 기존 문서와 일치 여부를 결정합니다. 다음 중 하나를 지정합니다.
지정된 필드에 대해
on 기본값은 출력 컬렉션에 따라 다릅니다.
| |||||||||||
선택 사항입니다. 결과 문서와 컬렉션의 기존 문서가 지정된 on 필드에 대해 동일한 값을 갖는 경우의 다음 두 가지 중 하나를 지정할 수 있습니다.
| |||||||||||
선택 사항입니다. whenMatched 파이프라인에서 사용할 변수를 지정합니다. 변수 이름과 값 표현식이 있는 문서를 지정합니다. 지정하지 않은 경우 기본값은 whenMatched 파이프라인의 변수에 액세스하려면 다음을 수행합니다. 변수 이름과 함께 이중 달러 기호 ($$) 접두사를 자세한 예는 변수를 사용하여 병합을 사용자 지정하기를 참조하세요. | |||||||||||
고려 사항
_id 필드 생성
집계 파이프라인 결과에서 _id 필드가 문서에 없는 경우 $merge 단계에서 자동으로 생성합니다.
예를 들어, 다음 집계 파이프라인에서 $project는 $merge에 전달된 문서에서 _id 필드를 제외합니다. $merge가 이러한 문서를 "newCollection"에 쓰면 $merge는 새로운 _id 필드와 값을 생성합니다.
db.sales.aggregate( [ { $project: { _id: 0 } }, { $merge : { into : "newCollection" } } ] )
출력 컬렉션이 존재하지 않는 경우 새 컬렉션 만들기
지정한 출력 컬렉션이 없는 경우 $merge 작업은 새 컬렉션을 생성합니다.
출력 컬렉션이 존재하지 않는 경우 $merge는 on 식별자가 _id 필드여야 합니다. 존재하지 않는 컬렉션에 다른 on 필드 값을 사용하려면 먼저 원하는 필드에 고유 인덱스를 생성하여 컬렉션을 만들 수 있습니다. 예를 들어 출력 컬렉션 newDailySales201905 가 존재하지 않고 salesDate 필드를 on 식별자로 지정하려는 경우입니다.
db.newDailySales201905.createIndex( { salesDate: 1 }, { unique: true } ) db.sales.aggregate( [ { $match: { date: { $gte: new Date("2019-05-01"), $lt: new Date("2019-06-01") } } }, { $group: { _id: { $dateToString: { format: "%Y-%m-%d", date: "$date" } }, totalqty: { $sum: "$quantity" } } }, { $project: { _id: 0, salesDate: { $toDate: "$_id" }, totalqty: 1 } }, { $merge : { into : "newDailySales201905", on: "salesDate" } } ] )
샤드된 컬렉션으로 출력
$merge 단계는 샤딩된 컬렉션으로 출력할 수 있습니다. 출력 컬렉션이 샤딩되면 $merge는 _id 필드와 모든 샤드 키 필드를 식별자 on의 기본값으로 사용합니다. 기본값을 재정의하는 경우, on 식별자에는 모든 샤드 키 필드가 포함되어야 합니다.
{ $merge: { into: "<shardedColl>" or { db:"<sharding enabled db>", coll: "<shardedColl>" }, on: [ "<shardkeyfield1>", "<shardkeyfield2>",... ], // Shard key fields and any additional fields let: <variables>, // Optional whenMatched: <replace|keepExisting|merge|fail|pipeline>, // Optional whenNotMatched: <insert|discard|fail> // Optional } }
예를 들어 sh.shardCollection() 메서드를 사용하여 postcode 필드를 샤드 키로 사용하여 새 샤드된 컬렉션 newrestaurants를 만듭니다.
sh.shardCollection( "exampledb.newrestaurants", // Namespace of the collection to shard { postcode: 1 }, // Shard key );
newrestaurants 컬렉션에는 월별(date 필드) 및 우편 번호(샤드 키)로 새 레스토랑 개점 정보가 있는 문서가 포함되며, 특히 on 식별자는 ["date", "postcode"]입니다(필드 순서는 중요하지 않음). $merge에는 on 식별자 필드에 해당하는 키가 있는 고유 인덱스가 필요하므로 고유 인덱스를 생성합니다(필드 순서는 중요하지 않음). [1]
use exampledb db.newrestaurants.createIndex( { postcode: 1, date: 1 }, { unique: true } )
샤드된 컬렉션 restaurants 과 생성된 고유 인덱스를 사용하면 $merge를 사용하여 이 컬렉션에 집계 결과를 출력하고, 이 예시에서처럼 [ "date", "postcode" ]에 일치하는 결과를 출력할 수 있습니다:
use exampledb db.openings.aggregate([ { $group: { _id: { date: { $dateToString: { format: "%Y-%m", date: "$date" } }, postcode: "$postcode" }, restaurants: { $push: "$restaurantName" } } }, { $project: { _id: 0, postcode: "$_id.postcode", date: "$_id.date", restaurants: 1 } }, { $merge: { into: "newrestaurants", "on": [ "date", "postcode" ], whenMatched: "replace", whenNotMatched: "insert" } } ])
| [1] |
이전 예시 에서는 |
문서 바꾸기($merge) 대 컬렉션 바꾸기($out)
집계 결과에 on 사양에 따라 일치하는 문서가 하나 이상 포함된 경우 $merge는 출력 컬렉션의 기존 문서를 대체할 수 있습니다. 따라서 집계 결과에 컬렉션의 모든 기존 문서에 대해 일치하는 문서가 포함되어 있고 whenMatched에 'replace'를 지정한 경우 $merge는 기존 컬렉션의 모든 문서를 대체할 수 있습니다.
그러나 집계 결과에 관계없이 기존 컬렉션을 바꾸려면 $out를 대신 사용합니다.
기존 문서와 _id 및 샤드 키 값
고유 인덱스 제약 조건
on 필드에 대해 $merge가 사용하는 고유 인덱스가 집계 도중에 제거되는 경우 집계가 중단된다는 보장이 없습니다. 집계가 계속되면 문서에 중복된 on 필드 값이 없다는 보장이 없습니다.
$merge가 출력 컬렉션의 고유 인덱스를 위반하는 문서를 작성하려고 하면 작업이 오류를 생성합니다. 예를 들면 다음과 같습니다.
온 필드의 인덱스가 아닌 고유 인덱스를 위반하는 일치하지 않는 문서를 삽입합니다 .
일치하는 문서를 병합하면 온 필드의 인덱스가 아닌 고유 인덱스를 위반하는 문서가 생성됩니다.
스키마 유효성 검사
컬렉션이 스키마 유효성 검사를 사용하고 validationAction이 error로 설정된 경우, $merge로 잘못된 문서를 삽입하거나 잘못된 값으로 문서를 업데이트하면 MongoServerError가 발생하며, 문서는 대상 컬렉션에 기록되지 않습니다. 잘못된 문서가 여러 개 있는 경우, 처음으로 발견된 잘못된 문서만 오류를 발생시킵니다. 모든 유효한 문서는 대상 컬렉션에 기록되며 모든 잘못된 문서는 기록에 실패합니다.
whenMatched 파이프라인 동작
$merge 다음 모든 조건이 참일 경우 문서를 출력 컬렉션에 직접 삽입합니다.
whenMatched 의 값은 집계 파이프라인입니다.
whenNotMatched 의 값은
insert입니다.출력 컬렉션에 일치하는 문서가 없습니다.
$merge 및 $out 비교
$merge의 도입으로 MongoDB는 집계 파이프라인의 결과를 컬렉션에 기록하기 위해 $merge 및 $out의 두 단계를 제공합니다.
|
|
|
|
|
|
|
|
|
|
집계 중인 동일한 컬렉션에 대한 출력
경고
$merge 집계 중인 동일한 컬렉션 에 출력이 발생하면 문서가 여러 번 업데이트되거나 작업이 무한 루프가 발생할 수 있습니다. 이 동작은 $merge 에서 수행한 업데이트로 인해 디스크에 저장된 문서의 물리적 위치 변경될 때 발생합니다. 문서 의 물리적 위치 변경되면 $merge 에서 문서를 완전히 새로운 문서 로 간주하여 추가 업데이트를 수행할 수 있습니다. 이 동작에 대한 자세한 내용은 '할로윈 문제'를 참조하세요.
$merge는 집계 중인 컬렉션과 동일한 컬렉션으로 출력할 수 있습니다. $lookup과 같이 파이프라인의 다른 단계에 나타나는 컬렉션으로 출력할 수도 있습니다.
제한 사항
제한 사항 | 설명 |
|---|---|
집계 파이프라인은 | |
보기 정의 | |
| |
| |
|
|
|
|
예시
온디맨드 구체화된 뷰: 초기 생성
출력 컬렉션이 존재하지 않으면 $merge가 컬렉션을 생성합니다.
예를 들어, zoo 데이터베이스의 salaries 이라는 컬렉션은 직원 급여 및 부서 내역으로 채워집니다.
db.getSiblingDB("zoo").salaries.insertMany([ { "_id" : 1, employee: "Ant", dept: "A", salary: 100000, fiscal_year: 2017 }, { "_id" : 2, employee: "Bee", dept: "A", salary: 120000, fiscal_year: 2017 }, { "_id" : 3, employee: "Cat", dept: "Z", salary: 115000, fiscal_year: 2017 }, { "_id" : 4, employee: "Ant", dept: "A", salary: 115000, fiscal_year: 2018 }, { "_id" : 5, employee: "Bee", dept: "Z", salary: 145000, fiscal_year: 2018 }, { "_id" : 6, employee: "Cat", dept: "Z", salary: 135000, fiscal_year: 2018 }, { "_id" : 7, employee: "Gecko", dept: "A", salary: 100000, fiscal_year: 2018 }, { "_id" : 8, employee: "Ant", dept: "A", salary: 125000, fiscal_year: 2019 }, { "_id" : 9, employee: "Bee", dept: "Z", salary: 160000, fiscal_year: 2019 }, { "_id" : 10, employee: "Cat", dept: "Z", salary: 150000, fiscal_year: 2019 } ])
$group 및 $merge 단계를 사용하여 현재 salaries 컬렉션에 있는 데이터에서 budgets(reporting 데이터베이스에 있는)라는 컬렉션을 처음 만들 수 있습니다.
참고
복제 세트 또는 독립형 배포의 경우 출력 데이터베이스가 존재하지 않으면 $merge가 데이터베이스를 생성하기도 합니다.
샤딩된 클러스터 배포의 경우, 지정된 출력 데이터베이스가 이미 존재해야 합니다.
db.getSiblingDB("zoo").salaries.aggregate( [ { $group: { _id: { fiscal_year: "$fiscal_year", dept: "$dept" }, salaries: { $sum: "$salary" } } }, { $merge : { into: { db: "reporting", coll: "budgets" }, on: "_id", whenMatched: "replace", whenNotMatched: "insert" } } ] )
급여를
fiscal_year및dept기준으로 그룹화하는$group단계.
새 budgets 컬렉션의 문서를 보려면 다음과 같이 하세요:
db.getSiblingDB("reporting").budgets.find().sort( { _id: 1 } )
budgets 컬렉션에는 다음 문서가 포함되어 있습니다.
{ "_id" : { "fiscal_year" : 2017, "dept" : "A" }, "salaries" : 220000 } { "_id" : { "fiscal_year" : 2017, "dept" : "Z" }, "salaries" : 115000 } { "_id" : { "fiscal_year" : 2018, "dept" : "A" }, "salaries" : 215000 } { "_id" : { "fiscal_year" : 2018, "dept" : "Z" }, "salaries" : 280000 } { "_id" : { "fiscal_year" : 2019, "dept" : "A" }, "salaries" : 125000 } { "_id" : { "fiscal_year" : 2019, "dept" : "Z" }, "salaries" : 310000 }
온디맨드 구체화된 뷰: 데이터 업데이트/바꾸기
다음 예시에서는 이전 예시의 컬렉션을 사용합니다.
예시 salaries 컬렉션에는 직원 급여 및 부서 기록이 포함되어 있습니다.
db.salaries.insertMany( [ { _id : 1, employee: "Ant", dept: "A", salary: 100000, fiscal_year: 2017 }, { _id : 2, employee: "Bee", dept: "A", salary: 120000, fiscal_year: 2017 }, { _id : 3, employee: "Cat", dept: "Z", salary: 115000, fiscal_year: 2017 }, { _id : 4, employee: "Ant", dept: "A", salary: 115000, fiscal_year: 2018 }, { _id : 5, employee: "Bee", dept: "Z", salary: 145000, fiscal_year: 2018 }, { _id : 6, employee: "Cat", dept: "Z", salary: 135000, fiscal_year: 2018 }, { _id : 7, employee: "Gecko", dept: "A", salary: 100000, fiscal_year: 2018 }, { _id : 8, employee: "Ant", dept: "A", salary: 125000, fiscal_year: 2019 }, { _id : 9, employee: "Bee", dept: "Z", salary: 160000, fiscal_year: 2019 }, { _id : 10, employee: "Cat", dept: "Z", salary: 150000, fiscal_year: 2019 } ] )
예시 budgets 컬렉션에는 연간 누적 예산이 포함되어 있습니다.
db.budgets.insertMany( [ { _id : { "fiscal_year" : 2017, "dept" : "A" }, "salaries" : 220000 }, { _id : { "fiscal_year" : 2017, "dept" : "Z" }, "salaries" : 115000 }, { _id : { "fiscal_year" : 2018, "dept" : "A" }, "salaries" : 215000 }, { _id : { "fiscal_year" : 2018, "dept" : "Z" }, "salaries" : 280000 }, { _id : { "fiscal_year" : 2019, "dept" : "A" }, "salaries" : 125000 }, { _id : { "fiscal_year" : 2019, "dept" : "Z" }, "salaries" : 310000 } ] )
현재 회계연도(이 예에서는 2019 ) 동안 새 직원이 salaries 컬렉션에 추가되고 새 인원수가 다음 연도에 미리 할당됩니다.
db.getSiblingDB("zoo").salaries.insertMany( [ { _id : 11, employee: "Wren", dept: "Z", salary: 100000, fiscal_year: 2019 }, { _id : 12, employee: "Zebra", dept: "A", salary: 150000, fiscal_year: 2019 }, { _id : 13, employee: "headcount1", dept: "Z", salary: 120000, fiscal_year: 2020 }, { _id : 14, employee: "headcount2", dept: "Z", salary: 120000, fiscal_year: 2020 } ] )
새 급여 정보를 반영하도록 budgets 컬렉션을 업데이트하기 위해 다음 집계 파이프라인은 다음을 사용합니다.
db.getSiblingDB("zoo").salaries.aggregate( [ { $match : { fiscal_year: { $gte : 2019 } } }, { $group: { _id: { fiscal_year: "$fiscal_year", dept: "$dept" }, salaries: { $sum: "$salary" } } }, { $merge : { into: { db: "reporting", coll: "budgets" }, on: "_id", whenMatched: "replace", whenNotMatched: "insert" } } ] )
집계가 실행된 후 budgets 컬렉션에서 문서를 봅니다.
db.getSiblingDB("reporting").budgets.find().sort( { _id: 1 } )
budgets 컬렉션은 2019 회계연도의 새 급여 데이터를 통합하고 2020 회계연도에 대한 새 문서를 추가합니다.
{ _id : { "fiscal_year" : 2017, "dept" : "A" }, "salaries" : 220000 } { _id : { "fiscal_year" : 2017, "dept" : "Z" }, "salaries" : 115000 } { _id : { "fiscal_year" : 2018, "dept" : "A" }, "salaries" : 215000 } { _id : { "fiscal_year" : 2018, "dept" : "Z" }, "salaries" : 280000 } { _id : { "fiscal_year" : 2019, "dept" : "A" }, "salaries" : 275000 } { _id : { "fiscal_year" : 2019, "dept" : "Z" }, "salaries" : 410000 } { _id : { "fiscal_year" : 2020, "dept" : "Z" }, "salaries" : 240000 }
새 데이터만 삽입
$merge가 컬렉션의 기존 데이터를 덮어쓰지 않도록 하려면 whenMatched를 keepExisting 또는 fail로 설정합니다.
zoo 데이터베이스의 예시 salaries 컬렉션에는 직원 급여 및 부서 내역이 포함되어 있습니다.
db.salaries.insertMany( [ { _id : 1, employee: "Ant", dept: "A", salary: 100000, fiscal_year: 2017 }, { _id : 2, employee: "Bee", dept: "A", salary: 120000, fiscal_year: 2017 }, { _id : 3, employee: "Cat", dept: "Z", salary: 115000, fiscal_year: 2017 }, { _id : 4, employee: "Ant", dept: "A", salary: 115000, fiscal_year: 2018 }, { _id : 5, employee: "Bee", dept: "Z", salary: 145000, fiscal_year: 2018 }, { _id : 6, employee: "Cat", dept: "Z", salary: 135000, fiscal_year: 2018 }, { _id : 7, employee: "Gecko", dept: "A", salary: 100000, fiscal_year: 2018 }, { _id : 8, employee: "Ant", dept: "A", salary: 125000, fiscal_year: 2019 }, { _id : 9, employee: "Bee", dept: "Z", salary: 160000, fiscal_year: 2019 }, { _id : 10, employee: "Cat", dept: "Z", salary: 150000, fiscal_year: 2019 } ] )
reporting 데이터베이스의 컬렉션 orgArchive 에는 지난 회계연도의 과거 부서별 조직 기록이 포함되어 있습니다. 보관된 기록은 수정해서는 안 됩니다.
db.orgArchive.insertMany( [ { _id : ObjectId("5cd8c68261baa09e9f3622be"), "employees" : [ "Ant", "Gecko" ], "dept" : "A", "fiscal_year" : 2018 }, { _id : ObjectId("5cd8c68261baa09e9f3622bf"), "employees" : [ "Ant", "Bee" ], "dept" : "A", "fiscal_year" : 2017 }, { _id : ObjectId("5cd8c68261baa09e9f3622c0"), "employees" : [ "Bee", "Cat" ], "dept" : "Z", "fiscal_year" : 2018 }, { _id : ObjectId("5cd8c68261baa09e9f3622c1"), "employees" : [ "Cat" ], "dept" : "Z", "fiscal_year" : 2017 } ] )
orgArchive 0} 컬렉션은 및 필드에 고유한 복합 인덱스가 fiscal_year dept 있습니다. 특히 동일한 회계 연도 및 부서 조합에 대해 최대 하나의 레코드가 있어야 합니다.
db.getSiblingDB("reporting").orgArchive.createIndex ( { fiscal_year: 1, dept: 1 }, { unique: true } )
현재 회계연도 말(이 예에서는 2019 )에 salaries 컬렉션에 다음 문서가 포함됩니다.
db.salaries.insertMany( [ { _id : 1, "employee" : "Ant", "dept" : "A", "salary" : 100000, "fiscal_year" : 2017 }, { _id : 2, "employee" : "Bee", "dept" : "A", "salary" : 120000, "fiscal_year" : 2017 }, { _id : 3, "employee" : "Cat", "dept" : "Z", "salary" : 115000, "fiscal_year" : 2017 }, { _id : 4, "employee" : "Ant", "dept" : "A", "salary" : 115000, "fiscal_year" : 2018 }, { _id : 5, "employee" : "Bee", "dept" : "Z", "salary" : 145000, "fiscal_year" : 2018 }, { _id : 6, "employee" : "Cat", "dept" : "Z", "salary" : 135000, "fiscal_year" : 2018 }, { _id : 7, "employee" : "Gecko", "dept" : "A", "salary" : 100000, "fiscal_year" : 2018 }, { _id : 8, "employee" : "Ant", "dept" : "A", "salary" : 125000, "fiscal_year" : 2019 }, { _id : 9, "employee" : "Bee", "dept" : "Z", "salary" : 160000, "fiscal_year" : 2019 }, { _id : 10, "employee" : "Cat", "dept" : "Z", "salary" : 150000, "fiscal_year" : 2019 }, { _id : 11, "employee" : "Wren", "dept" : "Z", "salary" : 100000, "fiscal_year" : 2019 }, { _id : 12, "employee" : "Zebra", "dept" : "A", "salary" : 150000, "fiscal_year" : 2019 }, { _id : 13, "employee" : "headcount1", "dept" : "Z", "salary" : 120000, "fiscal_year" : 2020 }, { _id : 14, "employee" : "headcount2", "dept" : "Z", "salary" : 120000, "fiscal_year" : 2020 } ] )
방금 종료된 회계연도 2019 를 포함하도록 orgArchive 컬렉션을 업데이트하기 위해 다음 집계 파이프라인은 다음을 사용합니다.
db.getSiblingDB("zoo").salaries.aggregate( [ { $match: { fiscal_year: 2019 }}, { $group: { _id: { fiscal_year: "$fiscal_year", dept: "$dept" }, employees: { $push: "$employee" } } }, { $project: { _id: 0, dept: "$_id.dept", fiscal_year: "$_id.fiscal_year", employees: 1 } }, { $merge : { into : { db: "reporting", coll: "orgArchive" }, on: [ "dept", "fiscal_year" ], whenMatched: "fail" } } ] )
작업 후 orgArchive 컬렉션에는 다음 문서가 포함됩니다.
{ "_id" : ObjectId("5caccc6a66b22dd8a8cc419f"), "employees" : [ "Ahn", "Bess" ], "dept" : "A", "fiscal_year" : 2017 } { "_id" : ObjectId("5caccc6a66b22dd8a8cc419e"), "employees" : [ "Ahn", "Gee" ], "dept" : "A", "fiscal_year" : 2018 } { "_id" : ObjectId("5caccd0b66b22dd8a8cc438e"), "employees" : [ "Ahn", "Zeb" ], "dept" : "A", "fiscal_year" : 2019 } { "_id" : ObjectId("5caccc6a66b22dd8a8cc41a0"), "employees" : [ "Carl" ], "dept" : "Z", "fiscal_year" : 2017 } { "_id" : ObjectId("5caccc6a66b22dd8a8cc41a1"), "employees" : [ "Bess", "Carl" ], "dept" : "Z", "fiscal_year" : 2018 } { "_id" : ObjectId("5caccd0b66b22dd8a8cc438d"), "employees" : [ "Bess", "Carl", "Wen" ], "dept" : "Z", "fiscal_year" : 2019 }
orgArchive 컬렉션에 "A" 및/또는 "B" 부서에 대한 2019년 문서가 이미 포함되어 있는 경우 중복 키 오류로 인해 집계가 실패합니다. 그러나 오류가 발생하기 전에 삽입된 문서는 롤백되지 않습니다.
일치하는 문서에 대해 keepExisting을 지정하면 집계가 일치하는 문서에 영향을 주지 않고 중복 키 오류를 발생시키지 않습니다. 마찬가지로 바꾸기를 지정해도 작업이 실패하지는 않지만 기존 문서를 대체하게 됩니다.
여러 컬렉션의 결과 병합
기본적으로 집계 결과의 문서가 컬렉션의 문서와 일치하면 $merge 단계에서 문서가 병합됩니다.
예시 컬렉션 purchaseorders 은 분기 및 리전별 구매 주문 정보로 채워집니다.
db.purchaseorders.insertMany( [ { _id: 1, quarter: "2019Q1", region: "A", qty: 200, reportDate: new Date("2019-04-01") }, { _id: 2, quarter: "2019Q1", region: "B", qty: 300, reportDate: new Date("2019-04-01") }, { _id: 3, quarter: "2019Q1", region: "C", qty: 700, reportDate: new Date("2019-04-01") }, { _id: 4, quarter: "2019Q2", region: "B", qty: 300, reportDate: new Date("2019-07-01") }, { _id: 5, quarter: "2019Q2", region: "C", qty: 1000, reportDate: new Date("2019-07-01") }, { _id: 6, quarter: "2019Q2", region: "A", qty: 400, reportDate: new Date("2019-07-01") }, ] )
예시 collection reportedsales 는 분기 및 리전별로 보고된 판매 정보로 채워집니다.
db.reportedsales.insertMany( [ { _id: 1, quarter: "2019Q1", region: "A", qty: 400, reportDate: new Date("2019-04-02") }, { _id: 2, quarter: "2019Q1", region: "B", qty: 550, reportDate: new Date("2019-04-02") }, { _id: 3, quarter: "2019Q1", region: "C", qty: 1000, reportDate: new Date("2019-04-05") }, { _id: 4, quarter: "2019Q2", region: "B", qty: 500, reportDate: new Date("2019-07-02") }, ] )
보고 목적으로 다음 형식으로 분기별로 데이터를 보려고 한다고 가정합니다.
{ "_id" : "2019Q1", "sales" : 1950, "purchased" : 1200 } { "_id" : "2019Q2", "sales" : 500, "purchased" : 1700 }
$merge를 사용하여 purchaseorders 컬렉션과 reportedsales 컬렉션의 결과를 병합하여 새 컬렉션 quarterlyreport를 만들 수 있습니다.
0} 컬렉션을 만들려면 다음 파이프라인을 사용할 수 있습니다:quarterlyreport
db.purchaseorders.aggregate( [ { $group: { _id: "$quarter", purchased: { $sum: "$qty" } } }, // group purchase orders by quarter { $merge : { into: "quarterlyreport", on: "_id", whenMatched: "merge", whenNotMatched: "insert" } } ])
- 첫 번째 단계:
2} 단계는
$group분기별로 그룹화하고 를 사용하여 필드를$sum새qtypurchased필드에 추가합니다. 예시:quarterlyreport0} 컬렉션을 만들려면 이 파이프라인을 사용할 수 있습니다:{ "_id" : "2019Q2", "purchased" : 1700 } { "_id" : "2019Q1", "purchased" : 1200 } - 두 번째 단계:
$merge단계에서는 동일한 데이터베이스의quarterlyreport컬렉션에 문서를 씁니다. 해당 단계가 컬렉션에서_id필드와 일치하는 기존 문서를 찾으면 해당 단계는 일치하는 문서를 병합합니다. 그렇지 않으면 단계가 문서를 삽입합니다. 처음 생성할 때는 일치하는 문서가 없어야 합니다.
컬렉션의 문서를 보려면 다음 작업을 실행합니다.
db.quarterlyreport.find().sort( { _id: 1 } )
컬렉션에는 다음 문서가 포함되어 있습니다.
{ "_id" : "2019Q1", "sales" : 1200, "purchased" : 1200 } { "_id" : "2019Q2", "sales" : 1700, "purchased" : 1700 }
마찬가지로, reportedsales 컬렉션에 대해 다음 집계 파이프라인을 실행하여 판매 결과를 quarterlyreport 컬렉션에 병합합니다.
db.reportedsales.aggregate( [ { $group: { _id: "$quarter", sales: { $sum: "$qty" } } }, // group sales by quarter { $merge : { into: "quarterlyreport", on: "_id", whenMatched: "merge", whenNotMatched: "insert" } } ])
- 첫 번째 단계:
2} 단계는
$group분기별로 그룹화하고 를 사용하여 필드를$sum새qtysales필드에 추가합니다. 예시:{ "_id" : "2019Q2", "sales" : 500 } { "_id" : "2019Q1", "sales" : 1950 } - 두 번째 단계:
$merge스테이지에서는 동일한 데이터베이스의quarterlyreport컬렉션에 문서를 씁니다._id필드(분기)에서 일치하는 기존 문서가 컬렉션에서 발견되면 스테이지에서 일치하는 문서를 병합합니다. 그렇지 않으면 스테이지가 문서를 삽입합니다.
데이터가 병합된 후 quarterlyreport 컬렉션의 문서를 보려면 다음 작업을 실행하세요.
db.quarterlyreport.find().sort( { _id: 1 } )
컬렉션에는 다음 문서가 포함되어 있습니다.
{ "_id" : "2019Q1", "sales" : 1950, "purchased" : 1200 } { "_id" : "2019Q2", "sales" : 500, "purchased" : 1700 }
파이프라인을 사용하여 병합 사용자 지정하기
$merge는 문서가 일치할 때 사용자 지정 업데이트 파이프라인을 사용할 수 있습니다. whenMatched 파이프라인은 다음과 같은 단계를 가질 수 있습니다.
$addFields및 그 별칭$set$replaceRoot및 그 별칭$replaceWith
예시 컬렉션 votes 은 일일 투표 집계로 채워집니다. 다음 문서로 collection을 생성합니다.
db.votes.insertMany( [ { date: new Date("2019-05-01"), "thumbsup" : 1, "thumbsdown" : 1 }, { date: new Date("2019-05-02"), "thumbsup" : 3, "thumbsdown" : 1 }, { date: new Date("2019-05-03"), "thumbsup" : 1, "thumbsdown" : 1 }, { date: new Date("2019-05-04"), "thumbsup" : 2, "thumbsdown" : 2 }, { date: new Date("2019-05-05"), "thumbsup" : 6, "thumbsdown" : 10 }, { date: new Date("2019-05-06"), "thumbsup" : 13, "thumbsdown" : 16 } ] )
또 다른 예시 컬렉션 monthlytotals 에는 최신 월별 투표 합계가 있습니다. 다음 문서로 collection을 생성합니다.
db.monthlytotals.insertOne( { "_id" : "2019-05", "thumbsup" : 26, "thumbsdown" : 31 } )
매일 하루가 끝나면 그날의 투표가 votes 컬렉션에 삽입됩니다:
db.votes.insertOne( { date: new Date("2019-05-07"), "thumbsup" : 14, "thumbsdown" : 10 } )
사용자 지정 파이프라인과 함께 $merge를 사용하여 컬렉션 monthlytotals의 기존 문서를 업데이트할 수 있습니다:
db.votes.aggregate([ { $match: { date: { $gte: new Date("2019-05-07"), $lt: new Date("2019-05-08") } } }, { $project: { _id: { $dateToString: { format: "%Y-%m", date: "$date" } }, thumbsup: 1, thumbsdown: 1 } }, { $merge: { into: "monthlytotals", on: "_id", whenMatched: [ { $addFields: { thumbsup: { $add:[ "$thumbsup", "$$new.thumbsup" ] }, thumbsdown: { $add: [ "$thumbsdown", "$$new.thumbsdown" ] } } } ], whenNotMatched: "insert" } } ])
- 첫 번째 단계:
$match단계에서는 특정 날짜의 투표를 찾습니다. 예시:{ "_id" : ObjectId("5ce6097c436eb7e1203064a6"), "date" : ISODate("2019-05-07T00:00:00Z"), "thumbsup" : 14, "thumbsdown" : 10 } - 두 번째 단계:
$project단계는_id필드를 연도-월 문자열로 설정합니다. 예시:{ "thumbsup" : 14, "thumbsdown" : 10, "_id" : "2019-05" } - 세 번째 단계:
$merge단계에서는 동일한 데이터베이스의monthlytotals컬렉션에 문서를 씁니다. 스테이지가 컬렉션에서_id필드와 일치하는 기존 문서를 찾으면 스테이지는 파이프라인을 사용하여thumbsup표와thumbsdown표를 추가합니다.이 파이프라인은 결과 문서의 필드에 직접 액세스할 수 없습니다. 결과 문서의
thumbsup필드와thumbsdown필드에 액세스하기 위해 파이프라인은$$new변수 (예:$$new.thumbsup및$new.thumbsdown) 를 사용합니다.이 파이프라인은 컬렉션에 있는 기존 문서의
thumbsup필드와thumbsdown필드 (예:$thumbsup및$thumbsdown) 에 직접 액세스할 수 있습니다.
결과 문서가 기존 문서를 대체합니다.
병합 작업 후 monthlytotals 컬렉션의 문서를 보려면 다음 작업을 실행하세요.
db.monthlytotals.find()
컬렉션에는 다음 문서가 포함되어 있습니다.
{ "_id" : "2019-05", "thumbsup" : 40, "thumbsdown" : 41 }
변수를 사용하여 병합 사용자 지정
$merge 단계의 whenMatched 필드에 변수를 사용할 수 있습니다. 변수를 사용하려면 먼저 변수를 정의해야 합니다.
다음 중 하나 또는 둘 모두에서 변수를 정의합니다:
때매치에서변수를 사용하려면:
변수 이름과 함께 이중 달러 기호 ($$) 접두사를 $$<variable_name> 형식으로 지정합니다. 예시: $$year. 변수가 문서로 설정된 경우 $$<variable_name>.<field> 형식으로 문서 필드를 포함할 수도 있습니다. 예시: $$year.month.
아래 탭은 병합 단계, 집계 명령 또는 둘 다에서 변수가 정의될 때의 동작을 보여줍니다.
병합 단계에서 정의된 변수 사용
$merge 단계에서 변수를 정의 하고 whenMatched 필드에서 변수를 사용할 수 있습니다.
예시:
db.cakeSales.insertOne( [ { _id: 1, flavor: "chocolate", salesTotal: 1580, salesTrend: "up" } ] ) db.runCommand( { aggregate: db.cakeSales.getName(), pipeline: [ { $merge: { into: db.cakeSales.getName(), let : { year: "2020" }, whenMatched: [ { $addFields: { "salesYear": "$$year" } } ] } } ], cursor: {} } ) db.cakeSales.find()
예시입니다:
라는 이름의 컬렉션 생성
cakeSales$mergelet에서year변수를 정의하는aggregate명령을 실행하고 whenMatched를 사용하여cakeSales에 연도를 추가합니다.retrieves the
cakeSalesdocument
출력:
{ "_id" : 1, "flavor" : "chocolate", "salesTotal" : 1580, "salesTrend" : "up", "salesYear" : "2020" }
집계 명령에 정의된 변수 사용
버전 5.0에 추가 되었습니다.:
aggregate 명령 let에서 변수를 정의하고 $merge 단계 whenMatched 필드에서 변수를 사용할 수 있습니다.
예시:
db.cakeSales.insertOne( { _id: 1, flavor: "chocolate", salesTotal: 1580, salesTrend: "up" } ) db.runCommand( { aggregate: db.cakeSales.getName(), pipeline: [ { $merge: { into: db.cakeSales.getName(), whenMatched: [ { $addFields: { "salesYear": "$$year" } } ] } } ], cursor: {}, let : { year: "2020" } } ) db.cakeSales.find()
예시입니다:
라는 이름의 컬렉션 생성
cakeSalesaggregate명령 let에서year변수를 정의하는aggregate명령을 실행하고 whenMatched를 사용하여cakeSales에 연도를 추가합니다.retrieves the
cakeSalesdocument
출력:
{ "_id" : 1, "flavor" : "chocolate", "salesTotal" : 1580, "salesTrend" : "up", "salesYear" : "2020" }
병합 단계 및 집계 명령에 정의된 변수 사용
$merge 단계에서 변수를 정의할 수 있으며 MongoDB 5.0부터는 aggregate 명령입니다.
동일한 이름을 가진 두 개의 변수가 $merge 단계와 aggregate 명령에 정의된 경우 $merge 단계 변수가 사용됩니다.
이 예에서는 year: "2019" 명령 aggregate 변수 대신 year: "2020" $merge 단계 변수가 사용됩니다.
db.cakeSales.insertOne( { _id: 1, flavor: "chocolate", salesTotal: 1580, salesTrend: "up" } ) db.runCommand( { aggregate: db.cakeSales.getName(), pipeline: [ { $merge: { into: db.cakeSales.getName(), let : { year: "2020" }, whenMatched: [ { $addFields: { "salesYear": "$$year" } } ] } } ], cursor: {}, let : { year: "2019" } } ) db.cakeSales.find()
출력:
{ _id: 1, flavor: 'chocolate', salesTotal: 1580, salesTrend: 'up', salesYear: '2020' }
다음 Movie 클래스는 이 예시에 사용된 문서를 모델링합니다.
[] public class Movie { [] public ObjectId Id { get; set; } [] public string Title { get; set; } = null!; [] public int? Year { get; set; } [] public int? Runtime { get; set; } [] public string? Rated { get; set; } [] public int Metacritic { get; set; } [] public string? Plot { get; set; } [] public string? Type { get; set; } [] public string[]? Cast { get; set; } [] public string[]? Directors { get; set; } [] public string[]? Writers { get; set; } [] public ImdbData? Imdb { get; set; } }
MongoDB .NET/ C# 운전자 사용하여 $merge 집계 파이프라인 에 단계를 추가하려면 PipelineDefinition 객체 에서 UnionWith() 메서드를 호출합니다.
Merge() 메서드를 호출할 때는 MergeStageOptions 클래스의 인스턴스 전달해야 합니다. 이 객체 사용하면 일치하는 문서를 처리하다 방법과 같은 $merge 단계에 대한 옵션을 지정할 수 있습니다.
다음 예시 파이프 파이프라인 의 문서를 movies 컬렉션 에 병합하는 파이프라인 단계를 만듭니다. MergeStageOptions 객체 다음 옵션을 지정합니다.
OnFieldNames옵션은 작업이"_id"필드를 사용하여 일치하는 문서를 식별하도록 지정합니다.WhenMatched옵션은 소스 컬렉션의 문서가 대상 컬렉션의 문서와 일치하는 경우 일치하는 문서를 대체하도록 지정합니다.WhenNotMatched옵션은 소스 컬렉션의 문서가 대상 컬렉션의 문서와 일치하지 않는 경우 작업이 문서를 대상 컬렉션에 삽입하도록 지정합니다.
var pipeline = new EmptyPipelineDefinition<Movie>() .Merge(_targetCollection, new MergeStageOptions<Movie>() { OnFieldNames = new List<string>() { "_id" }, WhenMatched = MergeStageWhenMatched.Replace, WhenNotMatched = MergeStageWhenNotMatched.Insert, });
{ "_id": "...", "title": "Back to the Future", "metacritic": 96 } { "_id": "...", "title": "Jurassic Park", "metacritic": 68 } { "_id": "...", "title": "The Shawshank Redemption", "metacritic": 80 }
이 페이지의 Node.js 예제에서는 Atlas 샘플 데이터 세트의 sample_mflix 데이터베이스 사용합니다. 무료 MongoDB Atlas cluster 생성하고 샘플 데이터 세트를 로드하는 방법을 학습하려면 MongoDB Node.js 운전자 설명서에서 시작하기 를 참조하세요.
MongoDB Node.js 운전자 사용하여 집계 파이프라인 에 $merge 단계를 추가하려면 파이프라인 객체 에서 $merge 연산자 사용합니다.
다음 예시 파이프 파이프라인 의 문서를 movies 컬렉션 에 병합하는 파이프라인 단계를 만듭니다. 이 예시 에는 다음 필드가 포함되어 있습니다.
on옵션은 작업이"_id"및"title"필드를 사용하여 소스 컬렉션 과movies컬렉션 에서 일치하는 문서를 찾도록 지정합니다.whenMatched옵션은 소스 컬렉션 의 문서movies컬렉션 의 문서 와 일치하는 경우movies컬렉션 의 문서 대체하도록 지정합니다.whenNotMatched옵션은 소스 컬렉션 의 문서movies컬렉션 의 문서 와 일치하지 않는 경우 작업이movies컬렉션 에 문서 삽입하도록 지정합니다.
그런 다음 이 예시 에서는 집계 파이프라인 실행합니다.
const pipeline = [ { $merge: { into: "movies", on: ["_id", "title"], whenMatched: "replace", whenNotMatched: "insert" } } ]; const cursor = collection.aggregate(pipeline); return cursor;