WIP: generalize option parsing to support k, max_distance, and min_score

Replace hardcoded k parameter with generic options map. All knn query
options (k, max_distance, min_score, method.ef_search, etc.) are now
passed through from the option string to the knn query JSON.

Validates that at least one search mode (k, max_distance, or min_score)
is specified. Adds tests for radial search modes.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mengweieric

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/VectorSearchIndex.java

@@ -5,6 +5,7 @@
 
 package org.opensearch.sql.opensearch.storage;
 
+import java.util.Map;
 import java.util.function.Function;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.index.query.QueryBuilder;
@@ -21,21 +22,23 @@
  */
 public class VectorSearchIndex extends OpenSearchIndex {
 
+  private static final String VECTOR_OPTION = "vector";
+
   private final String field;
   private final float[] vector;
-  private final int k;
+  private final Map<String, String> options;
 
   public VectorSearchIndex(
       OpenSearchClient client,
       Settings settings,
       String indexName,
       String field,
       float[] vector,
-      int k) {
+      Map<String, String> options) {
     super(client, settings, indexName);
     this.field = field;
     this.vector = vector;
-    this.k = k;
+    this.options = options;
   }
 
   @Override
@@ -66,9 +69,31 @@ private QueryBuilder buildKnnQuery() {
     }
     vectorJson.append("]");
 
+    StringBuilder optionsJson = new StringBuilder();
+    for (Map.Entry<String, String> entry : options.entrySet()) {
+      optionsJson.append(",");
+      String value = entry.getValue();
+      // Numeric values go unquoted, everything else quoted
+      if (isNumeric(value)) {
+        optionsJson.append(String.format("\"%s\":%s", entry.getKey(), value));
+      } else {
+        optionsJson.append(String.format("\"%s\":\"%s\"", entry.getKey(), value));
+      }
+    }
+
     String knnQueryJson =
         String.format(
-            "{\"knn\":{\"%s\":{\"vector\":%s,\"k\":%d}}}", field, vectorJson.toString(), k);
+            "{\"knn\":{\"%s\":{\"vector\":%s%s}}}",
+            field, vectorJson.toString(), optionsJson.toString());
     return new WrapperQueryBuilder(knnQueryJson);
   }
+
+  private static boolean isNumeric(String str) {
+    try {
+      Double.parseDouble(str);
+      return true;
+    } catch (NumberFormatException e) {
+      return false;
+    }
+  }
 }

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/VectorSearchTableFunctionImplementation.java

@@ -10,7 +10,9 @@
 import static org.opensearch.sql.opensearch.storage.VectorSearchTableFunctionResolver.TABLE;
 import static org.opensearch.sql.opensearch.storage.VectorSearchTableFunctionResolver.VECTOR;
 
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import org.opensearch.sql.common.setting.Settings;
 import org.opensearch.sql.data.model.ExprValue;
@@ -80,9 +82,10 @@ public Table applyArguments() {
     String optionStr = getArgumentValue(OPTION);
 
     float[] vector = parseVector(vectorLiteral);
-    int k = parseK(optionStr);
+    Map<String, String> options = parseOptions(optionStr);
+    validateOptions(options);
 
-    return new VectorSearchIndex(client, settings, tableName, fieldName, vector, k);
+    return new VectorSearchIndex(client, settings, tableName, fieldName, vector, options);
   }
 
   private float[] parseVector(String vectorLiteral) {
@@ -96,15 +99,25 @@ private float[] parseVector(String vectorLiteral) {
     return vector;
   }
 
-  private int parseK(String optionStr) {
-    // Parse "k=10" or "k=10,method.ef_search=100"
+  static Map<String, String> parseOptions(String optionStr) {
+    Map<String, String> options = new LinkedHashMap<>();
     for (String pair : optionStr.split(",")) {
       String[] kv = pair.trim().split("=", 2);
-      if (kv.length == 2 && kv[0].trim().equals("k")) {
-        return Integer.parseInt(kv[1].trim());
+      if (kv.length == 2) {
+        options.put(kv[0].trim(), kv[1].trim());
       }
     }
-    throw new ExpressionEvaluationException("Missing required option: k");
+    return options;
+  }
+
+  private void validateOptions(Map<String, String> options) {
+    boolean hasK = options.containsKey("k");
+    boolean hasMaxDistance = options.containsKey("max_distance");
+    boolean hasMinScore = options.containsKey("min_score");
+    if (!hasK && !hasMaxDistance && !hasMinScore) {
+      throw new ExpressionEvaluationException(
+          "Missing required option: one of k, max_distance, or min_score");
+    }
   }
 
   /** Extract a named argument's string value. */

opensearch/src/test/java/org/opensearch/sql/opensearch/storage/VectorSearchTableFunctionImplementationTest.java

@@ -5,12 +5,12 @@
 
 package org.opensearch.sql.opensearch.storage;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.List;
+import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
@@ -86,12 +86,36 @@ void testApplyArgumentsWithComplexOptions() {
   }
 
   @Test
-  void testMissingKOptionThrows() {
+  void testApplyArgumentsWithMaxDistance() {
+    VectorSearchTableFunctionImplementation impl =
+        createImplWithArgs("my-index", "embedding", "[1.0, 2.0]", "max_distance=10.0");
+    Table table = impl.applyArguments();
+    assertTrue(table instanceof VectorSearchIndex);
+  }
+
+  @Test
+  void testApplyArgumentsWithMinScore() {
+    VectorSearchTableFunctionImplementation impl =
+        createImplWithArgs("my-index", "embedding", "[1.0, 2.0]", "min_score=0.5");
+    Table table = impl.applyArguments();
+    assertTrue(table instanceof VectorSearchIndex);
+  }
+
+  @Test
+  void testMissingSearchModeOptionThrows() {
     VectorSearchTableFunctionImplementation impl =
         createImplWithArgs("my-index", "embedding", "[1.0, 2.0]", "method.ef_search=100");
     ExpressionEvaluationException ex =
         assertThrows(ExpressionEvaluationException.class, () -> impl.applyArguments());
-    assertEquals("Missing required option: k", ex.getMessage());
+    assertTrue(ex.getMessage().contains("one of k, max_distance, or min_score"));
+  }
+
+  @Test
+  void testParseOptionsMultiple() {
+    Map<String, String> opts =
+        VectorSearchTableFunctionImplementation.parseOptions("k=5,method.ef_search=100");
+    assertEquals("5", opts.get("k"));
+    assertEquals("100", opts.get("method.ef_search"));
   }
 
   @Test