Búsqueda de texto

Datos de muestra

Los ejemplos en esta guía utilizan lo siguiente Dish struct como modelo para documentos en la colección menu:

type Dish struct {
	Name        string
	Description string
}

Para ejecutar los ejemplos en esta guía, carga los datos de muestra en la colección db.menu con el siguiente fragmento:

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 contiene el name y el description de un plato en el menú de un restaurante.

Text Index

Debes crear un índice de texto antes de ejecutar una búsqueda de texto. Un índice de texto especifica el campo de string o arreglo de strings en el que se realiza una búsqueda de texto.

Los ejemplos en las siguientes secciones realizan búsquedas de texto en el campo description de los documentos en la colección menu. Para habilitar búsquedas de texto en el campo description, crea un índice de texto con el siguiente snippet:

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)

Buscar por un término

Para buscar un término, especifica el término como un string en tu filtro de query. Para buscar varios términos, separa cada término con espacios en la 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))
}

{"name":"Kale Tabbouleh","description":"A bright, herb-based salad. A perfect starter for vegetarians and vegans."}
{"name":"Herbed Whole Branzino","description":"Grilled whole fish stuffed with herbs and pomegranate seeds. Serves 3-4."}

Búsqueda por una frase

Para buscar una frase, especifíquela con comillas escapadas como una string en el filtro de query. Si no se agregan comillas escapadas alrededor de la frase, el método Find() ejecuta una búsqueda de términos.

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

{"name":"Shepherd's Pie","description":"A vegetarian take on the classic dish that uses lentils as a base. Serves 2."}
{"name":"Garlic Butter Trout","description":"Baked trout seasoned with garlic, lemon, dill, and, of course, butter. Serves 2."}

Buscar con términos excluidos

Para cada término o frase que desee excluir de su búsqueda de texto, especifique el término o frase precedido de un signo menos como una string en su 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))
}

{"name":"Kale Tabbouleh","description":"A bright, herb-based salad. A perfect starter for vegetarians and vegans."}

Ordenar por Relevancia

Una búsqueda de texto asigna una puntuación numérica de texto para indicar qué tan exactamente cada resultado coincide con la string en tu filtro de query. Para mostrar la puntuación de texto en tu resultado, utiliza una proyección para recuperar los metadatos textScore. Puede ordenar la puntuación del texto en orden descendente especificando un criterio de clasificación en los metadatos 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))
}

{"name":"Green Curry","score":0.8999999999999999}
{"name":"Kale Tabbouleh","score":0.5625}
{"name":"Shepherd's Pie","score":0.5555555555555556}

Coincidir con un término de búsqueda

El siguiente ejemplo ejecuta una búsqueda de texto para descripciones que contengan el término "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))
}

{"name":"Kale Tabbouleh","description":"A bright, herb-based salad. A perfect starter for vegetarians and vegans."}
{"name":"Herbed Whole Branzino","description":"Grilled whole fish stuffed with herbs and pomegranate seeds. Serves 3-4."}

Ordenar por Relevancia

El siguiente ejemplo realiza las siguientes acciones:

• Ejecuta una búsqueda de texto para descripciones que contengan el término “vegetariano”

• Ordena los resultados en orden descendente en base a su puntuación de texto

• Incluye solamente los campos name y score en el documento de salida 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))
}

{"name":"Green Curry","score":0.8999999999999999}
{"name":"Kale Tabbouleh","score":0.5625}
{"name":"Shepherd's Pie","score":0.5555555555555556}

Documentación de la API

Para obtener más información sobre cualquiera de los métodos o tipos discutidos en esta guía, consultar la siguiente documentación de la API:

• find()

• FindOptions.SetSort()

• FindOptions.SetProjection()