日付範囲フィルターを使用して Atlas Search クエリを実行する方法

項目一覧

動的マッピングを使用した Atlas Search インデックスの作成

複合クエリの実行

このチュートリアルでは、 sample_mflix.moviesコレクションに動的マッピングを使用してインデックスを作成する方法について説明します。範囲と近似演算子を使用して、 releasedフィールドに対して複合クエリを実行する方法を示します。次の手順が必要です。

sample_mflix.moviesコレクションの動的マッピングを使用して Atlas Search インデックスを設定します。
sample_mflix.moviesコレクションのreleasedフィールドに対して Atlas Search 複合クエリを実行します。

開始する前に、Atlas クラスターが前提条件に記載されている要件を満たしていることを確認してください。

Atlas Search インデックスを作成するには、プロジェクトに対するProject Data Access Admin以上のアクセス権が必要です。

動的マッピングを使用した Atlas Search インデックスの作成

このセクションでは、動的マッピングを使用してsample_mflix.moviesコレクション内のフィールドにインデックスを付ける Atlas Search インデックスを作成します。

Atlas Atlasで、プロジェクトの {0 ページにGoします。GoClusters

まだ表示されていない場合は、希望するプロジェクトを含む組織を選択しますナビゲーションバーのOrganizationsメニュー
まだ表示されていない場合は、ナビゲーションバーのProjectsメニューから目的のプロジェクトを選択します。
まだ表示されていない場合は、サイドバーの Clusters をクリックしてください。
[ クラスター]ページが表示されます。

GoAtlas Searchクラスターのページにします。

GoAtlas Searchページには、サイドバー、Data Explorer 、またはクラスターの詳細ページからできます。

サイドバーで、 Services見出しの下のAtlas Searchをクリックします。
[ Select data sourceドロップダウンからクラスターを選択し、[ Go to Atlas Search ] をクリックします。
Atlas Searchページが表示されます。

クラスターの [Browse Collections] ボタンをクリックします。
データベースを展開し、コレクションを選択します。
コレクションのSearch Indexesタブをクリックします。
Atlas Searchページが表示されます。

クラスタの名前をクリックします。
[Atlas Search] タブをクリックします。
Atlas Searchページが表示されます。

をクリックします。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Create Search Index

Atlas SearchConfiguration Method を選択し、[]Next をクリックします。

ガイドを利用する場合は、Atlas Search Visual Editor を選択します。
Raw インデックス定義を編集するには、Atlas Search JSON Editor を選択します。

Index Nameを入力し、Database and Collection を設定します。

Index Nameフィールドにdate-range-tutorialと入力します。
インデックスにdefaultと名付けると、 $searchパイプラインステージでindexパラメータを指定する必要がなくなります。インデックスにカスタム名を付ける場合は、 indexパラメータでこの名前を指定する必要があります。
Database and Collectionセクションで、 sample_mflixデータベースを検索し、 moviesコレクションを選択します。

インデックスの定義を指定します。

動的マッピングまたは静的マッピングを使用する Atlas Search インデックスを作成できます。動的マッピングと静的マッピングについて詳しくは、「静的マッピングと動的マッピング」を参照してください。

次のインデックス定義は、 moviesコレクション内のサポートされている型のフィールドを動的にインデックス化します。 Atlas Search Visual Editor またはAtlas Search JSON Editor を使用して、 Atlas userインターフェースでインデックスを作成できます。

ビジュアルエディター

[Next] をクリックします。
moviesコレクションの"date-range-tutorial"インデックス定義を確認します。

JSON エディター

[Next] をクリックします。
インデックスの定義を確認します。
インデックス定義は、次のようになります。
```
{
  "mappings": {
    "dynamic": true
  }
}
```
上記のインデックス定義は、 moviesコレクション内の各ドキュメントでサポートされているタイプのフィールドを動的にインデックス化します。
[Next] をクリックします。

をクリックします。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Save Changes

をクリックします。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Create Search Index

You're All Set!モーダルウィンドウを閉じます。

インデックスが作成中であることを知らせるモーダルウィンドウが表示されます。Close ボタンをクリックします。

インデックスの作成が完了するまで待ちます。

インデックスの構築には約 1 分かかります。作成している間、 Status列にはBuild in Progressと表示されます。作成が完了すると、 Status列にはActiveと表示されます。

複合クエリの実行

➤ [言語の選択] ドロップダウンメニューを使用して、このページの例の言語を設定します。

複合演算子を使用して、2 つ以上の演算子と句を 1 つのクエリにまとめることができます。このチュートリアルでは、複合演算子句を使用して、指定された日付範囲内の映画を検索します。このセクションでは、Atlas クラスターに接続し、 sample_mflix.moviesコレクションのreleasedフィールドに対して複合演算子を使用してサンプルクエリを実行します。

AtlasGoClustersAtlas で、プロジェクトのページにGoします。

まだ表示されていない場合は、希望するプロジェクトを含む組織を選択しますナビゲーションバーのOrganizationsメニュー
まだ表示されていない場合は、ナビゲーションバーのProjectsメニューから目的のプロジェクトを選択します。
まだ表示されていない場合は、サイドバーの Clusters をクリックしてください。
[ Clusters （クラスター） ] ページが表示されます。

GoAtlas Searchクラスターのページにします。

GoAtlas Searchページには、サイドバー、Data Explorer 、またはクラスターの詳細ページからできます。

サイドバーで、 Services見出しの下のAtlas Searchをクリックします。
[ Select data sourceドロップダウンからクラスターを選択し、[ Go to Atlas Search ] をクリックします。
Atlas Searchページが表示されます。

クラスターの [Browse Collections] ボタンをクリックします。
データベースを展開し、コレクションを選択します。
コレクションのSearch Indexesタブをクリックします。
Atlas Searchページが表示されます。

クラスタの名前をクリックします。
[Atlas Search] タブをクリックします。
Atlas Searchページが表示されます。

[Search Tester] に移動します。

クエリするインデックスの右側にある [ Query ] ボタンをクリックします。

クエリ構文を表示および編集します。

Edit Queryをクリックすると、 JSON形式のデフォルトのクエリ構文サンプルが表示されます。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

次の例では、サブクエリとともにcompound演算子を使用して、 2010から2015年までの映画を検索しています。クエリでは、次の句を使用します。

2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句

クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。

title 、 released 、 genresフィールドを除くすべてのフィールドを除外
次のフィールドを追加: score

次のクエリをコピーして、 Query Editorに貼り付け、 Query EditorのSearchボタンをクリックします。

1 [
2   {
3     $search: {
4       "index": "date-range-tutorial",
5       "compound": {
6         "must": [{
7           "range": {
8             "path": "released",
9             "gt": ISODate("2015-01-01T00:00:00.000Z"),
10             "lt": ISODate("2015-12-31T00:00:00.000Z")
11           }
12         }],
13         "should": [{
14           "near": {
15             "path": "released",
16             "origin": ISODate("2015-07-01T00:00:00.000+00:00"),
17             "pivot": 2629800000
18           }
19         }]
20       }
21     }
22   }
23 ]

SCORE: 2  _id:  "573a13c4f29313caabd6c383"
  fullplot: "When John Connor (Jason Clarke), leader of the human resistance, sends…"
  imdb: Object
  year: 2015
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 2  _id:  "573a13d9f29313caabdaa9e2"
  fullplot: "Three years after Mike bowed out of the stripper life at the top of hi…"
  imdb: Object
  year: 2015
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 2  _id:  "573a13e9f29313caabdcd223"
  plot: "A documentary about the power of transformation told through the eyes …"
  genres: Array
  runtime: 87
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 2  _id:  "573a13f4f29313caabde1138"
  plot: "Dedicated home care nurse Vlasta lives for her husband Lada, her daugh…"
  genres: Array
  runtime: 92
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 2  _id:  "573a13f9f29313caabdeb320"
  plot: "For anyone who has not fully understood the controversial Bitcoin yet,…"
  genres: Array
  runtime: 60
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 1.9681909084320068  _id:  "573a13c2f29313caabd67986"
  plot: "A man wakes up alone in the middle of the desert with a black hood on …"
  genres: Array
  runtime: 90
  ...
  released: 2015-07-02T00:00:00.000+00:00
  ...
SCORE: 1.9681909084320068  _id:  "573a13f4f29313caabde14cf"
  plot: "In 1836 the Danish romantic visionary Wulff travels to Africa to creat…"
  genres: Array
  runtime: 114
  ...
  released: 2015-07-02T00:00:00.000+00:00
  ...
SCORE: 1.9383430480957031  _id:  "573a13d6f29313caabd9f77d"
  plot: "The plot of the film has a grandfather telling his grand kids the stor…"
  genres: Array
  runtime: 78
  ...
  released: 2015-07-03T00:00:00.000+00:00
  ...
SCORE: 1.9383430480957031  _id:  "573a13e3f29313caabdbfb00"
  plot: "The story of Amy Winehouse in her own words, featuring unseen archival…"
  genres: Array
  runtime: 128
  ...
  released: 2015-07-02T00:00:00.000+00:00
  ...
SCORE: 1.9383430480957031  _id:  "573a13e9f29313caabdcbe1e"
  plot:  "A modern day train hopper fighting to become a successful musician, an…"
  genres: Array
  runtime: 90
  ...
  released: 2015-07-02T00:00:00.000+00:00
  ...

クエリ結果を展開します。

Search Testerでは、返されるドキュメント内のすべてのフィールドが表示されない場合があります。クエリパスで指定したフィールドを含むすべてのフィールドを表示するには、結果内のドキュメントを展開します。

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

次の例では、前の例に追加します。

must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。

1 [
2   {
3     $search: {
4       "index": "date-range-tutorial",
5       "compound": {
6         "must": [{
7           "range": {
8             "path": "released",
9             "gt": ISODate("2015-01-01T00:00:00.000Z"),
10             "lt": ISODate("2015-12-31T00:00:00.000Z")
11           }
12         }],
13         "should": [{
14           "near": {
15             "path": "released",
16             "origin": ISODate("2015-07-01T00:00:00.000+00:00"),
17             "pivot": 2629800000
18           }
19         }],
20         "mustNot": [{
21           "text": {
22             "query": "documentary",
23             "path": "genres"
24           }
25         }]
26       }
27     }
28   }
29   ]

SCORE: 2  _id:  "573a13c4f29313caabd6c383"
  fullplot: "When John Connor (Jason Clarke), leader of the human resistance, sends…"
  imdb: Object
  year: 2015
  ...
  genres:
    0: "Action"
    1: "Adventure"
    2: "Sci-Fi"
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 2  _id:  "573a13d9f29313caabdaa9e2"
  fullplot: "Three years after Mike bowed out of the stripper life at the top of hi…"
  imdb: Object
  year: 2015
  ...
  genres:
    0: "Comedy"
    1: "Drama"
    2: "Music"
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 2  _id:  "573a13f4f29313caabde1138"
  plot: "Dedicated home care nurse Vlasta lives for her husband Lada, her daugh…"
  genres:
    0: "Comedy"
    1: "Drama"
  runtime: 92
  ...
  released: 2015-07-01T00:00:00.000+00:00
  ...
SCORE: 1.9681909084320068  _id: "573a13c2f29313caabd67986"
  plot:  "A man wakes up alone in the middle of the desert with a black hood on …"
  genres:
    0: "Drama"
    1: "Mystery"
    2: "Sci-Fi"
  runtime: 90
  ...
  released: 2015-07-02T00:00:00.000+00:00
  ...
SCORE: 1.9681909084320068  _id:  "573a13f4f29313caabde14cf"
  plot: "In 1836 the Danish romantic visionary Wulff travels to Africa to creat…"
  genres:
    0: "Drama"
    1: "History"
    2: "Romance"
  runtime: 114
  ...
  released: 2015-07-02T00:00:00.000+00:00
  ...
SCORE: 1.9383430480957031  _id:  "573a13d6f29313caabd9f77d"
  plot: "The plot of the film has a grandfather telling his grand kids the stor…"
  genres:
    0: "Animation"
    1: "Family"
  runtime: 78
  ...
  released: 2015-07-03T00:00:00.000+00:00
  ...
SCORE: 1.9383430480957031  _id:  "573a13e9f29313caabdcbe1e"
  plot: "A modern day train hopper fighting to become a successful musician, an…"
  genres:
    0: "Drama"
  runtime: 90
  ...
  released: 2015-07-03T00:00:00.000+00:00
  ...
SCORE: 1.9383430480957031  _id:  "573a13e9f29313caabdccb5b"
  plot: "A fancy garden party turns into upper class prey when a colony of kill…"
  genres:
    0: "Comedy"
    1: "Horror"
  runtime: 87
  ...
  released: 2015-07-03T00:00:00.000+00:00
  ...
SCORE: 1.9102803468704224  _id:  "573a13faf29313caabdec74f"
  countries: Array
  genres:
    0: "Drama"
  runtime: 104
  ...
  released: 2015-07-03T00:00:00.000+00:00
  ...
SCORE: 1.8838474750518799  _id:  "573a13eef29313caabdd531d"
  plot: "A fantasy love story that drifts between this world and heaven. Chasuk…"
  genres:
    0: "Comdedy"
  countries: Array
  ...
  released: 2015-06-27T00:00:00.000+00:00
  ...

クエリ結果を展開します。

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

`mongosh`でクラスターに接続します。

ターミナルウィンドウでmongoshを開き、クラスターに接続します。接続の詳細な手順については、「 mongosh経由での接続」を参照してください。

`sample_mflix`データベースを使用します。

mongoshプロンプトで次のコマンドを実行します。

use sample_mflix

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

次の例では、サブクエリとともにcompound演算子を使用して、 2010から2015年までの映画を検索しています。クエリでは、次の句を使用します。

2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句

クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。

title 、 released 、 genresフィールドを除くすべてのフィールドを除外
次のフィールドを追加: score

db.movies.aggregate([
  {
    "$search": {
        "index": "date-range-tutorial",
        "compound": {
          "must": [{
            "range": {
              "path": "released",
              "gt": ISODate("2015-01-01T00:00:00.000Z"),
              "lt": ISODate("2015-12-31T00:00:00.000Z")
            }
          }],
          "should": [{
            "near": {
              "path": "released",
              "origin": ISODate("2015-07-01T00:00:00.000+00:00"),
              "pivot": 2629800000
            }
          }]
        }
      }
    },
    {
      "$limit": 6
    },
    {
      "$project": {
        "_id": 0,
        "title": 1,
        "released": 1,
        "genres": 1,
        "score": { "$meta": "searchScore" }
      }
    }
  ])

[
  {
    "genres": [ "Action", "Adventure", "Sci-Fi" ],
    "title": "Terminator Genisys",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Comedy", "Drama", "Music" ],
    "title": "Magic Mike XXL",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Documentary", "Biography", "Drama" ],
    "title": "Mala Mala",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Comedy", "Drama" ],
    "title": "Home Care",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Documentary", "News" ],
    "title": "Bitcoin: The End of Money as We Know It",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Drama", "Mystery", "Sci-Fi" ],
    "title": "Pig",
    "released": ISODate("2015-07-02T00:00:00.000Z"),
    "score": 1.9681909084320068
  }
]

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

次の例では、前の例に追加します。

db.movies.aggregate([
  {
    "$search": {
        "compound": {
          "must": [{
            "range": {
              "path": "released",
              "gt": ISODate("2015-01-01T00:00:00.000Z"),
              "lt": ISODate("2015-12-31T00:00:00.000Z")
            }
          }],
          "should": [{
            "near": {
              "path": "released",
              "origin": ISODate("2015-07-01T00:00:00.000+00:00"),
              "pivot": 2629800000
            }
          }],
          "mustNot": [{
            "text": {
              "query": "documentary",
              "path": "genres"
            }
          }]
        }
      }
    },
    {
      "$limit": 10
    },
    {
      "$project": {
        "_id": 0,
        "title": 1,
        "released": 1,
        "genres": 1,
        "score": { "$meta": "searchScore" }
      }
    }
  ])

[
  {
    "genres": [ "Action", "Adventure", "Sci-Fi" ],
    "title": "Terminator Genisys",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Comedy", "Drama", "Music" ],
    "title": "Magic Mike XXL",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Comedy", "Drama" ],
    "title": "Home Care",
    "released": ISODate("2015-07-01T00:00:00.000Z"),
    "score": 2
  },
  {
    "genres": [ "Drama", "Mystery", "Sci-Fi" ],
    "title": "Pig",
    "released": ISODate("2015-07-02T00:00:00.000Z"),
    "score": 1.9681909084320068
  },
  {
    "genres": [ "Drama", "History", "Romance" ],
    "title": "Gold Coast",
    "released": ISODate("2015-07-02T00:00:00.000Z"),
    "score": 1.9681909084320068
  },
  {
    "genres": [ "Animation", "Family" ],
    "title": "Zarafa",
    "released": ISODate("2015-07-03T00:00:00.000Z"),
    "score": 1.9383430480957031
  }
]

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

MongoDB Compass のクラスターに接続します。

MongoDB Compass を開き、クラスターに接続します。接続の詳細な手順については、「 Compass 経由での接続」を参照してください。

`moviessample_mflix`データベースにコレクションを作成します。

Database画面で、 sample_mflixデータベースをクリックし、 moviesコレクションをクリックします。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

次の例では、サブクエリとともにcompound演算子を使用して、 2010から2015年までの映画を検索しています。クエリでは、次の句を使用します。

2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句

クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。

title 、 released 、 genresフィールドを除くすべてのフィールドを除外
次のフィールドを追加: score

MongoDB Compass でこのクエリを実行するには：

[Aggregations] タブをクリックします。
Select...をクリックし、ドロップダウンからステージを選択し、そのステージのクエリを追加して、次の各パイプラインステージを構成します。ステージを追加するには、 Add Stageをクリックします。

パイプラインステージ

クエリ

$search

{
  "index": "date-range-tutorial",
  "compound": {
    "must": [{
      "range": {
        "path": "released",
        "gt": ISODate("2015-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-12-31T00:00:00.000Z")
      }
    }],
    "should": [{
      "near": {
        "path": "released",
        "origin": ISODate("2015-07-01T00:00:00.000+00:00"),
        "pivot": 2629800000
      }
    }]
  }
}

$limit

$project

{
  "_id": 0,
  "title": 1,
  "released": 1,
  "genres": 1,
  "score": {
    "$meta": "searchScore"
  }
}

Auto Previewを有効にした場合、MongoDB Compass は$projectパイプラインステージの横に次のドキュメントを表示します。

{
  "genres": [ "Action", "Adventure", "Sci-Fi" ],
  "title": "Terminator Genisys",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Comedy", "Drama", "Music" ],
  "title": "Magic Mike XXL",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Documentary", "Biography", "Drama" ],
  "title": "Mala Mala",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Comedy", "Drama" ],
  "title": "Home Care",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Documentary", "News" ],
  "title": "Bitcoin: The End of Money as We Know It",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Drama", "Mystery", "Sci-Fi" ],
  "title": "Pig",
  "released": ISODate("2015-07-02T00:00:00.000Z"),
  "score": 1.9681909084320068
}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

次の例では、前の例に追加します。

MongoDB Compass でこのクエリを実行するには：

[Aggregations] タブをクリックします。
Select...をクリックし、ドロップダウンからステージを選択し、そのステージのクエリを追加して、次の各パイプラインステージを構成します。ステージを追加するには、 Add Stageをクリックします。

パイプラインステージ

クエリ

$search

{
  "index": "date-range-tutorial",
  "compound": {
    "must": [{
      "range": {
        "path": "released",
        "gt": ISODate("2015-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-12-31T00:00:00.000Z")
      }
    }],
    "should": [{
      "near": {
        "path": "released",
        "origin": ISODate("2015-07-01T00:00:00.000+00:00"),
        "pivot": 2629800000
      }
    }],
    "mustNot": [{
      "text": {
        "query": "documentary",
        "path": "genres"
      }
    }]
  }
}

$limit

$project

{
  "_id": 0,
  "title": 1,
  "released": 1,
  "genres": 1,
  "score": {
    "$meta": "searchScore"
  }
}

Auto Previewを有効にした場合、MongoDB Compass は$projectパイプラインステージの横に次のドキュメントを表示します。

{
  "genres": [ "Action", "Adventure", "Sci-Fi" ],
  "title": "Terminator Genisys",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Comedy", "Drama", "Music" ],
  "title": "Magic Mike XXL",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Comedy", "Drama" ],
  "title": "Home Care",
  "released": ISODate("2015-07-01T00:00:00.000Z"),
  "score": 2
},
{
  "genres": [ "Drama", "Mystery", "Sci-Fi" ],
  "title": "Pig",
  "released": ISODate("2015-07-02T00:00:00.000Z"),
  "score": 1.9681909084320068
},
{
  "genres": [ "Drama", "History", "Romance" ],
  "title": "Gold Coast",
  "released": ISODate("2015-07-02T00:00:00.000Z"),
  "score": 1.9681909084320068
},
{
  "genres": [ "Animation", "Family" ],
  "title": "Zarafa",
  "released": ISODate("2015-07-03T00:00:00.000Z"),
  "score": 1.9383430480957031
}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

クエリの .NET/C# プロジェクトを設定して初期化します。

date-range-example という新しいディレクトリを作成し、dotnet new コマンドでプロジェクトを初期化します。
```
mkdir date-range-example
cd date-range-example
dotnet new console
```
.NET/C# ドライバーを依存関係としてプロジェクトに追加します。
```
dotnet add package MongoDB.Driver
```

ファイルに 2 つの句を持つ演算子を使用して`compoundProgram.cs` Atlas Search クエリを作成して実行します。

Program.cs ファイルの内容を、次のコードで置き換えます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
次のcompound演算子句を使用して、コレクションをクエリします。
- 2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
- ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句
クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。
- title 、 released 、 genresフィールドを除くすべてのフィールドを除外
- 次のフィールドを追加: score
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 using MongoDB.Bson;
2 using MongoDB.Bson.Serialization.Attributes;
3 using MongoDB.Bson.Serialization.Conventions;
4 using MongoDB.Driver;
5 using MongoDB.Driver.Search;
6 
7 public class DateRangeExample
8 {
9     private const string MongoConnectionString = "<connection-string>";
10 
11     public static void Main(string[] args)
12     {
13         // allow automapping of the camelCase database fields to our MovieDocument
14         var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15         ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16 
17         // connect to your Atlas cluster
18         var mongoClient = new MongoClient(MongoConnectionString);
19         var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20         var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
21 
22         // declare data for compound query
23         var startDate = new DateTime(2015, 01, 01, 0, 0, 0, DateTimeKind.Utc);
24         var endDate = new DateTime(2015, 12, 31, 0, 0, 0, DateTimeKind.Utc);
25         var nearDate = new DateTime(2015, 07, 01, 0, 0, 0, DateTimeKind.Utc);
26 
27         // define and run pipeline
28         var results = moviesCollection.Aggregate()
29             .Search(Builders<MovieDocument>.Search.Compound()
30                 .Must(Builders<MovieDocument>.Search.Range(movie => movie.Released, SearchRangeBuilder.Gt(startDate).Lt(endDate)))
31                 .Should(Builders<MovieDocument>.Search.Near(movie => movie.Released, nearDate, 2629800000)),
32                 indexName: "date-range-tutorial")
33             .Project<MovieDocument>(Builders<MovieDocument>.Projection
34                 .Include(movie => movie.Genres)
35                 .Include(movie => movie.Released)
36                 .Include(movie => movie.Title)
37                 .Exclude(movie => movie.Id)
38                 .MetaSearchScore(movie => movie.Score))
39             .Limit(6)
40             .ToList();
41 
42         // print results
43         foreach (var movie in results)
44         {
45             Console.WriteLine(movie.ToJson());
46         }
47     }
48 }
49 
50 [BsonIgnoreExtraElements]
51 public class MovieDocument
52 {
53     [BsonIgnoreIfDefault]
54     public ObjectId Id { get; set; }
55     public string [] Genres { get; set; }
56     public DateTime Released { get; set; }
57     public string Title { get; set; }
58     public double Score { get; set; }
59 }

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

Program.csファイルをコンパイルして実行します。

dotnet run date-range-example.csproj

{ "genres" : ["Action", "Adventure", "Sci-Fi"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Terminator Genisys", "score" : 2.0 }
{ "genres" : ["Comedy", "Drama", "Music"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Magic Mike XXL", "score" : 2.0 }
{ "genres" : ["Documentary", "Biography", "Drama"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Mala Mala", "score" : 2.0 }
{ "genres" : ["Comedy", "Drama"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Home Care", "score" : 2.0 }
{ "genres" : ["Documentary", "News"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Bitcoin: The End of Money as We Know It", "score" : 2.0 }
{ "genres" : ["Drama", "Mystery", "Sci-Fi"], "released" : ISODate("2015-07-02T00:00:00Z"), "title" : "Pig", "score" : 1.9681909084320068 }

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

ファイルに 3 つの句を持つ演算子を使用して`compound` `Program.cs`Atlas Search クエリを作成して実行します。

Program.cs ファイルの内容を、次のコードで置き換えます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
前の例に追加します。
must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 using MongoDB.Bson;
2 using MongoDB.Bson.Serialization.Attributes;
3 using MongoDB.Bson.Serialization.Conventions;
4 using MongoDB.Driver;
5 using MongoDB.Driver.Search;
6 
7 public class DateRangeComplexExample
8 {
9     private const string MongoConnectionString = "<connection-string>";
10 
11     public static void Main(string[] args)
12     {
13         // allow automapping of the camelCase database fields to our MovieDocument
14         var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15         ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16 
17         // connect to your Atlas cluster
18         var mongoClient = new MongoClient(MongoConnectionString);
19         var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20         var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
21 
22         // declare data for compound query
23         var startDate = new DateTime(2015, 01, 01, 0, 0, 0, DateTimeKind.Utc);
24         var endDate = new DateTime(2015, 12, 31, 0, 0, 0, DateTimeKind.Utc);
25         var nearDate = new DateTime(2015, 07, 01, 0, 0, 0, DateTimeKind.Utc);
26 
27         // define and run pipeline
28         var results = moviesCollection.Aggregate()
29             .Search(Builders<MovieDocument>.Search.Compound()
30                 .Must(Builders<MovieDocument>.Search.Range(movie => movie.Released, SearchRangeBuilder.Gt(startDate).Lt(endDate)))
31                 .Should(Builders<MovieDocument>.Search.Near(movie => movie.Released, nearDate, 2629800000))
32                 .MustNot(Builders<MovieDocument>.Search.Text(movie => movie.Genres, "Documentary")),
33                 indexName: "date-range-tutorial")
34             .Project<MovieDocument>(Builders<MovieDocument>.Projection
35                 .Include(movie => movie.Genres)
36                 .Include(movie => movie.Released)
37                 .Include(movie => movie.Title)
38                 .Exclude(movie => movie.Id)
39                 .MetaSearchScore(movie => movie.Score))
40             .Limit(6)
41             .ToList();
42 
43         // print results
44         foreach (var movie in results)
45         {
46             Console.WriteLine(movie.ToJson());
47         }
48     }
49 }
50 
51 [BsonIgnoreExtraElements]
52 public class MovieDocument
53 {
54     [BsonIgnoreIfDefault]
55     public ObjectId Id { get; set; }
56     public string [] Genres { get; set; }
57     public DateTime Released { get; set; }
58     public string Title { get; set; }
59     public double Score { get; set; }
60 }

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

Program.csファイルをコンパイルして実行します。

dotnet run date-range-example.csproj

{ "genres" : ["Action", "Adventure", "Sci-Fi"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Terminator Genisys", "score" : 2.0 }
{ "genres" : ["Comedy", "Drama", "Music"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Magic Mike XXL", "score" : 2.0 }
{ "genres" : ["Comedy", "Drama"], "released" : ISODate("2015-07-01T00:00:00Z"), "title" : "Home Care", "score" : 2.0 }
{ "genres" : ["Drama", "Mystery", "Sci-Fi"], "released" : ISODate("2015-07-02T00:00:00Z"), "title" : "Pig", "score" : 1.9681909084320068 }
{ "genres" : ["Drama", "History", "Romance"], "released" : ISODate("2015-07-02T00:00:00Z"), "title" : "Gold Coast", "score" : 1.9681909084320068 }
{ "genres" : ["Animation", "Family"], "released" : ISODate("2015-07-03T00:00:00Z"), "title" : "Zarafa", "score" : 1.9383430480957031 }

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

date-range.goという名前のファイルを作成します。

次のコードをコピーして、 date-range.goファイルに貼り付けます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
次のcompound演算子句を使用して、コレクションをクエリします。
- 2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
- ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句
クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。
- title 、 released 、 genresフィールドを除くすべてのフィールドを除外
- 次のフィールドを追加: score
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 package main
2 
3 import (
4 	"context"
5 	"fmt"
6 	"time"
7 
8 	"go.mongodb.org/mongo-driver/bson"
9 	"go.mongodb.org/mongo-driver/mongo"
10 	"go.mongodb.org/mongo-driver/mongo/options"
11 )
12 
13 func main() {
14 	// connect to your Atlas cluster
15 	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
16 	if err != nil {
17 		panic(err)
18 	}
19 	defer client.Disconnect(context.TODO())
20 
21 	// set namespace
22 	collection := client.Database("sample_mflix").Collection("movies")
23 
24 	// define pipeline stages
25 	searchStage := bson.D{{"$search", bson.M{
26 		"index": "date-range-tutorial",
27 		"compound": bson.M{
28 			"must": bson.M{
29 				"range": bson.M{
30 					"path": "released",
31 					"gt":   time.Date(2015, time.January, 1, 0, 0, 0, 0, time.UTC),
32 					"lt":   time.Date(2015, time.December, 31, 0, 0, 0, 0, time.UTC),
33 				}},
34 			"should": bson.D{
35 				{"near", bson.M{
36 					"path":   "released",
37 					"origin": time.Date(2015, time.July, 1, 0, 0, 0, 0, time.UTC),
38 					"pivot":  2629800000,
39 				}}},
40 		}}}}
41 	projectStage := bson.D{{"$project", bson.D{{"_id", 0}, {"title", 1}, {"released", 1}, {"genres", 1}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
42 	limitStage := bson.D{{"$limit", 6}}
43 
44 	// run pipeline
45 	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage, limitStage})
46 	if err != nil {
47 		panic(err)
48 	}
49 
50 	// print results
51 	var results []bson.D
52 	if err = cursor.All(context.TODO(), &results); err != nil {
53 		panic(err)
54 	}
55 	for _, result := range results {
56 		fmt.Println(result)
57 	}
58 }

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

次のコマンドを実行して、コレクションをクエリします。

go run date-range.go

[{genres [Action Adventure Sci-Fi]} {title Terminator Genisys} {released 1435708800000} {score 2}]
[{genres [Comedy Drama Music]} {title Magic Mike XXL} {released 1435708800000} {score 2}]
[{genres [Documentary Biography Drama]} {title Mala Mala} {released 1435708800000} {score 2}]
[{genres [Comedy Drama]} {title Home Care} {released 1435708800000} {score 2}]
[{genres [Documentary News]} {title Bitcoin: The End of Money as We Know It} {released 1435708800000} {score 2}]
[{genres [Drama Mystery Sci-Fi]} {title Pig} {released 1435795200000} {score 1.9681909084320068}]

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

date-range-complex.goという名前のファイルを作成します。

次のコードをコピーして、 date-range-complex.goファイルに貼り付けます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
前の例に追加します。
must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 package main
2 
3 import (
4 	"context"
5 	"fmt"
6 	"time"
7 
8 	"go.mongodb.org/mongo-driver/bson"
9 	"go.mongodb.org/mongo-driver/mongo"
10 	"go.mongodb.org/mongo-driver/mongo/options"
11 )
12 
13 func main() {
14 	// connect to your Atlas cluster
15 	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
16 	if err != nil {
17 		panic(err)
18 	}
19 	defer client.Disconnect(context.TODO())
20 
21 	// set namespace
22 	collection := client.Database("sample_mflix").Collection("movies")
23 
24 	// define pipeline stages
25 	searchStage := bson.D{{"$search", bson.M{
26 		"index": "date-range-tutorial",
27 		"compound": bson.M{
28 			"must": bson.M{
29 				"range": bson.M{
30 					"path": "released",
31 					"gt":   time.Date(2015, time.January, 1, 0, 0, 0, 0, time.UTC),
32 					"lt":   time.Date(2015, time.December, 31, 0, 0, 0, 0, time.UTC),
33 				}},
34 			"should": bson.D{
35 				{"near", bson.M{
36 					"path":   "released",
37 					"origin": time.Date(2015, time.July, 1, 0, 0, 0, 0, time.UTC),
38 					"pivot":  2629800000,
39 				}}},
40 			"mustNot": bson.D{
41 				{"text", bson.M{
42 					"path": "genres", "query": "Documentary",
43 				}}},
44 		}}}}
45 	projectStage := bson.D{{"$project", bson.D{{"_id", 0}, {"title", 1}, {"released", 1}, {"genres", 1}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
46 	limitStage := bson.D{{"$limit", 6}}
47 
48 	// run pipeline
49 	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage, limitStage})
50 	if err != nil {
51 		panic(err)
52 	}
53 
54 	// print results
55 	var results []bson.D
56 	if err = cursor.All(context.TODO(), &results); err != nil {
57 		panic(err)
58 	}
59 	for _, result := range results {
60 		fmt.Println(result)
61 	}
62 }

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

次のコマンドを実行して、コレクションをクエリします。

go run date-range-complex.go

[{genres [Action Adventure Sci-Fi]} {title Terminator Genisys} {released 1435708800000} {score 2}]
[{genres [Comedy Drama Music]} {title Magic Mike XXL} {released 1435708800000} {score 2}]
[{genres [Comedy Drama]} {title Home Care} {released 1435708800000} {score 2}]
[{genres [Drama Mystery Sci-Fi]} {title Pig} {released 1435795200000} {score 1.9681909084320068}]
[{genres [Drama History Romance]} {title Gold Coast} {released 1435795200000} {score 1.9681909084320068}]
[{genres [Animation Family]} {title Zarafa} {released 1435881600000} {score 1.9383430480957031}]

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

`CLASSPATH`に次のライブラリが含まれていることを確認します。

`junit`	4.11以降のバージョン
`mongodb-driver-sync`	4.3.0以降のバージョン
`slf4j-log4j12`	1.7.30以降のバージョン

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

DateRange.javaという名前のファイルを作成します。

次のコードをコピーして、 DateRange.javaファイルに貼り付けます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
次のcompound演算子句を使用して、コレクションをクエリします。
- 2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
- ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句
クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。
- title 、 released 、 genresフィールドを除くすべてのフィールドを除外
- 次のフィールドを追加: score
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 import java.util.Arrays;
2 import java.util.List;
3 
4 import static com.mongodb.client.model.Aggregates.limit;
5 import static com.mongodb.client.model.Aggregates.project;
6 import static com.mongodb.client.model.Projections.*;
7 import com.mongodb.client.MongoClient;
8 import com.mongodb.client.MongoClients;
9 import com.mongodb.client.MongoCollection;
10 import com.mongodb.client.MongoDatabase;
11 import org.bson.Document;
12 
13 import java.time.Instant;
14 import java.util.Date;
15 
16 public class DateRange {
17     public static void main( String[] args ) {
18         // define clauses
19         List<Document> mustClauses =
20             List.of( new Document(
21               "range", new Document("path", "released")
22               .append("gt", Date.from(Instant.parse("2015-01-01T00:00:00.000Z")))
23               .append("lt", Date.from(Instant.parse("2015-12-31T00:00:00.000Z")))));
24         List<Document> shouldClauses =
25             List.of(
26                 new Document(
27                 "near",
28                     new Document("pivot", 2629800000L)
29                     .append("path", "released")
30                     .append("origin", Date.from(Instant.parse("2015-07-01T00:00:00.000+00:00")))));
31         // define query
32         Document agg = 
33             new Document( "$search",
34                 new Document("index", "date-range-tutorial")
35                     .append( "compound",
36                         new Document().append("must", mustClauses)
37                         .append("should", shouldClauses)));
38         // specify connection
39         String uri = "<connection-string>";
40         
41         // establish connection and set namespace
42         try (MongoClient mongoClient = MongoClients.create(uri)) {
43           MongoDatabase database = mongoClient.getDatabase("sample_mflix");
44           MongoCollection<Document> collection = database.getCollection("movies");
45           
46           // run query and print results
47           collection.aggregate(Arrays.asList(agg, 
48             project(fields(
49                 excludeId(), 
50                 include("title", "released", "genres"), 
51                 computed("score", new Document("$meta", "searchScore")))),
52             limit(6)))
53             .forEach(doc -> System.out.println(doc.toJson()));	
54         }
55       }
56 }

注意

Maven 環境でサンプルコードを実行するには、ファイルのインポートステートメントの上に次のコードを追加します。

package com.mongodb.drivers;

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

DateRange.javaファイルをコンパイルして実行します。

javac DateRange.java
java DateRange

{"genres": ["Action", "Adventure", "Sci-Fi"], "title": "Terminator Genisys", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Comedy", "Drama", "Music"], "title": "Magic Mike XXL", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Documentary", "Biography", "Drama"], "title": "Mala Mala", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Comedy", "Drama"], "title": "Home Care", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Documentary", "News"], "title": "Bitcoin: The End of Money as We Know It", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Drama", "Mystery", "Sci-Fi"], "title": "Pig", "released": {"$date": "2015-07-02T00:00:00Z"}, "score": 1.9681909084320068}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

DateRangeComplex.javaという名前のファイルを作成します。

次のコードをコピーして、 DateRangeComplex.javaファイルに貼り付けます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
前の例に追加します。
must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 import java.util.Arrays;
2 import java.util.List;
3 
4 import static com.mongodb.client.model.Aggregates.limit;
5 import static com.mongodb.client.model.Aggregates.project;
6 import static com.mongodb.client.model.Projections.*;
7 import com.mongodb.client.MongoClient;
8 import com.mongodb.client.MongoClients;
9 import com.mongodb.client.MongoCollection;
10 import com.mongodb.client.MongoDatabase;
11 import org.bson.Document;
12 
13 import java.time.Instant;
14 import java.util.Date;
15 
16 public class DateRangeComplex {
17     public static void main( String[] args ) {
18         // define clauses
19         List<Document> mustClauses =
20             List.of( new Document(
21               "range", new Document("path", "released")
22               .append("gt", Date.from(Instant.parse("2015-01-01T00:00:00.000Z")))
23               .append("lt", Date.from(Instant.parse("2015-12-31T00:00:00.000Z")))));
24         List<Document> shouldClauses =
25             List.of(
26                 new Document(
27                 "near",
28                     new Document("pivot", 2629800000L)
29                     .append("path", "released")
30                     .append("origin", Date.from(Instant.parse("2015-07-01T00:00:00.000+00:00")))));
31         List<Document> mustNotClauses =
32             List.of(
33                 new Document(
34                     "text",
35                     new Document("query", "Documentary")
36                     .append("path", "genres")));
37                                 // define query
38         Document agg = 
39             new Document( "$search",
40                 new Document("index", "date-range-tutorial")
41                     .append( "compound",
42                         new Document().append("must", mustClauses)
43                         .append("should", shouldClauses)
44                         .append("mustNot", mustNotClauses)));
45         // specify connection
46         String uri = "<connection-string>";
47         
48         // establish connection and set namespace
49         try (MongoClient mongoClient = MongoClients.create(uri)) {
50           MongoDatabase database = mongoClient.getDatabase("sample_mflix");
51           MongoCollection<Document> collection = database.getCollection("movies");
52           
53           // run query and print results
54           collection.aggregate(Arrays.asList(agg, 
55             project(fields(
56                 excludeId(), 
57                 include("title", "released", "genres"), 
58                 computed("score", new Document("$meta", "searchScore")))),
59             limit(6)))
60             .forEach(doc -> System.out.println(doc.toJson()));	
61         }
62       }
63 }

注意

Maven 環境でサンプルコードを実行するには、ファイルのインポートステートメントの上に次のコードを追加します。

package com.mongodb.drivers;

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

DateRangeComplex.javaファイルをコンパイルして実行します。

javac DateRangeComplex.java
java DateRangeComplex

{"genres": ["Action", "Adventure", "Sci-Fi"], "title": "Terminator Genisys", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Comedy", "Drama", "Music"], "title": "Magic Mike XXL", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Comedy", "Drama"], "title": "Home Care", "released": {"$date": "2015-07-01T00:00:00Z"}, "score": 2.0}
{"genres": ["Drama", "Mystery", "Sci-Fi"], "title": "Pig", "released": {"$date": "2015-07-02T00:00:00Z"}, "score": 1.9681909084320068}
{"genres": ["Drama", "History", "Romance"], "title": "Gold Coast", "released": {"$date": "2015-07-02T00:00:00Z"}, "score": 1.9681909084320068}
{"genres": ["Animation", "Family"], "title": "Zarafa", "released": {"$date": "2015-07-03T00:00:00Z"}, "score": 1.9383430480957031}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

次の依存関係をプロジェクトに追加していることを確認してください。

`mongodb-driver-kotlin-coroutine`	4.10.0以降のバージョン

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

DateRange.ktという名前のファイルを作成します。

次のコードをコピーして、 DateRange.ktファイルに貼り付けます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
次のcompound演算子句を使用して、コレクションをクエリします。
- 2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
- ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句
クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。
- title 、 released 、 genresフィールドを除くすべてのフィールドを除外
- 次のフィールドを追加: score
クエリに一致するドキュメントをAggregateFlowインスタンスから出力します。

1 import com.mongodb.client.model.Aggregates.limit
2 import com.mongodb.client.model.Aggregates.project
3 import com.mongodb.client.model.Projections.*
4 import com.mongodb.kotlin.client.coroutine.MongoClient
5 import kotlinx.coroutines.runBlocking
6 import org.bson.Document
7 import java.time.Instant
8 import java.util.*
9 
10 fun main() {
11     // establish connection and set namespace
12     val uri = "<connection-string>"
13     val mongoClient = MongoClient.create(uri)
14     val database = mongoClient.getDatabase("sample_mflix")
15     val collection = database.getCollection<Document>("movies")
16 
17     runBlocking {
18         // define clauses
19         val mustClauses = listOf(
20             Document(
21                 "range", Document("path", "released")
22                     .append("gt", Date.from(Instant.parse("2015-01-01T00:00:00.000Z")))
23                     .append("lt", Date.from(Instant.parse("2015-12-31T00:00:00.000Z")))
24             )
25         )
26 
27         val shouldClauses = listOf(
28             Document(
29                 "near",
30                 Document("pivot", 2629800000L)
31                     .append("path", "released")
32                     .append("origin", Date.from(Instant.parse("2015-07-01T00:00:00.000+00:00")))
33             )
34         )
35 
36         // define query
37         val agg = Document(
38             "\$search",
39             Document("index", "date-range-tutorial")
40                 .append(
41                     "compound",
42                     Document().append("must", mustClauses)
43                         .append("should", shouldClauses)
44                 )
45         )
46 
47         // run query and print results
48         val resultsFlow = collection.aggregate<Document>(
49             listOf(
50                 agg,
51                 limit(6),
52                 project(fields(
53                     excludeId(),
54                     include("title", "released", "genres"),
55                     computed("score", Document("\$meta", "searchScore"))
56                 ))
57             )
58         )
59         resultsFlow.collect { println(it) }
60     }
61     mongoClient.close()
62 }

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

DateRange.ktファイルを実行します。

IDE でDateRange.ktプログラムを実行すると、次のドキュメントが出力されます。

Document{{genres=[Action, Adventure, Sci-Fi], title=Terminator Genisys, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Comedy, Drama, Music], title=Magic Mike XXL, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Documentary, News], title=Bitcoin: The End of Money as We Know It, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Documentary, Biography, Drama], title=Mala Mala, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Comedy, Drama], title=Home Care, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Drama, Mystery, Sci-Fi], title=Pig, released=Wed Jul 01 20:00:00 EDT 2015, score=1.9681909084320068}}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

DateRangeComplex.ktという名前のファイルを作成します。

次のコードをコピーして、 DateRangeComplex.ktファイルに貼り付けます。

このコード例では、次のタスクを実行します。

mongodb パッケージと依存関係をインポートします。
Atlas クラスターへの接続を確立します。
前の例に追加します。
must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。
クエリに一致するドキュメントをAggregateFlowインスタンスから出力します。

1 import com.mongodb.client.model.Aggregates.limit
2 import com.mongodb.client.model.Aggregates.project
3 import com.mongodb.client.model.Projections.*
4 import com.mongodb.kotlin.client.coroutine.MongoClient
5 import kotlinx.coroutines.runBlocking
6 import org.bson.Document
7 import java.time.Instant
8 import java.util.*
9 
10 fun main() {
11     // establish connection and set namespace
12     val uri = "<connection-string>"
13     val mongoClient = MongoClient.create(uri)
14     val database = mongoClient.getDatabase("sample_mflix")
15     val collection = database.getCollection<Document>("movies")
16 
17     runBlocking {
18         // define clauses
19         val mustClauses = listOf(
20             Document(
21                 "range", Document("path", "released")
22                     .append("gt", Date.from(Instant.parse("2015-01-01T00:00:00.000Z")))
23                     .append("lt", Date.from(Instant.parse("2015-12-31T00:00:00.000Z")))
24             )
25         )
26 
27         val shouldClauses = listOf(
28             Document(
29                 "near",
30                 Document("pivot", 2629800000L)
31                     .append("path", "released")
32                     .append("origin", Date.from(Instant.parse("2015-07-01T00:00:00.000+00:00")))
33             )
34         )
35 
36         val mustNotClauses = listOf(
37             Document(
38                 "text",
39                 Document("query", "Documentary")
40                     .append("path", "genres")
41             )
42         )
43 
44         // define query
45         val agg = Document(
46             "\$search",
47             Document("index", "date-range-tutorial")
48                 .append(
49                     "compound",
50                     Document().append("must", mustClauses)
51                         .append("should", shouldClauses)
52                         .append("mustNot", mustNotClauses)
53                 )
54         )
55 
56         // run query and print results
57         val resultsFlow = collection.aggregate<Document>(
58             listOf(
59                 agg,
60                 limit(6),
61                 project(fields(
62                     excludeId(),
63                     include("title", "released", "genres"),
64                     computed("score", Document("\$meta", "searchScore"))
65                 ))
66             )
67         )
68         resultsFlow.collect { println(it) }
69     }
70     mongoClient.close()
71 }

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

DateRangeComplex.ktファイルを実行します。

IDE でDateRangeComplex.ktプログラムを実行すると、次のドキュメントが出力されます。

Document{{genres=[Action, Adventure, Sci-Fi], title=Terminator Genisys, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Comedy, Drama, Music], title=Magic Mike XXL, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Comedy, Drama], title=Home Care, released=Tue Jun 30 20:00:00 EDT 2015, score=2.0}}
Document{{genres=[Drama, Mystery, Sci-Fi], title=Pig, released=Wed Jul 01 20:00:00 EDT 2015, score=1.9681909084320068}}
Document{{genres=[Drama, History, Romance], title=Gold Coast, released=Wed Jul 01 20:00:00 EDT 2015, score=1.9681909084320068}}
Document{{genres=[Drama], title=Jackie & Ryan, released=Thu Jul 02 20:00:00 EDT 2015, score=1.9383430480957031}}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

date-range.jsという名前のファイルを作成します。

次のコードをコピーして、 date-range.jsファイルに貼り付けます。

このコード例では、次のタスクを実行します。

MongoDB の Node.js ドライバーであるmongodbをインポートします。
Atlas クラスターへの接続を確立するためのMongoClientクラスのインスタンスを作成します。
次のcompound演算子句を使用して、コレクションをクエリします。
- 2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
- ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句
クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。
- title 、 released 、 genresフィールドを除くすべてのフィールドを除外
- 次のフィールドを追加: score
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 const { MongoClient } = require("mongodb");
2 
3 // connect to your Atlas cluster
4 const uri =
5     "<connection-string>";
6     
7 const client = new MongoClient(uri);
8 
9 async function run() {
10     try {
11         await client.connect();
12 
13         // set namespace
14         const database = client.db("sample_mflix");
15         const coll = database.collection("movies");
16 
17         // define pipeline
18         const agg = [
19             { $search: { 
20                 index: 'date-range-tutorial',
21                 compound: { 
22                     must: [{  range: { path: "released", gt: new Date("2015-01-01T00:00:00.000Z"), lt: new Date("2015-12-31T00:00:00.000Z") }}], 
23                     should: [{ near: { path: "released", origin: new Date("2015-07-01T00:00:00.000Z"), pivot: 2629800000 }}]}}},
24             { $project: {_id: 0, title: 1, released: 1, genres: 1, score: { $meta: "searchScore" }}}, 
25             { $limit: 6 }
26         ];
27         
28         // run pipeline
29         const result = await coll.aggregate(agg);
30 
31         // print results
32         await result.forEach((doc) => console.log(doc));
33     } finally {
34         await client.close();
35     }
36 }
37 run().catch(console.dir);

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

次のコマンドを実行して、コレクションをクエリします。

node date-range.js

{
  genres: [ 'Action', 'Adventure', 'Sci-Fi' ],
  title: 'Terminator Genisys',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
 genres: [ 'Comedy', 'Drama', 'Music' ],
 title: 'Magic Mike XXL',
 released: 2015-07-01T00:00:00.000Z,
 score: 2
}
{
  genres: [ 'Documentary', 'Biography', 'Drama' ],
  title: 'Mala Mala',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
  genres: [ 'Comedy', 'Drama' ],
  title: 'Home Care',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
  genres: [ 'Documentary', 'News' ],
  title: 'Bitcoin: The End of Money as We Know It',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
  genres: [ 'Drama', 'Mystery', 'Sci-Fi' ],
  title: 'Pig',
  released: 2015-07-02T00:00:00.000Z,
  score: 1.9681909084320068
}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

date-range-complex.jsという名前のファイルを作成します。

次のコードをコピーして、 date-range-complex.jsファイルに貼り付けます。

このコード例では、次のタスクを実行します。

MongoDB の Node.js ドライバーであるmongodbをインポートします。
Atlas クラスターへの接続を確立するためのMongoClientクラスのインスタンスを作成します。
前の例に追加します。
must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 const { MongoClient } = require("mongodb");
2 
3 // connect to your Atlas cluster
4 const uri =
5     "<connection-string>";
6     
7 const client = new MongoClient(uri);
8 
9 async function run() {
10     try {
11         await client.connect();
12 
13         // set namespace
14         const database = client.db("sample_mflix");
15         const coll = database.collection("movies");
16 
17         // define pipeline
18         const agg = [
19             { $search: { 
20                 index: 'date-range-tutorial',
21                 compound: { 
22                     must: [{  range: { path: "released", gt: new Date("2015-01-01T00:00:00.000Z"), lt: new Date("2015-12-31T00:00:00.000Z") }}], 
23                     should: [{ near: { path: "released", origin: new Date("2015-07-01T00:00:00.000Z"), pivot: 2629800000 }}],
24                     mustNot: [{ text: { path: "genres", query:  "Documentary"} }]}}},
25             { $project: {_id: 0, title: 1, released: 1, genres: 1, score: { $meta: "searchScore" }}}, 
26             { $limit: 6 }
27         ];
28         
29         // run pipeline
30         const result = await coll.aggregate(agg);
31 
32         // print results
33         await result.forEach((doc) => console.log(doc));
34     } finally {
35         await client.close();
36     }
37 }
38 run().catch(console.dir);

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

次のコマンドを実行して、コレクションをクエリします。

node date-range-complex.js

{
  genres: [ 'Action', 'Adventure', 'Sci-Fi' ],
  title: 'Terminator Genisys',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
  genres: [ 'Comedy', 'Drama', 'Music' ],
  title: 'Magic Mike XXL',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
  genres: [ 'Comedy', 'Drama' ],
  title: 'Home Care',
  released: 2015-07-01T00:00:00.000Z,
  score: 2
}
{
  genres: [ 'Drama', 'Mystery', 'Sci-Fi' ],
  title: 'Pig',
  released: 2015-07-02T00:00:00.000Z,
  score: 1.9681909084320068
}
{
  genres: [ 'Drama', 'History', 'Romance' ],
  title: 'Gold Coast',
  released: 2015-07-02T00:00:00.000Z,
  score: 1.9681909084320068
}
{
  genres: [ 'Animation', 'Family' ],
  title: 'Zarafa',
  released: 2015-07-03T00:00:00.000Z,
  score: 1.9383430480957031
}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

date-range.pyという名前のファイルを作成します。

次のコードをコピーして、 date-range.pyファイルに貼り付けます。

次のコード例では、次を行います。

pymongo、MongoDB の Python ドライバー、およびDNSシードリスト接続文字列を使用してpymongo をAtlas に接続するために必要なdns モジュールをインポートします。
Atlas クラスターへの接続を確立するためのMongoClientクラスのインスタンスを作成します。
次のcompound演算子句を使用して、コレクションをクエリします。
- 2015-01-01と2015-12-31の間に公開された映画を検索するためのmust句
- ピボット距離が 1 か月で、 2012-07-01にリリースされた映画の優先順位を指定するshould句
クエリには、出力を6の結果に制限する$limitステージと、次の操作を行う$projectステージが含まれています。
- title 、 released 、 genresフィールドを除くすべてのフィールドを除外
- 次のフィールドを追加: score
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 import pymongo
2 import datetime
3 
4 # connect to your Atlas cluster
5 client = pymongo.MongoClient("<connection-string>")
6 
7 # define pipeline
8 pipeline = [
9     {"$search": {
10         "index": "date-range-tutorial",
11         "compound": {
12             "must": [{"range": {"path": "released", "gt": datetime.datetime(2015,1,1,0,0,0), "lt": datetime.datetime(2015,12,31,0,0,0)}}],
13             "should": [{"near": {"path": "released", "origin": datetime.datetime(2015, 7, 1, 0, 0, 0, 0), "pivot": 2629800000}}]}}},
14     {"$limit": 6},
15     {"$project": {"_id": 0, "title": 1, "released": 1, "genres": 1, "score": {"$meta": "searchScore"}}}
16 ]
17 # run pipeline
18 result = client["sample_mflix"]["movies"].aggregate(pipeline)
19 
20 # print results
21 for i in result:
22     print(i)

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

次のコマンドを実行して、コレクションをクエリします。

python date-range.py

{'genres': ['Action', 'Adventure', 'Sci-Fi'], 'title': 'Terminator Genisys', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Comedy', 'Drama', 'Music'], 'title': 'Magic Mike XXL', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Documentary', 'Biography', 'Drama'], 'title': 'Mala Mala', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Comedy', 'Drama'], 'title': 'Home Care', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Documentary', 'News'], 'title': 'Bitcoin: The End of Money as We Know It', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Drama', 'Mystery', 'Sci-Fi'], 'title': 'Pig', 'released': datetime.datetime(2015, 7, 2, 0, 0), 'score': 1.9681909084320068}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

date-range-complex.pyという名前のファイルを作成します。

次のコードをコピーして、 date-range-complex.pyファイルに貼り付けます。

次のコード例では、次を行います。

pymongo、MongoDB の Python ドライバー、およびDNSシードリスト接続文字列を使用してpymongo をAtlas に接続するために必要なdns モジュールをインポートします。
Atlas クラスターへの接続を確立するためのMongoClientクラスのインスタンスを作成します。
前の例に追加します。
must句とshould句に加えて、このクエリにはdocumentaryジャンルの映画を結果に含めることはできないことを指定するためのmustNot句も含まれています。
カーソルを反復処理して、クエリに一致するドキュメントを出力します。

1 import pymongo
2 import datetime
3 
4 # connect to your Atlas cluster
5 client = pymongo.MongoClient("<connection-string>")
6 
7 # define pipeline
8 pipeline = [
9     {"$search": {
10         "index": "date-range-tutorial",
11         "compound": {
12             "must": [{"range": {"path": "released", "gt": datetime.datetime(2015,1,1,0,0,0), "lt": datetime.datetime(2015,12,31,0,0,0)}}],
13             "should": [{"near": {"path": "released", "origin": datetime.datetime(2015, 7, 1, 0, 0, 0, 0), "pivot": 2629800000}}],
14             "mustNot": [{"text": {"path": "genres", "query": "Documentary"}}]}}},
15     {"$limit": 6},
16     {"$project": {"_id": 0, "title": 1, "released": 1, "genres": 1, "score": {"$meta": "searchScore"}}}
17 ]
18 # run pipeline
19 result = client["sample_mflix"]["movies"].aggregate(pipeline)
20 
21 # print results
22 for i in result:
23     print(i)

サンプルを実行する前に、<connection-string> をAtlas接続stringに置き換えます。接続stringにデータベースユーザーの認証情報が含まれていることを確認します。詳しくは、「ドライバーによる接続」を参照してください。

次のコマンドを実行して、コレクションをクエリします。

python date-range-complex.py

{'genres': ['Action', 'Adventure', 'Sci-Fi'], 'title': 'Terminator Genisys', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Comedy', 'Drama', 'Music'], 'title': 'Magic Mike XXL', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Comedy', 'Drama'], 'title': 'Home Care', 'released': datetime.datetime(2015, 7, 1, 0, 0), 'score': 2.0}
{'genres': ['Drama', 'Mystery', 'Sci-Fi'], 'title': 'Pig', 'released': datetime.datetime(2015, 7, 2, 0, 0), 'score': 1.9681909084320068}
{'genres': ['Drama', 'History', 'Romance'], 'title': 'Gold Coast', 'released': datetime.datetime(2015, 7, 2, 0, 0), 'score': 1.9681909084320068}
{'genres': ['Animation', 'Family'], 'title': 'Zarafa', 'released': datetime.datetime(2015, 7, 3, 0, 0), 'score': 1.9383430480957031}

クエリでは、 should句で 7 月日頃の映画の優先順位が指定されていたため、上位の結果は 7 月の結果になります。

戻る

オブジェクトの配列

日付型および数値型文字列クエリ

1	[
2	{
3	$search: {
4	"index": "date-range-tutorial",
5	"compound": {
6	"must": [{
7	"range": {
8	"path": "released",
9	"gt": ISODate("2015-01-01T00:00:00.000Z"),
10	"lt": ISODate("2015-12-31T00:00:00.000Z")
11	}
12	}],
13	"should": [{
14	"near": {
15	"path": "released",
16	"origin": ISODate("2015-07-01T00:00:00.000+00:00"),
17	"pivot": 2629800000
18	}
19	}]
20	}
21	}
22	}
23	]

1	using MongoDB.Bson;
2	using MongoDB.Bson.Serialization.Attributes;
3	using MongoDB.Bson.Serialization.Conventions;
4	using MongoDB.Driver;
5	using MongoDB.Driver.Search;
6
7	public class DateRangeExample
8	{
9	private const string MongoConnectionString = "<connection-string>";
10
11	public static void Main(string[] args)
12	{
13	// allow automapping of the camelCase database fields to our MovieDocument
14	var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15	ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17	// connect to your Atlas cluster
18	var mongoClient = new MongoClient(MongoConnectionString);
19	var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20	var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
21
22	// declare data for compound query
23	var startDate = new DateTime(2015, 01, 01, 0, 0, 0, DateTimeKind.Utc);
24	var endDate = new DateTime(2015, 12, 31, 0, 0, 0, DateTimeKind.Utc);
25	var nearDate = new DateTime(2015, 07, 01, 0, 0, 0, DateTimeKind.Utc);
26
27	// define and run pipeline
28	var results = moviesCollection.Aggregate()
29	.Search(Builders<MovieDocument>.Search.Compound()
30	.Must(Builders<MovieDocument>.Search.Range(movie => movie.Released, SearchRangeBuilder.Gt(startDate).Lt(endDate)))
31	.Should(Builders<MovieDocument>.Search.Near(movie => movie.Released, nearDate, 2629800000)),
32	indexName: "date-range-tutorial")
33	.Project<MovieDocument>(Builders<MovieDocument>.Projection
34	.Include(movie => movie.Genres)
35	.Include(movie => movie.Released)
36	.Include(movie => movie.Title)
37	.Exclude(movie => movie.Id)
38	.MetaSearchScore(movie => movie.Score))
39	.Limit(6)
40	.ToList();
41
42	// print results
43	foreach (var movie in results)
44	{
45	Console.WriteLine(movie.ToJson());
46	}
47	}
48	}
49
50	[BsonIgnoreExtraElements]
51	public class MovieDocument
52	{
53	[BsonIgnoreIfDefault]
54	public ObjectId Id { get; set; }
55	public string [] Genres { get; set; }
56	public DateTime Released { get; set; }
57	public string Title { get; set; }
58	public double Score { get; set; }
59	}

1	package main
2
3	import (
4	"context"
5	"fmt"
6	"time"
7
8	"go.mongodb.org/mongo-driver/bson"
9	"go.mongodb.org/mongo-driver/mongo"
10	"go.mongodb.org/mongo-driver/mongo/options"
11	)
12
13	func main() {
14	// connect to your Atlas cluster
15	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
16	if err != nil {
17	panic(err)
18	}
19	defer client.Disconnect(context.TODO())
20
21	// set namespace
22	collection := client.Database("sample_mflix").Collection("movies")
23
24	// define pipeline stages
25	searchStage := bson.D{{"$search", bson.M{
26	"index": "date-range-tutorial",
27	"compound": bson.M{
28	"must": bson.M{
29	"range": bson.M{
30	"path": "released",
31	"gt": time.Date(2015, time.January, 1, 0, 0, 0, 0, time.UTC),
32	"lt": time.Date(2015, time.December, 31, 0, 0, 0, 0, time.UTC),
33	}},
34	"should": bson.D{
35	{"near", bson.M{
36	"path": "released",
37	"origin": time.Date(2015, time.July, 1, 0, 0, 0, 0, time.UTC),
38	"pivot": 2629800000,
39	}}},
40	}}}}
41	projectStage := bson.D{{"$project", bson.D{{"_id", 0}, {"title", 1}, {"released", 1}, {"genres", 1}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
42	limitStage := bson.D{{"$limit", 6}}
43
44	// run pipeline
45	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage, limitStage})
46	if err != nil {
47	panic(err)
48	}
49
50	// print results
51	var results []bson.D
52	if err = cursor.All(context.TODO(), &results); err != nil {
53	panic(err)
54	}
55	for _, result := range results {
56	fmt.Println(result)
57	}
58	}

1	import java.util.Arrays;
2	import java.util.List;
3
4	import static com.mongodb.client.model.Aggregates.limit;
5	import static com.mongodb.client.model.Aggregates.project;
6	import static com.mongodb.client.model.Projections.*;
7	import com.mongodb.client.MongoClient;
8	import com.mongodb.client.MongoClients;
9	import com.mongodb.client.MongoCollection;
10	import com.mongodb.client.MongoDatabase;
11	import org.bson.Document;
12
13	import java.time.Instant;
14	import java.util.Date;
15
16	public class DateRange {
17	public static void main( String[] args ) {
18	// define clauses
19	List<Document> mustClauses =
20	List.of( new Document(
21	"range", new Document("path", "released")
22	.append("gt", Date.from(Instant.parse("2015-01-01T00:00:00.000Z")))
23	.append("lt", Date.from(Instant.parse("2015-12-31T00:00:00.000Z")))));
24	List<Document> shouldClauses =
25	List.of(
26	new Document(
27	"near",
28	new Document("pivot", 2629800000L)
29	.append("path", "released")
30	.append("origin", Date.from(Instant.parse("2015-07-01T00:00:00.000+00:00")))));
31	// define query
32	Document agg =
33	new Document( "$search",
34	new Document("index", "date-range-tutorial")
35	.append( "compound",
36	new Document().append("must", mustClauses)
37	.append("should", shouldClauses)));
38	// specify connection
39	String uri = "<connection-string>";
40
41	// establish connection and set namespace
42	try (MongoClient mongoClient = MongoClients.create(uri)) {
43	MongoDatabase database = mongoClient.getDatabase("sample_mflix");
44	MongoCollection<Document> collection = database.getCollection("movies");
45
46	// run query and print results
47	collection.aggregate(Arrays.asList(agg,
48	project(fields(
49	excludeId(),
50	include("title", "released", "genres"),
51	computed("score", new Document("$meta", "searchScore")))),
52	limit(6)))
53	.forEach(doc -> System.out.println(doc.toJson()));
54	}
55	}
56	}

1	import com.mongodb.client.model.Aggregates.limit
2	import com.mongodb.client.model.Aggregates.project
3	import com.mongodb.client.model.Projections.*
4	import com.mongodb.kotlin.client.coroutine.MongoClient
5	import kotlinx.coroutines.runBlocking
6	import org.bson.Document
7	import java.time.Instant
8	import java.util.*
9
10	fun main() {
11	// establish connection and set namespace
12	val uri = "<connection-string>"
13	val mongoClient = MongoClient.create(uri)
14	val database = mongoClient.getDatabase("sample_mflix")
15	val collection = database.getCollection<Document>("movies")
16
17	runBlocking {
18	// define clauses
19	val mustClauses = listOf(
20	Document(
21	"range", Document("path", "released")
22	.append("gt", Date.from(Instant.parse("2015-01-01T00:00:00.000Z")))
23	.append("lt", Date.from(Instant.parse("2015-12-31T00:00:00.000Z")))
24	)
25	)
26
27	val shouldClauses = listOf(
28	Document(
29	"near",
30	Document("pivot", 2629800000L)
31	.append("path", "released")
32	.append("origin", Date.from(Instant.parse("2015-07-01T00:00:00.000+00:00")))
33	)
34	)
35
36	// define query
37	val agg = Document(
38	"\$search",
39	Document("index", "date-range-tutorial")
40	.append(
41	"compound",
42	Document().append("must", mustClauses)
43	.append("should", shouldClauses)
44	)
45	)
46
47	// run query and print results
48	val resultsFlow = collection.aggregate<Document>(
49	listOf(
50	agg,
51	limit(6),
52	project(fields(
53	excludeId(),
54	include("title", "released", "genres"),
55	computed("score", Document("\$meta", "searchScore"))
56	))
57	)
58	)
59	resultsFlow.collect { println(it) }
60	}
61	mongoClient.close()
62	}

1	const { MongoClient } = require("mongodb");
2
3	// connect to your Atlas cluster
4	const uri =
5	"<connection-string>";
6
7	const client = new MongoClient(uri);
8
9	async function run() {
10	try {
11	await client.connect();
12
13	// set namespace
14	const database = client.db("sample_mflix");
15	const coll = database.collection("movies");
16
17	// define pipeline
18	const agg = [
19	{ $search: {
20	index: 'date-range-tutorial',
21	compound: {
22	must: [{ range: { path: "released", gt: new Date("2015-01-01T00:00:00.000Z"), lt: new Date("2015-12-31T00:00:00.000Z") }}],
23	should: [{ near: { path: "released", origin: new Date("2015-07-01T00:00:00.000Z"), pivot: 2629800000 }}]}}},
24	{ $project: {_id: 0, title: 1, released: 1, genres: 1, score: { $meta: "searchScore" }}},
25	{ $limit: 6 }
26	];
27
28	// run pipeline
29	const result = await coll.aggregate(agg);
30
31	// print results
32	await result.forEach((doc) => console.log(doc));
33	} finally {
34	await client.close();
35	}
36	}
37	run().catch(console.dir);

1	import pymongo
2	import datetime
3
4	# connect to your Atlas cluster
5	client = pymongo.MongoClient("<connection-string>")
6
7	# define pipeline
8	pipeline = [
9	{"$search": {
10	"index": "date-range-tutorial",
11	"compound": {
12	"must": [{"range": {"path": "released", "gt": datetime.datetime(2015,1,1,0,0,0), "lt": datetime.datetime(2015,12,31,0,0,0)}}],
13	"should": [{"near": {"path": "released", "origin": datetime.datetime(2015, 7, 1, 0, 0, 0, 0), "pivot": 2629800000}}]}}},
14	{"$limit": 6},
15	{"$project": {"_id": 0, "title": 1, "released": 1, "genres": 1, "score": {"$meta": "searchScore"}}}
16	]
17	# run pipeline
18	result = client["sample_mflix"]["movies"].aggregate(pipeline)
19
20	# print results
21	for i in result:
22	print(i)

動的マッピングを使用した Atlas Search インデックスの作成

Atlas Atlasで、プロジェクトの {0 ページにGoします。Go.css-h15tq0{font-style:normal;font-weight:700;}Clusters

GoAtlas Searchクラスターの ページに します。

をクリックします。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Create Search Index

Atlas SearchConfiguration Method を選択し、[]Next をクリックします。

Index Nameを入力し、Database and Collection を設定します。

インデックスの定義を指定します。

ビジュアル エディター

JSON エディター

をクリックします。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Save Changes

をクリックします。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Create Search Index

You're All Set!モーダル ウィンドウを閉じます。

インデックスの作成が完了するまで待ちます。

複合クエリの実行

AtlasGoClustersAtlas で、プロジェクトの ページにGoします。

GoAtlas Searchクラスターの ページに します。

[Search Tester] に移動します。

クエリ構文を表示および編集します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

クエリ結果を展開します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

クエリ結果を展開します。

mongoshでクラスターに接続します。

sample_mflixデータベースを使用します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

MongoDB Compass のクラスターに接続します。

moviessample_mflixデータベースに コレクションを作成します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

クエリの .NET/C# プロジェクトを設定して初期化します。

ファイルに 2 つの句を持つ 演算子を使用してcompoundProgram.cs Atlas Search クエリを作成して実行します。

ファイルに 3 つの句を持つ 演算子を使用してcompound Program.csAtlas Search クエリを作成して実行します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

CLASSPATHに次のライブラリが含まれていることを確認します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

注意

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

注意

次の依存関係をプロジェクトに追加していることを確認してください。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

コレクションに対して compound2 つの 句を指定して moviesAtlas Search クエリを実行します。

コレクションに対して compound3 つの 句を使用して moviesAtlas Search クエリを実行します。

Atlas Atlasで、プロジェクトの {0 ページにGoします。GoClusters

GoAtlas Searchクラスターのページにします。

ビジュアルエディター

You're All Set!モーダルウィンドウを閉じます。

AtlasGoClustersAtlas で、プロジェクトのページにGoします。

GoAtlas Searchクラスターのページにします。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

`mongosh`でクラスターに接続します。

`sample_mflix`データベースを使用します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

`moviessample_mflix`データベースにコレクションを作成します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

ファイルに 2 つの句を持つ演算子を使用して`compoundProgram.cs` Atlas Search クエリを作成して実行します。

ファイルに 3 つの句を持つ演算子を使用して`compound` `Program.cs`Atlas Search クエリを作成して実行します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

`CLASSPATH`に次のライブラリが含まれていることを確認します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`2 つの句を指定して `movies`Atlas Search クエリを実行します。

コレクションに対して `compound`3 つの句を使用して `movies`Atlas Search クエリを実行します。