feat(api): Preserve original SQL expression text as column name

Calcite's SqlToRelConverter names unnamed SELECT items EXPR$0, EXPR$1,
etc. - surprising versus PostgreSQL/MySQL/Spark. Fix by adding
SelectItemAliasRewriter, a pre-validation SqlShuttle that wraps
unnamed, non-identifier items with AS <text> via the existing
LanguageSpec.postParseRules hook.

  SELECT COUNT(*) FROM t   -> `COUNT(*)`  (was EXPR$0)
  SELECT UPPER(name)       -> `UPPER(name)`
  SELECT x AS y, name, *   -> unchanged

Resolves #5332

Signed-off-by: Chen Dai <daichen@amazon.com>

Author: dai-chen

api/src/main/java/org/opensearch/sql/api/spec/search/SearchExtension.java

@@ -22,6 +22,8 @@ public SqlOperatorTable operators() {
 
   @Override
   public List<SqlVisitor<SqlNode>> postParseRules() {
-    return List.of(NamedArgRewriter.INSTANCE);
+    return List.of(
+        SelectItemAliasRewriter.INSTANCE, // TODO: non-search-specific and temporarily placed here
+        NamedArgRewriter.INSTANCE);
   }
 }

api/src/main/java/org/opensearch/sql/api/spec/search/SelectItemAliasRewriter.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.api.spec.search;
+
+import java.util.function.UnaryOperator;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.SqlWriterConfig;
+import org.apache.calcite.sql.dialect.AnsiSqlDialect;
+import org.apache.calcite.sql.util.SqlShuttle;
+import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * Wraps unnamed SELECT-list items with {@code AS <text>} so Calcite uses the expression text as the
+ * column name instead of synthetic {@code EXPR$N}.
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class SelectItemAliasRewriter extends SqlShuttle {
+
+  public static final SelectItemAliasRewriter INSTANCE = new SelectItemAliasRewriter();
+
+  /** Unparse config: bare identifiers (e.g., {@code SUM(a)} not {@code SUM(`a`)}). */
+  private static final UnaryOperator<SqlWriterConfig> UNPARSE_CONFIG =
+      c ->
+          c.withDialect(AnsiSqlDialect.DEFAULT)
+              .withQuoteAllIdentifiers(false)
+              .withAlwaysUseParentheses(false)
+              .withSelectListItemsOnSeparateLines(false)
+              .withUpdateSetListNewline(false)
+              .withIndentation(0);
+
+  @Override
+  public @Nullable SqlNode visit(SqlCall call) {
+    SqlCall visited = (SqlCall) super.visit(call);
+    if (visited instanceof SqlSelect select) {
+      SqlNodeList list = select.getSelectList();
+      for (int i = 0; i < list.size(); i++) {
+        list.set(i, aliasIfNeeded(list.get(i)));
+      }
+    }
+    return visited;
+  }
+
+  private static SqlNode aliasIfNeeded(SqlNode item) {
+    if (item.getKind() == SqlKind.AS
+        || item.getKind() == SqlKind.SELECT
+        || item instanceof SqlIdentifier) {
+      return item;
+    }
+    return SqlValidatorUtil.addAlias(item, item.toSqlString(UNPARSE_CONFIG).getSql());
+  }
+}

api/src/test/java/org/opensearch/sql/api/UnifiedQueryPlannerSqlTest.java

@@ -257,4 +257,22 @@ SELECT department, count(*)
             """)
         .assertErrorMessage("Encountered");
   }
+
+  @Test
+  public void testUnnamedMixedAggregates() {
+    givenQuery(
+            """
+            SELECT id, COUNT(*), AVG(age) FROM catalog.employees\
+            """)
+        .assertFields("id", "COUNT(*)", "AVG(age)");
+  }
+
+  @Test
+  public void testExplicitAliasStillWorks() {
+    givenQuery(
+            """
+            SELECT COUNT(*) AS cnt FROM catalog.employees\
+            """)
+        .assertFields("cnt");
+  }
 }

api/src/test/java/org/opensearch/sql/api/UnifiedRelevanceSearchSqlTest.java

@@ -137,7 +137,7 @@ SELECT upper(name) FROM catalog.employees\
             """)
         .assertPlan(
             """
-            LogicalProject(EXPR$0=[UPPER($1)])
+            LogicalProject(UPPER(name)=[UPPER($1)])
               LogicalTableScan(table=[[catalog, employees]])
             """);
   }

api/src/test/java/org/opensearch/sql/api/spec/search/SelectItemAliasRewriterTest.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.api.spec.search;
+
+import static org.junit.Assert.assertTrue;
+
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.parser.SqlParser;
+import org.junit.Test;
+import org.opensearch.sql.api.spec.UnifiedSqlSpec;
+
+/** Unit tests for {@link SelectItemAliasRewriter}. */
+public class SelectItemAliasRewriterTest {
+
+  /** Production parser config from {@link UnifiedSqlSpec}. */
+  private static final SqlParser.Config PARSER_CONFIG = UnifiedSqlSpec.extended().parserConfig();
+
+  @Test
+  public void testAliasesUnnamedExpression() throws Exception {
+    SqlNode result = rewrite("SELECT COUNT(*) FROM t");
+    assertContains(result, "AS `COUNT(*)`");
+  }
+
+  @Test
+  public void testPreservesExplicitAlias() throws Exception {
+    SqlNode result = rewrite("SELECT COUNT(*) AS cnt FROM t");
+    assertContains(result, "SELECT COUNT(*) AS `cnt`");
+  }
+
+  @Test
+  public void testSkipsSimpleIdentifier() throws Exception {
+    SqlNode result = rewrite("SELECT name FROM t");
+    assertContains(result, "SELECT `name`");
+  }
+
+  @Test
+  public void testSkipsStar() throws Exception {
+    SqlNode result = rewrite("SELECT * FROM t");
+    assertContains(result, "SELECT *");
+  }
+
+  @Test
+  public void testSkipsQualifiedStar() throws Exception {
+    SqlNode result = rewrite("SELECT t.* FROM t");
+    assertContains(result, "SELECT `t`.*");
+  }
+
+  @Test
+  public void testSkipsScalarSubquery() throws Exception {
+    // Avoids producing a column name like "SELECT MAX(x) AS MAX(x) FROM u" from our own
+    // recursion. Calcite will fall back to EXPR$N, matching Flink/Druid/Drill default.
+    SqlNode result = rewrite("SELECT (SELECT MAX(x) FROM u) FROM t");
+    assertContains(result, "SELECT (SELECT MAX(`x`) AS `MAX(x)` FROM `u`) FROM `t`");
+  }
+
+  @Test
+  public void testRecursesIntoSubquery() throws Exception {
+    SqlNode result = rewrite("SELECT x FROM (SELECT COUNT(*) FROM t) s");
+    assertContains(result, "AS `COUNT(*)`");
+  }
+
+  @Test
+  public void testHandlesMixedItemsCorrectly() throws Exception {
+    SqlNode result = rewrite("SELECT id, COUNT(*), name AS n FROM t");
+    assertContains(result, "SELECT `id`, COUNT(*) AS `COUNT(*)`, `name` AS `n`");
+  }
+
+  @Test
+  public void testPreservesIdentifierInAggregate() throws Exception {
+    SqlNode result = rewrite("SELECT SUM(MyCol), SUM(x + 1) FROM t");
+    assertContains(result, "AS `SUM(MyCol)`");
+    assertContains(result, "AS `SUM(x + 1)`");
+  }
+
+  private static SqlNode rewrite(String sql) throws Exception {
+    return parse(sql).accept(SelectItemAliasRewriter.INSTANCE);
+  }
+
+  private static SqlNode parse(String sql) throws Exception {
+    return SqlParser.create(sql, PARSER_CONFIG).parseStmt();
+  }
+
+  private static void assertContains(SqlNode node, String expected) {
+    String actual = node.toString().replaceAll("\\n", " ");
+    assertTrue(
+        "Expected to contain: " + expected + "\nActual: " + actual, actual.contains(expected));
+  }
+}