如何在 Atlas Search 中使用分面

AtlasGoClusters在Atlas中，Go项目的 页面。

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

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

3. 如果尚未出现，请单击侧边栏中的 Clusters（集群）。

   会显示集群页面。

转到集群的 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 分面查询，将流派和年份字段分组到存储桶中。

示例查询使用以下内容来查询集合：

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

• facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

1
db.movies.aggregate([
2
  {
3
    "$searchMeta": {
4
      "index": "facet-tutorial",
5
      "facet": {
6
        "operator": {
7
          "near": {
8
            "path": "released",
9
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
10
            "pivot": 7776000000
11
          }
12
        },
13
        "facets": {
14
          "genresFacet": {
15
            "type": "string",
16
            "path": "genres"
17
          },
18
          "yearFacet" : {
19
            "type" : "number",
20
            "path" : "year",
21
            "boundaries" : [1910,1920,1930,1940]
22
          }
23
        }
24
      }
25
    }
26
  }
27
])

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

db.movies.aggregate([
    {
      "$search": {
        "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]
            }
          }
        }
      }
    },
    {
      "$facet": {
        "meta": [
          {"$replaceWith": "$$SEARCH_META"},
          {"$limit": 1}
        ]
      }
    },
    {
      "$set": {
        "meta": {
          "$arrayElemAt": ["$meta", 0]
        }
      }
    }
  ])

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

在 MongoDB Compass 中连接到您的集群。

打开 MongoDB Compass 并连接到您的集群。有关连接的详细说明，请参阅通过 Compass 连接。

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

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

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

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

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

• facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

若要在 MongoDB Compass 中运行此查询：

1. 单击 Aggregations 标签页。

2. 单击 Select...，然后从下拉菜单中选择阶段并为该阶段添加查询，以配置以下每个管道阶段。单击 Add Stage 以添加其他阶段。

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   管道阶段	查询
   $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	{ "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] } } } }
   $facet	{ meta: [ { $replaceWith: "$$SEARCH_META" }, { $limit: 1 } ] }
   $set	{ meta: { $arrayElemAt: ["$meta", 0] } }

如果启用了 Auto Preview，MongoDB Compass 将在 $set 管道阶段旁边显示以下文档：

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

为查询设置并初始化 .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文件的内容替换为以下代码。

   示例查询使用以下内容来查询集合：

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

   • facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   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
   }

   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
   using System;
   7
   8
   public class FacetExample
   9
   {
   10
       private const string MongoConnectionString = "<your-connection-string>";
   11
   12
       public static void Main(string[] args)
   13
       {
   14
           // Register camelCase conventions for document mapping
   15
           var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
   16
           ConventionRegistry.Register("CamelCase", camelCaseConvention, t => true);
   17
   18
           // Connect to your MongoDB Atlas cluster
   19
           var mongoClient = new MongoClient(MongoConnectionString);
   20
           var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
   21
           var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
   22
   23
           // Define the origin date for the `near` operator
   24
           var originDate = new DateTime(1921, 11, 01, 0, 0, 0, DateTimeKind.Utc);
   25
   26
           // Create an array of BsonValues for the number boundaries
   27
           var yearBoundaries = new BsonArray { 1910, 1920, 1930, 1940 };
   28
   29
           // Define the $search stage 
   30
           var searchStage = Builders<MovieDocument>.Search.Facet(
   31
               Builders<MovieDocument>.Search.Near(
   32
                   "released", // The field to search
   33
                   origin: originDate, // Starting date
   34
                   pivot: 7776000000 // Pivot (milliseconds)
   35
               ),
   36
               Builders<MovieDocument>.SearchFacet.String(
   37
                   "genresFacet", // Name of the string facet
   38
                   "genres" // The field to facet on
   39
               ),
   40
               Builders<MovieDocument>.SearchFacet.Number(
   41
                   "yearFacet", // Name of the number facet
   42
                   "year", // The field to facet on
   43
                   yearBoundaries 
   44
               )
   45
           );
   46
   47
           // Step 2: Aggregate pipeline implementationdd
   48
           var pipeline = moviesCollection.Aggregate()
   49
               .Search(searchStage, indexName: "facet-tutorial") 
   50
               .AppendStage<BsonDocument>(new BsonDocument
   51
               {
   52
                   { "$facet", new BsonDocument
   53
                       {
   54
                           { "meta", new BsonArray
   55
                               {
   56
                                   new BsonDocument { { "$replaceWith", "$$SEARCH_META" } },
   57
                                   new BsonDocument { { "$limit", 1 } }
   58
                               }
   59
                           }
   60
                       }
   61
                   }
   62
               })
   63
               .AppendStage<BsonDocument>(new BsonDocument
   64
               {
   65
                   { "$set", new BsonDocument
   66
                       {
   67
                           { "meta", new BsonDocument
   68
                               {
   69
                                   { "$arrayElemAt", new BsonArray { "$meta", 0 } }
   70
                               }
   71
                           }
   72
                       }
   73
                   }
   74
               })
   75
               .ToList();
   76
   77
           // Step 3: Output results
   78
           foreach (var result in pipeline)
   79
           {
   80
               Console.WriteLine(result.ToJson());
   81
           }
   82
       }
   83
   }
   84
   85
   [BsonIgnoreExtraElements]
   86
   public class MovieDocument
   87
   {
   88
       [BsonIgnoreIfDefault]
   89
       public ObjectId Id { get; set; }
   90
       public string[] Genres { get; set; }
   91
       public DateTime Released { get; set; }
   92
       public int Year { get; set; }
   93
   }

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

编译并运行 Program.cs 文件。

dotnet run facet-query-example.csproj

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

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

1. 创建一个名为 facet-query.go 的文件。

2. 将以下代码复制并粘贴到 facet-query.go 文件。

   此代码示例将执行以下任务：

   • 导入mongodb包和依赖项。

   • 建立与您的 Atlas 集群的连接。

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

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

     • facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

   • 遍历游标以打印与查询匹配的文档。

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   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
   }

   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": "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
   		},
   44
   	}}}
   45
   46
   	facetStage:= bson.D{{"$facet", bson.D{
   47
           {"meta", bson.A{
   48
               bson.D{{"$replaceWith", "$$SEARCH_META"}},
   49
               bson.D{{"$limit", 1}},
   50
           }},
   51
       }}}
   52
   	setStage:= bson.D{{"$set", bson.D{
   53
           {"meta", bson.D{
   54
               {"$arrayElemAt", bson.A{"$meta",  0}},
   55
           }},
   56
       }}}
   57
   58
   	// run pipeline
   59
   	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, facetStage, setStage})
   60
   	if err != nil {
   61
   		panic(err)
   62
   	}
   63
   64
   	// print results
   65
   	var results []bson.D
   66
   	if err = cursor.All(context.TODO(), &results); err != nil {
   67
   		panic(err)
   68
   	}
   69
   	for _, result := range results {
   70
   		fmt.Println(result)
   71
   	}
   72
   }

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

4. 运行以下命令来查询您的集合：

   go run facet-query.go

   隐藏输出

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

确保 CLASSPATH 包含以下库。

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

1. 创建一个名为 FacetQuery.java 的文件。

2. 将以下代码复制并粘贴到 FacetQuery.java 文件。

   此代码示例将执行以下任务：

   • 导入mongodb包和依赖项。

   • 建立与您的 Atlas 集群的连接。

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

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

     • facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

   • 遍历游标以打印与查询匹配的文档。

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   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
   }

   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.util.Arrays;
   8
   import java.util.List;
   9
   10
   public class FacetQuery {
   11
       public static void main(String[] args) {
   12
           // connect to your Atlas cluster
   13
           String uri = "<CONNECTION-STRING>";
   14
   15
           try (MongoClient mongoClient = MongoClients.create(uri)) {
   16
               // set namespace
   17
               MongoDatabase database = mongoClient.getDatabase("sample_mflix");
   18
               MongoCollection<Document> collection = database.getCollection("movies");
   19
               
   20
               // define pipeline
   21
               List<Document> agg = Arrays.asList(new Document("$search", 
   22
               new Document("index", "facet-tutorial")
   23
                   .append("facet", new Document("operator", new Document("near", new Document("path", "released")
   24
                       .append("origin", new java.util.Date(-1520035200000L))
   25
                       .append("pivot", 7776000000L)))
   26
                   .append("facets", new Document("genresFacet", new Document("type", "string")
   27
                       .append("path", "genres"))
   28
                   .append("yearFacet", new Document("type", "number")
   29
                       .append("path", "year")
   30
                       .append("boundaries", Arrays.asList(1910L, 1920L, 1930L, 1940L)))))), 
   31
               new Document("$facet", new Document("meta", Arrays.asList(new Document("$replaceWith", "$$SEARCH_META"), 
   32
                   new Document("$limit", 1L)))), 
   33
               new Document("$set", new Document("meta", new Document("$arrayElemAt", Arrays.asList("$meta", 0L)))));
   34
               // run pipeline and print results
   35
               collection.aggregate(agg)
   36
                   .forEach(doc -> System.out.println(doc.toJson()));
   37
   38
           }
   39
       }
   40
   }

   注意

   要在 Maven 环境中运行示例代码，请在文件中的 import 语句上方添加以下内容。

   package com.mongodb.drivers;

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

4. 编译并运行 FacetQuery.java 文件。

   javac FacetQuery.java
   java FacetQuery

   隐藏输出

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

确保将以下依赖项添加到项目中。

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

1. 创建一个名为 FacetQuery.kt 的文件。

2. 将以下代码复制并粘贴到 FacetQuery.kt 文件。

   此代码示例将执行以下任务：

   • 导入mongodb包和依赖项。

   • 建立与您的 Atlas 集群的连接。

   • 使用以下内容查询集合：

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

     • facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

   • 打印与 AggregateFlow 实例中的查询相匹配的文档。

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   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
   }

   1
   import com.mongodb.kotlin.client.coroutine.MongoClient
   2
   import kotlinx.coroutines.flow.collect
   3
   import kotlinx.coroutines.runBlocking
   4
   import org.bson.Document
   5
   import java.time.Instant
   6
   import java.util.Date
   7
   8
   fun main() {
   9
       // Connection URI for your MongoDB Atlas cluster
   10
       val uri = "<connection-string>"
   11
       val mongoClient = MongoClient.create(uri)
   12
   13
       // Set namespace (database and collection)
   14
       val database = mongoClient.getDatabase("sample_mflix")
   15
       val collection = database.getCollection<Document>("movies")
   16
   17
       runBlocking {
   18
           // Define the aggregation pipeline
   19
           val searchStage = Document("\$search", Document("index", "facet-tutorial")
   20
               .append("facet", Document("operator", Document("near", Document("path", "released")
   21
                   // Replace +00:00 with Z
   22
                   .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000Z"))) 
   23
                   .append("pivot", 7776000000L)))
   24
                   .append("facets", Document("genresFacet", Document("type", "string")
   25
                       .append("path", "genres"))
   26
                       .append("yearFacet", Document("type", "number").append("path", "year")
   27
                           .append("boundaries", listOf(1910, 1920, 1930, 1940))))))
   28
   29
           val facetStage = Document("\$facet", Document("meta", listOf(
   30
               Document("\$replaceWith", "\$\$SEARCH_META"),
   31
               Document("\$limit", 1)
   32
           )))
   33
   34
           val setStage = Document("\$set", Document("meta", Document("\$arrayElemAt", listOf("\$meta", 0))))
   35
   36
           // Run the aggregation pipeline and print results
   37
           val resultsFlow = collection.aggregate<Document>(
   38
               listOf(searchStage, facetStage, setStage)
   39
           )
   40
   41
           resultsFlow.collect { println(it.toJson()) } // Convert each result to JSON and print
   42
       }
   43
   44
       // Close the MongoDB client
   45
       mongoClient.close()
   46
   }

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 string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

   • 遍历游标以打印与查询匹配的文档。

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   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);

   1
   const { MongoClient } = require("mongodb");
   2
   3
   // connect to your Atlas cluster
   4
   const uri = "<connection-string>";
   5
       
   6
   const client = new MongoClient(uri);
   7
   8
   async function run() {
   9
       try {
   10
           await client.connect();
   11
   12
           // set namespace
   13
           const database = client.db("sample_mflix");
   14
           const coll = database.collection("movies");
   15
   16
           // define pipeline
   17
           const agg = [
   18
               {
   19
                 '$search': {
   20
                   'index': "facet-tutorial",
   21
                   'facet': {
   22
                     'operator': {
   23
                       'near': {
   24
                         'path': 'released', 
   25
                         'origin': new Date('Tue, 01 Nov 1921 00:00:00 GMT'), 
   26
                         'pivot': 7776000000
   27
                       }
   28
                     }, 
   29
                     'facets': {
   30
                       'genresFacet': {
   31
                         'type': 'string', 
   32
                         'path': 'genres'
   33
                       }, 
   34
                       'yearFacet': {
   35
                         'type': 'number', 
   36
                         'path': 'year', 
   37
                         'boundaries': [1910, 1920, 1930, 1940]
   38
                       }
   39
                     }
   40
                   }
   41
                 }
   42
               }, {
   43
                 '$facet': {
   44
                   'meta': [
   45
                     {
   46
                       '$replaceWith': '$$SEARCH_META'
   47
                     }, {
   48
                       '$limit': 1
   49
                     }
   50
                   ]
   51
                 }
   52
               }, {
   53
                 '$set': {
   54
                   'meta': {
   55
                     '$arrayElemAt': ['$meta', 0]
   56
                   }
   57
                 }
   58
               }
   59
           ];
   60
           // run pipeline
   61
           const result = coll.aggregate(agg);
   62
   63
           // print results
   64
           await result.forEach((doc) => console.dir(JSON.stringify(doc)));
   65
       } finally {
   66
           await client.close();
   67
       }
   68
   }
   69
   run().catch(console.dir);

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

4. 运行以下命令来查询您的集合：

   node facet-query.js

   隐藏输出

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

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

1. 创建一个名为 facet-query.py 的文件。

   touch facet-query.py

2. 将以下代码复制并粘贴到 facet-query.py 文件。

   以下代码示例：

   • 导入 pymongo 、MongoDB 的 Python 驱动程序和 dns 模块，这是使用 DNS 种子列表连接字符串将 pymongo 连接到 Atlas 所必需的。

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

   • 使用以下内容查询集合：

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

     • facets 要请求 genres string 数组字段中每种类型的电影数，以及 1910 到 1939 年中的电影数，包括

   • 遍历游标以打印与查询匹配的文档。

   您可以使用$searchMeta或使用$search与 SEARCH_META 聚合变量来运行此查询。

   $searchMeta

   $ 使用 $$SEARCH_META 进行搜索

   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)

   1
   import pymongo
   2
   from datetime import datetime, timezone  # Import timezone for tzinfo=timezone.utc
   3
   4
   # Connect to your Atlas cluster
   5
   client = pymongo.MongoClient("<connection-string>")
   6
   7
   # Define pipeline
   8
   pipeline = [{
   9
       '$search': {
   10
           'index': 'facet-tutorial',
   11
           'facet': {
   12
               'operator': {
   13
                   'near': {
   14
                       'path': 'released',
   15
                       'origin': datetime(1921, 11, 1, 0, 0, 0, tzinfo=timezone.utc),  # Corrected timezone
   16
                       'pivot': 7776000000
   17
                   }
   18
               },
   19
               'facets': {
   20
                   'genresFacet': {
   21
                       'type': 'string', 'path': 'genres'
   22
                   },
   23
                   'yearFacet': {
   24
                       'type': 'number', 'path': 'year', 'boundaries': [1910, 1920, 1930, 1940]
   25
                   }
   26
               }
   27
           }
   28
       }
   29
   }, {
   30
       '$facet': {
   31
           'meta': [
   32
               {'$replaceWith': '$$SEARCH_META'},
   33
               {'$limit': 1}
   34
           ]
   35
       }
   36
   }, {
   37
       '$set': {
   38
           'meta': {'$arrayElemAt': ['$meta', 0]}
   39
       }
   40
   }]
   41
   # Run pipeline
   42
   result = client["sample_mflix"]["movies"].aggregate(pipeline)
   43
   44
   # Print results
   45
   for doc in result:
   46
       print(doc)

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

4. 运行以下命令来查询您的集合：

   python facet-query.py

   隐藏输出

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