Texto de pesquisa

Dados de amostra

Para executar os exemplos neste guia, carregue os dados de amostra na collection marvel.movies com o seguinte trecho:

coll := client.Database("marvel").Collection("movies")
docs := []interface{}{
	bson.D{{"title", "Captain America: Civil War"}, {"year", 2016}},
	bson.D{{"title", "The Avengers"}, {"year", 2012}},
	bson.D{{"title", "Captain America: The Winter Soldier"}, {"year", 2014}},
	bson.D{{"title", "Avengers: Infinity War"}, {"year", 2018}},
	bson.D{{"title", "Captain America: The First Avenger"}, {"year", 2011}},
}
result, err := coll.InsertMany(context.TODO(), docs)
if err != nil {
	panic(err)
}
fmt.Printf("Number of documents inserted: %d\n", len(result.InsertedIDs))

Cada documento contém o nome e o ano de lançamento do filme da Márvel que corresponde aos campos title e year .

Text Index

Você deve criar um índice de texto antes de executar uma pesquisa de texto. Um índice de texto especifica a string ou o campo de array de strings no qual executar uma pesquisa de texto.

Os exemplos nas seções seguintes executam pesquisas de texto no campo title na coleção movies . Para habilitar pesquisas de texto no campo title , crie um índice de texto com o seguinte trecho:

model := mongo.IndexModel{Keys: bson.D{{"title", "text"}}}
name, err := coll.Indexes().CreateOne(context.TODO(), model)
if err != nil {
	panic(err)
}
fmt.Println("Name of Index Created: " + name)

Pesquisar por um termo

Para pesquisar um termo, especifique o termo como uma string em seu filtro de query. Para pesquisar vários termos, separe cada termo com espaços na string.

filter := bson.D{{"$text", bson.D{{"$search", "War"}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Pesquisar por frase

Para pesquisar uma frase, especifique a frase com aspas escapadas como uma string em seu filtro de query. Se você não adicionar aspas escapadas ao redor da frase, o método Find() executará uma pesquisa de termo .

filter := bson.D{{"$text", bson.D{{"$search", "\"Infinity War\""}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Pesquisar com Termos Excluídos

Para cada termo ou frase que você deseja excluir da pesquisa de texto, especifique o termo ou frase prefixada com um sinal de subtração como uma string no filtro de query.

filter := bson.D{{"$text", bson.D{{"$search", "Avenger -\"Captain America\""}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Classificar por relevância

Uma pesquisa de texto atribui uma pontuação numérica de texto para indicar até que ponto cada resultado corresponde à string em seu filtro de query. Para revelar a pontuação de texto em sua saída, utilize uma projeção para recuperar os metadados do textScore. Você pode classificar a pontuação do texto em ordem decrescente especificando uma classificação nos metadados do textScore.

filter := bson.D{{"$text", bson.D{{"$search", "Avenger"}}}}
sort := bson.D{{"score", bson.D{{"$meta", "textScore"}}}}
projection := bson.D{{"title", 1}, {"score", bson.D{{"$meta", "textScore"}}}, {"_id", 0}}
opts := options.Find().SetSort(sort).SetProjection(projection)
cursor, err := coll.Find(context.TODO(), filter, opts)
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Exemplo de pesquisa de termo

O exemplo abaixo executa uma pesquisa de texto para títulos que contenham o termo "Winter":

matchStage := bson.D{{"$match", bson.D{{"$text", bson.D{{"$search", "Winter"}}}}}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage})
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Exemplo de pontuação de texto

O exemplo a seguir executa as seguintes ações:

• Executa uma pesquisa de texto para títulos que contenham o termo "Avenger"

• Classifica os resultados em ordem decrescente com base em sua pontuação de texto

• Inclui os campos title e score dos resultados

matchStage := bson.D{{"$match", bson.D{{"$text", bson.D{{"$search", "Avenger"}}}}}}
sortStage := bson.D{{"$sort", bson.D{{"score", bson.D{{ "$meta", "textScore" }}}}}}
projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"score", bson.D{{ "$meta", "textScore" }}}, {"_id", 0}}}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage, sortStage, projectStage})
if err != nil {
   panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
   fmt.Println(result)
}

Documentação da API

Para saber mais sobre qualquer um dos métodos ou tipos discutidos neste guia, consulte a seguinte documentação da API:

• Find()

• FindOptions.SetSort()

• FindOptions.SetProjection()