如何在 Atlas Search 中使用分面

在 AtlasClusters 中，转到项目的 页面。

1. 如果尚未显示，请选择包含所需项目的组织导航栏中的Organizations菜单。

2. 如果尚未显示，请从导航栏的Projects菜单中选择所需的项目。

3. 如果 Clusters（数据库部署）页面尚未出现，请单击侧边栏中的 Database（数据库）。

转到集群的 Atlas Search 页面。

您可以从侧边栏、 Data Explorer或集群详细信息页面转到 Atlas Search 页面。

转到Search Tester 。

单击要查询的索引右侧的 Query 按钮。

查看和编辑查询语法。

单击Edit $search Query查看 JSON格式的默认查询语法示例。

针对索引字段运行 Atlas Search 查询。

要运行查询，请将以下查询复制并粘贴到 Query Editor，然后单击 Search。

以下查询搜索在 1921 年 11 月 11 日前后上映的电影。它要求电影相对于 origin 的 pivot 距离为大约三个月。它要求提供 genres 和 year 字段上的元数据。该查询要求计数：

• genres 字符串数组字段中每种类型的电影数量

• 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 的 pivot 距离为大约三个月。它要求提供 genres 和 year 字段上的元数据。该查询要求计数：

• genres 字符串数组字段中每种类型的电影数量

• 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 连接。

movies使用sample_mflix 数据库中的 集合。

在 Database 屏幕上，依次单击 sample_mflix 数据库和 movies 集合。

运行 Atlas Search 分面查询，将流派和年份字段分组到存储桶中。

该查询使用以下searchMeta操作符子句：

• near 搜索 1921 年 11 月 11 日前后上映的电影，要求电影相对于 origin 的 pivot 距离为大约三个月

• facets 请求genres字符串数组字段中每种类型的电影数量以及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 的 pivot 距离为大约三个月。它要求提供 genres 和 year 字段上的元数据。该查询要求计数：

   • genres 字符串数组字段中每种类型的电影数量

   • 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 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情，请参阅通过驱动程序连接。

编译并运行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 子句来查询集合：

     • near 搜索 1921 年 11 月 11 日前后上映的电影，要求电影相对于 origin 的 pivot 距离为大约三个月

     • facets 请求genres字符串数组字段中每种类型的电影数量以及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 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情，请参阅通过驱动程序连接。

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 子句来查询集合：

     • near 搜索 1921 年 11 月 11 日前后上映的电影，要求电影相对于 origin 的 pivot 距离为大约三个月

     • facets 请求genres字符串数组字段中每种类型的电影数量以及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 环境中运行示例代码，请在您的声明中的 import 文件上方添加以下内容。

   package com.mongodb.drivers;

3. 在运行示例之前，请将 <connection-string> 替换为 Atlas 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情，请参阅通过驱动程序连接。

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子句查询集合：

     • near 搜索 1921 年 11 月 11 日前后上映的电影，要求电影相对于 origin 的 pivot 距离为大约三个月

     • facets 请求genres字符串数组字段中每种类型的电影数量以及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 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情，请参阅通过驱动程序连接。

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，即 MongoDB 的 Node.js 驱动程序。

   • 创建一个 MongoClient 类实例，以建立与 Atlas 集群的连接。

   • 使用以下 searchMeta 子句来查询集合：

     • near 搜索 1921 年 11 月 11 日前后上映的电影，要求电影相对于 origin 的 pivot 距离为大约三个月

     • facets 请求genres字符串数组字段中每种类型的电影数量以及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 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情，请参阅通过驱动程序连接。

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模块，这是使用DNS种子列表连接字符串将pymongo连接到Atlas所必需的。

   • 创建一个 MongoClient 类实例，以建立与 Atlas 集群的连接。

   • 使用以下 searchMeta 子句来查询集合：

     • near 搜索 1921 年 11 月 11 日前后上映的电影，要求电影相对于 origin 的 pivot 距离为大约三个月

     • facets 请求genres字符串数组字段中每种类型的电影数量以及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 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情，请参阅通过驱动程序连接。

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