Join us Sept 17 at .local NYC! Use code WEB50 to save 50% on tickets. Learn more >
MongoDB Event
Menu Docs
Página inicial do Docs
/
Atlas
/

Início rápido do Atlas Search

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:

  1. Crie um índice do Atlas Search em uma coleção de amostra.

  2. 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

Este tutorial inclui exemplos para uma seleção de clientes. Para todos os clientes compatíveis, consulte as páginas de Índices e Consultas.

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.

1
  1. Crie uma conta Atlas gratuita ou entre em uma conta existente.

  2. 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.

  3. 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 dados sample_mflix contém a coleção embedded_movies. Se não for o caso, descarte o banco de dados sample_mflix e recarregue o conjunto de dados sample_mflix.

    O carregamento do conjunto de dados de amostra pode levar vários minutos para ser concluído.

  4. Na barra lateral esquerda, clique em Atlas Search. Escolha seu cluster no menu Select data source e clique em Go to Atlas Search.

2

➤ Use o menu suspenso Selecione seu idioma para definir o cliente para este tutorial.


  1. Quando os dados de amostra terminarem de carregar, clique em Create Search Index.

  2. 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.
  3. 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 collection movies.

    1. 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.

    2. Clique em Next.

  4. Clique em Create Search Index.

  5. 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.

  1. 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.

  2. 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
  3. Execute o método db.collection.createSearchIndex() para criar o índice.

    db.movies.createSearchIndex(
    "default",
    { mappings: { dynamic: true } }
    )
    default
1

Abra o Compass e conecte-se ao Atlas cluster. Para obter instruções detalhadas, consulte Conectar-se a um cluster via Compass.

2

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

3
  1. Clique na aba Indexes e selecione Search Indexes.

  2. Clique em Create Index para abrir a caixa de diálogo de criação de índice.

  3. Use o nome e a definição do índice padrão.

    1{
    2 mappings: {
    3 dynamic: true,
    4 },
    5}
  4. Clique em Create Search Index.

  1. 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.

  2. Defina o índice.

    Cole o seguinte código no arquivo Program.cs.

    Program.cs
    1using MongoDB.Bson;
    2using MongoDB.Driver;
    3
    4// connect to your Atlas deployment
    5var uri = "<connection-string>";
    6
    7var client = new MongoClient(uri);
    8
    9var db = client.GetDatabase("sample_mflix");
    10var collection = db.GetCollection<BsonDocument>("movies");
    11
    12// define your Atlas Search index
    13var index = new CreateSearchIndexModel(
    14 "default", new BsonDocument
    15 {
    16 { "mappings", new BsonDocument
    17 {
    18 { "dynamic", true }
    19 }
    20 }
    21 });
    22
    23var result = collection.SearchIndexes.CreateOne(index);
    24Console.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
  3. Crie o índice.

    dotnet run Program.cs
    default
  1. 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.

  2. Defina o índice.

    Cole o seguinte código em um arquivo chamado create-index.go.

    create-index.go
    1package main
    2
    3import (
    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
    12func 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
  3. Crie o índice.

    go run create-index.go
  1. 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 arquivo pom.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 arquivo build.gradle do seu projeto:

    build.gradle
    dependencies {
    // MongoDB Java Sync Driver v4.11.0 or later
    implementation 'org.mongodb:mongodb-driver-sync:[4.11.0,)'
    }
  2. 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.

  3. Defina o índice.

    Cole o exemplo a seguir em um arquivo chamado CreateIndex.java.

    CreateIndex.java
    1import com.mongodb.client.MongoClient;
    2import com.mongodb.client.MongoClients;
    3import com.mongodb.client.MongoCollection;
    4import com.mongodb.client.MongoDatabase;
    5import org.bson.Document;
    6
    7public 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
  1. Instale o driver de corrotina Kotlin do MongoDB.

    Crie um novo projeto Kotlin e instale a documentação do driver MongoDB Kotlin corrotina.

  2. Defina o índice.

    Crie um arquivo denominado CreateIndex.kt. Copie e cole o seguinte código no arquivo.

    CreateIndex.kt
    1import com.mongodb.MongoException
    2import com.mongodb.client.model.SearchIndexModel
    3import com.mongodb.client.model.SearchIndexType
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun 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
  3. Execute o arquivo CreateIndex.kt no seu IDE.

  1. 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.

  2. Defina o índice.

    Cole o seguinte código em um arquivo chamado create-index.js.

    create-index.js
    1const { MongoClient } = require("mongodb");
    2
    3// connect to your Atlas deployment
    4const uri =
    5 "<connection-string>";
    6
    7const client = new MongoClient(uri);
    8
    9async 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
    35run().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
  3. Crie o índice.

    node create-index.js
    default
  1. Instale o driver Python do MongoDB.

    pip install pymongo

    Para instruções detalhadas de instalação, veja Driver Python do MongoDB (PyMongo).

  2. Defina o índice.

    Cole o seguinte código em um arquivo chamado create_index.py.

    create_index.py
    1from pymongo import MongoClient
    2from pymongo.operations import SearchIndexModel
    3
    4# connect to your Atlas deployment
    5uri = "<connection-string>"
    6client = MongoClient(uri)
    7
    8# set namespace
    9database = client["sample_mflix"]
    10collection = database["movies"]
    11
    12# define your Atlas Search index
    13search_index_model = SearchIndexModel(
    14 definition={
    15 "mappings": {
    16 "dynamic": True
    17 },
    18 },
    19 name="default",
    20)
    21
    22# create the index
    23result = collection.create_search_index(model=search_index_model)
    24print(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
  3. Crie o índice.

    python create_index.py
    default
  1. 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.

  2. Defina o índice.

    Cole o seguinte código em src/main.rs.

    src/main.rs
    1use mongodb::bson::{doc, Document};
    2use mongodb::{Client, Collection, SearchIndexModel, SearchIndexType};
    3
    4#[tokio::main]
    5async 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
  3. Crie o índice.

    cargo run
    search_idx
1
  1. 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

  2. Instale o docker.

    O Docker requer uma conexão de rede para extrair e armazenar em cache imagens do MongoDB .

  3. 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.

2
  1. Se você não tem uma conta existente do Atlas, execute o atlas setup em seu terminal ou crie uma nova conta.

  2. Execute atlas deployments setup e siga as solicitações para criar uma implantação local. Quando solicitado a se conectar à implantação, selecione skip.

    Para obter instruções detalhadas, consulte Criar uma implementação local do Atlas.

3
  1. 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
  2. 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>
4

➤ Use o menu suspenso Selecione seu idioma para definir o cliente para este tutorial.


  1. Quando os dados de amostra terminarem de carregar, clique em Create Search Index.

  2. 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.
  3. 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 collection movies.

    1. 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.

    2. Clique em Next.

  4. Clique em Create Search Index.

  5. 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.

  1. 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.

  2. 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
  3. Execute o método db.collection.createSearchIndex() para criar o índice.

    db.movies.createSearchIndex(
    "default",
    { mappings: { dynamic: true } }
    )
    default
1

Abra o Compass e conecte-se ao Atlas cluster. Para obter instruções detalhadas, consulte Conectar-se a um cluster via Compass.

2

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

3
  1. Clique na aba Indexes e selecione Search Indexes.

  2. Clique em Create Index para abrir a caixa de diálogo de criação de índice.

  3. 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ção index 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.

  4. 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}
  5. Clique em Create Search Index.

  1. 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.

  2. Defina o índice.

    Cole o seguinte código no arquivo Program.cs.

    Program.cs
    1using MongoDB.Bson;
    2using MongoDB.Driver;
    3
    4// connect to your Atlas deployment
    5var uri = "<connection-string>";
    6
    7var client = new MongoClient(uri);
    8
    9var db = client.GetDatabase("sample_mflix");
    10var collection = db.GetCollection<BsonDocument>("movies");
    11
    12// define your Atlas Search index
    13var index = new CreateSearchIndexModel(
    14 "default", new BsonDocument
    15 {
    16 { "mappings", new BsonDocument
    17 {
    18 { "dynamic", true }
    19 }
    20 }
    21 });
    22
    23var result = collection.SearchIndexes.CreateOne(index);
    24Console.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
  3. Crie o índice.

    dotnet run Program.cs
    default
  1. 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.

  2. Defina o índice.

    Cole o seguinte código em um arquivo chamado create-index.go.

    create-index.go
    1package main
    2
    3import (
    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
    12func 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
  3. Crie o índice.

    go run create-index.go
  1. 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 arquivo pom.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 arquivo build.gradle do seu projeto:

    build.gradle
    dependencies {
    // MongoDB Java Sync Driver v4.11.0 or later
    implementation 'org.mongodb:mongodb-driver-sync:[4.11.0,)'
    }
  2. 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.

  3. Defina o índice.

    Cole o exemplo a seguir em um arquivo chamado CreateIndex.java.

    CreateIndex.java
    1import com.mongodb.client.MongoClient;
    2import com.mongodb.client.MongoClients;
    3import com.mongodb.client.MongoCollection;
    4import com.mongodb.client.MongoDatabase;
    5import org.bson.Document;
    6
    7public 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
  1. Instale o driver de corrotina Kotlin do MongoDB.

    Crie um novo projeto Kotlin e instale a documentação do driver MongoDB Kotlin corrotina.

  2. Defina o índice.

    Crie um arquivo denominado CreateIndex.kt. Copie e cole o seguinte código no arquivo.

    CreateIndex.kt
    1import com.mongodb.MongoException
    2import com.mongodb.client.model.SearchIndexModel
    3import com.mongodb.client.model.SearchIndexType
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun 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
  3. Execute o arquivo CreateIndex.kt no seu IDE.

  1. 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.

  2. Defina o índice.

    Cole o seguinte código em um arquivo chamado create-index.js.

    create-index.js
    1const { MongoClient } = require("mongodb");
    2
    3// connect to your Atlas deployment
    4const uri =
    5 "<connection-string>";
    6
    7const client = new MongoClient(uri);
    8
    9async 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
    35run().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
  3. Crie o índice.

    node create-index.js
    default
  1. Instale o driver Python do MongoDB.

    pip install pymongo

    Para instruções detalhadas de instalação, veja Driver Python do MongoDB (PyMongo).

  2. Defina o índice.

    Cole o seguinte código em um arquivo chamado create_index.py.

    create_index.py
    1from pymongo import MongoClient
    2from pymongo.operations import SearchIndexModel
    3
    4# connect to your Atlas deployment
    5uri = "<connection-string>"
    6client = MongoClient(uri)
    7
    8# set namespace
    9database = client["sample_mflix"]
    10collection = database["movies"]
    11
    12# define your Atlas Search index
    13search_index_model = SearchIndexModel(
    14 definition={
    15 "mappings": {
    16 "dynamic": True
    17 },
    18 },
    19 name="default",
    20)
    21
    22# create the index
    23result = collection.create_search_index(model=search_index_model)
    24print(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
  3. Crie o índice.

    python create_index.py
    default
  1. 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.

  2. Defina o índice.

    Cole o seguinte código em src/main.rs.

    src/main.rs
    1use mongodb::bson::{doc, Document};
    2use mongodb::{Client, Collection, SearchIndexModel, SearchIndexType};
    3
    4#[tokio::main]
    5async 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
  3. Crie o índice.

    cargo run
    search_idx

Nesta seção, você executa queries na coleção indexada.

1

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

  1. Na barra lateral, clique em Atlas Search sob o título Services.

    Se você não tiver clusters, clique em Create cluster para criar um. Para saber mais, consulte Criar um cluster.

  2. Se o seu projeto tiver vários clusters, selecione o cluster que deseja usar no menu suspenso Select cluster e clique em Go to Atlas Search.

    A página Atlas Search é exibida.

  1. Clique no botão Browse Collections para o seu cluster.

  2. Expanda o banco de dados e selecione a coleção.

  3. Clique na guia Search Indexes da coleção.

    A página Atlas Search é exibida.

  1. Clique no nome do seu cluster.

  2. Clique na aba Atlas Search.

    A página Atlas Search é exibida.

2

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

3

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

4

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 palavra baseball.

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.

5

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 palavra baseball.

  • O campo genres não pode conter Comedy ou Romance.

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"]
...
...
6

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 palavra baseball.

  • O campo genres não pode conter Comedy ou Romance.

  • 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
...
...
1

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 palavra baseball.

  • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

1db.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"
}
2

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 palavra baseball.

  • O campo genres não pode conter Comedy ou Romance.

  • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

1db.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'
}
]
3

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 palavra baseball.

  • O campo genres não pode conter Comedy ou Romance.

  • 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 e released.

1db.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')
}
]
1

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

2

Execute uma consulta básica $search usando o operador de texto.

Para executar esta consulta no MongoDB Compass:

  1. Clique na aba Aggregations.

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

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

    estágio do pipeline
    Query

    $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"
}
3

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 palavra baseball.

  • O campo genres não pode conter Comedy ou Romance.

  • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

Atualize as seguintes etapas do pipeline no MongoDB Compass:

estágio do pipeline
Query

$search

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

$project

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

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

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 palavra baseball.

  • O campo genres não pode conter Comedy ou Romance.

  • 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 e released.

Atualize as seguintes etapas do pipeline no MongoDB Compass:

estágio do pipeline
Query

$search

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

$project

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

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

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

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

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

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

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

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

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

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

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.

  1. Modifique run-query.go para usar uma query composta.

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

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

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

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

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

junit

4.11.0 ou uma versão superior

mongodb-driver-sync

4.11.0 ou uma versão superior

slf4j-log4j12

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.

2

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

    1import java.util.Arrays;
    2import java.util.List;
    3import static com.mongodb.client.model.Aggregates.limit;
    4import static com.mongodb.client.model.Aggregates.project;
    5import static com.mongodb.client.model.Projections.excludeId;
    6import static com.mongodb.client.model.Projections.fields;
    7import static com.mongodb.client.model.Projections.include;
    8import com.mongodb.client.MongoClient;
    9import com.mongodb.client.MongoClients;
    10import com.mongodb.client.MongoCollection;
    11import com.mongodb.client.MongoDatabase;
    12import org.bson.Document;
    13
    14public 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;
  2. 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"}
3

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.

  1. Modifique RunQuery.java para usar uma query composta.

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

    1import java.util.Arrays;
    2import java.util.List;
    3import static com.mongodb.client.model.Aggregates.limit;
    4import static com.mongodb.client.model.Aggregates.project;
    5import static com.mongodb.client.model.Projections.excludeId;
    6import static com.mongodb.client.model.Projections.fields;
    7import static com.mongodb.client.model.Projections.include;
    8import com.mongodb.client.MongoClient;
    9import com.mongodb.client.MongoClients;
    10import com.mongodb.client.MongoCollection;
    11import com.mongodb.client.MongoDatabase;
    12import org.bson.Document;
    13
    14public 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}
  2. 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"}
4

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

    1import java.util.Arrays;
    2import java.util.List;
    3import static com.mongodb.client.model.Aggregates.limit;
    4import static com.mongodb.client.model.Aggregates.project;
    5import static com.mongodb.client.model.Projections.excludeId;
    6import static com.mongodb.client.model.Projections.fields;
    7import static com.mongodb.client.model.Projections.include;
    8import com.mongodb.client.MongoClient;
    9import com.mongodb.client.MongoClients;
    10import com.mongodb.client.MongoCollection;
    11import com.mongodb.client.MongoDatabase;
    12import org.bson.Document;
    13
    14public 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}
  2. 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"}}
1

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Filters.eq
    4import com.mongodb.client.model.Projections.*
    5import com.mongodb.kotlin.client.coroutine.MongoClient
    6import kotlinx.coroutines.runBlocking
    7import org.bson.Document
    8
    9fun 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}
  2. 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}}
2

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.

  1. Modifique RunQuery.kt para usar uma query composta.

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Filters.eq
    4import com.mongodb.client.model.Projections.*
    5import com.mongodb.kotlin.client.coroutine.MongoClient
    6import kotlinx.coroutines.runBlocking
    7import org.bson.Document
    8
    9fun 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}
  2. 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}}
3

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Filters.eq
    4import com.mongodb.client.model.Projections.*
    5import com.mongodb.kotlin.client.coroutine.MongoClient
    6import kotlinx.coroutines.runBlocking
    7import org.bson.Document
    8
    9fun 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}
  2. 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}}
1

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

    1const { MongoClient } = require("mongodb");
    2
    3async 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
    42main().catch(console.error);
  2. 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'
    }
2

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.

  1. Modifique run-query.js para usar uma query composta.

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

    1const { MongoClient } = require("mongodb");
    2
    3async 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
    56main().catch(console.error);
  2. 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'
    }
3

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

    1const { MongoClient } = require("mongodb");
    2
    3async 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
    60main().catch(console.error);
  2. 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
    }
1

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

    1import pymongo
    2
    3client = pymongo.MongoClient('<connection-string>')
    4result = 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
    26for i in result:
    27 print(i)
  2. 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'}
2

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.

  1. Modifique run_query.py para usar uma query composta.

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

    1import pymongo
    2
    3client = pymongo.MongoClient('<connection-string>')
    4result = 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
    40for i in result:
    41 print(i)
  2. 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'}
3

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

    1import pymongo
    2
    3client = pymongo.MongoClient('<connection-string>')
    4result = 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
    44for i in result:
    45 print(i)
  2. 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)}
1

Execute uma consulta básica $search usando o operador de texto.

  1. 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 palavra baseball.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title e plot.

    1use mongodb::bson::{doc, DateTime};
    2use mongodb::{Client, Collection};
    3use serde::{Deserialize, Serialize};
    4use futures::TryStreamExt;
    5
    6#[derive(Debug, Deserialize, Serialize)]
    7struct Movie {
    8 title: Option<String>,
    9 plot: Option<String>,
    10 genres: Option<Vec<String>>,
    11 released: Option<DateTime>,
    12}
    13
    14#[tokio::main]
    15async 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}
  2. 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." }
2

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.

  1. Modifique src/main.rs para usar uma query composta.

    Esta query tem os seguintes critérios de pesquisa:

    • O campo plot deve conter a palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • $limit e $project os estágios para retornar apenas 3 documentos e os campos title, plot e genres.

    1use mongodb::bson::{doc, DateTime, from_document};
    2use mongodb::{Client, Collection};
    3use serde::{Deserialize, Serialize};
    4use futures::TryStreamExt;
    5
    6#[derive(Debug, Deserialize, Serialize)]
    7struct Movie {
    8 title: Option<String>,
    9 plot: Option<String>,
    10 genres: Option<Vec<String>>,
    11 released: Option<DateTime>,
    12}
    13
    14#[tokio::main]
    15async 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}
  2. 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"]
3

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.

  1. 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 palavra baseball.

    • O campo genres não pode conter Comedy ou Romance.

    • 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 e released.

    1use mongodb::bson::{doc, DateTime, from_document};
    2use mongodb::{Client, Collection};
    3use serde::{Deserialize, Serialize};
    4use futures::TryStreamExt;
    5
    6#[derive(Debug, Deserialize, Serialize)]
    7struct Movie {
    8 title: Option<String>,
    9 plot: Option<String>,
    10 genres: Option<Vec<String>>,
    11 released: Option<DateTime>,
    12}
    13
    14#[tokio::main]
    15async 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}
  2. 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)

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.

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

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.

Você também pode assistir aos seguintes vídeos para aprender mais sobre o Atlas Search:

Voltar

Atlas Search

Nesta página