How to Sort Your Atlas Search Results

In Atlas, go to the Clusters page for your project.

1. If it is not already displayed, select the organization that contains your desired project from the Organizations menu in the navigation bar.

2. If it is not already displayed, select your desired project from the Projects menu in the navigation bar.

3. If the Clusters page is not already displayed, click Database in the sidebar.

Go to the Atlas Search page for your cluster.

You can go the Atlas Search page from the sidebar, the Data Explorer, or your cluster details page.

Go to the Search Tester.

Click the Query button to the right of the index to query.

View and edit the query syntax.

Click Edit Query to view a default query syntax sample in JSON format.

Run an Atlas Search query against the indexed field and sort the results.

The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

Copy and paste the following query into the Query Editor, and then click the Search button in the Query Editor.

[
  {
    "$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
    ...
  ...

Expand your query results.

The Search Tester might not display all the fields in the documents it returns. To view all the fields, including the field that you specify in the query path, expand the document in the results.

Connect to your cluster in mongosh.

Open mongosh in a terminal window and connect to your cluster. For detailed instructions on connecting, see Connect via mongosh.

Use the sample_mflix database.

Run the following command at mongosh prompt:

use sample_mflix

Run an Atlas Search query against the indexed field and sort the results.

The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

The query uses the following pipeline stages:

• $search stage to search the awards.wins field and sort the results in descending order.

• $limit stage to limit the output to 5 results.

• $project stage to exclude all fields except title and 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 }
  }
]

Connect to your cluster in MongoDB Compass.

Open MongoDB Compass and connect to your cluster. For detailed instructions on connecting, see Connect via Compass.

Use the movies collection in the sample_mflix database.

On the Database screen, click the sample_mflix database, then click the movies collection.

Run an Atlas Search query against the indexed field and sort the results.

The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

The query uses the following pipeline stages:

• $search stage to search the awards.wins field and sort the results in descending order.

• $limit stage to limit the output to 5 results.

• $project stage to exclude all fields except title and awards.wins.

To run this query in MongoDB Compass:

1. Click the Aggregations tab.

2. Click Select..., then configure each of the following pipeline stages by selecting the stage from the dropdown and adding the query for that stage. Click Add Stage to add additional stages.

   Pipeline Stage	Query
   $search	{ index: "sort-tutorial", "range": { "path": "awards.wins", "gte": 10 }, "sort": { "awards.wins": -1, } }
   $limit	5
   $project	{ title: 1, released: 1, year: 1 }

   If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $limit pipeline stage:

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

Set up and initialize the .NET/C# project for the query.

1. Create a new directory called sort-by-numbers-example and initialize your project with the dotnet new command.

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

2. Add the .NET/C# Driver to your project as a dependency.

   dotnet add package MongoDB.Driver

Create the query in the Program.cs file.

1. Replace the contents of the Program.cs file with the following code.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

     The query uses the following pipeline stages:

     • $search stage to search the awards.wins field and sort the results in descending order.

     • $limit stage to limit the output to 5 results.

     • $project stage to exclude all fields except title and awards.wins.

   • Iterates over the cursor to print the documents that match the query.

   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. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

Compile and run the Program.cs file.

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

Create a file named sort-by-numbers.go.

Copy and paste the following code into the sort-by-numbers.go file.

The code example performs the following tasks:

• Imports mongodb packages and dependencies.

• Establishes a connection to your Atlas cluster.

• The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

  The query uses the following pipeline stages:

  • $search stage to search the awards.wins field and sort the results in descending order.

  • $limit stage to limit the output to 5 results.

  • $project stage to exclude all fields except title and awards.wins.

• Iterates over the cursor to print the documents that match the query.

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
}

Run the following command to query your collection:

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

Ensure that your CLASSPATH contains the following libraries.

Run an Atlas Search query against the indexed field and sort the results.

1. Create a file named SortByNumbers.java.

2. Copy and paste the following code into the SortByNumbers.java file.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

     The query uses the following pipeline stages:

     • $search stage to search the awards.wins field and sort the results in descending order.

     • $limit stage to limit the output to 5 results.

     • $project stage to exclude all fields except title and awards.wins.

   • Iterates over the cursor to print the documents that match the query.

   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
   }

   Note

   To run the sample code in your Maven environment, add the following code above the import statements in your file.

   package com.mongodb.drivers;

3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4. Compile and run the SortByNumbers.java file.

   javac SortByNumbers.java
   java SortByNumbers

   HIDE OUTPUT

   {"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}}

Ensure that you add the following dependency to your project.

Run an Atlas Search query against the indexed field and sort the results.

1. Create a file named SortByNumbers.kt.

2. Copy and paste the following code into the SortByNumbers.kt file.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

     The query uses the following pipeline stages:

     • $search stage to search the awards.wins field and sort the results in descending order.

     • $limit stage to limit the output to 5 results.

     • $project stage to exclude all fields except title and awards.wins.

   • Prints the documents that match the query from the AggregateFlow instance.

   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. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4. Run the SortByNumbers.kt file.

   When you run the SortByNumbers.kt program in your IDE, it prints the following documents:

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

Create a file named sort-by-numbers.js.

Copy and paste the following code into the sort-by-numbers.js file.

The code example performs the following tasks:

• Imports mongodb, MongoDB's Node.js driver.

• Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

• The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

  The query uses the following pipeline stages:

  • $search stage to search the awards.wins field and sort the results in descending order.

  • $limit stage to limit the output to 5 results.

  • $project stage to exclude all fields except title and awards.wins.

• Iterates over the cursor to print the documents that match the query.

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

Run the following command to query your collection:

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

Create a file named sort-by-numbers.py.

Copy and paste the following code into the sort-by-numbers.py file.

The following code example:

• Imports pymongo, MongoDB's Python driver, and the dns module, which is required to connect pymongo to Atlas using a DNS seed list connection string.

• Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

• The following query shows how to sort the results by a numeric field. It uses the range operator to search for movies that have won 10 or more awards and then sorts the results by the numeric field value in descending order.

  The query uses the following pipeline stages:

  • $search stage to search the awards.wins field and sort the results in descending order.

  • $limit stage to limit the output to 5 results.

  • $project stage to exclude all fields except title and awards.wins.

• Iterates over the cursor to print the documents that match the query.

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)

Run the following command to query your collection:

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

In Atlas, go to the Clusters page for your project.

1. If it is not already displayed, select the organization that contains your desired project from the Organizations menu in the navigation bar.

2. If it is not already displayed, select your desired project from the Projects menu in the navigation bar.

3. If the Clusters page is not already displayed, click Database in the sidebar.

Go to the Atlas Search page for your cluster.

You can go the Atlas Search page from the sidebar, the Data Explorer, or your cluster details page.

Go to the Search Tester.

Click the Query button to the right of the index to query.

View and edit the query syntax.

Click Edit Query to view a default query syntax sample in JSON format.

Run an Atlas Search query against the indexed date field and sort the results.

The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

• wildcard operator to search for movie titles that begin with Summer.

• near operator to search for movies that were released in and about five months before or after April 18, 2014.

  Note

  When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

Copy and paste the following query into the Query Editor, and then click the Search button in the Query Editor.

[
  {
    $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
  ...

Expand your query results.

The Search Tester might not display all the fields in the documents it returns. To view all the fields, including the field that you specify in the query path, expand the document in the results.

Connect to your cluster in mongosh.

Open mongosh in a terminal window and connect to your cluster. For detailed instructions on connecting, see Connect via mongosh.

Use the sample_mflix database.

Run the following command at mongosh prompt:

use sample_mflix

Run an Atlas Search query against the indexed date field and sort the results.

The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

• wildcard operator to search for movie titles that begin with Summer.

• near operator to search for movies that were released in and about five months before or after April 18, 2014.

  Note

  When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

The query uses the following pipeline stages:

• $search stage to search the title and released fields and then sort the results by the released field in descending order.

• $limit stage to limit the output to 5 results.

• $project stage to:

  • Exclude all fields except title and released.

  • Add a field named 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
  }
]

Connect to your cluster in MongoDB Compass.

Open MongoDB Compass and connect to your cluster. For detailed instructions on connecting, see Connect via Compass.

Use the movies collection in the sample_mflix database.

On the Database screen, click the sample_mflix database, then click the movies collection.

Run an Atlas Search query against the indexed field and sort the results very fast.

The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

• wildcard operator to search for movie titles that begin with Summer.

• near operator to search for movies that were released in and about five months before or after April 18, 2014.

  Note

  When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

The query uses the following pipeline stages:

• $search stage to search the title and released fields and then sort the results by the released field in descending order.

• $limit stage to limit the output to 5 results.

• $project stage to:

  • Exclude all fields except title and released.

  • Add a field named score.

To run this query in MongoDB Compass:

1. Click the Aggregations tab.

2. Click Select..., then configure each of the following pipeline stages by selecting the stage from the dropdown and adding the query for that stage. Click Add Stage to add additional stages.

   Pipeline Stage	Query
   $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" } }

   If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $limit pipeline stage:

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

Set up and initialize the .NET/C# project for the query.

1. Create a new directory called sort-by-date-example and initialize your project with the dotnet new command.

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

2. Add the .NET/C# Driver to your project as a dependency.

   dotnet add package MongoDB.Driver

Create the query in the Program.cs file.

1. Replace the contents of the Program.cs file with the following code.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

     • wildcard operator to search for movie titles that begin with Summer.

     • near operator to search for movies that were released in and about five months before or after April 18, 2014.

       Note

       When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

     The query uses the following pipeline stages:

     • $search stage to search the title and released fields and then sort the results by the released field in descending order.

     • $limit stage to limit the output to 5 results.

     • $project stage to:

       • Exclude all fields except title and released.

       • Add a field named score.

   • Iterates over the cursor to print the documents that match the query.

   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. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

Compile and run the Program.cs file.

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 }

Create a file named sort-by-date.go.

Copy and paste the following code into the sort-by-date.go file.

The code example performs the following tasks:

• Imports mongodb packages and dependencies.

• Establishes a connection to your Atlas cluster.

• The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

  • wildcard operator to search for movie titles that begin with Summer.

  • near operator to search for movies that were released in and about five months before or after April 18, 2014.

    Note

    When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

  The query uses the following pipeline stages:

  • $search stage to search the title and released fields and then sort the results by the released field in descending order.

  • $limit stage to limit the output to 5 results.

  • $project stage to:

    • Exclude all fields except title and released.

    • Add a field named score.

• Iterates over the cursor to print the documents that match the query.

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
}

Run the following command to query your collection:

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

Ensure that your CLASSPATH contains the following libraries.

Run an Atlas Search query against the indexed field and sort the results.

1. Create a file named SortByDate.java.

2. Copy and paste the following code into the SortByDate.java file.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

     • wildcard operator to search for movie titles that begin with Summer.

     • near operator to search for movies that were released in and about five months before or after April 18, 2014.

       Note

       When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

     The query uses the following pipeline stages:

     • $search stage to search the title and released fields and then sort the results by the released field in descending order.

     • $limit stage to limit the output to 5 results.

     • $project stage to:

       • Exclude all fields except title and released.

       • Add a field named score.

   • Iterates over the cursor to print the documents that match the query.

   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
   }

   Note

   To run the sample code in your Maven environment, add the following code above the import statements in your file.

   package com.mongodb.drivers;

3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4. Compile and run the SortDateForSpeed.java file.

   javac SortByDate.java
   java SortByDate

   HIDE OUTPUT

   {"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}

Ensure that you add the following dependency to your project.

Run an Atlas Search query against the indexed field and sort the results.

1. Create a file named SortByDate.kt.

2. Copy and paste the following code into the SortByDate.kt file.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

     • wildcard operator to search for movie titles that begin with Summer.

     • near operator to search for movies that were released in and about five months before or after April 18, 2014.

       Note

       When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

     The query uses the following pipeline stages:

     • $search stage to search the title and released fields and then sort the results by the released field in descending order.

     • $limit stage to limit the output to 5 results.

     • $project stage to:

       • Exclude all fields except title and released.

       • Add a field named score.

   • Prints the documents that match the query from the AggregateFlow instance.

   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. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4. Run the SortByDate.kt file.

   When you run the SortByDate.kt program in your IDE, it prints the following documents:

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

Create a file named sort-by-date.js.

Copy and paste the following code into the sort-by-date.js file.

The code example performs the following tasks:

• Imports mongodb, MongoDB's Node.js driver.

• Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

• The following query shows how to run a compound query and sort the results by a date field. It uses the following operators:

  • wildcard operator to search for movie titles that begin with Summer.

  • near operator to search for movies that were released in and about five months before or after April 18, 2014.

    Note

    When you use pivot on a date field, its unit of measure is in milliseconds. Atlas Search calculates a score for each document based on how close the date field is to the specified date. To learn more, see near.

  The query uses the following pipeline stages:

  • $search stage to search the title and released fields and then sort the results by the released field in descending order.

  • $limit stage to limit the output to 5 results.

  • $project stage to:

    • Exclude all fields except title and released.

    • Add a field named score.

• Iterates over the cursor to print the documents that match the query.

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