Batch Synonyms

1
2
3
4
5
6
7
8
9
10
# Batch synonyms, with replica forwarding and atomic replacement of existing synonyms
index.batch_synonyms([{
  objectID: 'a-unique-identifier',
  type: 'synonym',
  synonyms: ['car', 'vehicle', 'auto']
}, {
  objectID: 'another-unique-identifier',
  type: 'synonym',
  synonyms: ['street', 'st']
}], { forwardToReplicas: true, replaceExistingSynonyms: true })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Batch synonyms, with replica forwarding and atomic replacement of existing synonyms
const synonyms = [{
  objectID: 'a-unique-identifier',
  type: 'synonym',
  synonyms: ['car', 'vehicle', 'auto']
}, {
  objectID: 'another-unique-identifier',
  type: 'synonym',
  synonyms: ['street', 'st']
}];

index.saveSynonyms(synonyms, {
  forwardToReplicas: true,
  replaceExistingSynonyms: true
}).then(() => {
  // done
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Batch synonyms, with replica forwarding and atomic replacement of existing synonyms
index.save_synonyms(
    [
        {
            'objectID': 'a-unique-identifier',
            'type': 'synonym',
            'synonyms': ['car', 'vehicle', 'auto']
        },
        {
            'objectID': 'another-unique-identifier',
            'type': 'synonym',
            'synonyms': ['street', 'st']
        }
    ],
    {
        'forwardToReplicas': True,
        'replaceExistingSynonyms': True
    }
)

1
2
3
4
5
6
7
8
9
10
let synonyms: [Synonym] = [
  .multiWay(objectID: "myID1", synonyms: ["car", "vehicle", "auto"]),
  .multiWay(objectID: "myID2", synonyms: ["street", "st"])
]

index.saveSynonyms(synonyms, forwardToReplicas: true, replaceExistingSynonyms: false) { 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
15
16
17
18
19
20
List<Synonym> synonyms = new List<Synonym>
{
    new Synonym
    {
      ObjectID = "a-unique-identifier",
      Type = "synonym",
      Synonyms = new List<string> { "car", "vehicle", "auto" }
    },
    new Synonym
    {
      ObjectID = "another-unique-identifier",
      Type = "synonym",
      Synonyms = new List<string> { "street", "st" }
    }
};

index.SaveSynonyms(synonyms, forwardToreplicas: true, replaceExistingSynonyms: true);

// Asynchronous
await index.SaveSynonymsAsync(synonyms, forwardToreplicas: true, replaceExistingSynonyms: true);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Batch synonyms, with replica forwarding
// and atomic replacement of existing synonyms

boolean forwardToReplicas = true;
boolean replaceExistingSynonyms = true;

List<Synonym> synonyms = Arrays.asList(
    new Synonym()
      .setObjectID("a-unique-identifier")
      .setSynonyms(Arrays.asList("car", "vehicle", "auto")),
    new Synonym()
      .setObjectID("another-unique-identifier")
      .setSynonyms(Arrays.asList("street", "st")));

index.saveSynonyms(synonyms, forwardToReplicas, replaceExistingSynonyms);

// Asynchronous
index.saveSynonymsAsync(synonyms, forwardToReplicas, replaceExistingSynonyms);

1
2
3
4
5
6
7
8
9
10
11
opts := []interface{}{
	opt.ForwardToReplicas(true),
	opt.ReplaceExistingSynonyms(true),
}

synonyms := []search.Synonym{
	search.NewRegularSynonym("a-unique-identifier", "car", "vehicle", "auto"),
	search.NewRegularSynonym("another-unique-identifier", "street", "st"),
}

res, err := index.SaveSynonyms(synonyms, opts...)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Batch synonyms, with replica forwarding
// and atomic replacement of existing synonyms
client.execute {
  save synonyms Seq(
    Synonym(
      "a-unique-identifier",
      Seq("car", "vehicle", "auto")
    ),
    Synonym(
      "another-unique-identifier",
      Seq("street", "st")
    )
  ) inIndex "index_name" and forwardToReplicas and replaceExistingSynonyms
}

1
2
3
4
5
6
7
8
9
10
11
val synonyms = listOf(
    Synonym.MultiWay(
        objectID = ObjectID("myID1"),
        synonyms = listOf("car", "vehicle", "auto")
    ),
    Synonym.MultiWay(
        objectID = ObjectID("myID2"),
        synonyms = listOf("street", "st")
    )
)
index.saveSynonyms(synonyms, forwardToReplicas = true, clearExistingSynonyms = true)