customNormalization

1
2
3
4
5
index.set_settings({
      'customNormalization': {
          default: {'ä': 'ae'},
      }
  })

1
2
3
4
5
6
7
index.setSettings({
  'customNormalization': {
    'default': {'ä': 'ae'}
  }
}).then(() => {
  // done
});

1
2
3
4
5
index.set_settings({
    'custom_normalization': {
        'default': {'ä': 'ae'},
    },
})

1
2
3
4
5
6
7
8
9
10
11
12
13
let settings = Settings()
  .set(\.customNormalization, to: [
    "default": [
      "ä": "ae",
      "ü": "ue"
    ]
  ])

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

1
// customNormalization is not implemented in Android.

1
2
3
4
5
6
7
8
9
IndexSettings settings = new IndexSettings();

settings.CustomNormalization =
new Dictionary<string, Dictionary<string, string>>
{
  { "default", new Dictionary<string, string> { {"ä", "ae"} } }
};

index.SetSettings(settings);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
IndexSettings settings = new IndexSettings();

settings.setCustomNormalization(
  new HashMap<String, Map<String, String>>() {
    {
      put(
          "default",
          new HashMap<String, String>() {
            {
              put("ä", "ae");
            }
          });
    }
  });

  index.setSettings(settings);

1
2
3
4
5
res, err := index.SetSettings(search.Settings{
    CustomNormalization: opt.CustomNormalization(map[string]map[string]string{
        "default": map[string]string{"ä": "ae"},
    }),
})

1
2
3
4
5
client.execute {
  setSettings of "myIndex" `with` IndexSettings(
  customNormalization = Some(Map("default" -> Map("ä" -> "ae")))
  )
}

1
2
3
4
5
6
7
8
9
10
val settings = settings {
    customNormalization = mapOf(
        "default" to mapOf(
            "ä" to "ae",
            "ü" to "ue"
        )
    )
}

index.setSettings(settings)