Search Text

Sample Data

To run the examples in this guide, load the sample data into the marvel.movies collection with the following snippet:

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

Each document contains the name and release year of the Marvel movie that corresponds to the title and year fields.

Text Index

You must create a text index before running a text search. A text index specifies the string or string array field on which to run a text search.

The examples in the following sections run text searches on the title field in the movies collection. To enable text searches on the title field, create a text index with the following snippet:

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)

Search by a Term

To search for a term, specify the term as a string in your query filter. To search for multiple terms, separate each term with spaces in the 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)
}

Search by a Phrase

To search for a phrase, specify the phrase with escaped quotes as a string in your query filter. If you don't add escaped quotes around the phrase, the Find() method runs a term search.

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

Search with Terms Excluded

For each term or phrase you want to exclude from your text search, specify the term or phrase prefixed with a minus sign as a string in your query filter.

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

Sort by Relevance

A text search assigns a numerical text score to indicate how closely each result matches the string in your query filter. To reveal the text score in your output, use a projection to retrieve the textScore metadata. You can sort the text score in descending order by specifying a sort on the textScore metadata.

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

Term Search Example

The following example runs a text search for titles that contain the term "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)
}

Text Score Example

The following example performs the following actions:

• Runs a text search for titles that contain the term "Avenger"

• Sorts the results in descending order based on their text score

• Includes the title and score fields from the results

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

API Documentation

To learn more about any of the methods or types discussed in this guide, see the following API Documentation:

• Find()

• FindOptions.SetSort()

• FindOptions.SetProjection()