API Reference / API Methods / Dictionaries / Save dictionary entries

Jan. 28, 2022

Save Dictionary Entries

Required API Key: any key with the editSettings ACL

Method signature

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

client.save_dictionary_entries(
  string dictionary,
  array  dictionaryEntries
)

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

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

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

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

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

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

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

save dictionary dictionary entries dictionaryEntries

See code examples

About this method # A

Send a batch of entries to a dictionary.

Examples # A

Save stopword entries#

Copy

1
2
3
4
5
6
7
8
$client->saveDictionaryEntries(
  'stopwords',
  array(array(
    'objectID' => 'down',
    'language' => 'en',
    'word' => 'down'
  ))
);

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

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

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

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

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

1
2
3
4
5
Stopword stopword = DictionaryEntry.stopword("MyObjectID", "en", "upper", "enabled");
// Synchronous
client.saveDictionaryEntries(Dictionary.STOPWORDS, Collections.singletonList(stopword));
// Asynchronous
client.saveDictionaryEntriesAsync(Dictionary.STOPWORDS, Collections.singletonList(stopword));

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

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

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

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

Save plural entries#

Copy

1
2
3
4
5
6
7
8
$client->saveDictionaryEntries(
  '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.saveDictionaryEntries(to: PluralsDictionary.self, dictionaryEntries: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

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.SaveDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { plural });

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

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

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

    res, err := client.SaveDictionaryEntries(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 {
  save dictionary Plurals entries Seq(entry)
}

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

Save compound entries#

Copy

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

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

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

1
2
3
4
5
6
7
8
9
client.save_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.saveDictionaryEntries(to: CompoundsDictionary.self, dictionaryEntries: [entry]) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

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
DictionaryClient.SaveDictionaryEntries(algoliaDictionary, new List<DictionaryEntry>() { compound });

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

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

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

res, err := client.SaveDictionaryEntries(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 {
  save dictionary Compounds entries Seq(entry)
}

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.saveDictionaryEntries(Dictionary.Compounds, listOf(entry))
// or using extension function:
client.saveCompoundEntries(listOf(entry))

Parameters # A

`dictionary` #	type: string Required Type of the dictionary entries you want to save. 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 `requestOptions` 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 stop word you want to add or update. If the entry already exists in the standard dictionary provided by Algolia, you can override its behavior by adding it to the custom dictionary and setting its `state` to `disabled`.
`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. If the entry already exists in the standard dictionary provided by Algolia, you can override its behavior by adding it to the custom dictionary and setting its `state` to `disabled`.

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. Since each language encapsulates this response inside objects specific to that language and/or implementation, the actual type in your language might differ from what’s written here. You can view the response in the logs (using the getLogs method).

JSON format#

Copy

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

        

`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?

Save 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

Save stopword entries#

Save plural entries#

Save 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