Atlas Search Quick Start

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 a basic query.

Run a basic $search query by using the text operator.

This query has the following search criteria:

• The plot field must contain the word baseball.

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

1
[
2
  {
3
    $search:
4
      {
5
        text: {
6
          query: "baseball",
7
          path: "plot"
8
      }
9
    }
10
  }
11
]

SCORE: 3.8531038761138916  _id:  "573a13b3f29313caabd3b409"
  fullplot: "Three guys, all their lives, have been living in the shadow of bullies…"
  imdb: Object
  year: 2006
  ...
SCORE: 3.6254453659057617  _id:  "573a1399f29313caabcee801"
  plot: "A young boy is bequeathed the ownership of a professional baseball tea..."
  genres: Array
  runtime: 119
  ...
SCORE: 3.6254453659057617  _id:  "573a139af29313caabcefe18"
  plot: "A trained chimpanzee plays third base for a minor-league baseball team..."
  genres: Array
  runtime: 94
  ...
...

Refine your search.

Atlas Search provides several operators that you can use to build complex queries and retrieve more specific results for your use case. Update your $search query to use the compound operator to combine multiple operators into a single query.

This query has the following search criteria:

• The plot field must contain the word baseball.

• The genres field must not contain either Comedy or Romance.

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

1
[
2
  {
3
    "$search": {
4
      "compound": {
5
        "must": [
6
          {
7
            "text": {
8
              "query": "baseball",
9
              "path": "plot"
10
            }
11
          }
12
        ],
13
        "mustNot": [
14
          {
15
            "text": {
16
              "query": ["Comedy", "Romance"],
17
              "path": "genres"
18
            }
19
          }
20
        ]
21
      }
22
    }
23
  }
24
]

SCORE: 3.4706974029541016  _id:  "573a1393f29313caabcdca79"
  title: "The Pride of the Yankees"
  plot: "The story of the life and career of the famed baseball player, Lou Geh…"
  genres: ["Biography", "Drama", "Family"]
  ...
SCORE: 3.4706974029541016  _id:  "573a1399f29313caabcecef1"
  title: "The Babe"
  plot: "Babe Ruth becomes a baseball legend but is unheroic to those who know …"
  genres: ["Biography", "Drama", "Sport"]
  ...
SCORE: 3.406810760498047  _id:  "573a13bdf29313caabd5813d"
  title: "Sugar"
  plot: "Dominican baseball star Miguel \"Sugar\" Santos is recruited to play in …"
  genres: ["Drama", "Sport"]
  ...
...

Process your results.

Atlas Search provides several search options that you can use to further process your Atlas Search query results. Add the sort option to your query to display the results in a specific order.

This query has the following search criteria:

• The plot field must contain the word baseball.

• The genres field must not contain either Comedy or Romance.

• Sort the results by the released date field in descending order. Atlas Search returns the most recent movies first.

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

1
[
2
  {
3
    "$search": {
4
      "compound": {
5
        "must": [
6
          {
7
            "text": {
8
              "query": "baseball",
9
              "path": "plot"
10
            }
11
          }
12
        ],
13
        "mustNot": [
14
          {
15
            "text": {
16
              "query": ["Comedy", "Romance"],
17
              "path": "genres"
18
            }
19
          }
20
        ]
21
      },
22
      "sort": {
23
        "released": -1
24
      }
25
    }
26
  }
27
]

SCORE: 3.173170804977417  _id: "573a13ccf29313caabd832f5"
  plot: "A sports agent stages an unconventional recruitment strategy to get ta…"
  title: "Million Dollar Arm"
  genres: Array (3)
  released: 2014-05-16T00:00:00.000+00:00
  ...
SCORE: 3.2858426570892334  _id: "573a13d9f29313caabda97d8"
  plot: "A Taiwanese high school baseball team travels to Japan in 1931 to comp…"
  title: "Kano"
  genres: Array (3)
  released: 2014-02-27T00:00:00.000+00:00
  ...
SCORE: 2.4570295810699463  _id: "573a13daf29313caabdad92d"
  plot: "12-year-old Josh is a mixed race boy and a promising baseball player..."
  title: "Calloused Hands"
  genres: Array (1)
  released: 2013-03-03T00:00:00.000+00:00
  ...
...

Run a basic query.

Run a basic $search query by using the text operator.

This query has the following search criteria:

• The plot field must contain the word baseball.

• $limit and $project stages to return only 3 documents and the title and plot fields.

1
db.movies.aggregate([
2
  {
3
    $search:
4
    {
5
      "text": {
6
        "query": "baseball",
7
        "path": "plot"
8
      }
9
    }
10
  },
11
  {
12
    $limit: 3
13
  },
14
  {
15
    $project: {
16
      "_id": 0,
17
      "title": 1,
18
      "plot": 1
19
    }
20
  }
21
])

{
  "plot" : "A trio of guys try and make up for missed
  opportunities in childhood by forming a three-player
  baseball team to compete against standard children
  baseball squads.",
  "title" : "The Benchwarmers"
}
{
  "plot" : "A young boy is bequeathed the ownership of a
  professional baseball team.",
  "title" : "Little Big League"
}
{
  "plot" : "A trained chimpanzee plays third base for a
  minor-league baseball team.",
  "title" : "Ed"
}

Refine your search.

Atlas Search provides several operators that you can use to build complex queries and retrieve more specific results for your use case. Update your $search query to use the compound operator to combine multiple operators into a single query.

This query has the following search criteria:

• The plot field must contain the word baseball.

• The genres field must not contain either Comedy or Romance.

• $limit and $project stages to return only 3 documents and the title, plot, and genres fields.

1
db.movies.aggregate([
2
  {
3
    $search: {
4
      "compound": {
5
        "must": [
6
          {
7
            "text": {
8
              "query": "baseball",
9
              "path": "plot"
10
            }
11
          }
12
        ],
13
        "mustNot": [
14
          {
15
            "text": {
16
              "query": ["Comedy", "Romance"],
17
              "path": "genres"
18
            }
19
          }
20
        ]
21
      }
22
    }
23
  },
24
  {
25
    $limit: 3
26
  },
27
  {
28
    $project: {
29
      "_id": 0,
30
      "title": 1,
31
      "plot": 1,
32
      "genres": 1
33
    }
34
  }
35
])

[
  {
    plot: 'The story of the life and career of the famed baseball player, Lou Gehrig.',
    genres: [ 'Biography', 'Drama', 'Family' ],
    title: 'The Pride of the Yankees'
  },
  {
    plot: 'Babe Ruth becomes a baseball legend but is unheroic to those who know him.',
    genres: [ 'Biography', 'Drama', 'Sport' ],
    title: 'The Babe'
  },
  {
    plot: 'Dominican baseball star Miguel "Sugar" Santos is recruited to play in the U.S. minor-leagues.',
    genres: [ 'Drama', 'Sport' ],
    title: 'Sugar'
  }
]

Process your results.

Atlas Search provides several search options that you can use to further process your Atlas Search query results. Add the sort option to your query to display the results in a specific order.

This query has the following search criteria:

• The plot field must contain the word baseball.

• The genres field must not contain either Comedy or Romance.

• Sort the results by the released date field in descending order. Atlas Search returns the most recent movies first.

• $limit and $project stages to return only 3 documents and the title, plot, genres, and released fields.

1
db.movies.aggregate([
2
  {
3
    $search: {
4
      "compound": {
5
        "must": [ {
6
          "text": {
7
            "query": "baseball",
8
            "path": "plot"
9
          }
10
        }],
11
        "mustNot": [ {
12
          "text": {
13
            "query": ["Comedy", "Romance"],
14
            "path": "genres"
15
          }
16
        } ]
17
      },
18
      "sort": {
19
        "released": -1
20
      }
21
    }
22
  },
23
  {
24
    $limit: 3
25
  },
26
  {
27
    $project: {
28
      "_id": 0,
29
      "title": 1,
30
      "plot": 1,
31
      "genres": 1,
32
      "released": 1
33
    }
34
  }
35
])

[
  {
    plot: 'A sports agent stages an unconventional recruitment strategy to get talented Indian cricket players to play Major League Baseball.',
    genres: [ 'Biography', 'Drama', 'Sport' ],
    title: 'Million Dollar Arm',
    released: ISODate('2014-05-16T00:00:00.000Z')
  },
  {
    plot: 'A Taiwanese high school baseball team travels to Japan in 1931 to compete in a national tournament.',
    genres: [ 'Biography', 'Drama', 'History' ],
    title: 'Kano',
    released: ISODate('2014-02-27T00:00:00.000Z')
  },
  {
    plot: "12-year-old Josh is a mixed race boy and a promising baseball player...",
    genres: [ 'Drama' ],
    title: 'Calloused Hands',
    released: ISODate('2013-03-03T00:00:00.000Z')
  }
]

Navigate to the collection in MongoDB Compass.

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

Run a basic query.

Run a basic $search query by using the text operator.

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.

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • $limit and $project stages to return only 3 documents and the title and plot fields.

   Pipeline Stage	Query
   $search	{ "text": { "query": "baseball", "path": "plot" } }
   $limit	3
   $project	{ "_id": 0, "title": 1, "plot": 1, }

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

 {
   "plot" : "A trio of guys try and make up for missed opportunities in childhood by forming a three-player baseball team to compete against standard children baseball squads.",
   "title" : "The Benchwarmers"
 }
 {
   "plot" : "A young boy is bequeathed the ownership of a professional baseball team.",
   "title" : "Little Big League"
 }
 {
   "plot" : "A trained chimpanzee plays third base for a minor-league baseball team.",
   "title" : "Ed"
 }

Refine your search.

Atlas Search provides several operators that you can use to build complex queries and retrieve more specific results for your use case. Update your $search query to use the compound operator to combine multiple operators into a single query.

This query has the following search criteria:

• The plot field must contain the word baseball.

• The genres field must not contain either Comedy or Romance.

• $limit and $project stages to return only 3 documents and the title, plot, and genres fields.

Update the following pipeline stages in MongoDB Compass:

{
  "compound": {
    "must": [
      {
        "text": {
          "query": "baseball",
          "path": "plot"
        }
      }
    ],
    "mustNot": [
      {
        "text": {
          "query": ["Comedy", "Romance"],
          "path": "genres"
        }
      }
    ]
  }
}

{
  "_id": 0,
  "title": 1,
  "plot": 1,
  "genres": 1,
}

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

 {
   "plot" : "The story of the life and career of the famed baseball player, Lou Gehrig.",
   "genres" : [ "Biography", "Drama", "Family" ],
   "title" : "The Pride of the Yankees"
 }
 {
   "plot" : "Babe Ruth becomes a baseball legend but is unheroic to those who know him.",
   "genres" : [ "Biography", "Drama", "Sport" ],
   "title" : "The Babe"
 }
 {
   "plot" : "Dominican baseball star Miguel \"Sugar\" Santos is recruited to play in the U.S. minor-leagues.",
   "genres" : [ "Drama", "Sport" ],
   "title" : "Sugar"
 }

Process your results.

Atlas Search provides several search options that you can use to further process your Atlas Search query results. Add the sort option to your query to display the results in a specific order.

This query has the following search criteria:

• The plot field must contain the word baseball.

• The genres field must not contain either Comedy or Romance.

• Sort the results by the released date field in descending order. Atlas Search returns the most recent movies first.

• $limit and $project stages to return only 3 documents and the title, plot, genres, and released fields.

Update the following pipeline stages in MongoDB Compass:

{
  "compound": {
    "must": [
      {
        "text": {
          "query": "baseball",
          "path": "plot"
        }
      }
    ],
    "mustNot": [
      {
        "text": {
          "query": ["Comedy", "Romance"],
          "path": "genres"
        }
      }
    ]
  },
  "sort": {
    "released": -1
  }
}

{
  "_id": 0,
  "title": 1,
  "plot": 1,
  "genres": 1,
  "released": 1,
}

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

[
  {
    plot: 'A sports agent stages an unconventional recruitment strategy to get talented Indian cricket players to play Major League Baseball.',
    genres: [ 'Biography', 'Drama', 'Sport' ],
    title: 'Million Dollar Arm',
    released: 2014-05-16T00:00:00.000+00:00
  },
  {
    plot: 'A Taiwanese high school baseball team travels to Japan in 1931 to compete in a national tournament.',
    genres: [ 'Biography', 'Drama', 'History' ],
    title: 'Kano',
    released: 2014-02-27T00:00:00.000+00:00
  },
  {
    plot: "12-year-old Josh is a mixed race boy and a promising baseball player...",
    genres: [ 'Drama' ],
    title: 'Calloused Hands',
    released: 2013-03-03T00:00:00.000+00:00
  }
]

Run a basic query.

Run a basic $search query by using the text operator.

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

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • $limit and $project stages to return only 3 documents and the title and plot fields.

   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 BasicQuery
   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 and run pipeline
   23
           var results = moviesCollection.Aggregate()
   24
               .Search(Builders<MovieDocument>.Search.Text(movie => movie.Plot, "baseball"))
   25
               .Project<MovieDocument>(Builders<MovieDocument>.Projection
   26
                   .Include(movie => movie.Plot)
   27
                   .Include(movie => movie.Title)
   28
                   .Exclude(movie => movie.Id))
   29
               .Limit(3)
   30
               .ToList();
   31
   32
           // print results
   33
           foreach (var movie in results)
   34
           {
   35
               Console.WriteLine(movie.ToJson());
   36
           }
   37
       }
   38
   }
   39
   40
   [BsonIgnoreExtraElements]
   41
   public class MovieDocument
   42
   {
   43
       [BsonIgnoreIfDefault]
   44
       public ObjectId Id { get; set; }
   45
       public string Plot { get; set; }
   46
       public string Title { get; set; }
   47
   }

2. Specify the <connection-string>, then run the query:

   dotnet run Program.cs

   VIEW OUTPUT

   { "plot" : "A trio of guys try and make up for missed opportunities in childhood by forming a three-player baseball team to compete against standard children baseball squads.", "title" : "The Benchwarmers" }
   { "plot" : "A young boy is bequeathed the ownership of a professional baseball team.", "title" : "Little Big League" }
   { "plot" : "A trained chimpanzee plays third base for a minor-league baseball team.", "title" : "Ed" }

Refine your search.

Atlas Search provides several operators that you can use to build complex queries and retrieve more specific results for your use case. Update your $search query to use the compound operator to combine multiple operators into a single query.

1. Modify your Program.cs file with the following code.

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • The genres field must not contain either Comedy or Romance.

   • $limit and $project stages to return only 3 documents and the title, plot, and genres fields.

   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 CompoundQuery
   8
   {
   9
       private const string MongoConnectionString = "<connection-string>";
   10
   11
       public static void Main(string[] args)
   12
       {
   13
           // allow automapping of the camelCase database fields to our MovieDocument
   14
           var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
   15
           ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
   16
   17
           // connect to your Atlas cluster
   18
           var mongoClient = new MongoClient(MongoConnectionString);
   19
           var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
   20
           var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
   21
   22
           // declare data for the compound query
   23
           string[] genres = { "Comedy", "Romance" };
   24
   25
           // define and run pipeline
   26
           var results = moviesCollection.Aggregate()
   27
               .Search(Builders<MovieDocument>.Search.Compound()
   28
                   .Must(Builders<MovieDocument>.Search.Text(movie => movie.Plot, "baseball"))
   29
                   .MustNot((Builders<MovieDocument>.Search.Text(movie => movie.Genres, genres))))
   30
               .Project<MovieDocument>(Builders<MovieDocument>.Projection
   31
                   .Exclude(movie => movie.Id)
   32
                   .Include(movie => movie.Plot)
   33
                   .Include(movie => movie.Title)
   34
                   .Include(movie => movie.Genres))
   35
               .Limit(3)
   36
               .ToList();
   37
   38
           // print results
   39
           foreach (var movie in results)
   40
           {
   41
               Console.WriteLine(movie.ToJson());
   42
           }
   43
       }
   44
   }
   45
   46
   [BsonIgnoreExtraElements]
   47
   public class MovieDocument
   48
   {
   49
       [BsonIgnoreIfDefault]
   50
       public ObjectId Id { get; set; }
   51
       public string Plot { get; set; }
   52
       public string Title { get; set; }
   53
       public string[] Genres { get; set; }
   54
   }

2. Specify the <connection-string>, then run the query:

   dotnet run Program.cs

   VIEW OUTPUT

   { "plot" : "The story of the life and career of the famed baseball player, Lou Gehrig.", "title" : "The Pride of the Yankees", "genres" : ["Biography", "Drama", "Family"] }
   { "plot" : "Babe Ruth becomes a baseball legend but is unheroic to those who know him.", "title" : "The Babe", "genres" : ["Biography", "Drama", "Sport"] }
   { "plot" : "Dominican baseball star Miguel \"Sugar\" Santos is recruited to play in the U.S. minor-leagues.", "title" : "Sugar", "genres" : ["Drama", "Sport"] }

Process your results.

Atlas Search provides several search options that you can use to further process your Atlas Search query results. Add the sort option to your query to display the results in a specific order.

1. Modify your Program.cs file with the following code.

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • The genres field must not contain either Comedy or Romance.

   • Sort the results by the released date field in descending order. Atlas Search returns the most recent movies first.

   • $limit and $project stages to return only 3 documents and the title, plot, genres, and released fields.

   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 SortQuery
   8
   {
   9
       private const string MongoConnectionString = "<connection-string>";
   10
   11
       public static void Main(string[] args)
   12
       {
   13
           // allow automapping of the camelCase database fields to our MovieDocument
   14
           var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
   15
           ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
   16
   17
           // connect to your Atlas cluster
   18
           var mongoClient = new MongoClient(MongoConnectionString);
   19
           var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
   20
           var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
   21
   22
           // declare data for the compound query
   23
           string[] genres = { "Comedy", "Romance" };
   24
   25
           // define search options
   26
           var searchOptions = new SearchOptions<MovieDocument>() 
   27
               { 
   28
                   Sort = Builders<MovieDocument>.Sort.Descending(movie => movie.Released),
   29
               };
   30
   31
           // define and run pipeline
   32
           var results = moviesCollection.Aggregate()
   33
               .Search(Builders<MovieDocument>.Search.Compound()
   34
                   .Must(Builders<MovieDocument>.Search.Text(movie => movie.Plot, "baseball"))
   35
                   .MustNot((Builders<MovieDocument>.Search.Text(movie => movie.Genres, genres))), searchOptions)
   36
               .Project<MovieDocument>(Builders<MovieDocument>.Projection
   37
                   .Exclude(movie => movie.Id)
   38
                   .Include(movie => movie.Plot)
   39
                   .Include(movie => movie.Title)
   40
                   .Include(movie => movie.Genres)
   41
                   .Include(movie => movie.Released))
   42
               .Limit(3)
   43
               .ToList();
   44
   45
           // print results
   46
           foreach (var movie in results)
   47
           {
   48
               Console.WriteLine(movie.ToJson());
   49
           }
   50
       }
   51
   }
   52
   53
   [BsonIgnoreExtraElements]
   54
   public class MovieDocument
   55
   {
   56
       [BsonIgnoreIfDefault]
   57
       public ObjectId Id { get; set; }
   58
       public string Plot { get; set; }
   59
       public string Title { get; set; }
   60
       public string[] Genres { get; set; }
   61
       public DateTime Released { get; set; }
   62
   }

2. Specify the <connection-string>, then run the query:

   dotnet run Program.cs

   VIEW OUTPUT

   { "plot" : "A sports agent stages an unconventional recruitment strategy to get talented Indian cricket players to play Major League Baseball.", "title" : "Million Dollar Arm", "genres" : ["Biography", "Drama", "Sport"], "released" : { "$date" : "2014-05-16T00:00:00Z" } }
   { "plot" : "A Taiwanese high school baseball team travels to Japan in 1931 to compete in a national tournament.", "title" : "Kano", "genres" : ["Biography", "Drama", "History"], "released" : { "$date" : "2014-02-27T00:00:00Z" } }
   { "plot" : "12-year-old Josh is a mixed race boy and a promising baseball player. He is abused by his mother's boyfriend Byrd, and neglected by his mother Debbie. He forges his own path in life when ...", "title" : "Calloused Hands", "genres" : ["Drama"], "released" : { "$date" : "2013-03-03T00:00:00Z" } }

Run a basic query.

Run a basic $search query by using the text operator.

1. Create a new file named run-query.go and paste the following code.

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • $limit and $project stages to return only 3 documents and the title and plot fields.

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

2. Specify the <connection-string>, then run the query:

   go run run-query.go

   VIEW OUTPUT

   {"plot":"A trio of guys try and make up for missed opportunities in childhood by forming a three-player baseball team to compete against standard children baseball squads.","title":"The Benchwarmers"}
   {"plot":"A young boy is bequeathed the ownership of a professional baseball team.","title":"Little Big League"}
   {"plot":"A trained chimpanzee plays third base for a minor-league baseball team.","title":"Ed"}

Refine your search.

Atlas Search provides several operators that you can use to build complex queries and retrieve more specific results for your use case. Update your $search query to use the compound operator to combine multiple operators into a single query.

1. Modify run-query.go to use the compound query.

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • The genres field must not contain either Comedy or Romance.

   • $limit and $project stages to return only 3 documents and the title, plot, and genres fields.

   1
   package main
   2
   3
   import (
   4
   	"context"
   5
   	"fmt"
   6
   	"time"
   7
   8
   	"go.mongodb.org/mongo-driver/v2/bson"
   9
   	"go.mongodb.org/mongo-driver/v2/mongo"
   10
   	"go.mongodb.org/mongo-driver/v2/mongo/options"
   11
   )
   12
   13
   func main() {
   14
   	var err error
   15
   	// connect to the Atlas cluster
   16
   	ctx := context.Background()
   17
   	client, err := mongo.Connect(options.Client().SetTimeout(5 * time.Second).ApplyURI("<connection-string>"))
   18
   	if err != nil {
   19
   		panic(err)
   20
   	}
   21
   	defer client.Disconnect(ctx)
   22
   	// set namespace
   23
   	collection := client.Database("sample_mflix").Collection("movies")
   24
   	// define pipeline
   25
   	searchStage := bson.D{{"$search", bson.M{
   26
   		"compound": bson.M{
   27
   			"must": bson.A{
   28
   				bson.M{
   29
   					"text": bson.D{
   30
   						{"path", "plot"}, {"query", "baseball"},
   31
   					},
   32
   				},
   33
   			},
   34
   			"mustNot": bson.A{
   35
   				bson.M{
   36
   					"text": bson.M{
   37
   						"path": "genres", "query": []string{"Comedy", "Romance"},
   38
   					},
   39
   				},
   40
   			},
   41
   		},
   42
   	}}}
   43
   	limitStage := bson.D{{"$limit", 3}}
   44
   	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"plot", 1}, {"genres", 1}, {"_id", 0}}}}
   45
   	// run pipeline
   46
   	cursor, err := collection.Aggregate(ctx, mongo.Pipeline{searchStage, limitStage, projectStage})
   47
   	if err != nil {
   48
   		panic(err)
   49
   	}
   50
   	// print results
   51
   	var results []bson.D
   52
   	if err = cursor.All(context.TODO(), &results); err != nil {
   53
   		panic(err)
   54
   	}
   55
   	for _, result := range results {
   56
   		fmt.Println(result)
   57
   	}
   58
   }

2. Specify the <connection-string>, then run the query:

   go run run-query.go

   VIEW OUTPUT

   {"plot":"The story of the life and career of the famed baseball player, Lou Gehrig.","genres":["Biography","Drama","Family"],"title":"The Pride of the Yankees"}
   {"plot":"Babe Ruth becomes a baseball legend but is unheroic to those who know him.","genres":["Biography","Drama","Sport"],"title":"The Babe"}
   {"plot":"Dominican baseball star Miguel \"Sugar\" Santos is recruited to play in the U.S. minor-leagues.","genres":["Drama","Sport"],"title":"Sugar"}

Process your results.

Atlas Search provides several search options that you can use to further process your Atlas Search query results. Add the sort option to your query to display the results in a specific order.

1. Modify run-query.go to add the sort option.

   This query has the following search criteria:

   • The plot field must contain the word baseball.

   • The genres field must not contain either Comedy or Romance.

   • Sort the results by the released date field in descending order. Atlas Search returns the most recent movies first.

   • $limit and $project stages to return only 3 documents and the title, plot, genres, and released fields.

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

2. Specify the <connection-string>, then run the query:

   go run run-query.go

   VIEW OUTPUT

   {"plot":"A sports agent stages an unconventional recruitment strategy to get talented Indian cricket players to play Major League Baseball.","genres":["Biography","Drama","Sport"],"title":"Million Dollar Arm","released":{"$date":{"$numberLong":"1400198400000"}}}
   {"plot":"A Taiwanese high school baseball team travels to Japan in 1931 to compete in a national tournament.","genres":["Biography","Drama","History"],"title":"Kano","released":{"$date":{"$numberLong":"1393459200000"}}}
   {"plot":"12-year-old Josh is a mixed race boy and a promising baseball player. He is abused by his mother's boyfriend Byrd, and neglected by his mother Debbie. He forges his own path in life when ...","genres":["Drama"],"title":"Calloused Hands","released":{"$date":{"$numberLong":"1362268800000"}}}