/ /

bottomN (축적자 연산자)

정의

$bottomN: 버전 5.2에 추가 되었습니다.
지정된 정렬 순서에 따라 그룹 내 하위 n 개 요소의 애그리게이션을 반환합니다. 그룹에 n 개 미만의 요소가 포함된 경우 $bottomN 은 그룹의 모든 요소를 반환합니다.

참고

명확화

이 페이지에서는 $bottomN을 축적자로 사용할 때에 대해 설명합니다. 축적자는 입력 문서 그룹 전체에서 집계된 값을 반환합니다.

bottomN를 다른 다음 문맥에서도 사용할 수 있습니다:

$bottomN (window function)는 지정된 정렬 순서에 따라 특정 창의 문서에서 하위 n 요소를 반환합니다.
$bottomN (expression operator)는 지정된 정렬 순서에 따라 입력 값 배열에서 하위 n 개 요소를 반환합니다.

구문

{
   $bottomN:
      {
         n: <expression>,
         output: <expression>,
         sortBy: { <field1>: <sort order>, <field2>: <sort order> ... }
      }
}

옵션

필드	필요성	설명
`n`	필수 사항	The number of elements that `$bottomN` returns from the group. For an example of setting n dynamically, see Set n Dynamically Based on the Group Key.
`output`	필수 사항	그룹의 각 요소에 대한 출력을 결정합니다. 모든 표현식이 가능합니다.
`sortBy`	필수 사항	`$sort`와 유사한 구문을 사용하여 각 그룹 내의 요소의 순위를 정의합니다. 파이프라인 출력의 문서 순서에 영향을 주지 않습니다.

행동

Null 및 누락된 값

$bottomN null 값을 필터링하지 않습니다.
$bottomN 누락된 값을 출력에 유지되는 null로 변환합니다.

db.aggregate( [
   {
      $documents: [
         { playerId: "PlayerA", gameId: "G1", score: 1 },
         { playerId: "PlayerB", gameId: "G1", score: 2 },
         { playerId: "PlayerC", gameId: "G1", score: 3 },
         { playerId: "PlayerD", gameId: "G1"},
         { playerId: "PlayerE", gameId: "G1", score: null }
      ]
   },
   {
      $group:
      {
            _id: "$gameId",
            playerId:
               {
                  $bottomN:
                     {
                        output: [ "$playerId", "$score" ],
                        sortBy: { "score": -1 },
                        n: 3
                     }
               }
      }
   }
] )

이 예시에서는

$documents 플레이어 점수가 포함된 리터럴 문서를 생성합니다.
$group은 gameId 기준으로 문서를 그룹화합니다. 이 예시에는 gameId가 단 하나(G1)만 있습니다.
PlayerD 점수가 누락되었고 PlayerE에 null score가 있습니다. 이 값은 모두 null로 간주됩니다.
playerId 및 score 필드는 output : ["$playerId"," $score"]로 지정되고 배열 값으로 반환됩니다.
sortBy: { "score" : -1 } 때문에 null 값은 반환된 playerId 배열의 끝으로 정렬됩니다.

[
   {
      _id: "G1",
      playerId: [ [ "PlayerA", 1 ], [ "PlayerD", null ], [ "PlayerE", null ] ]
   }
]

BSON 데이터 유형 정렬 순서

서로 다른 유형을 정렬할 때 BSON 데이터 유형 의 순서를 사용하여 순서를 결정합니다. 예를 들어 값이 문자열과 숫자로 구성된 컬렉션을 생각해 보겠습니다.

오름차순 정렬에서는 문자열 값이 숫자 값 뒤에 정렬됩니다.
내림차순 정렬에서는 문자열 값이 숫자 값보다 먼저 정렬됩니다.

db.aggregate( [
   {
      $documents: [
         { playerId: "PlayerA", gameId: "G1", score: 1 },
         { playerId: "PlayerB", gameId: "G1", score: "2" },
         { playerId: "PlayerC", gameId: "G1", score: "" }
      ]
   },
   {
      $group:
         {
            _id: "$gameId",
            playerId: {
               $bottomN:
               {
                  output: ["$playerId","$score"],
                  sortBy: {"score": -1},
                  n: 3
               }
            }
         }
   }
] )

이 예시에서는

PlayerA 의 점수는 정수입니다.
PlayerB 문자열 "2" 점수를 가집니다.
PlayerC 빈 문자열 점수가 있습니다.

정렬이 { "score" : -1 } 내림차순으로 이루어지기 때문에 문자열 리터럴 값은 PlayerA 의 숫자 점수보다 먼저 정렬됩니다.

[
   {
      _id: "G1",
      playerId: [ [ "PlayerB", "2" ], [ "PlayerC", "" ], [ "PlayerA", 1 ] ]
   }
]

예시

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

단일 장르에서 평점이 가장 낮은 영화 3개 찾기

$bottomN 축적자를 사용하여 Short 장르에서 평점이 가장 낮은 영화 3편을 찾을 수 있습니다.

db.movies.aggregate( [
   {
      $match: {
         genres: "Short",
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: "Short",
         lowestRatedMovies: {
            $bottomN: {
               output: [ "$title", "$imdb.rating" ],
               sortBy: { "imdb.rating": -1, title: 1 },
               n: 3
            }
         }
      }
   }
] )

[
  {
    _id: 'Short',
    lowestRatedMovies: [
      [ 'Andrè and Wally B.', 5.4 ],
      [ 'The Education of Mohammad Hussein', 5.4 ],
      [ 'Enigma', 5.3 ]
    ]
  }
]

예시 파이프라인:

imdb.rating 값이 포함된 Short 개의 영화로 입력을 제한하는 데 $match를 사용합니다.
$group를 사용하여 일치하는 영화를 단일 Short 그룹에 넣습니다.
sortBy: { "imdb.rating": -1, title: 1 }을(를) 사용하여 평점을 기준으로 영화 순위를 매기고 title을(를) 동점 처리 기준으로 사용합니다.
$bottomN에서 output: [ "$title", "$imdb.rating" ]을(를) 사용하여 반환되는 필드를 지정합니다.
$bottomN 을 사용하여 n: 3 가 있는 일치하는 하위 영화 3개를 반환합니다.

각 장르별 최하 평점 영화 찾기

$bottomN 축적자를 사용하여 각 장르별로 가장 낮은 평점을 받은 영화를 찾을 수 있습니다.

db.movies.aggregate( [
   {
      $unwind: "$genres"
   },
   {
      $match: {
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: "$genres",
         lowestRatedMovie: {
            $bottomN: {
               output: [ "$title", "$imdb.rating" ],
               sortBy: { "imdb.rating": -1, title: 1 },
               n: 3
            }
         }
      }
   },
   {
      $sort: { _id: 1 }
   },
   {
      $limit: 5
   }
] )

[
  {
    _id: 'Action',
    lowestRatedMovie: [
      [ 'Starship: Rising', 2.1 ],
      [ 'House of the Dead', 2 ],
      [ 'Krampus: The Christmas Devil', 2 ]
    ]
  },
  {
    _id: 'Adventure',
    lowestRatedMovie: [
      [ 'Battlefield Earth', 2.4 ],
      [ 'Epic Movie', 2.3 ],
      [ 'Son of the Mask', 2.1 ]
    ]
  },
  {
    _id: 'Animation',
    lowestRatedMovie: [
      [ 'The Adventures of Rocky & Bullwinkle', 4.1 ],
      [ 'The King and I', 4 ],
      [ 'Space Chimps 2: Zartog Strikes Back', 2.7 ]
    ]
  },
  {
    _id: 'Biography',
    lowestRatedMovie: [
      [ 'Man in the Mirror: The Michael Jackson Story', 3.5 ],
      [ 'The Gaul', 2.7 ],
      [ 'The Undefeated', 2.3 ]
    ]
  },
  {
    _id: 'Comedy',
    lowestRatedMovie: [
      [ 'Superbabies: Baby Geniuses 2', 1.9 ],
      [ 'The Hottie & the Nottie', 1.9 ],
      [ 'Saving Christmas', 1.6 ]
    ]
  }
]

예시 파이프라인:

각 영화의 genres 배열을 확장하기 위해 $unwind를 사용합니다.
$match를 사용하여 imdb.rating 값을 포함하는 문서만 유지합니다.
$group을 사용하여 장르를 기준으로 결과를 그룹화합니다.
$bottomN에서 output: [ "$title", "$imdb.rating" ]을(를) 사용하여 반환되는 필드를 지정합니다.
sortBy: { "imdb.rating": -1, title: 1 }을(를) 사용하여 평점별로 영화 순위를 매가고 title을(를) 결정론적 동점 처리기로 사용합니다.
$bottomN 을 사용하여 각 장르에서 하위 세 영화를 n: 3 로 반환합니다.
$sort와 $limit를 사용하여 첫 번째 다섯 개의 장르를 알파벳 순으로 보여줍니다.

그룹 키를 기반으로 n을 동적으로 설정합니다.

n의 값을 동적으로 할당할 수 있습니다. 다음 예시에서는 $cond 표현식을 사용하여 콘텐츠 등급에 따라 다른 수의 영화를 반환합니다.

db.movies.aggregate([
   {
      $match: {
         rated: { $in: [ "G", "PG", "PG-13", "R" ] },
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group:
         {
            _id: { rated: "$rated" },
            movies:
               {
                  $bottomN:
                     {
                        output: { title: "$title", rating: "$imdb.rating" },
                        n: { $cond: { if: { $eq: [ "$rated", "PG" ] }, then: 3, else: 1 } },
                        sortBy: { "imdb.rating": -1 }
                     }
               }
         }
   },
   {
      $sort: { "_id.rated": 1 }
   }
] )

[
  {
    _id: { rated: 'G' },
    movies: [ { title: 'Justin Bieber: Never Say Never', rating: 1.6 } ]
  },
  {
    _id: { rated: 'PG' },
    movies: [
      { title: 'Superbabies: Baby Geniuses 2', rating: 1.9 },
      { title: "Justin Bieber's Believe", rating: 1.6 },
      { title: 'Saving Christmas', rating: 1.6 }
    ]
  },
  {
    _id: { rated: 'PG-13' },
    movies: [ { title: 'The Hottie & the Nottie', rating: 1.9 } ]
  },
  { _id: { rated: 'R' }, movies: [ { title: 'House of the Dead', rating: 2 } ] }
]

예시 파이프라인:

$match를(를) 사용하여 G, PG, PG-13 또는 R 콘텐츠 등급이 있고 imdb.rating 값이 포함된 영화만 유지합니다.
$group을 사용하여 결과를 콘텐츠 평점을 기준으로 _id: { rated: "$rated" }와 함께 그룹화합니다.
$bottomN에서 output: { title: "$title", rating: "$imdb.rating" }을(를) 사용하여 반환되는 필드를 지정합니다.
컨텐츠 등급이 PG 이면 n은 3입니다. 그러지 않으면, n은 1입니다.
sortBy: { "imdb.rating": -1 }을(를) 사용하여 IMDb 점수를 기준으로 하위 n 개 영화를 찾습니다.
결과를 콘텐츠 등급을 기준으로 알파벳순으로 정렬합니다.

자세히 알아보기

돌아가기

$bottom

$concatArrays