Merge pull request #1392 from katzyn/misc

Some refactoring and assorted minor optimizations

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

@@ -189,7 +189,7 @@ import org.h2.table.TableFilter;
 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 +3691,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/command/dml/Query.java

@@ -10,6 +10,7 @@ import java.util.HashSet;
 import java.util.List;
 
 import org.h2.api.ErrorCode;
+import org.h2.command.CommandInterface;
 import org.h2.command.Prepared;
 import org.h2.engine.Database;
 import org.h2.engine.Mode.ModeEnum;
@@ -39,40 +40,56 @@ import org.h2.value.ValueNull;
  */
 public abstract class Query extends Prepared {
 
+    /**
+     * The column list, including invisible expressions such as order by expressions.
+     */
+    ArrayList<Expression> expressions;
+
+    /**
+     * Array of expressions.
+     *
+     * @see #expressions
+     */
+    Expression[] expressionArray;
+
+    ArrayList<SelectOrderBy> orderList;
+
+    SortOrder sort;
+
     /**
      * The limit expression as specified in the LIMIT or TOP clause.
      */
-    protected Expression limitExpr;
+    Expression limitExpr;
 
     /**
      * Whether limit expression specifies percentage of rows.
      */
-    protected boolean fetchPercent;
+    boolean fetchPercent;
 
     /**
      * Whether tied rows should be included in result too.
      */
-    protected boolean withTies;
+    boolean withTies;
 
     /**
      * The offset expression as specified in the LIMIT .. OFFSET clause.
      */
-    protected Expression offsetExpr;
+    Expression offsetExpr;
 
     /**
      * The sample size expression as specified in the SAMPLE_SIZE clause.
      */
-    protected Expression sampleSizeExpr;
+    Expression sampleSizeExpr;
 
     /**
      * Whether the result must only contain distinct rows.
      */
-    protected boolean distinct;
+    boolean distinct;
 
     /**
      * Whether the result needs to support random access.
      */
-    protected boolean randomAccessResult;
+    boolean randomAccessResult;
 
     private boolean noCache;
     private int lastLimit;
@@ -144,7 +161,9 @@ public abstract class Query extends Prepared {
      *
      * @return the list of expressions
      */
-    public abstract ArrayList<Expression> getExpressions();
+    public ArrayList<Expression> getExpressions() {
+        return expressions;
+    }
 
     /**
      * Calculate the cost to execute this query.
@@ -178,14 +197,18 @@ public abstract class Query extends Prepared {
      *
      * @param order the order by list
      */
-    public abstract void setOrder(ArrayList<SelectOrderBy> order);
+    public void setOrder(ArrayList<SelectOrderBy> order) {
+        orderList = order;
+    }
 
     /**
      * Whether the query has an order.
      *
      * @return true if it has
      */
-    public abstract boolean hasOrder();
+    public boolean hasOrder() {
+        return orderList != null || sort != null;
+    }
 
     /**
      * Set the 'for update' flag.
@@ -600,6 +623,11 @@ public abstract class Query extends Prepared {
         return new SortOrder(session.getDatabase(), index, sortType, orderList);
     }
 
+    @Override
+    public int getType() {
+        return CommandInterface.SELECT;
+    }
+
     public void setOffset(Expression offset) {
         this.offsetExpr = offset;
     }

h2/src/main/org/h2/command/dml/Select.java

@@ -13,7 +13,6 @@ import java.util.HashSet;
 import java.util.Map;
 import org.h2.api.ErrorCode;
 import org.h2.api.Trigger;
-import org.h2.command.CommandInterface;
 import org.h2.command.Parser;
 import org.h2.engine.Constants;
 import org.h2.engine.Database;
@@ -76,12 +75,6 @@ public class Select extends Query {
     private final ArrayList<TableFilter> filters = Utils.newSmallArrayList();
     private final ArrayList<TableFilter> topFilters = Utils.newSmallArrayList();
 
-    /**
-     * The column list, including synthetic columns (columns not shown in the
-     * result).
-     */
-    ArrayList<Expression> expressions;
-    private Expression[] expressionArray;
     private Expression having;
     private Expression condition;
 
@@ -98,7 +91,6 @@ public class Select extends Query {
     private int[] distinctIndexes;
 
     private int distinctColumnCount;
-    private ArrayList<SelectOrderBy> orderList;
     private ArrayList<Expression> group;
 
     /**
@@ -136,7 +128,6 @@ public class Select extends Query {
     private boolean isQuickAggregateQuery, isDistinctQuery;
     private boolean isPrepared, checkInit;
     private boolean sortUsingIndex;
-    private SortOrder sort;
 
     /**
      * The id of the current group.
@@ -245,16 +236,6 @@ public class Select extends Query {
         return currentGroupRowId;
     }
 
-    @Override
-    public void setOrder(ArrayList<SelectOrderBy> order) {
-        orderList = order;
-    }
-
-    @Override
-    public boolean hasOrder() {
-        return orderList != null || sort != null;
-    }
-
     @Override
     public void setDistinct() {
         if (distinctExpressions != null) {
@@ -1452,11 +1433,6 @@ public class Select extends Query {
         return topTableFilter;
     }
 
-    @Override
-    public ArrayList<Expression> getExpressions() {
-        return expressions;
-    }
-
     @Override
     public void setForUpdate(boolean b) {
         this.isForUpdate = b;
@@ -1617,11 +1593,6 @@ public class Select extends Query {
         return !isForUpdate;
     }
 
-    @Override
-    public int getType() {
-        return CommandInterface.SELECT;
-    }
-
     @Override
     public boolean allowGlobalConditions() {
         return offsetExpr == null && (limitExpr == null || sort == null);

h2/src/main/org/h2/command/dml/SelectUnion.java

@@ -9,7 +9,6 @@ import java.util.ArrayList;
 import java.util.HashSet;
 
 import org.h2.api.ErrorCode;
-import org.h2.command.CommandInterface;
 import org.h2.engine.Mode;
 import org.h2.engine.Session;
 import org.h2.engine.SysProperties;
@@ -23,7 +22,6 @@ import org.h2.result.LazyResult;
 import org.h2.result.LocalResult;
 import org.h2.result.ResultInterface;
 import org.h2.result.ResultTarget;
-import org.h2.result.SortOrder;
 import org.h2.table.Column;
 import org.h2.table.ColumnResolver;
 import org.h2.table.Table;
@@ -73,10 +71,6 @@ public class SelectUnion extends Query {
      */
     final Query right;
 
-    private ArrayList<Expression> expressions;
-    private Expression[] expressionArray;
-    private ArrayList<SelectOrderBy> orderList;
-    private SortOrder sort;
     private boolean isPrepared, checkInit;
     private boolean isForUpdate;
 
@@ -110,21 +104,6 @@ public class SelectUnion extends Query {
         return right;
     }
 
-    @Override
-    public void setSQL(String sql) {
-        this.sqlStatement = sql;
-    }
-
-    @Override
-    public void setOrder(ArrayList<SelectOrderBy> order) {
-        orderList = order;
-    }
-
-    @Override
-    public boolean hasOrder() {
-        return orderList != null || sort != null;
-    }
-
     @Override
     public void setDistinctIfPossible() {
         setDistinct();
@@ -376,11 +355,6 @@ public class SelectUnion extends Query {
         return set;
     }
 
-    @Override
-    public ArrayList<Expression> getExpressions() {
-        return expressions;
-    }
-
     @Override
     public void setForUpdate(boolean forUpdate) {
         left.setForUpdate(forUpdate);
@@ -484,11 +458,6 @@ public class SelectUnion extends Query {
         right.fireBeforeSelectTriggers();
     }
 
-    @Override
-    public int getType() {
-        return CommandInterface.SELECT;
-    }
-
     @Override
     public boolean allowGlobalConditions() {
         return left.allowGlobalConditions() && right.allowGlobalConditions();

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/Function.java

@@ -2324,20 +2324,24 @@ public class Function extends Expression implements FunctionCall {
             d = displaySize;
             break;
         case TRUNCATE:
-            t = p0.getType();
-            s = p0.getScale();
-            p = p0.getPrecision();
-            d = p0.getDisplaySize();
-            if (t == Value.NULL) {
-                t = Value.INT;
-                p = ValueInt.PRECISION;
-                d = ValueInt.DISPLAY_SIZE;
+            switch (p0.getType()) {
+            case Value.STRING:
+            case Value.DATE:
+            case Value.TIMESTAMP:
+                t = Value.TIMESTAMP;
+                p = d = ValueTimestamp.DEFAULT_PRECISION;
+                s = 0;
+                break;
+            case Value.TIMESTAMP_TZ:
+                t = Value.TIMESTAMP;
+                p = d = ValueTimestampTimeZone.DEFAULT_PRECISION;
                 s = 0;
-            } else if (t == Value.TIMESTAMP) {
-                t = Value.DATE;
-                p = ValueDate.PRECISION;
+                break;
+            default:
+                t = Value.DOUBLE;
                 s = 0;
-                d = ValueDate.PRECISION;
+                p = ValueDouble.PRECISION;
+                d = ValueDouble.DISPLAY_SIZE;
             }
             break;
         case ABS:

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

@@ -5,6 +5,8 @@
  */
 package org.h2.expression;
 
+import static org.h2.util.IntervalUtils.NANOS_PER_DAY_BI;
+
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
@@ -16,6 +18,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 +134,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 +145,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());
         }
@@ -168,9 +171,9 @@ public class IntervalOperation extends Expression {
             } else {
                 long[] a = DateTimeUtils.dateAndTimeFromValue(l);
                 long[] b = DateTimeUtils.dateAndTimeFromValue(r);
-                BigInteger bi1 = BigInteger.valueOf(a[0]).multiply(BigInteger.valueOf(DateTimeUtils.NANOS_PER_DAY))
+                BigInteger bi1 = BigInteger.valueOf(a[0]).multiply(NANOS_PER_DAY_BI)
                         .add(BigInteger.valueOf(a[1]));
-                BigInteger bi2 = BigInteger.valueOf(b[0]).multiply(BigInteger.valueOf(DateTimeUtils.NANOS_PER_DAY))
+                BigInteger bi2 = BigInteger.valueOf(b[0]).multiply(NANOS_PER_DAY_BI)
                         .add(BigInteger.valueOf(b[1]));
                 BigInteger diff = bi1.subtract(bi2);
                 if (lType == Value.TIMESTAMP_TZ || rType == Value.TIMESTAMP_TZ) {
@@ -179,7 +182,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,9 +195,9 @@ 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) {
+            if (n.signum() < 0 || n.compareTo(NANOS_PER_DAY_BI) >= 0) {
                 throw DbException.get(ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_1, n.toString());
             }
             return ValueTime.fromNanos(n.longValue());
@@ -203,24 +206,24 @@ 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()));
-                    a2 = a2.divide(BigInteger.valueOf(DateTimeUtils.NANOS_PER_DAY));
+                    a2 = a2.divide(NANOS_PER_DAY_BI);
                     BigInteger n = opType == IntervalOpType.DATETIME_PLUS_INTERVAL ? a1.add(a2) : a1.subtract(a2);
                     return ValueDate.fromDateValue(DateTimeUtils.dateValueFromAbsoluteDay(n.longValue()));
                 } else {
                     long[] a = DateTimeUtils.dateAndTimeFromValue(l);
                     long absoluteDay = DateTimeUtils.absoluteDayFromDateValue(a[0]);
                     long timeNanos = a[1];
-                    BigInteger[] dr = a2.divideAndRemainder(BigInteger.valueOf(DateTimeUtils.NANOS_PER_DAY));
+                    BigInteger[] dr = a2.divideAndRemainder(NANOS_PER_DAY_BI);
                     if (opType == IntervalOpType.DATETIME_PLUS_INTERVAL) {
                         absoluteDay += dr[0].longValue();
                         timeNanos += dr[1].longValue();

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

@@ -85,8 +85,8 @@ public class Parameter extends Expression implements ParameterInterface {
     @Override
     public Expression optimize(Session session) {
         if (session.getDatabase().getMode().treatEmptyStringsAsNull) {
-            if (value instanceof ValueString) {
-                value = ValueString.get(value.getString(), true);
+            if (value instanceof ValueString && value.getString().isEmpty()) {
+                value = ValueNull.INSTANCE;
             }
         }
         return this;

h2/src/main/org/h2/mvstore/db/ValueDataType.java

@@ -589,13 +589,13 @@ public class ValueDataType implements DataType {
                     ordinal < 5 ? 0 : readVarLong(buff));
         }
         case FLOAT_0_1:
-            return ValueFloat.get(0);
+            return ValueFloat.ZERO;
         case FLOAT_0_1 + 1:
-            return ValueFloat.get(1);
+            return ValueFloat.ONE;
         case DOUBLE_0_1:
-            return ValueDouble.get(0);
+            return ValueDouble.ZERO;
         case DOUBLE_0_1 + 1:
-            return ValueDouble.get(1);
+            return ValueDouble.ONE;
         case Value.DOUBLE:
             return ValueDouble.get(Double.longBitsToDouble(
                     Long.reverse(readVarLong(buff))));

h2/src/main/org/h2/schema/Sequence.java

@@ -5,7 +5,6 @@
  */
 package org.h2.schema;
 
-import java.math.BigInteger;
 import org.h2.api.ErrorCode;
 import org.h2.engine.DbObject;
 import org.h2.engine.Session;
@@ -139,17 +138,14 @@ public class Sequence extends SchemaObjectBase {
      * @param maxValue the prospective max value
      * @param increment the prospective increment
      */
-    private static boolean isValid(long value, long minValue, long maxValue,
-            long increment) {
+    private static boolean isValid(long value, long minValue, long maxValue, long increment) {
         return minValue <= value &&
             maxValue >= value &&
             maxValue > minValue &&
             increment != 0 &&
-            // Math.abs(increment) < maxValue - minValue
-            // use BigInteger to avoid overflows when maxValue and minValue
-            // are really big
-            BigInteger.valueOf(increment).abs().compareTo(
-                    BigInteger.valueOf(maxValue).subtract(BigInteger.valueOf(minValue))) < 0;
+            // Math.abs(increment) <= maxValue - minValue
+            // Can use Long.compareUnsigned() on Java 8
+            Math.abs(increment) + Long.MIN_VALUE <= maxValue - minValue + Long.MIN_VALUE;
     }
 
     private static long getDefaultMinValue(Long startValue, long increment) {

h2/src/main/org/h2/store/Data.java

@@ -809,13 +809,13 @@ public class Data {
         case Value.STRING_FIXED:
             return ValueStringFixed.get(readString());
         case FLOAT_0_1:
-            return ValueFloat.get(0);
+            return ValueFloat.ZERO;
         case FLOAT_0_1 + 1:
-            return ValueFloat.get(1);
+            return ValueFloat.ONE;
         case DOUBLE_0_1:
-            return ValueDouble.get(0);
+            return ValueDouble.ZERO;
         case DOUBLE_0_1 + 1:
-            return ValueDouble.get(1);
+            return ValueDouble.ONE;
         case Value.DOUBLE:
             return ValueDouble.get(Double.longBitsToDouble(
                     Long.reverse(readVarLong())));

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;
@@ -963,7 +964,7 @@ public abstract class Value {
     private ValueDouble convertToDouble() {
         switch (getType()) {
         case BOOLEAN:
-            return ValueDouble.get(getBoolean() ? 1 : 0);
+            return getBoolean() ? ValueDouble.ONE : ValueDouble.ZERO;
         case BYTE:
         case SHORT:
         case INT:
@@ -984,7 +985,7 @@ public abstract class Value {
     private ValueFloat convertToFloat() {
         switch (getType()) {
         case BOOLEAN:
-            return ValueFloat.get(getBoolean() ? 1 : 0);
+            return getBoolean() ? ValueFloat.ONE : ValueFloat.ZERO;
         case BYTE:
         case SHORT:
         case INT:
@@ -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/ValueDouble.java

@@ -28,12 +28,20 @@ public class ValueDouble extends Value {
     public static final int DISPLAY_SIZE = 24;
 
     /**
-     * Double.doubleToLongBits(0.0)
+     * Double.doubleToLongBits(0d)
      */
-    public static final long ZERO_BITS = Double.doubleToLongBits(0.0);
+    public static final long ZERO_BITS = 0L;
+
+    /**
+     * The value 0.
+     */
+    public static final ValueDouble ZERO = new ValueDouble(0d);
+
+    /**
+     * The value 1.
+     */
+    public static final ValueDouble ONE = new ValueDouble(1d);
 
-    private static final ValueDouble ZERO = new ValueDouble(0.0);
-    private static final ValueDouble ONE = new ValueDouble(1.0);
     private static final ValueDouble NAN = new ValueDouble(Double.NaN);
 
     private final double value;
@@ -45,24 +53,24 @@ public class ValueDouble extends Value {
     @Override
     public Value add(Value v) {
         ValueDouble v2 = (ValueDouble) v;
-        return ValueDouble.get(value + v2.value);
+        return get(value + v2.value);
     }
 
     @Override
     public Value subtract(Value v) {
         ValueDouble v2 = (ValueDouble) v;
-        return ValueDouble.get(value - v2.value);
+        return get(value - v2.value);
     }
 
     @Override
     public Value negate() {
-        return ValueDouble.get(-value);
+        return get(-value);
     }
 
     @Override
     public Value multiply(Value v) {
         ValueDouble v2 = (ValueDouble) v;
-        return ValueDouble.get(value * v2.value);
+        return get(value * v2.value);
     }
 
     @Override
@@ -71,7 +79,7 @@ public class ValueDouble extends Value {
         if (v2.value == 0.0) {
             throw DbException.get(ErrorCode.DIVISION_BY_ZERO_1, getSQL());
         }
-        return ValueDouble.get(value / v2.value);
+        return get(value / v2.value);
     }
 
     @Override
@@ -80,7 +88,7 @@ public class ValueDouble extends Value {
         if (other.value == 0) {
             throw DbException.get(ErrorCode.DIVISION_BY_ZERO_1, getSQL());
         }
-        return ValueDouble.get(value % other.value);
+        return get(value % other.value);
     }
 
     @Override

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

@@ -16,11 +16,6 @@ import org.h2.message.DbException;
  */
 public class ValueFloat extends Value {
 
-    /**
-     * Float.floatToIntBits(0.0F).
-     */
-    public static final int ZERO_BITS = Float.floatToIntBits(0.0F);
-
     /**
      * The precision in digits.
      */
@@ -32,8 +27,21 @@ public class ValueFloat extends Value {
      */
     static final int DISPLAY_SIZE = 15;
 
-    private static final ValueFloat ZERO = new ValueFloat(0.0F);
-    private static final ValueFloat ONE = new ValueFloat(1.0F);
+    /**
+     * Float.floatToIntBits(0f).
+     */
+    public static final int ZERO_BITS = 0;
+
+    /**
+     * The value 0.
+     */
+    public static final ValueFloat ZERO = new ValueFloat(0f);
+
+    /**
+     * The value 1.
+     */
+    public static final ValueFloat ONE = new ValueFloat(1f);
+
     private static final ValueFloat NAN = new ValueFloat(Float.NaN);
 
     private final float value;
@@ -45,24 +53,24 @@ public class ValueFloat extends Value {
     @Override
     public Value add(Value v) {
         ValueFloat v2 = (ValueFloat) v;
-        return ValueFloat.get(value + v2.value);
+        return get(value + v2.value);
     }
 
     @Override
     public Value subtract(Value v) {
         ValueFloat v2 = (ValueFloat) v;
-        return ValueFloat.get(value - v2.value);
+        return get(value - v2.value);
     }
 
     @Override
     public Value negate() {
-        return ValueFloat.get(-value);
+        return get(-value);
     }
 
     @Override
     public Value multiply(Value v) {
         ValueFloat v2 = (ValueFloat) v;
-        return ValueFloat.get(value * v2.value);
+        return get(value * v2.value);
     }
 
     @Override
@@ -71,7 +79,7 @@ public class ValueFloat extends Value {
         if (v2.value == 0.0) {
             throw DbException.get(ErrorCode.DIVISION_BY_ZERO_1, getSQL());
         }
-        return ValueFloat.get(value / v2.value);
+        return get(value / v2.value);
     }
 
     @Override
@@ -80,7 +88,7 @@ public class ValueFloat extends Value {
         if (other.value == 0) {
             throw DbException.get(ErrorCode.DIVISION_BY_ZERO_1, getSQL());
         }
-        return ValueFloat.get(value % other.value);
+        return get(value % other.value);
     }
 
     @Override

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/scripts/TestScript.java

@@ -125,7 +125,7 @@ public class TestScript extends TestDb {
             testScript("datatypes/" + s + ".sql");
         }
         for (String s : new String[] { "alterTableAdd", "alterTableDropColumn", "alterTableRename",
-                "createAlias", "createSynonym", "createTable", "createTrigger", "createView",
+                "createAlias", "createSequence", "createSynonym", "createTable", "createTrigger", "createView",
                 "dropDomain", "dropIndex", "dropSchema", "truncateTable" }) {
             testScript("ddl/" + s + ".sql");
         }

h2/src/test/org/h2/test/scripts/ddl/createSequence.sql

+-- Copyright 2004-2018 H2 Group. Multiple-Licensed under the MPL 2.0,
+-- and the EPL 1.0 (http://h2database.com/html/license.html).
+-- Initial Developer: H2 Group
+--
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY 1 MINVALUE 0 MAXVALUE 1;
+> ok
+
+DROP SEQUENCE SEQ;
+> ok
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY 1 MINVALUE 0 MAXVALUE 0;
+> exception SEQUENCE_ATTRIBUTES_INVALID
+
+CREATE SEQUENCE SEQ START WITH 1 INCREMENT BY 1 MINVALUE 1 MAXVALUE 0;
+> exception SEQUENCE_ATTRIBUTES_INVALID
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY 0 MINVALUE 0 MAXVALUE 1;
+> exception SEQUENCE_ATTRIBUTES_INVALID
+
+CREATE SEQUENCE SEQ START WITH 1 INCREMENT BY 1 MINVALUE 2 MAXVALUE 10;
+> exception SEQUENCE_ATTRIBUTES_INVALID
+
+CREATE SEQUENCE SEQ START WITH 20 INCREMENT BY 1 MINVALUE 1 MAXVALUE 10;
+> exception SEQUENCE_ATTRIBUTES_INVALID
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY 9223372036854775807 MINVALUE -9223372036854775808 MAXVALUE 9223372036854775807;
+> ok
+
+DROP SEQUENCE SEQ;
+> ok
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY -9223372036854775808 MINVALUE -9223372036854775808 MAXVALUE 9223372036854775807;
+> ok
+
+DROP SEQUENCE SEQ;
+> ok
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY -9223372036854775808 MINVALUE -1 MAXVALUE 9223372036854775807;
+> ok
+
+DROP SEQUENCE SEQ;
+> ok
+
+CREATE SEQUENCE SEQ START WITH 0 INCREMENT BY -9223372036854775808 MINVALUE 0 MAXVALUE 9223372036854775807;
+> exception SEQUENCE_ATTRIBUTES_INVALID
+

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) {