Preserve DATE/TIME return type for ADDDATE/SUBDATE/ADDTIME/SUBTIME on date/time columns

On the analytics-engine route a 'date'/'time' column is a TIMESTAMP-backed
DateOnlyType/TimeOnlyType marker, so operand-conditional return-type inference
mis-read it as TIMESTAMP — ADDDATE(date_col, N) reported (and rendered) TIMESTAMP
instead of DATE. Add isDateExprType/isTimeExprType helpers recognizing those
markers (off the general conversion path, no substrait round-trip risk) and use
them in AddSubDateFunction and PPLReturnTypes.TIME_APPLY_RETURN_TYPE. Fixes the
6 *Null column-operand cases end-to-end.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Vinay Krishna Pudyodu <vinkrish.neo@gmail.com>

Author: 2 people

core/src/main/java/org/opensearch/sql/calcite/utils/OpenSearchTypeFactory.java

@@ -279,6 +279,24 @@ public static ExprType convertRelDataTypeToExprType(RelDataType type) {
     return exprType;
   }
 
+  /**
+   * Whether {@code type} represents a DATE for the purpose of operand-conditional return-type
+   * inference (e.g. {@code ADDDATE(date, n)} returns DATE only when the base is a date). Recognizes
+   * both the SQL-plugin DATE UDT (via {@link #convertRelDataTypeToExprType}) and the
+   * analytics-route {@link DateOnlyType} column marker, which is {@code TIMESTAMP}-backed and would
+   * otherwise be misread as TIMESTAMP. Kept separate from {@link #convertRelDataTypeToExprType} so
+   * it isn't on the general planner path that round-trips through {@link
+   * #convertExprTypeToRelDataType}.
+   */
+  public static boolean isDateExprType(RelDataType type) {
+    return type instanceof DateOnlyType || convertRelDataTypeToExprType(type) == ExprCoreType.DATE;
+  }
+
+  /** TIME counterpart of {@link #isDateExprType} — recognizes the {@link TimeOnlyType} marker. */
+  public static boolean isTimeExprType(RelDataType type) {
+    return type instanceof TimeOnlyType || convertRelDataTypeToExprType(type) == ExprCoreType.TIME;
+  }
+
   /**
    * Result-schema-only variant of {@link #convertRelDataTypeToExprType} that recognizes the
    * analytics-engine {@link IpType} / {@link BinaryType} markers as {@link ExprCoreType#IP} /

core/src/main/java/org/opensearch/sql/calcite/utils/PPLReturnTypes.java

@@ -12,7 +12,6 @@
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeTransforms;
 import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.opensearch.sql.data.type.ExprCoreType;
 
 /**
  * Return types used in PPL. This class complements the {@link
@@ -36,8 +35,9 @@ private PPLReturnTypes() {}
   public static SqlReturnTypeInference TIME_APPLY_RETURN_TYPE =
       opBinding -> {
         RelDataType temporalType = opBinding.getOperandType(0);
-        if (ExprCoreType.TIME.equals(
-            OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType))) {
+        // isTimeExprType so a TimeOnlyType column (analytics-route TIMESTAMP-backed time marker) is
+        // recognized as TIME; otherwise ADDTIME/SUBTIME on a time column lose the TIME return type.
+        if (OpenSearchTypeFactory.isTimeExprType(temporalType)) {
           return UserDefinedFunctionUtils.NULLABLE_TIME_UDT;
         }
         return UserDefinedFunctionUtils.NULLABLE_TIMESTAMP_UDT;

core/src/main/java/org/opensearch/sql/expression/function/udf/datetime/AddSubDateFunction.java

@@ -63,7 +63,10 @@ public SqlReturnTypeInference getReturnTypeInference() {
     return opBinding -> {
       RelDataType temporalType = opBinding.getOperandType(0);
       RelDataType temporalDeltaType = opBinding.getOperandType(1);
-      if (OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType) == ExprCoreType.DATE
+      // isDateExprType (not convertRelDataTypeToExprType == DATE) so a DateOnlyType column — the
+      // analytics-route TIMESTAMP-backed date marker — is recognized as DATE; otherwise ADDDATE/
+      // SUBDATE on a date column would mis-declare TIMESTAMP and lose the DATE return type.
+      if (OpenSearchTypeFactory.isDateExprType(temporalType)
           && SqlTypeFamily.NUMERIC.contains(temporalDeltaType)) {
         return NULLABLE_DATE_UDT;
       } else {