API clients / Methods / Dictionaries

Sep 20, 2024

Replace dictionary entries

Required API Key: any key with the editSettings ACL

Method signature

$client->replaceDictionaryEntries(
  string dictionary,
  array  dictionaryEntries
);

client.replace_dictionary_entries(
  string dictionary,
  array  dictionaryEntries
)

client.replaceDictionaryEntries(
  dictionary: DictionaryName,
  dictionaryEntries: DictionaryEntry[],
  requestOptions: RequestOptions
)

client.replace_dictionary_entries(
  string dictionary,
  array  dictionaryEntries,
  # + any requestOptions
)

client.replaceDictionaryEntries<Dictionary: CustomDictionary>(
  in dictionary: Dictionary.Type ,
  with dictionaryEntries: [Dictionary.Entry],
  requestOptions: RequestOptions? = nil
)

client.replaceDictionaryEntries(
    dictionary: Dictionary<T>,
    dictionaryEntries: List<T>,
    requestOptions: __RequestOptions? = null,
)

DictionaryClient.ReplaceDictionaryEntries(
  AlgoliaDictionary algoliaDictionary,
  List<DictionaryEntry> dictionaryEntries
);

client.replaceDictionaryEntries(
  Dictionary dictionary,
  List<DictionaryEntry> dictionaryEntries,
  RequestOptions requestOptions
)

client.ReplaceDictionaryEntries(
  dictionaryName DictionaryName,
  dictionaryEntries []DictionaryEntry,
  opts ...interface{}
)

replace dictionary dictionary entries dictionaryEntries

See code examples

About this method # A

Replace a batch of dictionary entries.

Examples # A

Replace stopword entries#

Copy

1
2
3
4
5
6
7
8
9
10
let entry = StopwordsDictionary.Entry(objectID: "down",
                                      language: .english,
                                      word: "down",
                                      state: .enabled)

client.replaceDictionaryEntries(in: StopwordsDictionary.self, with: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val entry = DictionaryEntry.Stopword(
    objectID = ObjectID("MyObjectID"),
    language = Language.English,
    word = "upper"
)
client.replaceDictionaryEntries(Dictionary.Stopwords, listOf(entry))
// or using extension function:
client.replaceStopwordEntries(listOf(entry))

1
2
3
4
5
6
7
8
9
10
11
12
13
Stopword stopword = new Stopword()
{
  ObjectID = objectId,
  Language = "en",
   Word = "upper",
};

// Synchronous
var replaceDictionaryResponse = DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { stopword });

// Asynchronous
var replaceDictionaryResponse = DictionaryClient.ReplaceDictionaryEntriesAsync(algoliaDictionary, new List<DictionaryEntry>() { stopword });
replaceDictionaryResponse.Wait();

1
2
3
4
5
Stopword stopword = DictionaryEntry.stopword("MyObjectID", "en", "down", "enabled");
// Synchronous
searchClient.replaceDictionaryEntries(Dictionary.STOPWORDS, Collections.singletonList(stopword));
// Asynchronous
searchClient.replaceDictionaryEntriesAsync(Dictionary.STOPWORDS, Collections.singletonList(stopword));

1
2
3
stopwordEntry := search.NewStopword(entryID, "en", "down", "enabled")

res, err := client.ReplaceDictionaryEntries(search.Stopwords, []search.DictionaryEntry{stopwordEntry})

1
2
3
4
5
6
7
8
9
val entry = StopwordEntry(
  objectID = "MyObjectID",
  language = "en",
  word = "down",
  state = "enabled"
)
client.execute {
  replace dictionary Stopwords entries Seq(entry)
}

Replace plural entries#

Copy

1
2
3
4
5
6
7
8
$client->replaceDictionaryEntries(
  'plurals',
  array(array(
    'objectID' => 'chevaux',
    'language' => 'fr',
    'words' => array('cheval', 'chevaux')
  ))
);

1
2
3
4
5
6
7
8
9
let entry = PluralsDictionary.Entry(objectID: "chevaux",
                                    language: .french,
                                    words: ["cheval", "chevaux"])

client.replaceDictionaryEntries(in: PluralsDictionary.self, with: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val entry = DictionaryEntry.Plural(
    objectID = ObjectID("MyObjectID"),
    language = Language.French,
    words = listOf("cheval", "chevaux")
)
client.replaceDictionaryEntries(Dictionary.Plurals, listOf(entry))
// or using extension function:
client.replacePluralEntries(listOf(entry))

1
2
3
4
5
6
7
8
9
10
11
12
13
Plural plural = new Plural()
{
  ObjectID = objectId,
  Language = "fr",
  Words = new List<String>() { "cheval", "chevaux" }
};

// Synchronous
DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { plural });

// Asynchronous
var replaceDictionaryResponse = await DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { plural });
replaceDictionaryResponse.Wait();

1
2
3
4
5
Plural plural = DictionaryEntry.plural("MyObjectID", "fr", Arrays.asList("cheval", "chevaux"));
// Synchronous
client.replaceDictionaryEntries(Dictionary.PLURALS, Collections.singletonList(plural));
// Asynchronous
client.replaceDictionaryEntriesAsync(Dictionary.PLURALS, Collections.singletonList(plural));

1
2
3
pluralEntry := search.NewPlural(entryID, "fr", []string{"cheval", "chevaux"})

res, err := client.ReplaceDictionaryEntries(search.Plurals, []search.DictionaryEntry{pluralEntry})

1
2
3
4
5
6
7
8
val entry = PluralEntry(
  objectID = "MyObjectID",
  language = "fr",
  words = Seq("cheval", "chevaux")
)
client.execute {
  replace dictionary Plurals entries Seq(entry)
}

Replace compound entries#

Copy

1
2
3
4
5
6
7
8
9
$client->replaceDictionaryEntries(
  'compounds',
  array(array(
    'objectID' => 'kopfschmerztablette',
    'language' => 'de',
    'word' => 'kopfschmerztablette',
    'decomposition' => array('kopf', 'schmerz', 'tablette')
  ))
);

1
2
3
4
5
6
7
8
9
client.replace_dictionary_entries(
  'compounds',
  [{
    objectID: 'kopfschmerztablette',
    language: 'de',
    word: 'kopfschmerztablette',
    decomposition: %w(kopf schmerz tablette)
  }]
)

1
2
3
4
5
6
7
8
client.replaceDictionaryEntries('compounds', [
  {
    objectID: 'kopfschmerztablette',
    language: 'de',
    word: 'kopfschmerztablette',
    decomposition: ['kopf', 'schmerz', 'tablette'],
  },
]);

1
2
3
4
5
6
7
8
9
client.replace_dictionary_entries(
  'compounds',
  [{
    'objectID': 'kopfschmerztablette',
    'language': 'de',
    'word': 'kopfschmerztablette',
    'decomposition': ['kopf', 'schmerz', 'tablette]
  }]
)

1
2
3
4
5
6
7
8
9
10
let entry = CompoundsDictionary.Entry(objectID: "kopfschmerztablette",
                                      language: .german,
                                      word: "kopfschmerztablette",
                                      decomposition: ["kopf", "schmerz", "tablette"])

client.replaceDictionaryEntries(in: CompoundsDictionary.self, with: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
val entry = DictionaryEntry.Compound(
    objectID = ObjectID("MyObjectID"),
    language = Language.Dutch,
    word = "kopfschmerztablette",
    decomposition = listOf("kopf", "schmerz", "tablette")
)
client.replaceDictionaryEntries(Dictionary.Compounds, listOf(entry))
// or using extension function:
client.replaceCompoundEntries(listOf(entry))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Compound compound = new Compound()
{
  ObjectID = objectId,
  Language = "nl",
  Word = "kopfschmerztablette",
  Decomposition = new List<String>() { "kopf", "schmerz", "tablette" }
 };

 // Synchronous
 var replaceDictionaryResponse = DictionaryClient.ReplaceDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { compound });

 // Asynchronous
 var replaceDictionaryResponse = await DictionaryClient.ReplaceDictionaryEntriesAsync(algoliaDictionary, new List<DictionaryEntry>() { compound });
 replaceDictionaryResponse.Wait();

1
2
3
4
5
Compound compound = DictionaryEntry.compound("MyObjectID", "de", "kopfschmerztablette",Arrays.asList("kopf", "schmerz", "tablette"));
// Synchronous
client.replaceDictionaryEntries(Dictionary.COMPOUNDS, Collections.singletonList(compound));
// Asynchronous
client.replaceDictionaryEntriesAsync(Dictionary.COMPOUNDS, Collections.singletonList(compound));

1
2
3
compoundEntry := search.NewCompound(entryID, "de", "kopfschmerztablette", []string{"kopf", "schmerz", "tablette"})

res, err := client.ReplaceDictionaryEntries(search.Compounds, []search.DictionaryEntry{compoundEntry})

1
2
3
4
5
6
7
8
9
val entry = CompoundEntry(
  objectID = "MyObjectID",
  language = "de",
  word = "kopfschmerztablette",
  decomposition = Seq("kopf", "schmerz", "tablette")
)
client.execute {
  replace dictionary Compounds entries Seq(entry)
}

Parameters # A

`dictionary` #	type: string Required Type of the dictionary entries you want to replace. Can be either `stopword`, `plural` or `compound`
`dictionaryEntries` #	type: list of stopwordEntry\|pluralEntry\|compoundEntry Required An array of dictionary entries. Can contain either a list of stopwordEntry, pluralEntry or compoundEntry.
`requestOptions` #	type: key-value mapping default: No request options Optional A mapping of request options to send along with the request.

dictionaryEntry ➔ stopwordEntry #

`objectID` #	type: string Required Unique identifier of the entry to add or override.
`language` #	type: string Required Language ISO code supported by the dictionary (for example “en” for English).
`word` #	type: string Required The stopword you want to add or update. When `word` already exists in the standard dictionary provided by Algolia, the entry can be overridden by the one you provide.
`state` #	type: string default: enabled Optional The state of the entry: `enabled`: enable the current stopword `disabled`: disable the current stopword

dictionaryEntry ➔ pluralEntry #

`objectID` #	type: string Required Unique identifier of the entry to add or override.
`language` #	type: string Required Language ISO code supported by the dictionary (for example “en” for English).
`words` #	type: string Required List of word declensions. The entry overrides existing entries when any of these words exist in the standard dictionary provided by Algolia.

dictionaryEntry ➔ compoundEntry #

`objectID` #	type: string Required Unique identifier of the entry to add or override.
`language` #	type: string Required Language ISO code supported by the dictionary (for example `de` for German).
`word` #	type: string Required When `decomposition` is empty: adds `word` as a compound atom. For example, atom “kino” decomposes the query “kopfkino” into “kopf” and “kino”. When `decomposition` isn’t empty: creates a decomposition exception. For example, when `decomposition` is set to `["hund", "hutte"]`exception “hundehutte” decomposes the word into “hund” and “hutte”, discarding the linking morpheme “e”.
`decomposition` #	type: string array Required When empty, the key `word` is considered as a compound atom. Otherwise, it’s the decomposition of `word`.

Response # A

This section shows the JSON response returned by the API. Each API client encapsulates this response inside objects specific to the programming language, so that the actual response might be different. You can view the response by using the getLogs method. Don’t rely on the order of attributes in the response, as JSON doesn’t guarantee the ordering of keys in objects.

JSON format#

Copy

          {
  "updatedAt":"2013-01-18T15:33:13.556Z",
  "taskID": 678
}

        

Field	Description
`updatedAt` #	string Date at which the indexing job has been created.
`taskID` #	integer The taskID used with the waitTask method.

Did you find this page helpful?

Replace dictionary entries

About this method # Found an issue? Edit this page A Edit this page

Examples # Found an issue? Edit this page A Edit this page

Replace stopword entries#

Replace plural entries#

Replace compound entries#

Parameters # Found an issue? Edit this page A Edit this page

dictionaryEntry ➔ stopwordEntry #

dictionaryEntry ➔ pluralEntry #

dictionaryEntry ➔ compoundEntry #

Response # Found an issue? Edit this page A Edit this page

JSON format#

On this page

About this method # A

Examples # A

Parameters # A

Response # A