Atlas Searchでのファセットの使用方法

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

1. まだ表示されていない場合は、希望するプロジェクトを含む組織を選択しますナビゲーション バーのOrganizationsメニュー

2. まだ表示されていない場合は、ナビゲーション バーのProjectsメニューから目的のプロジェクトを選択します。

3. まだ表示されていない場合は、サイドバーの Clusters をクリックしてください。

   [ Clusters （クラスター） ] ページが表示されます。

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

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

[Search Tester] に移動します。

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

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

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

インデックス付きフィールドに対して Atlas Search クエリを実行します。

クエリを実行するには、次のクエリをコピーしてQuery Editorに貼り付け、[ Searchをクリックします。

次のクエリは、1921 年 11 月 11 日前後にリリースされた映画を検索します。 originから約 3 か月のpivotの距離を指定します。 genresyearフィールドと フィールドのメタデータをリクエストします。クエリは、次のカウントを要求します。

• genres string 配列フィールド内の各ジャンルの映画の数

• 1910 年から 1939 年までの映画の本数

[
  {
    "$searchMeta": {
      "index": "facet-tutorial",
      "facet": {
        "operator": {
          "near": {
            "path": "released",
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
            "pivot": 7776000000
          }
        },
        "facets": {
          "genresFacet": {
            "type": "string",
            "path": "genres"
          },
          "yearFacet" : {
            "type" : "number",
            "path" : "year",
            "boundaries" : [1910,1920,1930,1940]
          }
        }
      }
    }
  }
]

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

Search Testerでは、結果内のフィールドのすべての値が表示されない場合があります。 結果内のフィールドのすべての値を表示するには、フィールドを展開します。

Atlas Search によって、 ページに次の結果が表示されます。

count: Object
  lowerBound: 20878
facet: Object
  genresFacet: Object
    buckets: Array (10)
      0: Object
         _id: "Drama"
         count: 12149
      1: Object
         _id: "Comedy"
         count: 6436
      2: Object
         _id: "Romance"
         count: 3274
      3: Object
         _id: "Crime"
         count: 2429
      4: Object
         _id: "Thriller"
         count: 2400
      5: Object
         _id: "Action"
         count: 2349
      6: Object
         _id: "Adventure"
         count: 1876
      7: Object
         _id: "Documentary"
         count: 1755
      8: Object
         _id: "Horror"
         count: 1432
      9: Object
         _id: "Biography"
         count: 1244
  yearFacet: Object
    buckets: Array (3)
      0: Object
         _id: 1910
         count: 14
      1: Object
         _id: 1920
         count: 47
      2: Object
         _id: 1930
         count: 238

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

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

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

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

use sample_mflix

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

次のクエリは、1921 年 11 月 11 日前後にリリースされた映画を検索します。 originから約 3 か月のpivotの距離を指定します。 genresyearフィールドと フィールドのメタデータをリクエストします。クエリは、次のカウントを要求します。

• genres string 配列フィールド内の各ジャンルの映画の数

• 1910 年から 1939 年までの映画の本数

db.movies.aggregate([
  {
    "$searchMeta": {
      "index": "facet-tutorial",
      "facet": {
        "operator": {
          "near": {
            "path": "released",
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
            "pivot": 7776000000
          }
        },
        "facets": {
          "genresFacet": {
            "type": "string",
            "path": "genres"
          },
          "yearFacet" : {
            "type" : "number",
            "path" : "year",
            "boundaries" : [1910,1920,1930,1940]
          }
        }
      }
    }
  }
])

{
  "count" : {
    "lowerBound" : NumberLong(23026)
  },
  "facet" : {
    "genresFacet" : {
      "buckets" : [
        { "_id" : "Drama", "count" : NumberLong(13527) },
        { "_id" : "Comedy", "count" : NumberLong(6922) },
        { "_id" : "Romance", "count" : NumberLong(3615) },
        { "_id" : "Crime", "count" : NumberLong(2649) },
        { "_id" : "Thriller", "count" : NumberLong(2603) },
        { "_id" : "Action", "count" : NumberLong(2505) },
        { "_id" : "Documentary", "count" : NumberLong(2041) },
        { "_id" : "Adventure", "count" : NumberLong(2016) },
        { "_id" : "Horror", "count" : NumberLong(1662) },
        { "_id" : "Biography", "count" : NumberLong(1373) }
      ]
    },
    "yearFacet" : {
      "buckets" : [
        { "_id" : 1910, "count" : NumberLong(23) },
        { "_id" : 1920, "count" : NumberLong(89) },
        { "_id" : 1930, "count" : NumberLong(308) }
      ]
    }
  }
}

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

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

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

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

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

クエリでは、次のsearchMeta演算子句を使用します。

• に近いでは、1921 年 11 月 11 日から約 3 か月間にoriginからのpivotの距離でリリースされた映画を検索します

• facets genres string 配列フィールドの各ジャンルの映画の数と、 1910から1939までの 年間の映画の数をリクエストします

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

1. [Aggregations] タブをクリックします。

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

   パイプラインステージ	クエリ
   $searchMeta	{ index: 'facet-tutorial', facet: { operator: { near: { path: 'released', origin: ISODate("1921-11-01T00:00:00.000+00:00"), pivot: 7776000000 } }, facets: { genresFacet: { type: 'string', path: 'genres' }, yearFacet: { type: 'number', path: 'year', boundaries: [1910,1920,1930,1940] } } } }

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

{
   count: { lowerBound: 23026 },
   facet: {
     genresFacet: {
       buckets: [
         { _id: "Drama", count: 13527 },
         { _id: "Comedy", count: 6922 },
         { _id: "Romance", count: 3615 },
         { _id: "Crime", count: 2649 },
         { _id: "Thriller", count: 2603 },
         { _id: "Action", count: 2505 },
         { _id: "Documentary", count: 2041 },
         { _id: "Adventure", count: 2016 },
         { _id: "Horror", count: 1662 },
         { _id: "Biography", count: 1373 }
       ]
     },
     yearFacet: {
       buckets: [
         { _id: 1910, count: 23 },
         { _id: 1920, count: 89 },
         { _id: 1930, count: 308 }
       ]
     }
   }
 }

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

1. facet-query-example という新しいディレクトリを作成し、dotnet new コマンドでプロジェクトを初期化します。

   mkdir facet-query-example
   cd facet-query-example
   dotnet new console

2. .NET/C# ドライバーを依存関係としてプロジェクトに追加します。

   dotnet add package MongoDB.Driver

Program.csファイルにクエリを作成します。

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

   次のクエリは、1921 年 11 月 11 日前後にリリースされた映画を検索します。 originから約 3 か月のpivotの距離を指定します。 genresyearフィールドと フィールドのメタデータをリクエストします。クエリは、次のカウントを要求します。

   • genres string 配列フィールド内の各ジャンルの映画の数

   • 1910 年から 1939 年までの映画の本数

   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 FacetExample
   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 date and number fields
   23
           var originDate = new DateTime(1921, 11, 01, 0, 0, 0, DateTimeKind.Utc);
   24
   25
           // define and run pipeline
   26
           var results = moviesCollection.Aggregate()
   27
               .SearchMeta(Builders<MovieDocument>.Search.Facet(
   28
                       Builders<MovieDocument>.Search.Near(movie => movie.Released, originDate, 7776000000),
   29
                       Builders<MovieDocument>.SearchFacet.String("genresFacet", movie => movie.Genres, 10),
   30
                       Builders<MovieDocument>.SearchFacet.Number("yearFacet", movie => movie.Year, 1910, 1920, 1930, 1940)),
   31
                       indexName: "facet-tutorial")
   32
               .Single();
   33
   34
           // print results
   35
           Console.WriteLine(results.ToJson());
   36
       }
   37
   }
   38
   39
   [BsonIgnoreExtraElements]
   40
   public class MovieDocument
   41
   {
   42
       [BsonIgnoreIfDefault]
   43
       public ObjectId Id { get; set; }
   44
       public string [] Genres { get; set; }
   45
       public DateTime Released { get; set; }
   46
       public int Year { get; set; }
   47
   }

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

ファイルをコンパイルして実行します。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">Program.cs

dotnet run facet-query-example.csproj

{
  "count" : { "lowerBound" : NumberLong(23026), "total" : null },
  "facet" : {
    "genresFacet" : {
      "buckets" : [
        { "_id" : "Drama", "count" : NumberLong(13527) },
        { "_id" : "Comedy", "count" : NumberLong(6922) },
        { "_id" : "Romance", "count" : NumberLong(3615) },
        { "_id" : "Crime", "count" : NumberLong(2649) },
        { "_id" : "Thriller", "count" : NumberLong(2603) },
        { "_id" : "Action", "count" :  NumberLong(2505) },
        { "_id" : "Documentary", "count" : NumberLong(2041) },
        { "_id" : "Adventure", "count" : NumberLong(2016) },
        { "_id" : "Horror", "count" : NumberLong(1662) },
        { "_id" : "Biography", "count" : NumberLong(1373) }
      ]
    },
    "yearFacet" : {
      "buckets" : [
        { "_id" : 1910, "count" : NumberLong(23) },
        { "_id" : 1920, "count" : NumberLong(89) },
        { "_id" : 1930, "count" : NumberLong(308) }
      ]
    }
  }
}

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

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

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

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

   • mongodb パッケージと依存関係をインポートします。

   • Atlas クラスターへの接続を確立します。

   • 次の searchMeta 句を使用して、 コレクションをクエリします。

     • に近いでは、1921 年 11 月 11 日から約 3 か月間にoriginからのpivotの距離でリリースされた映画を検索します

     • facets genres string 配列フィールドの各ジャンルの映画の数と、 1910から1939までの 年間の映画の数をリクエストします

   • カーソルを反復処理して、クエリに一致するドキュメントを出力します。

   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{{"$searchMeta", bson.M{
   26
   		"index": "facet-tutorial",
   27
   		"facet": bson.M{
   28
   			"operator": bson.M{
   29
   				"near": bson.M{
   30
   					"path":   "released",
   31
   					"origin": time.Date(1921, time.November, 1, 0, 0, 0, 0, time.UTC),
   32
   					"pivot":  7776000000},
   33
   			},
   34
   			"facets": bson.M{
   35
   				"genresFacet": bson.M{
   36
   					"path": "genres",
   37
   					"type": "string"},
   38
   				"yearFacet": bson.M{
   39
   					"path":       "year",
   40
   					"type":       "number",
   41
   					"boundaries": bson.A{1910, 1920, 1930, 1940}},
   42
   			}}}}}
   43
   	// run pipeline
   44
   	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage})
   45
   	if err != nil {
   46
   		panic(err)
   47
   	}
   48
   49
   	// print results
   50
   	var results []bson.D
   51
   	if err = cursor.All(context.TODO(), &results); err != nil {
   52
   		panic(err)
   53
   	}
   54
   	for _, result := range results {
   55
   		fmt.Println(result)
   56
   	}
   57
   }

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

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

   go run facet-query.go

   出力を非表示

   [{count [{lowerBound 23026}]}
    {facet [
      {genresFacet [
        {buckets [
         [{_id Drama} {count 13527}]
         [{_id Comedy} {count 6922}]
         [{_id Romance} {count 3615}]
         [{_id Crime} {count 2649}]
         [{_id Thriller} {count 2603}]
         [{_id Action} {count 2505}]
         [{_id Documentary} {count 2041}]
         [{_id Adventure} {count 2016}]
         [{_id Horror} {count 1662}]
         [{_id Biography} {count 1373}]]}]}
     {yearFacet [
       {buckets [
         [{_id 1910} {count 23}]
         [{_id 1920} {count 89}]
         [{_id 1930} {count 308}]]}]}]}]

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

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

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

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

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

   • mongodb パッケージと依存関係をインポートします。

   • Atlas クラスターへの接続を確立します。

   • 次の searchMeta 句を使用して、 コレクションをクエリします。

     • に近いでは、1921 年 11 月 11 日から約 3 か月間にoriginからのpivotの距離でリリースされた映画を検索します

     • facets genres string 配列フィールドの各ジャンルの映画の数と、 1910から1939までの 年間の映画の数をリクエストします

   • カーソルを反復処理して、クエリに一致するドキュメントを出力します。

   1
   import com.mongodb.client.MongoClient;
   2
   import com.mongodb.client.MongoClients;
   3
   import com.mongodb.client.MongoCollection;
   4
   import com.mongodb.client.MongoDatabase;
   5
   import org.bson.Document;
   6
   7
   import java.time.Instant;
   8
   import java.util.Arrays;
   9
   import java.util.Date;
   10
   11
   public class FacetQuery {
   12
       public static void main(String[] args) {
   13
           // connect to your Atlas cluster
   14
           String uri = "<connection-string>";
   15
   16
           try (MongoClient mongoClient = MongoClients.create(uri)) {
   17
               // set namespace
   18
               MongoDatabase database = mongoClient.getDatabase("sample_mflix");
   19
               MongoCollection<Document> collection = database.getCollection("movies");
   20
               
   21
               // define pipeline
   22
               Document agg = new Document("$searchMeta", 
   23
                   new Document( "index", "facet-tutorial")
   24
                   .append("facet", 
   25
                       new Document("operator", 
   26
                           new Document("near", 
   27
                               new Document("path", "released")
   28
                               .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000+00:00")))
   29
                               .append("pivot", 7776000000L)))
   30
                   .append("facets", 
   31
                       new Document("genresFacet", 
   32
                           new Document("type", "string").append("path", "genres"))
   33
                       .append("yearFacet",
   34
                           new Document("type", "number").append("path", "year")
   35
                           .append("boundaries", Arrays.asList(1910, 1920, 1930, 1940))
   36
                ))));
   37
               // run pipeline and print results
   38
               collection.aggregate(Arrays.asList(agg))
   39
                   .forEach(doc -> System.out.println(doc.toJson()));
   40
   41
           }
   42
       }
   43
   }

   注意

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

   package com.mongodb.drivers;

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

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

   javac FacetQuery.java
   java FacetQuery

   出力を非表示

   {"count": {"lowerBound": 23026},
    "facet": {
      "genresFacet": {
        "buckets": [
          {"_id": "Drama", "count": 13527},
          {"_id": "Comedy", "count": 6922},
          {"_id": "Romance", "count": 3615},
          {"_id": "Crime", "count": 2649},
          {"_id": "Thriller", "count": 2603},
          {"_id": "Action", "count": 2505},
          {"_id": "Documentary", "count": 2041},
          {"_id": "Adventure", "count": 2016},
          {"_id": "Horror", "count": 1662},
          {"_id": "Biography", "count": 1373}]},
      "yearFacet": {
        "buckets": [
          {"_id": 1910, "count": 23},
          {"_id": 1920, "count": 89},
          {"_id": 1930, "count": 308}]}}}

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

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

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

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

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

   • mongodb パッケージと依存関係をインポートします。

   • Atlas クラスターへの接続を確立します。

   • 次のsearchMeta句を使用して、コレクションをクエリします。

     • に近いでは、1921 年 11 月 11 日から約 3 か月間にoriginからのpivotの距離でリリースされた映画を検索します

     • facets genres string 配列フィールドの各ジャンルの映画の数と、 1910から1939までの 年間の映画の数をリクエストします

   • クエリに一致するドキュメントをAggregateFlowインスタンスから出力します。

   1
   import com.mongodb.kotlin.client.coroutine.MongoClient
   2
   import kotlinx.coroutines.runBlocking
   3
   import org.bson.Document
   4
   import java.time.Instant
   5
   import java.util.*
   6
   7
   fun main() {
   8
       // connect to your Atlas cluster
   9
       val uri = "<connection-string>"
   10
       val mongoClient = MongoClient.create(uri)
   11
       
   12
       // set namespace
   13
       val database = mongoClient.getDatabase("sample_mflix")
   14
       val collection = database.getCollection<Document>("movies")
   15
   16
       runBlocking {
   17
           // define pipeline
   18
           val agg = Document(
   19
               "\$searchMeta",
   20
               Document("index", "facet-tutorial")
   21
                   .append(
   22
                       "facet",
   23
                       Document(
   24
                           "operator",
   25
                           Document(
   26
                               "near",
   27
                               Document("path", "released")
   28
                                   .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000+00:00")))
   29
                                   .append("pivot", 7776000000L)
   30
                           )
   31
                       )
   32
                           .append(
   33
                               "facets",
   34
                               Document(
   35
                                   "genresFacet",
   36
                                   Document("type", "string").append("path", "genres")
   37
                               )
   38
                                   .append(
   39
                                       "yearFacet",
   40
                                       Document("type", "number").append("path", "year")
   41
                                           .append("boundaries", listOf(1910, 1920, 1930, 1940))
   42
                                   )
   43
                           )
   44
                   )
   45
           )
   46
   47
           // run pipeline and print results
   48
           val resultsFlow = collection.aggregate<Document>(
   49
               listOf(agg)
   50
           )
   51
           resultsFlow.collect { println(it) }
   52
       }
   53
       mongoClient.close()
   54
   }

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

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

   IDE でFacetQuery.ktプログラムを実行すると、次の結果が出力されます。

   Document{{count=Document{{lowerBound=20878}},
   facet=Document{{genresFacet=Document{{buckets=[Document{{_id=Drama,
   count=12149}}, Document{{_id=Comedy, count=6436}},
   Document{{_id=Romance, count=3274}}, Document{{_id=Crime,
   count=2429}}, Document{{_id=Thriller, count=2400}},
   Document{{_id=Action, count=2349}}, Document{{_id=Adventure,
   count=1876}}, Document{{_id=Documentary, count=1755}},
   Document{{_id=Horror, count=1432}}, Document{{_id=Biography,
   count=1244}}]}},
   yearFacet=Document{{buckets=[Document{{_id=1910, count=14}},
   Document{{_id=1920, count=47}}, Document{{_id=1930,
   count=238}}]}}}}}}

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

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

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

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

   • MongoDB の Node.js ドライバーであるmongodbをインポートします。

   • Atlas クラスターへの接続を確立するためのMongoClientクラスのインスタンスを作成します。

   • 次の searchMeta 句を使用して、 コレクションをクエリします。

     • に近いでは、1921 年 11 月 11 日から約 3 か月間にoriginからのpivotの距離でリリースされた映画を検索します

     • facets genres string 配列フィールドの各ジャンルの映画の数と、 1910から1939までの 年間の映画の数をリクエストします

   • カーソルを反復処理して、クエリに一致するドキュメントを出力します。

   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 = [{$searchMeta: {
   19
             index: "facet-tutorial",
   20
             facet: {
   21
                   operator: {
   22
                     near: {path: "released", origin: new Date("1921-11-01T00:00:00.000Z"), pivot: 7776000000}
   23
                   },
   24
                   facets: {
   25
                     genresFacet: {type: "string", path: "genres"},
   26
                     yearFacet: {type: "number", path: "year",boundaries: [1910,1920,1930,1940]}
   27
                   }}}}];
   28
           // run pipeline
   29
           const result = coll.aggregate(agg);
   30
   31
           // print results
   32
           await result.forEach((doc) => console.dir(JSON.stringify(doc)));
   33
       } finally {
   34
           await client.close();
   35
       }
   36
   }
   37
   run().catch(console.dir);

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

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

   node facet-query.js

   出力を非表示

   '{"count":{"lowerBound":23026},
     "facet":{
       "genresFacet":{
         "buckets":[
           {"_id":"Drama","count":13527},
           {"_id":"Comedy","count":6922},
           {"_id":"Romance","count":3615},
           {"_id":"Crime","count":2649},
           {"_id":"Thriller","count":2603},
           {"_id":"Action","count":2505},
           {"_id":"Documentary","count":2041},
           {"_id":"Adventure","count":2016},
           {"_id":"Horror","count":1662},
           {"_id":"Biography","count":1373}]},
       "yearFacet":{
         "buckets":[
           {"_id":1910,"count":23},
           {"_id":1920,"count":89},
           {"_id":1930,"count":308}]}}}'

ジャンルと年 フィールドをバケットにグループ化する Atlas Search ファセット クエリを実行します。

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

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

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

   • pymongo、MongoDB の Python ドライバー、およびDNSシード リスト接続文字列を使用してpymongo をAtlas に接続するために必要なdns モジュールをインポートします。

   • Atlas クラスターへの接続を確立するためのMongoClientクラスのインスタンスを作成します。

   • 次の searchMeta 句を使用して、 コレクションをクエリします。

     • に近いでは、1921 年 11 月 11 日から約 3 か月間にoriginからのpivotの距離でリリースされた映画を検索します

     • facets genres string 配列フィールドの各ジャンルの映画の数と、 1910から1939までの 年間の映画の数をリクエストします

   • カーソルを反復処理して、クエリに一致するドキュメントを出力します。

   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 = [{"$searchMeta": { 
   9
       "index": "facet-tutorial",
   10
       "facet": {
   11
           "operator": {
   12
             "near": {"path": "released", "origin": datetime.datetime(1921, 11, 1, 0, 0, 0, 0), "pivot": 7776000000}
   13
           },
   14
           "facets": {
   15
             "genresFacet": {"type": "string", "path": "genres"},
   16
             "yearFacet" : {"type" : "number", "path" : "year", "boundaries" : [1910,1920,1930,1940]}
   17
           }}}}]
   18
   # run pipeline
   19
   result = client["sample_mflix"]["movies"].aggregate(pipeline)
   20
   21
   # print results
   22
   for i in result:
   23
       print(i)

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

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

   python facet-query.py

   出力を非表示

   {'count': {'lowerBound': 23026},
    'facet': {
      'genresFacet': {
        'buckets': [
          {'count': 13527, '_id': 'Drama'},
          {'count': 6922, '_id': 'Comedy'},
          {'count': 3615, '_id': 'Romance'},
          {'count': 2649, '_id': 'Crime'},
          {'count': 2603, '_id': 'Thriller'},
          {'count': 2505, '_id': 'Action'},
          {'count': 2041, '_id': 'Documentary'},
          {'count': 2016, '_id': 'Adventure'},
          {'count': 1662, '_id': 'Horror'},
          {'count': 1373, '_id': 'Biography'}]},
      'yearFacet': {
        'buckets': [
          {'count': 23, '_id': 1910},
          {'count': 89, '_id': 1920},
          {'count': 308, '_id': 1930}]}}}