O Atlas Search é uma full-text search incorporada no MongoDB Atlas que oferece uma experiência perfeita e dimensionável para criar funcionalidades de aplicativos baseados em relevância. Este guia de início rápido descreve como começar com as seguintes etapas:
Crie um índice do Atlas Search em uma coleção de amostra.
Crie uma query do Atlas Search para pesquisar a coleção. Você vai aprender como:
Executar uma query básica para pesquisa de um termo em um campo
Utilizar um operador para aprimorar sua pesquisa
Adicionar uma opção de pesquisa para processar seus resultados
Tempo necessário: 15 minutos
Observação
criar um índice do atlas search
Índice de pesquisa do Atlas é uma estrutura de dados que categoriza os dados em um formato facilmente pesquisável. Ele mapeia termos a documentos que contêm esses termos para habilitar a recuperação rápida de documentos no momento da consulta.
Você deve configurar um Índice de pesquisa do Atlas para consultar dados usando o Atlas Search. Recomendamos que você indexe os campos que usa regularmente para classificar ou filtrar seus dados.
Para aprender mais, veja Gerenciar índices de pesquisa do Atlas.
Nesta seção, você cria um Índice de pesquisa do Atlas na coleção de filmes de amostra. Você pode criar o Índice de pesquisa do Atlas em um cluster Atlas ou em uma implantação hospedada em seu computador local.
Configure seu cluster do Atlas.
Crie uma conta Atlas gratuita ou entre em uma conta existente.
Se você ainda não tem um cluster do Atlas, crie um cluster M0 gratuito. Para saber mais sobre como criar um cluster do Atlas, consulte Criar um cluster.
IMPORTANTE: se estiver trabalhando com um cluster existente, você deve ter acesso
Project Data Access Admin
ou superior ao projeto Atlas.Se você criar um novo cluster, terá as permissões necessárias por padrão.
Você pode criar apenas um cluster gratuito
M0
por projeto.Se você ainda não carregou o conjunto de dados de amostra para este início rápido em seu cluster, carregue o banco de dados de amostra
sample_mflix
em seu cluster.Se você já carregou o conjunto de dados
sample_mflix
, verifique se o banco de dadossample_mflix
contém a coleçãoembedded_movies
. Se não for o caso, descarte o banco de dadossample_mflix
e recarregue o conjunto de dadossample_mflix
.O carregamento do conjunto de dados de amostra pode levar vários minutos para ser concluído.
Na barra lateral esquerda, clique em Atlas Search. Escolha seu cluster no menu Select data source e clique em Go to Atlas Search.
Crie o índice Atlas Search .
➤ Use o menu suspenso Selecione seu idioma para definir o cliente para este tutorial.
Quando os dados de amostra terminarem de carregar, clique em Create Search Index.
Faça as seguintes seleções na página e clique em Next.
Search Type
Selecione o tipo de índice Atlas Search.
Index Name and Data Source
Especifique as seguintes informações:
Index Name:
default
Database and Collection:
sample_mflix
movies
Configuration Method
For a guided experience, select Visual Editor.To edit the raw index definition, select JSON Editor.Defina o índice.
A seguinte definição de índice indexa dinamicamente os campos na coleção
movies
.Revise a definição de índice
"default"
para a collectionmovies
.Revise a definição do índice.
A definição do seu índice deve ser semelhante a esta:
{ "mappings": { "dynamic": true } } A definição de índice acima indexa dinamicamente os campos de tipos suportados em cada documento na collection
movies
.Clique em Next.
Clique em Create Search Index.
Aguarde o índice para concluir a formação.
O índice deve levar cerca de um minuto para ser criado. Enquanto está se formando, a coluna Status mostra
Build in Progress
. Quando terminar de se formar, a coluna Status mostraráActive
.
Conecte-se ao cluster do Atlas usando
mongosh
.Abra o
mongosh
em uma janela do terminal e conecte-se ao seu cluster do Atlas. Para obter instruções detalhadas sobre como conectar, consulte Conectar-se via mongosh.Alterne para o banco de dados que contém a collection para a qual você deseja criar o índice.
Exemplo
use sample_mflix switched to db sample_mflix Execute o método
db.collection.createSearchIndex()
para criar o índice.db.movies.createSearchIndex( "default", { mappings: { dynamic: true } } ) default
Conecte-se ao seu cluster do Atlas via MongoDB Compass.
Abra o Compass e conecte-se ao Atlas cluster. Para obter instruções detalhadas, consulte Conectar-se a um cluster via Compass.
Configure e inicialize o projeto .NET/C#.
# Create a new directory and initialize the project mkdir atlas-search-quickstart && cd atlas-search-quickstart dotnet new console # Add the MongoDB .NET/C# Driver to your project dotnet add package MongoDB.Driver Para instruções de instalação mais detalhadas, consulte a documentação do driver C# do MongoDB.
Defina o índice.
Cole o seguinte código no arquivo
Program.cs
.Program.cs1 using MongoDB.Bson; 2 using MongoDB.Driver; 3 4 // connect to your Atlas deployment 5 var uri = "<connection-string>"; 6 7 var client = new MongoClient(uri); 8 9 var db = client.GetDatabase("sample_mflix"); 10 var collection = db.GetCollection<BsonDocument>("movies"); 11 12 // define your Atlas Search index 13 var index = new CreateSearchIndexModel( 14 "default", new BsonDocument 15 { 16 { "mappings", new BsonDocument 17 { 18 { "dynamic", true } 19 } 20 } 21 }); 22 23 var result = collection.SearchIndexes.CreateOne(index); 24 Console.WriteLine(result); Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
dotnet run Program.cs default
Configure e inicialize o módulo Go.
# Create a new directory and initialize the project mkdir atlas-search-quickstart && cd atlas-search-quickstart go mod init atlas-search-quickstart # Add the MongoDB Go Driver to your project go get go.mongodb.org/mongo-driver/v2/mongo Para instruções de instalação mais detalhadas, consulte a documentação do driver Go do MongoDB.
Defina o índice.
Cole o seguinte código em um arquivo chamado
create-index.go
.create-index.go1 package main 2 3 import ( 4 "context" 5 "log" 6 7 "go.mongodb.org/mongo-driver/v2/bson" 8 "go.mongodb.org/mongo-driver/v2/mongo" 9 "go.mongodb.org/mongo-driver/v2/mongo/options" 10 ) 11 12 func main() { 13 ctx := context.Background() 14 15 // Replace the placeholder with your Atlas connection string 16 const uri = "<connection-string>" 17 18 // Connect to your Atlas cluster 19 clientOptions := options.Client().ApplyURI(uri) 20 client, err := mongo.Connect(clientOptions) 21 if err != nil { 22 log.Fatalf("failed to connect to the server: %v", err) 23 } 24 defer func() { _ = client.Disconnect(ctx) }() 25 26 // Set the namespace 27 coll := client.Database("sample_mflix").Collection("movies") 28 29 // Define a simple Atlas Search index 30 indexName := "default" 31 32 // Create the default definition for search index 33 definition := bson.D{{"mappings", bson.D{{"dynamic", true}}}} 34 indexModel := mongo.SearchIndexModel{ 35 Definition: definition, 36 Options: options.SearchIndexes().SetName(indexName), 37 } 38 39 // Create the index 40 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel) 41 if err != nil { 42 log.Fatalf("failed to create the search index: %v", err) 43 } 44 log.Println("New search index named " + searchIndexName + " is building.") 45 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
go run create-index.go
Adicione a versão do driver Java 4.11 ou superior como uma dependência no seu projeto Java. Selecione uma das seguintes abas, dependendo do seu gerenciador de pacotes:
Se você estiver utilizando o Maven, adicione as seguintes dependências à array
dependencies
no arquivopom.xml
do seu projeto:pom.xml<dependencies> <!-- MongoDB Java Sync Driver v4.11.0 or later --> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongodb-driver-sync</artifactId> <version>[4.11.0,)</version> </dependency> </dependencies> Se você estiver usando o Gradle, adicione o seguinte à array
dependencies
no arquivobuild.gradle
do seu projeto:build.gradledependencies { // MongoDB Java Sync Driver v4.11.0 or later implementation 'org.mongodb:mongodb-driver-sync:[4.11.0,)' } Execute seu gerenciador de pacote para instalar as dependências em seu projeto.
Para obter instruções de instalação mais detalhadas e compatibilidade de versões, consulte a documentação do MongoDB Java Driver.
Defina o índice.
Cole o exemplo a seguir em um arquivo chamado
CreateIndex.java
.CreateIndex.java1 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 public class CreateIndex { 8 public static void main(String[] args) { 9 // connect to your Atlas cluster 10 String uri = "<connection-string>"; 11 12 try (MongoClient mongoClient = MongoClients.create(uri)) { 13 // set namespace 14 MongoDatabase database = mongoClient.getDatabase("sample_mflix"); 15 MongoCollection<Document> collection = database.getCollection("movies"); 16 17 Document index = new Document("mappings", 18 new Document("dynamic", true)); 19 collection.createSearchIndex(index); 20 } 21 } 22 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true
Instale o driver de corrotina Kotlin do MongoDB.
Crie um novo projeto Kotlin e instale a documentação do driver MongoDB Kotlin corrotina.
Defina o índice.
Crie um arquivo denominado
CreateIndex.kt
. Copie e cole o seguinte código no arquivo.CreateIndex.kt1 import com.mongodb.MongoException 2 import com.mongodb.client.model.SearchIndexModel 3 import com.mongodb.client.model.SearchIndexType 4 import com.mongodb.kotlin.client.coroutine.MongoClient 5 import kotlinx.coroutines.runBlocking 6 import org.bson.Document 7 8 fun main() { 9 // Replace the placeholder with your MongoDB deployment's connection string 10 val uri = "<connection-string>" 11 val mongoClient = MongoClient.create(uri) 12 val database = mongoClient.getDatabase("sample_mflix") 13 val collection = database.getCollection<Document>("movies") 14 val searchIdx = Document( 15 "mappings", 16 Document("dynamic", true) 17 ) 18 runBlocking { 19 try { 20 val result = collection.createSearchIndex("default", searchIdx) 21 println("Index created: $result") 22 } catch (e: MongoException) { 23 println("Failed to create search index: ${e.message}") 24 } finally { 25 mongoClient.close() 26 } 27 } 28 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Execute o arquivo
CreateIndex.kt
no seu IDE.
Inicialize seu projeto Node.js.
# Create a new directory and initialize the project mkdir atlas-search-quickstart && cd atlas-search-quickstart npm init -y # Add the MongoDB Node.js Driver to your project npm install mongodb Para instruções detalhadas de instalação, consulte a documentação do Driver de nó do MongoDB.
Defina o índice.
Cole o seguinte código em um arquivo chamado
create-index.js
.create-index.js1 const { MongoClient } = require("mongodb"); 2 3 // connect to your Atlas deployment 4 const uri = 5 "<connection-string>"; 6 7 const client = new MongoClient(uri); 8 9 async function run() { 10 try { 11 12 // set namespace 13 const database = client.db("sample_mflix"); 14 const collection = database.collection("movies"); 15 16 // define your Atlas Search index 17 const index = { 18 name: "default", 19 definition: { 20 /* search index definition fields */ 21 "mappings": { 22 "dynamic": true 23 } 24 } 25 } 26 27 // run the helper method 28 const result = await collection.createSearchIndex(index); 29 console.log(result); 30 } finally { 31 await client.close(); 32 } 33 } 34 35 run().catch(console.dir); Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
node create-index.js default
Instale o driver Python do MongoDB.
pip install pymongo Para instruções detalhadas de instalação, veja Driver Python do MongoDB (PyMongo).
Defina o índice.
Cole o seguinte código em um arquivo chamado
create_index.py
.create_index.py1 from pymongo import MongoClient 2 from pymongo.operations import SearchIndexModel 3 4 # connect to your Atlas deployment 5 uri = "<connection-string>" 6 client = MongoClient(uri) 7 8 # set namespace 9 database = client["sample_mflix"] 10 collection = database["movies"] 11 12 # define your Atlas Search index 13 search_index_model = SearchIndexModel( 14 definition={ 15 "mappings": { 16 "dynamic": True 17 }, 18 }, 19 name="default", 20 ) 21 22 # create the index 23 result = collection.create_search_index(model=search_index_model) 24 print(result) Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
python create_index.py default
Inicialize seu projeto Rust .
# Create a new Rust project cargo new atlas-search-quickstart && cd atlas-search-quickstart Adicione as seguintes dependências ao seu arquivo
Cargo.toml
:[dependencies] serde = "1.0" futures = "0.3" tokio = {version = "1.0", features = ["full"]} [dependencies.mongodb] version = "3.0" Para obter instruções de instalação detalhadas, consulte o guia de download e instalação do driver do MongoDB Rust.
Defina o índice.
Cole o seguinte código em
src/main.rs
.src/main.rs1 use mongodb::bson::{doc, Document}; 2 use mongodb::{Client, Collection, SearchIndexModel, SearchIndexType}; 3 4 5 async fn main() -> mongodb::error::Result<()> { 6 // Connects to your Atlas deployment 7 let uri = 8 "<connection-string>"; 9 10 let client = Client::with_uri_str(uri).await?; 11 12 // Sets the namespace 13 let collection: Collection<Document> = client 14 .database("sample_mflix") 15 .collection("movies"); 16 17 // Defines your Atlas Search index 18 let index = doc! { 19 "mappings": doc! { 20 "dynamic": true 21 } 22 }; 23 24 let idx_model = SearchIndexModel::builder() 25 .definition(index) 26 .name("search_idx".to_string()) 27 .index_type(SearchIndexType::Search) 28 .build(); 29 30 // Runs the helper method 31 let result = collection.create_search_index(idx_model).await?; 32 println!("{}", result); 33 34 Ok(()) 35 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
cargo run search_idx
Instale as dependências.
Instale o Atlas CLI.
Se você usar Homebrew, poderá executar o seguinte comando em seu terminal:
brew install mongodb-atlas-cli Para obter instruções de instalação em outros sistemas operacionais, consulte Instalar a Atlas CLI
Instale o docker.
O Docker requer uma conexão de rede para extrair e armazenar em cache imagens do MongoDB .
Para MacOS ou Windows, instale o Docker Desktop v4.31+.
Para Linux, instale o Docker Engine v27.0+.
Para RHEL, você também pode usar o Podman v5.0+.
Instale as Database Tools MongoDB.
Você deve instalar as Ferramentas de Banco de Dados de Linha de Comando do MongoDB para acessar o comando
mongorestore
, que você usará para carregar os dados de amostra.
Configure sua implantação local do Atlas.
Se você não tem uma conta existente do Atlas, execute o
atlas setup
em seu terminal ou crie uma nova conta.Execute
atlas deployments setup
e siga as solicitações para criar uma implantação local. Quando solicitado a se conectar à implantação, selecioneskip
.Para obter instruções detalhadas, consulte Criar uma implementação local do Atlas.
Carregue os dados de amostra.
Execute o seguinte comando no seu terminal para baixar os dados de amostra:
curl https://atlas-education.s3.amazonaws.com/sampledata.archive -o sampledata.archive Execute o seguinte comando para carregar os dados em sua implantação, substituindo
<port-number>
pela porta em que você está hospedando a implantação:mongorestore --archive=sampledata.archive --port=<port-number>
Crie o índice Atlas Search .
➤ Use o menu suspenso Selecione seu idioma para definir o cliente para este tutorial.
Quando os dados de amostra terminarem de carregar, clique em Create Search Index.
Faça as seguintes seleções na página e clique em Next.
Search Type
Selecione o tipo de índice Atlas Search.
Index Name and Data Source
Especifique as seguintes informações:
Index Name:
default
Database and Collection:
sample_mflix
movies
Configuration Method
For a guided experience, select Visual Editor.To edit the raw index definition, select JSON Editor.Defina o índice.
A seguinte definição de índice indexa dinamicamente os campos na coleção
movies
.Revise a definição de índice
"default"
para a collectionmovies
.Revise a definição do índice.
A definição do seu índice deve ser semelhante a esta:
{ "mappings": { "dynamic": true } } A definição de índice acima indexa dinamicamente os campos de tipos suportados em cada documento na collection
movies
.Clique em Next.
Clique em Create Search Index.
Aguarde o índice para concluir a formação.
O índice deve levar cerca de um minuto para ser criado. Enquanto está se formando, a coluna Status mostra
Build in Progress
. Quando terminar de se formar, a coluna Status mostraráActive
.
Conecte-se ao cluster do Atlas usando
mongosh
.Abra o
mongosh
em uma janela do terminal e conecte-se ao seu cluster do Atlas. Para obter instruções detalhadas sobre como conectar, consulte Conectar-se via mongosh.Alterne para o banco de dados que contém a collection para a qual você deseja criar o índice.
Exemplo
use sample_mflix switched to db sample_mflix Execute o método
db.collection.createSearchIndex()
para criar o índice.db.movies.createSearchIndex( "default", { mappings: { dynamic: true } } ) default
Conecte-se ao seu cluster do Atlas via MongoDB Compass.
Abra o Compass e conecte-se ao Atlas cluster. Para obter instruções detalhadas, consulte Conectar-se a um cluster via Compass.
Crie o índice Atlas Search .
Clique na aba Indexes e selecione Search Indexes.
Clique em Create Index para abrir a caixa de diálogo de criação de índice.
Especifique um nome para o índice.
O índice do Atlas Search é nomeado
default
por padrão. Se você mantiver esse nome, seu índice será o índice de pesquisa padrão para qualquer consulta do Atlas Search que não especifique uma opçãoindex
diferente nos operadores. Se você estiver criando vários índices, recomendamos que mantenha uma convenção de nomenclatura consistente e descritiva em todos os seus índices.Especifique a definição do índice do Atlas Search JSON.
1 { 2 "mappings": { 3 "dynamic": true|false, 4 "fields": { 5 "<field-name>": { 6 "type": "string" 7 } 8 } 9 } 10 } Clique em Create Search Index.
Configure e inicialize o projeto .NET/C#.
# Create a new directory and initialize the project mkdir atlas-search-quickstart && cd atlas-search-quickstart dotnet new console # Add the MongoDB .NET/C# Driver to your project dotnet add package MongoDB.Driver Para instruções de instalação mais detalhadas, consulte a documentação do driver C# do MongoDB.
Defina o índice.
Cole o seguinte código no arquivo
Program.cs
.Program.cs1 using MongoDB.Bson; 2 using MongoDB.Driver; 3 4 // connect to your Atlas deployment 5 var uri = "<connection-string>"; 6 7 var client = new MongoClient(uri); 8 9 var db = client.GetDatabase("sample_mflix"); 10 var collection = db.GetCollection<BsonDocument>("movies"); 11 12 // define your Atlas Search index 13 var index = new CreateSearchIndexModel( 14 "default", new BsonDocument 15 { 16 { "mappings", new BsonDocument 17 { 18 { "dynamic", true } 19 } 20 } 21 }); 22 23 var result = collection.SearchIndexes.CreateOne(index); 24 Console.WriteLine(result); Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
dotnet run Program.cs default
Configure e inicialize o módulo Go.
# Create a new directory and initialize the project mkdir atlas-search-quickstart && cd atlas-search-quickstart go mod init atlas-search-quickstart # Add the MongoDB Go Driver to your project go get go.mongodb.org/mongo-driver/v2/mongo Para instruções de instalação mais detalhadas, consulte a documentação do driver Go do MongoDB.
Defina o índice.
Cole o seguinte código em um arquivo chamado
create-index.go
.create-index.go1 package main 2 3 import ( 4 "context" 5 "log" 6 7 "go.mongodb.org/mongo-driver/v2/bson" 8 "go.mongodb.org/mongo-driver/v2/mongo" 9 "go.mongodb.org/mongo-driver/v2/mongo/options" 10 ) 11 12 func main() { 13 ctx := context.Background() 14 15 // Replace the placeholder with your Atlas connection string 16 const uri = "<connection-string>" 17 18 // Connect to your Atlas cluster 19 clientOptions := options.Client().ApplyURI(uri) 20 client, err := mongo.Connect(clientOptions) 21 if err != nil { 22 log.Fatalf("failed to connect to the server: %v", err) 23 } 24 defer func() { _ = client.Disconnect(ctx) }() 25 26 // Set the namespace 27 coll := client.Database("sample_mflix").Collection("movies") 28 29 // Define a simple Atlas Search index 30 indexName := "default" 31 32 // Create the default definition for search index 33 definition := bson.D{{"mappings", bson.D{{"dynamic", true}}}} 34 indexModel := mongo.SearchIndexModel{ 35 Definition: definition, 36 Options: options.SearchIndexes().SetName(indexName), 37 } 38 39 // Create the index 40 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel) 41 if err != nil { 42 log.Fatalf("failed to create the search index: %v", err) 43 } 44 log.Println("New search index named " + searchIndexName + " is building.") 45 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
go run create-index.go
Adicione a versão do driver Java 4.11 ou superior como uma dependência no seu projeto Java. Selecione uma das seguintes abas, dependendo do seu gerenciador de pacotes:
Se você estiver utilizando o Maven, adicione as seguintes dependências à array
dependencies
no arquivopom.xml
do seu projeto:pom.xml<dependencies> <!-- MongoDB Java Sync Driver v4.11.0 or later --> <dependency> <groupId>org.mongodb</groupId> <artifactId>mongodb-driver-sync</artifactId> <version>[4.11.0,)</version> </dependency> </dependencies> Se você estiver usando o Gradle, adicione o seguinte à array
dependencies
no arquivobuild.gradle
do seu projeto:build.gradledependencies { // MongoDB Java Sync Driver v4.11.0 or later implementation 'org.mongodb:mongodb-driver-sync:[4.11.0,)' } Execute seu gerenciador de pacote para instalar as dependências em seu projeto.
Para obter instruções de instalação mais detalhadas e compatibilidade de versões, consulte a documentação do MongoDB Java Driver.
Defina o índice.
Cole o exemplo a seguir em um arquivo chamado
CreateIndex.java
.CreateIndex.java1 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 public class CreateIndex { 8 public static void main(String[] args) { 9 // connect to your Atlas cluster 10 String uri = "<connection-string>"; 11 12 try (MongoClient mongoClient = MongoClients.create(uri)) { 13 // set namespace 14 MongoDatabase database = mongoClient.getDatabase("sample_mflix"); 15 MongoCollection<Document> collection = database.getCollection("movies"); 16 17 Document index = new Document("mappings", 18 new Document("dynamic", true)); 19 collection.createSearchIndex(index); 20 } 21 } 22 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true
Instale o driver de corrotina Kotlin do MongoDB.
Crie um novo projeto Kotlin e instale a documentação do driver MongoDB Kotlin corrotina.
Defina o índice.
Crie um arquivo denominado
CreateIndex.kt
. Copie e cole o seguinte código no arquivo.CreateIndex.kt1 import com.mongodb.MongoException 2 import com.mongodb.client.model.SearchIndexModel 3 import com.mongodb.client.model.SearchIndexType 4 import com.mongodb.kotlin.client.coroutine.MongoClient 5 import kotlinx.coroutines.runBlocking 6 import org.bson.Document 7 8 fun main() { 9 // Replace the placeholder with your MongoDB deployment's connection string 10 val uri = "<connection-string>" 11 val mongoClient = MongoClient.create(uri) 12 val database = mongoClient.getDatabase("sample_mflix") 13 val collection = database.getCollection<Document>("movies") 14 val searchIdx = Document( 15 "mappings", 16 Document("dynamic", true) 17 ) 18 runBlocking { 19 try { 20 val result = collection.createSearchIndex("default", searchIdx) 21 println("Index created: $result") 22 } catch (e: MongoException) { 23 println("Failed to create search index: ${e.message}") 24 } finally { 25 mongoClient.close() 26 } 27 } 28 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Execute o arquivo
CreateIndex.kt
no seu IDE.
Inicialize seu projeto Node.js.
# Create a new directory and initialize the project mkdir atlas-search-quickstart && cd atlas-search-quickstart npm init -y # Add the MongoDB Node.js Driver to your project npm install mongodb Para instruções detalhadas de instalação, consulte a documentação do Driver de nó do MongoDB.
Defina o índice.
Cole o seguinte código em um arquivo chamado
create-index.js
.create-index.js1 const { MongoClient } = require("mongodb"); 2 3 // connect to your Atlas deployment 4 const uri = 5 "<connection-string>"; 6 7 const client = new MongoClient(uri); 8 9 async function run() { 10 try { 11 12 // set namespace 13 const database = client.db("sample_mflix"); 14 const collection = database.collection("movies"); 15 16 // define your Atlas Search index 17 const index = { 18 name: "default", 19 definition: { 20 /* search index definition fields */ 21 "mappings": { 22 "dynamic": true 23 } 24 } 25 } 26 27 // run the helper method 28 const result = await collection.createSearchIndex(index); 29 console.log(result); 30 } finally { 31 await client.close(); 32 } 33 } 34 35 run().catch(console.dir); Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
node create-index.js default
Instale o driver Python do MongoDB.
pip install pymongo Para instruções detalhadas de instalação, veja Driver Python do MongoDB (PyMongo).
Defina o índice.
Cole o seguinte código em um arquivo chamado
create_index.py
.create_index.py1 from pymongo import MongoClient 2 from pymongo.operations import SearchIndexModel 3 4 # connect to your Atlas deployment 5 uri = "<connection-string>" 6 client = MongoClient(uri) 7 8 # set namespace 9 database = client["sample_mflix"] 10 collection = database["movies"] 11 12 # define your Atlas Search index 13 search_index_model = SearchIndexModel( 14 definition={ 15 "mappings": { 16 "dynamic": True 17 }, 18 }, 19 name="default", 20 ) 21 22 # create the index 23 result = collection.create_search_index(model=search_index_model) 24 print(result) Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
python create_index.py default
Inicialize seu projeto Rust .
# Create a new Rust project cargo new atlas-search-quickstart && cd atlas-search-quickstart Adicione as seguintes dependências ao seu arquivo
Cargo.toml
:[dependencies] serde = "1.0" futures = "0.3" tokio = {version = "1.0", features = ["full"]} [dependencies.mongodb] version = "3.0" Para obter instruções de instalação detalhadas, consulte o guia de download e instalação do driver do MongoDB Rust.
Defina o índice.
Cole o seguinte código em
src/main.rs
.src/main.rs1 use mongodb::bson::{doc, Document}; 2 use mongodb::{Client, Collection, SearchIndexModel, SearchIndexType}; 3 4 5 async fn main() -> mongodb::error::Result<()> { 6 // Connects to your Atlas deployment 7 let uri = 8 "<connection-string>"; 9 10 let client = Client::with_uri_str(uri).await?; 11 12 // Sets the namespace 13 let collection: Collection<Document> = client 14 .database("sample_mflix") 15 .collection("movies"); 16 17 // Defines your Atlas Search index 18 let index = doc! { 19 "mappings": doc! { 20 "dynamic": true 21 } 22 }; 23 24 let idx_model = SearchIndexModel::builder() 25 .definition(index) 26 .name("search_idx".to_string()) 27 .index_type(SearchIndexType::Search) 28 .build(); 29 30 // Runs the helper method 31 let result = collection.create_search_index(idx_model).await?; 32 println!("{}", result); 33 34 Ok(()) 35 } Substitua
<connection-string>
pela string de conexão para seu Atlas cluster ou sistema local do Atlas .Sua string de conexão deve usar o seguinte formato:
mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net Para saber mais, consulte Conectar a um cluster via drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Para saber mais, consulte Connection strings.
Observação
Certifique-se de que a string de conexão inclua as credenciais do usuário do banco de dados . Para saber mais sobre como encontrar sua string de conexão, consulte Conectar-se a um cluster por meio de drivers.
Sua string de conexão deve usar o seguinte formato:
mongodb://localhost:<port-number>/?directConnection=true Crie o índice.
cargo run search_idx
Construir uma Consulta de Pesquisa Atlas
As queries do Atlas Search assumem a forma de um estágio de pipeline de agregação . Você utiliza o Atlas Search principalmente com o estágio $search
, que deve ser o primeiro estágio no pipeline de consulta. Você também pode usar esta fase em conjunto com outras fases no seu pipeline.
Quando você executa uma consulta no Atlas Search, o Atlas Search utiliza o índice de pesquisa para localizar e recuperar dados relevantes da coleção. O Atlas Search também fornece o estágio $searchMeta
, múltiplos sub-pipelines e vários operadores de query e coletores que você pode usar para refinar ainda mais os resultados da pesquisa.
Para aprender mais, consulte Queries e índices.
Nesta seção, você executa queries na coleção indexada.
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.
Cole a seguinte consulta no Query Editor e depois clique no botão Search no 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 ... ...
Observação
O Search Tester pode não exibir todos os campos nos documentos que ele retorna. Para exibir todos os campos, incluindo o campo que você especifica no caminho da query, expanda o documento nos resultados.
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.
Cole a seguinte consulta no Query Editor e depois clique no botão Search no 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"] ... ...
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.
Copie e cole a seguinte consulta no Query Editor e, em seguida, clique no botão Search no 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 ... ...
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
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" }
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
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' } ]
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
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') } ]
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Para executar esta consulta no MongoDB Compass:
Clique na aba Aggregations.
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.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
estágio do pipelineQuery$search
{ "text": { "query": "baseball", "path": "plot" } } $limit
3 $project
{ "_id": 0, "title": 1, "plot": 1, }
Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado da etapa de pipeline do $project
:
{ "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" }
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
Atualize as seguintes etapas do pipeline no MongoDB Compass:
estágio do pipeline | Query | ||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
| ||||||||||||||||||||
|
|
Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado da etapa de pipeline do $project
:
{ "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" }
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
Atualize as seguintes etapas do pipeline no MongoDB Compass:
estágio do pipeline | Query | |||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
| |||||||||||||||||||||||
|
|
Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado da etapa de pipeline do $project
:
[ { 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 } ]
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Substitua o conteúdo do arquivo
Program.cs
pelo seguinte código.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
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 [ ]41 public class MovieDocument 42 { 43 [ ]44 public ObjectId Id { get; set; } 45 public string Plot { get; set; } 46 public string Title { get; set; } 47 } Especifique o
<connection-string>
, depois execute a consulta:dotnet run Program.cs { "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" }
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique seu arquivo
Program.cs
com o seguinte código.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
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 [ ]47 public class MovieDocument 48 { 49 [ ]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 } Especifique o
<connection-string>
, depois execute a consulta:dotnet run Program.cs { "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"] }
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique seu arquivo
Program.cs
com o seguinte código.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
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 [ ]54 public class MovieDocument 55 { 56 [ ]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 } Especifique o
<connection-string>
, depois execute a consulta:dotnet run Program.cs { "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" } }
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Crie um novo arquivo chamado
run-query.go
e cole o código a seguir.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
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 } Especifique o
<connection-string>
, depois execute a consulta:go run run-query.go {"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"}
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique
run-query.go
para usar uma query composta.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
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 } Especifique o
<connection-string>
, depois execute a consulta:go run run-query.go {"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"}
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique
run-query.go
para adicionar a opção de classificação.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
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 } Especifique o
<connection-string>
, depois execute a consulta:go run run-query.go {"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"}}}
Instale as dependências.
Certifique-se de que seu CLASSPATH
contém as seguintes bibliotecas.
| 4.11.0 ou uma versão superior |
| 4.11.0 ou uma versão superior |
| 1.7.30 ou uma versão superior |
Para obter instruções de instalação mais detalhadas e compatibilidade de versões, consulte a documentação do MongoDB Java Driver.
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Crie um novo arquivo chamado
RunQuery.java
e cole o código a seguir.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
1 import java.util.Arrays; 2 import java.util.List; 3 import static com.mongodb.client.model.Aggregates.limit; 4 import static com.mongodb.client.model.Aggregates.project; 5 import static com.mongodb.client.model.Projections.excludeId; 6 import static com.mongodb.client.model.Projections.fields; 7 import static com.mongodb.client.model.Projections.include; 8 import com.mongodb.client.MongoClient; 9 import com.mongodb.client.MongoClients; 10 import com.mongodb.client.MongoCollection; 11 import com.mongodb.client.MongoDatabase; 12 import org.bson.Document; 13 14 public class RunQuery { 15 public static void main( String[] args ) { 16 String uri = "<connection-string>"; 17 18 try (MongoClient mongoClient = MongoClients.create(uri)) { 19 MongoDatabase database = mongoClient.getDatabase("sample_mflix"); 20 MongoCollection<Document> collection = database.getCollection("movies"); 21 22 Document textQuery = new Document("query", "baseball").append("path","plot"); 23 24 Document searchStage = new Document("$search", 25 new Document("index", "default") 26 .append("text", textQuery)); 27 28 collection.aggregate(Arrays.asList( 29 searchStage, 30 limit(3), 31 project(fields(excludeId(), include("title", "plot")))) 32 ).forEach(doc -> System.out.println(doc.toJson())); 33 } 34 } 35 } 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:
package com.mongodb.drivers; Especifique o
<connection-string>
, depois execute a consulta:javac RunQuery.java java RunQuery {"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"}
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique
RunQuery.java
para usar uma query composta.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
1 import java.util.Arrays; 2 import java.util.List; 3 import static com.mongodb.client.model.Aggregates.limit; 4 import static com.mongodb.client.model.Aggregates.project; 5 import static com.mongodb.client.model.Projections.excludeId; 6 import static com.mongodb.client.model.Projections.fields; 7 import static com.mongodb.client.model.Projections.include; 8 import com.mongodb.client.MongoClient; 9 import com.mongodb.client.MongoClients; 10 import com.mongodb.client.MongoCollection; 11 import com.mongodb.client.MongoDatabase; 12 import org.bson.Document; 13 14 public class RunQuery { 15 public static void main( String[] args ) { 16 String uri = "<connection-string>"; 17 18 try (MongoClient mongoClient = MongoClients.create(uri)) { 19 MongoDatabase database = mongoClient.getDatabase("sample_mflix"); 20 MongoCollection<Document> collection = database.getCollection("movies"); 21 22 Document compound = new Document("must", Arrays.asList( 23 new Document("text", new Document("query", "baseball").append("path", "plot")))) 24 .append("mustNot", Arrays.asList( 25 new Document("text", new Document("query", Arrays.asList("Comedy", "Romance")).append("path", "genres")))); 26 27 Document searchStage = new Document("$search", 28 new Document("index", "default") 29 .append("compound", compound)); 30 31 collection.aggregate(Arrays.asList( 32 searchStage, 33 limit(3), 34 project(fields(excludeId(), include("title", "plot", "genres")))) 35 ).forEach(doc -> System.out.println(doc.toJson())); 36 } 37 } 38 } Especifique o
<connection-string>
, depois execute a consulta:javac RunQuery.java java RunQuery {"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"}
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique
RunQuery.java
para adicionar a opção de classificação.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
1 import java.util.Arrays; 2 import java.util.List; 3 import static com.mongodb.client.model.Aggregates.limit; 4 import static com.mongodb.client.model.Aggregates.project; 5 import static com.mongodb.client.model.Projections.excludeId; 6 import static com.mongodb.client.model.Projections.fields; 7 import static com.mongodb.client.model.Projections.include; 8 import com.mongodb.client.MongoClient; 9 import com.mongodb.client.MongoClients; 10 import com.mongodb.client.MongoCollection; 11 import com.mongodb.client.MongoDatabase; 12 import org.bson.Document; 13 14 public class RunQuery { 15 public static void main( String[] args ) { 16 String uri = "<connection-string>"; 17 18 try (MongoClient mongoClient = MongoClients.create(uri)) { 19 MongoDatabase database = mongoClient.getDatabase("sample_mflix"); 20 MongoCollection<Document> collection = database.getCollection("movies"); 21 22 Document compound = new Document("must", Arrays.asList( 23 new Document("text", new Document("query", "baseball").append("path", "plot")))) 24 .append("mustNot", Arrays.asList( 25 new Document("text", new Document("query", Arrays.asList("Comedy", "Romance")).append("path", "genres")))); 26 27 Document searchStage = new Document("$search", 28 new Document("index", "default") 29 .append("compound", compound) 30 .append("sort", new Document("released", -1))); 31 32 collection.aggregate(Arrays.asList( 33 searchStage, 34 limit(3), 35 project(fields(excludeId(), include("title", "plot", "genres", "released")))) 36 ).forEach(doc -> System.out.println(doc.toJson())); 37 } 38 } 39 } Especifique o
<connection-string>
, depois execute a consulta:javac RunQuery.java java RunQuery {"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": "2014-05-16T00:00:00Z"}} {"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": "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 ...", "genres": ["Drama"], "title": "Calloused Hands", "released": {"$date": "2013-03-03T00:00:00Z"}}
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Crie um novo arquivo chamado
RunQuery.kt
e cole o código a seguir.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
1 import com.mongodb.client.model.Aggregates.limit 2 import com.mongodb.client.model.Aggregates.project 3 import com.mongodb.client.model.Filters.eq 4 import com.mongodb.client.model.Projections.* 5 import com.mongodb.kotlin.client.coroutine.MongoClient 6 import kotlinx.coroutines.runBlocking 7 import org.bson.Document 8 9 fun main() { 10 // establish connection and set namespace 11 val uri = "<connection-string>" 12 val mongoClient = MongoClient.create(uri) 13 val database = mongoClient.getDatabase("sample_mflix") 14 val collection = database.getCollection<Document>("movies") 15 16 runBlocking { 17 // define query 18 val agg = Document("query", "baseball").append("path","plot") 19 20 // run query and print results 21 val resultsFlow = collection.aggregate<Document>( 22 listOf( 23 eq("\$search", eq("text", agg)), 24 limit(3), 25 project(fields(excludeId(), include("title", "plot"))) 26 ) 27 ) 28 resultsFlow.collect { println(it) } 29 } 30 mongoClient.close() 31 } Especifique o
<connection-string>
, depois execute a consulta:Ao executar o programa
RunQuery.kt
no seu IDE, ele imprime os seguintes documentos:Document{{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}} Document{{plot=Babe Ruth becomes a baseball legend but is unheroic to those who know him., genres=[Biography, Drama, Sport], title=The Babe}} Document{{plot=Dominican baseball star Miguel "Sugar" Santos is recruited to play in the U.S. minor-leagues., genres=[Drama, Sport], title=Sugar}}
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique
RunQuery.kt
para usar uma query composta.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
1 import com.mongodb.client.model.Aggregates.limit 2 import com.mongodb.client.model.Aggregates.project 3 import com.mongodb.client.model.Filters.eq 4 import com.mongodb.client.model.Projections.* 5 import com.mongodb.kotlin.client.coroutine.MongoClient 6 import kotlinx.coroutines.runBlocking 7 import org.bson.Document 8 9 fun main() { 10 // establish connection and set namespace 11 val uri = "<connection-string>" 12 val mongoClient = MongoClient.create(uri) 13 val database = mongoClient.getDatabase("sample_mflix") 14 val collection = database.getCollection<Document>("movies") 15 16 runBlocking { 17 // define query 18 val compoundQuery = Document( 19 "must", listOf( 20 Document("text", Document("query", "baseball") 21 .append("path", "plot")) 22 ) 23 ) 24 .append( 25 "mustNot", listOf( 26 Document("text", Document("query", listOf("Comedy", "Romance")) 27 .append("path", "genres")) 28 ) 29 ) 30 31 // run query and print results 32 val resultsFlow = collection.aggregate<Document>( 33 listOf( 34 eq("\$search", eq("compound", compoundQuery)), 35 limit(3), 36 project(fields( 37 excludeId(), 38 include("title", "plot", "genres") 39 )) 40 ) 41 ) 42 resultsFlow.collect { println(it) } 43 } 44 mongoClient.close() 45 } Especifique o
<connection-string>
, depois execute a consulta.Ao executar o programa
RunQuery.kt
no seu IDE, ele imprime os seguintes documentos:Document{{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}} Document{{plot=Babe Ruth becomes a baseball legend but is unheroic to those who know him., genres=[Biography, Drama, Sport], title=The Babe}} Document{{plot=Dominican baseball star Miguel "Sugar" Santos is recruited to play in the U.S. minor-leagues., genres=[Drama, Sport], title=Sugar}}
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique
RunQuery.kt
para adicionar a opção de classificação.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
1 import com.mongodb.client.model.Aggregates.limit 2 import com.mongodb.client.model.Aggregates.project 3 import com.mongodb.client.model.Filters.eq 4 import com.mongodb.client.model.Projections.* 5 import com.mongodb.kotlin.client.coroutine.MongoClient 6 import kotlinx.coroutines.runBlocking 7 import org.bson.Document 8 9 fun main() { 10 // establish connection and set namespace 11 val uri = "<connection-string>" 12 val mongoClient = MongoClient.create(uri) 13 val database = mongoClient.getDatabase("sample_mflix") 14 val collection = database.getCollection<Document>("movies") 15 16 runBlocking { 17 // define query 18 val compoundQuery = Document( 19 "must", listOf( 20 Document("text", Document("query", "baseball") 21 .append("path", "plot")) 22 ) 23 ) 24 .append( 25 "mustNot", listOf( 26 Document("text", Document("query", listOf("Comedy", "Romance")) 27 .append("path", "genres")) 28 ) 29 ) 30 31 // sort configuration 32 val sortConfig = Document("released", -1) 33 34 // run query and print results 35 val resultsFlow = collection.aggregate<Document>( 36 listOf( 37 Document("\$search", Document("compound", compoundQuery).append("sort", sortConfig)), 38 limit(3), 39 project(fields( 40 excludeId(), 41 include("title", "plot", "genres", "released") 42 )) 43 ) 44 ) 45 resultsFlow.collect { println(it) } 46 } 47 mongoClient.close() 48 } Especifique o
<connection-string>
, depois execute a consulta:Ao executar o programa
RunQuery.kt
no seu IDE, ele imprime os seguintes documentos:Document{{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=Thu May 15 19:00:00 CDT 2014}} Document{{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=Wed Feb 26 18:00:00 CST 2014}} Document{{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=Sat Mar 02 18:00:00 CST 2013}}
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Crie um novo arquivo chamado
run-query.js
e cole o código a seguir.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
1 const { MongoClient } = require("mongodb"); 2 3 async function main() { 4 // Replace the placeholder with your connection string 5 const uri = "<connection-string>"; 6 const client = new MongoClient(uri); 7 8 try { 9 await client.connect(); 10 const database = client.db("sample_mflix"); 11 const movies = database.collection("movies"); 12 13 const query = [ 14 { 15 $search: 16 { 17 text: { 18 query: "baseball", 19 path: "plot", 20 }, 21 } 22 }, 23 { 24 $limit: 3, 25 }, 26 { 27 $project: { 28 _id: 0, 29 title: 1, 30 plot: 1, 31 }, 32 }, 33 ]; 34 35 const cursor = movies.aggregate(query); 36 await cursor.forEach(doc => console.log(doc)); 37 } finally { 38 await client.close(); 39 } 40 } 41 42 main().catch(console.error); Especifique o
<connection-string>
, depois execute a consulta:node run-query.js { 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' }
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique
run-query.js
para usar uma query composta.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
1 const { MongoClient } = require("mongodb"); 2 3 async function main() { 4 // Replace the placeholder with your connection string 5 const uri = "<connection-string>"; 6 const client = new MongoClient(uri); 7 8 try { 9 await client.connect(); 10 const database = client.db("sample_mflix"); 11 const movies = database.collection("movies"); 12 13 const query = [ 14 { 15 $search: { 16 compound: { 17 must: [ 18 { 19 text: { 20 query: "baseball", 21 path: "plot", 22 } 23 } 24 ], 25 mustNot: [ 26 { 27 text: { 28 query: ["Comedy", "Romance"], 29 path: "genres", 30 }, 31 } 32 ] 33 } 34 } 35 }, 36 { 37 $limit: 3 38 }, 39 { 40 $project: { 41 _id: 0, 42 title: 1, 43 plot: 1, 44 genres: 1 45 } 46 } 47 ]; 48 49 const cursor = movies.aggregate(query); 50 await cursor.forEach(doc => console.log(doc)); 51 } finally { 52 await client.close(); 53 } 54 } 55 56 main().catch(console.error); Especifique o
<connection-string>
, depois execute a consulta:node run-query.js { 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' }
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique
run-query.js
para adicionar a opção de classificação.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
1 const { MongoClient } = require("mongodb"); 2 3 async function main() { 4 // Replace the placeholder with your connection string 5 const uri = "<connection-string>"; 6 const client = new MongoClient(uri); 7 8 try { 9 await client.connect(); 10 const database = client.db("sample_mflix"); 11 const movies = database.collection("movies"); 12 13 const query = [ 14 { 15 $search: { 16 compound: { 17 must: [ 18 { 19 text: { 20 query: "baseball", 21 path: "plot", 22 } 23 } 24 ], 25 mustNot: [ 26 { 27 text: { 28 query: ["Comedy", "Romance"], 29 path: "genres", 30 } 31 } 32 ] 33 }, 34 sort: { 35 released: -1 36 } 37 } 38 }, 39 { 40 $limit: 3 41 }, 42 { 43 $project: { 44 _id: 0, 45 title: 1, 46 plot: 1, 47 genres: 1, 48 released: 1 49 } 50 } 51 ]; 52 53 const cursor = movies.aggregate(query); 54 await cursor.forEach(doc => console.log(doc)); 55 } finally { 56 await client.close(); 57 } 58 } 59 60 main().catch(console.error); Especifique o
<connection-string>
, depois execute a consulta:node run-query.js { 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.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: 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: 2013-03-03T00:00:00.000Z }
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Crie um novo arquivo chamado
run_query.py
e cole o código a seguir.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
1 import pymongo 2 3 client = pymongo.MongoClient('<connection-string>') 4 result = client['sample_mflix']['movies'].aggregate([ 5 { 6 '$search': 7 { 8 'text': { 9 'query': 'baseball', 10 'path': 'plot' 11 } 12 } 13 }, 14 { 15 '$limit': 3 16 }, 17 { 18 '$project': { 19 '_id': 0, 20 'title': 1, 21 'plot': 1 22 } 23 } 24 ]) 25 26 for i in result: 27 print(i) Especifique o
<connection-string>
, depois execute a consulta:python run_query.py {'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'}
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique
run_query.py
para usar uma query composta.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
1 import pymongo 2 3 client = pymongo.MongoClient('<connection-string>') 4 result = client['sample_mflix']['movies'].aggregate([ 5 { 6 '$search': { 7 'compound': { 8 'must': [ 9 { 10 'text': { 11 'query': 'baseball', 12 'path': 'plot' 13 } 14 } 15 ], 16 'mustNot': [ 17 { 18 'text': { 19 'query': ['Comedy', 'Romance'], 20 'path': 'genres' 21 } 22 } 23 ] 24 } 25 } 26 }, 27 { 28 '$limit': 3 29 }, 30 { 31 '$project': { 32 '_id': 0, 33 'title': 1, 34 'plot': 1, 35 'genres': 1 36 } 37 } 38 ]) 39 40 for i in result: 41 print(i) Especifique o
<connection-string>
, depois execute a consulta:python run_query.py {'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'}
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique
run_query.py
para adicionar a opção de classificação.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
1 import pymongo 2 3 client = pymongo.MongoClient('<connection-string>') 4 result = client['sample_mflix']['movies'].aggregate([ 5 { 6 '$search': { 7 'compound': { 8 'must': [ 9 { 10 'text': { 11 'query': 'baseball', 12 'path': 'plot' 13 } 14 } 15 ], 16 'mustNot': [ 17 { 18 'text': { 19 'query': ['Comedy', 'Romance'], 20 'path': 'genres' 21 } 22 } 23 ] 24 }, 25 'sort': { 26 'released': -1 27 } 28 } 29 }, 30 { 31 '$limit': 3 32 }, 33 { 34 '$project': { 35 '_id': 0, 36 'title': 1, 37 'plot': 1, 38 'genres': 1, 39 'released': 1 40 } 41 } 42 ]) 43 44 for i in result: 45 print(i) Especifique o
<connection-string>
, depois execute a consulta:python run_query.py {'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': datetime.datetime(2014, 5, 16, 0, 0)} {'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': datetime.datetime(2014, 2, 27, 0, 0)} {'plot': "12-year-old Josh is a mixed race boy and a promising baseball player...", 'genres': ['Drama'], 'title': 'Calloused Hands', 'released': datetime.datetime(2013, 3, 3, 0, 0)}
Execute uma consulta básica.
Execute uma consulta básica $search
usando o operador de texto.
Crie um novo arquivo chamado
src/main.rs
e cole o código a seguir.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
eplot
.
1 use mongodb::bson::{doc, DateTime}; 2 use mongodb::{Client, Collection}; 3 use serde::{Deserialize, Serialize}; 4 use futures::TryStreamExt; 5 6 7 struct Movie { 8 title: Option<String>, 9 plot: Option<String>, 10 genres: Option<Vec<String>>, 11 released: Option<DateTime>, 12 } 13 14 15 async fn main() -> mongodb::error::Result<()> { 16 // Replace the placeholder with your connection string 17 let uri = "<connection-string>"; 18 let client = Client::with_uri_str(uri).await?; 19 20 let collection: Collection<Movie> = client 21 .database("sample_mflix") 22 .collection("movies"); 23 24 let query = vec![ 25 doc! { 26 "$search": { 27 "index": "search_idx", 28 "text": { 29 "query": "baseball", 30 "path": "plot" 31 } 32 } 33 }, 34 doc! { 35 "$limit": 3 36 }, 37 doc! { 38 "$project": { 39 "_id": 0, 40 "title": 1, 41 "plot": 1 42 } 43 } 44 ]; 45 46 println!("Executing aggregation query..."); 47 let mut results = movies.aggregate(query).await?; 48 49 println!("Processing results..."); 50 while let Some(doc) = results.try_next().await? { 51 let movie: Movie = mongodb::bson::from_document(doc)?; 52 println!("{{ \"title\": {:?}, \"plot\": {:?} }}", 53 movie.title.unwrap_or_else(|| "N/A".to_string()), 54 movie.plot.unwrap_or_else(|| "N/A".to_string())); 55 } 56 Ok(()) 57 } Especifique o
<connection-string>
, depois execute a consulta:cargo run { "title": "The Benchwarmers", "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": "Ed", "plot": "A trained chimpanzee plays third base for a minor-league baseball team." } { "title": "Little Big League", "plot": "A young boy is bequeathed the ownership of a professional baseball team." }
Refinar sua pesquisa.
O Atlas Search fornece vários operadores que você pode usar para criar consultas complexas e recuperar resultados mais específicos para o seu caso de uso. Atualize sua query $search
para usar o operador composto para combinar vários operadores em uma única query.
Modifique
src/main.rs
para usar uma query composta.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.$limit e $project os estágios para retornar apenas 3 documentos e os campos
title
,plot
egenres
.
1 use mongodb::bson::{doc, DateTime, from_document}; 2 use mongodb::{Client, Collection}; 3 use serde::{Deserialize, Serialize}; 4 use futures::TryStreamExt; 5 6 7 struct Movie { 8 title: Option<String>, 9 plot: Option<String>, 10 genres: Option<Vec<String>>, 11 released: Option<DateTime>, 12 } 13 14 15 async fn main() -> mongodb::error::Result<()> { 16 // Replace the placeholder with your connection string 17 let uri = "<connection-string>"; 18 let client = Client::with_uri_str(uri).await?; 19 20 let query = vec![ 21 doc! { 22 "$search": { 23 "index": "search_idx", 24 "compound": { 25 "must": [ 26 { 27 "text": { 28 "query": "baseball", 29 "path": "plot" 30 } 31 } 32 ], 33 "mustNot": [ 34 { 35 "text": { 36 "query": ["Comedy", "Romance"], 37 "path": "genres" 38 } 39 } 40 ] 41 } 42 } 43 }, 44 doc! { 45 "$limit": 3 46 }, 47 doc! { 48 "$project": { 49 "_id": 0, 50 "title": 1, 51 "plot": 1, 52 "genres": 1 53 } 54 } 55 ]; 56 57 let movies: Collection<Movie> = client 58 .database("sample_mflix") 59 .collection("movies"); 60 61 let mut result = collection.aggregate(query).await?; 62 63 while let Some(doc) = result.try_next().await? { 64 let movie: Movie = from_document(doc)?; 65 println!(" Title: '{}'", movie.title.unwrap_or_else(|| "N/A".to_string())); 66 println!(" Plot: '{}'", movie.plot.unwrap_or_else(|| "N/A".to_string())); 67 println!(" Genres: {:?}", movie.genres.unwrap_or_default()); 68 println!(); 69 } 70 Ok(()) 71 } Especifique o
<connection-string>
, depois execute a consulta:cargo run Title: 'The Babe' Plot: 'Babe Ruth becomes a baseball legend but is unheroic to those who know him.' Genres: ["Biography", "Drama", "Sport"] Title: 'The Pride of the Yankees' Plot: 'The story of the life and career of the famed baseball player, Lou Gehrig.' Genres: ["Biography", "Drama", "Family"] Title: 'Sugar' Plot: 'Dominican baseball star Miguel "Sugar" Santos is recruited to play in the U.S. minor-leagues.' Genres: ["Drama", "Sport"]
Processar seus resultados.
O Atlas Search oferece várias opções de pesquisa que você pode usar para processar ainda mais os resultados da sua consulta do Atlas Search. Adicione a opção de ordenar à sua consulta para exibir os resultados em uma ordem específica.
Modifique
src/main.rs
para adicionar a opção de classificação.Esta query tem os seguintes critérios de pesquisa:
O campo
plot
deve conter a palavrabaseball
.O campo
genres
não pode conterComedy
ouRomance
.Classifique os resultados pelo campo de data de
released
em ordem decrescente. O Atlas Search retorna primeiro os filmes mais recentes.$limit e $project os estágio para retornar apenas 3 documentos e os campos
title
,plot
,genres
ereleased
.
1 use mongodb::bson::{doc, DateTime, from_document}; 2 use mongodb::{Client, Collection}; 3 use serde::{Deserialize, Serialize}; 4 use futures::TryStreamExt; 5 6 7 struct Movie { 8 title: Option<String>, 9 plot: Option<String>, 10 genres: Option<Vec<String>>, 11 released: Option<DateTime>, 12 } 13 14 15 async fn main() -> mongodb::error::Result<()> { 16 // Replace the placeholder with your connection string 17 let uri = "<connection-string>"; 18 let client = Client::with_uri_str(uri).await?; 19 20 let query = vec![ 21 doc! { 22 "$search": { 23 "index": "search_idx", 24 "compound": { 25 "must": [ 26 { 27 "text": { 28 "query": "baseball", 29 "path": "plot" 30 } 31 } 32 ], 33 "mustNot": [ 34 { 35 "text": { 36 "query": ["Comedy", "Romance"], 37 "path": "genres" 38 } 39 } 40 ] 41 }, 42 "sort": { 43 "released": -1 44 } 45 } 46 }, 47 doc! { 48 "$limit": 3 49 }, 50 doc! { 51 "$project": { 52 "_id": 0, 53 "title": 1, 54 "plot": 1, 55 "genres": 1, 56 "released": 1 57 } 58 } 59 ]; 60 61 let movies: Collection<Movie> = client 62 .database("sample_mflix") 63 .collection("movies"); 64 let mut cursor = movies.aggregate(query).await?; 65 while let Some(doc) = cursor.try_next().await? { 66 let movie: Movie = from_document(doc)?; 67 println!("Title: {:?}", movie.title.unwrap_or_else(|| "N/A".to_string())); 68 println!("Plot: {:?}", movie.plot.unwrap_or_else(|| "N/A".to_string())); 69 println!("Genres: {:?}", movie.genres.unwrap_or_default()); 70 if let Some(released) = movie.released { 71 println!("Released: {:?}", released); 72 } 73 println!(); 74 } 75 76 Ok(()) 77 } Especifique o
<connection-string>
, depois execute a consulta:cargo run Title: "Million Dollar Arm" Plot: "A sports agent stages an unconventional recruitment strategy to get talented Indian cricket players to play Major League Baseball." Genres: ["Biography", "Drama", "Sport"] Released: DateTime(2014-05-16 0:00:00.0 +00:00:00) Title: "Kano" Plot: "A Taiwanese high school baseball team travels to Japan in 1931 to compete in a national tournament." Genres: ["Biography", "Drama", "History"] Released: DateTime(2014-02-27 0:00:00.0 +00:00:00) Title: "Calloused Hands" 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"] Released: DateTime(2013-03-03 0:00:00.0 +00:00:00)
Continuar aprendendo
Executar consultas de preenchimento automático e correspondência parcial
Você pode usar o Atlas Search para executar consultas de preenchimento automático e parciais que retornam resultados para palavras parciais. Isso é útil para recuperar resultados com precisão crescente à medida que mais caracteres são inseridos no campo de pesquisa do seu aplicativo. Você deve indexar os campos como o tipo autocompletar do Atlas Search para usar o operador autocompletar.
Para começar, consulte Como executar consultas no Atlas Search com Autocompletar e Correspondência Parcial.
Resultados da pesquisa de grupo com facetas
Você pode usar o Atlas Search para executar queries de faceta que agrupam resultados de pesquisa por string, data ou valores numéricos. Você deve criar um índice com uma definição de faceta para usar o coletor facet
(Operador de Atlas Search).
Para começar, consulte Como Utilizar Facetas com o Atlas Search.
Use o Atlas Search Playground
Use o Playground do Atlas Search para experimentar diferentes recursos do Atlas Search configurando índices de pesquisa e executando queries sem uma conta, cluster ou coleção do Atlas.
Para saber mais, consulte Playground do Atlas Search.
Aprenda com um Curso
Para saber mais sobre o Atlas Search, você pode fazer a Unidade 1 do Curso Atlas Search na Universidade MongoDB. A unidade de 2.25 horas inclui uma visão geral do Atlas Search e aulas sobre como criar índices do Atlas Search , usar $search
com diferentes operadores e gerar facetas de pesquisa.
Aprenda assistindo
Você também pode assistir aos seguintes vídeos para aprender mais sobre o Atlas Search:
Assista a uma visão geral do Atlas e do Atlas Search e comece a configurar o Atlas Search para seus dados. O vídeo demonstra como carregar dados de amostra no cluster, criar um índice do Atlas Search e executar uma query de amostra utilizando Search Tester e Data Explorer.
Duração: 10 Minutos
Acompanhe o seguinte vídeo para saber como configurar seu índice de pesquisa do Atlas Search e executar queries a partir de sua aplicação.
Duração: 7 Minutos
Acompanhe o seguinte tutorial em vídeo que demonstra como criar consultas do Atlas Search para um aplicativo de demonstração do Restaurant Finder, que também está disponível em www.atlassearchrestaurants.com.
Duração: 20 Minutos