How to Use Facets with Atlas Search

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 $search Query to view a default query syntax sample in JSON format.

Run an Atlas Search query against the indexed field.

To run the query, copy and paste the following query into the the Query Editor, then click Search.

The following query searches for movies released near November 11, 1921. It specifies a pivot distance from origin of approximately three months. It requests metadata on the genres and year field. The query requests a count of the:

• Number of movies in each genre in the genres string array field

• Number of movies in the years 1910 to 1939, inclusive

[
  {
    "$searchMeta": {
      "index": "facet-tutorial",
      "facet": {
        "operator": {
          "near": {
            "path": "released",
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
            "pivot": 7776000000
          }
        },
        "facets": {
          "genresFacet": {
            "type": "string",
            "path": "genres"
          },
          "yearFacet" : {
            "type" : "number",
            "path" : "year",
            "boundaries" : [1910,1920,1930,1940]
          }
        }
      }
    }
  }
]

Expand your query results.

The Search Tester might not display all the values for the fields in the results. To view all the values for the fields in the results, expand the fields.

Atlas Search displays the following results in the page:

count: Object
  lowerBound: 20878
facet: Object
  genresFacet: Object
    buckets: Array (10)
      0: Object
         _id: "Drama"
         count: 12149
      1: Object
         _id: "Comedy"
         count: 6436
      2: Object
         _id: "Romance"
         count: 3274
      3: Object
         _id: "Crime"
         count: 2429
      4: Object
         _id: "Thriller"
         count: 2400
      5: Object
         _id: "Action"
         count: 2349
      6: Object
         _id: "Adventure"
         count: 1876
      7: Object
         _id: "Documentary"
         count: 1755
      8: Object
         _id: "Horror"
         count: 1432
      9: Object
         _id: "Biography"
         count: 1244
  yearFacet: Object
    buckets: Array (3)
      0: Object
         _id: 1910
         count: 14
      1: Object
         _id: 1920
         count: 47
      2: Object
         _id: 1930
         count: 238

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 facet query that groups the genre and year fields into buckets.

The following query searches for movies released near November 11, 1921. It specifies a pivot distance from origin of approximately three months. It requests metadata on the genres and year field. The query requests a count of the:

• Number of movies in each genre in the genres string array field

• Number of movies in the years 1910 to 1939, inclusive

db.movies.aggregate([
  {
    "$searchMeta": {
      "index": "facet-tutorial",
      "facet": {
        "operator": {
          "near": {
            "path": "released",
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
            "pivot": 7776000000
          }
        },
        "facets": {
          "genresFacet": {
            "type": "string",
            "path": "genres"
          },
          "yearFacet" : {
            "type" : "number",
            "path" : "year",
            "boundaries" : [1910,1920,1930,1940]
          }
        }
      }
    }
  }
])

{
  "count" : {
    "lowerBound" : NumberLong(23026)
  },
  "facet" : {
    "genresFacet" : {
      "buckets" : [
        { "_id" : "Drama", "count" : NumberLong(13527) },
        { "_id" : "Comedy", "count" : NumberLong(6922) },
        { "_id" : "Romance", "count" : NumberLong(3615) },
        { "_id" : "Crime", "count" : NumberLong(2649) },
        { "_id" : "Thriller", "count" : NumberLong(2603) },
        { "_id" : "Action", "count" : NumberLong(2505) },
        { "_id" : "Documentary", "count" : NumberLong(2041) },
        { "_id" : "Adventure", "count" : NumberLong(2016) },
        { "_id" : "Horror", "count" : NumberLong(1662) },
        { "_id" : "Biography", "count" : NumberLong(1373) }
      ]
    },
    "yearFacet" : {
      "buckets" : [
        { "_id" : 1910, "count" : NumberLong(23) },
        { "_id" : 1920, "count" : NumberLong(89) },
        { "_id" : 1930, "count" : NumberLong(308) }
      ]
    }
  }
}

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 facet query that groups the genre and year fields into buckets.

The query uses the following searchMeta operator clauses:

• near to search for movies released with a pivot distance from origin of approximately three months from November 11, 1921

• facets to request the number of movies in each genre in the genres string array field and the number of movies in the years 1910 to 1939, inclusive

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
   $searchMeta	{ index: 'facet-tutorial', facet: { operator: { near: { path: 'released', origin: ISODate("1921-11-01T00:00:00.000+00:00"), pivot: 7776000000 } }, facets: { genresFacet: { type: 'string', path: 'genres' }, yearFacet: { type: 'number', path: 'year', boundaries: [1910,1920,1930,1940] } } } }

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

{
   count: { lowerBound: 23026 },
   facet: {
     genresFacet: {
       buckets: [
         { _id: "Drama", count: 13527 },
         { _id: "Comedy", count: 6922 },
         { _id: "Romance", count: 3615 },
         { _id: "Crime", count: 2649 },
         { _id: "Thriller", count: 2603 },
         { _id: "Action", count: 2505 },
         { _id: "Documentary", count: 2041 },
         { _id: "Adventure", count: 2016 },
         { _id: "Horror", count: 1662 },
         { _id: "Biography", count: 1373 }
       ]
     },
     yearFacet: {
       buckets: [
         { _id: 1910, count: 23 },
         { _id: 1920, count: 89 },
         { _id: 1930, count: 308 }
       ]
     }
   }
 }

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

1. Create a new directory called facet-query-example and initialize your project with the dotnet new command.

   mkdir facet-query-example
   cd facet-query-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 following query searches for movies released near November 11, 1921. It specifies a pivot distance from origin of approximately three months. It requests metadata on the genres and year field. The query requests a count of the:

   • Number of movies in each genre in the genres string array field

   • Number of movies in the years 1910 to 1939, inclusive

   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 FacetExample
   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 date and number fields
   23
           var originDate = new DateTime(1921, 11, 01, 0, 0, 0, DateTimeKind.Utc);
   24
   25
           // define and run pipeline
   26
           var results = moviesCollection.Aggregate()
   27
               .SearchMeta(Builders<MovieDocument>.Search.Facet(
   28
                       Builders<MovieDocument>.Search.Near(movie => movie.Released, originDate, 7776000000),
   29
                       Builders<MovieDocument>.SearchFacet.String("genresFacet", movie => movie.Genres, 10),
   30
                       Builders<MovieDocument>.SearchFacet.Number("yearFacet", movie => movie.Year, 1910, 1920, 1930, 1940)),
   31
                       indexName: "facet-tutorial")
   32
               .Single();
   33
   34
           // print results
   35
           Console.WriteLine(results.ToJson());
   36
       }
   37
   }
   38
   39
   [BsonIgnoreExtraElements]
   40
   public class MovieDocument
   41
   {
   42
       [BsonIgnoreIfDefault]
   43
       public ObjectId Id { get; set; }
   44
       public string [] Genres { get; set; }
   45
       public DateTime Released { get; set; }
   46
       public int Year { get; set; }
   47
   }

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 facet-query-example.csproj

{
  "count" : { "lowerBound" : NumberLong(23026), "total" : null },
  "facet" : {
    "genresFacet" : {
      "buckets" : [
        { "_id" : "Drama", "count" : NumberLong(13527) },
        { "_id" : "Comedy", "count" : NumberLong(6922) },
        { "_id" : "Romance", "count" : NumberLong(3615) },
        { "_id" : "Crime", "count" : NumberLong(2649) },
        { "_id" : "Thriller", "count" : NumberLong(2603) },
        { "_id" : "Action", "count" :  NumberLong(2505) },
        { "_id" : "Documentary", "count" : NumberLong(2041) },
        { "_id" : "Adventure", "count" : NumberLong(2016) },
        { "_id" : "Horror", "count" : NumberLong(1662) },
        { "_id" : "Biography", "count" : NumberLong(1373) }
      ]
    },
    "yearFacet" : {
      "buckets" : [
        { "_id" : 1910, "count" : NumberLong(23) },
        { "_id" : 1920, "count" : NumberLong(89) },
        { "_id" : 1930, "count" : NumberLong(308) }
      ]
    }
  }
}

Run an Atlas Search facet query that groups the genre and year fields into buckets.

1. Create a file named facet-query.go.

2. Copy and paste the following code into the facet-query.go file.

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • Uses the following searchMeta clauses to query the collection:

     • near to search for movies released with a pivot distance from origin of approximately three months from November 11, 1921

     • facets to request the number of movies in each genre in the genres string array field and the number of movies in the years 1910 to 1939, inclusive

   • 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{{"$searchMeta", bson.M{
   26
   		"index": "facet-tutorial",
   27
   		"facet": bson.M{
   28
   			"operator": bson.M{
   29
   				"near": bson.M{
   30
   					"path":   "released",
   31
   					"origin": time.Date(1921, time.November, 1, 0, 0, 0, 0, time.UTC),
   32
   					"pivot":  7776000000},
   33
   			},
   34
   			"facets": bson.M{
   35
   				"genresFacet": bson.M{
   36
   					"path": "genres",
   37
   					"type": "string"},
   38
   				"yearFacet": bson.M{
   39
   					"path":       "year",
   40
   					"type":       "number",
   41
   					"boundaries": bson.A{1910, 1920, 1930, 1940}},
   42
   			}}}}}
   43
   	// run pipeline
   44
   	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage})
   45
   	if err != nil {
   46
   		panic(err)
   47
   	}
   48
   49
   	// print results
   50
   	var results []bson.D
   51
   	if err = cursor.All(context.TODO(), &results); err != nil {
   52
   		panic(err)
   53
   	}
   54
   	for _, result := range results {
   55
   		fmt.Println(result)
   56
   	}
   57
   }

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 following command to query your collection:

   go run facet-query.go

   HIDE OUTPUT

   [{count [{lowerBound 23026}]}
    {facet [
      {genresFacet [
        {buckets [
         [{_id Drama} {count 13527}]
         [{_id Comedy} {count 6922}]
         [{_id Romance} {count 3615}]
         [{_id Crime} {count 2649}]
         [{_id Thriller} {count 2603}]
         [{_id Action} {count 2505}]
         [{_id Documentary} {count 2041}]
         [{_id Adventure} {count 2016}]
         [{_id Horror} {count 1662}]
         [{_id Biography} {count 1373}]]}]}
     {yearFacet [
       {buckets [
         [{_id 1910} {count 23}]
         [{_id 1920} {count 89}]
         [{_id 1930} {count 308}]]}]}]}]

Ensure that your CLASSPATH contains the following libraries.

Run an Atlas Search facet query that groups the genre and year fields into buckets.

1. Create a file named FacetQuery.java.

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

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • Uses the following searchMeta clauses to query the collection:

     • near to search for movies released with a pivot distance from origin of approximately three months from November 11, 1921

     • facets to request the number of movies in each genre in the genres string array field and the number of movies in the years 1910 to 1939, inclusive

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

   1
   import com.mongodb.client.MongoClient;
   2
   import com.mongodb.client.MongoClients;
   3
   import com.mongodb.client.MongoCollection;
   4
   import com.mongodb.client.MongoDatabase;
   5
   import org.bson.Document;
   6
   7
   import java.time.Instant;
   8
   import java.util.Arrays;
   9
   import java.util.Date;
   10
   11
   public class FacetQuery {
   12
       public static void main(String[] args) {
   13
           // connect to your Atlas cluster
   14
           String uri = "<connection-string>";
   15
   16
           try (MongoClient mongoClient = MongoClients.create(uri)) {
   17
               // set namespace
   18
               MongoDatabase database = mongoClient.getDatabase("sample_mflix");
   19
               MongoCollection<Document> collection = database.getCollection("movies");
   20
               
   21
               // define pipeline
   22
               Document agg = new Document("$searchMeta", 
   23
                   new Document( "index", "facet-tutorial")
   24
                   .append("facet", 
   25
                       new Document("operator", 
   26
                           new Document("near", 
   27
                               new Document("path", "released")
   28
                               .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000+00:00")))
   29
                               .append("pivot", 7776000000L)))
   30
                   .append("facets", 
   31
                       new Document("genresFacet", 
   32
                           new Document("type", "string").append("path", "genres"))
   33
                       .append("yearFacet",
   34
                           new Document("type", "number").append("path", "year")
   35
                           .append("boundaries", Arrays.asList(1910, 1920, 1930, 1940))
   36
                ))));
   37
               // run pipeline and print results
   38
               collection.aggregate(Arrays.asList(agg))
   39
                   .forEach(doc -> System.out.println(doc.toJson()));
   40
   41
           }
   42
       }
   43
   }

   Note

   To run the sample code in your Maven environment, add the following 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 FacetQuery.java file.

   javac FacetQuery.java
   java FacetQuery

   HIDE OUTPUT

   {"count": {"lowerBound": 23026},
    "facet": {
      "genresFacet": {
        "buckets": [
          {"_id": "Drama", "count": 13527},
          {"_id": "Comedy", "count": 6922},
          {"_id": "Romance", "count": 3615},
          {"_id": "Crime", "count": 2649},
          {"_id": "Thriller", "count": 2603},
          {"_id": "Action", "count": 2505},
          {"_id": "Documentary", "count": 2041},
          {"_id": "Adventure", "count": 2016},
          {"_id": "Horror", "count": 1662},
          {"_id": "Biography", "count": 1373}]},
      "yearFacet": {
        "buckets": [
          {"_id": 1910, "count": 23},
          {"_id": 1920, "count": 89},
          {"_id": 1930, "count": 308}]}}}

Ensure that you add the following dependency to your project.

Run an Atlas Search facet query that groups the genre and year fields into buckets.

1. Create a file named FacetQuery.kt.

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

   The code example performs the following tasks:

   • Imports mongodb packages and dependencies.

   • Establishes a connection to your Atlas cluster.

   • Uses the following searchMeta clauses to query the collection:

     • near to search for movies released with a pivot distance from origin of approximately three months from November 11, 1921

     • facets to request the number of movies in each genre in the genres string array field and the number of movies in the years 1910 to 1939, inclusive

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

   1
   import com.mongodb.kotlin.client.coroutine.MongoClient
   2
   import kotlinx.coroutines.runBlocking
   3
   import org.bson.Document
   4
   import java.time.Instant
   5
   import java.util.*
   6
   7
   fun main() {
   8
       // connect to your Atlas cluster
   9
       val uri = "<connection-string>"
   10
       val mongoClient = MongoClient.create(uri)
   11
       
   12
       // set namespace
   13
       val database = mongoClient.getDatabase("sample_mflix")
   14
       val collection = database.getCollection<Document>("movies")
   15
   16
       runBlocking {
   17
           // define pipeline
   18
           val agg = Document(
   19
               "\$searchMeta",
   20
               Document("index", "facet-tutorial")
   21
                   .append(
   22
                       "facet",
   23
                       Document(
   24
                           "operator",
   25
                           Document(
   26
                               "near",
   27
                               Document("path", "released")
   28
                                   .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000+00:00")))
   29
                                   .append("pivot", 7776000000L)
   30
                           )
   31
                       )
   32
                           .append(
   33
                               "facets",
   34
                               Document(
   35
                                   "genresFacet",
   36
                                   Document("type", "string").append("path", "genres")
   37
                               )
   38
                                   .append(
   39
                                       "yearFacet",
   40
                                       Document("type", "number").append("path", "year")
   41
                                           .append("boundaries", listOf(1910, 1920, 1930, 1940))
   42
                                   )
   43
                           )
   44
                   )
   45
           )
   46
   47
           // run pipeline and print results
   48
           val resultsFlow = collection.aggregate<Document>(
   49
               listOf(agg)
   50
           )
   51
           resultsFlow.collect { println(it) }
   52
       }
   53
       mongoClient.close()
   54
   }

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 FacetQuery.kt file.

   When you run the FacetQuery.kt program in your IDE, it prints the following result:

   Document{{count=Document{{lowerBound=20878}},
   facet=Document{{genresFacet=Document{{buckets=[Document{{_id=Drama,
   count=12149}}, Document{{_id=Comedy, count=6436}},
   Document{{_id=Romance, count=3274}}, Document{{_id=Crime,
   count=2429}}, Document{{_id=Thriller, count=2400}},
   Document{{_id=Action, count=2349}}, Document{{_id=Adventure,
   count=1876}}, Document{{_id=Documentary, count=1755}},
   Document{{_id=Horror, count=1432}}, Document{{_id=Biography,
   count=1244}}]}},
   yearFacet=Document{{buckets=[Document{{_id=1910, count=14}},
   Document{{_id=1920, count=47}}, Document{{_id=1930,
   count=238}}]}}}}}}

Run an Atlas Search facet query that groups the genre and year fields into buckets.

1. Create a file named facet-query.js.

2. Copy and paste the following code into the facet-query.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.

   • Uses the following searchMeta clauses to query the collection:

     • near to search for movies released with a pivot distance from origin of approximately three months from November 11, 1921

     • facets to request the number of movies in each genre in the genres string array field and the number of movies in the years 1910 to 1939, inclusive

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

   1
   const { MongoClient } = require("mongodb");
   2
   3
   // connect to your Atlas cluster
   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 = [{$searchMeta: {
   19
             index: "facet-tutorial",
   20
             facet: {
   21
                   operator: {
   22
                     near: {path: "released", origin: new Date("1921-11-01T00:00:00.000Z"), pivot: 7776000000}
   23
                   },
   24
                   facets: {
   25
                     genresFacet: {type: "string", path: "genres"},
   26
                     yearFacet: {type: "number", path: "year",boundaries: [1910,1920,1930,1940]}
   27
                   }}}}];
   28
           // run pipeline
   29
           const result = coll.aggregate(agg);
   30
   31
           // print results
   32
           await result.forEach((doc) => console.dir(JSON.stringify(doc)));
   33
       } finally {
   34
           await client.close();
   35
       }
   36
   }
   37
   run().catch(console.dir);

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 following command to query your collection:

   node facet-query.js

   HIDE OUTPUT

   '{"count":{"lowerBound":23026},
     "facet":{
       "genresFacet":{
         "buckets":[
           {"_id":"Drama","count":13527},
           {"_id":"Comedy","count":6922},
           {"_id":"Romance","count":3615},
           {"_id":"Crime","count":2649},
           {"_id":"Thriller","count":2603},
           {"_id":"Action","count":2505},
           {"_id":"Documentary","count":2041},
           {"_id":"Adventure","count":2016},
           {"_id":"Horror","count":1662},
           {"_id":"Biography","count":1373}]},
       "yearFacet":{
         "buckets":[
           {"_id":1910,"count":23},
           {"_id":1920,"count":89},
           {"_id":1930,"count":308}]}}}'

Run an Atlas Search facet query that groups the genre and year fields into buckets.

1. Create a file named facet-query.py.

2. Copy and paste the following code into the facet.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.

   • Uses the following searchMeta clauses to query the collection:

     • near to search for movies released with a pivot distance from origin of approximately three months from November 11, 1921

     • facets to request the number of movies in each genre in the genres string array field and the number of movies in the years 1910 to 1939, inclusive

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

   1
   import pymongo
   2
   import datetime
   3
   4
   # connect to your Atlas cluster
   5
   client = pymongo.MongoClient('<connection-string>')
   6
   7
   # define pipeline
   8
   pipeline = [{"$searchMeta": { 
   9
       "index": "facet-tutorial",
   10
       "facet": {
   11
           "operator": {
   12
             "near": {"path": "released", "origin": datetime.datetime(1921, 11, 1, 0, 0, 0, 0), "pivot": 7776000000}
   13
           },
   14
           "facets": {
   15
             "genresFacet": {"type": "string", "path": "genres"},
   16
             "yearFacet" : {"type" : "number", "path" : "year", "boundaries" : [1910,1920,1930,1940]}
   17
           }}}}]
   18
   # run pipeline
   19
   result = client["sample_mflix"]["movies"].aggregate(pipeline)
   20
   21
   # print results
   22
   for i in result:
   23
       print(i)

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 following command to query your collection:

   python facet-query.py

   HIDE OUTPUT

   {'count': {'lowerBound': 23026},
    'facet': {
      'genresFacet': {
        'buckets': [
          {'count': 13527, '_id': 'Drama'},
          {'count': 6922, '_id': 'Comedy'},
          {'count': 3615, '_id': 'Romance'},
          {'count': 2649, '_id': 'Crime'},
          {'count': 2603, '_id': 'Thriller'},
          {'count': 2505, '_id': 'Action'},
          {'count': 2041, '_id': 'Documentary'},
          {'count': 2016, '_id': 'Adventure'},
          {'count': 1662, '_id': 'Horror'},
          {'count': 1373, '_id': 'Biography'}]},
      'yearFacet': {
        'buckets': [
          {'count': 23, '_id': 1910},
          {'count': 89, '_id': 1920},
          {'count': 308, '_id': 1930}]}}}