Realizar una consulta de texto

Datos de muestra

Los ejemplos en esta guía utilizan lo siguiente Dish Estructura como modelo para los documentos de 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 := []any{
	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

Debe crear un índice de texto antes de ejecutar una query 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 de las siguientes secciones ejecutan consultas de query en el campo description de los documentos de la colección menu. Para habilitar queries 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 desees excluir de tu query de texto, especifica el término o frase prefijado con un signo menos como una string en tu 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 query de texto asigna una puntuación numérica de texto para indicar el grado de coincidencia de cada resultado con la string en tu filtro de query. Para revelar el puntaje de texto en tu salida, utiliza una proyección para recuperar los metadatos de textScore. Puede ordenar la puntuación de texto en orden descendente especificando un criterio de orden 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 consulta de texto para descripciones que contienen el término "hierba":

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 consulta de texto para descripciones que contienen el término "vegetariano".

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

• Incluye solo 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()

• FindOptionsBuilder.SetSort()

• FindOptionsBuilder.SetProjection()