decompoundQuery

Split compound words into parts in the query.

The decompoundQuery parameter controls splitting compound words in the query into their component parts.

Decompounding is available for these queryLanguages: German, Dutch, Finnish, Danish, Swedish, and Norwegian.

Usage

• If true (default), compound words are split into multiple parts to improve recall. For example, the Dutch query "schoolboeken" (school books) will match "school", "boeken", and "schoolboeken".

• If false, compound words are matched as-is.
  This is useful when you want to preserve precise matches for product names, legal terms, or brand names.
  For example, "gartenstühle" (garden chairs in German) would only match "gartenstühle".

• Decompounding doesn’t apply to decomposed Unicode characters with combining marks. For example, "Gartenstühle" (using u + combining ◌̈) won’t be split, but "Gartenstühle" (single ü character) will be.

• To control decompounding for individual attributes, see decompoundedAttributes.

Examples

Enable splitting compound words by default

Current API clients

C#

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings { DecompoundQuery = true }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    decompoundQuery: true,
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetDecompoundQuery(true)))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings("INDEX_NAME", new IndexSettings().setDecompoundQuery(true));

const response = await client.setSettings({ indexName: 'theIndexName', indexSettings: { decompoundQuery: true } });

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(decompoundQuery = true),
  )

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

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "decompoundQuery": True,
    },
)

response = client.set_settings("INDEX_NAME", Algolia::Search::IndexSettings.new(decompound_query: true))

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      decompoundQuery = Some(true)
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(decompoundQuery: true)
)

Legacy API clients

C#

IndexSettings settings = new IndexSettings
{
  DecompoundQuery = true
};

index.SetSettings(settings);

// Asynchronous
await index.SetSettings(settings);

res, err := index.SetSettings(search.Settings{
	DecompoundQuery: opt.DecompoundQuery(true),
})

IndexSettings setting = new IndexSettings().setDecompoundQuery(true);
// Synchronous
index.setSettings(setting);
// Asynchronous
index.setSettingsAsync(setting);

index.setSettings({
  decompoundQuery: true,
});

val settings = settings {
    decompoundQuery = true
}
index.setSettings(settings)

$index->setSettings(array(
  'decompoundQuery' => true,
));

index.set_settings(
    {
        "decompoundQuery": True,
    }
)

index.set_settings(
  {
    decompoundQuery: true
  }
)

client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    decompoundQuery = Some(true)
  )
}

let settings = Settings()
  .set(\.decompoundQuery, to: true)

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

Enable splitting compound words for the current search

Current API clients

C#

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(new SearchParamsObject { Query = "query", DecompoundQuery = true })
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    decompoundQuery: true,
  ),
);

response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
  "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
  search.NewEmptySearchParamsObject().SetQuery("query").SetDecompoundQuery(true))))
if err != nil {
  // handle the eventual error
  panic(err)
}

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setDecompoundQuery(true),
  Hit.class
);

const response = await client.searchSingleIndex({
  indexName: 'indexName',
  searchParams: { query: 'query', decompoundQuery: true },
});

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = SearchParamsObject(query = "query", decompoundQuery = true),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'decompoundQuery' => true,
    ],
);

response = client.search_single_index(
    index_name="INDEX_NAME",
    search_params={
        "query": "query",
        "decompoundQuery": True,
    },
)

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", decompound_query: true)
)

val response = Await.result(
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = Some(
      SearchParamsObject(
        query = Some("query"),
        decompoundQuery = Some(true)
      )
    )
  ),
  Duration(100, "sec")
)

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        decompoundQuery: true
    ))
)

Legacy API clients

C#

var result = index.Search(new Query("query string")
{
  DecoumpoundQuery = true
});

res, err := index.Search(
  "query",
  opt.DecompoundQuery(true),
})

Query query = new Query("query");
query.setDecompoundQuery(true);
index.search(query);

index
  .search("query", {
    decompoundQuery: true,
  })
  .then(({ hits }) => {
    console.log(hits);
  });

val query = Query(query = "query", decompoundQuery = true)
index.search(query)

$res = $index->search('query string', [
  'decompoundQuery' => true
]);

index.search("query", {"decompoundQuery": True})

index.search(
  "query",
  {
    decompoundQuery: true
  }
)

client.execute {
  search into "myIndex" query Query(query = Some("query"), decompoundQuery = Some(true))
}

let query = Query("query")
  .set(\.decompoundQuery, to: true)

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