Extract IntervalUtils from DateTimeUtils

h2/src/main/org/h2/api/Interval.java

@@ -9,7 +9,7 @@ import static org.h2.util.DateTimeUtils.NANOS_PER_MINUTE;
 import static org.h2.util.DateTimeUtils.NANOS_PER_SECOND;
 
 import org.h2.message.DbException;
-import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 
 /**
  * INTERVAL representation for result sets.
@@ -471,7 +471,7 @@ public final class Interval {
     public Interval(IntervalQualifier qualifier, boolean negative, long leading, long remaining) {
         this.qualifier = qualifier;
         try {
-            this.negative = DateTimeUtils.validateInterval(qualifier, negative, leading, remaining);
+            this.negative = IntervalUtils.validateInterval(qualifier, negative, leading, remaining);
         } catch (DbException e) {
             throw new IllegalArgumentException();
         }
@@ -523,7 +523,7 @@ public final class Interval {
      * @return years, or 0
      */
     public long getYears() {
-        return DateTimeUtils.yearsFromInterval(qualifier, negative, leading, remaining);
+        return IntervalUtils.yearsFromInterval(qualifier, negative, leading, remaining);
     }
 
     /**
@@ -532,7 +532,7 @@ public final class Interval {
      * @return months, or 0
      */
     public long getMonths() {
-        return DateTimeUtils.monthsFromInterval(qualifier, negative, leading, remaining);
+        return IntervalUtils.monthsFromInterval(qualifier, negative, leading, remaining);
     }
 
     /**
@@ -541,7 +541,7 @@ public final class Interval {
      * @return days, or 0
      */
     public long getDays() {
-        return DateTimeUtils.daysFromInterval(qualifier, negative, leading, remaining);
+        return IntervalUtils.daysFromInterval(qualifier, negative, leading, remaining);
     }
 
     /**
@@ -550,7 +550,7 @@ public final class Interval {
      * @return hours, or 0
      */
     public long getHours() {
-        return DateTimeUtils.hoursFromInterval(qualifier, negative, leading, remaining);
+        return IntervalUtils.hoursFromInterval(qualifier, negative, leading, remaining);
     }
 
     /**
@@ -559,7 +559,7 @@ public final class Interval {
      * @return minutes, or 0
      */
     public long getMinutes() {
-        return DateTimeUtils.minutesFromInterval(qualifier, negative, leading, remaining);
+        return IntervalUtils.minutesFromInterval(qualifier, negative, leading, remaining);
     }
 
     /**
@@ -599,7 +599,7 @@ public final class Interval {
      * @return nanoseconds (including seconds), or 0
      */
     public long getSecondsAndNanos() {
-        return DateTimeUtils.nanosFromInterval(qualifier, negative, leading, remaining);
+        return IntervalUtils.nanosFromInterval(qualifier, negative, leading, remaining);
     }
 
     @Override
@@ -628,7 +628,7 @@ public final class Interval {
 
     @Override
     public String toString() {
-        return DateTimeUtils.intervalToString(qualifier, negative, leading, remaining);
+        return IntervalUtils.intervalToString(qualifier, negative, leading, remaining);
     }
 
 }

h2/src/main/org/h2/command/Parser.java

@@ -190,6 +190,7 @@ import org.h2.table.TableFilter.TableFilterVisitor;
 import org.h2.table.TableView;
 import org.h2.util.DateTimeFunctions;
 import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 import org.h2.util.MathUtils;
 import org.h2.util.ParserUtil;
 import org.h2.util.StatementBuilder;
@@ -3691,7 +3692,7 @@ public class Parser {
             qualifier = IntervalQualifier.SECOND;
         }
         try {
-            return ValueExpression.get(DateTimeUtils.parseInterval(qualifier, negative, s));
+            return ValueExpression.get(IntervalUtils.parseInterval(qualifier, negative, s));
         } catch (Exception e) {
             throw DbException.get(ErrorCode.INVALID_DATETIME_CONSTANT_2, e, "INTERVAL", s);
         }

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

@@ -23,6 +23,7 @@ import org.h2.table.IndexColumn;
 import org.h2.table.Table;
 import org.h2.table.TableFilter;
 import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 import org.h2.value.CompareMode;
 import org.h2.value.Value;
 import org.h2.value.ValueDate;
@@ -261,9 +262,9 @@ class AggregateDataMedian extends AggregateDataCollecting {
         case Value.INTERVAL_HOUR_TO_MINUTE:
         case Value.INTERVAL_HOUR_TO_SECOND:
         case Value.INTERVAL_MINUTE_TO_SECOND:
-            return DateTimeUtils.intervalFromAbsolute(IntervalQualifier.valueOf(dataType - Value.INTERVAL_YEAR),
-                    DateTimeUtils.intervalToAbsolute((ValueInterval) v0)
-                    .add(DateTimeUtils.intervalToAbsolute((ValueInterval) v1)).shiftRight(1));
+            return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(dataType - Value.INTERVAL_YEAR),
+                    IntervalUtils.intervalToAbsolute((ValueInterval) v0)
+                    .add(IntervalUtils.intervalToAbsolute((ValueInterval) v1)).shiftRight(1));
         default:
             // Just return first
             return v0.convertTo(dataType);

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

@@ -16,6 +16,7 @@ import org.h2.table.ColumnResolver;
 import org.h2.table.TableFilter;
 import org.h2.util.DateTimeFunctions;
 import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 import org.h2.value.DataType;
 import org.h2.value.Value;
 import org.h2.value.ValueDate;
@@ -131,9 +132,9 @@ public class IntervalOperation extends Expression {
         switch (opType) {
         case INTERVAL_PLUS_INTERVAL:
         case INTERVAL_MINUS_INTERVAL: {
-            BigInteger a1 = DateTimeUtils.intervalToAbsolute((ValueInterval) l);
-            BigInteger a2 = DateTimeUtils.intervalToAbsolute((ValueInterval) r);
-            return DateTimeUtils.intervalFromAbsolute(
+            BigInteger a1 = IntervalUtils.intervalToAbsolute((ValueInterval) l);
+            BigInteger a2 = IntervalUtils.intervalToAbsolute((ValueInterval) r);
+            return IntervalUtils.intervalFromAbsolute(
                     IntervalQualifier.valueOf(Value.getHigherOrder(lType, rType) - Value.INTERVAL_YEAR),
                     opType == IntervalOpType.INTERVAL_PLUS_INTERVAL ? a1.add(a2) : a1.subtract(a2));
         }
@@ -142,9 +143,9 @@ public class IntervalOperation extends Expression {
             return getDateTimeWithInterval(l, r, lType, rType);
         case INTERVAL_MULTIPLY_NUMERIC:
         case INTERVAL_DIVIDE_NUMERIC: {
-            BigDecimal a1 = new BigDecimal(DateTimeUtils.intervalToAbsolute((ValueInterval) l));
+            BigDecimal a1 = new BigDecimal(IntervalUtils.intervalToAbsolute((ValueInterval) l));
             BigDecimal a2 = r.getBigDecimal();
-            return DateTimeUtils.intervalFromAbsolute(IntervalQualifier.valueOf(lType - Value.INTERVAL_YEAR),
+            return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(lType - Value.INTERVAL_YEAR),
                     (opType == IntervalOpType.INTERVAL_MULTIPLY_NUMERIC ? a1.multiply(a2) : a1.divide(a2))
                             .toBigInteger());
         }
@@ -179,7 +180,7 @@ public class IntervalOperation extends Expression {
                     diff = diff.add(BigInteger.valueOf((((ValueTimestampTimeZone) r).getTimeZoneOffsetMins()
                             - ((ValueTimestampTimeZone) l).getTimeZoneOffsetMins()) * 60_000_000_000L));
                 }
-                return DateTimeUtils.intervalFromAbsolute(IntervalQualifier.DAY_TO_SECOND, diff);
+                return IntervalUtils.intervalFromAbsolute(IntervalQualifier.DAY_TO_SECOND, diff);
             }
         }
         throw DbException.throwInternalError("type=" + opType);
@@ -192,7 +193,7 @@ public class IntervalOperation extends Expression {
                 throw DbException.throwInternalError("type=" + rType);
             }
             BigInteger a1 = BigInteger.valueOf(((ValueTime) l).getNanos());
-            BigInteger a2 = DateTimeUtils.intervalToAbsolute((ValueInterval) r);
+            BigInteger a2 = IntervalUtils.intervalToAbsolute((ValueInterval) r);
             BigInteger n = opType == IntervalOpType.DATETIME_PLUS_INTERVAL ? a1.add(a2) : a1.subtract(a2);
             if (n.signum() < 0 || n.compareTo(BigInteger.valueOf(DateTimeUtils.NANOS_PER_DAY)) >= 0) {
                 throw DbException.get(ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_1, n.toString());
@@ -203,13 +204,13 @@ public class IntervalOperation extends Expression {
         case Value.TIMESTAMP:
         case Value.TIMESTAMP_TZ:
             if (DataType.isYearMonthIntervalType(rType)) {
-                long m = DateTimeUtils.intervalToAbsolute((ValueInterval) r).longValue();
+                long m = IntervalUtils.intervalToAbsolute((ValueInterval) r).longValue();
                 if (opType == IntervalOpType.DATETIME_MINUS_INTERVAL) {
                     m = -m;
                 }
                 return DateTimeFunctions.dateadd("MONTH", m, l);
             } else {
-                BigInteger a2 = DateTimeUtils.intervalToAbsolute((ValueInterval) r);
+                BigInteger a2 = IntervalUtils.intervalToAbsolute((ValueInterval) r);
                 if (lType == Value.DATE) {
                     BigInteger a1 = BigInteger
                             .valueOf(DateTimeUtils.absoluteDayFromDateValue(((ValueDate) l).getDateValue()));

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

@@ -355,7 +355,7 @@ public final class DateTimeFunctions {
                         bd = bd.negate();
                     }
                 } else {
-                    bd = new BigDecimal(DateTimeUtils.intervalToAbsolute(interval))
+                    bd = new BigDecimal(IntervalUtils.intervalToAbsolute(interval))
                             .divide(BigDecimal.valueOf(NANOS_PER_SECOND));
                 }
                 return ValueDecimal.get(bd);
@@ -634,33 +634,33 @@ public final class DateTimeFunctions {
             long v;
             switch (field) {
             case YEAR:
-                v = DateTimeUtils.yearsFromInterval(qualifier, negative, leading, remaining);
+                v = IntervalUtils.yearsFromInterval(qualifier, negative, leading, remaining);
                 break;
             case MONTH:
-                v = DateTimeUtils.monthsFromInterval(qualifier, negative, leading, remaining);
+                v = IntervalUtils.monthsFromInterval(qualifier, negative, leading, remaining);
                 break;
             case DAY_OF_MONTH:
             case DAY_OF_WEEK:
             case DAY_OF_YEAR:
-                v = DateTimeUtils.daysFromInterval(qualifier, negative, leading, remaining);
+                v = IntervalUtils.daysFromInterval(qualifier, negative, leading, remaining);
                 break;
             case HOUR:
-                v = DateTimeUtils.hoursFromInterval(qualifier, negative, leading, remaining);
+                v = IntervalUtils.hoursFromInterval(qualifier, negative, leading, remaining);
                 break;
             case MINUTE:
-                v = DateTimeUtils.minutesFromInterval(qualifier, negative, leading, remaining);
+                v = IntervalUtils.minutesFromInterval(qualifier, negative, leading, remaining);
                 break;
             case SECOND:
-                v = DateTimeUtils.nanosFromInterval(qualifier, negative, leading, remaining) / NANOS_PER_SECOND;
+                v = IntervalUtils.nanosFromInterval(qualifier, negative, leading, remaining) / NANOS_PER_SECOND;
                 break;
             case MILLISECOND:
-                v = DateTimeUtils.nanosFromInterval(qualifier, negative, leading, remaining) / 1_000_000 % 1_000;
+                v = IntervalUtils.nanosFromInterval(qualifier, negative, leading, remaining) / 1_000_000 % 1_000;
                 break;
             case MICROSECOND:
-                v = DateTimeUtils.nanosFromInterval(qualifier, negative, leading, remaining) / 1_000 % 1_000_000;
+                v = IntervalUtils.nanosFromInterval(qualifier, negative, leading, remaining) / 1_000 % 1_000_000;
                 break;
             case NANOSECOND:
-                v = DateTimeUtils.nanosFromInterval(qualifier, negative, leading, remaining) % NANOS_PER_SECOND;
+                v = IntervalUtils.nanosFromInterval(qualifier, negative, leading, remaining) % NANOS_PER_SECOND;
                 break;
             default:
                 throw DbException.getUnsupportedException("getDatePart(" + date + ", " + field + ')');

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

@@ -397,7 +397,7 @@ public class LocalDateTimeUtils {
         if (DataType.isYearMonthIntervalType(value.getType())) {
             throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, (Throwable) null, value.getString());
         }
-        BigInteger[] dr = DateTimeUtils.intervalToAbsolute((ValueInterval) value)
+        BigInteger[] dr = IntervalUtils.intervalToAbsolute((ValueInterval) value)
                 .divideAndRemainder(BigInteger.valueOf(1_000_000_000));
         try {
             return DURATION_OF_SECONDS.invoke(null, dr[0].longValue(), dr[1].longValue());

h2/src/main/org/h2/value/Value.java

@@ -28,6 +28,7 @@ import org.h2.store.DataHandler;
 import org.h2.tools.SimpleResultSet;
 import org.h2.util.Bits;
 import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 import org.h2.util.JdbcUtils;
 import org.h2.util.MathUtils;
 import org.h2.util.StringUtils;
@@ -1234,7 +1235,7 @@ public abstract class Value {
         case Value.STRING_FIXED: {
             String s = getString();
             try {
-                return (ValueInterval) DateTimeUtils
+                return (ValueInterval) IntervalUtils
                         .parseFormattedInterval(IntervalQualifier.valueOf(targetType - Value.INTERVAL_YEAR), s)
                         .convertTo(targetType);
             } catch (Exception e) {
@@ -1244,8 +1245,8 @@ public abstract class Value {
         case Value.INTERVAL_YEAR:
         case Value.INTERVAL_MONTH:
         case Value.INTERVAL_YEAR_TO_MONTH:
-            return DateTimeUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - Value.INTERVAL_YEAR),
-                    DateTimeUtils.intervalToAbsolute((ValueInterval) this));
+            return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - Value.INTERVAL_YEAR),
+                    IntervalUtils.intervalToAbsolute((ValueInterval) this));
         }
         throw getDataConversionError(targetType);
     }
@@ -1257,7 +1258,7 @@ public abstract class Value {
         case Value.STRING_FIXED: {
             String s = getString();
             try {
-                return (ValueInterval) DateTimeUtils
+                return (ValueInterval) IntervalUtils
                         .parseFormattedInterval(IntervalQualifier.valueOf(targetType - Value.INTERVAL_YEAR), s)
                         .convertTo(targetType);
             } catch (Exception e) {
@@ -1274,8 +1275,8 @@ public abstract class Value {
         case Value.INTERVAL_HOUR_TO_MINUTE:
         case Value.INTERVAL_HOUR_TO_SECOND:
         case Value.INTERVAL_MINUTE_TO_SECOND:
-            return DateTimeUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - Value.INTERVAL_YEAR),
-                    DateTimeUtils.intervalToAbsolute((ValueInterval) this));
+            return IntervalUtils.intervalFromAbsolute(IntervalQualifier.valueOf(targetType - Value.INTERVAL_YEAR),
+                    IntervalUtils.intervalToAbsolute((ValueInterval) this));
         }
         throw getDataConversionError(targetType);
     }

h2/src/main/org/h2/value/ValueInterval.java

@@ -12,6 +12,7 @@ import org.h2.api.Interval;
 import org.h2.api.IntervalQualifier;
 import org.h2.message.DbException;
 import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 
 /**
  * Implementation of the INTERVAL data type.
@@ -58,7 +59,7 @@ public class ValueInterval extends Value {
      * @return interval value
      */
     public static ValueInterval from(IntervalQualifier qualifier, boolean negative, long leading, long remaining) {
-        negative = DateTimeUtils.validateInterval(qualifier, negative, leading, remaining);
+        negative = IntervalUtils.validateInterval(qualifier, negative, leading, remaining);
         return (ValueInterval) Value
                 .cache(new ValueInterval(qualifier.ordinal() + INTERVAL_YEAR, negative, leading, remaining));
     }
@@ -203,7 +204,7 @@ public class ValueInterval extends Value {
 
     @Override
     public String getString() {
-        return DateTimeUtils.intervalToString(getQualifier(), negative, leading, remaining);
+        return IntervalUtils.intervalToString(getQualifier(), negative, leading, remaining);
     }
 
     @Override
@@ -298,14 +299,14 @@ public class ValueInterval extends Value {
 
     @Override
     public Value add(Value v) {
-        return DateTimeUtils.intervalFromAbsolute(getQualifier(),
-                DateTimeUtils.intervalToAbsolute(this).add(DateTimeUtils.intervalToAbsolute((ValueInterval) v)));
+        return IntervalUtils.intervalFromAbsolute(getQualifier(),
+                IntervalUtils.intervalToAbsolute(this).add(IntervalUtils.intervalToAbsolute((ValueInterval) v)));
     }
 
     @Override
     public Value subtract(Value v) {
-        return DateTimeUtils.intervalFromAbsolute(getQualifier(),
-                DateTimeUtils.intervalToAbsolute(this).subtract(DateTimeUtils.intervalToAbsolute((ValueInterval) v)));
+        return IntervalUtils.intervalFromAbsolute(getQualifier(),
+                IntervalUtils.intervalToAbsolute(this).subtract(IntervalUtils.intervalToAbsolute((ValueInterval) v)));
     }
 
     @Override

h2/src/test/org/h2/test/unit/TestDateTimeUtils.java

@@ -15,11 +15,12 @@ import java.util.TimeZone;
 import org.h2.api.IntervalQualifier;
 import org.h2.test.TestBase;
 import org.h2.util.DateTimeUtils;
+import org.h2.util.IntervalUtils;
 import org.h2.value.ValueInterval;
 import org.h2.value.ValueTimestamp;
 
 /**
- * Unit tests for the DateTimeUtils class
+ * Unit tests for the DateTimeUtils and IntervalUtils classes.
  */
 public class TestDateTimeUtils extends TestBase {
 
@@ -257,7 +258,7 @@ public class TestDateTimeUtils extends TestBase {
     private void testParseIntervalImpl(IntervalQualifier qualifier, boolean negative, long leading, long remaining,
             String s, String full) {
         ValueInterval expected = ValueInterval.from(qualifier, negative, leading, remaining);
-        assertEquals(expected, DateTimeUtils.parseInterval(qualifier, negative, s));
+        assertEquals(expected, IntervalUtils.parseInterval(qualifier, negative, s));
         StringBuilder b = new StringBuilder();
         b.append("INTERVAL ").append('\'');
         if (negative) {