queryLanguages

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
index.setSettings(
  new JSONObject()
    .put(
      "queryLanguages",
      new JSONArray()
        .put("es")
    )
    .put("removeStopWords", true)
    .put("ignorePlurals", true)
);

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

index.SetSettings(settings);

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

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

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

1
2
3
4
5
6
7
8
9
val settings = settings {
    queryLanguages {
        +Spanish
    }
    ignorePlurals = IgnorePlurals.True
    removeStopWords = RemoveStopWords.True
}

index.setSettings(settings)

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(\.queryLanguages, to: [.catalan, .spanish])

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

1
index.search(new Query("query").setRemoveStopWords("ca", "es"));

1
2
3
4
index.Search<T>(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
6
7
8
val query = query("query") {
    queryLanguages {
        +Spanish
        +Catalan
    }
}

index.search(query)

1
2
3
results = index.search('query', {
  queryLanguages: ['ja', 'en']
})

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

1
2
3
results = index.search('query', {
    'queryLanguages': ['ja', 'en']
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.queryLanguages, to: [.japanese, .english])

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

1
index.search(new Query("query").setQueryLanguages("ja", "en"));

1
2
3
4
index.Search<T>(new Query("")
{
    QueryLanguages = new List<string> { "ja", "en"}
});

1
2
3
4
5
6
index.search(
      new Query("").setQueryLanguages(Arrays.asList(
              "ja",
              "en"
      ))
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.QueryLanguages("ja", "en"),
)

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

1
2
3
4
5
6
7
8
val query = query("query") {
    queryLanguages {
        +Japanese
        +English
    }
}

index.search(query)