Apply second-pass polish: return parsed numeric options, tighten key-order test

- parseIntOption / parseDoubleOption now return the parsed value so
  validateOptions does not re-parse the canonicalized string solely to
  check numeric bounds.
- The unknown-option-key stable-order test now matches the rendered
  list literal "[k, max_distance, min_score, filter_type]" rather
  than using indexOf("k"), which would match the "k" in "Unknown
  option key" and reduce the assertion to a tautology.
- Adds a direct unit test pinning parseOptions("") -> empty map, so
  the wholly-empty option string contract (which flows to the
  "Missing required option" gate) is exercised explicitly.

No functional change for user-visible paths.

Signed-off-by: Eric Wei <mengwei.eric@gmail.com>

Author: mengweieric

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

@@ -296,50 +296,49 @@ private void validateOptions(Map<String, String> options) {
     }
     // Parse and canonicalize numeric values — closes JSON injection via option values
     if (hasK) {
-      parseIntOption(options, "k");
-      int k = Integer.parseInt(options.get("k"));
+      int k = parseIntOption(options, "k");
       if (k < 1 || k > 10000) {
         throw new ExpressionEvaluationException(
             String.format("k must be between 1 and 10000, got %d", k));
       }
     }
     if (hasMaxDistance) {
-      parseDoubleOption(options, "max_distance");
-      double maxDistance = Double.parseDouble(options.get("max_distance"));
+      double maxDistance = parseDoubleOption(options, "max_distance");
       if (maxDistance < 0) {
         throw new ExpressionEvaluationException(
             String.format(
                 "max_distance must be non-negative, got %s", options.get("max_distance")));
       }
     }
     if (hasMinScore) {
-      parseDoubleOption(options, "min_score");
-      double minScore = Double.parseDouble(options.get("min_score"));
+      double minScore = parseDoubleOption(options, "min_score");
       if (minScore < 0) {
         throw new ExpressionEvaluationException(
             String.format("min_score must be non-negative, got %s", options.get("min_score")));
       }
     }
   }
 
-  private void parseIntOption(Map<String, String> options, String key) {
+  private int parseIntOption(Map<String, String> options, String key) {
     try {
       int value = Integer.parseInt(options.get(key));
       options.put(key, Integer.toString(value));
+      return value;
     } catch (NumberFormatException e) {
       throw new ExpressionEvaluationException(
           String.format("Option '%s' must be an integer, got '%s'", key, options.get(key)));
     }
   }
 
-  private void parseDoubleOption(Map<String, String> options, String key) {
+  private double parseDoubleOption(Map<String, String> options, String key) {
     try {
       double value = Double.parseDouble(options.get(key));
       if (!Double.isFinite(value)) {
         throw new ExpressionEvaluationException(
             String.format("Option '%s' must be a finite number, got '%s'", key, options.get(key)));
       }
       options.put(key, Double.toString(value));
+      return value;
     } catch (NumberFormatException e) {
       throw new ExpressionEvaluationException(
           String.format("Option '%s' must be a number, got '%s'", key, options.get(key)));

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

@@ -703,12 +703,20 @@ void applyArguments_unknownOptionKeyErrorListsSupportedKeysInStableOrder() {
         createImplWithArgs("my-index", "embedding", "[1.0, 2.0]", "k=5,bogus=1");
     ExpressionEvaluationException ex =
         assertThrows(ExpressionEvaluationException.class, () -> impl.applyArguments());
-    String msg = ex.getMessage();
-    int kIdx = msg.indexOf("k");
-    int maxIdx = msg.indexOf("max_distance");
-    int minIdx = msg.indexOf("min_score");
-    int filterIdx = msg.indexOf("filter_type");
-    assertTrue(kIdx >= 0 && maxIdx > kIdx && minIdx > maxIdx && filterIdx > minIdx);
+    // Match the rendered list literal (e.g. "[k, max_distance, min_score, filter_type]") rather
+    // than searching for the substring "k", which would match the first "k" in "Unknown option
+    // key" and reduce the assertion to a tautology.
+    assertTrue(
+        ex.getMessage().contains("[k, max_distance, min_score, filter_type]"),
+        "expected stable key order in error; got: " + ex.getMessage());
+  }
+
+  @Test
+  void parseOptions_emptyStringReturnsEmptyMap() {
+    // The wholly empty option string is explicitly allowed through parseOptions so it flows to
+    // the "Missing required option" gate in validateOptions. Pins that contract.
+    Map<String, String> opts = VectorSearchTableFunctionImplementation.parseOptions("");
+    assertTrue(opts.isEmpty());
   }
 
   private VectorSearchTableFunctionImplementation createImpl() {