Docs 菜单
Docs 主页
/
MongoDB Atlas
/ /

如何对 Atlas Search 结果进行排序

在此页面上

  • 加载样本数据
  • 创建 Atlas Search 索引
  • Overview
  • 步骤
  • 搜索结果排序
  • 字符串排序

本教程介绍了如何按数字、日期和字符串字段对 sample_mflix.movies 集合中的 Atlas Search 结果进行升序或降序 排序。它还演示了如何对 Atlas Search 结果进行不区分大小写的排序。在集合上创建 Atlas Search 索引时,可以对索引进行配置,以将字符串字段的值规范化为小写。这样,无论排序字段的大小写如何,您都可以对查询结果进行排序。

为了演示如何使用 Atlas Search sort 选项的默认行为按数字、日期和字符串字段对 Atlas 搜索结果进行排序,本教程将引导您完成以下步骤:

  1. sample_mflix.movies 集合中名为 title 的字符串字段、名为 released 的日期字段和名为 awards.wins 的数字字段上,创建 Atlas Search 索引,以便对这些字段运行查询并按这些字段对结果进行排序。

    注意

    如果启用动态映射,则 Atlas Search 会自动索引数字日期类型,以进行排序。它不会动态索引用于排序的字符串字段。相反,必须使用令牌类型为字符串字段编制索引以进行排序。

  2. 针对 sample_mflix.movies 集合中的 titlereleasedawards.wins 字段运行 Atlas Search 查询,并按这些字段对结果进行升序与降序排序。

为了演示如何通过使用 Atlas Search sort 选项将字符串字段的值规范化为小写来对 Atlas Search 结果进行排序,本教程将引导您完成以下步骤:

  1. 将示例文档加载到 Atlas 集群中的 sample_mflix.movies 集合。

  2. 在名为 title 的字符串字段上创建 Atlas Search 索引,以便运行查询并按此字段对结果进行排序。

    注意

    如果启用动态映射,则 Atlas Search 会自动索引数字日期类型,以进行排序。它不会动态索引用于排序的字符串字段。相反,必须使用令牌类型为字符串字段编制索引以进行排序。

  3. 对集合中的 title 字段运行 Atlas Search 查询,并按索引字段对结果进行排序。

开始之前,请确保 Atlas 集群满足先决条件中所述的要求。

要创建 Atlas Search 索引,您必须拥有 Project Data Access Admin 或更高的项目访问权限。

要使用默认的 sort 行为按数字、日期和字符串字段对 sample_mflix.movies 集合的文档进行排序,您可以跳过此部分,继续为集合创建索引。

为了演示 Atlas Search 如何对文档进行排序(不考虑字母大小写),我们提供了示例文档。每个示例文档代表一部电影,包含三个字段,分别指定电影的标题(小写)、类型和奖项数量。在本节中,您将示例文档加载到 Atlas 集群中的 sample_mflix.movies 集合。您可以使用 Atlas 用户界面或 mongosh 来加载示例集合。

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

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

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

单击集群的对应 Browse Collections 按钮。

显示数据浏览器

3

您可以从 Atlas 用户界面或mongosh加载集合:

  1. 展开sample_mflix数据库并选择movies集合。

  2. 对于要添加到集合中的每个样本文档,请执行以下操作:

    1. 单击 Insert Document 并选择JSON 视图 ({}) 来替换默认文档。

    2. 一次一个,复制并粘贴以下示例文档,然后单击Insert将每个文档添加到集合中。

    1{
    2 "genres": [ "Action", "Drama", "Thriller" ],
    3 "title": "atomic train",
    4 "awards": { "wins": 1, "nominations": 1 }
    5}
    1{
    2 "genres": [ "Animation", "Adventure", "Family" ],
    3 "title": "how to train your dragon",
    4 "awards": { "wins": 32, "nominations": 51 }
    5}
  1. 单击要连接的集群所对应的 Connect

  2. 选择 Shell 并完成通过 mongosh 连接到集群的步骤。

    要了解更多信息,请参阅通过 mongosh 进行连接

  3. mongosh 中切换到 sample_mflix 数据库。

    use sample_mflix
    switched to db sample_mflix
  4. mongosh中运行以下命令,将数据集加载到所选数据库:

    1db.movies.insertMany([
    2 {
    3 "_id": 1,
    4 "genres": [ "Action", "Drama", "Thriller" ],
    5 "title": "atomic train",
    6 "awards": { wins: 1, nominations: 1 }
    7 },
    8 {
    9 "_id": 2,
    10 "genres": [ "Animation", "Adventure", "Family" ],
    11 "title": "how to train your dragon",
    12 "awards": { "wins": 32, "nominations": 51 },
    13 }
    14])
    { acknowledged: true, insertedIds: { '0': 1, '1': 2 } }

在本节中,您将在 sample_mflix.movies 集合中的 titlereleasedawards.wins 字段上创建 Atlas Search 索引,以对这些字段运行查询并按这些字段对结果进行排序。

在本部分中,您将在 sample_mflix.movies 集合中的 title 字段上创建 Atlas Search 索引,以便对该字段运行查询并按该字段对结果进行排序。

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

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

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

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

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

    注意

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

3
4

在页面上进行以下选择,然后单击 Next

Search Type

选择 Atlas Search索引类型。

Index Name and Data Source

指定以下信息:

  • Index Name: sort-tutorial

  • Database and Collection:

    • sample_mflix database

    • movies 集合

Configuration Method

For a guided experience, select Visual Editor.

To edit the raw index definition, select JSON Editor.
5

以下索引定义:

  • awards.wins 字段按数字类型进行索引编制,以便按该字段对结果进行查询和排序。

  • released 字段按日期类型进行索引编制,以便按该字段对结果进行查询和排序。

  • 指定对 title 字段编制索引和进行搜索的关键字分析器,并按照以下类型对 title 字段编制索引:

    • 字符串类型,以便查询该字段。

    • 令牌类型,用于按字段对结果进行排序。

    您可以使用 Atlas 用户界面中的 Atlas Search Visual Editor 或 Atlas Search JSON Editor 来创建索引。

  1. 单击 Refine Your Index(连接)。

  2. Index Configurations 部分中,切换以禁用 Dynamic Mapping

  3. Field Mappings 部分中,单击 Add Field 显示 Add Field Mapping 窗口。

  4. 单击 Customized Configuration(连接)。

  5. 从相应的下拉菜单中逐个选择以下字段的字段名称和数据类型,配置属性(如有)或接受默认值,然后单击 Add

    字段名称
    数据类型
    属性

    awards.wins

    数值

    接受默认值。

    released

    Date

    接受默认值。

    title

    Token

    接受默认值。

    title

    字符串

    Index AnalyzerSearch Analyzer 下拉菜单中选择 lucene.keyword

  1. 将默认索引定义替换为以下定义。

    {
    "mappings": {
    "dynamic": false,
    "fields": {
    "awards": {
    "dynamic": false,
    "fields": {
    "wins": [
    {
    "type": "number"
    }
    ]
    },
    "type": "document"
    },
    "released": [
    {
    "type": "date"
    }
    ],
    "title": [{
    "type": "token"
    }, {
    "type": "string",
    "analyzer": "lucene.keyword",
    "searchAnalyzer": "lucene.keyword"
    }]
    }
    }
    }
  2. 单击 Next(连接)。

6
7

此时将显示一个模态窗口,让您知道索引正在构建中。点击 Close 按钮。

8

构建索引大约需要一分钟时间。在构建时,Status 列显示 Build in Progress。构建完成后,Status 列显示 Active

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

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

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2
3

在页面上进行以下选择,然后单击 Next

Search Type

选择 Atlas Search索引类型。

Index Name and Data Source

指定以下信息:

  • Index Name: case-insensitive-sort

  • Database and Collection:

    • sample_mflix database

    • movies 集合

Configuration Method

For a guided experience, select Visual Editor.

To edit the raw index definition, select JSON Editor.
4

以下索引定义将 title 字段编制为以下类型的索引:

  • 用于排序的词元类型,它使用 lowercase 规范化器将索引术语转换为小写。

  • 字符串类型,以便查询该字段。

您可以使用 Atlas 用户界面中的 Atlas Search Visual Editor 或 Atlas Search JSON Editor 来创建索引。

  1. 单击 Refine Your Index(连接)。

  2. Index Configurations 部分中,切换以禁用 Dynamic Mapping

  3. Field Mappings 部分中,单击 Add Field 显示 Add Field Mapping 窗口。

  4. 单击 Customized Configuration(连接)。

  5. Field Name 下拉列表中选择 title

  6. Data Type 下拉列表中选择 Token

  7. 展开Token Properties并从Normalizer下拉列表中选择lowercase

  8. 单击 Add(连接)。

  9. 重复步骤 de

  10. Data Type 下拉列表中选择 String

  11. 单击 Add(连接)。

  1. 将默认索引定义替换为以下定义。

    1{
    2 "mappings": {
    3 "dynamic": false,
    4 "fields": {
    5 "title": [{
    6 "type": "token",
    7 "normalizer": "lowercase"
    8 },{
    9 "type": "string"
    10 }]
    11 }
    12 }
    13}
  2. 单击 Next(连接)。

5

此时将显示一个模态窗口,让您知道索引正在构建中。

6

构建索引大约需要一分钟时间。在构建时,Status 列显示 Initial Sync。构建完成后,Status 列显示 Active


➤ 使用选择语言下拉菜单设置本节中示例的语言。


您可以通过多种方式对搜索结果进行排序。在本部分中,您将连接到 Atlas 集群,然后针对 sample_mflix.movies 集合中的索引字段运行样本查询。

样本查询中的 $search 阶段使用 sort 选项并按已索引的数字字段对 Atlas 搜索结果进行排序。

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

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

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

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

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

    注意

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

3

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

4

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

5

以下查询演示如何按数值字段对结果进行排序。它使用范围操作符搜索赢得 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
...
...
6

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

1

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

2

mongosh 提示符下运行以下命令:

use sample_mflix
3

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

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

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

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

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

1db.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 }
}
]
1

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

2

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

3

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

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

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

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

  • $project 阶段排除 titleawards.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 }
    }
    ]
1
  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
2
  1. Program.cs文件的内容替换为以下代码。

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

    • 导入mongodb包和依赖项。

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

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

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

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

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

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

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

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public 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]
    49public 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
    57public class Award
    58{
    59 [BsonIgnoreIfDefault]
    60 public int Wins { get; set; }
    61}
  2. 在运行示例之前,请将 <connection-string> 替换为 Atlas 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情,请参阅通过驱动程序连接。

3
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 } }
1
2

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

  • 导入mongodb包和依赖项。

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

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

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

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

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

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

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

1package main
2
3import (
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
12func 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}

注意

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

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

junit

4.11 或更高版本

mongodb-driver-sync

4.3.0 或更高版本

slf4j-log4j12

1.7.30 或更高版本

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

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

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

    • 导入mongodb包和依赖项。

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

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

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

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

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

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

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

    1import java.util.Arrays;
    2
    3import static com.mongodb.client.model.Aggregates.limit;
    4import static com.mongodb.client.model.Aggregates.project;
    5import static com.mongodb.client.model.Projections.excludeId;
    6import static com.mongodb.client.model.Projections.fields;
    7import static com.mongodb.client.model.Projections.include;
    8import com.mongodb.client.MongoClient;
    9import com.mongodb.client.MongoClients;
    10import com.mongodb.client.MongoCollection;
    11import com.mongodb.client.MongoDatabase;
    12import org.bson.Document;
    13
    14public 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}}
1

mongodb-driver-kotlin-coroutine

4.10.0 或更高版本

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

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

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

    • 导入mongodb包和依赖项。

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

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

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

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

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

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

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

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun 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}}}}
1
2

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

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

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

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

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

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

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

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

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

1const { MongoClient } = require("mongodb");
2
3// Replace the uri string with your MongoDB deployments connection string.
4const uri =
5 "<connection-string>";
6
7const client = new MongoClient(uri);
8
9async 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}
51run().catch(console.dir);

注意

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

3
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 } }
1
2

以下代码示例:

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

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

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

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

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

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

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

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

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

注意

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

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

样本查询中的 $search 阶段使用 sort 选项并按已索引的日期字段对 Atlas 搜索结果进行排序。

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

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

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

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

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

    注意

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

3

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

4

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

5

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

  • 通配符操作符来搜索以 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
...
6

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

1

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

2

mongosh 提示符下运行以下命令:

use sample_mflix
3

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

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

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

    注意

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

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

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

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

  • $project 阶段到:

    • 排除除 titlereleased 之外的所有字段。

    • 添加名为 score 的字段。

1db.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
}
]
1

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

2

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

3

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

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

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

    注意

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

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

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

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

  • $project 阶段到:

    • 排除除 titlereleased 之外的所有字段。

    • 添加名为 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
    }
1
  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
2
  1. Program.cs文件的内容替换为以下代码。

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

    • 导入mongodb包和依赖项。

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

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

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

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

        注意

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

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

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

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

      • $project 阶段到:

        • 排除除 titlereleased 之外的所有字段。

        • 添加名为 score 的字段。

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

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public 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]
    55public 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 连接字符串。确保您的连接字符串包含数据库用户的档案。要了解详情,请参阅通过驱动程序连接。

3
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 }
1
2

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

  • 导入mongodb包和依赖项。

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

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

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

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

      注意

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

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

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

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

    • $project 阶段到:

      • 排除除 titlereleased 之外的所有字段。

      • 添加名为 score 的字段。

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

1package main
2
3import (
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
13func 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}

注意

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

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

junit

4.11 或更高版本

mongodb-driver-sync

4.3.0 或更高版本

slf4j-log4j12

1.7.30 或更高版本

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

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

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

    • 导入mongodb包和依赖项。

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

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

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

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

        注意

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

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

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

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

      • $project 阶段到:

        • 排除除 titlereleased 之外的所有字段。

        • 添加名为 score 的字段。

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

    1import java.util.Arrays;
    2import java.util.List;
    3
    4import static com.mongodb.client.model.Aggregates.limit;
    5import static com.mongodb.client.model.Aggregates.project;
    6import static com.mongodb.client.model.Projections.*;
    7import com.mongodb.client.MongoClient;
    8import com.mongodb.client.MongoClients;
    9import com.mongodb.client.MongoCollection;
    10import com.mongodb.client.MongoDatabase;
    11import org.bson.Document;
    12
    13import java.time.Instant;
    14import java.util.Date;
    15
    16public 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}
1

mongodb-driver-kotlin-coroutine

4.10.0 或更高版本

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

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

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

    • 导入mongodb包和依赖项。

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

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

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

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

        注意

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

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

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

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

      • $project 阶段到:

        • 排除除 titlereleased 之外的所有字段。

        • 添加名为 score 的字段。

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

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7import java.time.Instant
    8import java.util.*
    9
    10fun 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}}
1
2

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

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

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

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

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

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

      注意

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

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

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

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

    • $project 阶段到:

      • 排除除 titlereleased 之外的所有字段。

      • 添加名为 score 的字段。

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

1const { MongoClient } = require("mongodb");
2
3// Replace the uri string with your MongoDB deployments connection string.
4const uri =
5 "<connection-string>";
6
7const client = new MongoClient(uri);
8
9async 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}
41run().catch(console.dir);

注意

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

3
node sort-by-date.js
{
title: 'Summer Nights',
released: 2015-01-28T00:00:00.000Z,
score: 0.348105788230896
}
{
title: 'Summertime',
released: 2014-08-01T00:00:00.000Z,
score: 0.5917375683784485
}
{
title: 'Summer of Blood',
released: 2014-04-17T00:00:00.000Z,
score: 0.9934720396995544
}
{
title: 'Summer Games',
released: 2012-02-08T00:00:00.000Z,
score: 0.15982933342456818
}
{
title: 'Summer of Goliath',
released: 2011-07-08T00:00:00.000Z,
score: 0.13038821518421173
}
1
2

以下代码示例:

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

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

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

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

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

      注意

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

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

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

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

    • $project 阶段到:

      • 排除除 titlereleased 之外的所有字段。

      • 添加名为 score 的字段。

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

1import datetime
2import pymongo
3
4# connect to your Atlas cluster
5client = pymongo.MongoClient('<connection-string>')
6
7# define pipeline
8pipeline = [
9 {'$search': {
10 'index': 'sort-tutorial',
11 'compound': {
12 'filter': {'wildcard': {'query': 'Summer*', 'path': 'title'}},
13 'must': {'near': {
14 "path": "released",
15 "origin": datetime.datetime(2014, 4, 18, 0, 0, 0, 0),
16 "pivot": 13149000000
17 }}},
18 'sort': { 'released': -1 }}},
19 {'$limit': 5},
20 {'$project': {'_id': 0, 'title': 1, 'released': 1, 'score': {'$meta': 'searchScore'}}}
21]
22
23# run pipeline
24result = client['sample_mflix']['movies'].aggregate(pipeline)
25
26# print results
27for i in result:
28 print(i)

注意

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

3
python sort-date-for-speed.py
{'title': 'Summer Nights', 'released': datetime.datetime(2015, 1, 28, 0, 0), 'score': 0.348105788230896}
{'title': 'Summertime', 'released': datetime.datetime(2014, 8, 1, 0, 0), 'score': 0.5917375683784485}
{'title': 'Summer of Blood', 'released': datetime.datetime(2014, 4, 17, 0, 0), 'score': 0.9934720396995544}
{'title': 'Summer Games', 'released': datetime.datetime(2012, 2, 8, 0, 0), 'score': 0.15982933342456818}
{'title': 'Summer of Goliath', 'released': datetime.datetime(2011, 7, 8, 0, 0), 'score': 0.13038821518421173}

示例查询中的 $search 阶段使用 sort 选项按索引字符串字段对 Atlas Search 结果进行排序。

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

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

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

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

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

    注意

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

3

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

4

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

5

以下查询演示如何按字符串字段查询结果并对其进行排序。它搜索以 PrancePrince 开头的标题,并按 title 字段升序对结果进行排序。

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

[
{
$search: {
"index": "sort-tutorial",
"compound": {
"should": [{
"wildcard": {
"query": ["Prance*"],
"path": "title",
"allowAnalyzedField": true
}
},
{
"wildcard": {
"query": ["Prince*"],
"path": "title",
"allowAnalyzedField": true
}
}]
},
"sort": {
"title": 1
}
}
}
]