如何对 Atlas Search 结果进行排序

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

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

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

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

   会显示集群页面。

转到集群的 Atlas Search 页面。

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

转到 Search Tester（搜索测试器）。

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

查看和编辑查询语法。

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

针对索引字段运行 Atlas Search 查询并对结果进行排序。

以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

将以下查询复制并粘贴到 Query Editor 中，然后点击 Query Editor 中的 Search 按钮。

[
  {
    "$search": {
      "index": "sort-tutorial",
      "range": {
        "path": "awards.wins",
        "gte": 10
      },
      "sort": {
        "awards.wins": -1,
      }
    }
  }
]

SCORE: 1  _id:  "573a13d5f29313caabd9cae7"
  fullplot: "Based on an incredible true story of one man's fight for survival and …"
  imdb: Object
    ...
  year: 2013
  ...
  awards: Object
    wins: 267
    ...
  ...
SCORE: 1  _id:  "573a13c7f29313caabd74a4d"
  fullplot: "Dr. Ryan Stone (Sandra Bullock) is a brilliant medical engineer on her…"
  imdb: Object
    ...
  year: 2013
  ...
  awards: Object
    wins: 231
    ...
  ...
SCORE: 1  _id:  "573a13cbf29313caabd808d2"
  fullplot: "Dr. Ryan Stone (Sandra Bullock) is a brilliant medical engineer on her…"
  imdb: Object
    ...
  year: 2013
  ...
  awards: Object
    wins: 231
    ...
  ...
SCORE: 1  _id:  “573a13dff29313caabdb7adb”"
  fullplot: "Actor Riggan Thomson is most famous for his movie role from over twent…"
  imdb: Object
    ...
  year: 2014
  ...
  awards: Object
    wins: 210
    ...
  ...
SCORE: 1  _id:  "573a13bef29313caabd5c06c"
  plot: "The life of Mason, from early childhood to his arrival at college."
  imdb: Object
    ...
  runtime: 165
  ...
  awards: Object
    wins: 185
    ...
  ...
SCORE: 1  _id:  "573a139ef29313caabcfbd6a"
  fullplot: "While Frodo & Sam continue to approach Mount Doom to destroy the One R…"
  imdb: Object
    ...
  year: 2003
  ...
  awards: Object
    wins: 175
    ...
  ...
SCORE: 1  _id:  "573a13b5f29313caabd447f5"
  plot: "In rural Texas, welder and hunter Llewelyn Moss discovers the remains …"
  imdb: Object
    ...
  year: 2007
  ...
  awards: Object
    wins: 172
    ...
  ...
SCORE: 1  _id:  "573a13c3f29313caabd68d9f"
  plot: "On a fall night in 2003, Harvard undergrad and computer programming ge…"
  imdb: Object
    ...
  year: 2010
  ...
  awards: Object
    wins: 171
    ...
  ...
SCORE: 1  _id:  "573a13c5f29313caabd6ee61"
  fullplot: "Dom Cobb is a skilled thief, the absolute best in the dangerous art of…"
  imdb: Object
    ...
  year: 2010
  ...
  awards: Object
    wins: 162
    ...
  ...
SCORE: 1  _id:  "573a13bdf29313caabd58fd3"
  plot: "The story of Jamal Malik, an 18 year-old orphan from the slums of Mumb…"
  imdb: Object
    ...
  year: 2008
  ...
  awards: Object
    wins: 161
    ...
  ...

展开查询结果。

Search Tester 可能不会显示其所返回文档的所有字段。要查看所有字段，包括在查询路径中指定的字段，请展开结果中的文档。

通过 mongosh 连接到您的集群。

在终端窗口中打开mongosh并连接到集群。 有关连接的详细说明，请参阅通过mongosh连接。

使用 sample_mflix 数据库。

在 mongosh 提示符下运行以下命令：

use sample_mflix

针对索引字段运行 Atlas Search 查询并对结果进行排序。

以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

查询使用了下列管道阶段：

• $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

• $limit 阶段将输出限制为 5 个结果。

• $project 阶段排除 title 和 awards.wins 以外的所有字段。

1
db.movies.aggregate([
2
  {
3
    "$search": {
4
      "index": "sort-tutorial",
5
      "range": {
6
        "path": "awards.wins",
7
        "gte": 10
8
      },
9
      "sort": {
10
        "awards.wins": -1,
11
      }
12
    }
13
  },
14
  {
15
    $limit: 5
16
  },
17
  {
18
    "$project": {
19
      "_id": 0,
20
      "title": 1,
21
      "awards.wins": 1
22
    }
23
  }
24
])

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

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

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

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

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

针对索引字段运行 Atlas Search 查询并对结果进行排序。

以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

查询使用了下列管道阶段：

• $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

• $limit 阶段将输出限制为 5 个结果。

• $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

1. 单击 Aggregations 标签页。

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

   管道阶段	查询
   $search	{ index: "sort-tutorial", "range": { "path": "awards.wins", "gte": 10 }, "sort": { "awards.wins": -1, } }
   $limit	5
   $project	{ title: 1, released: 1, year: 1 }

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

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

为查询设置并初始化 .NET/C# 项目。

1. 创建一个名为 sort-by-numbers-example 的新目录，并使用 dotnet new 命令初始化项目。

   mkdir sort-by-numbers-example
   cd sort-by-numbers-example
   dotnet new console

2. 将 .NET/C# 驱动程序作为依赖项添加到项目中。

   dotnet add package MongoDB.Driver

在 Program.cs 文件中创建查询。

1. 将Program.cs文件的内容替换为以下代码。

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

   • 导入mongodb包和依赖项。

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

   • 以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

     查询使用了下列管道阶段：

     • $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

     • $limit 阶段将输出限制为 5 个结果。

     • $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

   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 SortByNumbers
   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
           // define search options
   23
           var searchOptions = new SearchOptions<MovieDocument>() 
   24
               { 
   25
                   Sort = Builders<MovieDocument>.Sort.Descending(movies => movies.Awards.Wins),
   26
                   IndexName = "sort-tutorial"
   27
               };
   28
   29
           // define and run pipeline
   30
           var results = moviesCollection.Aggregate()
   31
               .Search(
   32
                   Builders<MovieDocument>.Search.Range(movie => movie.Awards.Wins, SearchRangeBuilder.Gte(10)), searchOptions)
   33
               .Project<MovieDocument>(Builders<MovieDocument>.Projection
   34
                   .Exclude(movie => movie.Id)
   35
                   .Include(movie => movie.Title)
   36
                   .Include(movie => movie.Awards.Wins))
   37
               .Limit(5)
   38
               .ToList();
   39
   40
           // print results
   41
           foreach (var movie in results)
   42
           {
   43
               Console.WriteLine(movie.ToJson());
   44
           }
   45
       }
   46
   }
   47
   48
   [BsonIgnoreExtraElements]
   49
   public class MovieDocument
   50
   {
   51
       [BsonIgnoreIfDefault]
   52
       public ObjectId Id { get; set; }
   53
       public string Title { get; set; }
   54
       public Award Awards { get; set; }
   55
   }
   56
   57
   public class Award
   58
   {
   59
       [BsonIgnoreIfDefault]
   60
       public int Wins { get; set; }
   61
   }

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

编译并运行 Program.cs 文件。

dotnet run Program.cs

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

创建一个名为 sort-by-numbers.go 的文件。

将以下代码复制并粘贴到 sort-by-numbers.go 文件。

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

• 导入mongodb包和依赖项。

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

• 以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

  查询使用了下列管道阶段：

  • $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

  • $limit 阶段将输出限制为 5 个结果。

  • $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
7
	"go.mongodb.org/mongo-driver/bson"
8
	"go.mongodb.org/mongo-driver/mongo"
9
	"go.mongodb.org/mongo-driver/mongo/options"
10
)
11
12
func main() {
13
	// connect to your Atlas cluster
14
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
15
	if err != nil {
16
		panic(err)
17
	}
18
	defer client.Disconnect(context.TODO())
19
20
	// set namespace
21
	collection := client.Database("sample_mflix").Collection("movies")
22
23
	// define pipeline stages
24
	searchStage := bson.D{{"$search", bson.D{
25
	  {"index", "sort-tutorial"},
26
	  {"range", bson.D{
27
		{"path", "awards.wins"},
28
		{"gte", 10},
29
	  }},
30
	  {"sort", bson.D{{"awards.wins", -1}}},
31
	}}}
32
	limitStage := bson.D{{"$limit", 5}}
33
	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"awards.wins", 1}, {"_id", 0}}}}
34
35
	// run pipeline
36
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage})
37
	if err != nil {
38
		panic(err)
39
	}
40
41
	// print results
42
	var results []bson.D
43
	if err = cursor.All(context.TODO(), &results); err != nil {
44
		panic(err)
45
	}
46
	for _, result := range results {
47
		fmt.Println(result)
48
	}
49
}

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

go run sort-by-numbers.go

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

确保 CLASSPATH 包含以下库。

针对索引字段运行 Atlas Search 查询并对结果进行排序。

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

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

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

   • 导入mongodb包和依赖项。

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

   • 以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

     查询使用了下列管道阶段：

     • $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

     • $limit 阶段将输出限制为 5 个结果。

     • $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

   1
   import java.util.Arrays;
   2
   3
   import static com.mongodb.client.model.Aggregates.limit;
   4
   import static com.mongodb.client.model.Aggregates.project;
   5
   import static com.mongodb.client.model.Projections.excludeId;
   6
   import static com.mongodb.client.model.Projections.fields;
   7
   import static com.mongodb.client.model.Projections.include;
   8
   import com.mongodb.client.MongoClient;
   9
   import com.mongodb.client.MongoClients;
   10
   import com.mongodb.client.MongoCollection;
   11
   import com.mongodb.client.MongoDatabase;
   12
   import org.bson.Document;
   13
   14
   public class SortByNumbers {
   15
     public static void main( String[] args ) {
   16
       // define query
   17
       Document agg =
   18
           new Document("$search", 
   19
           	    new Document("index", "sort-tutorial")
   20
           	            .append("range", 
   21
           	    new Document("path", "awards.wins")
   22
           	                .append("gte", 10L))
   23
           	            .append("sort", 
   24
           	    new Document("awards.wins", -1L)));
   25
       
   26
       // specify connection
   27
       String uri = "<connection-string>";
   28
       
   29
       // establish connection and set namespace
   30
       try (MongoClient mongoClient = MongoClients.create(uri)) {
   31
         MongoDatabase database = mongoClient.getDatabase("sample_mflix");
   32
         MongoCollection<Document> collection = database.getCollection("movies");
   33
   	  
   34
         // run query and print results
   35
         collection.aggregate(Arrays.asList(agg, 
   36
           limit(5), 
   37
           project(fields(excludeId(), include("title"), include("awards.wins")))))
   38
           .forEach(doc -> System.out.println(doc.toJson()));	
   39
       }
   40
     }
   41
   }

   注意

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

   package com.mongodb.drivers;

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

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

   javac SortByNumbers.java
   java SortByNumbers

   隐藏输出

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

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

针对索引字段运行 Atlas Search 查询并对结果进行排序。

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

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

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

   • 导入mongodb包和依赖项。

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

   • 以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

     查询使用了下列管道阶段：

     • $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

     • $limit 阶段将输出限制为 5 个结果。

     • $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

   1
   import com.mongodb.client.model.Aggregates.limit
   2
   import com.mongodb.client.model.Aggregates.project
   3
   import com.mongodb.client.model.Projections.*
   4
   import com.mongodb.kotlin.client.coroutine.MongoClient
   5
   import kotlinx.coroutines.runBlocking
   6
   import org.bson.Document
   7
   8
   fun main() {
   9
       // establish connection and set namespace
   10
       val uri = "<connection-string>"
   11
       val mongoClient = MongoClient.create(uri)
   12
       val database = mongoClient.getDatabase("sample_mflix")
   13
       val collection = database.getCollection<Document>("movies")
   14
   15
       runBlocking {
   16
           // define query
   17
           val agg = Document(
   18
               "\$search",
   19
               Document("index", "sort-tutorial")
   20
                   .append(
   21
                       "range",
   22
                       Document("path", "awards.wins")
   23
                           .append("gte", 10L)
   24
                   )
   25
                   .append(
   26
                       "sort",
   27
                       Document("awards.wins", -1L)
   28
                   )
   29
           )
   30
   31
           // run query and print results
   32
           val resultsFlow = collection.aggregate<Document>(
   33
               listOf(
   34
                   agg,
   35
                   limit(5),
   36
                   project(fields(
   37
                       excludeId(),
   38
                       include("title", "awards.wins")
   39
                   ))
   40
               )
   41
           )
   42
           resultsFlow.collect { println(it) }
   43
       }
   44
       mongoClient.close()
   45
   }

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

4. 运行 SortByNumbers.kt 文件。

   当你在 IDE 中运行 SortByNumbers.kt 程序时，它会打印以下文档：

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

创建一个名为 sort-by-numbers.js 的文件。

将以下代码复制并粘贴到 sort-by-numbers.js 文件。

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

• 导入 mongodb，即 MongoDB 的 Node.js 驱动程序。

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

• 以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

  查询使用了下列管道阶段：

  • $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

  • $limit 阶段将输出限制为 5 个结果。

  • $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

1
const { MongoClient } = require("mongodb");
2
3
// Replace the uri string with your MongoDB deployments connection string.
4
const uri =
5
  "<connection-string>";
6
7
const client = new MongoClient(uri);
8
9
async function run() {
10
  try {
11
    await client.connect();
12
13
    // set namespace
14
    const database = client.db("sample_mflix");
15
    const coll = database.collection("movies");
16
17
    // define pipeline
18
    const agg = [
19
      {
20
        '$search': {
21
          'index': 'sort-tutorial',
22
          'range': {
23
            'path': 'awards.wins', 
24
            'gte': 10
25
          }, 
26
          'sort': {
27
            'awards.wins': -1
28
          }
29
        }
30
      }, {
31
        '$limit': 5
32
      }, {
33
        '$project': {
34
          '_id': 0, 
35
          'title': 1, 
36
          'awards.wins': 1
37
        }
38
      }
39
    ];
40
41
    // run pipeline
42
    const result = await coll.aggregate(agg);
43
44
    // print results
45
    await result.forEach((doc) => console.log(doc));
46
47
  } finally {
48
    await client.close();
49
  }
50
}
51
run().catch(console.dir);

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

node sort-by-numbers.js

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

创建一个名为 sort-by-numbers.py 的文件。

将以下代码复制并粘贴到 sort-by-numbers.py 文件。

以下代码示例：

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

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

• 以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 10 个或更多奖项的电影，然后按数值字段值降序对结果进行排序。

  查询使用了下列管道阶段：

  • $search 阶段搜索 awards.wins 字段，并按降序对结果排序。

  • $limit 阶段将输出限制为 5 个结果。

  • $project 阶段排除 title 和 awards.wins 以外的所有字段。

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

1
import datetime
2
import pymongo
3
4
# connect to your Atlas cluster
5
client = pymongo.MongoClient('<connection-string>')
6
7
# define pipeline
8
pipeline = [
9
  {
10
    '$search': {
11
      'index': 'sort-tutorial',
12
      'range': {
13
        'path': 'awards.wins',
14
        'gte': 10
15
      },
16
      'sort': {
17
        'awards.wins': -1
18
      }
19
    }
20
  }, {
21
    '$limit': 5
22
  }, {
23
    '$project': {'_id': 0, 'title': 1, 'awards.wins': 1
24
    }
25
  }
26
]
27
28
# run pipeline
29
result = client['sample_mflix']['movies'].aggregate(pipeline)
30
31
# print results
32
for i in result:
33
    print(i)

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

python sort-by-numbers.py

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

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

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

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

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

   会显示集群页面。

转到集群的 Atlas Search 页面。

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

转到 Search Tester（搜索测试器）。

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

查看和编辑查询语法。

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

针对已索引的日期字段运行 Atlas Search 查询，并对结果进行排序。

以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

• 通配符操作符来搜索以 Summer 开头的电影标题。

• 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

  注意

  对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

将以下查询复制并粘贴到 Query Editor 中，然后点击 Query Editor 中的 Search 按钮。

[
  {
    $search: {
      "index": "sort-tutorial",
      "compound": {
        "filter": [{
          "wildcard": {
            "query": "Summer*",
            "path": "title"
          }
        }],
        "must": [{
          "near": {
            "pivot": 13149000000,
            "path": "released",
            "origin": ISODate("2014-04-18T00:00:00.000+00:00")
          }
        }]
      },
      "sort": {
        "released": -1,
        "title": 1
      }
    }
  }
]

SCORE: 0.348105788230896  _id:  "573a13f0f29313caabddaf7a"
  countries: Array
  runtime: 104
  cast: Array
  ...
  title: "Summer Nights"
  ...
  released: 2015-01-28T00:00:00.000+00:00
  ...
SCORE: 0.5917375683784485  _id:  "573a13e6f29313caabdc673b"
  plot: "25-year-old Iiris and Karoliina have been best friends since childhood…"
  genres: Array
  runtime: 90
  ...
  title: "Summertime"
  ...
  released: 2014-08-01T00:00:00.000+00:00
  ...
SCORE: 0.9934720396995544  _id:  "573a13eff29313caabdd760c"
  plot: "Erik Sparrow is one of the lucky ones. He's got a good job. He's in a …"
  genres: Array
  runtime: 86
  ...
  title: "Summer of Blood"
  ...
  released: 2014-04-17T00:00:00.000+00:00
  ...
SCORE: 0.15982933342456818  _id:  "573a13cff29313caabd8ab74"
  plot: "The story of an adult and a teenage couple during a brief summer holid…"
  genres: Array
  countries: Array
  ...
  title: "Summer Games"
  ...
  released: 2012-02-08T00:00:00.000+00:00
  ...
SCORE: 0.13038821518421173  _id:  "573a13cef29313caabd87f4e"
  plot: "Summer of Goliath is a documentary/fiction hybrid that narrates variou…"
  genres: Array
  runtime: 78
  ...
  title: "Summer of Goliath"
  ...
  released: 2011-07-08T00:00:00.000+00:00
  ...
SCORE: 0.08124520629644394  _id:  "573a13c7f29313caabd7608d"
  plot: "A student tries to fix a problem he accidentally caused in OZ, a digit…"
  genres: Array
  runtime: 114
  ...
  title: "Summer Wars"
  ...
  released: 2009-08-01T00:00:00.000+00:00
SCORE: 0.0711759403347969  _id:  "573a13bbf29313caabd54ee6"
  plot: "The life of a public school epitomized by disobedient student Jonah Ta…"
  genres: Array
  runtime: 30
  ...
  title: "Summer Heights High"
  ...
  released: 2008-11-09T00:00:00.000+00:00
  ...
SCORE: 0.06951779872179031  _id:  "573a13bff29313caabd5f935"
  plot: "On his spring break at the seaside, with his wife and his four year ol…"
  genres: Array
  runtime: 102
  ...
  title: "Summer Holiday"
  ...
  released: 2008-09-19T00:00:00.000+00:00
  ...
SCORE: 0.05834990739822388  _id:  "573a13c0f29313caabd628ac"
  plot: "Kochi Uehara is a fourth grade student living in the suburb of Tokyo. …"
  genres: Array
  runtime: 138
  ...
  title: "Summer Days with Coo"
  ...
  released: 2007-07-28T00:00:00.000+00:00
  ...
SCORE: 0.056174591183662415  _id:  "573a13b8f29313caabd4c1d0"
  fullplot: "Country girl Yu Hong leaves her village, her family and her lover to s…"
  genres: Array
  runtime: 158
  ...
  title: "Summer Palace"
  ...
  released: 2007-04-18T00:00:00.000+00:00
  ...

展开查询结果。

Search Tester 可能不会显示其所返回文档的所有字段。要查看所有字段，包括在查询路径中指定的字段，请展开结果中的文档。

通过 mongosh 连接到您的集群。

在终端窗口中打开mongosh并连接到集群。 有关连接的详细说明，请参阅通过mongosh连接。

使用 sample_mflix 数据库。

在 mongosh 提示符下运行以下命令：

use sample_mflix

针对已索引的日期字段运行 Atlas Search 查询，并对结果进行排序。

以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

• 通配符操作符来搜索以 Summer 开头的电影标题。

• 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

  注意

  对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

查询使用了下列管道阶段：

• $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

• $limit 阶段将输出限制为 5 个结果。

• $project 阶段到：

  • 排除除 title 和 released 之外的所有字段。

  • 添加名为 score 的字段。

1
db.movies.aggregate([
2
{
3
  $search: {
4
    "index": "sort-tutorial",
5
    "compound": {
6
      "filter": [{
7
        "wildcard": {
8
          "query": "Summer*",
9
          "path": "title"
10
        }
11
      }],
12
      "must": [{
13
        "near": {
14
          "pivot": 13149000000,
15
          "path": "released",
16
          "origin": ISODate("2014-04-18T00:00:00.000+00:00")
17
        }
18
      }]
19
    },
20
    "sort": {
21
      "released": -1
22
    }
23
  }
24
},
25
{
26
  $limit: 5
27
},
28
{
29
  $project: {
30
    "_id": 0, 
31
    "title": 1,
32
    "released": 1,
33
    "score": {
34
        "$meta": "searchScore"
35
    }
36
  }
37
}])

[
  {
    title: 'Summer Nights',
    released: ISODate("2015-01-28T00:00:00.000Z"),
    score: 0.348105788230896
  },
  {
    title: 'Summertime',
    released: ISODate("2014-08-01T00:00:00.000Z"),
    score: 0.5917375683784485
  },
  {
    title: 'Summer of Blood',
    released: ISODate("2014-04-17T00:00:00.000Z"),
    score: 0.9934720396995544
  },
  {
    title: 'Summer Games',
    released: ISODate("2012-02-08T00:00:00.000Z"),
    score: 0.15982933342456818
  },
  {
    title: 'Summer of Goliath',
    released: ISODate("2011-07-08T00:00:00.000Z"),
    score: 0.13038821518421173
  }
]

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

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

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

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

针对索引字段运行 Atlas Search 查询，并对结果快速排序。

以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

• 通配符操作符来搜索以 Summer 开头的电影标题。

• 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

  注意

  对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

查询使用了下列管道阶段：

• $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

• $limit 阶段将输出限制为 5 个结果。

• $project 阶段到：

  • 排除除 title 和 released 之外的所有字段。

  • 添加名为 score 的字段。

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

1. 单击 Aggregations 标签页。

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

   管道阶段	查询
   $search	{ "index": "sort-tutorial", "compound": { "filter": [{ "wildcard": { "query": "Summer*", "path": "title" } }], "must": [{ "near": { "pivot": 13149000000, "path": "released", "origin": ISODate("2014-04-18T00:00:00.000+00:00") } }] }, "sort": { "released": -1 } }
   $limit	5
   $project	{ _id: 0, title: 1, released: 1, score: { $meta: "searchScore" } }

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

   {
     title: 'Summer Nights',
     released: 2015-01-28T00:00:00.000+00:00,
     score: 0.348105788230896
   },
   {
     title: 'Summertime',
     released: 2014-08-01T00:00:00.000+00:00,
     score: 0.5917375683784485
   },
   {
     title: 'Summer of Blood',
     released: 2014-04-17T00:00:00.000+00:00,
     score: 0.9934720396995544
   },
   {
     title: 'Summer Games',
     released: 2012-02-08T00:00:00.000+00:00,
     score: 0.15982933342456818
   },
   {
     title: 'Summer of Goliath',
     released: 2011-07-08T00:00:00.000+00:00,
     score: 0.13038821518421173
   }

为查询设置并初始化 .NET/C# 项目。

1. 创建一个名为 sort-by-date-example 的新目录，并使用 dotnet new 命令初始化项目。

   mkdir sort-by-date-example
   cd sort-by-date-example
   dotnet new console

2. 将 .NET/C# 驱动程序作为依赖项添加到项目中。

   dotnet add package MongoDB.Driver

在 Program.cs 文件中创建查询。

1. 将Program.cs文件的内容替换为以下代码。

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

   • 导入mongodb包和依赖项。

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

   • 以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

     • 通配符操作符来搜索以 Summer 开头的电影标题。

     • 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

       注意

       对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

     查询使用了下列管道阶段：

     • $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

     • $limit 阶段将输出限制为 5 个结果。

     • $project 阶段到：

       • 排除除 title 和 released 之外的所有字段。

       • 添加名为 score 的字段。

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

   1
   using MongoDB.Bson;
   2
   using MongoDB.Bson.Serialization.Attributes;
   3
   using MongoDB.Bson.Serialization.Conventions;
   4
   using MongoDB.Driver;
   5
   using MongoDB.Driver.Search;
   6
   7
   public class SortByStrings
   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
   23
           // declare data for compound query
   24
           var originDate = new DateTime(2014, 04, 18, 0, 0, 0, DateTimeKind.Utc);
   25
   26
           // define search options
   27
           var searchOptions = new SearchOptions<MovieDocument>() 
   28
               { 
   29
                   Sort = Builders<MovieDocument>.Sort.Descending(movie => movie.Released),
   30
                   IndexName = "sort-tutorial"
   31
               };
   32
               
   33
           // define and run pipeline
   34
           var results = moviesCollection.Aggregate()
   35
               .Search(Builders<MovieDocument>.Search.Compound()
   36
                   .Filter(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Summer*"))
   37
                   .Must(Builders<MovieDocument>.Search.Near(movie => movie.Released, originDate, 13149000000)), searchOptions)
   38
               .Project<MovieDocument>(Builders<MovieDocument>.Projection
   39
                   .Include(movie => movie.Released)
   40
                   .Include(movie => movie.Title)
   41
                   .Exclude(movie => movie.Id)
   42
                   .MetaSearchScore(movie => movie.Score))
   43
               .Limit(5)
   44
               .ToList();
   45
   46
           // print results
   47
           foreach (var movie in results)
   48
           {
   49
               Console.WriteLine(movie.ToJson());
   50
           }
   51
       }
   52
   }
   53
   54
   [BsonIgnoreExtraElements]
   55
   public class MovieDocument
   56
   {
   57
       [BsonIgnoreIfDefault]
   58
       public ObjectId Id { get; set; }
   59
       public DateTime Released { get; set; }
   60
       public string Title { get; set; }
   61
       public double Score { get; set; }
   62
   }

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

编译并运行 Program.cs 文件。

dotnet run Program.cs

{ "released" : ISODate("2015-01-28T00:00:00Z"), "title" : "Summer Nights", "score" : 0.348105788230896 }
{ "released" : ISODate("2014-08-01T00:00:00Z"), "title" : "Summertime", "score" : 0.59173756837844849 }
{ "released" : ISODate("2014-04-17T00:00:00Z"), "title" : "Summer of Blood", "score" : 0.99347203969955444 }
{ "released" : ISODate("2014-01-17T00:00:00Z"), "title" : "Summer in February", "score" : 0.62580311298370361 }
{ "released" : ISODate("2012-02-08T00:00:00Z"), "title" : "Summer Games", "score" : 0.15982933342456818 }

创建一个名为 sort-by-date.go 的文件。

将以下代码复制并粘贴到 sort-by-date.go 文件。

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

• 导入mongodb包和依赖项。

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

• 以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

  • 通配符操作符来搜索以 Summer 开头的电影标题。

  • 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

    注意

    对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

  查询使用了下列管道阶段：

  • $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

  • $limit 阶段将输出限制为 5 个结果。

  • $project 阶段到：

    • 排除除 title 和 released 之外的所有字段。

    • 添加名为 score 的字段。

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

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

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

go run sort-by-date.go

[{title Summer Nights} {released 1422403200000} {score 0.348105788230896}]
[{title Summertime} {released 1406851200000} {score 0.5917375683784485}]
[{title Summer of Blood} {released 1397692800000} {score 0.9934720396995544}]
[{title Summer Games} {released 1328659200000} {score 0.15982933342456818}]
[{title Summer of Goliath} {released 1310083200000} {score 0.13038821518421173}]

确保 CLASSPATH 包含以下库。

针对索引字段运行 Atlas Search 查询并对结果进行排序。

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

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

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

   • 导入mongodb包和依赖项。

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

   • 以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

     • 通配符操作符来搜索以 Summer 开头的电影标题。

     • 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

       注意

       对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

     查询使用了下列管道阶段：

     • $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

     • $limit 阶段将输出限制为 5 个结果。

     • $project 阶段到：

       • 排除除 title 和 released 之外的所有字段。

       • 添加名为 score 的字段。

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

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

   注意

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

   package com.mongodb.drivers;

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

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

   javac SortByDate.java
   java SortByDate

   隐藏输出

   {"title": "Summer Nights", "released": {"$date": "2015-01-28T00:00:00Z"}, "score": 0.348105788230896}
   {"title": "Summertime", "released": {"$date": "2014-08-01T00:00:00Z"}, "score": 0.5917375683784485}
   {"title": "Summer of Blood", "released": {"$date": "2014-04-17T00:00:00Z"}, "score": 0.9934720396995544}
   {"title": "Summer Games", "released": {"$date": "2012-02-08T00:00:00Z"}, "score": 0.15982933342456818}
   {"title": "Summer of Goliath", "released": {"$date": "2011-07-08T00:00:00Z"}, "score": 0.13038821518421173}

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

针对索引字段运行 Atlas Search 查询并对结果进行排序。

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

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

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

   • 导入mongodb包和依赖项。

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

   • 以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

     • 通配符操作符来搜索以 Summer 开头的电影标题。

     • 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

       注意

       对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

     查询使用了下列管道阶段：

     • $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

     • $limit 阶段将输出限制为 5 个结果。

     • $project 阶段到：

       • 排除除 title 和 released 之外的所有字段。

       • 添加名为 score 的字段。

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

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

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

4. 运行 SortByDate.kt 文件。

   当你在 IDE 中运行 SortByDate.kt 程序时，它会打印以下文档：

   Document{{title=Summer Nights, released=Tue Jan 27 19:00:00 EST 2015, score=0.348105788230896}}
   Document{{title=Summertime, released=Thu Jul 31 20:00:00 EDT 2014, score=0.5917375683784485}}
   Document{{title=Summer of Blood, released=Wed Apr 16 20:00:00 EDT 2014, score=0.9934720396995544}}
   Document{{title=Summer Games, released=Tue Feb 07 19:00:00 EST 2012, score=0.15982933342456818}}
   Document{{title=Summer of Goliath, released=Thu Jul 07 20:00:00 EDT 2011, score=0.13038821518421173}}

创建一个名为 sort-by-date.js 的文件。

将以下代码复制并粘贴到 sort-by-date.js 文件。

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

• 导入 mongodb，即 MongoDB 的 Node.js 驱动程序。

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

• 以下查询显示了如何运行复合查询，并按日期字段对结果进行排序。它使用以下操作符：

  • 通配符操作符来搜索以 Summer 开头的电影标题。

  • 接近操作符，用于搜索 2014 年 4 月 18 日之前或之后五个月内发行的电影。

    注意

    对日期字段使用 pivot 时，其计量单位为毫秒。Atlas Search 会根据该日期字段与指定日期的接近程度为每个文档计算一个分数。要了解详情，请参阅 near。

  查询使用了下列管道阶段：

  • $search 阶段搜索 title 和 released 字段，然后按 released 字段降序对结果进行排序。

  • $limit 阶段将输出限制为 5 个结果。

  • $project 阶段到：

    • 排除除 title 和 released 之外的所有字段。

    • 添加名为 score 的字段。

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

1
const { MongoClient } = require("mongodb");
2
3
// Replace the uri string with your MongoDB deployments connection string.
4
const uri =
5
  "<connection-string>";
6
7
const client = new MongoClient(uri);
8
9
async function run() {
10
  try {
11
    await client.connect();
12
13
    // set namespace
14
    const database = client.db("sample_mflix");
15
    const coll = database.collection("movies");
16
17
    // define pipeline
18
    const agg = [
19
      {$search: {
20
        index: "sort-tutorial",
21
        compound: {
22
          filter: {wildcard: {query: "Summer*", path: "title"}},
23
          must: [{near: {path: "released", origin: new Date("2014-04-18T00:00:00.000Z"), pivot: 13149000000}}]
24
        },
25
        sort: { released: -1 }
26
      }},
27
    {$limit: 5},
28
    {$project: {_id: 0, title: 1, released: 1, score: {$meta: "searchScore"}}}
29
  ];
30
           
31
    // run pipeline
32
    const result = await coll.aggregate(agg);
33
34
    // print results
35
    await result.forEach((doc) => console.log(doc));
36
    
37
  } finally {
38
    await client.close();
39
  }
40
}
41
run().catch(console.dir);