/ /

Operadores y coleccionistas

Docs Home

/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`wildcard` Operador

Definición

wildcard

El operador wildcard habilita consultas que utilizan caracteres especiales en la cadena 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, ya que el query campo se trata como un solo término, con caracteres especiales incluidos. Para ver un ejemplo de consulta en un query campo 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 consulta:

Campo	Tipo	Descripción	Necesidad	predeterminado
`query`	cadena o matriz de cadenas	Cadena o cadenas a buscar.	sí
`path`	cadena o matriz de cadenas	Campo o campos indexados para buscar. También puede especificar una ruta comodín para la búsqueda.	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 del resultado 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 el uso de `score` en su consulta,consulte Calificar 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 analiza. Es posible usar el operador wildcard para realizar búsquedas en un campo analizado durante la indexación, estableciendo la opción allowAnalyzedField en true. Si se usa wildcard con allowAnalyzedField: true, MongoDB Search aplica filtros de caracteres y de tokens según el analizador especificado o personalizado para el campo. MongoDB Search omite la tokenización y el resultado siempre es un único token.

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

Ejemplo

Analizador estándar

Supongamos que un campo foo bar baz está indexado con el analizador estándar. MongoDB Search analiza e indexa el campo foo como, bar bazy. La búsqueda de foo bar* en este campo no encuentra nada, ya que el operador comodín trata foo bar* como un único término de búsqueda con un comodín al final. En otras palabras, MongoDB Search busca en el campo cualquier término que comience foo bar por, pero no encuentra nada, ya que no existe ningún término.

Ejemplo

Analizador de palabras clave

La búsqueda de *Star Trek* en un campo indexado con el analizador de palabras clave encuentra todos los documentos que contienen la cadena Star Trek en cualquier contexto. La búsqueda de *Star Trek* en un campo indexado con el analizador estándar no encuentra nada, ya que hay un espacio entre Star Treky, y el índice no contiene espacios.

Comportamiento del personaje 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 cadena que contenga un asterisco literal en una canalización de agregación, utilice la siguiente expresión:

"*\\**"

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

Nota

Utilice 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 movies colección de la sample_mflix base de datos con una definición de índice personalizada que utiliza el analizador de palabras clave. Si tiene el conjunto de datos de ejemplo en su clúster, puede crear un índice de búsqueda de MongoDB en la movies colección y ejecutar las consultas de ejemplo en su 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.
Haga clic en Edit Query para ver un ejemplo de sintaxis de consulta predeterminada en FormatoJSON.

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

Ejecute el siguiente comando en mongosh el sample_mflix indicador para utilizar la base de datos:

use sample_mflix

Para saber cómo ejecutar las siguientes consultas en,mongosh consulte Definir su consulta.

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

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

Para aprender a ejecutar las siguientes consultas utilizando el controlador MongoDB Go#, consulte Definir su 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 consultas utilizando el controlador de nodo MongoDB, consulte Definir su consulta.

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

Ejemplo de índice

La siguiente definición de índice indexa el title campo en la movies colección 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 consultas

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