$text (Self-Managed Deployments)

Exact Strings

To match on an exact multi-word string, as opposed to individual terms, enclose the string in escaped double quotes (\"), as in:

"\"ssl certificate\""

If the $search string of a $text operation includes a multi-word string and individual terms, $text only matches the documents that include the multi-word string.

For example, the following $search string returns documents that include the exact string "ssl certificate":

"\"ssl certificate\" authority key"

Negations

Prefixing a word with a hyphen-minus (-) negates a word:

• The negated word excludes documents that contain the negated word from the result set.

• When passed a string that only contains negated words, $text does not match any documents.

• A hyphenated word, such as pre-market, is not a negation. If used in a hyphenated word, the $text operator treats the hyphen-minus (-) as a delimiter. To negate the word market in this instance, include a space between pre and -market, i.e., pre -market.

The $text operator adds all negations to the operation with the logical AND operator.

Stop Words

The $text operator ignores language-specific stop words, such as the and and in English.

Stemmed Words

When you use case insensitivity and diacritic insensitivity, the $text operator matches on the complete stemmed word. If a document field contains the word blueberry, a $text operation with a $search term of blue does not match. However, blueberry or blueberries match.

$caseSensitive Option

To support case sensitivity where the text index is case insensitive, specify $caseSensitive: true.

Case Sensitivity Process

If $caseSensitive: true and the text index is case insensitive, the $text operator:

• First queries the text index for case insensitive and diacritic matches.

• Then, to return just the documents that match the case of the specified terms, the $text operation includes an additional stage to filter out the documents that do not match the specified case.

If $caseSensitive: true and if the suffix stem contains uppercase letters, the $text operator matches on the exact word.

Specifying $caseSensitive: true may impact performance.

$diacriticSensitive Option

To support diacritic sensitivity with the text index, specify $diacriticSensitive: true.

Text queries against earlier versions of the text index are inherently diacritic sensitive and cannot be diacritic insensitive. As such, the $diacriticSensitive option for the $text operator has no effect with earlier versions of the text index.

Diacritic Sensitivity Process

To use diacritic sensitivity ($diacriticSensitive: true) with a version 3 text index, the $text operator:

• First queries the text index, which is diacritic insensitive.

• Then, to return just the documents that match the diacritic marked characters of the specified terms, the $text operation includes an additional stage to filter out the documents that do not match.

Specifying $diacriticSensitive: true may impact performance.

If you use $diacriticSensitive: true with an earlier version of the text index, the $text operator queries the text index, which is diacritic sensitive.

If $diacriticSensitive: true and if the suffix stem contains the diacritic mark or marks, the $text operator matches on the exact word.

Case Sensitivity with a Term

The following example performs a case sensitive query for the term Coffee:

db.articles.find( { $text: { $search: "Coffee", $caseSensitive: true } } )

The operation matches just the following document:

{ "_id" : 2, "subject" : "Coffee Shopping", "author" : "efg", "views" : 5 }

Case Sensitivity with an Exact String

The following example performs a case sensitive query for the exact multi-word string Café Con Leche:

db.articles.find( {
 $text: { $search: "\"Café Con Leche\"", $caseSensitive: true }
} )

The operation matches just the following document:

{ "_id" : 5, "subject" : "Café Con Leche", "author" : "abc", "views" : 200 }

Case Sensitivity with Negated Term

A negated term is a term that is prefixed by a minus sign -. If you negate a term, the $text operator will exclude the documents that contain those terms from the results. You can also specify case sensitivity for negated terms.

The following example performs a case sensitive query for documents that contain the word Coffee but do not contain the lower-case term shop, or more precisely the stemmed version of the words:

db.articles.find( { $text: { $search: "Coffee -shop", $caseSensitive: true } } )

The operation matches the following document:

{ "_id" : 2, "subject" : "Coffee Shopping", "author" : "efg" }

Diacritic Sensitivity with a Term

The following example performs a diacritic sensitive text query on the term CAFÉ, or more precisely the stemmed version of the word:

db.articles.find( { $text: { $search: "CAFÉ", $diacriticSensitive: true } } )

The operation only matches the following document:

{ "_id" : 5, "subject" : "Café Con Leche", "author" : "abc" }

Diacritic Sensitivity with Negated Term

The $diacriticSensitive option applies also to negated terms. A negated term is a term that is prefixed by a minus sign -. If you negate a term, the $text operator will exclude the documents that contain those terms from the results.

The following example performs a diacritic sensitive text query for documents that contain the term leches but not the term cafés, or more precisely the stemmed version of the words:

db.articles.find(
 { $text: { $search: "leches -cafés", $diacriticSensitive: true } }
)

The operation matches the following document:

{ "_id" : 8, "subject" : "Cafe con Leche", "author" : "xyz" }

Return the Relevance Score

The following example performs a text query for the term cake and uses the $meta operator in the projection document to append the relevance score to each matching document:

db.articles.find(
 { $text: { $search: "cake" } },
 { score: { $meta: "textScore" } }
)

The returned document includes an additional field score that contains the document's relevance score:

{ "_id" : 3, "subject" : "Baking a cake", "author" : "abc", "views" : 90, "score" : 0.75 }

Sort by Relevance Score

• You can specify the { $meta: "textScore" } expression in the sort() without also specifying the expression in the projection. For example:

  db.articles.find(
   { $text: { $search: "cake" } }
  ).sort( { score: { $meta: "textScore" } } )

  As a result, you can sort the resulting documents by their relevance without projecting the textScore.

• If you include the { $meta: "textScore" } expression in both the projection and sort(), the projection and sort documents can have different field names for the expression.

  For example, in the following operation, the projection uses a field named score for the expression and the sort() uses the field named ignoredName.

  db.articles.find(
   { $text: { $search: "cake" } } ,
   { score: { $meta: "textScore" } }
  ).sort( { ignoredName: { $meta: "textScore" } } )

Return Top 2 Matching Documents

Use the limit() method in conjunction with a sort() to return the top n matching documents.

The following example queries for the term coffee and sorts the results by the descending score, limiting the results to the top two matching documents:

db.articles.find(
 { $text: { $search: "coffee" } },
 { score: { $meta: "textScore" } }
).sort( { score: { $meta: "textScore" } } ).limit(2)

$text with Additional Query and Sort Expressions

The following example matches documents where the author equals "xyz" and the indexed field subject contains the terms coffee or bake. The operation also specifies a sort order of ascending date, then descending relevance score:

db.articles.find(
 { author: "xyz", $text: { $search: "coffee bake" } },
 { score: { $meta: "textScore" } }
).sort( { date: 1, score: { $meta: "textScore" } } )