/ /

Driver C#/.NET

Docs Home

Librerías de clientes

Driver C#/.NET

Docs Home

Librerías de clientes

Driver C#/.NET

MongoDB búsqueda

Overview

En esta guía puede aprender cómo utilizar el Search Constructor para crear una etapa de canalización de agregación $search con el controlador MongoDB .NET/C#.

Para obtener más información sobre la etapa de la pipeline $search, consulta $busqueda.

Nota

Atlas y requisitos de versión de Community Edition

El operador $search pipeline de agregación está disponible únicamente para colecciones alojadas en clústeres de MongoDB Atlas que ejecutan MongoDB v4.2 o posterior, o en clústeres de MongoDB Community Edition que ejecutan MongoDB v8.2 o posterior. Las colecciones deben estar cubiertas por un índice de búsqueda MongoDB. Para obtener más información sobre la configuración necesaria y la funcionalidad de este operador, consulta la documentación de MongoDB Search.

Los ejemplos de esta guía usan los siguientes documentos en una colección llamada guitars:

{ "_id": 1, "make": "Fender", "description": "Classic guitars known for their versatility.", "establishedYear": 1946, "in_stock": true, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "Classic guitars known for their rich, full tones.", "establishedYear": 1902, "in_stock": true, "rating": 8 }
{ "_id": 3, "make": "PRS", "description": "High-end guitars known for their quality.", "establishedYear": 1985, "in_stock": true, "rating": 9 }
{ "_id": 4, "make": "Kiesel", "description": "Quality guitars made only for custom orders.", "establishedYear": 2015, "in_stock": false }
{ "_id": 5, "make": "Ibanez", "description": "Well-crafted guitars used by many professional guitarists.", "establishedYear": 1957, "in_stock": true, "rating": 7 }
{ "_id": 6, "make": "Strandberg", "description": "Modern guitars known for their headless models.", "establishedYear": 1982, "in_stock": false }

La siguiente clase Guitar modela los documentos de esta colección.

public class Guitar
{
    public int Id { get; set; }
    public string Make { get; set; }
    public string Description { get; set; }
    public int EstablishedYear { get; set; }
    [BsonElement("in_stock")]
    public bool InStock { get; set; }
    [BsonElement("in_stock_location")]
    public Location InStockLocation { get; set; }
    public int? Rating { get; set; }
    public double Score {get; set;}
    [BsonElement("paginationToken")]
    public string PaginationToken { get; set; }
}

Nota

Los documentos de la colección guitars utilizan la convención de nomenclatura camel case. En los ejemplos de esta guía, se utiliza un ConventionPack para deserializar los campos de la colección en notación Pascal y asignarlos a las propiedades de la clase Guitar.

Para obtener más información sobre la serialización personalizada, consulta Serialización personalizada.

Cree un índice de búsqueda de MongoDB

Antes de realizar una búsqueda en una colección de Atlas, primero se debe crear un Índice de MongoDB Search en la colección. Un índice de MongoDB Search es una estructura de datos que categoriza los datos en un formato buscable.

Para aprender a crear un índice de búsquedas de MongoDB, consulte la guía Crear un índice de búsqueda de MongoDB.

Operadores y recolectores de MongoDB Search

La clase Search contiene métodos que puedes usar para realizar operaciones de $search. Para ver una lista completa de los $search operadores y recolectores disponibles, consulta la guía Operadores y recolectores de Atlas.

Autocompletar

Utiliza el método Autocomplete() para buscar una palabra o frase que contenga una secuencia de caracteres de una string de entrada incompleta.

El siguiente ejemplo realiza una query de autocompletado en el campo make para el texto que comienza con la string "Gib".

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Autocomplete(g => g.Make, "Gib"), indexName: "guitarmakes")
    .ToList();

Nota

Índice para consultas de autocompletado

Debe crear un índice de búsqueda de MongoDB compatible con el autocompletado para ejecutar consultas de autocompletado correctamente. Para obtener más información, consulte "Cómo indexar campos para el autocompletado" en la documentación de Atlas.

Después de crear el índice de MongoDB Search, se debe pasar el nombre del índice al método Autocomplete(), como se muestra en el código anterior.

La búsqueda devuelve el siguiente documento:

{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

Para obtener más información sobre el operador autocomplete, consulta la guía de Atlas de autocompletado.

Compuesto

Utilice el método Compound() para combinar dos o más operadores en una sola búsqueda.

The following example searches the guitars collection for any documents that match all the following criteria:

El campo rating existe en el documento
El campo in_stock no es false
El campo establishedYear tiene un valor mayor a 1940

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Compound()
        .Must(Builders<Guitar>.Search.Exists(g => g.Rating))
        .MustNot(Builders<Guitar>.Search.Equals(g => g.InStock, false))
        .Must(Builders<Guitar>.Search.Range(g => g.EstablishedYear, SearchRangeBuilder.Gt(1940))))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Para obtener más información sobre el operador compound, consulta la guía compound de Atlas.

embeddedDocument

Utiliza el método EmbeddedDocument() para realizar operaciones de búsqueda en documentos dentro del valor de un campo tipo arreglo.

Nota

Para buscar en documentos incrustados, debe crear un índice embeddedDocument en el campo de la matriz.

Para aprender cómo definir un índice de embeddedDocument, consulta Definir el índice del tipo embeddedDocument en la documentación de Atlas.

Tenga en cuenta que algunos documentos de la colección guitars han agregado un campo productDetails que contiene una matriz de objetos de detalles del producto:

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "rating": 9, "productDetails": [{"product_id": 1234, "serial": "YZ5678"}] }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "rating": 8 }
{ "_id": 3, "make": "PRS", "description": "...", "establishedYear": 1985, "in_stock": true, "rating": 9, "productDetails": [{"product_id": 9870, "serial": "AB5555"}] }
{ "_id": 4, "make": "Kiesel", "description": "...", "establishedYear": 2015, "in_stock": false }
{ "_id": 5, "make": "Ibanez", "description": "...", "establishedYear": 1957, "in_stock": true, "rating": 7, "productDetails": [{"product_id": 5432, "serial": "ZZ1234"}] }
{ "_id": 6, "make": "Strandberg", "description": "...", "establishedYear": 1982, "in_stock": false }

Después de crear un índice embeddedDocument en el campo productDetails, puedes realizar operaciones de MongoDB Search en los documentos de ese campo. El siguiente ejemplo realiza una búsqueda de texto en los campos del arreglo productDetails y devuelve cualquier documento con un valor de campo serial de "YZ5678":

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.EmbeddedDocument(
        g => g.ProductDetails,
        Builders<ProductDetails>.Search.Text(p => p.Serial, "YZ5678")
    )).ToList();
return result;

La búsqueda devuelve el siguiente documento:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9, "productDetails" : [{ "product_id" : 1234, "serial" : "YZ5678" }] }

Para obtener más información sobre el operador embeddedDocument, consulta la guía de Atlas embeddedDocument.

Iguales

Utiliza el método Equals() para comprobar si un campo coincide con un valor especificado.

The following example searches the guitars collection for any documents in which the value of the in_stock field is true.

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Equals(g => g.InStock, true))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "...", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Para obtener más información sobre el equals operador, consulte la guía de Atlas de equals.

exists

Utiliza el método Exists() para buscar documentos en los que exista un nombre de campo indexado especificado. Si el campo especificado existe pero no está indexado, el documento no se incluye en el conjunto de resultados.

The following example searches the guitars collection for any documents in which the rating field exists.

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Exists(g => g.Rating))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "...", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Para obtener más información sobre el operador exists, consulta la guía de Atlas exists.

Facet

Usa el método Facet() para agrupar los resultados por valores o rangos en los campos facetados especificados y devuelve el recuento de cada uno de esos grupos.

Puede utilizar el método Facet() con las etapas $search y $searchMeta. MongoDB recomienda usar facet con la etapa $searchMeta para recuperar solo los resultados de metadatos de la query. Para recuperar los resultados de metadatos y los resultados de consulta utilizando la etapa $search, debe usar la variable de agregación $$SEARCH_META. Para obtener más información sobre esta variable, consulta la guía de Atlas SEARCH_META variable de agregación.

Se aplican las siguientes limitaciones:

Solo puedes ejecutar query de faceta en un único campo. No puedes ejecutar consultas de facetas sobre grupos de campos.
Puedes ejecutar consultas de facetas en colecciones fragmentadas en clústeres que ejecuten solo MongoDB v6.0.

The following example searches the guitars collection for any documents in which the value of the in_stock field is true. The query uses the Facet() method to process the input documents, with a maximum number of 100 facet categories to return in the results. The query returns the total count of documents in which the value of in_stock is true.

var result = guitarsCollection.Aggregate()
    .SearchMeta(
    	Builders<Guitar>.Search.Facet(
    	          Builders<Guitar>.Search.Equals(g => g.InStock, true),
    	          Builders<Guitar>.SearchFacet.String("string", g => g.Make, 100)), 
        indexName: "guitarfacetsearch")
     .Single()
     .Facet["string"].Buckets.Count();

La búsqueda devuelve el siguiente resultado:

Para obtener más información sobre el facet coleccionista, consulte la guía de Facet Atlas.

geoShape

Utiliza el método GeoShape() para buscar documentos en relación con una geometría determinada. Al especificar las coordenadas para buscar, se debe indicar la longitud primero, seguida de la latitud. Los valores de longitud pueden estar entre -180 y 180, inclusive. Los valores de latitud pueden estar entre -90 y 90, inclusive.

Nota

MongoDB Search no admite lo siguiente:

Sistema de referencia de coordenadas (CRS) no por defecto
Sistema de coordenadas XY plano (2 dimensiones)
Notación de pares de coordenadas Punto (nombre del campo del punto: [12, 34])

Considera que algunos documentos en la guitars colección han agregado un campo in_stock_location. Los documentos modificados en la colección ahora se ven de la siguiente manera:

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ -73.93615, 40.69791 ]}, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ 47.6062, 122.321 ]}, "rating": 8 }

The following example searches for all documents in which the coordinates in the in_stock_location field intersect with a specified polygon:

GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
{
     new(-72.93615, 41.69791),
     new(-72.93615, 40.59791),
     new(-74.93615, 40.59791),
     new(-74.93615, 41.69791),
     new(-72.93615, 41.69791),
})));
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.GeoShape(g => g.InStockLocation, GeoShapeRelation.Intersects, searchArea))
    .ToList();

La búsqueda devuelve el siguiente documento:

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "in_stock_location" : { "type" : "Point", "coordinates" : ["-73.93615", "40.69791"] }, "rating" : 9 }

Para obtener más información sobre el geoShape operador, consulte la guía de geoShape Atlas.

geoWithin

Utilice el GeoWithin() método para buscar documentos cuyas coordenadas del campo GeoJSON especificado se encuentren dentro de una geometría dada. Puede buscar puntos que se encuentren dentro de:

Círculo
Cuadro delimitador
polígono

Al especificar las coordenadas para la búsqueda, se debe indicar primero la longitud, seguida de la latitud. Los valores de longitud pueden estar entre -180 y 180, ambos inclusive. Los valores de latitud pueden estar entre -90 y 90, inclusives.

Nota

MongoDB Search no admite lo siguiente:

Sistema de referencia de coordenadas (CRS) no por defecto
Sistema de coordenadas XY plano (2 dimensiones)
Notación de pares de coordenadas Punto (nombre del campo del punto: [12, 34])

Considera que algunos documentos en la guitars colección han agregado un campo in_stock_location. Los documentos modificados en la colección ahora se ven de la siguiente manera:

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ -73.93615, 40.69791 ]}, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ 47.6062, 122.321 ]}, "rating": 8 }

The following example searches for all documents in which the coordinates in the in_stock_location field falls within a specified polygon:

GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
{
     new(-74.3994140625, 40.5305017757),
     new(-74.7290039063, 40.5805846641),
     new(-74.7729492188, 40.9467136651),
     new(-74.0698242188, 41.1290213475),
     new(-73.65234375, 40.9964840144),
     new(-72.6416015625, 40.9467136651),
     new(-72.3559570313, 40.7971774152),
     new(-74.3994140625, 40.5305017757),
})));
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.GeoWithin(g => g.InStockLocation, searchArea))
    .ToList();

La búsqueda devuelve el siguiente documento:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "in_stock_location" : { "type" : "Point", "coordinates" : ["-73.93615", "40.69791"] }, "rating" : 9 }

Para obtener más información sobre el geoWithin operador, consulte la guía geoWithin Atlas.

En

Utilice el método In() para buscar documentos con valores de campo que coincidan con una lista de valores especificados.

The following example searches the guitars collection for documents that have a make field value of either "Fender" or "Gibson".

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.In(g => g.Make, ["Fender", "Gibson"]))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "rating": 8 }

Más como esto

Utiliza el método MoreLikeThis() para buscar documentos que sean similares a un documento de entrada.

The following example searches the guitars collection for documents that are similar to an object in which the value of the Description field is "high quality."

var searchDocument = new GuitarSearch()
{
    Description = "high quality",
};
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.MoreLikeThis(searchDocument))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 3, "make" : "PRS", "description" : "High-end guitars known for their quality.", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }

Para obtener más información sobre el moreLikeThis operador, consulte la guía Atlas moreLikeThis.

near

Usa el método Near() para buscar documentos en los que un campo especificado esté cerca de un valor dado. Puedes realizar la búsqueda en:

Un campo numérico
Un campo fecha
Un punto geográfico

The following example searches the guitars collection for documents in which the value of the rating field is near 9. The documents are returned in order based on how close the value is to the number 9.

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Near(g => g.Rating, 9, 1))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "...", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Para obtener más información sobre el operador near, consulte la guía cerca Atlas.

Frase

Utiliza el método Phrase() para buscar documentos en los que un campo especificado contenga una string de entrada.

The following example searches the guitars collection for documents in which the description field contains the phrase "classic guitars."

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Phrase(g => g.Description, "classic guitars"))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

También puedes buscar en la colección documentos que coincidan con varias frases independientes de la siguiente manera:

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Phrase(g => g.Description, new List<string>() { "classic guitars", "quality guitars" }))
    .ToList();

Esta búsqueda devuelve los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

Para conocer más sobre el operador phrase, consulta la guía de frase Atlas.

queryString

Utiliza el método QueryString() para buscar documentos usando una string con los siguientes operadores y delimitadores:

AND
OR
NOT
()

The following example searches the guitars collection for documents in which the value of the description field matches each of the following criteria:

Contiene la cadena "string" o la cadena "string"
No contiene la cadena "custom"

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.QueryString(g => g.Description, "(classic OR quality) AND NOT custom"))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 3, "make" : "PRS", "description" : "High-end guitars known for their quality.", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

Para obtener más información sobre el operador queryString, consulte la queryString guía de Atlas.

Rango

Utiliza el método Range() para buscar documentos en los que el valor de un campo específico se encuentre dentro de un rango numérico, de fechas o de string.

The following example searches the guitars collection for all documents with an establishedYear value greater than 1980 and less than 2020.

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search
    .Range(g => g.EstablishedYear, SearchRangeBuilder.Gt(1980).Lt(2020)))
    .ToList();

La búsqueda devuelve los siguientes resultados:

{ "_id" : 3, "make" : "PRS", "description" : "High-end guitars known for their quality.", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 6, "make" : "Strandberg", "description" : "Modern guitars known for their headless models.", "establishedYear" : 1982, "in_stock" : false, "rating" : null }

Para buscar documentos cuyo valor de un campo específico se encuentre dentro de un rango de cadenas, primero debe crear un índice de token para ese campo. Después de crear el índice, puede buscar documentos basándose en un rango de cadenas, como se muestra en el siguiente ejemplo:

var result = guitarsCollection.Aggregate()
     .Search(Builders<Guitar>.Search
     .Range(g => g.Make, SearchRangeV2Builder.Gte("Fender").Lte("Kiesel")))
     .ToList();

The preceding example searches for any documents in which the string value of the make field is greater than or equal to "Fender" and less than or equal to "Kiesel". The driver compares the string values in lexicographic order.

La búsqueda devuelve los siguientes resultados:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Para obtener más información sobre el operador range, consulta la guía de rangos de Atlas.

regex

Utilice el método Regex() para buscar documentos con una expresión regular.

The following example searches the guitars collection for documents in which the value of the make field contains exactly six letters.

var regex = "[A-Za-z]{6}";
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Regex(g => g.Make, regex))
    .ToList();

La búsqueda devuelve los siguientes resultados:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Nota

Por defecto, el regex operador no puede ejecutarse en un campo analizado. Se puede permitir que se ejecute en un campo analizado estableciendo la opción allowAnalyzedField en true, de la siguiente manera:

var result = guitarsCollection.Aggregate()
 .Search(Builders<Guitar>.Search.Regex(g => g.Make, regex, true))
 .ToList();

Configurar la allowAnalyzedField opción como verdadera puede generar resultados de búsqueda inesperados. Para obtener más información, consulte Comportamiento de expresiones regulares.

Para obtener más información sobre el operador regex, consulte la Guía de Atlas regex.

span

Utiliza el método Span() para buscar coincidencias de texto dentro de las regiones de un campo. Puedes usar este método para encontrar cadenas que estén cerca unas de otras con grados específicos de precisión.

Nota

El operador span requiere un mayor esfuerzo computacional que otros operadores porque las consultas deben realizar un seguimiento de la información posicional.

The following example searches the guitars collection for documents in which the value of the description field contains the strings "guitars" and "quality" within one word of each other.

var searchTerms = new[]
{
     Builders<Guitar>.SearchSpan.Term(g => g.Description, "guitars"),
     Builders<Guitar>.SearchSpan.Term(g => g.Description, "quality")
 };
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Span(Builders<Guitar>.SearchSpan.Near(searchTerms, 1)))
    .ToList();

La búsqueda devuelve el siguiente documento:

{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }

Aunque el documento con _id: 3 contiene las cadenas "guitarras" y "calidad", están separadas por más de una palabra, por lo que la búsqueda omite este documento de los resultados.

Para obtener más información sobre el span operador, consulte la guía de span Atlas.

Text

Utilice el método Text() para buscar una cadena o un conjunto de cadenas en un documento. Si una cadena contiene varios términos, MongoDB Search también busca una coincidencia para cada término por separado.

The following example searches the guitars collection for documents in which the value of the description field contains the string "used by professionals".

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Text(g => g.Description, "used by professional"))
    .ToList();

La búsqueda devuelve el siguiente documento:

{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

Tip

Si su cadena de búsqueda contiene varios términos, el método también busca una coincidencia para cada término en la cadena por separado.

Para obtener más información sobre el text operador, consulte la guía de texto de Atlas.

Búsqueda de vectores

Usa el método VectorSearch() para realizar una búsqueda vectorial como operador de búsquedas de MongoDB. Este método permite buscar documentos basados en la similitud semántica con un vector de query y combinar la búsqueda vectorial con otros operadores de búsqueda o filtros. Esto es útil cuando necesitas filtrar tu conjunto de datos antes de realizar comparaciones de similitud de vectores.

Nota

Índice de búsqueda vectorial requerido

Para utilizar el método VectorSearch(), debes tener un índice de búsqueda vectorial de MongoDB configurado en tu colección. El índice debe incluir el campo que contiene los embeddings de los vectores y cualquier campo que quieras usar para el filtrado.

Para obtener más información sobre incrustaciones vectoriales y cómo generarlas para tus datos, consulta Ejecutar una query de búsqueda vectorial de MongoDB.

Considera que los documentos en la colección guitars tienen un campo adicional llamado description_embeddings que contiene representaciones vectoriales de las descripciones de guitarras. Después de crear un índice de MongoDB Vector Search en este campo, puedes buscar guitarras que sean semánticamente similares a un vector de query y filtrar los resultados por otros criterios.

El siguiente ejemplo busca guitarras similares a un vector de consulta y filtra los resultados para incluir solo aquellas con un rating mayor o igual a 8:

// Query vector representing "high-quality electric guitars"
var queryVector = new[] { <list of vectors> };
var options = new VectorSearchOperatorOptions<Guitar>()
{
    Filter = Builders<Guitar>.Filter.Gte(g => g.Rating, 8),
    NumberOfCandidates = 50
};
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.VectorSearch(
        g => g.DescriptionEmbeddings,
        queryVector,
        10,
        options))
    .ToList();

El método VectorSearch() acepta un parámetro VectorSearchOperatorOptions que permite configurar las siguientes opciones:

Opción	Tipo	Descripción
filtro	`SearchDefinition<TDocument>`	Un filtro para aplicar antes de realizar la búsqueda de vectores.
NumberOfCandidates	`int`	El número de vecinos más cercanos a considerar durante la búsqueda.
Exacto	`bool`	Si se debe utilizar la búsqueda del vecino más cercano exacto (ENN) en lugar de la búsqueda del vecino más cercano aproximado (ANN).

Comodín

Utiliza el método Wildcard() para buscar documentos utilizando caracteres especiales en tu string de búsqueda que puedan coincidir con cualquier carácter. Puede utilizar los siguientes caracteres en su búsqueda:

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

The following example searches for documents in which the value of the make field contains the string "Strand" followed by any other characters.

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Wildcard(g => g.Make, "Strand*"))
    .ToList();

La búsqueda devuelve el siguiente documento:

{ "_id" : 6, "make" : "Strandberg", "description" : "Modern guitars known for their headless models.", "establishedYear" : 1982, "in_stock" : false, "rating" : null }

Nota

Por defecto, el wildcard operador no puede ejecutarse en un campo analizado. Se puede permitir que se ejecute en un campo analizado estableciendo la opción allowAnalyzedField en true, de la siguiente manera:

var result =  guitarsCollection.Aggregate()
 .Search(Builders<Guitar>.Search.Wildcard(g => g.Make, "Strand*", true))
 .ToList();

Si se establece la opción de allowAnalyzedField como verdadera, podría generar resultados de búsqueda inesperados. Para obtener más información, consulta comportamiento de comodines.

Para obtener más información sobre el operador wildcard, consulta la guía wildcard de Atlas.

Buscar en varios campos

Los operadores de búsqueda de MongoDB utilizan el path parámetro para especificar el campo o los campos que se buscarán. Para obtener más información sobre el path contenido del parámetro, consulte la guía "Construir una ruta de consulta".

Nota

No todos los operadores pueden usar todos los diferentes tipos de caminos. Consulta la documentación de cada operador individual para obtener detalles sobre los tipos de caminos que admite.

Para buscar en múltiples campos indexados, use el método Multi() y pase sus campos. Los documentos que coinciden en cualquiera de los campos especificados se incluyen en el conjunto de resultados.

The following example searches for the string classic in either the make or the description field.

var result = guitarsCollection.Aggregate().Search(
    Builders<Guitar>.Search.Phrase(Builders<Guitar>.SearchPath
    .Multi(g => g.Description, g => g.Make), "classic"), indexName: "guitarmulti")
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9}
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8}

Documentos de puntuación

A cada documento devuelto por una consulta de búsqueda de MongoDB se le asigna una puntuación según su relevancia, y los documentos incluidos en un conjunto de resultados se ordenan de mayor a menor puntuación. Para obtener más información sobre la asignación de puntuaciones, consulte la guía de Score Atlas.

La puntuación asignada a un documento devuelto forma parte de los metadatos del documento. Puedes incluir la puntuación de cada documento devuelto junto con el conjunto de resultados utilizando una etapa $project en tu pipeline de agregación.

The following example searches the guitars collection for documents in which the value of the make field contains exactly six letters and uses a $project stage to add a field named score to the returned documents.

var regex = "[A-Za-z]{6}";
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Regex(g => g.Make, regex, allowAnalyzedField: true), indexName: "guitarscore")
    .Project<Guitar>(Builders<Guitar>.Projection
    .Include("Id")
    .Include("Make")
    .Include("Description")
    .MetaSearchScore(g => g.Score))
    .ToList();

La búsqueda muestra los siguientes documentos:

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 0, "in_stock" : false, "rating" : null, "score" : 1.0 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 0, "in_stock" : false, "rating" : null, "score" : 1.0 }
{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 0, "in_stock" : false, "rating" : null, "score" : 1.0 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 0, "in_stock" : false, "rating" : null, "score" : 1.0 }

Modificar el comportamiento de MongoDB Search

Puedes modificar el comportamiento del método Search() pasando un objeto SearchOptions como parámetro.

La clase SearchOptions contiene las siguientes propiedades:

Propiedad	Descripción
`CountOptions`	The options for counting the search results. Data type: SearchCountOptions Default: `null`
`Highlight`	The options for displaying search terms in their original context. Data type: SearchHighlightOptions<TDocument> Default: `null`
`IndexName`	The index to use for the search. Data type: `string` Default: `null`
`ReturnStoredSource`	A flag that specifies whether to perform a full document lookup on the database or to return only stored source fields directly from MongoDB Search. Data type: `boolean` Default: `false`
`ScoreDetails`	A flag that specifies whether to return detailed information about the score for each document in the results. Data type: `boolean` Default: `false`
`SearchAfter`	The starting point for pagination. When set, the search retrieves documents starting immediately after the specified reference point. Data type: `string` Default: `null`
`SearchBefore`	The end point for pagination. When set, the search retrieves documents starting immediately before the specified reference point. Data type: `string` Default: `null`
`Sort`	The sorting criteria to apply to the results. Data type: SortDefinition<TDocument> Default: `null`
`Tracking`	The options for tracking search terms. Data type: SearchTrackingOptions Default: `null`

Ejemplo de SearchAfter

El siguiente ejemplo pagina los resultados de una operación de MongoDB Search realizando las siguientes acciones:

Define una proyección que utiliza el método de creación MetaSearchSequenceToken(), que especifica un PaginationToken para contener el punto de referencia
Crea una instancia de SearchOptions y establece el índice y los criterios de ordenamiento a utilizar
Ejecuta una búsqueda inicial para encontrar documentos que contengan un valor de campo description con el texto "classic", aplicando la proyección y las opciones a la operación
Establece la propiedad SearchAfter de la misma instancia SearchOptions para indicar que la próxima búsqueda debe comenzar después del primer resultado de la búsqueda base.
Ejecuta otra operación de búsqueda que tenga los mismos criterios de coincidencia y aplique las opciones de búsqueda para paginar los resultados

var projection = Builders<Guitar>.Projection
    .Include(x => x.Make)
    .MetaSearchSequenceToken(x => x.PaginationToken);
var searchDefinition = Builders<Guitar>.Search.Text(g => g.Description, "classic");
var searchOptions = new SearchOptions<Guitar>
{ IndexName = "default", Sort = Builders<Guitar>.Sort.Ascending(g => g.Id) };
// Runs the base search operation
var baseSearchResults = guitarsCollection.Aggregate()
    .Search(searchDefinition, searchOptions)
    .Project<Guitar>(projection)
    .ToList();
// Sets the starting point for the next search
searchOptions.SearchAfter = baseSearchResults[0].PaginationToken;
var result = guitarsCollection.Aggregate()
    .Search(searchDefinition, searchOptions)
    .ToList();

La búsqueda devuelve el siguiente documento:

{ "_id": 2, "make": "Gibson", "description": "Classic guitars known for their rich, full tones.", "establishedYear": 1902, "in_stock": true, "rating": 8 }

Tip

Para obtener más información sobre la paginación de búsqueda de MongoDB, consulte Paginar los resultados en la documentación de Atlas.

Volver

Ejecute un comando de base de datos

Búsqueda vectorial de MongoDB