[Feature] Add table function relation to SQL grammar for vectorSearch()

Add table function relation support to the SQL parser:
- New `tableFunctionRelation` alternative in `relation` grammar rule
- Named argument syntax: `key=value` (e.g., table='index', field='vec')
- Alias is required by grammar (FROM func(...) AS alias)
- AstBuilder emits existing TableFunction + SubqueryAlias AST nodes
- 3 parser unit tests: basic parse, with WHERE/ORDER BY/LIMIT, alias required

This is a pure grammar change — no execution support yet. Queries will
parse successfully but fail at the Analyzer with "unsupported function".

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

Author: mengweieric

sql/src/main/antlr/OpenSearchSQLParser.g4

@@ -111,6 +111,15 @@ fromClause
 relation
    : tableName (AS? alias)?                                         # tableAsRelation
    | LR_BRACKET subquery = querySpecification RR_BRACKET AS? alias  # subqueryAsRelation
+   | qualifiedName LR_BRACKET tableFunctionArgs RR_BRACKET AS alias # tableFunctionRelation
+   ;
+
+tableFunctionArgs
+   : tableFunctionArg (COMMA tableFunctionArg)*
+   ;
+
+tableFunctionArg
+   : ident EQUAL_SYMBOL functionArg
    ;
 
 whereClause

sql/src/main/java/org/opensearch/sql/sql/parser/AstBuilder.java

@@ -13,6 +13,7 @@
 import static org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.SelectElementContext;
 import static org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.SubqueryAsRelationContext;
 import static org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.TableAsRelationContext;
+import static org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.TableFunctionRelationContext;
 import static org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.WhereClauseContext;
 import static org.opensearch.sql.sql.parser.ParserUtils.getTextInQuery;
 import static org.opensearch.sql.utils.SystemIndexUtils.TABLE_INFO;
@@ -26,6 +27,7 @@
 import org.opensearch.sql.ast.expression.Alias;
 import org.opensearch.sql.ast.expression.AllFields;
 import org.opensearch.sql.ast.expression.Function;
+import org.opensearch.sql.ast.expression.UnresolvedArgument;
 import org.opensearch.sql.ast.expression.UnresolvedExpression;
 import org.opensearch.sql.ast.tree.DescribeRelation;
 import org.opensearch.sql.ast.tree.Filter;
@@ -34,6 +36,7 @@
 import org.opensearch.sql.ast.tree.Relation;
 import org.opensearch.sql.ast.tree.RelationSubquery;
 import org.opensearch.sql.ast.tree.SubqueryAlias;
+import org.opensearch.sql.ast.tree.TableFunction;
 import org.opensearch.sql.ast.tree.UnresolvedPlan;
 import org.opensearch.sql.ast.tree.Values;
 import org.opensearch.sql.common.antlr.SyntaxCheckException;
@@ -189,6 +192,23 @@ public UnresolvedPlan visitSubqueryAsRelation(SubqueryAsRelationContext ctx) {
     return new RelationSubquery(visit(ctx.subquery), subqueryAlias);
   }
 
+  @Override
+  public UnresolvedPlan visitTableFunctionRelation(TableFunctionRelationContext ctx) {
+    ImmutableList.Builder<UnresolvedExpression> args = ImmutableList.builder();
+    ctx.tableFunctionArgs()
+        .tableFunctionArg()
+        .forEach(
+            arg -> {
+              String argName = arg.ident().getText();
+              UnresolvedExpression argValue = visitAstExpression(arg.functionArg());
+              args.add(new UnresolvedArgument(argName, argValue));
+            });
+    TableFunction tableFunction =
+        new TableFunction(visitAstExpression(ctx.qualifiedName()), args.build());
+    String alias = StringUtils.unquoteIdentifier(ctx.alias().getText());
+    return new SubqueryAlias(alias, tableFunction);
+  }
+
   @Override
   public UnresolvedPlan visitWhereClause(WhereClauseContext ctx) {
     return new Filter(visitAstExpression(ctx.expression()));

sql/src/test/java/org/opensearch/sql/sql/parser/AstBuilderTest.java

@@ -7,7 +7,9 @@
 
 import static java.util.Collections.emptyList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.opensearch.sql.ast.dsl.AstDSL.agg;
 import static org.opensearch.sql.ast.dsl.AstDSL.aggregate;
 import static org.opensearch.sql.ast.dsl.AstDSL.alias;
@@ -40,6 +42,10 @@
 import org.opensearch.sql.ast.expression.DataType;
 import org.opensearch.sql.ast.expression.Literal;
 import org.opensearch.sql.ast.expression.NestedAllTupleFields;
+import org.opensearch.sql.ast.expression.UnresolvedArgument;
+import org.opensearch.sql.ast.tree.SubqueryAlias;
+import org.opensearch.sql.ast.tree.TableFunction;
+import org.opensearch.sql.ast.tree.UnresolvedPlan;
 import org.opensearch.sql.common.antlr.SyntaxCheckException;
 
 class AstBuilderTest extends AstBuilderTestBase {
@@ -131,6 +137,57 @@ public void can_build_from_index_with_alias_quoted() {
         buildAST("SELECT `t`.name FROM test `t` WHERE `t`.age = 30"));
   }
 
+  @Test
+  public void can_build_from_table_function() {
+    assertEquals(
+        project(
+            new SubqueryAlias(
+                "v",
+                new TableFunction(
+                    qualifiedName("vectorSearch"),
+                    ImmutableList.of(
+                        new UnresolvedArgument("table", stringLiteral("products")),
+                        new UnresolvedArgument("field", stringLiteral("embedding")),
+                        new UnresolvedArgument("vector", stringLiteral("[0.1,0.2]")),
+                        new UnresolvedArgument("option", stringLiteral("k=10"))))),
+            AllFields.of()),
+        buildAST(
+            "SELECT * FROM vectorSearch("
+                + "table='products', field='embedding', "
+                + "vector='[0.1,0.2]', option='k=10') AS v"));
+  }
+
+  @Test
+  public void can_build_from_table_function_with_where_and_order() {
+    // Verify parsing succeeds for table function with WHERE, ORDER BY, and LIMIT
+    UnresolvedPlan plan =
+        buildAST(
+            "SELECT s.title, s._score FROM vectorSearch("
+                + "table='products', field='embedding', "
+                + "vector='[0.1,0.2]', option='k=10') AS s "
+                + "WHERE s.category = 'shoes' "
+                + "ORDER BY s._score DESC "
+                + "LIMIT 5");
+    assertNotNull(plan);
+    // Verify the plan contains the expected structure
+    String planStr = plan.toString();
+    assertTrue(planStr.contains("SubqueryAlias(alias=s"));
+    assertTrue(planStr.contains("TableFunction(functionName=vectorSearch"));
+    assertTrue(planStr.contains("UnresolvedArgument(argName=table, value=products)"));
+    assertTrue(planStr.contains("Filter(condition==(s.category, shoes)"));
+  }
+
+  @Test
+  public void table_function_relation_requires_alias() {
+    assertThrows(
+        SyntaxCheckException.class,
+        () ->
+            buildAST(
+                "SELECT * FROM vectorSearch("
+                    + "table='products', field='embedding', "
+                    + "vector='[0.1,0.2]', option='k=10')"));
+  }
+
   @Test
   public void can_build_where_clause() {
     assertEquals(