feat(api): Add Calcite native SQL planning path in UnifiedQueryPlanner

Add SQL support to the unified query API using Calcite's native parser
pipeline (SqlParser → SqlValidator → SqlToRelConverter → RelNode),
bypassing the ANTLR parser used by PPL.

Changes:
- UnifiedQueryPlanner: route SQL queries to new planWithCalcite() method
  with HepPlanner optimization (AGGREGATE_CASE_TO_FILTER rule)
- UnifiedQueryContext: configure SQL-aware SqlParser.Config with
  Casing.UNCHANGED and Programs.standard() for richer optimization rules

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

Author: dai-chen

api/src/main/java/org/opensearch/sql/api/UnifiedQueryContext.java

@@ -14,6 +14,7 @@
 import java.util.Map;
 import java.util.Objects;
 import lombok.Value;
+import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.jdbc.CalciteSchema;
 import org.apache.calcite.plan.RelTraitDef;
 import org.apache.calcite.rel.metadata.DefaultRelMetadataProvider;
@@ -176,13 +177,21 @@ private FrameworkConfig buildFrameworkConfig() {
 
       SchemaPlus defaultSchema = findSchemaByPath(rootSchema, defaultNamespace);
       return Frameworks.newConfigBuilder()
-          .parserConfig(SqlParser.Config.DEFAULT)
+          .parserConfig(buildParserConfig())
           .defaultSchema(defaultSchema)
           .traitDefs((List<RelTraitDef>) null)
-          .programs(Programs.calc(DefaultRelMetadataProvider.INSTANCE))
+          .programs(Programs.standard(DefaultRelMetadataProvider.INSTANCE))
           .build();
     }
 
+    private SqlParser.Config buildParserConfig() {
+      if (queryType == QueryType.SQL) {
+        // Preserve identifier case for SQL — Calcite default (TO_UPPER) breaks lowercase schemas
+        return SqlParser.Config.DEFAULT.withUnquotedCasing(Casing.UNCHANGED);
+      }
+      return SqlParser.Config.DEFAULT;
+    }
+
     private SchemaPlus findSchemaByPath(SchemaPlus rootSchema, String defaultPath) {
       if (defaultPath == null) {
         return rootSchema;

api/src/main/java/org/opensearch/sql/api/UnifiedQueryPlanner.java

@@ -6,11 +6,18 @@
 package org.opensearch.sql.api;
 
 import org.antlr.v4.runtime.tree.ParseTree;
+import org.apache.calcite.plan.hep.HepPlanner;
+import org.apache.calcite.plan.hep.HepProgramBuilder;
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelRoot;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.logical.LogicalSort;
+import org.apache.calcite.rel.rules.CoreRules;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.tools.Frameworks;
+import org.apache.calcite.tools.Planner;
 import org.opensearch.sql.ast.statement.Query;
 import org.opensearch.sql.ast.statement.Statement;
 import org.opensearch.sql.ast.tree.UnresolvedPlan;
@@ -26,15 +33,22 @@
  * {@code UnifiedQueryPlanner} provides a high-level API for parsing and analyzing queries using the
  * Calcite-based query engine. It serves as the primary integration point for external consumers
  * such as Spark or command-line tools, abstracting away Calcite internals.
+ *
+ * <p>Two planning paths are supported:
+ *
+ * <ul>
+ *   <li><b>PPL</b>: ANTLR parser → AST → CalciteRelNodeVisitor → RelNode
+ *   <li><b>SQL</b>: Calcite native SqlParser → SqlValidator → SqlToRelConverter → RelNode
+ * </ul>
  */
 public class UnifiedQueryPlanner {
-  /** The parser instance responsible for converting query text into a parse tree. */
+  /** The parser instance responsible for converting query text into a parse tree (PPL only). */
   private final Parser parser;
 
   /** Unified query context containing CalcitePlanContext with all configuration. */
   private final UnifiedQueryContext context;
 
-  /** AST-to-RelNode visitor that builds logical plans from the parsed AST. */
+  /** AST-to-RelNode visitor that builds logical plans from the parsed AST (PPL only). */
   private final CalciteRelNodeVisitor relNodeVisitor =
       new CalciteRelNodeVisitor(new EmptyDataSourceService());
 
@@ -44,19 +58,23 @@ public class UnifiedQueryPlanner {
    * @param context the unified query context containing CalcitePlanContext
    */
   public UnifiedQueryPlanner(UnifiedQueryContext context) {
-    this.parser = buildQueryParser(context.getPlanContext().queryType);
     this.context = context;
+    this.parser =
+        context.getPlanContext().queryType == QueryType.PPL ? new PPLSyntaxParser() : null;
   }
 
   /**
    * Parses and analyzes a query string into a Calcite logical plan (RelNode). TODO: Generate
    * optimal physical plan to fully unify query execution and leverage Calcite's optimizer.
    *
-   * @param query the raw query string in PPL or other supported syntax
+   * @param query the raw query string in PPL or SQL syntax
    * @return a logical plan representing the query
    */
   public RelNode plan(String query) {
     try {
+      if (context.getPlanContext().queryType == QueryType.SQL) {
+        return planWithCalcite(query);
+      }
       return preserveCollation(analyze(parse(query)));
     } catch (SyntaxCheckException e) {
       // Re-throw syntax error without wrapping
@@ -66,11 +84,29 @@ public RelNode plan(String query) {
     }
   }
 
-  private Parser buildQueryParser(QueryType queryType) {
-    if (queryType == QueryType.PPL) {
-      return new PPLSyntaxParser();
+  /**
+   * Plans a SQL query using Calcite's native parser and validator. The pipeline is: SqlParser →
+   * SqlValidator → SqlToRelConverter → HepPlanner optimization → RelNode.
+   */
+  private RelNode planWithCalcite(String query) throws Exception {
+    Planner planner = Frameworks.getPlanner(context.getPlanContext().config);
+    try {
+      SqlNode parsed = planner.parse(query);
+      SqlNode validated = planner.validate(parsed);
+      RelRoot relRoot = planner.rel(validated);
+      return optimize(relRoot.rel);
+    } finally {
+      planner.close();
     }
-    throw new IllegalArgumentException("Unsupported query type: " + queryType);
+  }
+
+  /** Applies heuristic optimization rules to the logical plan. */
+  private RelNode optimize(RelNode rel) {
+    HepPlanner hepPlanner =
+        new HepPlanner(
+            new HepProgramBuilder().addRuleInstance(CoreRules.AGGREGATE_CASE_TO_FILTER).build());
+    hepPlanner.setRoot(rel);
+    return hepPlanner.findBestExp();
   }
 
   private UnresolvedPlan parse(String query) {