ignorePlurals

Whether to treat singular, plural, and inflected forms as equivalent

The ignorePlurals parameter controls whether Algolia treats singular, plural, and other inflected forms as equivalent.
For example, "car" matches "cars" and "child" matches "children".

For more information, see Ignoring plurals and other forms.

Options

true

Treat plural and inflected forms as equivalent for all supported languages. If queryLanguages is set, only those languages are affected.

false

Plurals and other declensions will be treated as separate words.

list<enum<string>>

List of languages (as ISO 639-1 codes) for which plural and inflected forms should be treated as equivalent. Overrides any language(s) set in queryLanguages. See the list of supported languages.

Usage

• You should only turn on ignorePlurals for languages used in your data.
• If ignorePlurals is set to true without specifying queryLanguages, Algolia enables plural normalization for all supported languages. This may lead to unexpected matches. For example, the French word "chair" (meaning “flesh”) may match "chairs" in English.

Examples

Set default query language and ignore plurals

Current API clients

C#

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings
  {
    QueryLanguages = new List<SupportedLanguage> { Enum.Parse<SupportedLanguage>("Es") },
    IgnorePlurals = new IgnorePlurals(true),
  }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    queryLanguages: [
      SupportedLanguage.fromJson("es"),
    ],
    ignorePlurals: true,
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetQueryLanguages(
    []search.SupportedLanguage{search.SupportedLanguage("es")}).SetIgnorePlurals(search.BoolAsIgnorePlurals(true))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setQueryLanguages(Arrays.asList(SupportedLanguage.ES)).setIgnorePlurals(IgnorePlurals.of(true))
);

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: { queryLanguages: ['es'], ignorePlurals: true },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings =
      IndexSettings(
        queryLanguages = listOf(SupportedLanguage.entries.first { it.value == "es" }),
        ignorePlurals = IgnorePlurals.of(true),
      ),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['queryLanguages' => [
        'es',
    ],
        'ignorePlurals' => true,
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "queryLanguages": [
            "es",
        ],
        "ignorePlurals": True,
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(query_languages: ["es"], ignore_plurals: true)
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      queryLanguages = Some(Seq(SupportedLanguage.withName("es"))),
      ignorePlurals = Some(IgnorePlurals(true))
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(
        ignorePlurals: SearchIgnorePlurals.bool(true),
        queryLanguages: [SearchSupportedLanguage.es]
    )
)

Legacy API clients

C#

IndexSettings settings = new IndexSettings();
settings.QueryLanguages = new List { "es" };
settings.IgnorePlurals = true;

index.SetSettings(settings);

res, err := index.SetSettings(search.Settings{
	QueryLanguages: opt.QueryLanguages("es"),
	IgnorePlurals:  opt.IgnorePlurals(true),
})

index.setSettings(
        new IndexSettings()
                .setQueryLanguages(Collections.singletonList("es"))
                .setIgnorePlurals(IgnorePlurals.of(true))
);

index
  .setSettings({
    queryLanguages: ["es"],
    ignorePlurals: true,
  })
  .then(() => {
    // done
  });

val settings = settings {
    queryLanguages {
        +Spanish
    }
    ignorePlurals = IgnorePlurals.True
}

index.setSettings(settings)

$index->setSettings([
  'queryLanguages' => ['es'],
  'ignorePlurals' => true
]);

index.set_settings({"queryLanguages": ["es"], "ignorePlurals": True})

index.set_settings(
  {
    queryLanguages: ["es"],
    ignorePlurals: true
  }
)

client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    queryLanguages = Some(QueryLanguages.list(Seq("es")),
    ignorePlurals = Some(IgnorePlurals.`true`)
  )
}

let settings = Settings()
  .set(\.queryLanguages, to: [.spanish])
  .set(\.ignorePlurals, to: true)

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

Override query language in search request

Current API clients

C#

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(
    new SearchParamsObject
    {
      Query = "query",
      IgnorePlurals = new IgnorePlurals(
        new List<SupportedLanguage>
        {
          Enum.Parse<SupportedLanguage>("Ca"),
          Enum.Parse<SupportedLanguage>("Es"),
        }
      ),
    }
  )
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    ignorePlurals: [
      SupportedLanguage.fromJson("ca"),
      SupportedLanguage.fromJson("es"),
    ],
  ),
);

response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
  "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
  search.NewEmptySearchParamsObject().SetQuery("query").SetIgnorePlurals(search.ArrayOfSupportedLanguageAsIgnorePlurals(
    []search.SupportedLanguage{search.SupportedLanguage("ca"), search.SupportedLanguage("es")})))))
if err != nil {
  // handle the eventual error
  panic(err)
}

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject()
    .setQuery("query")
    .setIgnorePlurals(IgnorePlurals.of(Arrays.asList(SupportedLanguage.CA, SupportedLanguage.ES))),
  Hit.class
);

const response = await client.searchSingleIndex({
  indexName: 'indexName',
  searchParams: { query: 'query', ignorePlurals: ['ca', 'es'] },
});

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams =
      SearchParamsObject(
        query = "query",
        ignorePlurals =
          IgnorePlurals.of(
            listOf(
              SupportedLanguage.entries.first { it.value == "ca" },
              SupportedLanguage.entries.first { it.value == "es" },
            )
          ),
      ),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'ignorePlurals' => [
            'ca',

            'es',
        ],
    ],
);

response = client.search_single_index(
    index_name="INDEX_NAME",
    search_params={
        "query": "query",
        "ignorePlurals": [
            "ca",
            "es",
        ],
    },
)

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", ignore_plurals: ["ca", "es"])
)

val response = Await.result(
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = Some(
      SearchParamsObject(
        query = Some("query"),
        ignorePlurals = Some(IgnorePlurals(Seq(SupportedLanguage.withName("ca"), SupportedLanguage.withName("es"))))
      )
    )
  ),
  Duration(100, "sec")
)

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        ignorePlurals: SearchIgnorePlurals.arrayOfSearchSupportedLanguage([
            SearchSupportedLanguage.ca,
            SearchSupportedLanguage.es,
        ])
    ))
)

Legacy API clients

C#

index.Search(new Query("")
{
    IgnorePlurals = new List { "ca", "es"}
});

res, err := index.Search(
	"query",
	opt.IgnorePluralsFor("ca", "es"),
)

index.search(
  new Query("").setIgnorePlurals(IgnorePlurals.of(Arrays.asList(
    "ca",
    "es"
  )))
);

index
  .search("query", {
    ignorePlurals: ["ca", "es"],
  })
  .then(({ hits }) => {
    console.log(hits);
  });

val query = query("query") {
    ignorePlurals = IgnorePlurals.QueryLanguages(
        QueryLanguage.Spanish,
        QueryLanguage.Catalan
    )
}

index.search(query)

$results = $index->search('query', [
  'ignorePlurals' => ['ca', 'es']
]);

results = index.search("query", {"ignorePlurals": ["ca", "es"]})

results = index.search(
  "query",
  {
    ignorePlurals: ["ca", "es"]
  }
)

client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    ignorePlurals = Some(ignorePlurals.list(Seq("ca", "es")))
  )
}

let query = Query("query")
  .set(\.ignorePlurals, to: [.spanish, .catalan])

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