AI 에이전트의 경우: 문서 인덱스는 https://www.mongodb.com/ko-kr/docs/llms.txt에서 사용할 수 있으며, 모든 페이지의 마크다운 버전은 어떤 URL 경로에 .md를 추가하여 사용할 수 있습니다.
Docs Menu
Docs Home
/ /
검색 옵션
Docs Home
/ /
쿼리 참조
/
검색 옵션
Docs Home
/
개발
/
검색
/
쿼리 및 인덱스
/
쿼리 참조
/
검색 옵션

MongoDB 검색 결과 정렬

개요

MongoDB Search를 사용하면 MongoDB Search 인덱스 에 정의한 필드의 결과를 오름차순 또는 내림차순으로 정렬할 수 있습니다. sort 옵션을 사용하여 다음 필드 유형별로 정렬할 수 있습니다.

  • boolean

  • date

  • number (integer, float 및 double 값)

  • objectId

  • uuid

  • string ( 토큰 유형으로 인덱싱됨)

결과에서 문서의 점수와 null 값을 기준으로 정렬할 수도 있습니다.

sort 옵션 호환성

Atlas MongoDB 7.0 이상 버전의 모든 메이저 및 마이너 릴리스에서 비샤드 및 샤딩된 정렬 쿼리를 모두 지원합니다.

sort 옵션 제한 사항

  • embeddedDocuments 유형의 필드는 정렬할 수 없습니다.

  • 더 이상 사용되지 않는 knnBeta 연산자에는 sort 옵션을 사용할 수 없습니다.

사용법

MongoDB Search 결과를 정렬하려면 다음을 수행해야 합니다.

  1. 결과를 정렬할 필드에 MongoDB Search 인덱스 생성합니다.

    boolean, date, number, UUID 및 objectId 필드를 정렬하려면 동적 또는 정적 매핑을 사용합니다. 문자열 필드를 정렬하려면 정적 매핑을 사용하여 필드를 token 유형으로 인덱싱해야 합니다.

  2. 정렬을 위해 인덱스에 정의한 필드에 대해 sort 옵션을 사용하여 쿼리를 만들고 실행합니다. 자세한 내용은 구문을 참조하세요.

행동

부울, 날짜, 숫자, UUID, ObjectId 또는 문자열 필드로 정렬

sort 옵션은 정렬 기준이 되는 필드와 해당 정렬 순서를 지정하는 문서 사용합니다. MongoDB Search는 지원되는 데이터 유형에 대해 MongoDB 비교 순서 를 따릅니다. UUID 값을 BinData처럼 취급합니다. 자세한 학습 은 존재하지 않는 필드를 참조하세요.

다음 정렬 순서를 지정하여 결과를 정렬할 수 있습니다.

1

오름차순으로 정렬합니다.

오름차순으로 정렬하면 MongoDB Search는 값이 있는 문서보다 누락된 값이 있는 문서를 반환합니다.

-1

내림차순으로 정렬합니다.

점수 및 고유 필드별로 정렬

점수별로 오름차순 또는 내림차순으로 정렬할 수도 있습니다. sort 옵션은 searchScore 값이 필요한 $meta 표현식을 지정하는 문서를 사용합니다.

예시

애플리케이션에서 사용자가 검색 결과의 마지막 페이지로 건너뛸 수 있도록 허용한다고 가정해 보겠습니다. 다음 예시에서는 점수가 가장 낮은 문서가 결과 상단에 표시되도록 점수를 기준으로 결과를 오름차순으로 정렬합니다.

sort: {score: {$meta: "searchScore", order: 1}}

결과의 여러 문서에 동일한 점수가 있는 경우 sort 를 사용하여 결과의 순서가 결정되도록 할 수도 있습니다. 예시 를 들어, 다음 예시 와 같이 lastUpdated 이라는 이름의 날짜 필드 와 같이 고유한 필드 기준으로 결과를 정렬하면 MongoDB Search는 동일한 점수를 가진 결과를 정해진 순서에 따라 반환합니다.

예시

sort: {score: {$meta: "searchScore"}, lastUpdated: 1}

그러나 결과를 정렬할 고유 필드 지정하지 않으면 MongoDB Search는 점수를 기준으로 정렬된 결과를 내림차순으로 반환합니다. MongoDB Search는 동일한 점수 또는 값을 가진 결과를 임의의 순서로 반환합니다. 다음 예시 고유한 필드 기준으로 결과를 정렬하지 않습니다.

예시

sort: {score: {$meta: "searchScore"}}

자세히 알아보려면 결과에서 문서 점수 매기기를 참조하세요.

배열 정렬하기

MongoDB Search는 정렬을 위해 배열을 평면화합니다.

예시

다음 배열을 살펴보세요.

[4, [1, [8,5], 9], 2]

MongoDB Search는 다음과 유사하게 이전 배열 평면화합니다.

4, 1, 8, 5, 9, 2

오름차순 정렬의 경우 MongoDB Search는 1 를 사용하여 배열 다른 값과 비교합니다. 내림차순 정렬의 경우 MongoDB Search는 9 를 사용하여 배열 다른 값과 비교합니다.

배열 내부의 요소와 비교할 때:

  • 오름차순 정렬의 경우 MongoDB Search는 배열 의 가장 작은 요소를 비교하거나 보다 작은(<) 비교를 수행합니다.

    예시

    MongoDB Search는 숫자를 기준으로 오름차순으로 정렬하는 경우 다음과 같은 순서로 결과를 정렬합니다.

    -20
    [-3, 12] // <- -3 comes before 5.
    5
    [6, 18]  // <- 6 comes after 5.
    13
    14

  • 내림차순 정렬의 경우 MongoDB Search는 배열 의 가장 큰 요소를 비교하거나 보다 큰 값(>) 비교를 수행합니다.

    예시

    MongoDB Search는 숫자를 기준으로 내림차순으로 정렬하는 경우 다음과 같은 순서로 결과를 정렬합니다.

    [6, 18]  // <- 18 comes before 14.
    14
    13
    [-3, 12] // <- 12 comes after 13.
    5
    -20

여러 유형으로 배열 정렬

여러 BSON 유형의 값이 포함된 배열 필드를 정렬할 때 MongoDB Search는 기본값으로 MongoDB 비교 및 정렬 순서 에 따라 배열에 사용할 대표 요소를 선택합니다.

  • 오름차순 정렬의 경우 MongoDB Search는 BSON 유형이 가장 낮은 요소를 사용합니다.

  • 내림차순 정렬의 경우 MongoDB Search는 BSON 유형이 가장 높은 요소를 사용합니다.

배열 에 동일한 BSON 유형의 값이 여러 개 있는 경우 선택한 유형에 대한 표준 정렬 동작이 적용됩니다.

예시

다음 배열을 살펴보세요.

[ 'foo', null, 15, true, false ]

  • 오름차순 정렬의 경우, MongoDB Search는 null 지원되는 가장 낮은 BSON types인 을(를) 사용합니다.

  • 내림차순 정렬의 경우 MongoDB Search는 true 배열 에서 가장 높은 BSON types인 를 사용하고 MongoDB Search는 true 값을 값보다 위에 false 순위를 매깁니다.

그러나 sort 구문에 noData: highest 를 설정하다 MongoDB Search는 null 및 누락된 값을 가장 높은 BSON 유형으로 간주합니다. 예시 배열 의 경우 다음 동작이 적용됩니다.

  • 오름차순 정렬의 경우 MongoDB Search는 이제 배열에서 가장 낮은 BSON types 15 을 사용합니다.

  • 내림차순 정렬의 경우 MongoDB Search는 null이(가) 배열에서 가장 높은 BSON types이므로 사용합니다.

자세히 학습 Null 및 누락된 값으로 정렬을 참조하세요.

예시 는 다중 유형 배열에서 정렬을 참조하세요.

Null 및 누락된 값을 기준으로 정렬

MongoDB Search는 null 값을 누락되거나 빈 값과 동일하게 취급하며, 이러한 값이 있는 문서의 순서는 정렬 시 비결정적입니다.

기본값으로 MongoDB Search는 MongoDB 비교 및 정렬 순서 를 따르며 null 값을 지원되는 다른 모든 BSON types 보다 낮은 것으로 간주합니다. 따라서 null 값은 오름차순 정렬 시 결과 상단에 표시되고 내림차순 정렬 시 결과 하단에 표시됩니다.

결과에서 null 값이 표시되는 noData 위치를 구성하려면 sort 구문에 필드 지정합니다. noData 필드 다음 값을 사용합니다.

  • lowest (기본값): 정렬 중에 null 값을 가장 낮은 BSON type으로 설정합니다. 오름차순 정렬 시 결과의 맨 위에 null 값을 정렬하고 내림차순 정렬 시 맨 아래에 정렬합니다.

  • highest: 정렬 중에 null 값을 가장 높은 BSON type으로 설정합니다. 오름차순 정렬 시 결과의 맨 아래에, 내림차순 정렬 시 맨 위에 null 값을 정렬합니다.

참고

null 또는 누락된 값이 포함된 여러 유형의 배열을 정렬할 때도 동일한 동작이 적용됩니다.

예제는 Null 값으로 정렬 및 다중 유형 배열에서 정렬을 참조하세요.

내장된 문서 배열 필드에서 정렬

내장된 문서 필드를 기준으로 상위 문서를 정렬하려면 다음을 수행해야 합니다.

  • 내장된 문서 하위 필드의 상위 항목을 문서 유형으로 인덱싱합니다.

  • 내장된 문서 내에서 문자열 값을 사용하여 하위 필드를 토큰 유형으로 인덱싱합니다. 숫자 및 날짜 값이 있는 하위 필드의 경우 동적 매핑을 활성화하여 해당 필드를 자동으로 인덱싱합니다.

MongoDB Search는 상위 문서에서만 정렬합니다. 문서 배열 내의 하위 필드는 정렬하지 않습니다. 예시는 정렬 예제를 참조하세요.

고려 사항

일관성

MongoDB Search 인덱스는 최종적으로 일관적인 되며 결과에 반환되는 값은 정렬에 사용된 값과 다를 수 있습니다.

성능

이 기능 와 함께 $search 를 $limit 후속 단계로 사용하는 쿼리를 최적화합니다. MongoDB Search가 컬렉션 의 모든 문서를 정렬해야 하는 경우 응답이 느릴 수 있습니다.

득점

MongoDB Search는 결과의 모든 문서에 대한 점수 를 반환합니다. 그러나 점수별로 명시적으로 정렬하지 않는 한 결과의 문서 순서가 정렬 기준을 기반으로 하기 때문에 점수가 낮은 문서 다음에 점수가 높은 문서가 표시될 수 있습니다.

구문

sort 의 구문은 다음과 같습니다:

1{
2  "$search": {
3    "index": "<index name>", // optional, defaults to "default"
4    "<operator>": { // such as "text", "compound", or "phrase"
5      <operator-specification>
6    },
7    "sort": {
8      score: {$meta: "searchScore"}, // optional field
9      "<field-to-sort>": <sort-order>, // 1 or -1, or a document
10      ...
11    }
12  }
13}
Parameter
설명

score

선택 사항. 검색 점수로 정렬할지 여부를 결정합니다. 더 자세히 알아보려면 점수 및 고유 필드로 정렬하기를 참조하세요.

<field-to-sort>

필수입니다. 정렬 기준이 되는 필드 의 이름입니다.

<sort-order>

필수입니다. 정렬 순서를 결정합니다. 오름차순에는 1 을 사용하고 내림차순에는 -1 을 사용합니다.

noData 필드를 지정하려면 다음 구문의 문서를 사용하세요.

"<field-to-sort>": {
  order: 1 | -1, // required field
  noData: "lowest" | "highest" // optional field
},
...

예시

다음 예시에서는 sample_mflix.movies, sample_airbnb.listingsAndReview 또는 users라는 사용자 지정 컬렉션을 사용합니다.

인덱스 정의

이 페이지의 예시 쿼리는 sample_mflix.movies, sample_airbnb.listingsAndReview 또는 사용자 지정 컬렉션을 사용합니다. 이러한 컬렉션에 다음과 같은 인덱스를 만들면 인덱싱된 필드에 대해 샘플 쿼리를 실행할 수 있습니다.

movies 컬렉션

movies 컬렉션에 대한 인덱스 정의는 다음을 지정합니다.

  • awards.wins 필드를 다음과 같이 인덱싱합니다.

  • released 필드를 다음과 같이 인덱싱합니다.

  • title 필드를 다음과 같이 인덱싱합니다.

    • token 정렬용 유형

    • string 쿼리 유형

1{
2  "mappings": {
3    "dynamic": true,
4    "fields": {
5      "awards": {
6        "dynamic": false,
7        "fields": {
8          "wins": [
9            {
10              "type": "number"
11            }
12          ]
13        },
14        "type": "document"
15      },
16      "released": [
17        {
18          "type": "date"
19        }
20      ],
21      "title": [{
22        "type": "token"
23      }, {
24        "type": "string"
25      }]
26    }
27  }
28}

앞의 인덱스 정의에 대해 MongoDB Search는 지정된 필드에 정적 매핑 을 사용하여 default 이라는 인덱스 생성합니다.

listingsAndReviews 컬렉션

sample_airbnb.listingsAndReviews 컬렉션에 대한 예시 쿼리는 다음 인덱스를 사용합니다. 인덱스 정의는 컬렉션의 필드에 대한 동적 매핑을 지정합니다.

{
  "mappings": {
    "dynamic": true
  }
}

사용자 컬렉션

users 컬렉션에는 다음 문서가 포함되어 있습니다.

db.users.insertMany([
  {
    "_id": 0,
    "a": UUID("1a324de2-e34b-c87e-f2a1-42ce37ad74ed"),
    "b": "hello",
    "c": ObjectId("507f1f77bcf86cd799439011")
  },
  {
    "_id": 1,
    "a": UUID("3b241101-e2bb-4255-8caf-4136c566a962"),
    "b": "hello",
    "c": true
  },
  {
    "_id": 2,
    "a": UUID("dee11d4e-63c6-4d90-983c-5c9f1e79e96c"),
    "b": "hello",
    "c": "foo"
  },
  {
    "_id": 3,
    "b": "hello",
    "c": UUID("3be11d4e-62cb-4e95-9a3c-5c9f1e56c732")
  },
  {
    "_id": 4,
    "a": UUID("d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752"),
    "b": "hello",
    "c": null
  },
  {
    "_id": 5,
    "a": UUID("d73f181e-cdda-42b4-b844-4d6e172e9bc8"),
    "b": "hello",
    "c": []
  }
  {
    "_id": 6,
    "a": UUID("7eeddf21-b313-4a5c-81c2-c68915daa618"),
    "b": "hello",
  }
])

users 컬렉션에 대한 인덱스 정의는 다음을 지정합니다.

  • c라는 필드를 제외한 모든 필드를 동적으로 인덱스 합니다.

  • 정렬을 위해 c라는 이름의 정적인 인덱스 필드를 다음 유형으로 지정합니다.

    • token

    • uuid

    • objectId

    • boolean

1{
2  "mappings": {
3    "dynamic": true,
4    "fields": {
5      "c": [
6       { "type": "token" },
7       { "type": "uuid" },
8       { "type": "objectId" },
9       { "type": "boolean" },
10       { "type": "number" }
11      ]
12    }
13  }
14}

앞의 컬렉션 에 대해 MongoDB Search는 지정된 필드에 지정된 매핑을 사용하여 default 이라는 인덱스 생성합니다.

날짜 검색 및 정렬

다음 쿼리는 복합 연산자 쿼리를 실행하고 날짜 필드를 기준으로 결과를 정렬하는 방법을 보여 줍니다. 다음 연산자를 사용합니다.

  • 와일드카드 연산자를 사용하여 Summer로 시작하는 영화 제목을 검색합니다.

  • 근사(near) 연산자를 입력해 2014년 4월 18일 전후로 약 5개월 안에 개봉한 영화를 검색할 수 있습니다.

    참고

    날짜 필드 에 pivot 를 사용하는 경우 해당 측정 단위는 밀리초입니다. MongoDB Search는 날짜 필드 지정된 날짜와 얼마나 가까운지에 따라 각 문서 의 점수를 계산합니다. 자세한학습 은 near를 참조하세요.

쿼리는 다음 파이프라인 단계를 사용합니다:

  • $search 단계를 사용하여 title과 released 필드를 검색한 다음 결과를 released 필드를 기준으로 내림차순으로 정렬합니다.

  • $limit 단계는 출력을 5 결과로만 제한합니다.

  • $project 단계로 이동합니다:

    • title와 released 이외의 모든 필드를 제외합니다.

    • score(이)라는 필드를 추가합니다.

번호 검색 및 정렬

다음 쿼리는 숫자 필드를 기준으로 결과를 정렬하는 방법을 보여 줍니다. 범위 연산자를 사용하여 10개 이상의 상을 수상한 영화를 검색한 다음 숫자 필드 값을 기준으로 결과를 내림차순으로 정렬합니다.

쿼리는 다음 파이프라인 단계를 사용합니다:

  • $search 단계를 사용하여 awards.wins 필드를 검색하고 결과를 내림차순으로 정렬합니다.

  • $limit 단계는 출력을 5 결과로만 제한합니다.

  • title과 awards.wins를 제외한 모든 필드를 제외하려면 $project 단계를 수행합니다.

문자열 검색 및 정렬하기

기본 예시

sample_mflix.movies 네임스페이스에 대한 다음 쿼리는 $search 단계를 사용하여 다음을 수행합니다.

  • 제목에 country(이)라는 용어가 포함된 영화를 검색합니다.

  • sort 옵션을 사용하여 결과를 오름차순으로 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 출력을 5 문서로 제한합니다. 또한 $project 단계를 사용하여 다음을 수행합니다.

  • 결과에서 title을 제외한 모든 필드를 생략합니다.

  • score(이)라는 필드를 추가합니다.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "country"
      },
      "sort": {
        "title": 1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { title: 'A Country Called Home', score: 2.536633253097534 },
  { title: 'A Month in the Country', score: 2.258953094482422 },
  { title: 'A Quiet Place in the Country', score: 2.0360684394836426 },
  { title: 'A Sunday in the Country', score: 2.258953094482422 },
  { title: 'Another Country', score: 3.3635599613189697 }
]

복합 와일드카드 검색 및 정렬 예시

다음 쿼리는 문자열 필드를 기준으로 결과를 쿼리하고 정렬하는 방법을 보여 줍니다. Prance 또는 Prince로 시작하는 제목을 검색하고 title 필드를 기준으로 오름차순으로 결과를 정렬합니다.

쿼리는 다음 파이프라인 단계를 사용합니다:

  • 와일드카드 연산자와 함께 should절을 사용해 title 필드를 검색하여 Prance 및 Prince로 시작하는 제목을 검색하려면 $search를 입력합니다. 이 쿼리는 또한 결과가 title 필드를 기준으로 오름차순으로 정렬되도록 지정합니다.

  • $limit 단계는 출력을 5 결과로만 제한합니다.

  • $project 단계로 이동합니다:

    • title을 제외한 모든 필드를 제외합니다.

    • score(이)라는 필드를 추가합니다.

대소문자를 구분하지 않는 정렬 예시

다음 쿼리는 대소문자에 관계없이 결과를 정렬하는 방법을 보여줍니다. 텍스트 연산자를 사용하여 title 필드에 train이라는 용어가 있는 영화를 검색한 다음 결과를 title 필드 값을 기준으로 오름차순으로 정렬합니다.

쿼리는 결과의 문서를 5 (으)로 제한하는 $limit 단계와 다음을 수행하는 $project 단계를 지정합니다.

  • 결과에 _id, title 및 awards 필드만 포함합니다.

  • 결과에 score라는 필드를 추가합니다.

ObjectId로 정렬

다음 쿼리는 range 연산자를 사용하여 sample_mflix.movies 컬렉션의 released 필드에서 2015-01-01에서 2015-12-31 사이에 개봉된 영화를 검색합니다. ObjectId 유형의 값을 포함하는 _id 필드를 기준으로 결과를 내림차순으로 정렬합니다.

db.movies.aggregate([
  {
    "$search": {
      "range": {
        "path": "released",
        "gt": ISODate("2015-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-12-31T00:00:00.000Z")
      },
      "sort": {
        "_id": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 1,
      "title": 1,
      "released": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  {
    _id: ObjectId('573a13fbf29313caabdedf31'),
    title: 'No Home Movie',
    released: ISODate('2015-08-10T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13fbf29313caabdedf30'),
    title: 'Our Loved Ones',
    released: ISODate('2015-08-12T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabded406'),
    title: 'The Red Spider',
    released: ISODate('2015-11-20T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabded1d6'),
    title: 'The Laundryman',
    released: ISODate('2015-07-11T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabdecaf3'),
    title: 'Right Now, Wrong Then',
    released: ISODate('2015-09-01T00:00:00.000Z'),
    score: 1
  }
]

UUID로 정렬

다음 쿼리는 users 컬렉션의 b 필드에서 hello 텀을 검색합니다. 쿼리는 정렬 순서를 나타내기 위해 다형성 데이터를 포함하는 필드 a 기준으로 결과를 오름차순으로 정렬합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "a": 1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "a": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 3, score: 0.029335692524909973 },
  {
    _id: 0,
    a: UUID('1a324de2-e34b-c87e-f2a1-42ce37ad74ed'),
    score: 0.029335692524909973
  },
  {
    _id: 1,
    a: UUID('3b241101-e2bb-4255-8caf-4136c566a962'),
    score: 0.029335692524909973
  },
  {
    _id: 6,
    a: UUID('7eeddf21-b313-4a5c-81c2-c68915daa618'),
    score: 0.029335692524909973
  },
  {
    _id: 4,
    a: UUID('d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752'),
    score: 0.029335692524909973
  },
  {
    _id: 5,
    a: UUID('d73f181e-cdda-42b4-b844-4d6e172e9bc8'),
    score: 0.029335692524909973
  },
  {
    _id: 2,
    a: UUID('dee11d4e-63c6-4d90-983c-5c9f1e79e96c'),
    score: 0.029335692524909973
  }
]

Null 값으로 정렬

텍스트 연산자 사용하여 컬렉션 에서 문자열 에 대해 필드 을(를) 검색 다음 b hello users 쿼리를 고려합니다. 그런 다음 쿼리 컬렉션 의 일부 문서에 대해 null 또는 누락된 값을 포함하는 c 필드 기준으로 결과를 정렬합니다.

자세히 학습 Null 및 누락된 값으로 정렬을 참조하세요.

오름차순 정렬(기본값)

오름차순 정렬 중에 MongoDB Search는 다음 예시 와 같이 기본값 으로 null 또는 누락된 값이 있는 문서를 결과 상단에 반환합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": { "c": 1 }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 4, c: null, score: 0.029335692524909973 },
  { _id: 5, c: [], score: 0.029335692524909973 },
  { _id: 6, score: 0.029335692524909973 },
  { _id: 2, c: 'foo', score: 0.029335692524909973 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.029335692524909973
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.029335692524909973
  },
  { _id: 1, c: true, score: 0.029335692524909973 }
]

내림차순 정렬(기본값)

내림차순 정렬 중에 MongoDB Search는 다음 예시 와 같이 기본값 으로 null 또는 누락된 값이 있는 문서를 결과 하단에 반환합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": { "c": -1 }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

참고

noData: lowest 설정은 기본값 과 동일합니다.

오름차순 정렬(noData: 최하)

오름차순 정렬 중에 noData 필드 lowest 로 지정하면 MongoDB Search는 다음 예시 와 같이 결과 상단에 null 또는 누락된 값이 있는 문서를 반환합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": {
          "order": 1,
          "noData": "lowest"
        }
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 4, c: null, score: 0.029335692524909973 },
  { _id: 5, c: [], score: 0.029335692524909973 },
  { _id: 6, score: 0.029335692524909973 },
  { _id: 2, c: 'foo', score: 0.029335692524909973 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.029335692524909973
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.029335692524909973
  },
  { _id: 1, c: true, score: 0.029335692524909973 }
]

내림차순 정렬(noData: 최하)

내림차순 정렬 중에 noData 필드 lowest 로 지정하면 MongoDB Search는 다음 예시 와 같이 결과 하단에 null 또는 누락된 값이 있는 문서를 반환합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": {
          "order": -1,
          "noData": "lowest"
        }
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

오름차순 정렬(데이터 없음: 가장 높음)

오름차순 정렬 중에 noData 필드 highest 로 지정하면 MongoDB Search는 다음 예시 와 같이 결과 하단에 null 또는 누락된 값이 있는 문서를 반환합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": {
          "order": 1,
          "noData": "highest"
        }
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  { _id: 1, c: true, score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

내림차순 정렬(noData: 최고)

내림차순 정렬 중에 noData 필드 highest 로 지정하면 MongoDB Search는 다음 예시 와 같이 결과 상단에 null 또는 누락된 값이 있는 문서를 반환합니다.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": {
          "order": -1,
          "noData": "highest"
        }
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 },
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 }
]

"_id": 4, "_id": 5, "_id": 6 가 있는 문서의 순서는 임의적이며, 이는 MongoDB Search가 정렬 시 null 값과 누락된 값을 동일하게 취급하기 때문입니다.

다중 유형 배열에서 정렬

필드 에 다중 유형 배열 있는 추가 문서 있는 경우 사용자 컬렉션 에 대한 다음 쿼리를 가정해 c 보겠습니다.

db.users.insertOne({
  "_id": 7,
  "a": UUID("03e32aa9-1cbd-43b8-b9d6-18b171a03cc7"),
  "b": "hello",
  "c": [ false, null, 15 ]
})

다음은 b 텍스트 연산자 hello 사용하여 문자열 에 대해 필드 을 검색 하고 결과를 필드 c 을 기준으로 정렬합니다.

참고

정렬 noData: lowest 구문에서 를 설정하는 것은 기본값 과 동일합니다.

오름차순 정렬(기본값)

오름차순 정렬의 경우 MongoDB Search는 BSON 유형이 가장 낮은 요소를 사용하여 다중 유형 배열 나타냅니다. 기본값 으로 MongoDB Search는 null 또는 누락된 값을 가장 낮은 BSON 값으로 간주합니다. 따라서 MongoDB Search는 null 를 사용하여 문서 의 다중 유형 배열 _id: 7 으로 나타내고, 이 문서 다른 null 및 누락된 값과 함께 결과 상단에 반환합니다.

자세히 학습 Null 및 누락된 값으로 정렬 및 여러 유형으로 배열 정렬을 참조하세요.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": 1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  { _id: 1, c: true, score: 0.025981096550822258 }
]

"_id": 4, "_id": 5, "_id": 6, "_id": 7 가 있는 문서의 순서는 무작위입니다. 이는 MongoDB Search가 정렬 시 null 값과 누락된 값을 동일하게 취급하기 때문입니다.

내림차순 정렬(기본값)

내림차순 정렬의 경우 MongoDB Search는 BSON 유형이 가장 높은 요소를 사용하여 다중 유형 배열 나타냅니다. MongoDB Search는 _id: 7가 있는 문서의 다중 유형 배열을 나타내기 위해 false 를 사용하는데, 이는 배열에서 가장 높은 BSON types이기 때문입니다. MongoDB Search는 또한 true 값의 순위를 false 값보다 높게 지정하므로 MongoDB Search는 _id: 1이 있는 문서 다음에 이 문서 반환합니다.

자세히 학습 Null 및 누락된 값으로 정렬 및 여러 유형으로 배열 정렬을 참조하세요.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": -1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 1, c: true, score: 0.025981096550822258 },
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 }
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 },
]

"_id": 4, "_id": 5, "_id": 6 가 있는 문서의 순서는 임의적이며, 이는 MongoDB Search가 정렬 시 null 값과 누락된 값을 동일하게 취급하기 때문입니다.

다음 쿼리는 를 noData: highest 지정하여 정렬 중에 null 값을 가장 높은 BSON types로 설정하다 .

오름차순 정렬(데이터 없음: 가장 높음)

오름차순 정렬의 경우 MongoDB Search는 BSON 유형이 가장 낮은 요소를 사용하여 다중 유형 배열 나타냅니다. 쿼리 null 또는 누락된 값을 가장 높은 BSON 값으로 간주하도록 noData: highest 를 지정하므로, 숫자가 배열에서 그 다음으로 낮은 BSON types이므로 MongoDB Search는 15 를 사용하여 문서의 다중 유형 배열 _id: 7 으로 표현합니다. .

자세히 학습 Null 및 누락된 값으로 정렬 및 여러 유형으로 배열 정렬을 참조하세요.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": {
          "order": 1,
          "noData": "highest"
        }
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  { _id: 2, c: 'foo', score: 0.025981096550822258 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  { _id: 1, c: true, score: 0.025981096550822258 },
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 }
]

"_id": 4, "_id": 5, "_id": 6 가 있는 문서의 순서는 임의적이며, 이는 MongoDB Search가 정렬 시 null 값과 누락된 값을 동일하게 취급하기 때문입니다.

내림차순 정렬(noData: 최고)

내림차순 정렬의 경우 MongoDB Search는 BSON 유형이 가장 높은 요소를 사용하여 다중 유형 배열 나타냅니다. 쿼리 noData highest null 또는 누락된 값을 가장 높은 BSON 값으로 설정하다 위해 필드 으로 지정하므로 MongoDB Search는 를 사용하여 null 로 문서 의 다중 유형 배열 _id: 7 나타내고 이 문서 다음 위치에서 반환합니다. 다른 null 및 누락된 값과 함께 결과의 맨 위에 표시됩니다.

자세히 학습 Null 및 누락된 값으로 정렬 및 여러 유형으로 배열 정렬을 참조하세요.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": {
          "order": -1,
          "noData": "highest"
        }
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  { _id: 4, c: null, score: 0.025981096550822258 },
  { _id: 5, c: [], score: 0.025981096550822258 },
  { _id: 6, score: 0.025981096550822258 },
  { _id: 7, c: [ false, null, 15 ], score: 0.025981096550822258 },
  { _id: 1, c: true, score: 0.025981096550822258 },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.025981096550822258
  },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.025981096550822258
  },
  { _id: 2, c: 'foo', score: 0.025981096550822258 }
]

"_id": 4, "_id": 5, "_id": 6, "_id": 7 가 있는 문서의 순서는 무작위입니다. 이는 MongoDB Search가 정렬 시 null 값과 누락된 값을 동일하게 취급하기 때문입니다.

부울로 정렬

다음 쿼리는 sample_airbnb.listingsAndReviews 컬렉션에서 Portugal 지역의 속성을 검색하고 결과를 is_location_exact라는 boolean 필드를 기준으로 내림차순으로 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 출력을 5개 문서로 제한합니다. 또한 $project 단계를 사용하여 결과에서 name, property_type, address.country, address.location.is_location_exact를 제외한 모든 필드를 생략합니다.

1db.listingsAndReviews.aggregate([
2  {
3    "$search": {
4      "text": {
5        "path": "address.country",
6        "query": "Portugal"
7      },
8      "sort": {
9        "address.location.is_location_exact": -1,
10      }
11    }
12  },
13  {
14    "$limit": 5
15  },
16  {
17    "$project": {
18      "_id": 0,
19      "name": 1,
20      "property_type": 1,
21      "address.country": 1,
22      "address.location.is_location_exact": 1
23    }
24  }
25])
1[
2  {
3    name: 'BBC OPORTO 4X2',
4    property_type: 'Apartment',
5    address: { country: 'Portugal', location: { is_location_exact: true } }
6  },
7  {
8    name: 'Heroísmo IV',
9    property_type: 'Apartment',
10    address: { country: 'Portugal', location: { is_location_exact: true } }
11  },
12  {
13    name: 'Spacious and well located apartment',
14    property_type: 'Apartment',
15    address: { country: 'Portugal', location: { is_location_exact: true } }
16  },
17  {
18    name: 'Renovated Classic Design Studio with Sun Room',
19    property_type: 'Apartment',
20    address: { country: 'Portugal', location: { is_location_exact: true } }
21  },
22  {
23    name: "O'Porto Studio | Historic Center",
24    property_type: 'Loft',
25    address: { country: 'Portugal', location: { is_location_exact: true } }
26  }
27]

앞의 결과에서 MongoDB Search는 내림차순 정렬에서 true 값의 순위를 false 값보다 높게 지정하기 때문에 문서의 is_location_exact 값이 true 입니다. 이전 쿼리 의 9 줄에 있는 값을 1로 변경하여 오름차순 정렬을 수행하면 MongoDB Search는 false 값이 true 값보다 높은 문서의 순위를 지정하고 다음 문서를 반환합니다.

[
  {
    name: 'Ribeira Charming Duplex',
    property_type: 'House',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'Be Happy in Porto',
    property_type: 'Loft',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'Downtown Oporto Inn (room cleaning)',
    property_type: 'Hostel',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'A Casa Alegre é um apartamento T1.',
    property_type: 'Apartment',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'FloresRooms 3T',
    property_type: 'Apartment',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  }
]

복합 검색 및 정렬하기

다음 쿼리는 $search 단계를 사용하여 다음을 수행합니다.

  • 제목에 dance라는 단어가 포함된 영화를 검색하며, 상을 2개 이상 수상하고 1990년 1월 1일 이후에 개봉한 영화가 우선적으로 검색됩니다.

  • 수상 횟수를 기준으로 결과를 내림차순으로 정렬한 다음, 영화 제목별로 오름차순으로 정렬하고 개봉일을 기준으로 내림차순으로 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 출력을 10 문서로 제한합니다. 또한 $project 단계를 사용하여 다음을 수행합니다.

  • 결과에서 title, released, awards.wins를 제외한 모든 필드를 생략합니다.

  • score(이)라는 필드를 추가합니다.

db.movies.aggregate([
  {
    "$search": {
      "compound": {
        "must": [{
          "text": {
            "path": "title",
            "query": "dance"
          }
        }],
        "should": [{
          "range": {
            "path": "awards.wins",
            "gte": 2
          }
        }, {
          "range": {
            "path": "released",
            "gte": ISODate("1990-01-01T00:00:00.000Z")
          }
        }]
      },
      "sort": {
        "awards.wins": -1,
        "title": 1,
        "released": -1
      }
    }
  },
  {
    "$limit": 10
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1,
      "awards.wins": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])
[
  {
    title: 'Shall We Dance?',
    released: ISODate("1997-07-11T00:00:00.000Z"),
    awards: { wins: 57 },
    score: 4.9811458587646484
  },
  {
    title: 'Shall We Dance?',
    released: ISODate("1997-07-11T00:00:00.000Z"),
    awards: { wins: 57 },
    score: 4.9811458587646484
  },
  {
    title: 'War Dance',
    released: ISODate("2008-11-01T00:00:00.000Z"),
    awards: { wins: 11 },
    score: 5.466421127319336
  },
  {
    title: 'Dance with the Devil',
    released: ISODate("1997-10-31T00:00:00.000Z"),
    awards: { wins: 6 },
    score: 4.615056037902832
  },
  {
    title: 'Save the Last Dance',
    released: ISODate("2001-01-12T00:00:00.000Z"),
    awards: { wins: 6 },
    score: 4.615056037902832
  },
  {
    title: 'Dance with a Stranger',
    released: ISODate("1985-08-09T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 3.615056037902832
  },
  {
    title: 'The Baby Dance',
    released: ISODate("1998-08-23T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 4.981145858764648
  },
  {
    title: 'Three-Step Dance',
    released: ISODate("2004-02-19T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 4.981145858764648
  },
  {
    title: "Cats Don't Dance",
    released: ISODate("1997-03-26T00:00:00.000Z"),
    awards: { wins: 3 },
    score: 4.981145858764648
  },
  {
    title: 'Dance Me Outside',
    released: ISODate("1995-03-10T00:00:00.000Z"),
    awards: { wins: 3 },
    score: 4.981145858764648
  }
]

패싯 검색 및 정렬

다음 쿼리는 $search 단계를 사용하여 다음을 수행합니다.

  • 범위 연산자를 사용하여 2010년 1월 1일에서 2015년 1월 1일 사이에 개봉한 영화를 검색합니다.

  • 1, 5 10, 15 상을 받은 영화의 수를 구합니다.

  • 2010-01-01, 2011-01-01, 2012-01-01, 2013-01-01, 2014-01-01, 2015-01-01에 개봉한 영화의 수를 구합니다.

  • sort 옵션을 사용하여 출시 날짜의 내림차순으로 결과를 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 다음을 수행합니다.

  • docs 출력 필드에 있는 5개 문서로 출력을 제한합니다.

  • meta 출력 필드에 있는 1개 문서로 출력을 제한합니다.

$project 단계를 사용하여 awards.wins, released 및 title 필드를 제외한 모든 필드를 생략합니다.

또한 $replaceWith 단계를 사용하여 $$SEARCH_META 변수에 저장된 메타데이터 결과를 meta 출력 필드에 포함하고 $set 단계를 사용하여 meta 필드를 결과에 추가합니다.

db.movies.aggregate([
  {
    "$search": {
      "facet": {
        "operator": {
          "range": {
            "path": "released",
            "gt": ISODate("2010-01-01T00:00:00.000Z"),
            "lt": ISODate("2015-01-01T00:00:00.000Z")
          }
        },
        "facets": {
          "awardsFacet": {
            "type": "number",
            "path": "awards.wins",
            "boundaries" : [1,5,10,15]
          },
          "releasedFacet" : {
            "type" : "date",
            "path" : "released",
            "boundaries" : [ISODate("2010-01-01T00:00:00.000Z"), ISODate("2011-01-01T00:00:00.000Z"), ISODate("2012-01-01T00:00:00.000Z"), ISODate("2013-01-01T00:00:00.000Z"), ISODate("2014-01-01T00:00:00.000Z"), ISODate("2015-01-01T00:00:00.000Z")]
          }
        }
      },
      "sort": {
        "released": -1
      }
    }
  },
  {
    "$facet": {
      "docs": [
        { "$limit": 5 },
        { "$project":
          {
            "_id": 0,
            "title": 1,
            "released": 1,
            "awards.wins": 1
          }
        }
      ],
      "meta": [
        {"$replaceWith": "$$SEARCH_META"},
        {"$limit": 1}
      ]
    }
  },
  {
    "$set": {
      "meta": {
        "$arrayElemAt": ["$meta", 0]
      }
    }
  }
])
[
  {
    docs: [
      {
        title: 'Cold in July',
        released: ISODate("2014-12-31T00:00:00.000Z"),
        awards: { wins: 1 }
      },
      {
        title: 'The Gambler',
        released: ISODate("2014-12-31T00:00:00.000Z"),
        awards: { wins: 7 }
      },
      {
        title: 'Force Majeure',
        released: ISODate("2014-12-30T00:00:00.000Z"),
        awards: { wins: 31 }
      },
      {
        title: 'LFO',
        released: ISODate("2014-12-27T00:00:00.000Z"),
        awards: { wins: 3 }
      },
      {
        title: 'Peace After Marriage',
        released: ISODate('2014-12-26T00:00:00.000Z'),
        awards: { wins: 5 }
      }
    ],
    meta: {
      count: { lowerBound: Long("4821") },
        facet: {
          releasedFacet: {
            buckets: [
              {
                _id: ISODate("2010-01-01T00:00:00.000Z"),
                count: Long("857")
              },
              {
                _id: ISODate("2011-01-01T00:00:00.000Z"),
                count: Long("909")
              },
              {
                _id: ISODate("2012-01-01T00:00:00.000Z"),
                count: Long("903")
              },
              {
                _id: ISODate("2013-01-01T00:00:00.000Z"),
                count: Long("1063")
              },
              {
                _id: ISODate("2014-01-01T00:00:00.000Z"),
                count: Long("1089")
              }
            ]
          },
          awardsFacet: {
            buckets: [
              { _id: 1, count: Long("2330") },
              { _id: 5, count: Long("604") },
              { _id: 10, count: Long("233") }
            ]
          }
        }
      }
    }
  }
]

점수순 정렬

다음 예에서는 결과에서 문서 점수를 기준으로 결과를 정렬하는 방법을 보여줍니다. 예시에서는 다음 조치를 수행하는 방법을 보여 줍니다.

  • 결과를 오름차순으로 정렬하여 점수가 가장 낮은 문서를 먼저 조회합니다.

  • 결과를 점수별로 내림차순으로 정렬하고, 점수가 동일한 결과에 대해서는 임의로 정렬합니다.

  • 결과를 점수별로 정렬하고, 점수가 동일한 결과의 경우 고유한 필드를 사용하여 정렬합니다.

오름차순 정렬

다음 쿼리는 $search 단계를 사용하여 다음 작업을 수행합니다.

  • 제목에 story(이)라는 용어가 포함된 영화를 검색합니다.

  • 점수별로 결과를 오름차순으로 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 출력을 5 문서로 제한합니다. 또한 $project 단계를 사용하여 다음 작업을 수행합니다.

  • 결과에서 title을 제외한 모든 필드를 생략합니다.

  • score(이)라는 필드를 추가합니다.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "story"
      },
      "sort": {score: {$meta: "searchScore", order: 1}}
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "score": {$meta: "searchScore"}
    }
  }
])
[
  {
    title: 'Do You Believe in Miracles? The Story of the 1980 U.S. Hockey Team',
    score: 0.8674521446228027
  },
  {
    title: 'Once in a Lifetime: The Extraordinary Story of the New York Cosmos',
    score: 0.9212141036987305
  },
  {
    title: 'The Source: The Story of the Beats and the Beat Generation',
    score: 0.9820802211761475
  },
  {
    title: 'If These Knishes Could Talk: The Story of the NY Accent',
    score: 0.9820802211761475
  },
  {
    title: 'Dream Deceivers: The Story Behind James Vance vs. Judas Priest',
    score: 1.051558256149292
  }
]

기본(내림차순) 정렬

다음 쿼리는 $search 단계를 사용하여 다음 작업을 수행합니다.

  • 제목에 summer(이)라는 용어가 포함된 영화를 검색합니다.

  • 결과를 점수별로 내림차순으로 정렬하고, 점수가 동일한 결과에 대해서는 임의로 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 출력을 5 문서로 제한합니다. 또한 $project 단계를 사용하여 다음 작업을 수행합니다.

  • 결과에서 _id 및 title 필드를 제외한 모든 필드를 생략합니다.

  • score(이)라는 필드를 추가합니다.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "summer"
      },
      "sort": {score: {$meta: "searchScore"}}
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 1,
      "title": 1,
      "score": {$meta: "searchScore"}
    }
  }
])
[
  {
    _id: ObjectId("573a1398f29313caabcea21e"),
    title: 'Summer',
    score: 3.5844719409942627
  },
  {
    _id: ObjectId("573a13a6f29313caabd18eca"),
    title: 'Summer Things',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a13b8f29313caabd4c1d0"),
    title: 'Summer Palace',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a1394f29313caabcde8e8"),
    title: 'Summer Stock',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a13acf29313caabd284fa"),
    title: 'Wolf Summer',
    score: 3.000213623046875
  }
]

고유 필드별로 정렬

다음 쿼리는 $search 단계를 사용하여 다음 작업을 수행합니다.

  • 제목에 prince(이)라는 용어가 포함된 영화를 검색합니다.

  • 먼저 점수를 기준으로 결과를 정렬한 다음, 점수가 동일한 결과에 대해 released 필드의 값을 기준으로 오름차순으로 정렬합니다.

이 쿼리는 $limit 단계를 사용하여 출력을 5 문서로 제한합니다. 또한 $project 단계를 사용하여 다음 작업을 수행합니다.

  • 결과에서 title 및 released 필드를 제외한 모든 필드를 생략합니다.

  • score(이)라는 필드를 추가합니다.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "prince"
      },
      "sort": {score: {$meta: "searchScore"}, "released": 1}
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1,
      "score": {$meta: "searchScore"}
    }
  }
])
[
  {
    title: 'Prince',
    released: ISODate("2015-08-14T00:00:00.000Z"),
    score: 4.168826103210449
  },
  {
    title: 'Prince Avalanche',
    released: ISODate("2013-09-19T00:00:00.000Z"),
    score: 3.4893198013305664
  },
  {
    title: 'The Prince',
    released: ISODate("2014-08-22T00:00:00.000Z"),
    score: 3.4893198013305664
  },
  {
    title: 'Prince of Foxes',
    released: ISODate("1949-12-23T00:00:00.000Z"),
    score: 3.0002830028533936
 },
  {
    title: 'The Oil Prince',
    released: ISODate("1966-01-01T00:00:00.000Z"),
    score: 3.0002830028533936
  }
]

돌아가기

점수 상세 정보

다음

하이라이트

이 페이지의 내용