optionalWords

1
2
3
4
5
6
index.set_settings({
  optionalWords: [
    'word1',
    'word2 word3'
  ]
})

1
2
3
4
5
6
7
8
index.setSettings({
  optionalWords: [
    'word1',
    'word2 word3'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
6
index.set_settings({
    'optionalWords': [
        'word1',
        'word2 word3'
    ]
})

1
2
3
4
5
6
7
8
let settings = Settings()
  .set(\.optionalWords, to: ["word1", "word2 word3"])

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

1
2
3
4
5
6
7
8
9
index.setSettings(
  new JSONObject()
    .put(
      "optionalWords",
      new JSONArray()
        .put("word1")
        .put("word2 word3")
    )
);

1
2
3
4
5
6
7
8
IndexSettings settings = new IndexSettings();
settings.OptionalWords = new List<string>
{
  "word1",
  "word2 word3"
},

index.SetSettings(settings);

1
2
3
4
5
6
7
8
9
index.setSettings(
  new IndexSettings()
    .setOptionalWords(
      Arrays.asList(
        "word1",
        "word2 word3"
      )
    )
);

1
2
3
4
5
6
res, err := index.SetSettings(search.Settings{
  OptionalWords: opt.OptionalWords(
    "word1",
    "word2 word3",
  ),
})

1
2
3
4
5
6
7
8
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    optionalWords = Some(Seq(
      "word1",
      "word2 word3"
    ))
  )
}

1
2
3
4
5
6
7
8
val settings = settings {
    optionalWords {
        +"word1"
        +"word2 word3"
    }
}

index.setSettings(settings)

1
2
3
4
5
6
results = index.search('query', {
  optionalWords: [
    'word1',
    'word2 word3'
  ]
})

1
2
3
4
5
6
7
8
index.search('query', {
  optionalWords: [
    'word1',
    'word2 word3'
  ]
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
results = index.search('query', {
    'optionalWords': [
        'word1',
        'word2 word3'
    ]
})

1
2
3
4
5
6
let query = Query(query: "query")
query.optionalWords = ["word1", "word2 word3"]

index.search(query, completionHandler: { (res, error) in
  print(res)
})

1
2
3
4
5
6
7
index.search(
  new Query("query")
    .setOptionalWords(
      "word1",
      "word2 word3"
    )
);

1
2
3
4
5
6
7
8
index.Search<T>(new Query("")
{
    OptionalWords = new List<string>
    {
      "word1",
      "word2 word3"
    },
});

1
2
3
4
5
6
7
8
9
index.search(
  new Query("query")
    .setOptionalWords(
      Arrays.asList(
        "word1",
        "word2 word3"
      )
    )
);

1
2
3
4
5
6
7
8
res, err := index.Search(
"query",

  OptionalWords: opt.OptionalWords(
    "word1",
    "word2 word3",
  },
})

1
2
3
4
5
6
7
8
9
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    optionalWords = Some(Seq(
      "word1",
      "word2 word3"
    ))
  )
}

1
2
3
4
5
6
7
8
val query = query("query") {
    optionalWords {
        +"word1"
        +"word2 word3"
    }
}

index.search(query)

1
2
3
4
5
6
7
query = 'the query'

params = {
  optionalWords: query
}

results = index.search(query, params)

1
2
3
4
5
6
7
8
9
const query = 'the query';

const params = {
  'optionalWords': query
};

index.search(query, params).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
7
query = 'the query'

params = {
    'optionalWords': query
}

results = index.search(query, params)

1
2
3
4
5
6
7
8
9
let queryString = "query"
let query = Query(queryString)
  .set(\.optionalWords, to: [queryString])

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

1
2
3
4
5
6
final String query = "the query";

index.search(
  new Query(query)
    .setOptionalWords(query)
);

1
2
3
4
5
6
String query = "the query";

index.Search<T>(new Query(query)
{
    OptionalWords = new List<string> { query };
});

1
2
3
4
5
6
7
8
9
10
String query = "the query";

index.search(
  new Query(query)
    .setOptionalWords(
      Collections.singletonList(
        query
      )
    )
);

1
2
3
4
5
6
query := "the query"

res, err := index.Search(
  query,
  opt.OptionalWords(query),
)

1
2
3
4
5
6
7
8
9
10
val query = "the query"

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

1
2
3
4
5
6
7
8
val queryString = "query"
val query = query(queryString) {
    optionalWords {
        +queryString
    }
}

index.search(query)