Como usar as Facetas com Atlas Search

No Atlas, váGo para a Clusters página do seu projeto.

1. Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.

2. Se ainda não estiver exibido, selecione o projeto desejado no menu Projects na barra de navegação.

3. Se ainda não estiver exibido, clique em Clusters na barra lateral.

   A página Clusters é exibida.

Acesse a página do Atlas Search do seu cluster.

Você pode acessar a página do Atlas Search pela barra lateral, pelo Data Explorer ou pela página de detalhes do cluster.

Acesse o Search Tester.

Clique no botão Query à direita do índice para consultar.

Visualizar e editar a sintaxe da consulta.

Clique em Edit $search Query para visualizar uma amostra de sintaxe de consulta padrão no formato JSON .

Execute uma query do Atlas Search no campo indexado.

Para executar a query, copie e cole a seguinte query no Query Editor, e clique em Search.

A query abaixo procura filmes lançados próximo a 11 de novembro de 1921. Ela especifica uma distância de pivot de origin de aproximadamente três meses. Ela solicita metadados no campo genres e year. A query solicita uma contagem de:

• Número de filmes em cada gênero no campo genres da string array

• Número de filmes nos anos de 1910 a 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]
          }
        }
      }
    }
  }
]

Expanda os resultados da query.

O Search Tester pode não exibir todos os valores dos campos nos resultados. Para visualizar todos os valores dos campos nos resultados, expanda os campos.

A Pesquisa do Atlas exibe os seguintes resultados na página:

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

Conecte-se ao seu cluster no mongosh.

Abra o mongosh em uma janela do terminal e conecte ao seu cluster. Para obter instruções detalhadas sobre a conexão, consulte Conectar via mongosh.

Mudar para o banco de dados sample_mflix.

Execute o seguinte comando no prompt mongosh:

use sample_mflix

Execute uma consulta de faceta do Atlas Search que agrupa os campos de gênero e ano em buckets."

A consulta de amostra usa o seguinte para consultar a coleção:

• próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

• facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

1
db.movies.aggregate([
2
  {
3
    "$searchMeta": {
4
      "index": "facet-tutorial",
5
      "facet": {
6
        "operator": {
7
          "near": {
8
            "path": "released",
9
            "origin": ISODate("1921-11-01T00:00:00.000+00:00"),
10
            "pivot": 7776000000
11
          }
12
        },
13
        "facets": {
14
          "genresFacet": {
15
            "type": "string",
16
            "path": "genres"
17
          },
18
          "yearFacet" : {
19
            "type" : "number",
20
            "path" : "year",
21
            "boundaries" : [1910,1920,1930,1940]
22
          }
23
        }
24
      }
25
    }
26
  }
27
])

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

db.movies.aggregate([
    {
      "$search": {
        "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]
            }
          }
        }
      }
    },
    {
      "$facet": {
        "meta": [
          {"$replaceWith": "$$SEARCH_META"},
          {"$limit": 1}
        ]
      }
    },
    {
      "$set": {
        "meta": {
          "$arrayElemAt": ["$meta", 0]
        }
      }
    }
  ])

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

Conecte-se ao seu cluster no MongoDB Compass.

Abra o MongoDB Compass e conecte-se ao cluster. Para obter instruções detalhadas sobre a conexão, consulte Conectar via Compass.

Use a coleção movies no banco de dados sample_mflix.

Na tela Database, clique no banco de dados sample_mflix e, em seguida, clique na coleção movies.

Execute uma query facet do Atlas Search que agrupa os campos de gênero e ano em buckets.

A query usa as seguintes cláusulas de operador searchMeta:

• próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

• facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

Para executar esta consulta no MongoDB Compass:

1. Clique na aba Aggregations.

2. Clique em Select... e, em seguida, configure cada um dos seguintes estágios do pipeline, selecionando o estágio no menu suspenso e adicionando a consulta para esse estágio. Clique em Add Stage para adicionar estágios adicionais.

   Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

   $searchMeta

   $search com $$SEARCH_META

   estágio do pipeline	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] } } } }

   estágio do pipeline	Query
   $search	{ "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] } } } }
   $facet	{ meta: [ { $replaceWith: "$$SEARCH_META" }, { $limit: 1 } ] }
   $set	{ meta: { $arrayElemAt: ["$meta", 0] } }

   Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado da etapa de pipeline do $set:

   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

Configure e inicialize o projeto .NET/C# para a query.

1. Crie um novo diretório chamado facet-query-example e inicialize seu projeto com o comando dotnet new.

   mkdir facet-query-example
   cd facet-query-example
   dotnet new console

2. Adicione o driver .NET/C# ao seu projeto como uma dependência.

   dotnet add package MongoDB.Driver

Crie a query no arquivo Program.cs.

1. Substitua o conteúdo do arquivo Program.cs pelo seguinte código.

   A consulta de amostra usa o seguinte para consultar a coleção:

   • próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

   • facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

   Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

   $searchMeta

   $search com $$SEARCH_META

   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
   }

   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
   using System;
   7
   8
   public class FacetExample
   9
   {
   10
       private const string MongoConnectionString = "<your-connection-string>";
   11
   12
       public static void Main(string[] args)
   13
       {
   14
           // Register camelCase conventions for document mapping
   15
           var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
   16
           ConventionRegistry.Register("CamelCase", camelCaseConvention, t => true);
   17
   18
           // Connect to your MongoDB Atlas cluster
   19
           var mongoClient = new MongoClient(MongoConnectionString);
   20
           var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
   21
           var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
   22
   23
           // Define the origin date for the `near` operator
   24
           var originDate = new DateTime(1921, 11, 01, 0, 0, 0, DateTimeKind.Utc);
   25
   26
           // Create an array of BsonValues for the number boundaries
   27
           var yearBoundaries = new BsonArray { 1910, 1920, 1930, 1940 };
   28
   29
           // Define the $search stage 
   30
           var searchStage = Builders<MovieDocument>.Search.Facet(
   31
               Builders<MovieDocument>.Search.Near(
   32
                   "released", // The field to search
   33
                   origin: originDate, // Starting date
   34
                   pivot: 7776000000 // Pivot (milliseconds)
   35
               ),
   36
               Builders<MovieDocument>.SearchFacet.String(
   37
                   "genresFacet", // Name of the string facet
   38
                   "genres" // The field to facet on
   39
               ),
   40
               Builders<MovieDocument>.SearchFacet.Number(
   41
                   "yearFacet", // Name of the number facet
   42
                   "year", // The field to facet on
   43
                   yearBoundaries 
   44
               )
   45
           );
   46
   47
           // Step 2: Aggregate pipeline implementationdd
   48
           var pipeline = moviesCollection.Aggregate()
   49
               .Search(searchStage, indexName: "facet-tutorial") 
   50
               .AppendStage<BsonDocument>(new BsonDocument
   51
               {
   52
                   { "$facet", new BsonDocument
   53
                       {
   54
                           { "meta", new BsonArray
   55
                               {
   56
                                   new BsonDocument { { "$replaceWith", "$$SEARCH_META" } },
   57
                                   new BsonDocument { { "$limit", 1 } }
   58
                               }
   59
                           }
   60
                       }
   61
                   }
   62
               })
   63
               .AppendStage<BsonDocument>(new BsonDocument
   64
               {
   65
                   { "$set", new BsonDocument
   66
                       {
   67
                           { "meta", new BsonDocument
   68
                               {
   69
                                   { "$arrayElemAt", new BsonArray { "$meta", 0 } }
   70
                               }
   71
                           }
   72
                       }
   73
                   }
   74
               })
   75
               .ToList();
   76
   77
           // Step 3: Output results
   78
           foreach (var result in pipeline)
   79
           {
   80
               Console.WriteLine(result.ToJson());
   81
           }
   82
       }
   83
   }
   84
   85
   [BsonIgnoreExtraElements]
   86
   public class MovieDocument
   87
   {
   88
       [BsonIgnoreIfDefault]
   89
       public ObjectId Id { get; set; }
   90
       public string[] Genres { get; set; }
   91
       public DateTime Released { get; set; }
   92
       public int Year { get; set; }
   93
   }

2. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

Compile e execute o arquivo Program.cs.

dotnet run facet-query-example.csproj

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

Crie um arquivo denominado facet-query.go.

Copie e cole o seguinte código no arquivo facet-query.go.

O exemplo de código executa as seguintes tarefas:

• Importa pacotes e dependências do mongodb .

• Estabelece uma ligação ao seu cluster Atlas.

• Utiliza as seguintes cláusulas searchMeta para fazer query da collection:

  • próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

  • facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

• Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

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
	// Connects to your Atlas cluster
15
	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string>"))
16
	if err != nil {
17
		panic(err)
18
	}
19
	defer client.Disconnect(context.TODO())
20
21
	// Sets the namespace
22
	collection := client.Database("sample_mflix").Collection("movies")
23
24
	// Defines the pipeline stages
25
	searchStage := bson.D{{Key: "$searchMeta", Value: 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
44
	// Runs the pipeline
45
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage})
46
	if err != nil {
47
		panic(err)
48
	}
49
50
	// Prints the 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
}

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
	// Connects to your Atlas cluster
15
	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string>"))
16
	if err != nil {
17
		panic(err)
18
	}
19
	defer client.Disconnect(context.TODO())
20
21
	// Sets the namespace
22
	collection := client.Database("sample_mflix").Collection("movies")
23
24
	// Defines the pipeline stages
25
	searchStage := bson.D{{Key: "$search", Value: 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
		},
44
	}}}
45
46
	facetStage := bson.D{{Key: "$facet", Value: bson.D{
47
		{Key: "meta", Value: bson.A{
48
			bson.D{{Key: "$replaceWith", Value: "$$SEARCH_META"}},
49
			bson.D{{Key: "$limit", Value: 1}},
50
		}},
51
	}}}
52
	setStage := bson.D{{Key: "$set", Value: bson.D{
53
		{Key: "meta", Value: bson.D{
54
			{Key: "$arrayElemAt", Value: bson.A{"$meta", 0}},
55
		}},
56
	}}}
57
58
	// Runs the pipeline
59
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, facetStage, setStage})
60
	if err != nil {
61
		panic(err)
62
	}
63
64
	// Prints the results
65
	var results []bson.D
66
	if err = cursor.All(context.TODO(), &results); err != nil {
67
		panic(err)
68
	}
69
	for _, result := range results {
70
		fmt.Println(result)
71
	}
72
}

Substitua a string de conexão e salve o arquivo.

Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

Execute uma query facet do Atlas Search que agrupa os campos de gênero e ano em buckets.

go run facet-query.go

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

Certifique-se de que seu CLASSPATH contém as seguintes bibliotecas.

Configure o arquivo para executar a query de faceta do Atlas Search .

1. Crie um arquivo denominado FacetQuery.java.

2. Copie e cole o seguinte código no arquivo FacetQuery.java.

   O exemplo de código executa as seguintes tarefas:

   • Importa pacotes e dependências do mongodb .

   • Estabelece uma ligação ao seu cluster Atlas.

   • Utiliza as seguintes cláusulas searchMeta para fazer query da collection:

     • próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

     • facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

   • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

   Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

   $searchMeta

   $search com $$SEARCH_META

   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
   }

   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.util.Arrays;
   8
   import java.util.List;
   9
   10
   public class FacetQuery {
   11
       public static void main(String[] args) {
   12
           // connect to your Atlas cluster
   13
           String uri = "<CONNECTION-STRING>";
   14
   15
           try (MongoClient mongoClient = MongoClients.create(uri)) {
   16
               // set namespace
   17
               MongoDatabase database = mongoClient.getDatabase("sample_mflix");
   18
               MongoCollection<Document> collection = database.getCollection("movies");
   19
               
   20
               // define pipeline
   21
               List<Document> agg = Arrays.asList(new Document("$search", 
   22
               new Document("index", "facet-tutorial")
   23
                   .append("facet", new Document("operator", new Document("near", new Document("path", "released")
   24
                       .append("origin", new java.util.Date(-1520035200000L))
   25
                       .append("pivot", 7776000000L)))
   26
                   .append("facets", new Document("genresFacet", new Document("type", "string")
   27
                       .append("path", "genres"))
   28
                   .append("yearFacet", new Document("type", "number")
   29
                       .append("path", "year")
   30
                       .append("boundaries", Arrays.asList(1910L, 1920L, 1930L, 1940L)))))), 
   31
               new Document("$facet", new Document("meta", Arrays.asList(new Document("$replaceWith", "$$SEARCH_META"), 
   32
                   new Document("$limit", 1L)))), 
   33
               new Document("$set", new Document("meta", new Document("$arrayElemAt", Arrays.asList("$meta", 0L)))));
   34
               // run pipeline and print results
   35
               collection.aggregate(agg)
   36
                   .forEach(doc -> System.out.println(doc.toJson()));
   37
   38
           }
   39
       }
   40
   }

   Observação

   Para executar o código de exemplo em seu ambiente Maven, adicione o seguinte acima das declarações de importação no seu arquivo:

   pacote com.mongodb.drivers;

3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

Compile e execute o arquivo FacetQuery.java.

javac FacetQuery.java
java FacetQuery

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

Certifique-se de adicionar a seguinte dependência ao seu projeto.

Configure o arquivo para executar uma query de faceta do Atlas Search .

1. Crie um arquivo denominado FacetQuery.kt.

2. Copie e cole o seguinte código no arquivo FacetQuery.kt.

   O exemplo de código executa as seguintes tarefas:

   • Importa pacotes e dependências do mongodb .

   • Estabelece uma ligação ao seu cluster Atlas.

   • Usa o seguinte para consultar a coleção:

   • próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

   • facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

   • Imprime os documentos que correspondem à query da instância AggregateFlow.

   Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

   $searchMeta

   $search com $$SEARCH_META

   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
   }

   1
   import com.mongodb.kotlin.client.coroutine.MongoClient
   2
   import kotlinx.coroutines.flow.collect
   3
   import kotlinx.coroutines.runBlocking
   4
   import org.bson.Document
   5
   import java.time.Instant
   6
   import java.util.Date
   7
   8
   fun main() {
   9
       // Connection URI for your MongoDB Atlas cluster
   10
       val uri = "<connection-string>"
   11
       val mongoClient = MongoClient.create(uri)
   12
   13
       // Set namespace (database and collection)
   14
       val database = mongoClient.getDatabase("sample_mflix")
   15
       val collection = database.getCollection<Document>("movies")
   16
   17
       runBlocking {
   18
           // Define the aggregation pipeline
   19
           val searchStage = Document("\$search", Document("index", "facet-tutorial")
   20
               .append("facet", Document("operator", Document("near", Document("path", "released")
   21
                   // Replace +00:00 with Z
   22
                   .append("origin", Date.from(Instant.parse("1921-11-01T00:00:00.000Z"))) 
   23
                   .append("pivot", 7776000000L)))
   24
                   .append("facets", Document("genresFacet", Document("type", "string")
   25
                       .append("path", "genres"))
   26
                       .append("yearFacet", Document("type", "number").append("path", "year")
   27
                           .append("boundaries", listOf(1910, 1920, 1930, 1940))))))
   28
   29
           val facetStage = Document("\$facet", Document("meta", listOf(
   30
               Document("\$replaceWith", "\$\$SEARCH_META"),
   31
               Document("\$limit", 1)
   32
           )))
   33
   34
           val setStage = Document("\$set", Document("meta", Document("\$arrayElemAt", listOf("\$meta", 0))))
   35
   36
           // Run the aggregation pipeline and print results
   37
           val resultsFlow = collection.aggregate<Document>(
   38
               listOf(searchStage, facetStage, setStage)
   39
           )
   40
   41
           resultsFlow.collect { println(it.toJson()) } // Convert each result to JSON and print
   42
       }
   43
   44
       // Close the MongoDB client
   45
       mongoClient.close()
   46
   }

3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

Execute o arquivo FacetQuery.kt.

Quando você executa o programa FacetQuery.kt no seu IDE, ele imprime o seguinte resultado:

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

Configure o arquivo para executar uma query de faceta do Atlas Search .

1. Crie um arquivo denominado facet-query.js.

2. Copie e cole o seguinte código no arquivo facet-query.js.

   O exemplo de código executa as seguintes tarefas:

   • Importa mongodb, o driver do Node.js da MongoDB.

   • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

   • Utiliza as seguintes cláusulas searchMeta para fazer query da collection:

   • próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

   • facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

   • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

   Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

   $searchMeta

   $search com $$SEARCH_META

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

   1
   const { MongoClient } = require("mongodb");
   2
   3
   // connect to your Atlas cluster
   4
   const uri = "<connection-string>";
   5
       
   6
   const client = new MongoClient(uri);
   7
   8
   async function run() {
   9
       try {
   10
           await client.connect();
   11
   12
           // set namespace
   13
           const database = client.db("sample_mflix");
   14
           const coll = database.collection("movies");
   15
   16
           // define pipeline
   17
           const agg = [
   18
               {
   19
                 '$search': {
   20
                   'index': "facet-tutorial",
   21
                   'facet': {
   22
                     'operator': {
   23
                       'near': {
   24
                         'path': 'released', 
   25
                         'origin': new Date('Tue, 01 Nov 1921 00:00:00 GMT'), 
   26
                         'pivot': 7776000000
   27
                       }
   28
                     }, 
   29
                     'facets': {
   30
                       'genresFacet': {
   31
                         'type': 'string', 
   32
                         'path': 'genres'
   33
                       }, 
   34
                       'yearFacet': {
   35
                         'type': 'number', 
   36
                         'path': 'year', 
   37
                         'boundaries': [1910, 1920, 1930, 1940]
   38
                       }
   39
                     }
   40
                   }
   41
                 }
   42
               }, {
   43
                 '$facet': {
   44
                   'meta': [
   45
                     {
   46
                       '$replaceWith': '$$SEARCH_META'
   47
                     }, {
   48
                       '$limit': 1
   49
                     }
   50
                   ]
   51
                 }
   52
               }, {
   53
                 '$set': {
   54
                   'meta': {
   55
                     '$arrayElemAt': ['$meta', 0]
   56
                   }
   57
                 }
   58
               }
   59
           ];
   60
           // run pipeline
   61
           const result = coll.aggregate(agg);
   62
   63
           // print results
   64
           await result.forEach((doc) => console.dir(JSON.stringify(doc)));
   65
       } finally {
   66
           await client.close();
   67
       }
   68
   }
   69
   run().catch(console.dir);

3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

Execute a query de faceta do Atlas Search .

node facet-query.js

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

Configure o arquivo para executar uma query de faceta do Atlas Search ."

1. Crie um arquivo denominado facet-query.py.

   touch facet-query.py

2. Copie e cole o seguinte código no arquivo facet-query.py.

   O seguinte exemplo de código:

   • Importa pymongo, o driver Python do MongoDB e o módulo dns, que é necessário para conectar pymongo a Atlas usando uma string de conexão da lista de sementes de DNS.

   • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

   • Usa o seguinte para consultar a coleção:

     • próximo para procurar filmes lançados com uma distância de pivot de origin de aproximadamente três meses a partir de 11 de novembro de 1921

     • facets para solicitar o número de filmes em cada gênero no campo genres de array de strings e o número de filmes nos anos 1910 a 1939, inclusive

   • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

   Você pode executar esta consulta usando $searchMeta ou usando $search com a variável de agregação SEARCH_META.

   $searchMeta

   $search com $$SEARCH_META

   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)

   1
   import pymongo
   2
   from datetime import datetime, timezone  # Import timezone for tzinfo=timezone.utc
   3
   4
   # Connect to your Atlas cluster
   5
   client = pymongo.MongoClient("<connection-string>")
   6
   7
   # Define pipeline
   8
   pipeline = [{
   9
       '$search': {
   10
           'index': 'facet-tutorial',
   11
           'facet': {
   12
               'operator': {
   13
                   'near': {
   14
                       'path': 'released',
   15
                       'origin': datetime(1921, 11, 1, 0, 0, 0, tzinfo=timezone.utc),  # Corrected timezone
   16
                       'pivot': 7776000000
   17
                   }
   18
               },
   19
               'facets': {
   20
                   'genresFacet': {
   21
                       'type': 'string', 'path': 'genres'
   22
                   },
   23
                   'yearFacet': {
   24
                       'type': 'number', 'path': 'year', 'boundaries': [1910, 1920, 1930, 1940]
   25
                   }
   26
               }
   27
           }
   28
       }
   29
   }, {
   30
       '$facet': {
   31
           'meta': [
   32
               {'$replaceWith': '$$SEARCH_META'},
   33
               {'$limit': 1}
   34
           ]
   35
       }
   36
   }, {
   37
       '$set': {
   38
           'meta': {'$arrayElemAt': ['$meta', 0]}
   39
       }
   40
   }]
   41
   # Run pipeline
   42
   result = client["sample_mflix"]["movies"].aggregate(pipeline)
   43
   44
   # Print results
   45
   for doc in result:
   46
       print(doc)

3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

Execute o fts| query de faceta que agrupa os campos de gênero e ano em buckets.

python facet-query.py

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