curinga

Nesta página

Definição
Sintaxe
Opções
Comportamento
Analisador padrão
Analisador de palavras-chave
Comportamento de Caractere de Escape
Exemplos
Exemplo de índice
Exemplos de consulta

Definição

wildcard

O operador wildcard habilita queries que utilizam caracteres especiais na string de pesquisa que podem corresponder a qualquer caractere.

Personagem	Descrição
`?`	Corresponde a qualquer caractere único.
`*`	Corresponde a 0 ou mais caracteres.
`\`	Personagem de fuga.

wildcard é um operador de nível de termo, o que significa que o campo query não é analisado. Os operadores de nível de termo funcionam bem com o Analisador de Palavras-chave, porque o campo query é tratado como um único termo, com caracteres especiais incluídos. Para obter um exemplo de consulta em relação a um campo query analisado versus um campo query não analisado, consulte o exemplo do campoanalisado.

Sintaxe

wildcard tem a seguinte sintaxe:

{
  $search: {
    "index": <index name>, // optional, defaults to "default"
    "wildcard": {
      "query": "<search-string>",
      "path": "<field-to-search>",
      "allowAnalyzedField": <boolean>,
      "score": <options>
    }
  }
}

Opções

wildcard usa os seguintes termos para construir uma consulta:

Campo	Tipo	Descrição	necessidade	Default
`query`	cadeia de caracteres ou matriz de cadeias de caracteres	String ou strings para pesquisar.	sim
`path`	cadeia de caracteres ou matriz de cadeias de caracteres	campo ou campos indexados a serem pesquisados. Você também pode especificar um caminho curinga para pesquisa.	sim
`allowAnalyzedField`	booleano	Deve ser definido para `true` se a query for executada em um campo analisado.	no	`false`
`score`	objeto	Modifique a score atribuída aos resultados dos procurar correspondentes. As opções são: `boost`: multiplique a pontuação do resultado pelo número fornecido. `constant`: substitui a pontuação do resultado pelo número fornecido. `function`: substitua a pontuação do resultado usando a expressão fornecida. Para obter informações sobre como utilizar o `score` em sua consulta, consulte Classificar os documentos nos resultados.	no

Comportamento

wildcard é um operador de nível de termo, o que significa que o campo query não é analisado. É possível utilizar o operador wildcard para executar pesquisas em um campo analisado durante a indexação definindo a opção allowAnalyzedField para true. No entanto, os resultados refletem que o texto da query não é analisado.

Os exemplos a seguir mostram como o operador wildcard se comporta ao realizar uma pesquisa em campos analisados:

Exemplo

Analisador padrão

Suponha que um campo foo bar baz seja indexado com o analisador padrão. O Atlas Search analisa e indexa o campo como foo, bar e baz. Pesquisar foo bar* neste campo não encontra nada, porque o operador curinga trata foo bar* como um único termo de pesquisa com um curinga no final. Em outras palavras, o Atlas Search pesquisa no campo qualquer termo que comece com foo bar, mas não encontra nada, porque não existe nenhum termo.

Exemplo

Analisador de palavras-chave

A pesquisa de *Star Trek* em um campo indexado com o analisador de palavras-chave encontra todos os documentos nos quais o campo contém a string Star Trek em qualquer contexto. A pesquisa de *Star Trek* em um campo indexado com o analisador padrão não encontra nada, pois há um espaço entre Star e Trek, e o índice não contém espaços.

Comportamento de Caractere de Escape

Ao usar o caractere de escape em mongosh ou com um driver, é necessário usar uma barra invertida dupla antes do caractere a ser escapado.

Exemplo

Para criar uma expressão curinga que procure qualquer string que contenha um asterisco literal em um aggregation pipeline, use a seguinte expressão:

"*\\**"

O primeiro e o último asteriscos funcionam como curingas que correspondem a qualquer caractere, e o \\* corresponde a um asterisco literal.

Observação

Use a seguinte expressão para escapar de uma barra invertida literal:

"*\\\*"

➤ Use o menu suspenso Selecione sua linguagem para definir o idioma dos exemplos nesta página.

Exemplos

Os exemplos a seguir usam a collection movies no banco de dados sample_mflix com uma definição de índice personalizada que usa o analisador de palavras-chave. Se você tiver o sample dataset em seu cluster, poderá criar um Atlas Search index na movies e executar as querys de exemplo em seu cluster.

Para visualizar e editar a sintaxe da query no Search Tester:

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

Aviso

Melhorias na navegação em andamento

No momento, estamos lançando uma experiência de navegação nova e aprimorada. Se as etapas a seguir não corresponderem à sua visualização na UI do Atlas, consulte a documentação de visualização.

Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione o projeto desejado no menu Projects na barra de navegação.
Se ainda não estiver exibido, clique em Clusters na barra lateral.
A página Clusters é exibida.

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

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

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.
Se o seu projeto tiver múltiplos clusters, selecione o cluster que deseja utilizar a partir do menu suspenso Select cluster e clique em Go to Atlas Search.
A página Atlas Search é exibida.

Clique no botão Browse Collections para o seu cluster.
Expanda o banco de dados e selecione a coleção.
Clique na guia Search Indexes da coleção.
A página Atlas Search é exibida.

Clique no nome do seu cluster.
Clique na aba Atlas Search.
A página Atlas Search é exibida.

Visualizar e editar a sintaxe da consulta.

Clique no botão Query à direita do índice para consultar.
Clique em Edit Query para visualizar uma amostra de sintaxe de consulta padrão no formato JSON .

Para aprender como executar as seguintes queries na UI do Atlas, consulte Definir sua query.

Execute o seguinte comando no prompt mongosh para usar o banco de dados sample_mflix:

use sample_mflix

Para aprender como executar as seguintes queries no mongosh, consulte Definir Sua Query.

Para saber como executar as seguintes queries no MongoDB Compass, consulte Definir sua query.

Para saber como executar as seguintes queries usando o driver MongoDB C#, consulte Definir sua query.

Para saber como executar as seguintes queries usando o driver MongoDB Go#, consulte Definir sua query.

Para saber como executar as seguintes queries usando o driver do MongoDB Java, consulte Definir sua query.

Para saber como executar as seguintes queries usando o driver MongoDB Kotlin, consulte Definir sua query.

Para saber como executar as seguintes queries usando o Driver de Node do MongoDB, consulte Definir sua query.

Para saber como executar as seguintes queries usando o driver do PyMongo, consulte Definir sua query.

Exemplo de índice

A seguinte definição de índice indexa o campo title na coleção movies com o analisador de palavra-chave:

1 {
2   "mappings": {
3     "fields": {
4       "title": {
5         "analyzer": "lucene.keyword",
6         "type": "string"
7       }
8     }
9   }
10 }

Exemplos de consulta

O exemplo a seguir procurar em todos os campos title os títulos de filmes que começam com Green D, seguidos de qualquer número de outros caracteres.

Copie e cole a seguinte consulta no Query Editor e, em seguida, clique no botão Search no Query Editor.

[
   {
      $search: {
         "wildcard": {
         "path": "title",
         "query": "Green D*"
         }
      }
   }
]

SCORE: 1  _id:  "573a1393f29313caabcddaf5"
plot: "Sophie loved Edmund, but he left town when her parents forced her to m…"
genres: Array
runtime: 141
SCORE: 1  _id:  "573a13a2f29313caabd0a4e4"
plot: "The story of some Vietnamese refugees as they first arrive at Camp Pen…"
genres: Array
runtime: 115

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.

db.movies.aggregate([
  {
    "$search": {
      "wildcard": {
        "path": "title",
        "query": "Green D*"
      }
    }
  },
  {
    "$project": {
      "_id": 0,
      "title": 1
    }
  }
])

{ "title" : "Green Dolphin Street" }
{ "title" : "Green Dragon" }

In the :guilabel:`Aggregations` tab of the ``movies`` collection,
configure each of the following pipeline stages by selecting the stage
from the dropdown and adding the query for that stage. Click
:guilabel:`Add Stage` to add additional stages.
.. list-table::
   :header-rows: 1
   :widths: 25 75
   * - Pipeline Stage
     - Query
   * - ``$search``
     - .. code-block:: javascript
          
          {
            "wildcard": {
              "query": "Green D*",
              "path": "title"
            }
          }
   * - ``$project``
     - .. code-block:: javascript
          
          {
            "_id": 0,
            "title": 1,
          }

{ "title" : "Green Dolphin Street" }
{ "title" : "Green Dragon" }

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using MongoDB.Driver.Search;
public class WildcardSingleCharacter
{
    private const string MongoConnectionString = "<connection-string>";
    public static void Main(string[] args)
    {
        // allow automapping of the camelCase database fields to our MovieDocument
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
        // connect to your Atlas cluster
        var mongoClient = new MongoClient(MongoConnectionString);
        var mflixDatabase = mongoClient.GetDatabase("sample_mflix");
        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
        // define and run pipeline
        var results = moviesCollection.Aggregate()
            .Search(Builders<MovieDocument>.Search.Wildcard(movie => movie.Title, "Green D*"))
            .Project<MovieDocument>(Builders<MovieDocument>.Projection
                .Include(movie => movie.Title)
                .Exclude(movie => movie.Id))
            .ToList();
        // print results
        foreach (var movie in results)
        {
            Console.WriteLine(movie.ToJson());
        }
    }
}
[BsonIgnoreExtraElements]
public class MovieDocument
{
    [BsonIgnoreIfDefault]
    public ObjectId Id { get; set; }
    public string Title { get; set; }
}

{ "title" : "Green Dolphin Street" }
{ "title" : "Green Dragon" }

package main
import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)
func main() {
	// connect to your Atlas cluster
	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string>"))
	if err != nil {
		panic(err)
	}
	defer client.Disconnect(context.TODO())
	// set namespace
	collection := client.Database("sample_mflix").Collection("movies")
	// define pipeline stages
	searchStage := bson.D{{"$search", bson.D{{"wildcard", bson.D{{"path", "title"}, {"query", "Green D*"}}}}}}
	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"_id", 0}}}}
	// run pipeline
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage})
	if err != nil {
		panic(err)
	}
	// print results
	var results []bson.D
	if err = cursor.All(context.TODO(), &results); err != nil {
		panic(err)
	}
	for _, result := range results {
		fmt.Println(result)
	}
}

[{title Green Dolphin Street}]
[{title Green Dragon}]

import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Aggregates.project;
import static com.mongodb.client.model.Projections.excludeId;
import static com.mongodb.client.model.Projections.fields;
import static com.mongodb.client.model.Projections.include;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import java.util.Arrays;
public class WildcardSingleCharacter {
    public static void main(String[] args) {
        // connect to your Atlas cluster
        String uri = "<connection-string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // set namespace
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
            MongoCollection<Document> collection = database.getCollection("movies");
            
            // define pipeline
            Document agg = new Document("query", "Green D*").append("path", "title");
            // run pipeline and print results
            collection.aggregate(Arrays.asList(
                eq("$search", eq("wildcard", agg)),
                project(fields(excludeId(), include("title"))))).forEach(doc -> System.out.println(doc.toJson()));
        }
    }
}

{"title": "Green Dolphin Street"}
{"title": "Green Dragon"}

import com.mongodb.client.model.Aggregates.project
import com.mongodb.client.model.Filters.eq
import com.mongodb.client.model.Projections.*
import com.mongodb.kotlin.client.coroutine.MongoClient
import kotlinx.coroutines.runBlocking
import org.bson.Document
fun main() {
    val uri = "<connection-string>"
    val mongoClient = MongoClient.create(uri)
    val database = mongoClient.getDatabase("sample_mflix")
    val collection = database.getCollection<Document>("movies")
    runBlocking {
        val agg = Document("query", "Green D*").append("path", "title")
        val resultsFlow = collection.aggregate<Document>(
            listOf(
                eq("\$search", eq("wildcard", agg)),
                project(fields(
                    excludeId(),
                    include("title")
                ))
            )
        )
        resultsFlow.collect { println(it) }
    }
    mongoClient.close()
}

Document{{title=Green Dolphin Street}}
Document{{title=Green Dragon}}

const { MongoClient } = require("mongodb");
// connect to your Atlas cluster
const uri =
    "<connection-string>";
const client = new MongoClient(uri);
async function run() {
    try {
        await client.connect();
        // set namespace
        const database = client.db("sample_mflix");
        const coll = database.collection("movies");
        // define pipeline
        const agg = [
            {$search: {wildcard: {query: "Green D*", path: "title"}}},
            {$project: {_id: 0, title: 1}},
        ];
        // run pipeline
        const result = await coll.aggregate(agg);
        // print results
        await result.forEach((doc) => console.log(doc));
    } finally {
        await client.close();
    }
}
run().catch(console.dir);

{ title: 'Green Dolphin Street' }
{ title: 'Green Dragon' }

import pymongo
# connect to your Atlas cluster
client = pymongo.MongoClient('<connection-string>')
# define pipeline
pipeline = [
    {"$search": {"wildcard": {"query": "Green D*", "path": "title"}}},
    {"$project": {"_id": 0, "title": 1}},
]
# run pipeline
result = client["sample_mflix"]["movies"].aggregate(pipeline)
# print results
for i in result:
    print(i)

{'title': 'Green Dolphin Street'}
{'title': 'Green Dragon'}

O exemplo a seguir pesquisa todos os campos title em busca de títulos de filmes que começam com a string Wom?n (onde ? pode ser qualquer caractere único), seguido por um espaço e, em seguida, qualquer número de caracteres adicionais.

Copie e cole a seguinte consulta no Query Editor e, em seguida, clique no botão Search no Query Editor.

[
   {
      $search: {
         "wildcard": {
         "path": "title",
         "query": "Wom?n *"
         }
      }
   }
]

SCORE: 1  _id:  "573a1393f29313caabcdcbdd"
plot: "Rival reporters Sam and Tess fall in love and get married, only to fin…"
genres: Array
runtime: 114
SCORE: 1  _id:  "573a1394f29313caabce08c6"
plot: "A married, middle-aged woman is shocked to discover that her husband, …"
genres: Array
runtime: 93
SCORE: 1  _id:  "573a1396f29313caabce42e5"
plot: "The battle of the sexes and relationships among the elite of Britian's…"
genres: Array
runtime: 131
SCORE: 1  _id:  "573a1398f29313caabceb06d"
fullplot: "A woman's lover leaves her, and she tries to contact him to find out w…"
imdb: Object
year: 1988
SCORE: 1  _id:  "573a139df29313caabcf9c83"
plot: "A new woman comes between a widower and his adult son."
genres: Array
runtime: 110
SCORE: 1  _id:  "573a13a0f29313caabd050bf"
fullplot: "Isabella is a great cook, making her husband's restaurant in Bahia, Br…"
imdb: Object
year: 2000
SCORE: 1  _id:  "573a13aaf29313caabd22c05"
countries: Array
genres: Array
runtime: 115
SCORE: 1  _id:  "573a13aef29313caabd2d899"
countries: Array
genres: Array
runtime: 72
SCORE: 1  _id:  "573a13aff29313caabd32566"
fullplot: "An adaptation of Bishop T.D. Jakes' self-help novel, chronciling a wom…"
imdb: Object
year: 2004
SCORE: 1  _id:  "573a13b0f29313caabd332de"
fullplot: "Two college friends get together and reminisce on the woman they both …"
imdb: Object
year: 2004