/ /

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 podrás aprender a 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 canalización $search, consulte $búsqueda.

Nota

Requisitos de las versiones Atlas y Community Edition

El $search operador de canalización de agregación solo está disponible para colecciones alojadas en clústeres de MongoDB Atlas con MongoDB v4.2 o posterior, o en clústeres de MongoDB Community Edition con MongoDB v.8 2 o posterior. Las colecciones deben estar cubiertas por un índice de MongoDB Search. Para obtener más información sobre la configuración necesaria y la funcionalidad de este operador, consulte 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, consulte Serialización personalizada.

Cree un índice de búsqueda de MongoDB

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

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

Operadores de búsqueda y recopiladores de MongoDB

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

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

El siguiente ejemplo realiza una consulta de autocompletar en el campo make para el texto que comienza con la cadena "Gib".

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

Nota

Índice de consultas de autocompletar

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 búsqueda de MongoDB, 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 autocomplete operador, consulte la guía de autocompletar de Atlas.

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 que 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 devuelve 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 compound operador, consulte la guía de Atlas compuesto.

Documento incrustado

Utilice el método EmbeddedDocument() para realizar operaciones de búsqueda en documentos dentro del valor de la matriz de un campo.

Nota

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

Para aprender a definir un embeddedDocument índice, consulte Definir el índice para el 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 }

Tras crear un índice embeddedDocument en el campo productDetails, puede realizar búsquedas de MongoDB en los documentos de ese campo. El siguiente ejemplo realiza una búsqueda de texto en los campos de la matriz productDetails y devuelve cualquier documento cuyo valor en el campo serial sea "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 embeddedDocument operador, consulte la guía embeddedDocument Atlas.

Iguales

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

existe

Utilice el método Exists() para buscar documentos que contengan un nombre de campo indexado específico. 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 devuelve 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 exists operador, consulte la guía de Atlas.

Facet

Utilice el método Facet() para agrupar los resultados por valores o rangos en los campos facetados especificados y devolver 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 se pueden ejecutar consultas de facetas en un solo campo. No se pueden ejecutar consultas de facetas en grupos de campos.
Puede ejecutar consultas de facetas en colecciones fragmentadas en clústeres que ejecutan únicamente 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.

Geoforma

Utilice el método GeoShape() para buscar documentos relacionados con una geometría dada. Al especificar las coordenadas de búsqueda, primero debe especificarse la longitud y luego la latitud. Los valores de longitud pueden estar entre -180 y 180, ambos inclusive. Los valores de latitud pueden estar entre -90 y 90, ambos inclusive.

Nota

La búsqueda de MongoDB no admite lo siguiente:

Sistema de referencia de coordenadas (CRS) no predeterminado
Sistema de coordenadas XY planas (2 dimensión)
Pares de coordenadas Notación de puntos (pointFieldName: [12, 34])

Considere que algunos documentos de la colección guitars han añadido un campo in_stock_location. Los documentos modificados de la colección ahora tienen el siguiente aspecto:

{ "_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 de búsqueda, primero se debe especificar la longitud y luego la latitud. Los valores de longitud pueden estar entre -180 y 180, ambos inclusive. Los valores de latitud pueden estar entre -90 y 90, ambos inclusive.

Nota

La búsqueda de MongoDB no admite lo siguiente:

Sistema de referencia de coordenadas (CRS) no predeterminado
Sistema de coordenadas XY planas (2 dimensión)
Pares de coordenadas Notación de puntos (pointFieldName: [12, 34])

Considere que algunos documentos de la colección guitars han añadido un campo in_stock_location. Los documentos modificados de la colección ahora tienen el siguiente aspecto:

{ "_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 devuelve 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

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

Cerca

Utilice el método Near() para buscar documentos en los que un campo específico esté cerca de un valor dado. Puede realizar la búsqueda en:

Un campo numérico
Un campo de 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 devuelve 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 near operador, consulte la guía cercana de Atlas.

Frase

Utilice el método Phrase() para buscar documentos en los que un campo especificado contenga una cadena 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 devuelve 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 puede 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

Utilice el método QueryString() para buscar documentos utilizando una cadena 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 "clásico" o la cadena "calidad"
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 devuelve 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 queryString operador, consulte la guía de queryString 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 range operador, consulte la guía Atlas de rango.

Regex

Utilice el método Regex() para buscar documentos utilizando 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

De forma predeterminada, el operador regex no puede ejecutarse en un campo analizado. Puede permitir su ejecución en un campo analizado configurando la opción allowAnalyzedField como verdadera, como se indica a continuación:

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 regex operador, consulte la guía de expresiones regulares de Atlas.

Palmo

Utilice el método Span() para buscar coincidencias de texto dentro de las regiones de un campo. Puede usar este método para encontrar cadenas cercanas entre sí con un grado de precisión específico.

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 de vectores 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 las incrustaciones vectoriales y cómo generarlas para sus datos, consulte Ejecutar una consulta de búsqueda vectorial de MongoDB.

Tenga en cuenta que los documentos de la colección guitars tienen un campo adicional llamado description_embeddings que contiene representaciones vectoriales de las descripciones de las guitarras. Tras crear un índice de búsqueda vectorial de MongoDB en este campo, puede buscar guitarras semánticamente similares a un vector de consulta 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 le 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.
Número de candidatos	`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

Utilice el método Wildcard() para buscar documentos utilizando caracteres especiales en su cadena de búsqueda que coincidan con cualquier carácter. Puede usar los siguientes caracteres en su búsqueda:

Carácter	Descripción
`?`	Coincide con cualquier carácter individual
`*`	Coincide con 0 o más caracteres
`\`	Personaje 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

De forma predeterminada, el operador wildcard no puede ejecutarse en un campo analizado. Puede permitir su ejecución en un campo analizado configurando la opción allowAnalyzedField como verdadera, como se indica a continuación:

var result =  guitarsCollection.Aggregate()
 .Search(Builders<Guitar>.Search.Wildcard(g => g.Make, "Strand*", 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 los comodines.

Para obtener más información sobre el wildcard operador, consulte la guía de comodines 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 tipos de rutas. Consulte la documentación de cada operador para obtener más información sobre los tipos de rutas compatibles.

Para buscar en varios campos indexados, utilice el método Multi() e introduzca sus campos. Los documentos que coincidan con 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 devuelve 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 devuelve 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 búsqueda de MongoDB

Puede 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 búsqueda posterior

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

Define una proyección que utiliza el método de construcción MetaSearchSequenceToken(), que especifica un PaginationToken para contener el punto de referencia
Crea una instancia SearchOptions y establece el índice y los criterios de ordenación a utilizar
Ejecuta una búsqueda inicial para encontrar documentos que tengan un valor de campo description que contenga 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 comience después del primer resultado de la búsqueda base
Ejecuta otra operación de búsqueda que tiene los mismos criterios de coincidencia y aplica 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