[BugFix] Surface dedicated error for wildcard or multi-target table in vectorSearch()

vectorSearch() requires a single concrete index because top-k
semantics, dimension checks, and the embedded filter JSON are not
defined across heterogeneous shards. Values like 'sql_vector_*' or
'idx_a,idx_b' were already rejected by the generic SAFE_FIELD_NAME
character-class regex, but surfaced the fallback message
"must contain only alphanumeric characters, dots, underscores, or
hyphens", which does not tell the user what the actual constraint
is.

This change adds a dedicated check (before the regex) that flags
'*' and ',' in the table name and surfaces:

  "Invalid table name '...': vectorSearch() requires a single
   concrete index or alias; wildcards ('*') and multi-target
   patterns (comma-separated) are not supported"

No DSL or execution-path change. Accepted inputs are unchanged
(simple names, dotted names, hyphens, underscores all still pass).

Adds four unit tests (bare '*', trailing '*', mid-name '*',
multi-target ',') and two integration tests pinning the new
message on real queries.

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

Author: mengweieric

integ-test/src/test/java/org/opensearch/sql/sql/VectorSearchIT.java

@@ -399,6 +399,39 @@ public void testInvalidTableNameRejected() throws IOException {
     assertThat(ex.getMessage(), containsString("Invalid table name"));
   }
 
+  @Test
+  public void testWildcardTableRejectedWithDedicatedMessage() throws IOException {
+    // Wildcards in a table name fan out to multiple indices, which vectorSearch() does not
+    // support (top-k semantics, dimension checks, and embedded filter JSON are not defined
+    // across heterogeneous shards). Surface a dedicated user-facing error instead of the
+    // generic "must contain only alphanumeric..." fallback.
+    ResponseException ex =
+        expectThrows(
+            ResponseException.class,
+            () ->
+                executeQuery(
+                    "SELECT v._id FROM vectorSearch(table='sql_vector_*', field='f', "
+                        + "vector='[1.0]', option='k=5') AS v"));
+
+    assertThat(ex.getMessage(), containsString("Invalid table name"));
+    assertThat(ex.getMessage(), containsString("wildcards"));
+    assertThat(ex.getMessage(), containsString("single concrete index"));
+  }
+
+  @Test
+  public void testMultiTargetTableRejectedWithDedicatedMessage() throws IOException {
+    ResponseException ex =
+        expectThrows(
+            ResponseException.class,
+            () ->
+                executeQuery(
+                    "SELECT v._id FROM vectorSearch(table='idx_a,idx_b', field='f', "
+                        + "vector='[1.0]', option='k=5') AS v"));
+
+    assertThat(ex.getMessage(), containsString("Invalid table name"));
+    assertThat(ex.getMessage(), containsString("multi-target"));
+  }
+
   @Test
   public void testDuplicateNamedArgRejected() throws IOException {
     // Previously this crashed the server with 500 ArrayIndexOutOfBoundsException. Must now

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

@@ -234,6 +234,19 @@ private void validateNamedArgs() {
    * its own error message.
    */
   private void validateTableName(String tableName) {
+    // Flag wildcard and multi-target patterns with a dedicated message before the generic
+    // character-class check, so users get an actionable hint instead of "must contain only
+    // alphanumeric characters, dots, ...". vectorSearch() targets a single index because
+    // top-k semantics, dimension checks, and the embedded filter JSON are not defined across
+    // heterogeneous shards.
+    if (tableName.indexOf('*') >= 0 || tableName.indexOf(',') >= 0) {
+      throw new ExpressionEvaluationException(
+          String.format(
+              "Invalid table name '%s': vectorSearch() requires a single concrete index or alias;"
+                  + " wildcards ('*') and multi-target patterns (comma-separated) are not"
+                  + " supported",
+              tableName));
+    }
     if (!SAFE_FIELD_NAME.matcher(tableName).matches()) {
       throw new ExpressionEvaluationException(
           String.format(

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

@@ -498,6 +498,46 @@ void applyArguments_rejectsDoubleDotTable() {
     assertTrue(ex.getMessage().contains("Invalid table name"));
   }
 
+  @Test
+  void applyArguments_rejectsWildcardTableWithDedicatedMessage() {
+    VectorSearchTableFunctionImplementation impl =
+        createImplWithArgs("sql_vector_*", "embedding", "[1.0, 2.0]", "k=5");
+    ExpressionEvaluationException ex =
+        assertThrows(ExpressionEvaluationException.class, () -> impl.applyArguments());
+    assertTrue(ex.getMessage().contains("Invalid table name"));
+    assertTrue(ex.getMessage().contains("wildcards ('*')"));
+    assertTrue(ex.getMessage().contains("single concrete index"));
+  }
+
+  @Test
+  void applyArguments_rejectsBareStarTableWithDedicatedMessage() {
+    VectorSearchTableFunctionImplementation impl =
+        createImplWithArgs("*", "embedding", "[1.0, 2.0]", "k=5");
+    ExpressionEvaluationException ex =
+        assertThrows(ExpressionEvaluationException.class, () -> impl.applyArguments());
+    assertTrue(ex.getMessage().contains("wildcards ('*')"));
+  }
+
+  @Test
+  void applyArguments_rejectsMultiTargetTableWithDedicatedMessage() {
+    VectorSearchTableFunctionImplementation impl =
+        createImplWithArgs("idx_a,idx_b", "embedding", "[1.0, 2.0]", "k=5");
+    ExpressionEvaluationException ex =
+        assertThrows(ExpressionEvaluationException.class, () -> impl.applyArguments());
+    assertTrue(ex.getMessage().contains("Invalid table name"));
+    assertTrue(ex.getMessage().contains("multi-target"));
+    assertTrue(ex.getMessage().contains("single concrete index"));
+  }
+
+  @Test
+  void applyArguments_rejectsMidNameStarTable() {
+    VectorSearchTableFunctionImplementation impl =
+        createImplWithArgs("foo*bar", "embedding", "[1.0, 2.0]", "k=5");
+    ExpressionEvaluationException ex =
+        assertThrows(ExpressionEvaluationException.class, () -> impl.applyArguments());
+    assertTrue(ex.getMessage().contains("wildcards ('*')"));
+  }
+
   @Test
   void validateNamedArgs_rejectsDuplicateNames() {
     // Two occurrences of "table" reach the Implementation layer directly (bypassing the resolver).