Reimplement DATEADD without a Calendar and correct its return type

h2/src/main/org/h2/expression/Function.java

@@ -14,7 +14,6 @@ import java.nio.charset.StandardCharsets;
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.sql.Timestamp;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Calendar;
@@ -1485,8 +1484,7 @@ public class Function extends Expression implements FunctionCall {
                     database.getMode().treatEmptyStringsAsNull);
             break;
         case DATE_ADD:
-            result = ValueTimestamp.get(dateadd(
-                    v0.getString(), v1.getLong(), v2.getTimestamp()));
+            result = dateadd(v0.getString(), v1.getLong(), v2);
             break;
         case DATE_DIFF:
             result = ValueLong.get(datediff(v0.getString(), v1, v2));
@@ -1805,53 +1803,79 @@ public class Function extends Expression implements FunctionCall {
         return p.intValue();
     }
 
-    private static Timestamp dateadd(String part, long count, Timestamp d) {
+    private static Value dateadd(String part, long count, Value v) {
         int field = getDatePart(part);
+        //v = v.convertTo(Value.TIMESTAMP);
+        if (field != MILLISECOND && count > Integer.MAX_VALUE || count < Integer.MIN_VALUE) {
+            throw DbException.getInvalidValueException("DATEADD count", count);
+        }
+        boolean withDate = !(v instanceof ValueTime), withTime = !(v instanceof ValueDate), forceTimestamp = false;
+        long[] a = DateTimeUtils.dateAndTimeFromValue(v);
+        long dateValue = a[0];
+        long timeNanos = a[1];
         switch (field) {
         case YEAR:
-            field = Calendar.YEAR;
-            break;
-        case MONTH:
-            field = Calendar.MONTH;
-            break;
+        case MONTH: {
+            if (!withDate) {
+                throw DbException.getInvalidValueException("DATEADD timestamp", v);
+            }
+            long year = DateTimeUtils.yearFromDateValue(dateValue);
+            long month = DateTimeUtils.monthFromDateValue(dateValue);
+            int day = DateTimeUtils.dayFromDateValue(dateValue);
+            if (field == YEAR) {
+                year += count;
+            } else {
+                month += count;
+            }
+            dateValue = DateTimeUtils.dateValueFromDenormalizedDate(year, month, day);
+            return DateTimeUtils.dateTimeToValue(v, dateValue, timeNanos, forceTimestamp);
+        }
+        case WEEK:
+        case ISO_WEEK:
+            count *= 7;
+            //$FALL-THROUGH$
+        case DAY_OF_WEEK:
         case DAY_OF_MONTH:
-            field = Calendar.DAY_OF_MONTH;
-            break;
         case DAY_OF_YEAR:
-            field = Calendar.DAY_OF_YEAR;
-            break;
-        case WEEK:
-            field = Calendar.WEEK_OF_YEAR;
-            break;
+            if (!withDate) {
+                throw DbException.getInvalidValueException("DATEADD timestamp", v);
+            }
+            dateValue = DateTimeUtils.dateValueFromAbsoluteDay(
+                    DateTimeUtils.absoluteDayFromDateValue(dateValue) + count);
+            return DateTimeUtils.dateTimeToValue(v, dateValue, timeNanos, forceTimestamp);
         case HOUR:
-            field = Calendar.HOUR_OF_DAY;
+            count *= 3_600_000_000_000L;
             break;
         case MINUTE:
-            field = Calendar.MINUTE;
+            count *= 60_000_000_000L;
             break;
         case SECOND:
-            field = Calendar.SECOND;
+            count *= 1_000_000_000;
+            break;
+        case MILLISECOND:
+            count *= 1_000_000;
             break;
-        case MILLISECOND: {
-            Timestamp ts = new Timestamp(d.getTime() + count);
-            ts.setNanos(ts.getNanos() + (d.getNanos() % 1000000));
-            return ts;
-        }
         default:
             throw DbException.getUnsupportedException("DATEADD " + part);
         }
-        // We allow long for manipulating the millisecond component,
-        // for the rest we only allow int.
-        if (count > Integer.MAX_VALUE) {
-            throw DbException.getInvalidValueException("DATEADD count", count);
+        if (!withTime) {
+            // Treat date as timestamp at the start of this date
+            forceTimestamp = true;
+        }
+        timeNanos += count;
+        if (timeNanos > DateTimeUtils.NANOS_PER_DAY || timeNanos < 0) {
+            long d;
+            if (timeNanos > DateTimeUtils.NANOS_PER_DAY) {
+                d = timeNanos / DateTimeUtils.NANOS_PER_DAY;
+            } else {
+                d = (timeNanos - DateTimeUtils.NANOS_PER_DAY + 1) / DateTimeUtils.NANOS_PER_DAY;
+            }
+            timeNanos -= d * DateTimeUtils.NANOS_PER_DAY;
+            return DateTimeUtils.dateTimeToValue(v,
+                    DateTimeUtils.dateValueFromAbsoluteDay(DateTimeUtils.absoluteDayFromDateValue(dateValue) + d),
+                    timeNanos, forceTimestamp);
         }
-        Calendar calendar = DateTimeUtils.createGregorianCalendar();
-        int nanos = d.getNanos() % 1000000;
-        calendar.setTime(d);
-        calendar.add(field, (int) count);
-        Timestamp ts = new Timestamp(calendar.getTimeInMillis());
-        ts.setNanos(ts.getNanos() + nanos);
-        return ts;
+        return DateTimeUtils.dateTimeToValue(v, dateValue, timeNanos, forceTimestamp);
     }
 
     /**

h2/src/main/org/h2/util/DateTimeUtils.java

@@ -591,6 +591,40 @@ public class DateTimeUtils {
         return new long[] {dateValue, timeNanos};
     }
 
+    /**
+     * Creates a new date-time value with the same type as original value. If
+     * original value is a ValueTimestampTimeZone, returned value will have the same
+     * time zone offset as original value.
+     *
+     * @param original
+     *            original value
+     * @param dateValue
+     *            date value for the returned value
+     * @param timeNanos
+     *            nanos of day for the returned value
+     * @param forceTimestamp
+     *            if {@code true} return ValueTimestamp if original argument is
+     *            ValueDate or ValueTime
+     * @return new value with specified date value and nanos of day
+     */
+    public static Value dateTimeToValue(Value original, long dateValue, long timeNanos, boolean forceTimestamp) {
+        if (!(original instanceof ValueTimestamp)) {
+            if (!forceTimestamp) {
+                if (original instanceof ValueDate) {
+                    return ValueDate.fromDateValue(dateValue);
+                }
+                if (original instanceof ValueTime) {
+                    return ValueTime.fromNanos(timeNanos);
+                }
+            }
+            if (original instanceof ValueTimestampTimeZone) {
+                return ValueTimestampTimeZone.fromDateValueAndNanos(dateValue, timeNanos,
+                        ((ValueTimestampTimeZone) original).getTimeZoneOffsetMins());
+            }
+        }
+        return ValueTimestamp.fromDateValueAndNanos(dateValue, timeNanos);
+    }
+
     /**
      * Get the specified field of a date, however with years normalized to
      * positive or negative, and month starting with 1.

h2/src/test/org/h2/test/scripts/functions/timeanddate/dateadd.sql

@@ -81,7 +81,7 @@ select d + t, t + d - t x from test;
 select 1 + d + 1, d - 1, 2 + ts + 2, ts - 2 from test;
 > DATEADD('DAY', 1, DATEADD('DAY', 1, D)) DATEADD('DAY', -1, D) DATEADD('DAY', 2, DATEADD('DAY', 2, TS)) DATEADD('DAY', -2, TS)
 > --------------------------------------- --------------------- ---------------------------------------- ----------------------
-> 2001-01-03 00:00:00.0                   2000-12-31 00:00:00.0 2010-01-05 00:00:00.0                    2009-12-30 00:00:00.0
+> 2001-01-03                              2000-12-31            2010-01-05 00:00:00.0                    2009-12-30 00:00:00.0
 > rows: 1
 
 select 1 + d + t + 1 from test;
@@ -104,3 +104,24 @@ call dateadd('MS', 1, TIMESTAMP '2001-02-03 04:05:06.789001');
 > --------------------------------------
 > 2001-02-03 04:05:06.790001
 > rows: 1
+
+SELECT DATEADD('HOUR', 1, DATE '2010-01-20');
+> TIMESTAMP '2010-01-20 01:00:00.0'
+> ---------------------------------
+> 2010-01-20 01:00:00.0
+> rows: 1
+
+SELECT DATEADD('MINUTE', 30, TIME '12:30:55');
+> TIME '13:00:55'
+> ---------------
+> 13:00:55
+> rows: 1
+
+SELECT DATEADD('DAY', 1, TIME '12:30:55');
+> exception
+
+SELECT DATEADD('DAY', 10, TIMESTAMP WITH TIME ZONE '2000-01-05 15:00:30.123456789-10');
+> TIMESTAMP WITH TIME ZONE '2000-01-15 15:00:30.123456789-10'
+> -----------------------------------------------------------
+> 2000-01-15 15:00:30.123456789-10
+> rows: 1

h2/src/test/org/h2/test/scripts/testScript.sql

@@ -7586,9 +7586,9 @@ SELECT * FROM TEST;
 SELECT XD+1, XD-1, XD-XD FROM TEST;
 > DATEADD('DAY', 1, XD) DATEADD('DAY', -1, XD) DATEDIFF('DAY', XD, XD)
 > --------------------- ---------------------- -----------------------
-> 0001-02-04 00:00:00.0 0001-02-02 00:00:00.0  0
-> 0004-05-07 00:00:00.0 0004-05-05 00:00:00.0  0
-> 2000-01-01 00:00:00.0 1999-12-30 00:00:00.0  0
+> 0001-02-04            0001-02-02             0
+> 0004-05-07            0004-05-05             0
+> 2000-01-01            1999-12-30             0
 > null                  null                   null
 > rows: 4