fix(calcite): preserve SQL aggregate aliases in plan

SELECT col, COUNT(*) AS cnt produces an identity-shaped projection that
only renames a field. RelBuilder.project (force=false) treats such a
rename-only projection over unchanged columns as a no-op and skips
emitting the LogicalProject, so the alias was dropped from the output
schema (the column came back as the raw expression name, e.g. COUNT(*)).

Force the projection only when an AS genuinely renames a field, mirroring
how Calcite's own SqlToRelConverter materializes SELECT-list aliases. The
PPL path is unaffected: it never produces an AS RexCall through
visitProject (rename/eval/fields/stats build output names differently).

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

Author: dai-chen

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

@@ -355,6 +355,42 @@ SELECT department, COUNT(*) AS cnt FROM catalog.employees
             """);
   }
 
+  @Test
+  public void testOrderByAggregateAlias() {
+    givenQuery(
+            """
+            SELECT department, COUNT(*) AS cnt FROM catalog.employees
+              GROUP BY department ORDER BY cnt DESC LIMIT 3
+            """)
+        .assertPlan(
+            """
+            LogicalSort(sort0=[$1], dir0=[DESC-nulls-last])
+              LogicalProject(department=[$1], cnt=[$0])
+                LogicalSort(sort0=[$0], dir0=[DESC-nulls-last], fetch=[3])
+                  LogicalProject(COUNT(*)=[$1], department=[$0])
+                    LogicalAggregate(group=[{0}], COUNT(*)=[COUNT()])
+                      LogicalProject(department=[$3])
+                        LogicalTableScan(table=[[catalog, employees]])
+            """);
+  }
+
+  @Test
+  public void testAliasPreservedInOutputSchema() {
+    givenQuery("SELECT COUNT(*) AS cnt FROM catalog.employees").assertFields("cnt");
+
+    givenQuery("SELECT department, COUNT(*) AS cnt FROM catalog.employees GROUP BY department")
+        .assertFields("department", "cnt");
+
+    givenQuery("SELECT department, COUNT(*) FROM catalog.employees GROUP BY department")
+        .assertFields("department", "COUNT(*)");
+
+    givenQuery("SELECT MAX(age) + MIN(age) AS range_sum FROM catalog.employees")
+        .assertFields("range_sum");
+
+    givenQuery("SELECT id, name, age AS years, department FROM catalog.employees")
+        .assertFields("id", "name", "years", "department");
+  }
+
   @Test
   public void testHavingCompoundAnd() {
     givenQuery(

core/src/main/java/org/opensearch/sql/calcite/CalciteRelNodeVisitor.java

@@ -481,11 +481,30 @@ public RelNode visitProject(Project node, CalcitePlanContext context) {
       if (!context.isResolvingSubquery()) {
         context.setProjectVisited(true);
       }
-      context.relBuilder.project(expandedFields);
+
+      // Force the projection on a rename: without it, Calcite omits the project node when the
+      // columns are unchanged (same fields and order), so an alias like COUNT(*) AS cnt is lost.
+      boolean force = isRenameFieldsProject(expandedFields, currentFields);
+      context.relBuilder.project(expandedFields, ImmutableList.of(), force);
     }
     return context.relBuilder.peek();
   }
 
+  private static boolean isRenameFieldsProject(List<RexNode> fields, List<String> currentFields) {
+    for (RexNode r : fields) {
+      if (r.getKind() == AS) {
+        RexCall as = (RexCall) r;
+        if (as.getOperands().get(0) instanceof RexInputRef ref) {
+          String name = ((RexLiteral) as.getOperands().get(1)).getValueAs(String.class);
+          if (!name.equals(currentFields.get(ref.getIndex()))) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
   private boolean isSingleAllFieldsProject(Project node) {
     return node.getProjectList().size() == 1
         && node.getProjectList().getFirst() instanceof AllFields;