Texto de pesquisa

Dados de amostra

Os exemplos nesta aba usam o seguinte struct Dish como um modelo para documentos na coleção menu:

type Dish struct {
	Name        string
	Description string
}

Para executar os exemplos nesta aba, carregue os dados de amostra na coleção db.menu com o seguinte trecho:

coll := client.Database("db").Collection("menu")
docs := []interface{}{
	Dish{Name: "Shepherd’s Pie", Description: "A vegetarian take on the classic dish that uses lentils as a base. Serves 2."},
	Dish{Name: "Green Curry", Description: "A flavorful Thai curry, made vegetarian with fried tofu. Vegetarian and vegan friendly."},
	Dish{Name: "Herbed Whole Branzino", Description: "Grilled whole fish stuffed with herbs and pomegranate seeds. Serves 3-4."},
	Dish{Name: "Kale Tabbouleh", Description: "A bright, herb-based salad. A perfect starter for vegetarians and vegans."},
	Dish{Name: "Garlic Butter Trout", Description: "Baked trout seasoned with garlic, lemon, dill, and, of course, butter. Serves 2."},
}
result, err := coll.InsertMany(context.TODO(), docs)

Cada documento contém o name e description de um prato no cardápio de um restaurante.

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 description de documentos na coleção menu. Para habilitar pesquisas de texto no campo description, crie um índice de texto com o seguinte trecho:

model := mongo.IndexModel{Keys: bson.D{{"description", "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", "herb"}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Dish
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

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

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

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", "vegan -tofu"}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []Dish
if err = cursor.All(context.TODO(), &results); err != nil {
   panic(err)
}
for _, result := range results {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

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", "vegetarian"}}}}
sort := bson.D{{"score", bson.D{{"$meta", "textScore"}}}}
projection := bson.D{{"name", 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 {
   res, _ := bson.MarshalExtJSON(result, false, false)
   fmt.Println(string(res))
}

Corresponder a um termo de pesquisa

O exemplo abaixo executa uma pesquisa de texto para descrições que contêm o termo "herb":

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

Classificar por relevância

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

• Executa uma pesquisa de texto para descrições que contenham o termo "vegetariano"

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

• Inclui apenas os campos name e score no documento de saída final

matchStage := bson.D{{"$match", bson.D{{"$text", bson.D{{"$search", "vegetarian"}}}}}}
sortStage := bson.D{{"$sort", bson.D{{"score", bson.D{{ "$meta", "textScore" }}}}}}
projectStage := bson.D{{"$project", bson.D{{"name", 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 {
    res, _ := bson.MarshalExtJSON(result, false, false)
    fmt.Println(string(res))
}

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()