Make the MongoDB docs better! We value your opinion. Share your feedback for a chance to win $100.
Click here >
Docs Menu
Docs Home
/ /
집계 단계
Docs Home
/
개발
/
쿼리 언어
/
집계 단계
Docs Home
/
개발
/
쿼리 언어
/
집계 단계

$lookup (집계 단계)

정의

$lookup

버전 8.0에서 변경되었습니다.

동일한 데이터베이스 내 컬렉션에 대해 왼쪽 외부 조인을 수행하여, 처리를 위해 외부 컬렉션의 문서를 필터링합니다. $lookup 단계에서는 각 입력 문서에 새 배열 필드를 추가합니다. 새 배열 필드에는 외부 컬렉션에서 일치하는 문서가 포함됩니다. $lookup 단계에서는 이렇게 재구성된 문서를 다음 단계로 넘깁니다.

MongoDB 5.1부터 샤딩된 컬렉션에 $lookup을 사용할 수 있습니다.

서로 다른 두 컬렉션의 요소를 결합하려면 $unionWith 파이프라인 단계를 사용합니다.

중요

$lookup 을 과도하게 사용하면 쿼리 성능이 저하될 수 있습니다. $lookup에 대한 의존도를 줄이려면 관련 데이터를 단일 컬렉션에 저장할 임베디드 데이터 모델 을 고려하세요.

$lookup 성능에 대한 자세한 내용은 성능 고려 사항을 참조하세요.

호환성

다음 환경에서 호스팅되는 배포에 $lookup 사용할 수 있습니다.

  • MongoDB Atlas: 클라우드에서의 MongoDB 배포를 위한 완전 관리형 서비스

구문

$lookup 단계 구문:

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       let: { <var_1>: <expression>, …, <var_n>: <expression> },
       pipeline: [ <pipeline to run> ],
       as: <output array field>
     }
}

$lookup은 다음과 같은 필드가 있는 문서를 수락합니다.

필드
필요성
설명

FROM

필수 사항

동일한 데이터베이스에서 로컬 컬렉션에 조인할 외부 컬렉션을 지정합니다.

일부 경우에는 첫 번째 단계로 $documents 를 사용하여 from 을 pipeline 로 대체하는 것이 가능합니다. 예시는 $lookup 단계에서 $documents 단계 사용하기를 참조하세요.

MongoDB 5.1부터 from 컬렉션을 샤딩할 수 있습니다.

localField

pipeline이 지정된 경우, 선택 사항

문서 입력에서 단계까지의 $lookup 필드 를 지정합니다. 는 컬렉션 의 문서에서 에 대한 에 대해$lookup 동등성 매치 수행합니다.localField foreignField from 입력 문서 가 포함되어 있지 않은 경우 localField 는 매칭을 위해 $lookup 필드 값이 인 null 것으로 처리합니다.

foreignField

pipeline이 지정된 경우, 선택 사항

로컬 문서의 localField와 동등성 매치를 수행하도록 외부 문서의 foreignField를 지정합니다.

외부 문서 foreignField 값이 포함되어 $lookup 있지 않으면 는 null 일치를 위해 값을 사용합니다.

하자

옵션

파이프라인 단계에서 사용할 변수를 지정합니다. 변수 표현식을 사용하여 pipeline에 입력되는 로컬 컬렉션 문서의 필드에 액세스합니다.

파이프라인 단계에서 변수를 참조하려면 "$$<variable>" 구문을 사용합니다.

let 변수는 에 중첩된 추가 단계를 $lookup 포함하여 파이프라인 의 단계에서 액세스할 수 pipeline 있습니다.

  • $match 단계에서는 $expr 연산자를 사용하여 변수에 액세스해야 합니다. $expr 연산자를 사용하면 $match 구문 내에서 집계 표현식을 사용할 수 있습니다.

    $expr연산자 에 배치된$eq , $lt , $lte , $gt및$gte비교 연산자는$lookup단계에서 참조된 from 컬렉션 의 인덱스 사용할 수 있습니다. 제한 사항:

    • 인덱스는 필드와 상수 간의 비교에만 사용할 수 있으므로 let 피연산자는 상수로 해결되어야 합니다.

      예를 들어 $a 및 상수 값 간의 비교에는 인덱스를 사용할 수 있지만, $a 및 $b 간의 비교에는 인덱스를 사용할 수 없습니다.

    • let 피연산자가 비어 있거나 누락된 값으로 확인되는 비교에는 인덱스가 사용되지 않습니다.

    • 멀티키, 부분 또는 희소 인덱스는 사용되지 않습니다.

  • 파이프라인 의 다른( 이$match 아님) 단계에서는 $expr 변수에 액세스 위해 연산자 필요하지 않습니다.

파이프라인

localField 및 foreignField가 지정된 경우, 선택 사항

외부 컬렉션에서 실행할 pipeline을 지정합니다. pipeline은 외부 컬렉션에서 문서를 반환합니다. 모든 문서를 반환하려면 빈 pipeline: []을 지정합니다.

pipeline 에는 $out 또는 $merge 단계를 포함할 수 없습니다. v6.0부터 pipeline 는 파이프라인 내부의 첫 번째 단계로 MongoDB Search $search 단계를 포함할 수 있습니다. 자세한 학습 은 MongoDB 검색 지원을 참조하세요.

pipeline은 입력 문서의 필드에 액세스할 수 없습니다. 대신 let 옵션을 사용하여 문서 필드에 대한 변수를 정의한 다음 pipeline 단계에서 변수를 참조합니다.

파이프라인 단계에서 변수를 참조하려면 "$$<variable>" 구문을 사용합니다.

let 변수는 에 중첩된 추가 단계를 $lookup 포함하여 파이프라인 의 단계에서 액세스할 수 pipeline 있습니다.

  • $match 단계에서는 $expr 연산자를 사용하여 변수에 액세스해야 합니다. $expr 연산자를 사용하면 $match 구문 내에서 집계 표현식을 사용할 수 있습니다.

    $expr연산자 에 배치된$eq , $lt , $lte , $gt및$gte비교 연산자는$lookup단계에서 참조된 from 컬렉션 의 인덱스 사용할 수 있습니다. 제한 사항:

    • 인덱스는 필드와 상수 간의 비교에만 사용할 수 있으므로 let 피연산자는 상수로 해결되어야 합니다.

      예를 들어 $a 및 상수 값 간의 비교에는 인덱스를 사용할 수 있지만, $a 및 $b 간의 비교에는 인덱스를 사용할 수 없습니다.

    • let 피연산자가 비어 있거나 누락된 값으로 확인되는 비교에는 인덱스가 사용되지 않습니다.

    • 멀티키, 부분 또는 희소 인덱스는 사용되지 않습니다.

  • 파이프라인 의 다른( 이$match 아님) 단계에서는 $expr 변수에 액세스 위해 연산자 필요하지 않습니다.

방식

필수 사항

입력 문서에 추가할 새 배열 필드의 이름을 지정합니다. 새 배열 필드에는 from 컬렉션에서 매칭되는 문서가 포함됩니다. 지정된 이름이 입력 문서에 이미 존재하는 경우 기존 필드를 덮어씁니다.

단일 조인 조건으로 동일성 일치

입력 문서의 필드와 외부 컬렉션의 문서 필드 간에 동등성 매치를 수행하기 위해, $lookup 단계는 다음과 같은 구문을 가집니다.

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       pipeline: [ <pipeline to run> ],
       as: <output array field>
     }
}

참고

이 예시 에서 pipeline 은 선택 사항이며 로컬 및 외부 동일성 단계 이후에 실행됩니다.

이 작업은 다음과 같은 유사 SQL 문장에 해당합니다.

SELECT *, (
   SELECT ARRAY_AGG(*)
   FROM <collection to join>
   WHERE <foreignField> = <collection.localField>
) AS <output array field>
FROM collection;

참고

이 페이지의 SQL 문은 MongoDB 집계 파이프라인 구문과 비교할 수 있도록 포함되어 있습니다. SQL 문을 실행할 수 없습니다.

MongoDB 예시는 이 페이지를 참조하세요.

외래 컬렉션에 대한 조인 조건 및 하위 쿼리

MongoDB는 다음을 지원합니다.

  • 외부 컬렉션에서 파이프라인 실행하기.

  • 여러 조인 조건.

  • 상관관계가 있는 하위 쿼리와 상관관계가 없는 하위 쿼리.

MongoDB 에서 상관 관계가 없는 하위 쿼리는 모든 입력 문서 동일한 결과를 반환한다는 의미입니다. 상관 하위 쿼리는 로컬 $lookup 또는 input 컬렉션의 필드를 사용하여 각 수신 문서 와 관련된 결과를 반환하는 단계의 파이프라인 입니다.

참고

MongoDB 5.0부터는 $lookup 파이프라인 단계에서 $sample 단계, $sampleRate 연산자 또는 $rand 연산자를 포함하는 상관 관계가 없는 하위 쿼리의 경우, 반복 시 항상 하위 쿼리가 다시 실행됩니다. 이전에는 하위 쿼리 출력 크기에 따라 하위 쿼리 출력이 캐시되거나 하위 쿼리가 다시 실행되었습니다.

MongoDB 상관 서브쿼리는 내부 쿼리가 외부 쿼리 값을 참조하는 SQL 상관 서브쿼리와 유사합니다. SQL 비연관 서브쿼리는 외부 쿼리 값을 참조하지 않습니다.

MongoDB 5.0은 상관관계가 있는 간결한 하위 쿼리도 지원합니다.

두 컬렉션에 대해 상관 관계 및 비상관 관계 하위 쿼리를 수행하고 단일 동등성 매치 외에 다른 조인 조건을 수행하려면 이 $lookup 구문을 사용합니다.

{
   $lookup:
      {
         from: <foreign collection>,
         let: { <var_1>: <expression>, …, <var_n>: <expression> },
         pipeline: [ <pipeline to run on foreign collection> ],
         as: <output array field>
      }
}

이 작업은 다음과 같은 유사 SQL 문장에 해당합니다.

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (
   SELECT <documents as determined from the pipeline>
   FROM <collection to join>
   WHERE <pipeline>
);

다음 예시를 참조하세요.

간결한 구문을 사용한 상호 연관된 하위 쿼리

버전 5.0에 추가.

MongoDB 5.0부터는 상관 하위 쿼리에 간결한 구문을 사용할 수 있습니다. 상관 하위 쿼리는 외부 컬렉션과 aggregate() 메서드가 실행된 '로컬' 컬렉션의 문서 필드를 참조합니다.

다음과 같은 새롭고 간결한 구문은 $expr 연산자 내부의 외부 및 로컬 필드에 대한 동등성 매치 요구 사항을 제거합니다.

{
   $lookup:
      {
         from: <foreign collection>,
         localField: <field from local collection's documents>,
         foreignField: <field from foreign collection's documents>,
         let: { <var_1>: <expression>, …, <var_n>: <expression> },
         pipeline: [ <pipeline to run> ],
         as: <output array field>
      }
}

이 작업은 다음과 같은 유사 SQL 문장에 해당합니다.

SELECT *, <output array field>
FROM localCollection
WHERE <output array field> IN (
   SELECT <documents as determined from the pipeline>
   FROM <foreignCollection>
   WHERE <foreignCollection.foreignField> = <localCollection.localField>
   AND <pipeline match condition>
);

이 예시를 참조하세요.

행동

암호화된 컬렉션

MongoDB 8.1부터는 $lookup 단계에서 여러 개의 암호화됨 컬렉션을 참조할 수 있습니다. 그러나 $lookup 은(는) 지원 하지 않습니다.

  • 암호화됨 필드 localField 또는 foreignField에서 조인 필드 로 사용합니다.

    참고

    클라이언트 측 필드 레벨 암호화 사용하는 드라이버의 경우 자체 조인 작업을 수행하는 경우에만 암호화됨 필드 조인 필드 로 사용할 수 있습니다.

  • 암호화됨 배열 의 필드 사용. 배열 암호화됨 요소가 포함되어 있으면 암호화됨 것으로 간주됩니다.

    • 예시 들어, 클라이언트 측 필드 레벨 암호화 및 필드 사용하지 않는 한 결과 내의 어떤 $lookup $unwind 필드 작업의 배열 로 사용할 수 as 없습니다.

보기 및 데이터 정렬

$lookup 또는 $graphLookup 등 여러 뷰가 포함된 집계를 수행하는 경우 반드시 뷰의 데이터 정렬이 동일해야 합니다.

제한 사항

$out 또는 $merge 단계는 $lookup 단계에 포함할 수 없습니다. 즉, 외부 컬렉션에 대한 파이프라인을 지정할 때 pipeline 필드에 어느 단계도 포함할 수 없습니다.

{
   $lookup:
   {
      from: <collection to join>,
      let: { <var_1>: <expression>, …, <var_n>: <expression> },
      pipeline: [ <pipeline to execute on the foreign collection> ],  // Cannot include $out or $merge
      as: <output array field>
   }
}

MongoDB 검색 지원

MongoDB 6.0 부터는 파이프라인 에서 MongoDB Search $search 또는 $searchMeta 단계를 지정하여 $lookup Atlas cluster 에서 컬렉션을 검색 수 있습니다. $search 또는 $searchMeta 단계는 $lookup 파이프라인 내의 첫 번째 단계여야 합니다.

예를 들어, 외부 컬렉션에서 조건 및 하위 쿼리를 조인하거나 간결한 구문을 사용하여 상관 하위 쿼리를 실행하는 경우 아래와 같이 파이프라인에 $search 또는 $searchMeta를 지정할 수 있습니다.

[{
  "$lookup": {
    "from": <foreign collection>,
    localField: <field from the input documents>,
    foreignField: <field from the documents of the "from" collection>,
    "as": <output array field>,
    "pipeline": [{
      "$search": {
        "<operator>": {
          <operator-specification>
        }
      },
      ...
    }]
  }
}]
[{
  "$lookup": {
    "from": <foreign collection>,
    localField: <field from the input documents>,
    foreignField: <field from the documents of the "from" collection>,
    "as": <output array field>,
    "pipeline": [{
      "$searchMeta": {
        "<collector>": {
          <collector-specification>
        }
      },
      ...
    }]
  }
}]

을 $lookup 사용한 $search 의 예시 보려면 MongoDB Search 튜토리얼 $lookup을 사용하여 MongoDB Search $ 검색 쿼리 실행하기를 참조하세요.

샤드 컬렉션

MongoDB 5.1부터 $lookup 단계의 from 파라미터에서 샤딩된 컬렉션을 지정할 수 있습니다.

MongoDB 8.0부터 샤딩된 컬렉션을 대상으로 하는 트랜잭션 내에서 $lookup 단계를 사용할 수 있습니다.

슬롯 기반 쿼리 실행 엔진

6.0버전부터 파이프라인의 모든 이전 단계가 슬롯 기반 실행 엔진에서도 실행될 수 있고 다음 조건 중 어느 것도 참이 아닌 경우 MongoDB는 슬롯 기반 실행 쿼리 엔진을 사용하여 $lookup 단계를 실행할 수 있습니다.

  • $lookup 작업은 외부 컬렉션에서 파이프라인을 실행합니다. 이러한 종류의 작업 예시를 보려면 외부 컬렉션의 조인 조건 및 하위 쿼리를 참조하세요.

  • $lookup의 localField 또는 foreignField는 숫자 구성 요소를 지정합니다. 예시: { localField: "restaurant.0.review" }

  • 파이프라인에서 $lookup의 from 필드는 뷰 또는 샤드 컬렉션을 지정합니다.

자세한 내용은 $lookup 최적화를 참조하세요.

성능 고려 사항

$lookup 성능은 수행되는 작업 유형에 따라 달라집니다. 다양한 $lookup 작업에 대한 성능 고려 사항은 다음 표를 참조하세요.

$lookup 작업
성능 고려 사항

한 번의 조인으로 동등성 매치

  • $lookup 연산은 단일 조인으로 동등성 매치를 수행하고, 외부 컬렉션에 foreignField에 대한 인덱스가 포함된 경우 성능이 더 우수합니다.

    중요: foreignField에 대한 지원 인덱스가 없는 경우 단일 조인으로 동등성 매치를 수행하는 $lookup 작업의 성능이 저하될 가능성이 있습니다.

관련 없는 하위 쿼리

  • $lookup 연산은 관련 없는 하위 쿼리를 포함하며, 내부 파이프라인이 외부 컬렉션의 인덱스를 참조할 수 있을 때 성능이 더 우수합니다.

  • MongoDB는 소스 컬렉션과 외부 컬렉션 사이에 관계가 없기 때문에 쿼리를 캐싱하기 전에 $lookup 하위 쿼리를 한 번만 실행하면 됩니다. 하위 쿼리는 소스 컬렉션의 값을 기반으로 하지 않습니다. 이 동작은 $lookup 작업의 후속 실행에 대한 성능을 향상시킵니다.

연관된 하위 쿼리

  • $lookup 연산은 연관된 하위 쿼리를 포함하며, 다음의 조건이 적용될 때 성능이 더 우수합니다.

    • 외부 컬렉션에 foreignField에 대한 인덱스가 포함.

    • 외부 컬렉션 에는 내부 파이프라인 참조하는 인덱스 포함되어 있습니다.

  • 파이프라인이 많은 수의 문서를 $lookup 쿼리에 전달하는 경우 다음 전략을 사용하면 성능이 향상될 수 있습니다.

    • MongoDB가 $lookup 쿼리에 전달하는 문서 수를 줄입니다. 예를 들어 $match 단계에서 더 엄격한 필터를 설정합니다.

    • $lookup 하위 쿼리의 내부 파이프라인 별도의 쿼리 로 실행하고 $out 을(를) 사용하여 임시 컬렉션 만듭니다. 그런 다음 단일 조인으로 동등성 매치 실행 .

    • 데이터의 스키마를 재검토하여 사용 사례에 적합한지 확인합니다.

일반적인 성능 전략은 인덱싱 전략 및 쿼리 최적화를 참조하세요.

예시

이 페이지의 예시에서는 sample_mflix 샘플 데이터 세트의 데이터를 사용합니다. 이 데이터 세트를 자체 관리형 MongoDB 배포서버에 로드하는 방법에 대한 자세한 내용은 샘플 데이터 세트 로드를 참조하세요. 샘플 데이터베이스를 수정한 경우 이 페이지의 예시를 실행 하려면 데이터베이스를 제거하고 다시 만들어야 할 수 있습니다.

단일 동일성 조인 수행하기 - $lookup

다음 집계 작업은 먼저 movies 컬렉션 1000보다 큰 runtime 를 가진 영화로 필터링한 다음 _id 및 movie_id 필드에서 comments 컬렉션 과 조인합니다.

db.movies.aggregate( [
   { $match: { runtime: { $gt: 1000 } } },
   {
      $lookup: {
         from: "comments",
         localField: "_id",
         foreignField: "movie_id",
         as: "movie_comments"
      }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         year: 1,
         "movie_comments.name": 1,
         "movie_comments.text": 1,
         "movie_comments.date": 1
      }
   }
] )
[
  {
    title: 'Centennial',
    year: 1978,
    movie_comments: [
      {
        name: 'Ellaria Sand',
        text: 'Excepturi nam nam eum possimus aspernatur autem. Quis nulla optio praesentium ut distinctio explicabo.',
        date: ISODate('1995-08-18T03:01:50.000Z')
      }
    ]
  },
  { title: 'Baseball', year: 1994, movie_comments: [] }
]

이 작업은 다음과 같은 유사 SQL 문장에 해당합니다.

SELECT *, movie_comments
FROM movies
WHERE movie_comments IN (
   SELECT *
   FROM comments
   WHERE movie_id = movies._id
);

자세한 내용은 동등성 매치 성능 고려 사항을 참조하세요.

배열에사용 $lookup

localField가 배열인 경우 $unwind 단계 없이 스칼라 foreignField에 일치시킬 수 있습니다.

다음 집계 작업은 movies 컬렉션 users 컬렉션 과 조인하여 movies 의 cast 배열 필드 users의 스칼라 name 필드 와 일치시킵니다.

db.movies.aggregate( [
   {
      $match: {
         title: {
            $in: [ "Roger & Me", "The Sum of Us",
               "Centennial" ]
         }
      }
   },
   {
      $lookup: {
         from: "users",
         localField: "cast",
         foreignField: "name",
         as: "cast_users"
      }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         year: 1,
         cast: 1,
         "cast_users.name": 1,
         "cast_users.email": 1
      }
   },
   { $sort: { year: 1 } }
] )
[
  {
    cast: [
      'Raymond Burr',
      'Barbara Carrera',
      'Richard Chamberlain',
      'Robert Conrad'
    ],
    title: 'Centennial',
    year: 1978,
    cast_users: []
  },
  {
    cast: [
      'Michael Moore',
      'Roger B. Smith',
      'Rhonda Britton',
      'Fred Ross'
    ],
    title: 'Roger & Me',
    year: 1989,
    cast_users: [ { name: 'Michael Moore', email: 'michael_moore@fakegmail.com' } ]
  },
  {
    cast: [
      'Jack Thompson',
      'Russell Crowe',
      'John Polson',
      'Deborah Kennedy'
    ],
    title: 'The Sum of Us',
    year: 1994,
    cast_users: [
      {
        name: 'Deborah Kennedy',
        email: 'deborah_kennedy@fakegmail.com'
      }
    ]
  }
]

와 함께 사용 $lookup $mergeObjects

$mergeObjects 연산자는 여러 문서를 단일 문서로 결합합니다.

The following 작업 uses $lookup to join the movies 컬렉션 with the comments 컬렉션, then uses $mergeObjects in $replaceRoot to merge the first comment document with the movie document:

db.movies.aggregate( [
   { $match: { runtime: { $gt: 1000 } } },
   {
      $lookup: {
         from: "comments",
         localField: "_id",
         foreignField: "movie_id",
         as: "movie_comments"
      }
   },
   {
      $replaceRoot: {
         newRoot: {
            $mergeObjects: [
               { $arrayElemAt: [ "$movie_comments", 0 ] },
               "$$ROOT"
            ]
         }
      }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         year: 1,
         genres: 1,
         name: 1,
         email: 1,
         text: 1,
         date: 1
      }
   }
] )
[
  {
    name: 'Ellaria Sand',
    email: 'indira_varma@gameofthron.es',
    text: 'Excepturi nam nam eum possimus aspernatur autem. Quis nulla optio praesentium ut distinctio explicabo.',
    date: ISODate('1995-08-18T03:01:50.000Z'),
    genres: [ 'Action', 'Adventure', 'Drama' ],
    title: 'Centennial',
    year: 1978
  },
  {
    genres: [ 'Documentary', 'History', 'Sport' ],
    title: 'Baseball',
    year: 1994
  }
]

다중 조인 조건 및 상관관계 하위 쿼리 사용

파이프라인은 외부 컬렉션에서 실행할 수 있으며 여러 조인 조건을 포함할 수 있습니다. $expr 연산자를 사용하면 접속사 및 비동등성 매치를 포함한 더 복잡한 조인 조건이 가능합니다.

조인 조건은 aggregate() 메서드가 실행된 로컬 컬렉션의 필드를 참조하고 외부 컬렉션의 필드를 참조할 수 있습니다. 이렇게 하면 두 컬렉션 간에 상관 하위 쿼리가 가능합니다.

MongoDB 5.0은 상관관계가 있는 간결한 하위 쿼리를 지원합니다.

다음 예제입니다.

  • _id 및 movie_id 필드를 사용하여 movies 및 comments 컬렉션을 조인합니다.

  • 영화 출시하다 연도 이후에 게시된 댓글만 포함하도록 댓글을 필터링합니다.

db.movies.aggregate( [
   {
      $match: {
         title: {
            $in: [ "Class Action", "Kafka", "Corpse Bride" ]
         }
      }
   },
   {
      $lookup: {
         from: "comments",
         localField: "_id",
         foreignField: "movie_id",
         let: { movie_year: "$year" },
         pipeline: [
            {
               $match: {
                  $expr: {
                     $gt: [
                        { $year: "$date" }, "$$movie_year"
                     ]
                  }
               }
            },
            { $project: { _id: 0, name: 1, date: 1 } }
         ],
         as: "post_release_comments"
      }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         year: 1,
         post_release_comments: 1
      }
   }
] )
[
  {
    year: 1991,
    title: 'Class Action',
    post_release_comments: [
      { name: 'Khal Drogo', date: ISODate('2016-12-06T07:17:03.000Z') }
    ]
  },
  {
    year: 1991,
    title: 'Kafka',
    post_release_comments: [
      { name: 'Khal Drogo', date: ISODate('1998-05-10T03:10:20.000Z') }
    ]
  },
  { year: 2005, title: 'Corpse Bride', post_release_comments: [] }
]

이 작업은 다음과 같은 유사 SQL 문장에 해당합니다.

SELECT *, post_release_comments
FROM movies
WHERE post_release_comments IN (
   SELECT name, date
   FROM comments
   WHERE movie_id = movies._id
   AND YEAR(date) > movies.year
);

$expr 연산자에 배치된 $eq, $lt, $lte, $gt, $gte 비교 연산자는 $lookup 단계에서 참조된 from 컬렉션의 인덱스를 사용할 수 있습니다. 제한 사항:

  • 인덱스는 필드와 상수 간의 비교에만 사용할 수 있으므로 let 피연산자는 상수로 해결되어야 합니다.

    예를 들어 $a 및 상수 값 간의 비교에는 인덱스를 사용할 수 있지만, $a 및 $b 간의 비교에는 인덱스를 사용할 수 없습니다.

  • let 피연산자가 비어 있거나 누락된 값으로 확인되는 비교에는 인덱스가 사용되지 않습니다.

  • 멀티키, 부분 또는 희소 인덱스는 사용되지 않습니다.

예를 들어 comments 컬렉션에 인덱스 { movie_id: 1 }가 존재하는 경우입니다.

  • comments.movie_id 필드의 동등성 매치는 인덱스를 사용합니다.

팁

상관관계가 없는 하위 쿼리 수행하기 - $lookup

집계 파이프라인 $lookup 단계는 외부 컬렉션에서 파이프라인을 실행할 수 있으며, 이는 비상관 하위 쿼리를 허용합니다. 비상관 하위 쿼리는 로컬 문서 필드를 참조하지 않습니다.

참고

MongoDB 5.0부터는 $lookup 파이프라인 단계에서 $sample 단계, $sampleRate 연산자 또는 $rand 연산자를 포함하는 상관 관계가 없는 하위 쿼리의 경우, 반복 시 항상 하위 쿼리가 다시 실행됩니다. 이전에는 하위 쿼리 출력 크기에 따라 하위 쿼리 출력이 캐시되거나 하위 쿼리가 다시 실행되었습니다.

다음 작업은 movies 컬렉션 에서 런타임이 1000 분보다 긴 영화와 users 컬렉션 조인합니다.

db.users.aggregate( [
   {
      $match: {
         email: { $in: [
            "mark_addy@gameofthron.es",
            "lena_headey@gameofthron.es"
         ] }
      }
   },
   {
      $lookup: {
         from: "movies",
         pipeline: [
            { $match: { runtime: { $gt: 1000 } } },
            { $project: { _id: 0, title: 1, year: 1 } }
         ],
         as: "long_movies"
      }
   },
   {
      $project: {
         _id: 0, name: 1, email: 1, long_movies: 1
      }
   }
] )
[
  {
    name: 'Robert Baratheon',
    email: 'mark_addy@gameofthron.es',
    long_movies: [
      { title: 'Centennial', year: 1978 },
      { title: 'Baseball', year: 1994 }
    ]
  },
  {
    name: 'Cersei Lannister',
    email: 'lena_headey@gameofthron.es',
    long_movies: [
      { title: 'Centennial', year: 1978 },
      { title: 'Baseball', year: 1994 }
    ]
  }
]

이 작업은 다음과 같은 유사 SQL 문장에 해당합니다.

SELECT *, long_movies
FROM users
WHERE long_movies IN (
   SELECT title, year
   FROM movies
   WHERE runtime > 1000
);

자세한 내용은 상관관계가 없는 하위 쿼리 성능 고려 사항을참조하세요.

상관관계가 있는 간결한 하위 쿼리 수행하기 - $lookup

버전 5.0에 추가.

MongoDB 5.0부터 집계 파이프라인 $lookup 단계는 컬렉션 간의 조인을 개선하는 간결한 상관관계 하위 쿼리 구문을 지원합니다. 새로운 간결한 구문은 $match 단계에서 $expr 연산자 내부의 외부 및 로컬 필드에 대한 동등성 매치 요구 사항을 제거합니다.

다음 예제입니다.

  • localField _id 를 foreignField movie_id와 일치시켜 movies 및 comments 컬렉션을 조인합니다. pipeline 이(가 ) 실행 전에 일치 항목이 수행됩니다.

  • 댓글을 필터링하여 영화 출시하다 연도 이후에 게시된 댓글만 포함하며, 각각 $$movie_year 및 $date 를 사용하여 액세스합니다.

db.movies.aggregate( [
   {
      $match: {
         title: { $in: [
            "I Don't Kiss",
            "Lucky Luke",
            "Mississippi Masala"
         ] }
      }
   },
   {
      $lookup: {
         from: "comments",
         localField: "_id",
         foreignField: "movie_id",
         let: { movie_year: "$year" },
         pipeline: [
            {
               $match: {
                  $expr: {
                     $gt: [
                        { $year: "$date" }, "$$movie_year"
                     ]
                  }
               }
            },
            { $project: { _id: 0, name: 1, date: 1 } }
         ],
         as: "post_release_comments"
      }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         year: 1,
         post_release_comments: 1
      }
   }
] )
[
  {
    title: "I Don't Kiss",
    year: 1991,
    post_release_comments: [
      {
        name: 'Brandon Hardy',
        date: ISODate('2016-09-18T11:11:34.000Z')
      }
    ]
  },
  {
    title: 'Lucky Luke',
    year: 1991,
    post_release_comments: [
      {
        name: 'Kelsey Smith',
        date: ISODate('2010-01-13T17:55:01.000Z')
      }
    ]
  },
  {
    title: 'Mississippi Masala',
    year: 1991,
    post_release_comments: [
      {
        name: 'Phillip Collins',
        date: ISODate('2010-05-13T08:04:22.000Z')
      }
    ]
  }
]

이 예에서는 5.0 이전 버전의 구형 MongoDB 구문을 사용하며 버전에서 앞의 간결한 예와 동일한 결과를 반환합니다.

db.movies.aggregate( [
   {
      $match: {
         title: { $in: [
            "I Don't Kiss",
            "Lucky Luke",
            "Mississippi Masala"
         ] }
      }
   },
   {
      $lookup: {
         from: "comments",
         let: { movie_id: "$_id", movie_year: "$year" },
         pipeline: [
            {
               $match: {
                  $expr: {
                     $and: [
                        { $eq: [ "$movie_id", "$$movie_id" ] },
                        { $gt: [
                           { $year: "$date" }, "$$movie_year"
                        ] }
                     ]
                  }
               }
            },
            { $project: { _id: 0, name: 1, date: 1 } }
         ],
         as: "post_release_comments"
      }
   },
   {
      $project: {
         _id: 0,
         title: 1,
         year: 1,
         post_release_comments: 1
      }
   }
] )
[
  {
    title: "I Don't Kiss",
    year: 1991,
    post_release_comments: [
      {
        name: 'Brandon Hardy',
        date: ISODate('2016-09-18T11:11:34.000Z')
      }
    ]
  },
  {
    title: 'Lucky Luke',
    year: 1991,
    post_release_comments: [
      {
        name: 'Kelsey Smith',
        date: ISODate('2010-01-13T17:55:01.000Z')
      }
    ]
  },
  {
    title: 'Mississippi Masala',
    year: 1991,
    post_release_comments: [
      {
        name: 'Phillip Collins',
        date: ISODate('2010-05-13T08:04:22.000Z')
      }
    ]
  }
]

이전 예시는 다음 유사 SQL 문에 해당합니다.

SELECT *, post_release_comments
FROM movies
WHERE post_release_comments IN (
   SELECT *
   FROM comments
   WHERE comments.movie_id = movies._id
   AND YEAR(comments.date) > movies.year
);

자세한 내용은 상관관계가 있는 하위 쿼리 성능 고려 사항을 참조하세요.

하위 파이프라인의 네임스페이스

MongoDB 8.0부터 $lookup 및 $unionWith 내의 서브파이프라인의 네임스페이스가 from 및 coll 필드의 올바른 사용을 보장하기 위해 검증됩니다.

  • $lookup의 경우 지정된 컬렉션이 필요하지 않은 단계를 사용하는 서브파이프라인을 사용할 때는 from 필드를 생략합니다. 예를 들어 $documents 단계입니다.

  • 마찬가지로, $unionWith의 경우 coll 필드를 생략합니다.

변경되지 않은 동작:

  • 예를 들어 $match 또는 $collStats서브파이프라인과 같이 컬렉션을 위한 단계로 시작하는 $lookup의 경우 from 필드를 포함하고 컬렉션을 지정해야 합니다.

  • 마찬가지로 $unionWith의 경우 coll 필드를 포함하고 컬렉션을 지정합니다.

다음 시나리오는 한 가지 예시를 보여줍니다.

컬렉션 cakeFlavors을 만듭니다:

db.cakeFlavors.insertMany( [
   { _id: 1, flavor: "chocolate" },
   { _id: 2, flavor: "strawberry" },
   { _id: 3, flavor: "cherry" }
] )

이 페이지의 C# 예제에서는 Atlas 샘플 데이터 세트의 sample_mflix 데이터베이스 사용합니다. 무료 MongoDB Atlas cluster 생성하고 샘플 데이터 세트를 로드하는 방법을 학습하려면 MongoDB .NET/ C# 드라이버 문서에서 시작하기 를 참조하세요.

다음 Movie 클래스는 sample_mflix.movies 컬렉션의 문서를 모델링합니다.

public class Movie
{
    public ObjectId Id { get; set; }
    public int Runtime { get; set; }
    
    public string Title { get; set; }
    public string Rated { get; set; }
    public List<string> Genres { get; set; }
    public string Plot { get; set; }
    
    public ImdbData Imdb { get; set; }
    public int Year { get; set; }
    public int Index { get; set; }
    
    public string[] Comments { get; set; }
   
    [BsonElement("lastupdated")]
    public DateTime LastUpdated { get; set; }
}

참고

Pascal Case를 위한 ConventionPack

이 페이지의 C# 클래스는 속성 이름에 파스칼 표기법을 사용하지만, MongoDB 컬렉션의 필드 이름은 카멜 표기법을 사용합니다. 이 차이를 해결하기 위해 애플리케이션이 시작될 때 다음 코드를 사용하여 ConventionPack을 등록할 수 있습니다.

var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);

다음 Comment 클래스는 sample_mflix.comments 컬렉션의 문서를 모델링합니다.

public class Comment
{
    public Guid Id { get; set; }
   
    [BsonElement("movie_id")]
    public Guid MovieId { get; set; }
    
    public string Text { get; set; }
}

MongoDB .NET/ C# 운전자 사용하여 $lookup 집계 파이프라인 에 단계를 추가하려면 PipelineDefinition 객체 에서 Lookup() 메서드를 호출합니다.

다음 예시 movies 컬렉션과 comments 컬렉션 간의 왼쪽 외부 조인을 수행하는 파이프라인 단계를 만듭니다. 이 코드는 각 Movie 문서 의 Id 필드 Comment 문서의 MovieId 필드 에 조인합니다. 각 영화에 대한 댓글은 각 Movie 문서 의 Comments 필드 에 저장됩니다.

var commentCollection = client
    .GetDatabase("aggregation_examples")
    .GetCollection<Comment>("comments");
var pipeline = new EmptyPipelineDefinition<Movie>()
    .Lookup<Movie, Movie, Comment, Movie>(
        foreignCollection: commentCollection,
        localField: m => m.Id,
        foreignField: c => c.MovieId,
        @as: m => m.Comments);

이 페이지의 Node.js 예제에서는 Atlas 샘플 데이터 세트의 sample_mflix 데이터베이스 사용합니다. 무료 MongoDB Atlas cluster 생성하고 샘플 데이터 세트를 로드하는 방법을 학습하려면 MongoDB Node.js 운전자 설명서에서 시작하기 를 참조하세요.

MongoDB Node.js 운전자 사용하여 집계 파이프라인 에 $lookup 단계를 추가하려면 파이프라인 객체 에서 $lookup 연산자 사용합니다.

다음 예시에서는 movies 컬렉션과 comments 컬렉션 간의 왼쪽 외부 조인을 수행하는 파이프라인 단계를 만듭니다. 코드는 각 movie 문서의 _id 필드를 comment 문서의 movie_id 필드와 조인합니다. comments 필드는 각 movie 문서에 개별 영화의 댓글을 저장합니다. 그리고 집계 파이프라인을 실행합니다.

const pipeline = [
  {
    $lookup: {
      from: "comments",
      localField: "_id",
      foreignField: "movie_id",
      as: "comments"
    }
  }
];
const cursor = collection.aggregate(pipeline);
return cursor;

돌아가기

$listSessions

다음

$매치

스킬 배지 획득

' 문서 모델 과 관계'를 무료로 마스터하세요!

자세한 내용을 알아보세요.

이 페이지의 내용