removeStopWords

About this parameter

Removes stop (common) words from the query before executing it.

Stop word removal is useful when you have a query in natural language, e.g. “what is a record?”. In that case, the engine will remove “what”, “is”, and “a” before executing the query, and therefore just search for “record”. This will remove false positives caused by stop words, especially when combined with optional words (see optionalWords and removeWordsIfNoResults).

Usage notes

• removeStopWords is used in conjunction with the queryLanguages setting.

• You can send removeStopWords one of 3 values:

  • true, which enables the stop word functionality, ensuring that stop words are removed from consideration in a search. The languages supported here are either every language (this is the default, see list of languages below), or those set by queryLanguages. See queryLanguages example below.

  • false, which disables stop word functionality, allowing stop words to be taken into account in a search.

  • a list of language ISO codes for which stop words should be enabled. This list will override any values that you may have set in ‘queryLanguages`.

• For most use cases, however, it is better not to use this feature, as people tend to search by keywords on search engines (that is, they naturally omit stop words).

• Prefix logic: Stop words only apply on query words that are not interpreted as prefixes. To control how prefixes are interpreted, check out queryType.

• List of supported languages with their associated ISO code:

  Arabic=ar Bulgarian=bg Bengali=bn Catalan=ca Czech=cs Danish=da German=de Greek=el English=en Spanish=es Basque=eu Persian (Farsi)=fa Finnish=fi French=fr

  Irish=ga Galician=gl Hindi=hi Hungarian=hu Armenian=hy Indonesian=id Italian=it Japanese=ja Korean=ko Kurdish=ku Lithuanian=lt Latvian=lv Marathi=mr Dutch=nl

  Norwegian=no Polish=pl Portuguese=pt Brazilian=pt-br Romanian=ro Russian=ru Slovak=sk Swedish=sv Thai=th Turkish=tr Ukranian=uk Urdu=ur Chinese=zh

Examples

Set the default Query Languages

In this example, we set Spanish (‘es’) as the default language for removeStopWords

1
2
3
4
$index->setSettings([
  'queryLanguages' => ['es'],
  'removeStopWords' => true
]);

1
2
3
4
index.set_settings({
  queryLanguages: ['es'],
  removeStopWords: true
})

1
2
3
4
5
6
index.setSettings({
  queryLanguages: ['es'],
  removeStopWords: true
}).then(() => {
  // done
});

1
2
3
4
index.set_settings({
    'queryLanguages': ['es'],
    'removeStopWords': True
})

1
2
3
4
5
6
7
8
9
let settings = Settings()
  .set(\.queryLanguages, to: [.spanish])
  .set(\.removeStopWords, to: true)

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
IndexSettings settings = new IndexSettings();
settings.QueryLanguages = new List<string> { "es" };
settings.RemoveStopWords = true;
index.SetSettings(settings);

1
2
3
4
5
index.setSettings(
        new IndexSettings()
                .setQueryLanguages(Collections.singletonList("es"))
                .setRemoveStopWords(RemoveStopWords.of(true))
);

1
2
3
4
res, err := index.SetSettings(search.Settings{
  QueryLanguages:  opt.QueryLanguages("es"),
  RemoveStopWords: opt.RemoveStopWords(true),
})

1
2
3
4
5
6
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    queryLanguages = Some(QueryLanguages.list(Seq("es")),
    removeStopWords = Some(RemoveStopWords.`true`)
  )
}

1
2
3
4
5
6
7
8
val settings = settings {
    queryLanguages {
        +English
    }
    removeStopWords = RemoveStopWords.True
}

index.setSettings(settings)

Override Query Languages

In this example, we override the Spanish default for removeStopWords by adding Catalan (‘ca’) to its list of languages.

1
2
3
$results = $index->search('query', [
  'removeStopWords' => ['ca', 'es']
]);

1
2
3
results = index.search('query', {
  removeStopWords: ['ca', 'es']
})

1
2
3
4
5
index.search('query', {
  removeStopWords: ['ca', 'es']
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
results = index.search('query', {
    'removeStopWords': ['ca', 'es']
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.removeStopWords, to: ["catalan", "spanish"])

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
index.Search<Book>(new Query("")
{
    RemoveStopWords = new List<string> { "ca", "es"}
});

1
2
3
4
5
6
index.search(
  new Query("").setRemoveStopWords(RemoveStopWords.of(Arrays.asList(
    "ca",
    "es"
  )))
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.RemoveStopWordsFor("ca", "es"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    removeStopWords = Some(removeStopWords.list(Seq("ca", "es")))
  )
}

1
2
3
4
5
val query = query("query") {
    removeStopWords = RemoveStopWords.QueryLanguages(QueryLanguage.English)
}

index.search(query)