如何对 Atlas Search 结果进行排序

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

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

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

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

转到集群的 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 连接。

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

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

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

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

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

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

转到集群的 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 连接。

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

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