Fix interval semantic mismatch between sql and ppl

Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>

Author: yuancu

…ch/sql/calcite/PplRelToSqlConverter.java …e/validate/PplRelToSqlNodeConverter.javacore/src/main/java/org/opensearch/sql/calcite/PplRelToSqlConverter.java renamed to core/src/main/java/org/opensearch/sql/calcite/validate/PplRelToSqlNodeConverter.java core/src/main/java/org/opensearch/sql/calcite/PplRelToSqlConverter.java renamed to core/src/main/java/org/opensearch/sql/calcite/validate/PplRelToSqlNodeConverter.java

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package org.opensearch.sql.calcite;
+package org.opensearch.sql.calcite.validate;
 
 import org.apache.calcite.rel.rel2sql.RelToSqlConverter;
 import org.apache.calcite.sql.SqlDialect;
@@ -15,8 +15,8 @@
  * <p>This converter is used during the validation phase to convert RelNode back to SqlNode for
  * validation and type checking using Calcite's SqlValidator.
  *
- * <p>Currently, we haven't implemented any specific changes to it, just leaving it for future
- * extension.
+ * <p>Note: Interval literal issues are handled by preprocessing with {@link
+ * IntervalLiteralFixShuttle} before conversion.
  */
 public class PplRelToSqlConverter extends RelToSqlConverter {
   /**

core/src/main/java/org/opensearch/sql/calcite/validate/PplRelToSqlRelShuttle.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.validate;
+
+import java.math.BigDecimal;
+import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelShuttleImpl;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.sql.SqlIntervalQualifier;
+
+/**
+ * A RelShuttle that recursively visits all RelNodes and their RexNode expressions to fix interval
+ * literals before/after SQL conversion.
+ *
+ * <p>This shuttle extends RelShuttleImpl to ensure it visits the entire RelNode tree recursively,
+ * applying the interval literal fixes at each node.
+ */
+public class PplRelToSqlRelShuttle extends RelShuttleImpl {
+  private final RexShuttle rexShuttle;
+
+  public PplRelToSqlRelShuttle(RexBuilder rexBuilder, boolean forward) {
+    this.rexShuttle =
+        new RexShuttle() {
+          @Override
+          public RexNode visitLiteral(RexLiteral literal) {
+            SqlIntervalQualifier qualifier = literal.getType().getIntervalQualifier();
+            if (qualifier == null) {
+              return literal;
+            }
+            BigDecimal value = literal.getValueAs(BigDecimal.class);
+            if (value == null) {
+              return literal;
+            }
+            TimeUnit unit = qualifier.getUnit();
+            BigDecimal newValue =
+                forward
+                    ? value.multiply(unit.multiplier)
+                    : value.divideToIntegralValue(unit.multiplier);
+            return rexBuilder.makeIntervalLiteral(newValue, qualifier);
+          }
+        };
+  }
+
+  @Override
+  protected RelNode visitChild(RelNode parent, int i, RelNode child) {
+    // First visit the child recursively
+    RelNode newChild = super.visitChild(parent, i, child);
+    // Then apply the RexShuttle to the child's expressions
+    return newChild.accept(rexShuttle);
+  }
+}

core/src/main/java/org/opensearch/sql/executor/QueryService.java

@@ -51,10 +51,11 @@
 import org.opensearch.sql.calcite.CalcitePlanContext;
 import org.opensearch.sql.calcite.CalciteRelNodeVisitor;
 import org.opensearch.sql.calcite.OpenSearchSchema;
-import org.opensearch.sql.calcite.PplRelToSqlConverter;
 import org.opensearch.sql.calcite.SysLimit;
 import org.opensearch.sql.calcite.plan.LogicalSystemLimit;
 import org.opensearch.sql.calcite.plan.LogicalSystemLimit.SystemLimitType;
+import org.opensearch.sql.calcite.validate.PplRelToSqlNodeConverter;
+import org.opensearch.sql.calcite.validate.PplRelToSqlRelShuttle;
 import org.opensearch.sql.common.response.ResponseListener;
 import org.opensearch.sql.common.setting.Settings;
 import org.opensearch.sql.datasource.DataSourceService;
@@ -80,8 +81,8 @@ public class QueryService {
   private final Planner planner;
   private DataSourceService dataSourceService;
   private Settings settings;
-  private static final PplRelToSqlConverter converter =
-      new PplRelToSqlConverter(MysqlSqlDialect.DEFAULT);
+  private static final PplRelToSqlNodeConverter converter =
+      new PplRelToSqlNodeConverter(MysqlSqlDialect.DEFAULT);
 
   @Getter(lazy = true)
   private final CalciteRelNodeVisitor relNodeVisitor = new CalciteRelNodeVisitor(dataSourceService);
@@ -314,8 +315,11 @@ public LogicalPlan analyze(UnresolvedPlan plan, QueryType queryType) {
    * @return the validated (and potentially modified) relation node
    */
   private RelNode validate(RelNode relNode, CalcitePlanContext context) {
+    // Fix interval literals before conversion to SQL
+    RelNode sqlRelNode = relNode.accept(new PplRelToSqlRelShuttle(context.rexBuilder, true));
+
     // Convert RelNode to SqlNode for validation
-    SqlImplementor.Result result = converter.visitRoot(relNode);
+    SqlImplementor.Result result = converter.visitRoot(sqlRelNode);
     SqlNode root = result.asStatement();
 
     // Rewrite SqlNode to remove database qualifiers
@@ -337,20 +341,14 @@ public SqlNode visit(SqlIdentifier id) {
     SqlValidator validator = context.getValidator();
     if (rewritten != null) {
       try {
-        String before = rewritten.toString();
-        // rewritten will be modified in-place by validation
+        log.debug("Before validation: {}", rewritten);
         validator.validate(rewritten);
         log.debug("After validation: {}", rewritten);
-        String after = rewritten.toString();
-        if (before.equals(after)) {
-          // If the rewritten SQL node is not modified, return the original RelNode as is
-          return relNode;
-        }
       } catch (CalciteContextException e) {
         throw new ExpressionEvaluationException(e.getMessage(), e);
       }
     } else {
-      log.debug("Failed to rewrite the SQL node before validation: {}", root);
+      log.info("Failed to rewrite the SQL node before validation: {}", root);
       return relNode;
     }
 
@@ -367,8 +365,8 @@ public SqlNode visit(SqlIdentifier id) {
             cluster,
             StandardConvertletTable.INSTANCE,
             SqlToRelConverter.config());
-    RelRoot validatedRelRoot = sql2rel.convertQuery(rewritten, true, true);
-    return validatedRelRoot.rel;
+    RelRoot validatedRelRoot = sql2rel.convertQuery(rewritten, false, true);
+    return validatedRelRoot.rel.accept(new PplRelToSqlRelShuttle(context.rexBuilder, false));
   }
 
   /** Translate {@link LogicalPlan} to {@link PhysicalPlan}. */