/ /

Operadores y coleccionistas

Docs Home

/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`wildcard` Operador

Definición

wildcard

El operador wildcard permite realizar queries que utilizan caracteres especiales en la string de búsqueda que pueden coincidir con cualquier carácter.

Carácter	Descripción
`?`	Coincide con cualquier carácter único.
`*`	Coincide con 0 o más caracteres.
`\`	Personaje de escape.

wildcard es un operador a nivel de término, lo que significa que el campo query no se analiza. Los operadores a nivel de término funcionan bien con el Analizador de palabras clave, porque el campo query se trata como un solo término, incluidos los caracteres especiales. Para obtener un ejemplo de consulta en un campo query analizado, consulte ejemplo de campo analizado.

Sintaxis

wildcard tiene la siguiente sintaxis:

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

opciones

wildcard utiliza los siguientes términos para construir una query:

Campo	Tipo	Descripción	Necesidad	predeterminado
`query`	string o arreglo de strings	String o strings de búsqueda.	Sí
`path`	string o arreglo de strings	Campo o campos indexados para buscar. También puedes especificar una ruta comodín para buscar.	Sí
`allowAnalyzedField`	booleano	Debe establecerse en `true` si la consulta se ejecuta en un campo analizado.	no	`false`
`score`	Objeto	Modifique la puntuación asignada a los resultados de búsqueda coincidentes. Las opciones son: `boost`Multiplica la puntuación resultante por el número dado. `constant`:reemplace la puntuación del resultado con el número dado. `function`: reemplazar el puntaje de resultados usando la expresión dada. Para obtener información sobre cómo usar `score` en tu query, consulta Calificación de los Documentos en los Resultados.	no

Comportamiento

wildcard es un operador a nivel de término, lo que significa que el campo query no se ha analizado. Es posible utilizar el operador wildcard para realizar búsquedas en un campo analizado durante la indexación configurando la opción allowAnalyzedField a true. Si usas wildcard con allowAnalyzedField: true, MongoDB Search aplica filtros de caracteres y filtros de tokens en función del analizador especificado o del analizador personalizado para el campo. MongoDB Search omite la tokenización y la salida es siempre un solo token.

Los siguientes ejemplos muestran cómo se comporta el operador wildcard cuando se realiza una búsqueda en campos analizados:

Ejemplo

Analizador estándar

Supón que un campo foo bar baz está indexado con el analizador estándar. MongoDB Search analiza e indexa el campo como foo, bar y baz. Buscar foo bar* en este campo no arroja resultados, porque el operador wildcard trata foo bar* como un único término de búsqueda con un wildcard al final. En otras palabras, MongoDB Search busca en el campo cualquier término que comience con foo bar, pero no encuentra nada porque no existe ningún término.

Ejemplo

Analizador de palabras clave.

Buscar *Star Trek* en un campo indexado con el analizador de palabras clave encuentra todos los documentos en los que el campo contiene la string Star Trek en cualquier contexto. Buscar *Star Trek* en un campo indexado con el analizador estándar no arroja resultados porque hay un espacio entre Star y Trek, y el índice no contiene espacios.

Comportamiento de los caracteres de escape

Al utilizar el carácter de escape en o mongosh con un controlador, debe utilizar una barra invertida doble antes del carácter que se va a escapar.

Ejemplo

Para crear una expresión comodín que busque cualquier string que contenga un asterisco literal en una canalización de agregación, utilice la siguiente expresión:

"*\\**"

El primer y último asteriscos actúan como comodines que coinciden con cualquier carácter, y el \\* coincide con un asterisco literal.

Nota

Utiliza la siguiente expresión para escapar una barra invertida literal:

"*\\\*"

➤ Utiliza el menú desplegable Seleccionar su lenguaje para establecer el lenguaje de los ejemplos en esta página.

Ejemplos

Los siguientes ejemplos utilizan la colección movies en la base de datos sample_mflix con una definición de índice personalizada que emplea el analizador de palabras clave. Si tienes el conjunto de datos de muestra en tu clúster, puedes crear un índice de búsqueda de MongoDB Search en la colección movies y ejecutar las consultas de ejemplo en tu clúster.

Para ver y editar la sintaxis de la consulta en el Search Tester:

En Atlas, vaya a la Search & Vector Search página de su clúster.

Puedes ir a la página de búsqueda de MongoDB desde la opción Search & Vector Search o desde el Data Explorer.

Si aún no aparece, se debe seleccionar la organización que contiene el proyecto en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Search & Vector Search en la sección Database.
Si no tienes clústeres, haz clic en Create cluster para crear uno. Para obtener más información, consulta Crear un clúster.
Si el proyecto tiene varios clústeres, se debe seleccionar el clúster que se desea usar en el menú desplegable Select cluster y luego se debe hacer clic en Go to Search.
Aparece la página de Búsqueda y Búsqueda Vectorial.

Si aún no aparece, se debe seleccionar la organización que contiene el proyecto en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Data Explorer en la sección Database.
Expanda la base de datos y seleccione la colección.
Haga clic en la pestaña Indexes para la colección.
Haga clic en el enlace Search and Vector Search en el banner.
Aparece la página de Búsqueda y Búsqueda Vectorial.

Ver y editar la sintaxis de la query.

Haz clic en el botón Query a la derecha del índice que deseas consultar.
Haz clic Edit Query para ver un ejemplo de sintaxis de query por defecto en JSON format.

Para aprender a ejecutar las siguientes consultas en la Interfaz de Usuario de Atlas, consulte Definir tu consulta.

Ejecute el siguiente comando en el mongosh prompt para usar la base de datos sample_mflix:

use sample_mflix

Para aprender cómo ejecutar las siguientes consultas en el mongosh, consulta Define tu consulta.

Para aprender a ejecutar las siguientes consultas en MongoDB Compass, consulte Definir su consulta.

Para aprender cómo ejecutar las siguientes queries utilizando el controlador MongoDB C#, consulte Defina su query.

Para aprender a ejecutar las siguientes consultas utilizando el controlador MongoDB Go#, consulta Define tu consulta.

Para aprender a ejecutar las siguientes consultas utilizando el controlador Java de MongoDB, consulte Definir su consulta.

Para aprender a ejecutar las siguientes queries utilizando el driver de MongoDB Kotlin, consulta Define tu query.

Para aprender a ejecutar las siguientes queries utilizando el Controlador de nodo de MongoDB, consulte Defina su query.

Para aprender cómo ejecutar las siguientes queries usando el driver PyMongo, revise Definir su query.

Ejemplo de índice

La siguiente definición de índice indexa el campo title en la colección movies con el Analizador de palabras clave:

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

Ejemplos de query

The following example searches all title fields for movie titles that begin with Green D, followed by any number of other characters.

Copia y pega la siguiente query en el Query Editor, y luego haz clic en el botón Search en el 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

Es posible que Search Tester no muestre todos los campos en los documentos que devuelve. Para ver todos los campos, incluido el campo que especifica en la ruta de query, expanda el documento en los 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'}

The following example searches all title fields for movie titles that begin with the string Wom?n (where ? may be any single character), followed by a space and then any number of additional characters.

Copia y pega la siguiente query en el Query Editor, y luego haz clic en el botón Search en el 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