MongoDB búsqueda

Datos de muestra

Los ejemplos de esta guía utilizan la colección movies de la base de datos sample_mflix. Los documentos de esta colección contienen información sobre películas, incluyendo sus títulos, tramas, género y valoraciones. La siguiente Movie clase modela los documentos de esta colección:

[BsonIgnoreExtraElements]
public class Movie
{
    [BsonId]
    public ObjectId Id { get; set; }
    public string Title { get; set; } = null!;
    public string Plot { get; set; } = null!;
    public string[] Genres { get; set; } = null!;
    public int Year { get; set; }
    public string Rated { get; set; } = null!;
    public Imdb Imdb { get; set; } = null!;
    [BsonElement("plot_embedding")]
    public float[] PlotEmbedding { get; set; } = null!;
    public double Score { get; set; }
    [BsonElement("scoreDetails")]
    [BsonIgnoreIfNull]
    public SearchScoreDetails ScoreDetails { get; set; } = null!;
    [BsonElement("paginationToken")]
    public string PaginationToken { get; set; } = null!;
}

La clase Movie referencia la siguiente clase Imdb, que modela el campo anidado imdb en cada documento:

[BsonIgnoreExtraElements]
public class Imdb
{
    public double Rating { get; set; }
    public int Votes { get; set; }
    public int Id { get; set; }
}

Algunos ejemplos en esta guía utilizan colecciones adicionales y clases de modelo, que se presentan en las secciones pertinentes. Todas las colecciones provienen de los conjuntos de datos de muestra proporcionados por Atlas. Consulta Comienza con el controlador .NET/C# para aprender cómo crear un clúster gratuito de MongoDB y cargar estos datos de muestra.

[BsonIgnoreExtraElements]
public class Imdb
{
    [BsonSerializer(typeof(FlexibleDoubleSerializer))]
    public double Rating { get; set; }
    [BsonSerializer(typeof(FlexibleInt32Serializer))]
    public int Votes { get; set; }
    public int Id { get; set; }
}

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 consulta de autocompletado en el campo title para texto que comienza con la string "Gravity":

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Autocomplete(m => m.Title, "Gravity"), indexName: "movietitles")
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Gravity", "plot" : "...", "genres" : ["Drama", "Sci-Fi", "Thriller"], "year" : 2013, "rated" : "PG-13", "imdb" : { "rating" : 7.7, "votes" : "...", "id" : "..." } }
...

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 movies collection for any documents that match all the following criteria:

• El campo imdb.rating existe en el documento

• El valor del campo rated no es "G"

• El campo year tiene un valor mayor que 2000

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Compound()
        .Must(Builders<Movie>.Search.Exists(m => m.Imdb.Rating))
        .MustNot(Builders<Movie>.Search.Equals(m => m.Rated, "G"))
        .Must(Builders<Movie>.Search.Range(m => m.Year, SearchRangeBuilder.Gt(2000))))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Dark Knight", "plot" : "...", "genres" : ["Action", "Crime", "Drama"], "year" : 2008, "rated" : "PG-13", "imdb" : { "rating" : 9.0, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Inception", "plot" : "...", "genres" : ["Action", "Adventure", "Sci-Fi"], "year" : 2010, "rated" : "PG-13", "imdb" : { "rating" : 8.8, "votes" : "...", "id" : "..." } }
...

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.

Este ejemplo utiliza la colección restaurants de la base de datos sample_restaurants. Las siguientes clases modelan los documentos en esa colección:

[BsonIgnoreExtraElements]
public class Restaurant
{
    [BsonId]
    public ObjectId Id { get; set; }
    public string Name { get; set; } = null!;
    public string Cuisine { get; set; } = null!;
    public string Borough { get; set; } = null!;
    public List<GradeEntry> Grades { get; set; } = null!;
}

[BsonIgnoreExtraElements]
public class GradeEntry
{
    public string Grade { get; set; } = null!;
    public int? Score { get; set; }
}

El siguiente ejemplo busca en esa colección cualquier restaurante cuyo arreglo grades contenga una entrada con un valor de campo grade igual a "A":

var result = restaurantsCollection.Aggregate()
    .Search(Builders<Restaurant>.Search.EmbeddedDocument(
        r => r.Grades,
        Builders<GradeEntry>.Search.Equals(g => g.Grade, "A")
    ), indexName: "restaurantsembedded").ToList();

...
{ "_id" : ObjectId("..."), "name" : "Riviera Caterer", "cuisine" : "American", "borough" : "Brooklyn", "grades" : [{ "grade" : "A", "score" : 5 }, { "grade" : "B", "score" : 23 }] }
...

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.

El siguiente ejemplo busca en la colección movies cualquier documento en el que el valor del campo year sea 2000:

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Equals(m => m.Year, 2000))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Gladiator", "plot" : "...", "genres" : ["Action", "Adventure", "Drama"], "year" : 2000, "rated" : "R", "imdb" : { "rating" : 8.5, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Cast Away", "plot" : "...", "genres" : ["Adventure", "Drama", "Romance"], "year" : 2000, "rated" : "PG-13", "imdb" : { "rating" : 7.8, "votes" : "...", "id" : "..." } }
...

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

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.

El siguiente ejemplo busca en la colección movies cualquier documento en el que exista el campo imdb.rating. La búsqueda devuelve todos los documentos en los que está presente el campo imdb.rating:

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Exists(m => m.Imdb.Rating))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Godfather", "plot" : "...", "genres" : ["Crime", "Drama"], "year" : 1972, "rated" : "R", "imdb" : { "rating" : 9.2, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "The Shawshank Redemption", "plot" : "...", "genres" : ["Drama"], "year" : 1994, "rated" : "R", "imdb" : { "rating" : 9.3, "votes" : "...", "id" : "..." } }
...

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.

El siguiente ejemplo busca en la colección movies cualquier documento en el que el campo year tenga un valor mayor o igual que 2000. La query utiliza el método Facet() para procesar los documentos de entrada, con un número máximo de 100 categorías de facetas a devolver en los resultados basados en el campo genres. La query devuelve el número de categorías de géneros distintos que se han encontrado:

var result = moviesCollection.Aggregate()
    .SearchMeta(
        Builders<Movie>.Search.Facet(
            Builders<Movie>.Search.Range(m => m.Year, SearchRangeBuilder.Gte(2000)),
            Builders<Movie>.SearchFacet.String("genres", m => m.Genres, 100)),
        indexName: "moviesfacetsearch")
    .Single()
    .Facet["genres"].Buckets.Count();

23

Para obtener más información sobre el colector facet, consulta la guía faceta 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.

Este ejemplo utiliza la colección theaters de la base de datos sample_mflix. Las siguientes clases modelan los documentos en esa colección:

[BsonIgnoreExtraElements]
public class Theater
{
    [BsonId]
    public ObjectId Id { get; set; }
    public int TheaterId { get; set; }
    public TheaterLocation Location { get; set; } = null!;
}

[BsonIgnoreExtraElements]
public class TheaterLocation
{
    [BsonElement("geo")]
    public GeoJsonPoint<GeoJson2DGeographicCoordinates> Geo { get; set; } = null!;
}

El siguiente ejemplo busca en esa colección todos los documentos en los que las coordenadas en el campo location.geo se intersecan con un polígono especificado en el área de Minneapolis, MN:

GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
{
    new(-93.5, 44.7),
    new(-93.5, 45.0),
    new(-93.0, 45.0),
    new(-93.0, 44.7),
    new(-93.5, 44.7),
})));
var result = theatersCollection.Aggregate()
    .Search(Builders<Theater>.Search.GeoShape(
        t => t.Location.Geo, GeoShapeRelation.Intersects, searchArea),
        indexName: "theatersgeo")
    .ToList();

...
{ "_id" : ObjectId("..."), "theaterId" : 1000, "location" : { "geo" : { "type" : "Point", "coordinates" : [-93.24565, 44.85466] } } }
...

Para aprender más sobre el operador de geoShape , se puede consultar la guía de geoShape de Atlas.

geoWithin

Utiliza el método GeoWithin() para buscar documentos en los que las coordenadas de su campo GeoJSON especificado se encuentren dentro de una geometría dada. Puede buscar puntos que estén dentro de un:

• 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.

El siguiente ejemplo busca en la colección theaters todos los documentos en los que las coordenadas en el campo location.geo se encuentran dentro de un polígono especificado:

GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
{
    new(-94.0, 44.5),
    new(-94.0, 45.2),
    new(-92.5, 45.2),
    new(-92.5, 44.5),
    new(-94.0, 44.5),
})));
var result = theatersCollection.Aggregate()
    .Search(Builders<Theater>.Search.GeoWithin(t => t.Location.Geo, searchArea),
        indexName: "theatersgeo")
    .ToList();

...
{ "_id" : ObjectId("..."), "theaterId" : 1000, "location" : { "geo" : { "type" : "Point", "coordinates" : [-93.24565, 44.85466] } } }
...

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

En

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

El siguiente ejemplo busca en la colección movies documentos que tengan un arreglo genres que contenga "Action" o "Comedy":

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.In(m => m.Genres, new[] { "Action", "Comedy" }))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Home Alone", "plot" : "...", "genres" : ["Comedy", "Family"], "year" : 1990, "rated" : "PG", "imdb" : { "rating" : 7.4, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Die Hard", "plot" : "...", "genres" : ["Action", "Thriller"], "year" : 1988, "rated" : "R", "imdb" : { "rating" : 8.2, "votes" : "...", "id" : "..." } }
...

moreLikeThis

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

Este ejemplo utiliza la siguiente clase para especificar el documento de entrada para la búsqueda:

public class MovieSearch
{
    public string Plot { get; set; } = null!;
}

El siguiente ejemplo busca en la colección movies documentos similares a un objeto en el que el valor del campo plot es "time travel":

var searchDocument = new MovieSearch()
{
    Plot = "time travel",
};
var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.MoreLikeThis(searchDocument))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Thrill Seekers", "plot" : "...", "genres" : ["Action", "Sci-Fi", "Thriller"], "year" : 1999, "rated" : "...", "imdb" : { "rating" : "...", "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "About Time", "plot" : "...", "genres" : ["Drama", "Fantasy", "Romance"], "year" : 2013, "rated" : "R", "imdb" : { "rating" : 7.8, "votes" : "...", "id" : "..." } }
...

Para aprender más sobre el operador moreLikeThis, se puede consultar la guía de 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

El siguiente ejemplo busca en la colección movies aquellos documentos en los que el valor del campo imdb.rating se encuentra cerca de 8.5. Los documentos se muestran en orden según qué tan cercano esté el valor a 8.5:

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Near(m => m.Imdb.Rating, 8.5, 1))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Dark Knight", "plot" : "...", "genres" : ["Action", "Crime", "Drama"], "year" : 2008, "rated" : "PG-13", "imdb" : { "rating" : 9.0, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "The Godfather", "plot" : "...", "genres" : ["Crime", "Drama"], "year" : 1972, "rated" : "R", "imdb" : { "rating" : 9.2, "votes" : "...", "id" : "..." } }
...

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.

El siguiente ejemplo registra la colección movies para documentos en los que, el campo plot contiene la frase "time travel":

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Phrase(m => m.Plot, "time travel"))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Time Traveler's Wife", "plot" : "...", "genres" : ["Drama", "Fantasy", "Romance"], "year" : 2009, "rated" : "PG-13", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Safety Not Guaranteed", "plot" : "...", "genres" : ["Comedy", "Drama", "Romance"], "year" : 2012, "rated" : "R", "imdb" : { "rating" : 7, "votes" : "...", "id" : "..." } }
...

También puede buscar en la colección documentos que contengan "time travel" o "space adventure" en el campo plot:

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Phrase(m => m.Plot, new List<string>() { "time travel", "space adventure" }))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Time Traveler's Wife", "plot" : "...", "genres" : ["Drama", "Fantasy", "Romance"], "year" : 2009, "rated" : "PG-13", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Safety Not Guaranteed", "plot" : "...", "genres" : ["Comedy", "Drama", "Romance"], "year" : 2012, "rated" : "R", "imdb" : { "rating" : 7, "votes" : "...", "id" : "..." } }
...

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 movies collection for documents in which the value of the plot field matches each of the following criteria:

• Incluye la cadena "time" o la cadena "space"

• No contiene la string "comedy"

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.QueryString(m => m.Plot, "(time OR space) AND NOT comedy"))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Interstellar", "plot" : "...", "genres" : ["Adventure", "Drama", "Sci-Fi"], "year" : 2014, "rated" : "PG-13", "imdb" : { "rating" : 8.7, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Tomorrowland", "plot" : "...", "genres" : ["Action", "Adventure", "Family"], "year" : 2015, "rated" : "PG", "imdb" : { "rating" : 6.6, "votes" : "...", "id" : "..." } }
...

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.

El siguiente ejemplo busca en la colección movies todos los documentos con un valor year mayor que 2000 y menor que 2010:

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search
    .Range(m => m.Year, SearchRangeBuilder.Gt(2000).Lt(2010)))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Dark Knight", "plot" : "...", "genres" : ["Action", "Crime", "Drama"], "year" : 2008, "rated" : "PG-13", "imdb" : { "rating" : 9.0, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "The Departed", "plot" : "...", "genres" : ["Crime", "Drama", "Thriller"], "year" : 2006, "rated" : "R", "imdb" : { "rating" : 8.5, "votes" : "...", "id" : "..." } }
...

Para buscar documentos en los que el valor de un campo específico esté dentro de un rango de cadenas, primero debes crear un índice de token en el campo. Después de crear el índice, puedes buscar documentos en función de un rango de cadenas. El siguiente ejemplo devuelve documentos en los que el valor del campo title se encuentra entre "A" y "G", en comparación con el orden lexicográfico:

var result = moviesCollection.Aggregate()
     .Search(Builders<Movie>.Search
     .Range(m => m.Title, SearchRangeV2Builder.Gte("A").Lte("G")))
     .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Apollo 13", "plot" : "...", "genres" : ["Adventure", "Drama", "History"], "year" : 1995, "rated" : "PG", "imdb" : { "rating" : 7.6, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Braveheart", "plot" : "...", "genres" : ["Biography", "Drama", "History"], "year" : 1995, "rated" : "R", "imdb" : { "rating" : 8.3, "votes" : "...", "id" : "..." } }
...

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.

El siguiente ejemplo busca en la colección movies documentos en los que el valor del campo title contenga exactamente seis letras:

var regex = "[A-Za-z]{6}";
var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Regex(m => m.Title, regex,
        allowAnalyzedField: true))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Gandhi", "plot" : "...", "genres" : ["Biography", "Drama", "History"], "year" : 1982, "rated" : "PG", "imdb" : { "rating" : 8.0, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "Batman", "plot" : "...", "genres" : ["Action", "Adventure"], "year" : 1989, "rated" : "PG-13", "imdb" : { "rating" : 7.5, "votes" : "...", "id" : "..." } }
...

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Regex(m => m.Title, regex,
        allowAnalyzedField: true))
    .ToList();

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.

El siguiente ejemplo busca en la colección movies los documentos en los que el valor del campo plot contiene las cadenas "time" y "travel" dentro de una palabra de distancia la una de la otra:

var searchTerms = new[]
{
    Builders<Movie>.SearchSpan.Term(m => m.Plot, "time"),
    Builders<Movie>.SearchSpan.Term(m => m.Plot, "travel")
};
var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Span(Builders<Movie>.SearchSpan.Near(searchTerms, 1)))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "The Time Traveler's Wife", "plot" : "...", "genres" : ["Drama", "Fantasy", "Romance"], "year" : 2009, "rated" : "PG-13", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "About Time", "plot" : "...", "genres" : ["Drama", "Fantasy", "Romance"], "year" : 2013, "rated" : "R", "imdb" : { "rating" : 7.8, "votes" : "...", "id" : "..." } }
...

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

Text

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

El siguiente ejemplo busca en la colección movies los documentos en los que el valor del campo plot contiene la string "secret agent":

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Text(m => m.Plot, "secret agent"))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "Spy Kids", "plot" : "...", "genres" : ["Action", "Adventure", "Comedy"], "year" : 2001, "rated" : "PG", "imdb" : { "rating" : 5.4, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "The Spy Who Loved Me", "plot" : "...", "genres" : ["Action", "Adventure", "Thriller"], "year" : 1977, "rated" : "PG", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } }
...

Para aprender más sobre el operador text, consulta la guía Atlas de texto.

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:

El siguiente ejemplo busca documentos en los que el valor del campo title contiene la string "Amer" seguida de cualquier otro carácter:

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Wildcard(m => m.Title, "Amer*", allowAnalyzedField: true))
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "American Beauty", "plot" : "...", "genres" : ["Drama"], "year" : 1999, "rated" : "R", "imdb" : { "rating" : 8.4, "votes" : "...", "id" : "..." } }
{ "_id" : ObjectId("..."), "title" : "American Gangster", "plot" : "...", "genres" : ["Biography", "Crime", "Drama"], "year" : 2007, "rated" : "R", "imdb" : { "rating" : 7.8, "votes" : "...", "id" : "..." } }
...

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Wildcard(m => m.Title, "Amer*", allowAnalyzedField: true))
    .ToList();

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

Campo único

Utilice el método Single() para especificar un campo como la ruta de búsqueda. Los siguientes ejemplos muestran tres formas de especificar el campo: utilizando una expresión lambda con un modelo tipado, pasando un nombre de campo en forma de string como una variable fieldName o un parámetro de método conocido durante la ejecución, o utilizando un documento sin tipo.

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Text(
        Builders<Movie>.SearchPath.Single(m => m.Plot), "secret agent"))
    .ToList();

[
  "...",
  { "_id" : ObjectId("..."), "title" : "Spy Kids", "plot" : "...", "genres" : ["Action", "Adventure", "Comedy"], "year" : 2001, "rated" : "PG", "imdb" : { "rating" : 5.4, "votes" : "...", "id" : "..." } },
  "...",
  { "_id" : ObjectId("..."), "title" : "The Spy Who Loved Me", "plot" : "...", "genres" : ["Action", "Adventure", "Thriller"], "year" : 1977, "rated" : "PG", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } },
  "..."
]

FieldDefinition<Movie> runtimeField = fieldName;
var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Text(
        Builders<Movie>.SearchPath.Single(runtimeField), "secret agent"))
    .ToList();

[
  "...",
  { "_id" : ObjectId("..."), "title" : "Spy Kids", "plot" : "...", "genres" : ["Action", "Adventure", "Comedy"], "year" : 2001, "rated" : "PG", "imdb" : { "rating" : 5.4, "votes" : "...", "id" : "..." } },
  "...",
  { "_id" : ObjectId("..."), "title" : "The Spy Who Loved Me", "plot" : "...", "genres" : ["Action", "Adventure", "Thriller"], "year" : 1977, "rated" : "PG", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } },
  "..."
]

var result = moviesCollectionBson.Aggregate()
    .Search(Builders<BsonDocument>.Search.Text(
        Builders<BsonDocument>.SearchPath.Single("plot"), "secret agent"))
    .ToList();

[
  "...",
  { "_id" : ObjectId("..."), "title" : "Spy Kids", "plot" : "...", "...": "..." },
  "...",
  { "_id" : ObjectId("..."), "title" : "The Spy Who Loved Me", "plot" : "...", "...": "..." },
  "..."
]

Campos múltiples

Utiliza el método Multi() para especificar la ruta de búsqueda de varios campos. El conjunto de resultados incluye documentos que coinciden con cualquiera de los campos especificados.

El siguiente ejemplo busca la frase "time travel" ya sea en el campo plot o title:

var result = moviesCollection.Aggregate().Search(
    Builders<Movie>.Search.Phrase(Builders<Movie>.SearchPath
    .Multi(m => m.Plot, m => m.Title), "time travel"), indexName: "moviesmulti")
    .ToList();

[
  "...",
  { "title" : "Safety Not Guaranteed", "year" : 2012, "rated" : "R" },
  { "title" : "The Time Traveler's Wife", "year" : 2009, "rated" : "PG-13" },
  "..."
]

Analizador

Los analizadores procesan el texto en tokens buscables aplicando operaciones como la conversión a minúsculas. MongoDB Server aplica un analizador al indexar un campo y nuevamente al ejecutar una query en ese campo. Si especificas la opción multi al crear un índice de búsqueda, el MongoDB Server también almacena un segundo conjunto de tokens producidos por un analizador alternativo.

Puede usar el método Analyzer() para ejecutar una query contra los tokens producidos por un analizador multi en lugar de los tokens producidos por el analizador predeterminado del campo. El nombre que pases a Analyzer() debe ser el nombre clave del bloque multi en tu definición de índice, no el nombre del analizador subyacente.

El siguiente ejemplo utiliza un analizador multi denominado "lucene" para buscar en el campo title documentos que contienen el texto "gravity":

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Text(
        Builders<Movie>.SearchPath.Analyzer(m => m.Title, "lucene"),
        "gravity"), indexName: "moviesanalyzer")
    .ToList();

[
  "...",
  { "title" : "Gravity", "year" : 2013, "rated" : "PG-13" },
  "..."
]

Ruta comodín

Utiliza el método Wildcard() para establecer una ruta de búsqueda que emplee caracteres comodín para hacer coincidir nombres de campos. Puedes utilizar el carácter * en el nombre del campo para que coincida con cualquier secuencia de caracteres.

MongoDB Server busca solo campos que cumplan las siguientes condiciones:

• El campo debe estar indexado.

• El nombre del campo debe coincidir con el patrón especificado.

• El tipo de dato del campo debe coincidir con el operador de búsqueda. Por ejemplo, una consulta Text() busca solo en campos de string.

El siguiente ejemplo busca en todos los campos cuyos nombres empiezan por "p" documentos que contienen el texto "secret agent":

var result = moviesCollection.Aggregate()
    .Search(Builders<Movie>.Search.Text(
        Builders<Movie>.SearchPath.Wildcard("p*"), "secret agent"))
    .ToList();

[
  "...",
  { "_id" : ObjectId("..."), "title" : "Spy Kids", "plot" : "...", "genres" : ["Action", "Adventure", "Comedy"], "year" : 2001, "rated" : "PG", "imdb" : { "rating" : 5.4, "votes" : "...", "id" : "..." } },
  "...",
  { "_id" : ObjectId("..."), "title" : "The Spy Who Loved Me", "plot" : "...", "genres" : ["Action", "Adventure", "Thriller"], "year" : 1977, "rated" : "PG", "imdb" : { "rating" : 7.1, "votes" : "...", "id" : "..." } },
  "..."
]

Para obtener más información sobre las rutas comodín, consulte Construir una ruta de query en la documentación de Atlas.

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 plot con el texto "time travel", 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<Movie>.Projection
    .Include(x => x.Title)
    .MetaSearchSequenceToken(x => x.PaginationToken);
var searchDefinition = Builders<Movie>.Search.Text(m => m.Plot, "time travel");
var searchOptions = new SearchOptions<Movie>
{ IndexName = "default", Sort = Builders<Movie>.Sort.Ascending(m => m.Id) };
// Runs the base search operation
var baseSearchResults = moviesCollection.Aggregate()
    .Search(searchDefinition, searchOptions)
    .Project<Movie>(projection)
    .ToList();
if (baseSearchResults.Count == 0)
    return baseSearchResults;
// Sets the starting point for the next search
searchOptions.SearchAfter = baseSearchResults[0].PaginationToken;
var result = moviesCollection.Aggregate()
    .Search(searchDefinition, searchOptions)
    .Project<Movie>(projection)
    .ToList();

...
{ "_id" : ObjectId("..."), "title" : "About Time", "plot" : "...", "genres" : ["Comedy", "Drama", "Romance"], "year" : 2013, "rated" : "R", "imdb" : { "rating" : 7.8, "votes" : "...", "id" : "..." } }
...