MongoDB Search

Dados de amostra

Os exemplos neste guia usam a coleção movies do banco de dados sample_mflix . Os documentos desta coleção contêm informações sobre filmes, incluindo título, trama, gênero e classificações. A seguinte classe Movie modela os documentos nesta coleção:

[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("paginationToken")]
    public string PaginationToken { get; set; } = null!;
}

A classe Movie faz referência à seguinte classe Imdb, que modela o campo imdb aninhado em cada documento:

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

Alguns exemplos deste guia usam coleções adicionais e classes de modelo, que são introduzidas nas seções relevantes. Todas as coleções são dos conjuntos de dados de amostra fornecidos pelo Atlas. Consulte Introdução ao driver .NET/C# para aprender como criar um cluster MongoDB gratuito e carregar esses dados de amostra.

[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

Use o método Autocomplete() para pesquisar uma palavra ou frase que contenha uma sequência de caracteres de uma string de entrada incompleta.

O exemplo seguinte executa uma consulta de preenchimento automático no campo title para texto que começa com a 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 saber mais sobre o operador autocomplete , consulte o guia do Atlas de preenchimento automático.

composto

Use o método Compound() para combinar dois ou mais operadores em uma única pesquisa.

O exemplo a seguir pesquisa a coleção movies por quaisquer documentos que correspondam a todos os seguintes critérios:

• O campo imdb.rating existe no documento

• O valor do campo rated não é "G"

• O campo year tem um valor superior a 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 saber mais sobre o operador compound, consulte o guia Atlas composto.

documento incorporado

Use o método EmbeddedDocument() para realizar operações de pesquisa em documentos dentro do valor da array de um campo.

Este exemplo utiliza a coleção restaurants do banco de dados sample_restaurants. As seguintes classes modelam os documentos nessa coleção:

[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; }
}

O exemplo a seguir pesquisa nessa coleção quaisquer restaurantes cuja array grades contenha uma entrada com um campo grade de "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 saber mais sobre o operador embeddedDocument, consulte o guia do Atlas embeddedDocument.

Iguais

Utilize o método Equals() para verificar se um campo corresponde a um valor especificado.

O exemplo a seguir pesquisa a coleção movies para quaisquer documentos nos quais o valor do campo year é 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 saber mais sobre o operador equals, consulte o guia equals do Atlas.

Existe

Use o método Exists() para pesquisar documentos nos quais existe um nome de campo indexado especificado. Se o campo especificado existir, mas não estiver indexado, o documento não será incluído com o conjunto de resultados.

O exemplo a seguir pesquisa a coleção movies para quaisquer documentos nos quais o campo imdb.rating existe. A pesquisa retorna todos os documentos nos quais o campo imdb.rating está presente:

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 saber mais sobre o operador exists, consulte o guia do Atlas existente.

Facet

Use o método Facet() para agrupar resultados por valores ou intervalos nos campos facetados especificados e retornar a contagem para cada um desses grupos.

Você pode usar o método Facet() com os estágios $search e $searchMeta. O MongoDB recomenda usar o faceta com o estágio $searchMeta para recuperar resultados de metadados somente para a query. Para recuperar resultados de metadados e queries usando o estágio $search, use a variável de agregação $$SEARCH_META. Para saber mais sobre essa variável, consulte o guia Atlas de variável de agregação SEARCH_META.

Aplicam-se as seguintes limitações:

• Você pode executar queries de facets somente em um único campo. Não é possível executar queries de atributos em grupos de campos.

• Você pode executar queries de faceta em collections fragmentadas em clusters que executam apenas o MongoDB v6.0.

O exemplo a seguir pesquisa a coleção movies em busca de quaisquer documentos nos quais o campo year tenha um valor maior ou igual a 2000. A query usa o método Facet() para processar os documentos de entrada, com um número máximo de 100 categorias de faceta para retornar nos resultados com base no campo genres. A query retorna o número de categorias de gênero distintas encontradas:

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 saber mais sobre o coletor facet, consulte o guia do Atlas facet.

GeoShape

Use o método GeoShape() para pesquisar documentos em relação a uma determinada geometria. Ao especificar as coordenadas a serem pesquisadas, a longitude deve ser especificada primeiro e, em seguida, a latitude. Os valores de longitude podem estar entre -180 e 180. Os valores de latitude podem estar entre -90 e 90.

Este exemplo utiliza a coleção theaters do banco de dados sample_mflix. As seguintes classes modelam os documentos nessa coleção:

[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!;
}

O exemplo a seguir pesquisa nessa coleção todos os documentos em que as coordenadas no campo location.geo interseccionam com um polígono especificado na área de Minnealis, NV:

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 saber mais sobre o operador geoShape, consulte o guia geoShape do Atlas.

GeoWithin

Use o método GeoWithin() para pesquisar documentos nos quais as coordenadas de seu campo GeoJSON especificado estão dentro de uma determinada geometria. Você pode pesquisar pontos que estão dentro de:

• Círculo

• Caixa delimitadora

• Polígono

Ao especificar as coordenadas a serem pesquisadas, a longitude deve ser especificada primeiro, seguida da latitude. Os valores de longitude podem estar entre -180 e 180, inclusive. Os valores de latitude podem estar entre -90 e 90, inclusive.

O exemplo a seguir pesquisa na coleção theaters todos os documentos em que as coordenadas no campo location.geo estejam dentro de um determinado polígono:

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 saber mais sobre o operador geoWithin , consulte o guia geoWithin Atlas.

In

Use o método In() para pesquisar documentos com valores de campo que correspondam a uma lista de valores especificados.

O exemplo a seguir pesquisa a coleção movies em busca de documentos que tenham uma array genres que contenha "Action" ou "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

Use o método MoreLikeThis() para pesquisar documentos semelhantes a um documento de entrada.

Este exemplo usa a seguinte classe para especificar o documento de entrada para a pesquisa:

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

O exemplo a seguir pesquisa a coleção movies em busca de documentos semelhantes a um objeto no qual o valor do campo plot é "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 saber mais sobre o operador do moreLikeThis, consulte o guia do Atlas moreLikeThis .

Aproximar

Use o método Near() para pesquisar documentos nos quais um campo especificado está próximo de um determinado valor. Você pode realizar a pesquisa em:

• Um campo de número

• Um campo de data

• Um ponto geográfico

O exemplo a seguir pesquisa a coleção movies em busca de documentos nos quais o valor do campo imdb.rating esteja próximo 8.5. Os documentos são retornados em ordem com base na proximidade do valor de 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" : "..." } }
...

To learn more about the near operator, see the near Atlas guide.

Frase

Use o método Phrase() para pesquisar documentos nos quais um campo especificado contém uma string de entrada.

O exemplo a seguir pesquisa a coleção movies em busca de documentos nos quais o campo plot contenha a 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" : "..." } }
...

Você também pode pesquisar na coleção documentos que contenham "time travel" ou "space adventure" no 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 saber mais sobre o operador phrase , consulte a frase Guia do Atlas.

QueryString

Use o método QueryString() para pesquisar documentos usando uma string com os seguintes operadores e delimitadores:

• AND

• OR

• NOT

• ()

O exemplo a seguir pesquisa na coleção movies documentos nos quais o valor do campo plot corresponda a cada um dos seguintes critérios:

• Contém a string "time" ou a string "space"

• Não contém a 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 saber mais sobre o operador queryString, consulte o guia queryString do Atlas.

faixa

Use o método Range() para pesquisar documentos nos quais o valor de um campo especificado esteja dentro de um determinado intervalo numérico, de data ou de string.

O exemplo a seguir pesquisa na coleção movies todos os documentos com um valor year maior que 2000 e 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 pesquisar documentos nos quais o valor de um campo especificado esteja dentro de uma faixa de strings, você deve primeiro criar um índice de token no campo. Depois de criar o índice, você pode pesquisar documentos com base em uma faixa de strings. O exemplo a seguir retorna documentos em que o valor do campo title cai entre "A" e "G", comparado em ordem lexicográfica:

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 saber mais sobre o operador range, consulte o guia Atlas de intervalos.

expressão regular

Use o método Regex() para pesquisar documentos usando uma expressão regular.

O exemplo seguinte pesquisa a coleção movies para documentos em que o valor do campo title contém exatamente 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 saber mais sobre o operador regex , consulte o guia regex Atlas.

Espanha

Utilize o método Span() para pesquisar correspondências de pesquisa de texto dentro de regiões de um campo. Você pode usar este método para encontrar strings próximas umas das outras com graus de precisão especificados.

O exemplo a seguir pesquisa na coleção movies os documentos em que o valor do campo plot contém as strings "time" e "travel" dentro de uma palavra de cada:

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 saber mais sobre o operador span , consulte o guia do Atlas de extensão .

Text

Use o método Text() para fazer uma pesquisa de uma determinada string ou array de strings em um documento. Se houver vários termos em uma determinada string, o MongoDB pesquisa também procurará uma correspondência para cada termo na string separadamente.

O exemplo a seguir pesquisa a coleção movies em busca de documentos nos quais o valor do campo plot contém a 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 saber mais sobre o operador text, consulte o guia texto do Atlas.

Curinga

Use o método Wildcard() para pesquisar documentos usando caracteres especiais em sua sequência de pesquisa que podem corresponder a qualquer caractere. Você pode usar os seguintes caracteres em sua pesquisa:

O exemplo a seguir pesquisa documentos nos quais o valor do campo title contém a string "Amer" seguida por qualquer outro caractere:

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 saber mais sobre o operador wildcard, consulte o guia do Atlas de curingas.

Campo Único

Utilize o método Single() para especificar um campo como o caminho da pesquisa. Os exemplos a seguir mostram três maneiras de especificar o campo: usando uma expressão lambda com um modelo digitado, passando um nome de campo de string como uma variável fieldName ou parâmetro de método cujo valor é conhecido no tempo de execução ou usando um documento não digitado .

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" : "...", "...": "..." },
  "..."
]

Vários campos

Utilize o método Multi() para especificar o caminho de pesquisa para vários campos. O conjunto de resultados inclui documentos que correspondem a qualquer um dos campos especificados.

O exemplo a seguir procura a frase "time travel" no campo plot ou 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" },
  "..."
]

Analisador

Os analisadores processam texto em tokens pesquisáveis aplicando operações como minúsculas. O MongoDB Server aplica um analisador ao indexar um campo e novamente ao executar uma query nesse campo. Se você especificar a opção multi ao criar um índice de pesquisa, o MongoDB Server também armazenará um segundo conjunto de tokens produzido por um analisador alternativo.

Você pode utilizar o método Analyzer() para executar uma query nos tokens produzidos por um analisador multi em vez dos tokens produzidos pelo analisador padrão do campo. O nome que você passa para Analyzer() deve ser o nome da chave do bloco multi em sua definição de índice, não o nome do analisador subjacente.

O exemplo a seguir usa um analisador multi chamado "lucene" para pesquisar no campo title documentos que contenham o 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" },
  "..."
]

Caminho curinga

Utilize o método Wildcard() para especificar um caminho de pesquisa que utiliza caracteres curinga para corresponder aos nomes dos campo . Você pode usar o caractere * no nome do campo para corresponder a qualquer sequência de caracteres.

O MongoDB Server pesquisa apenas campos que atendam às seguintes condições:

• O campo deve ser indexado.

• O nome do campo deve corresponder ao padrão especificado.

• O tipo de dados do campo deve corresponder ao operador de pesquisa. Por exemplo, uma query Text() pesquisa somente campos de string.

O exemplo a seguir pesquisa todos os campos cujos nomes começam com "p" para documentos que contêm o 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 saber mais sobre caminhos curinga, consulte Construir um Caminho de Query na documentação do Atlas .

Exemplo de SearchAfter

O exemplo a seguir pagina os resultados de uma operação MongoDB pesquisa executando as seguintes ações:

• Define uma projeção que utiliza o método construtor MetaSearchSequenceToken(), que especifica um PaginationToken para conter o ponto de referência

• Cria uma instância SearchOptions e define o índice e os critérios de classificação a serem utilizados.

• Executa uma pesquisa inicial para encontrar documentos que possuam um valor no campo plot que contenha o texto "time travel", aplicando a projeção e as opções à operação

• Configura a propriedade SearchAfter da mesma instância SearchOptions para instruir a próxima pesquisa a iniciar após o primeiro resultado da pesquisa base

• Executa outra operação de pesquisa que possui os mesmos critérios de correspondência e aplica as opções de pesquisa para paginar os 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" : "..." } }
...