Atlas Search 結果のソート

項目一覧

Overview

使用法
動作
Considerations
制限
互換性
構文
例
インデックスの定義
日付検索とソート
数値検索とソート
string 検索とソート
ObjectId でソート
UUID でソート
Null 値でソート
ブール値でソート
複合検索とソート
ファセット検索とソート
スコアで並べ替え

Overview

Atlas Search を使用すると、Atlas Search インデックスで定義したフィールドの昇順または降順で結果を昇順または降順でソートできます。 sortオプションを使用して、次のフィールドタイプで並べ替えることができます。

boolean
date
number （整数、浮動小数、double 値）
objectId
uuid
string （トークンタイプとしてインデックス付け）

結果内のドキュメントのスコアでソートしたり、null 値でソートしたりすることもできます。

使用法

Atlas Search の結果を並べ替えるには、次の操作を行う必要があります。

結果を並べ替えるには、フィールドに Atlas Search インデックスを作成します。
boolean 、 date 、 number 、 UUID 、 objectIdフィールドで並べ替えるには、動的マッピングまたは静的マッピングを使用します。 string フィールドでソートするには、静的マッピングを使用してフィールドをtokenタイプとしてインデックス付けする必要があります。
並べ替え用インデックスで定義したフィールドに対してsortオプションを使用してクエリを作成し、実行します。詳しくは、「構文」を参照してください。

動作

ブール値、日付、数値、UUID、ObjectId、または string フィールドでソート

sortオプションには、並べ替えるフィールドとそれぞれの並べ替え順序を指定するドキュメントが指定されます。 Atlas Search は、サポートされているデータ型のMongoDB 比較順序に従います。 UUID 値はBinDataのように扱われます。詳細については、存在しないフィールドを参照してください。

次の並べ替え順序を指定して、結果を並べ替えることができます。

`1`	昇順でソートします。昇順でソートすると、Atlas Search は、値を持つドキュメントの前に欠損値を持つドキュメントを返します。
`-1`	降順でソートします。

スコアと一意のフィールドで並べ替え

スコアの昇順または降順で並べ替えることもできます。 sortオプションには$meta式を指定するドキュメントが指定されます。これにはsearchScore値が必要です。

例

アプリケーションで、ユーザーが検索結果の最後のページにスキップできるとします。次の例では、結果をスコアの昇順でソートし、スコアが最も低いドキュメントが結果の上部に表示されるようにします。

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

sortを使用すると、結果内の複数のドキュメントのスコアが同じである場合に、結果の順序が特定の順序になるようにすることもできます。たとえば、次の例に示すように、 lastUpdatedという名前の日付フィールドなど、一意のフィールドで結果をソートすると、Atlas Search は決定された順序で同じスコアを持つ結果を返します。

例

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

ただし、結果を並べ替えるための一意のフィールドを指定しない場合、Atlas Search はスコアの降順で並べ替えられた結果を返します。 Atlas Search では、スコアまたは値が同一の結果が任意の順序で返されます。次の例では、結果を一意のフィールドでソートしません。

例

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

詳細については、「結果内のドキュメントにスコアを付ける」を参照してください。

配列のソート

Atlas Search は、ソート用に配列をフラット化します。

例

次の配列について考えてみましょう。

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

Atlas Search は、次のように、前述の配列をフラット化します。

4, 1, 8, 5, 9, 2

昇順並べ替えでは、Atlas Search は1を使用して配列を他の値と比較します。降順並べ替えでは、Atlas Search は9を使用して配列を他の値と比較します。

配列内の要素と比較する場合:

昇順ソートでは、Atlas Search は配列の最小要素を比較するか、（ < ）未満の比較を実行します。
例
Atlas Search では、数値で昇順にソートすると、次の順序で結果がソートされます。
-20 [-3, 12] // <- -3 comes before 5. 5 [6, 18] // <- 6 comes after 5. 13 14
降順ソートでは、Atlas Search は配列の最大要素を比較するか、より大きい（ > ）比較を実行します。
例
Atlas Search では、数値で降順にソートすると、次の順序で結果がソートされます。
[6, 18] // <- 18 comes before 14. 14 13 [-3, 12] // <- 12 comes after 13. 5 -20

NULL 値でソート

Atlas Search は null を欠落フィールドと同等として扱うため、null 値を含むフィールドや一部のドキュメントに欠落しているフィールドでソートすると、結果内のドキュメントの順序は非決定的になります。ソート操作で異なる BSON types の値を比較する場合、Atlas Search はMongoDB の比較とソート順序に従い、null 値はサポートされているすべてのBSONタイプよりも低いと見なします。

埋め込みドキュメント配列フィールドでのソート

埋め込まれたドキュメントフィールドで親ドキュメントをソートするには、次の操作を行う必要があります。

埋め込まれたドキュメント子フィールドの親をドキュメントタイプとしてインデックス化します。
埋め込みドキュメント内のstring値を持つ子フィールドをトークンタイプとしてインデックスします。数値値と日付値を持つ子フィールドの場合は、動的マッピングを有効にして、それらのフィールドを自動的にインデックス化します。

Atlas Search は親ドキュメントのみをソートします。ドキュメントの配列内の子フィールドはソートされません。例については、「ソートの例」を参照してください。

Considerations

整合性

Atlas Search インデックスは結果整合性があり、結果として返される値はソートで使用される値と異なる場合があります。

パフォーマンス

この機能により、後続のステージとして$search$limit とともに使用するクエリが最適化されます。Atlas Search がコレクション内のすべてのドキュメントをソートする必要がある場合、応答が遅くなる可能性があります。

スコアリング

Atlas Search では、結果のすべてのドキュメントのスコアが返されます。ただし、スコアで明示的に並べ替えない限り、結果内のドキュメントの順序が並べ替え条件に基づいているため、スコアの低いドキュメントの後にスコアの高いドキュメントが表示される可能性があります。

制限

embeddedDocuments型のフィールドではソートできません。
非推奨の knnBeta 演算子では sort オプションは使用できません。

互換性

Atlas は、メジャーおよびマイナーな MongoDB 5.0以降のすべてのバージョンで非シャーディングされたソートクエリをサポートしています。シャーディングされたソートクエリは、 6.0のすべてのメジャーリリースと、 7.0以降のバージョンのすべてのメジャーリリースとマイナーリリースで利用できます。 MongoDB v 5.0以前を実行しているシャーディングされた Atlas クラスターでsortを使用すると、Atlas 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"},
9       "<field-to-sort>": <sort-order>,
10       ...
11     }
12   }
13 }

例

次の例では、 sample_mflix.movies 、 sample_airbnb.listingsAndReview 、またはusersという名前のカスタムコレクションを使用します。

インデックスの定義

このページのサンプルクエリでは、 sample_mflix.movies 、 sample_airbnb.listingsAndReview 、またはカスタムコレクションのいずれかを使用します。これらのコレクションに次のインデックスを作成すると、インデックスフィールドに対してサンプルクエリを実行できます。

moviesコレクションのインデックス定義では、次の内容を指定します。

インデックスawards.winsフィールドは次のようになります。
- number ソートとクエリのタイプ
- numberFacet ファセットクエリを実行するための型
インデックスreleasedフィールドは次のようになります。
- date ソートとクエリのタイプ
- dateFacet ファセットクエリを実行するための型
インデックス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               "type": "numberFacet"
14             }
15           ]
16         },
17         "type": "document"
18       },
19       "released": [
20         {
21           "type": "date"
22         },
23         {
24           "type": "dateFacet"
25         }
26       ],
27       "title": [{
28         "type": "token"
29       }, {
30         "type": "string"
31       }]
32     }
33   }
34 }

上記のインデックス定義では、Atlas Search は指定されたフィールドの静的マッピングを含むdefaultという名前のインデックスを作成します。

この例では、 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
  }
])

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       ]
11     }
12   }
13 }

前述のコレクションでは、Atlas Search は、指定されたフィールドの指定されたマッピングで、 defaultという名前のインデックスを作成します。

日付検索とソート

sample_mflix.movies名前空間に対する次のクエリでは、 $searchステージを使用して次の処理が行われます。

範囲演算子を使用して、2010 年 1 月 1 日から 2015 年 1 月 01 日の間に公開された映画を検索します。
sortオプションを使用して、結果をリリース日の降順で並べ替えます。

クエリは$limitステージを使用して出力を5ドキュメントに制限します。また、 $projectステージを使用して、結果のtitleとreleasedを除くすべてのフィールドを省略します。

db.movies.aggregate([
  {
    "$search": {
      "range": {
        "path": "released",
        "gt": ISODate("2010-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-01-01T00:00:00.000Z")
      },
      "sort": {
        "released": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1
    }
  }
])

[
  {
    title: 'Cold in July',
    released: ISODate("2014-12-31T00:00:00.000Z")
  },
  {
    title: 'The Gambler',
    released: ISODate("2014-12-31T00:00:00.000Z")
  },
  {
    title: 'Force Majeure',
    released: ISODate("2014-12-30T00:00:00.000Z")
  },
  {
    title: 'LFO',
    released: ISODate("2014-12-27T00:00:00.000Z")
  },
  {
    title: 'Peace After Marriage',
    released: ISODate('2014-12-26T00:00:00.000Z')
  }
]

数値検索とソート

sample_mflix.movies名前空間に対する次のクエリでは、 $searchステージを使用して次の処理が行われます。

賞を受賞した映画を検索します。
sortオプションを使用して、結果を降順で並べ替えます。

クエリは$limitステージを使用して出力を5ドキュメントに制限します。また、 $projectステージを使用して、結果のtitleとawards.winsを除くすべてのフィールドを省略します。

db.movies.aggregate([
  {
    "$search": {
       "range": {
         "path": "awards.wins",
         "gt": 3
      },
      "sort": {
        "awards.wins": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "awards.wins": 1
    }
  }
])

[
  { title: '12 Years a Slave', awards: { wins: 267 } },
  { title: 'Gravity', awards: { wins: 231 } },
  { title: 'Gravity', awards: { wins: 231 } },
  {
    title: 'Birdman: Or (The Unexpected Virtue of Ignorance)',
    awards: { wins: 210 }
  },
  { title: 'Boyhood', awards: { wins: 185 } },
]

string 検索とソート

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 }
]

ObjectId でソート

次のクエリは、範囲演算子を使用して、 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.039550621062517166 },
  {
    _id: 0,
    a: UUID('1a324de2-e34b-c87e-f2a1-42ce37ad74ed'),
    score: 0.039550621062517166
  },
  {
    _id: 1,
    a: UUID('3b241101-e2bb-4255-8caf-4136c566a962'),
    score: 0.039550621062517166
  },
  {
    _id: 4,
    a: UUID('d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752'),
    score: 0.039550621062517166
  },
  {
    _id: 2,
    a: UUID('dee11d4e-63c6-4d90-983c-5c9f1e79e96c'),
    score: 0.039550621062517166
  }
]

Null 値でソート

b次のクエリは、stringhello usersテキスト演算子を使用して、フィールドでコレクション内のを検索します。クエリは、フィールドaの昇順で結果をソートします。

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.039550621062517166 },
  { _id: 2, c: 'foo', score: 0.039550621062517166 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.039550621062517166
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.039550621062517166
  },
  { _id: 1, c: true, score: 0.039550621062517166 }
]

Atlas Search はすべてのドキュメントを返しますが、 "_id": 2と"_id": 4を持つドキュメントの順序はランダムであり、Atlas Search はソート時に欠落と null を等しく扱うためです。詳しくは、「 MongoDB のソート順序」で、さまざまな BSON types のデータをソートする方法を参照してください。

ブール値でソート

次のクエリは、 sample_airbnb.listingsAndReviewsコレクションでPortugalのプロパティを検索し、その結果をbooleanフィールドis_location_exactの降順で並べ替えます。

クエリは$limitステージを使用して出力を5ドキュメントに制限します。また、 $projectステージを使用して、結果のname 、 property_type 、 address.country 、 address.location.is_location_exact以外のすべてのフィールドを省略します。

1 db.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 ]

前述の結果では、ドキュメントのis_location_exactの値はtrueです。降順ソートでは、Atlas Search はtrueの値をfalseの値より超えてランク付けするためです。前のクエリの9行の値を1に変更して昇順並べ替えを行うと、Atlas 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 月 01 日の間に公開された映画を検索します。
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
  }
]

戻る

5. 追加の検索オプションの定義

2 。クエリ実行の並列化

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"},
9	"<field-to-sort>": <sort-order>,
10	...
11	}
12	}
13	}

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

1	db.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	]