Register PPL ADDDATE/SUBDATE with integer-days overload

ADDDATE / SUBDATE were unbound in the analytics-engine scalar registry,
so PPL queries using either UDF returned `No backend supports scalar
function [ADDDATE]`. Both alias DATE_ADD / DATE_SUB but additionally
accept an integer second operand (days), which the existing
DateAddSubAdapter rejected.

Add ADDDATE / SUBDATE to ScalarFunction, register them against the
shared DateAddSubAdapter, and extend the adapter to rebuild integer
operands as INTERVAL N DAY before the existing interval-lowering path.
Cluster verified — 10/10 affected queries return HTTP 200 with expected
values; null-row semantics preserved.

Author: vinaykpud

sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/DateAddSubAdapter.java

@@ -31,7 +31,8 @@
 
 /**
  * Rewrites PPL {@code DATE_ADD(base, INTERVAL n unit)} / {@code DATE_SUB(base, INTERVAL n unit)}
- * into {@code DATETIME_PLUS(CAST(base AS TIMESTAMP), interval)}, which lowers to Substrait's
+ * (and the alias forms {@code ADDDATE} / {@code SUBDATE}) into
+ * {@code DATETIME_PLUS(CAST(base AS TIMESTAMP), interval)}, which lowers to Substrait's
  * {@code add(timestamp, interval)} that DataFusion executes natively. The raw PPL UDFs have no
  * Substrait binding, so isthmus rejects them.
  *
@@ -45,6 +46,10 @@
  * {@link TimeUnit#DAY} or {@link TimeUnit#MONTH} qualifier) and folds the {@code DATE_SUB} sign in,
  * the same way {@link EarliestLatestAdapter} does.
  *
+ * <p>{@code ADDDATE(base, n_days)} / {@code SUBDATE(base, n_days)} share the same lowering: the
+ * integer second operand is rebuilt as an {@code INTERVAL n DAY} literal before the standard
+ * interval path runs. This matches the SQL plugin's {@code AddSubDateFunction} semantics.
+ *
  * <p>DATE / TIMESTAMP / TIME / character bases are all lowered. TIME anchors to today-UTC at plan
  * time, which can drift from the PPL UDF's query-start anchor across UTC midnight or cached plans
  * (TODO: thread {@code FunctionProperties#getQueryStartClock} through to adapters). MICROSECOND
@@ -74,21 +79,14 @@ public RexNode adapt(RexCall original, List<FieldStorageInfo> fieldStorage, RelO
         }
         RexBuilder rexBuilder = cluster.getRexBuilder();
         RexNode base = original.getOperands().get(0);
-        RexNode intervalOperand = stripOperatorAnnotation(original.getOperands().get(1));
-
-        SqlIntervalQualifier qualifier;
-        BigDecimal leadingValue;
-        if (intervalOperand instanceof RexLiteral intervalLiteral
-            && SqlTypeName.INTERVAL_TYPES.contains(intervalLiteral.getType().getSqlTypeName())) {
-            qualifier = intervalLiteral.getType().getIntervalQualifier();
-            leadingValue = intervalLiteral.getValueAs(BigDecimal.class);
-        } else if (SqlTypeFamily.NUMERIC.contains(intervalOperand.getType()) && intervalOperand instanceof RexLiteral numericLiteral) {
-            // ADDDATE/SUBDATE integer form: ADDDATE(base, N) is treated as INTERVAL N DAY.
-            qualifier = new SqlIntervalQualifier(TimeUnit.DAY, null, SqlParserPos.ZERO);
-            leadingValue = numericLiteral.getValueAs(BigDecimal.class);
-        } else {
+        RexNode rawSecond = stripOperatorAnnotation(original.getOperands().get(1));
+        // ADDDATE/SUBDATE accept INTEGER days; rebuild as INTERVAL n DAY so the interval path runs.
+        RexLiteral intervalLiteral = asIntervalLiteral(rawSecond, rexBuilder);
+        if (intervalLiteral == null) {
             return original;
         }
+        SqlIntervalQualifier qualifier = intervalLiteral.getType().getIntervalQualifier();
+        BigDecimal leadingValue = intervalLiteral.getValueAs(BigDecimal.class);
         if (qualifier == null || leadingValue == null) {
             return original;
         }
@@ -194,4 +192,25 @@ private static RexNode stripOperatorAnnotation(RexNode node) {
         }
         return node;
     }
+
+    /**
+     * Returns {@code node} when it's already an interval literal; for an integer literal returns a
+     * synthetic {@code INTERVAL n DAY} literal (the ADDDATE/SUBDATE integer-days form). Anything
+     * else returns null so the caller can pass the call through to the UDF path.
+     */
+    private static RexLiteral asIntervalLiteral(RexNode node, RexBuilder rexBuilder) {
+        if (node instanceof RexLiteral lit) {
+            if (SqlTypeName.INTERVAL_TYPES.contains(lit.getType().getSqlTypeName())) {
+                return lit;
+            }
+            if (SqlTypeName.INT_TYPES.contains(lit.getType().getSqlTypeName())) {
+                BigDecimal days = lit.getValueAs(BigDecimal.class);
+                if (days == null) {
+                    return null;
+                }
+                return rexBuilder.makeIntervalLiteral(days, new SqlIntervalQualifier(TimeUnit.DAY, null, SqlParserPos.ZERO));
+            }
+        }
+        return null;
+    }
 }

sandbox/plugins/analytics-backend-datafusion/src/test/java/org/opensearch/be/datafusion/DateAddSubAdapterTests.java

@@ -31,7 +31,7 @@
 import java.math.BigDecimal;
 import java.util.List;
 
-/** Covers {@link DateAddSubAdapter}: TIME base anchors to today UTC before DATETIME_PLUS. */
+/** Covers {@link DateAddSubAdapter}: TIME base anchors to today UTC; integer-days form rebuilds as INTERVAL DAY. */
 public class DateAddSubAdapterTests extends OpenSearchTestCase {
 
     private final RelDataTypeFactory typeFactory = new JavaTypeFactoryImpl();
@@ -47,6 +47,24 @@ public class DateAddSubAdapterTests extends OpenSearchTestCase {
         SqlFunctionCategory.TIMEDATE
     );
 
+    private static final SqlFunction ADDDATE_OP = new SqlFunction(
+        "ADDDATE",
+        SqlKind.OTHER_FUNCTION,
+        ReturnTypes.TIMESTAMP,
+        null,
+        OperandTypes.VARIADIC,
+        SqlFunctionCategory.TIMEDATE
+    );
+
+    private static final SqlFunction SUBDATE_OP = new SqlFunction(
+        "SUBDATE",
+        SqlKind.OTHER_FUNCTION,
+        ReturnTypes.TIMESTAMP,
+        null,
+        OperandTypes.VARIADIC,
+        SqlFunctionCategory.TIMEDATE
+    );
+
     /** DATE_ADD(TIME-col, INTERVAL 1 DAY) → DATETIME_PLUS(CAST(CONCAT(today,' ',CAST time AS VARCHAR)) AS TIMESTAMP), 86400000 millis). */
     public void testDateAddTimeOperandAnchoredToToday() {
         RelDataType timeType = typeFactory.createSqlType(SqlTypeName.TIME);
@@ -70,4 +88,43 @@ public void testDateAddTimeOperandAnchoredToToday() {
         RexCall concat = (RexCall) castNode.getOperands().get(0);
         assertEquals("||", concat.getOperator().getName());
     }
+
+    /** ADDDATE(DATE-col, 1) → DATETIME_PLUS(CAST(date AS …), INTERVAL 1 DAY). The integer 1 is rebuilt as a DAY interval. */
+    public void testAddDateIntegerDaysOnDateRebuiltAsIntervalDay() {
+        RelDataType dateType = typeFactory.createSqlType(SqlTypeName.DATE);
+        RexNode dateCol = rexBuilder.makeInputRef(dateType, 0);
+        RexNode oneInt = rexBuilder.makeLiteral(1, typeFactory.createSqlType(SqlTypeName.INTEGER), false);
+        RexCall original = (RexCall) rexBuilder.makeCall(ADDDATE_OP, List.of(dateCol, oneInt));
+
+        RexNode adapted = new DateAddSubAdapter(true).adapt(original, List.of(), cluster);
+
+        RexCall outer = adapted instanceof RexCall && ((RexCall) adapted).getKind() == SqlKind.CAST
+            ? (RexCall) ((RexCall) adapted).getOperands().get(0)
+            : (RexCall) adapted;
+        assertSame(SqlStdOperatorTable.DATETIME_PLUS, outer.getOperator());
+        RexNode shiftedInterval = outer.getOperands().get(1);
+        assertTrue(SqlTypeName.INTERVAL_TYPES.contains(shiftedInterval.getType().getSqlTypeName()));
+        assertEquals(TimeUnit.DAY, shiftedInterval.getType().getIntervalQualifier().getUnit());
+        // INTERVAL DAY values are stored in millis after the unit-rebuild step; +1 day = +86400000.
+        long signed = ((org.apache.calcite.rex.RexLiteral) shiftedInterval).getValueAs(Long.class);
+        assertEquals(86_400_000L, signed);
+    }
+
+    /** SUBDATE(TIMESTAMP-col, 5) → DATETIME_PLUS(ts, INTERVAL -5 DAY). Sign folded for SUB. */
+    public void testSubDateIntegerDaysFoldsSign() {
+        RelDataType tsType = typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
+        RexNode tsCol = rexBuilder.makeInputRef(tsType, 0);
+        RexNode fiveInt = rexBuilder.makeLiteral(5, typeFactory.createSqlType(SqlTypeName.INTEGER), false);
+        RexCall original = (RexCall) rexBuilder.makeCall(SUBDATE_OP, List.of(tsCol, fiveInt));
+
+        RexNode adapted = new DateAddSubAdapter(false).adapt(original, List.of(), cluster);
+
+        RexCall outer = adapted instanceof RexCall && ((RexCall) adapted).getKind() == SqlKind.CAST
+            ? (RexCall) ((RexCall) adapted).getOperands().get(0)
+            : (RexCall) adapted;
+        assertSame(SqlStdOperatorTable.DATETIME_PLUS, outer.getOperator());
+        long signed = ((org.apache.calcite.rex.RexLiteral) outer.getOperands().get(1)).getValueAs(Long.class);
+        // 5 days in millis, negated for SUB.
+        assertEquals(-5L * 86_400_000L, signed);
+    }
 }

sandbox/qa/analytics-engine-rest/src/test/java/org/opensearch/analytics/qa/DatetimeCoverageIT.java

@@ -181,6 +181,38 @@ public void testClusterB_dateSubOnTime() throws IOException {
         assertEquals("date_sub(time, -30min) wall time must be 08:30:00", "08:30:00", firstRowFirstCell(response));
     }
 
+    /** Cluster B: ADDDATE(DATE, integer days) lowers via DateAddSubAdapter integer-days form. */
+    public void testClusterB_addDateIntegerDaysOnDate() throws IOException {
+        assertFirstRowString(
+            oneRow() + "| eval f = adddate(date('2020-08-26'), 1) | fields f",
+            "2020-08-27"
+        );
+    }
+
+    /** Cluster B: SUBDATE(DATE, integer days) — sign folded by adapter. */
+    public void testClusterB_subDateIntegerDaysOnDate() throws IOException {
+        assertFirstRowString(
+            oneRow() + "| eval f = subdate(date('2020-08-26'), 1) | fields f",
+            "2020-08-25"
+        );
+    }
+
+    /** Cluster B: ADDDATE(TIMESTAMP, integer days) — promotes to TIMESTAMP wall time. */
+    public void testClusterB_addDateIntegerDaysOnTimestamp() throws IOException {
+        assertFirstRowString(
+            oneRow() + "| eval f = adddate(timestamp('2020-09-16 17:30:00'), 1) | fields f",
+            "2020-09-17 17:30:00"
+        );
+    }
+
+    /** Cluster B: ADDDATE(DATE, INTERVAL n DAY) — interval form sharing the DATE_ADD path. */
+    public void testClusterB_addDateIntervalOnDate() throws IOException {
+        assertFirstRowString(
+            oneRow() + "| eval f = adddate(date('2020-08-26'), interval 3 day) | fields f",
+            "2020-08-29 00:00:00"
+        );
+    }
+
     /** Cluster B: TIMESTAMPADD standalone string-overload resolves. */
     public void testClusterB_timestampAddStandalone() throws IOException {
         assertFirstRowString(