Address review feedback on table function relation grammar

1. Canonicalize argument names at parser boundary:
   unquoteIdentifier + toLowerCase(Locale.ROOT) in visitTableFunctionRelation
   so FIELD='x' and `field`='x' both produce argName="field"

2. Make AS keyword optional (AS? alias) for consistency with
   tableAsRelation and subqueryAsRelation grammar rules

3. Strengthen test coverage:
   - Full structural AST assertion for WHERE + ORDER BY + LIMIT
     (verifies Sort, Limit, Filter nodes, not just toString)
   - Argument reorder test proves names resolve by name not position
   - Case canonicalization test (TABLE= → table=)
   - Alias-without-AS test (FROM func(...) v)

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

Author: mengweieric

sql/src/main/antlr/OpenSearchSQLParser.g4

@@ -111,7 +111,7 @@ fromClause
 relation
    : tableName (AS? alias)?                                         # tableAsRelation
    | LR_BRACKET subquery = querySpecification RR_BRACKET AS? alias  # subqueryAsRelation
-   | qualifiedName LR_BRACKET tableFunctionArgs RR_BRACKET AS alias # tableFunctionRelation
+   | qualifiedName LR_BRACKET tableFunctionArgs RR_BRACKET AS? alias # tableFunctionRelation
    ;
 
 tableFunctionArgs

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

@@ -21,6 +21,7 @@
 
 import com.google.common.collect.ImmutableList;
 import java.util.Collections;
+import java.util.Locale;
 import java.util.Optional;
 import lombok.RequiredArgsConstructor;
 import org.antlr.v4.runtime.tree.ParseTree;
@@ -199,7 +200,9 @@ public UnresolvedPlan visitTableFunctionRelation(TableFunctionRelationContext ct
         .tableFunctionArg()
         .forEach(
             arg -> {
-              String argName = arg.ident().getText();
+              String argName =
+                  StringUtils.unquoteIdentifier(arg.ident().getText())
+                      .toLowerCase(Locale.ROOT);
               UnresolvedExpression argValue = visitAstExpression(arg.functionArg());
               args.add(new UnresolvedArgument(argName, argValue));
             });

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

@@ -7,9 +7,7 @@
 
 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;
@@ -45,7 +43,6 @@
 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 {
@@ -158,23 +155,94 @@ public void can_build_from_table_function() {
   }
 
   @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 =
+  public void can_build_from_table_function_with_where_order_limit() {
+    assertEquals(
+        project(
+            limit(
+                sort(
+                    filter(
+                        new SubqueryAlias(
+                            "s",
+                            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"))))),
+                        function("=", qualifiedName("s", "category"), stringLiteral("shoes"))),
+                    field(
+                        qualifiedName("s", "_score"),
+                        argument("asc", booleanLiteral(false)))),
+                5,
+                0),
+            alias("s.title", qualifiedName("s", "title")),
+            alias("s._score", qualifiedName("s", "_score"))),
         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)"));
+                + "LIMIT 5"));
+  }
+
+  @Test
+  public void table_function_args_are_resolved_by_name_not_position() {
+    assertEquals(
+        project(
+            new SubqueryAlias(
+                "v",
+                new TableFunction(
+                    qualifiedName("vectorSearch"),
+                    ImmutableList.of(
+                        new UnresolvedArgument("option", stringLiteral("k=10")),
+                        new UnresolvedArgument("field", stringLiteral("embedding")),
+                        new UnresolvedArgument("table", stringLiteral("products")),
+                        new UnresolvedArgument("vector", stringLiteral("[0.1,0.2]"))))),
+            AllFields.of()),
+        buildAST(
+            "SELECT * FROM vectorSearch("
+                + "option='k=10', field='embedding', "
+                + "table='products', vector='[0.1,0.2]') AS v"));
+  }
+
+  @Test
+  public void table_function_arg_names_are_canonicalized() {
+    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 table_function_allows_alias_without_as_keyword() {
+    assertEquals(
+        project(
+            new SubqueryAlias(
+                "v",
+                new TableFunction(
+                    qualifiedName("vectorSearch"),
+                    ImmutableList.of(
+                        new UnresolvedArgument("table", stringLiteral("products")),
+                        new UnresolvedArgument("vector", stringLiteral("[0.1]"))))),
+            AllFields.of()),
+        buildAST(
+            "SELECT * FROM vectorSearch(table='products', vector='[0.1]') v"));
   }
 
   @Test