Merge branch 'master' into scay-issue#832

h2/src/docsrc/help/help.csv

@@ -3668,12 +3668,14 @@ CURRENT_TIMESTAMP()
 "Functions (Time and Date)","DATEADD","
 { DATEADD| TIMESTAMPADD } (unitString, addIntLong, timestamp)
 ","
-Adds units to a timestamp. The string indicates the unit.
+Adds units to a date-time value. The string indicates the unit.
 Use negative values to subtract units.
 addIntLong may be a long value when manipulating milliseconds,
 otherwise it's range is restricted to int.
 The same units as in the EXTRACT function are supported.
-DATEADD method returns a timestamp. TIMESTAMPADD method returns a long.
+This method returns a value with the same type as specified value if unit is compatible with this value.
+If specified unit is a HOUR, MINUTE, SECOND, MILLISECOND, etc and value is a DATE value DATEADD returns combined TIMESTAMP.
+Units DAY, MONTH, YEAR, WEEK, etc are not allowed for TIME values.
 ","
 DATEADD('MONTH', 1, DATE '2001-01-31')
 "
@@ -3723,8 +3725,9 @@ DAY_OF_YEAR(CREATED)
 "
 
 "Functions (Time and Date)","EXTRACT","
-EXTRACT ( { YEAR | YY | MONTH | MM | WEEK | ISO_WEEK | DAY | DD | DAY_OF_YEAR
-    | DOY | HOUR | HH | MINUTE | MI | SECOND | SS | MILLISECOND | MS }
+EXTRACT ( { YEAR | YY | MONTH | MM | QUARTER | WEEK | ISO_WEEK
+    | DAY | DD | DAY_OF_YEAR | DOY
+    | HOUR | HH | MINUTE | MI | SECOND | SS | MILLISECOND | MS }
     FROM timestamp )
 ","
 Returns a specific value from a timestamps.

h2/src/docsrc/html/performance.html

@@ -490,7 +490,7 @@ Instead, use a prepared statement with arrays as in the following example:
 </p>
 <pre>
 PreparedStatement prep = conn.prepareStatement(
-    "SELECT * TEST.ID = ANY(?)");
+    "SELECT * FROM TEST WHERE ID = ANY(?)");
 prep.setObject(1, new Object[] { "1", "2" });
 ResultSet rs = prep.executeQuery();
 </pre>

h2/src/installer/release.txt

@@ -17,7 +17,28 @@ Ensure lines are not overly long:
 
     ./build.sh docs
 
-## Jar File Size Verification
+## JDBC Client Jar File Size Verification
+
+The JDBC client is supposed to not have dependencies to the database engine.
+To verify, run
+
+    ./build.sh clean jarClient
+
+If this fails with eg. "Expected file size 400 - 500 KB, got: 1687", then
+find out where the dependency is, and resolve. As follows:
+start by renaming Database to Database2:
+
+    mv src/main/org/h2/engine/Database.java src/main/org/h2/engine/Database2.java
+    ./build.sh clean jarClient
+
+This will fail, the first error is for example can not compile Session because Database was not found.
+So rename Session to Session2 and try again.
+This will fail again, the first error is different, now for example can not compile ResultInterface
+because Session was not found. Now, ResultInterface should not depend on the Session.
+So this needs to be fixed (the JDBC API shouldn't indirectly depend on it).
+After everything is resolved, rename the classes back.
+
+## MVStore Jar File Size Verification
 
 To ensure the MVStore jar file is not too large
 (does not reference the database code by accident).
@@ -27,14 +48,39 @@ The file size should be about 200 KB:
 
 ## Changing Version Numbers
 
-Update Constants.java - change version and build number
-Update changelog.html - add new version, remove oldest
-Update newsfeed.sql - add new version, remove oldest
-Minor version change: change sourceError.html and source.html
-If a beta, change download.html: Version ${version} (${versionDate}), Beta
-If a beta, change mainWeb.html: Version ${version} (${versionDate}), Beta
-Benchmark: use latest versions of other dbs, change version(s) in performance.html
-Run ./buildRelease.sh / buildRelease.bat
+Update org.h2.engine.Constants.java:
+    if the last build was stable (the normal case):
+        set BUILD_DATE_STABLE to current BUILD_DATE
+        set BUILD_ID_STABLE to current BUILD_ID
+    change the version and build number:
+        set BUILD_DATE to today
+        increment BUILD_ID
+
+Update changelog.html:
+    * create a new "Next Version (unreleased)" with an empty list
+    * add a new version
+    * remove change log entries of the oldest version (keeping about 500 lines)
+
+Update newsfeed.sql:
+    * add new version, for example:
+    * (146, '1.4.197', '2017-06-10'),
+    * remove oldest entry in that list
+
+## Skipped
+
+The following can be skipped currently, as sourceError.html and source.html
+are no longer working (they can be removed, or fixed):
+* Minor version change: change sourceError.html and source.html
+* If a beta, change download.html: Version ${version} (${versionDate}), Beta
+* If a beta, change mainWeb.html: Version ${version} (${versionDate}), Beta
+
+The following can be skipped currently; benchmarks should probably be removed:
+* To update benchmark data: use latest versions of other dbs, change version(s) in performance.html
+
+## Build the release
+
+Change directory to src/installer
+Run ./buildRelease.sh (non-Windows) or buildRelease.bat (Windows)
 
 Scan for viruses
 Test installer, H2 Console (test new languages)

h2/src/main/org/h2/bnf/context/DbContextRule.java

@@ -15,8 +15,8 @@ import org.h2.bnf.RuleElement;
 import org.h2.bnf.RuleHead;
 import org.h2.bnf.RuleList;
 import org.h2.bnf.Sentence;
-import org.h2.command.Parser;
 import org.h2.message.DbException;
+import org.h2.util.ParserUtil;
 import org.h2.util.StringUtils;
 
 /**
@@ -154,7 +154,7 @@ public class DbContextRule implements Rule {
                 break;
             }
             String alias = up.substring(0, i);
-            if (Parser.isKeyword(alias, true)) {
+            if (ParserUtil.isKeyword(alias, true)) {
                 break;
             }
             s = s.substring(alias.length());
@@ -301,7 +301,7 @@ public class DbContextRule implements Rule {
             return s;
         }
         String alias = up.substring(0, i);
-        if ("SET".equals(alias) || Parser.isKeyword(alias, true)) {
+        if ("SET".equals(alias) || ParserUtil.isKeyword(alias, true)) {
             return s;
         }
         if (newAlias) {

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

@@ -148,6 +148,7 @@ import org.h2.table.TableFilter.TableFilterVisitor;
 import org.h2.table.TableView;
 import org.h2.util.MathUtils;
 import org.h2.util.New;
+import org.h2.util.ParserUtil;
 import org.h2.util.StatementBuilder;
 import org.h2.util.StringUtils;
 import org.h2.value.CompareMode;
@@ -186,15 +187,18 @@ public class Parser {
             CHAR_DOLLAR_QUOTED_STRING = 9;
 
     // this are token types
-    private static final int KEYWORD = 1, IDENTIFIER = 2, PARAMETER = 3,
-            END = 4, VALUE = 5;
-    private static final int EQUAL = 6, BIGGER_EQUAL = 7, BIGGER = 8;
-    private static final int SMALLER = 9, SMALLER_EQUAL = 10, NOT_EQUAL = 11,
-            AT = 12;
-    private static final int MINUS = 13, PLUS = 14, STRING_CONCAT = 15;
-    private static final int OPEN = 16, CLOSE = 17, NULL = 18, TRUE = 19,
-            FALSE = 20;
-    private static final int ROWNUM = 24;
+    private static final int KEYWORD = ParserUtil.KEYWORD;
+    private static final int IDENTIFIER = ParserUtil.IDENTIFIER;
+    private static final int NULL = ParserUtil.NULL;
+    private static final int TRUE = ParserUtil.TRUE;
+    private static final int FALSE = ParserUtil.FALSE;
+    private static final int ROWNUM = ParserUtil.ROWNUM;
+    private static final int PARAMETER = 10, END = 11, VALUE = 12;
+    private static final int EQUAL = 13, BIGGER_EQUAL = 14, BIGGER = 15;
+    private static final int SMALLER = 16, SMALLER_EQUAL = 17, NOT_EQUAL = 18;
+    private static final int AT = 19;
+    private static final int MINUS = 20, PLUS = 21, STRING_CONCAT = 22;
+    private static final int OPEN = 23, CLOSE = 24;
     private static final int SPATIAL_INTERSECTS = 25;
 
     private static final Comparator<TableFilter> TABLE_FILTER_COMPARATOR =
@@ -4170,140 +4174,11 @@ public class Parser {
             // if not yet converted to uppercase, do it now
             s = StringUtils.toUpperEnglish(s);
         }
-        return isKeyword(s, false);
-    }
-
-    /**
-     * Checks if this string is a SQL keyword.
-     *
-     * @param s                  the token to check
-     * @param supportOffsetFetch if OFFSET and FETCH are keywords
-     * @return true if it is a keyword
-     */
-    public static boolean isKeyword(String s, boolean supportOffsetFetch) {
-        if (s == null || s.length() == 0) {
-            return false;
-        }
-        return getSaveTokenType(s, supportOffsetFetch, false) != IDENTIFIER;
+        return ParserUtil.isKeyword(s, false);
     }
 
     private static int getSaveTokenType(String s, boolean supportOffsetFetch, boolean functionsAsKeywords) {
-        switch (s.charAt(0)) {
-        case 'A':
-            return getKeywordOrIdentifier(s, "ALL", KEYWORD);
-        case 'C':
-            if ("CHECK".equals(s)) {
-                return KEYWORD;
-            } else if ("CONSTRAINT".equals(s)) {
-                return KEYWORD;
-            } else if ("CROSS".equals(s)) {
-                return KEYWORD;
-            }
-            if (functionsAsKeywords) {
-                if ("CURRENT_DATE".equals(s) || "CURRENT_TIME".equals(s) || "CURRENT_TIMESTAMP".equals(s)) {
-                    return KEYWORD;
-                }
-            }
-            return IDENTIFIER;
-        case 'D':
-            return getKeywordOrIdentifier(s, "DISTINCT", KEYWORD);
-        case 'E':
-            if ("EXCEPT".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "EXISTS", KEYWORD);
-        case 'F':
-            if ("FROM".equals(s)) {
-                return KEYWORD;
-            } else if ("FOR".equals(s)) {
-                return KEYWORD;
-            } else if ("FOREIGN".equals(s)) {
-                return KEYWORD;
-            } else if ("FULL".equals(s)) {
-                return KEYWORD;
-            } else if (supportOffsetFetch && "FETCH".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "FALSE", FALSE);
-        case 'G':
-            return getKeywordOrIdentifier(s, "GROUP", KEYWORD);
-        case 'H':
-            return getKeywordOrIdentifier(s, "HAVING", KEYWORD);
-        case 'I':
-            if ("INNER".equals(s)) {
-                return KEYWORD;
-            } else if ("INTERSECT".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "IS", KEYWORD);
-        case 'J':
-            return getKeywordOrIdentifier(s, "JOIN", KEYWORD);
-        case 'L':
-            if ("LIMIT".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "LIKE", KEYWORD);
-        case 'M':
-            return getKeywordOrIdentifier(s, "MINUS", KEYWORD);
-        case 'N':
-            if ("NOT".equals(s)) {
-                return KEYWORD;
-            } else if ("NATURAL".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "NULL", NULL);
-        case 'O':
-            if ("ON".equals(s)) {
-                return KEYWORD;
-            } else if (supportOffsetFetch && "OFFSET".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "ORDER", KEYWORD);
-        case 'P':
-            return getKeywordOrIdentifier(s, "PRIMARY", KEYWORD);
-        case 'R':
-            return getKeywordOrIdentifier(s, "ROWNUM", ROWNUM);
-        case 'S':
-            if ("SELECT".equals(s)) {
-                return KEYWORD;
-            }
-            if (functionsAsKeywords) {
-                if ("SYSDATE".equals(s) || "SYSTIME".equals(s) || "SYSTIMESTAMP".equals(s)) {
-                    return KEYWORD;
-                }
-            }
-            return IDENTIFIER;
-        case 'T':
-            if ("TRUE".equals(s)) {
-                return TRUE;
-            }
-            if (functionsAsKeywords) {
-                if ("TODAY".equals(s)) {
-                    return KEYWORD;
-                }
-            }
-            return IDENTIFIER;
-        case 'U':
-            if ("UNIQUE".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "UNION", KEYWORD);
-        case 'W':
-            if ("WITH".equals(s)) {
-                return KEYWORD;
-            }
-            return getKeywordOrIdentifier(s, "WHERE", KEYWORD);
-        default:
-            return IDENTIFIER;
-        }
-    }
-
-    private static int getKeywordOrIdentifier(String s1, String s2,
-            int keywordType) {
-        if (s1.equals(s2)) {
-            return keywordType;
-        }
-        return IDENTIFIER;
+        return ParserUtil.getSaveTokenType(s, supportOffsetFetch, functionsAsKeywords);
     }
 
     private Column parseColumnForTable(String columnName,
@@ -6890,8 +6765,9 @@ public class Parser {
         if (s == null) {
             return "\"\"";
         }
-        if (isSimpleIdentifier(s, false))
+        if (isSimpleIdentifier(s, false)) {
             return s;
+        }
         return StringUtils.quoteIdentifier(s);
     }
 
@@ -6904,22 +6780,7 @@ public class Parser {
      * @throws NullPointerException if s is {@code null}
      */
     public static boolean isSimpleIdentifier(String s, boolean functionsAsKeywords) {
-        if (s.length() == 0) {
-            return false;
-        }
-        char c = s.charAt(0);
-        // lowercase a-z is quoted as well
-        if ((!Character.isLetter(c) && c != '_') || Character.isLowerCase(c)) {
-            return false;
-        }
-        for (int i = 1, length = s.length(); i < length; i++) {
-            c = s.charAt(i);
-            if ((!Character.isLetterOrDigit(c) && c != '_') ||
-                    Character.isLowerCase(c)) {
-                return false;
-            }
-        }
-        return getSaveTokenType(s, true, functionsAsKeywords) == IDENTIFIER;
+        return ParserUtil.isSimpleIdentifier(s, functionsAsKeywords);
     }
 
     public void setLiteralsChecked(boolean literalsChecked) {

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

@@ -311,7 +311,7 @@ public class Aggregate extends Expression {
                 return v;
             }
             case MEDIAN: {
-                return AggregateDataMedian.getFromIndex(session, on, dataType);
+                return AggregateDataMedian.getResultFromIndex(session, on, dataType);
             }
             default:
                 DbException.throwInternalError("type=" + type);

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

@@ -49,6 +49,12 @@ class AggregateDataMedian extends AggregateData {
                 || (sortType & SortOrder.DESCENDING) != 0 && (sortType & SortOrder.NULLS_FIRST) == 0;
     }
 
+    /**
+     * Get the index (if any) for the column specified in the median aggregate.
+     *
+     * @param on the expression (usually a column expression)
+     * @return the index, or null
+     */
     static Index getMedianColumnIndex(Expression on) {
         if (on instanceof ExpressionColumn) {
             ExpressionColumn col = (ExpressionColumn) on;
@@ -68,8 +74,8 @@ class AggregateDataMedian extends AggregateData {
                         if (!index.isFirstColumn(column)) {
                             continue;
                         }
-                        if (result == null || result.getColumns().length > index.getColumns().length
                         // Prefer index without nulls last for nullable columns
+                        if (result == null || result.getColumns().length > index.getColumns().length
                                 || nullable && isNullsLast(result) && !isNullsLast(index)) {
                             result = index;
                         }
@@ -81,7 +87,15 @@ class AggregateDataMedian extends AggregateData {
         return null;
     }
 
-    static Value getFromIndex(Session session, Expression on, int dataType) {
+    /**
+     * Get the result from the index.
+     *
+     * @param session the session
+     * @param on the expression
+     * @param dataType the data type
+     * @return the result
+     */
+    static Value getResultFromIndex(Session session, Expression on, int dataType) {
         Index index = getMedianColumnIndex(on);
         long count = index.getRowCount(session);
         if (count == 0) {
@@ -94,10 +108,8 @@ class AggregateDataMedian extends AggregateData {
         if (expr.getColumn().isNullable()) {
             boolean hasNulls = false;
             SearchRow row;
-            /*
-             * Try to skip nulls from the start first with the same cursor that will be used
-             * to read values.
-             */
+            // Try to skip nulls from the start first with the same cursor that
+            // will be used to read values.
             while (count > 0) {
                 row = cursor.getSearchRow();
                 if (row == null) {
@@ -113,10 +125,8 @@ class AggregateDataMedian extends AggregateData {
             if (count == 0) {
                 return ValueNull.INSTANCE;
             }
-            /*
-             * If no nulls found and if index orders nulls last create a second cursor to
-             * count nulls at the end.
-             */
+            // If no nulls found and if index orders nulls last create a second
+            // cursor to count nulls at the end.
             if (!hasNulls && isNullsLast(index)) {
                 TableFilter tableFilter = expr.getTableFilter();
                 SearchRow check = tableFilter.getTable().getTemplateSimpleRow(true);
@@ -196,7 +206,7 @@ class AggregateDataMedian extends AggregateData {
         return getMedian(a[idx - 1], v1, dataType, mode);
     }
 
-    static Value getMedian(Value v0, Value v1, int dataType, CompareMode mode) {
+    private static Value getMedian(Value v0, Value v1, int dataType, CompareMode mode) {
         if (v0.compareTo(v1, mode) == 0) {
             return v0.convertTo(dataType);
         }

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

@@ -12,6 +12,7 @@ import org.h2.engine.Session;
 import org.h2.engine.SysProperties;
 import org.h2.index.IndexCondition;
 import org.h2.message.DbException;
+import org.h2.table.Column;
 import org.h2.table.ColumnResolver;
 import org.h2.table.TableFilter;
 import org.h2.util.MathUtils;
@@ -202,9 +203,10 @@ public class Comparison extends Condition {
                     // to constant type, but vise versa, then let's do this here
                     // once.
                     if (constType != resType) {
+                        Column column = ((ExpressionColumn) left).getColumn();
                         right = ValueExpression.get(r.convertTo(resType,
                                 MathUtils.convertLongToInt(left.getPrecision()),
-                                session.getDatabase().getMode(), ((ExpressionColumn) left).getColumn()));
+                                session.getDatabase().getMode(), column, column.getEnumerators()));
                     }
                 } else if (right instanceof Parameter) {
                     ((Parameter) right).setColumn(

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

@@ -57,7 +57,7 @@ public class ConditionInParameter extends Condition {
 
     private Expression left;
 
-    final Parameter parameter;
+    private final Parameter parameter;
 
     /**
      * Create a new {@code = ANY(?)} condition.

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

@@ -15,10 +15,10 @@ 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;
+import java.util.GregorianCalendar;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.regex.Pattern;
@@ -173,6 +173,7 @@ public class Function extends Expression implements FunctionCall {
         DATE_PART.put("MONTH", MONTH);
         DATE_PART.put("MM", MONTH);
         DATE_PART.put("M", MONTH);
+        DATE_PART.put("QUARTER", QUARTER);
         DATE_PART.put("SQL_TSI_WEEK", WEEK);
         DATE_PART.put("WW", WEEK);
         DATE_PART.put("WK", WEEK);
@@ -351,7 +352,7 @@ public class Function extends Expression implements FunctionCall {
         addFunction("DATEADD", DATE_ADD,
                 3, Value.TIMESTAMP);
         addFunction("TIMESTAMPADD", DATE_ADD,
-                3, Value.LONG);
+                3, Value.TIMESTAMP);
         addFunction("DATEDIFF", DATE_DIFF,
                 3, Value.LONG);
         addFunction("TIMESTAMPDIFF", DATE_DIFF,
@@ -858,7 +859,7 @@ public class Function extends Expression implements FunctionCall {
         case SECOND:
         case WEEK:
         case YEAR:
-            result = ValueInt.get(DateTimeUtils.getDatePart(v0, info.type));
+            result = ValueInt.get(getDatePart(v0, info.type));
             break;
         case MONTH_NAME: {
             SimpleDateFormat monthName = new SimpleDateFormat("MMMM",
@@ -1489,8 +1490,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));
@@ -1848,53 +1848,85 @@ 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);
+        boolean withTime = !(v instanceof ValueDate);
+        boolean forceTimestamp = false;
+        long[] a = DateTimeUtils.dateAndTimeFromValue(v);
+        long dateValue = a[0];
+        long timeNanos = a[1];
         switch (field) {
+        case QUARTER:
+            count *= 3;
+            //$FALL-THROUGH$
         case YEAR:
-            field = Calendar.YEAR;
-            break;
-        case MONTH:
-            field = Calendar.MONTH;
-            break;
+        case MONTH: {
+            if (!withDate) {
+                throw DbException.getInvalidValueException("DATEADD time part", part);
+            }
+            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 time part", part);
+            }
+            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;
         }
-        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;
+        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);
+        }
+        return DateTimeUtils.dateTimeToValue(v, dateValue, timeNanos, forceTimestamp);
     }
 
     /**
@@ -1950,6 +1982,10 @@ public class Function extends Expression implements FunctionCall {
         case MONTH:
             return (DateTimeUtils.yearFromDateValue(dateValue2) - DateTimeUtils.yearFromDateValue(dateValue1)) * 12
                     + DateTimeUtils.monthFromDateValue(dateValue2) - DateTimeUtils.monthFromDateValue(dateValue1);
+        case QUARTER:
+            return (DateTimeUtils.yearFromDateValue(dateValue2) - DateTimeUtils.yearFromDateValue(dateValue1)) * 4
+                    + (DateTimeUtils.monthFromDateValue(dateValue2) - 1) / 3
+                    - (DateTimeUtils.monthFromDateValue(dateValue1) - 1) / 3;
         case YEAR:
             return DateTimeUtils.yearFromDateValue(dateValue2) - DateTimeUtils.yearFromDateValue(dateValue1);
         default:
@@ -2806,6 +2842,52 @@ public class Function extends Expression implements FunctionCall {
         }
     }
 
+    /**
+     * Get the specified field of a date, however with years normalized to
+     * positive or negative, and month starting with 1.
+     *
+     * @param date the date value
+     * @param field the field type, see {@link Function} for constants
+     * @return the value
+     */
+    public static int getDatePart(Value date, int field) {
+        long[] a = DateTimeUtils.dateAndTimeFromValue(date);
+        long dateValue = a[0];
+        long timeNanos = a[1];
+        switch (field) {
+        case Function.YEAR:
+            return DateTimeUtils.yearFromDateValue(dateValue);
+        case Function.MONTH:
+            return DateTimeUtils.monthFromDateValue(dateValue);
+        case Function.DAY_OF_MONTH:
+            return DateTimeUtils.dayFromDateValue(dateValue);
+        case Function.HOUR:
+            return (int) (timeNanos / 3_600_000_000_000L % 24);
+        case Function.MINUTE:
+            return (int) (timeNanos / 60_000_000_000L % 60);
+        case Function.SECOND:
+            return (int) (timeNanos / 1_000_000_000 % 60);
+        case Function.MILLISECOND:
+            return (int) (timeNanos / 1_000_000 % 1_000);
+        case Function.DAY_OF_YEAR:
+            return DateTimeUtils.getDayOfYear(dateValue);
+        case Function.DAY_OF_WEEK:
+            return DateTimeUtils.getSundayDayOfWeek(dateValue);
+        case Function.WEEK:
+            GregorianCalendar gc = DateTimeUtils.getCalendar();
+            return DateTimeUtils.getWeekOfYear(dateValue, gc.getFirstDayOfWeek() - 1, gc.getMinimalDaysInFirstWeek());
+        case Function.QUARTER:
+            return (DateTimeUtils.monthFromDateValue(dateValue) - 1) / 3 + 1;
+        case Function.ISO_YEAR:
+            return DateTimeUtils.getIsoWeekYear(dateValue);
+        case Function.ISO_WEEK:
+            return DateTimeUtils.getIsoWeekOfYear(dateValue);
+        case Function.ISO_DAY_OF_WEEK:
+            return DateTimeUtils.getIsoDayOfWeek(dateValue);
+        }
+        throw DbException.getUnsupportedException("getDatePart(" + date + ", " + field + ')');
+    }
+
     @Override
     public Expression[] getArgs() {
         return args;

h2/src/main/org/h2/jdbc/JdbcStatement.java

@@ -13,13 +13,13 @@ import java.sql.Statement;
 import java.util.ArrayList;
 import org.h2.api.ErrorCode;
 import org.h2.command.CommandInterface;
-import org.h2.command.Parser;
 import org.h2.engine.SessionInterface;
 import org.h2.engine.SysProperties;
 import org.h2.message.DbException;
 import org.h2.message.TraceObject;
 import org.h2.result.ResultInterface;
 import org.h2.util.New;
+import org.h2.util.ParserUtil;
 import org.h2.util.StringUtils;
 
 /**
@@ -1333,7 +1333,7 @@ public class JdbcStatement extends TraceObject implements Statement, JdbcStateme
      */
     @Override
     public boolean isSimpleIdentifier(String identifier) throws SQLException {
-        return Parser.isSimpleIdentifier(identifier, true);
+        return ParserUtil.isSimpleIdentifier(identifier, true);
     }
 
     /**

h2/src/main/org/h2/result/LazyResult.java

@@ -5,7 +5,7 @@
  */
 package org.h2.result;
 
-import org.h2.engine.Session;
+import org.h2.engine.SessionInterface;
 import org.h2.expression.Expression;
 import org.h2.message.DbException;
 import org.h2.value.Value;
@@ -180,7 +180,7 @@ public abstract class LazyResult implements ResultInterface {
     }
 
     @Override
-    public ResultInterface createShallowCopy(Session targetSession) {
+    public ResultInterface createShallowCopy(SessionInterface targetSession) {
         // Copying is impossible with lazy result.
         return null;
     }

h2/src/main/org/h2/result/LocalResult.java

@@ -12,6 +12,7 @@ import java.util.Arrays;
 
 import org.h2.engine.Database;
 import org.h2.engine.Session;
+import org.h2.engine.SessionInterface;
 import org.h2.expression.Expression;
 import org.h2.message.DbException;
 import org.h2.util.New;
@@ -125,7 +126,7 @@ public class LocalResult implements ResultInterface, ResultTarget {
      * @return the copy if possible, or null if copying is not possible
      */
     @Override
-    public LocalResult createShallowCopy(Session targetSession) {
+    public LocalResult createShallowCopy(SessionInterface targetSession) {
         if (external == null && (rows == null || rows.size() < rowCount)) {
             return null;
         }
@@ -141,7 +142,7 @@ public class LocalResult implements ResultInterface, ResultTarget {
         }
         LocalResult copy = new LocalResult();
         copy.maxMemoryRows = this.maxMemoryRows;
-        copy.session = targetSession;
+        copy.session = (Session) targetSession;
         copy.visibleColumnCount = this.visibleColumnCount;
         copy.expressions = this.expressions;
         copy.rowId = -1;

h2/src/main/org/h2/result/ResultInterface.java

@@ -5,7 +5,7 @@
  */
 package org.h2.result;
 
-import org.h2.engine.Session;
+import org.h2.engine.SessionInterface;
 import org.h2.value.Value;
 
 /**
@@ -200,7 +200,7 @@ public interface ResultInterface extends AutoCloseable {
      * @param targetSession the session of the copy
      * @return the copy if possible, or null if copying is not possible
      */
-    ResultInterface createShallowCopy(Session targetSession);
+    ResultInterface createShallowCopy(SessionInterface targetSession);
 
     /**
      * Check if this result set contains the given row.

h2/src/main/org/h2/result/ResultRemote.java

@@ -7,7 +7,7 @@ package org.h2.result;
 
 import java.io.IOException;
 import java.util.ArrayList;
-import org.h2.engine.Session;
+import org.h2.engine.SessionInterface;
 import org.h2.engine.SessionRemote;
 import org.h2.engine.SysProperties;
 import org.h2.message.DbException;
@@ -271,7 +271,7 @@ public class ResultRemote implements ResultInterface {
     }
 
     @Override
-    public ResultInterface createShallowCopy(Session targetSession) {
+    public ResultInterface createShallowCopy(SessionInterface targetSession) {
         // The operation is not supported on remote result.
         return null;
     }

h2/src/main/org/h2/table/Column.java

@@ -173,7 +173,7 @@ public class Column {
      */
     public Value convert(Value v, Mode mode) {
         try {
-            return v.convertTo(type, MathUtils.convertLongToInt(precision), mode, this);
+            return v.convertTo(type, MathUtils.convertLongToInt(precision), mode, this, getEnumerators());
         } catch (DbException e) {
             if (e.getErrorCode() == ErrorCode.DATA_CONVERSION_ERROR_1) {
                 String target = (table == null ? "" : table.getName() + ": ") +

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

@@ -16,7 +16,6 @@ import java.util.Locale;
 import java.util.TimeZone;
 import org.h2.api.ErrorCode;
 import org.h2.engine.Mode;
-import org.h2.expression.Function;
 import org.h2.message.DbException;
 import org.h2.value.Value;
 import org.h2.value.ValueDate;
@@ -25,7 +24,6 @@ import org.h2.value.ValueTime;
 import org.h2.value.ValueTimestamp;
 import org.h2.value.ValueTimestampTimeZone;
 
-
 /**
  * This utility class contains time conversion functions.
  * <p>
@@ -116,7 +114,7 @@ public class DateTimeUtils {
      *
      * @return a calendar instance. A cached instance is returned where possible
      */
-    private static GregorianCalendar getCalendar() {
+    public static GregorianCalendar getCalendar() {
         GregorianCalendar c = CACHED_CALENDAR.get();
         if (c == null) {
             c = DateTimeUtils.createGregorianCalendar();
@@ -597,49 +595,37 @@ public class DateTimeUtils {
     }
 
     /**
-     * Get the specified field of a date, however with years normalized to
-     * positive or negative, and month starting with 1.
+     * 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 date the date value
-     * @param field the field type, see {@link Function} for constants
-     * @return the value
-     */
-    public static int getDatePart(Value date, int field) {
-        long[] a = dateAndTimeFromValue(date);
-        long dateValue = a[0];
-        long timeNanos = a[1];
-        switch (field) {
-        case Function.YEAR:
-            return yearFromDateValue(dateValue);
-        case Function.MONTH:
-            return monthFromDateValue(dateValue);
-        case Function.DAY_OF_MONTH:
-            return dayFromDateValue(dateValue);
-        case Function.HOUR:
-            return (int) (timeNanos / 3_600_000_000_000L % 24);
-        case Function.MINUTE:
-            return (int) (timeNanos / 60_000_000_000L % 60);
-        case Function.SECOND:
-            return (int) (timeNanos / 1_000_000_000 % 60);
-        case Function.MILLISECOND:
-            return (int) (timeNanos / 1_000_000 % 1_000);
-        case Function.DAY_OF_YEAR:
-            return getDayOfYear(dateValue);
-        case Function.DAY_OF_WEEK:
-            return getSundayDayOfWeek(dateValue);
-        case Function.WEEK:
-            GregorianCalendar gc = getCalendar();
-            return getWeekOfYear(dateValue, gc.getFirstDayOfWeek() - 1, gc.getMinimalDaysInFirstWeek());
-        case Function.QUARTER:
-            return (monthFromDateValue(dateValue) - 1) / 3 + 1;
-        case Function.ISO_YEAR:
-            return getIsoWeekYear(dateValue);
-        case Function.ISO_WEEK:
-            return getIsoWeekOfYear(dateValue);
-        case Function.ISO_DAY_OF_WEEK:
-            return getIsoDayOfWeek(dateValue);
+     * @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());
+            }
         }
-        throw DbException.getUnsupportedException("getDatePart(" + date + ", " + field + ')');
+        return ValueTimestamp.fromDateValueAndNanos(dateValue, timeNanos);
     }
 
     /**
@@ -882,6 +868,26 @@ public class DateTimeUtils {
         }
     }
 
+    /**
+     * Returns number of days in month.
+     *
+     * @param year the year
+     * @param month the month
+     * @return number of days in the specified month
+     */
+    public static int getDaysInMonth(int year, int month) {
+        if (month != 2) {
+            return NORMAL_DAYS_PER_MONTH[month];
+        }
+        // All leap years divisible by 4
+        return (year & 3) == 0
+                // All such years before 1582 are Julian and leap
+                && (year < 1582
+                        // Otherwise check Gregorian conditions
+                        || year % 100 != 0 || year % 400 == 0)
+                ? 29 : 28;
+    }
+
     /**
      * Verify if the specified date is valid.
      *
@@ -894,24 +900,11 @@ public class DateTimeUtils {
         if (month < 1 || month > 12 || day < 1) {
             return false;
         }
-        if (year > 1582) {
-            // Gregorian calendar
-            if (month != 2) {
-                return day <= NORMAL_DAYS_PER_MONTH[month];
-            }
-            // February
-            if ((year & 3) != 0) {
-                return day <= 28;
-            }
-            return day <= ((year % 100 != 0) || (year % 400 == 0) ? 29 : 28);
-        } else if (year == 1582 && month == 10) {
+        if (year == 1582 && month == 10) {
             // special case: days 1582-10-05 .. 1582-10-14 don't exist
-            return day <= 31 && (day < 5 || day > 14);
-        }
-        if (month != 2 && day <= NORMAL_DAYS_PER_MONTH[month]) {
-            return true;
+            return day < 5 || (day > 14 && day <= 31);
         }
-        return day <= ((year & 3) != 0 ? 28 : 29);
+        return day <= getDaysInMonth(year, month);
     }
 
     /**
@@ -1037,6 +1030,38 @@ public class DateTimeUtils {
         return (year << SHIFT_YEAR) | (month << SHIFT_MONTH) | day;
     }
 
+    /**
+     * Get the date value from a given denormalized date with possible out of range
+     * values of month and/or day. Used after addition or subtraction month or years
+     * to (from) it to get a valid date.
+     *
+     * @param year
+     *            the year
+     * @param month
+     *            the month, if out of range month and year will be normalized
+     * @param day
+     *            the day of the month, if out of range it will be saturated
+     * @return the date value
+     */
+    public static long dateValueFromDenormalizedDate(long year, long month, int day) {
+        long mm1 = month - 1;
+        long yd = mm1 / 12;
+        if (mm1 < 0 && yd * 12 != mm1) {
+            yd--;
+        }
+        int y = (int) (year + yd);
+        int m = (int) (month - yd * 12);
+        if (day < 1) {
+            day = 1;
+        } else {
+            int max = getDaysInMonth(y, m);
+            if (day > max) {
+                day = max;
+            }
+        }
+        return dateValue(y, m, day);
+    }
+
     /**
      * Convert a UTC datetime in millis to an encoded date in the default
      * timezone.

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

+/*
+ * 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
+ */
+package org.h2.util;
+
+public class ParserUtil {
+
+    /**
+     * A keyword.
+     */
+    public static final int KEYWORD = 1;
+
+    /**
+     * An identifier (table name, column name,...).
+     */
+    public static final int IDENTIFIER = 2;
+
+    /**
+     * The token "null".
+     */
+    public static final int NULL = 3;
+
+    /**
+     * The token "true".
+     */
+    public static final int TRUE = 4;
+
+    /**
+     * The token "false".
+     */
+    public static final int FALSE = 5;
+
+    /**
+     * The token "rownum".
+     */
+public static final int ROWNUM = 6;
+
+    private ParserUtil() {
+        // utility class
+    }
+
+    /**
+     * Checks if this string is a SQL keyword.
+     *
+     * @param s the token to check
+     * @param supportOffsetFetch if OFFSET and FETCH are keywords
+     * @return true if it is a keyword
+     */
+    public static boolean isKeyword(String s, boolean supportOffsetFetch) {
+        if (s == null || s.length() == 0) {
+            return false;
+        }
+        return getSaveTokenType(s, supportOffsetFetch, false) != IDENTIFIER;
+    }
+
+    /**
+     * Is this a simple identifier (in the JDBC specification sense).
+     *
+     * @param s identifier to check
+     * @param functionsAsKeywords treat system functions as keywords
+     * @return is specified identifier may be used without quotes
+     * @throws NullPointerException if s is {@code null}
+     */
+    public static boolean isSimpleIdentifier(String s, boolean functionsAsKeywords) {
+        if (s.length() == 0) {
+            return false;
+        }
+        char c = s.charAt(0);
+        // lowercase a-z is quoted as well
+        if ((!Character.isLetter(c) && c != '_') || Character.isLowerCase(c)) {
+            return false;
+        }
+        for (int i = 1, length = s.length(); i < length; i++) {
+            c = s.charAt(i);
+            if ((!Character.isLetterOrDigit(c) && c != '_') ||
+                    Character.isLowerCase(c)) {
+                return false;
+            }
+        }
+        return getSaveTokenType(s, true, functionsAsKeywords) == IDENTIFIER;
+    }
+
+    /**
+     * Get the token type.
+     *
+     * @param s the token
+     * @param supportOffsetFetch whether offset / fetch are supported
+     * @param functionsAsKeywords whether "current data / time" functions are keywords
+     * @return the token type
+     */
+    public static int getSaveTokenType(String s, boolean supportOffsetFetch, boolean functionsAsKeywords) {
+        switch (s.charAt(0)) {
+        case 'A':
+            return getKeywordOrIdentifier(s, "ALL", KEYWORD);
+        case 'C':
+            if ("CHECK".equals(s)) {
+                return KEYWORD;
+            } else if ("CONSTRAINT".equals(s)) {
+                return KEYWORD;
+            } else if ("CROSS".equals(s)) {
+                return KEYWORD;
+            }
+            if (functionsAsKeywords) {
+                if ("CURRENT_DATE".equals(s) || "CURRENT_TIME".equals(s) || "CURRENT_TIMESTAMP".equals(s)) {
+                    return KEYWORD;
+                }
+            }
+            return IDENTIFIER;
+        case 'D':
+            return getKeywordOrIdentifier(s, "DISTINCT", KEYWORD);
+        case 'E':
+            if ("EXCEPT".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "EXISTS", KEYWORD);
+        case 'F':
+            if ("FROM".equals(s)) {
+                return KEYWORD;
+            } else if ("FOR".equals(s)) {
+                return KEYWORD;
+            } else if ("FOREIGN".equals(s)) {
+                return KEYWORD;
+            } else if ("FULL".equals(s)) {
+                return KEYWORD;
+            } else if (supportOffsetFetch && "FETCH".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "FALSE", FALSE);
+        case 'G':
+            return getKeywordOrIdentifier(s, "GROUP", KEYWORD);
+        case 'H':
+            return getKeywordOrIdentifier(s, "HAVING", KEYWORD);
+        case 'I':
+            if ("INNER".equals(s)) {
+                return KEYWORD;
+            } else if ("INTERSECT".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "IS", KEYWORD);
+        case 'J':
+            return getKeywordOrIdentifier(s, "JOIN", KEYWORD);
+        case 'L':
+            if ("LIMIT".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "LIKE", KEYWORD);
+        case 'M':
+            return getKeywordOrIdentifier(s, "MINUS", KEYWORD);
+        case 'N':
+            if ("NOT".equals(s)) {
+                return KEYWORD;
+            } else if ("NATURAL".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "NULL", NULL);
+        case 'O':
+            if ("ON".equals(s)) {
+                return KEYWORD;
+            } else if (supportOffsetFetch && "OFFSET".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "ORDER", KEYWORD);
+        case 'P':
+            return getKeywordOrIdentifier(s, "PRIMARY", KEYWORD);
+        case 'R':
+            return getKeywordOrIdentifier(s, "ROWNUM", ROWNUM);
+        case 'S':
+            if ("SELECT".equals(s)) {
+                return KEYWORD;
+            }
+            if (functionsAsKeywords) {
+                if ("SYSDATE".equals(s) || "SYSTIME".equals(s) || "SYSTIMESTAMP".equals(s)) {
+                    return KEYWORD;
+                }
+            }
+            return IDENTIFIER;
+        case 'T':
+            if ("TRUE".equals(s)) {
+                return TRUE;
+            }
+            if (functionsAsKeywords) {
+                if ("TODAY".equals(s)) {
+                    return KEYWORD;
+                }
+            }
+            return IDENTIFIER;
+        case 'U':
+            if ("UNIQUE".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "UNION", KEYWORD);
+        case 'W':
+            if ("WITH".equals(s)) {
+                return KEYWORD;
+            }
+            return getKeywordOrIdentifier(s, "WHERE", KEYWORD);
+        default:
+            return IDENTIFIER;
+        }
+    }
+
+    private static int getKeywordOrIdentifier(String s1, String s2,
+            int keywordType) {
+        if (s1.equals(s2)) {
+            return keywordType;
+        }
+        return IDENTIFIER;
+    }
+
+}

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

@@ -24,7 +24,6 @@ import org.h2.engine.Mode;
 import org.h2.engine.SysProperties;
 import org.h2.message.DbException;
 import org.h2.store.DataHandler;
-import org.h2.table.Column;
 import org.h2.tools.SimpleResultSet;
 import org.h2.util.Bits;
 import org.h2.util.DateTimeUtils;
@@ -604,7 +603,7 @@ public abstract class Value {
      * @return the converted value
      */
     public final Value convertTo(int targetType, int precision, Mode mode) {
-        return convertTo(targetType, precision, mode, null);
+        return convertTo(targetType, precision, mode, null, null);
     }
 
     /**
@@ -615,11 +614,12 @@ public abstract class Value {
      *        The special constant <code>-1</code> is used to indicate that
      *        the precision plays no role when converting the value
      * @param mode the conversion mode
-     * @param column the column that contains the ENUM datatype enumerators,
+     * @param column the column (if any), used for to improve the error message if conversion fails
+     * @param enumerators the ENUM datatype enumerators (if any),
      *        for dealing with ENUM conversions
      * @return the converted value
      */
-    public Value convertTo(int targetType, int precision, Mode mode, Column column) {
+    public Value convertTo(int targetType, int precision, Mode mode, Object column, String[] enumerators) {
         // converting NULL is done in ValueNull
         // converting BLOB to CLOB and vice versa is done in ValueLob
         if (getType() == targetType) {
@@ -938,11 +938,11 @@ public abstract class Value {
                     case INT:
                     case LONG:
                     case DECIMAL:
-                        return ValueEnum.get(column.getEnumerators(), getInt());
+                        return ValueEnum.get(enumerators, getInt());
                     case STRING:
                     case STRING_IGNORECASE:
                     case STRING_FIXED:
-                        return ValueEnum.get(column.getEnumerators(), getString());
+                        return ValueEnum.get(enumerators, getString());
                     default:
                         throw DbException.get(
                                 ErrorCode.DATA_CONVERSION_ERROR_1, getString());
@@ -1154,51 +1154,51 @@ public abstract class Value {
         return this;
     }
 
-    private static byte convertToByte(long x, Column col) {
+    private static byte convertToByte(long x, Object column) {
         if (x > Byte.MAX_VALUE || x < Byte.MIN_VALUE) {
             throw DbException.get(
-                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(col));
+                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(column));
         }
         return (byte) x;
     }
 
-    private static short convertToShort(long x, Column col) {
+    private static short convertToShort(long x, Object column) {
         if (x > Short.MAX_VALUE || x < Short.MIN_VALUE) {
             throw DbException.get(
-                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(col));
+                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(column));
         }
         return (short) x;
     }
 
-    private static int convertToInt(long x, Column col) {
+    private static int convertToInt(long x, Object column) {
         if (x > Integer.MAX_VALUE || x < Integer.MIN_VALUE) {
             throw DbException.get(
-                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(col));
+                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Long.toString(x), getColumnName(column));
         }
         return (int) x;
     }
 
-    private static long convertToLong(double x, Column col) {
+    private static long convertToLong(double x, Object column) {
         if (x > Long.MAX_VALUE || x < Long.MIN_VALUE) {
             // TODO document that +Infinity, -Infinity throw an exception and
             // NaN returns 0
             throw DbException.get(
-                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Double.toString(x), getColumnName(col));
+                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, Double.toString(x), getColumnName(column));
         }
         return Math.round(x);
     }
 
-    private static long convertToLong(BigDecimal x, Column col) {
+    private static long convertToLong(BigDecimal x, Object column) {
         if (x.compareTo(MAX_LONG_DECIMAL) > 0 ||
                 x.compareTo(Value.MIN_LONG_DECIMAL) < 0) {
             throw DbException.get(
-                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, x.toString(), getColumnName(col));
+                    ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_2, x.toString(), getColumnName(column));
         }
         return x.setScale(0, BigDecimal.ROUND_HALF_UP).longValue();
     }
 
-    private static String getColumnName(Column col) {
-        return col == null ? "" : col.getName();
+    private static String getColumnName(Object column) {
+        return column == null ? "" : column.toString();
     }
 
     /**

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

@@ -10,7 +10,6 @@ import java.sql.SQLException;
 import java.util.Arrays;
 import org.h2.engine.Mode;
 import org.h2.message.DbException;
-import org.h2.table.Column;
 import org.h2.util.StringUtils;
 import com.vividsolutions.jts.geom.CoordinateSequence;
 import com.vividsolutions.jts.geom.CoordinateSequenceFilter;
@@ -273,11 +272,11 @@ public class ValueGeometry extends Value {
     }
 
     @Override
-    public Value convertTo(int targetType, int precision, Mode mode, Column column) {
+    public Value convertTo(int targetType, int precision, Mode mode, Object column, String[] enumerators) {
         if (targetType == Value.JAVA_OBJECT) {
             return this;
         }
-        return super.convertTo(targetType, precision, mode, column);
+        return super.convertTo(targetType, precision, mode, column, null);
     }
 
     /**

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

@@ -14,6 +14,7 @@ import java.io.Reader;
 import java.nio.charset.StandardCharsets;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
+
 import org.h2.engine.Constants;
 import org.h2.engine.Mode;
 import org.h2.engine.SysProperties;
@@ -26,7 +27,6 @@ import org.h2.store.FileStoreOutputStream;
 import org.h2.store.RangeInputStream;
 import org.h2.store.RangeReader;
 import org.h2.store.fs.FileUtils;
-import org.h2.table.Column;
 import org.h2.util.IOUtils;
 import org.h2.util.MathUtils;
 import org.h2.util.SmallLRUCache;
@@ -499,12 +499,13 @@ public class ValueLob extends Value {
      *        The special constant <code>-1</code> is used to indicate that
      *        the precision plays no role when converting the value
      * @param mode the database mode
-     * @param column the column that contains the ENUM datatype enumerators,
+     * @param column the column (if any), used for to improve the error message if conversion fails
+     * @param enumerators the ENUM datatype enumerators (if any),
      *        for dealing with ENUM conversions
      * @return the converted value
      */
     @Override
-    public Value convertTo(int t, int precision, Mode mode, Column column) {
+    public Value convertTo(int t, int precision, Mode mode, Object column, String[] enumerators) {
         if (t == type) {
             return this;
         } else if (t == Value.CLOB) {
@@ -514,7 +515,7 @@ public class ValueLob extends Value {
             ValueLob copy = ValueLob.createBlob(getInputStream(), -1, handler);
             return copy;
         }
-        return super.convertTo(t, precision, mode, column);
+        return super.convertTo(t, precision, mode, column, null);
     }
 
     @Override

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

@@ -14,6 +14,7 @@ import java.io.Reader;
 import java.nio.charset.StandardCharsets;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
+
 import org.h2.engine.Constants;
 import org.h2.engine.Mode;
 import org.h2.engine.SysProperties;
@@ -26,7 +27,6 @@ import org.h2.store.FileStoreOutputStream;
 import org.h2.store.LobStorageFrontend;
 import org.h2.store.LobStorageInterface;
 import org.h2.store.fs.FileUtils;
-import org.h2.table.Column;
 import org.h2.util.IOUtils;
 import org.h2.util.MathUtils;
 import org.h2.util.StringUtils;
@@ -186,11 +186,13 @@ public class ValueLobDb extends Value implements Value.ValueClob,
      * @param t the new type
      * @param precision the precision
      * @param mode the mode
-     * @param column the column
+     * @param column the column (if any), used for to improve the error message if conversion fails
+     * @param enumerators the ENUM datatype enumerators (if any),
+     *        for dealing with ENUM conversions
      * @return the converted value
      */
     @Override
-    public Value convertTo(int t, int precision, Mode mode, Column column) {
+    public Value convertTo(int t, int precision, Mode mode, Object column, String[] enumerators) {
         if (t == type) {
             return this;
         } else if (t == Value.CLOB) {
@@ -210,7 +212,7 @@ public class ValueLobDb extends Value implements Value.ValueClob,
                 return ValueLobDb.createSmallLob(t, small);
             }
         }
-        return super.convertTo(t, precision, mode, column);
+        return super.convertTo(t, precision, mode, column, null);
     }
 
     @Override

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

@@ -13,9 +13,9 @@ import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.Time;
 import java.sql.Timestamp;
+
 import org.h2.engine.Mode;
 import org.h2.message.DbException;
-import org.h2.table.Column;
 
 /**
  * Implementation of NULL. NULL is not a regular data type.
@@ -133,7 +133,7 @@ public class ValueNull extends Value {
     }
 
     @Override
-    public Value convertTo(int type, int precision, Mode mode, Column column) {
+    public Value convertTo(int type, int precision, Mode mode, Object column, String[] enumerators) {
         return this;
     }
 

h2/src/test/org/h2/test/TestBase.java

@@ -464,6 +464,17 @@ public abstract class TestBase {
         throw new AssertionError(string);
     }
 
+   /**
+    * Log an error message.
+    *
+    * @param s the message
+    */
+   public static void logErrorMessage(String s) {
+       System.out.flush();
+       System.err.println("ERROR: " + s + "------------------------------");
+       logThrowable(s, null);
+   }
+
     /**
      * Log an error message.
      *
@@ -478,6 +489,10 @@ public abstract class TestBase {
         System.err.println("ERROR: " + s + " " + e.toString()
                 + " ------------------------------");
         e.printStackTrace();
+        logThrowable(null, e);
+    }
+
+    private static void logThrowable(String s, Throwable e) {
         // synchronize on this class, because file locks are only visible to
         // other JVMs
         synchronized (TestBase.class) {
@@ -494,9 +509,14 @@ public abstract class TestBase {
                 }
                 // append
                 FileWriter fw = new FileWriter("error.txt", true);
-                PrintWriter pw = new PrintWriter(fw);
-                e.printStackTrace(pw);
-                pw.close();
+                if (s != null) {
+                    fw.write(s);
+                }
+                if (e != null) {
+                    PrintWriter pw = new PrintWriter(fw);
+                    e.printStackTrace(pw);
+                    pw.close();
+                }
                 fw.close();
                 // unlock
                 lock.release();

h2/src/test/org/h2/test/db/AbstractBaseForCommonTableExpressions.java

@@ -17,7 +17,20 @@ import org.h2.test.TestBase;
  */
 public abstract class AbstractBaseForCommonTableExpressions extends TestBase {
 
-    protected void testRepeatedQueryWithSetup(int maxRetries, String[] expectedRowData, String[] expectedColumnNames,
+    /**
+     * Test a query.
+     *
+     * @param maxRetries the number of times the query is run
+     * @param expectedRowData the expected result data
+     * @param expectedColumnNames the expected columns of the result
+     * @param expectedNumberOfRows the expected number of rows
+     * @param setupSQL the SQL statement used for setup
+     * @param withQuery the query
+     * @param closeAndReopenDatabaseConnectionOnIteration whether the connection
+     *            should be re-opened each time
+     * @param expectedColumnTypes the expected datatypes of the result
+     */
+    void testRepeatedQueryWithSetup(int maxRetries, String[] expectedRowData, String[] expectedColumnNames,
             int expectedNumberOfRows, String setupSQL, String withQuery,
             int closeAndReopenDatabaseConnectionOnIteration, String[] expectedColumnTypes) throws SQLException {
 

h2/src/test/org/h2/test/db/TestOptimizations.java

@@ -68,7 +68,9 @@ public class TestOptimizations extends TestBase {
         testMultiColumnRangeQuery();
         testDistinctOptimization();
         testQueryCacheTimestamp();
-        testQueryCacheSpeed();
+        if (!config.lazy) {
+            testQueryCacheSpeed();
+        }
         testQueryCache(true);
         testQueryCache(false);
         testIn();
@@ -800,21 +802,28 @@ public class TestOptimizations extends TestBase {
     }
 
     private void testQuerySpeed(Statement stat, String sql) throws SQLException {
-        stat.execute("set OPTIMIZE_REUSE_RESULTS 0");
+        long totalTime = 0;
+        long totalTimeOptimized = 0;
+        for (int i = 0; i < 3; i++) {
+            totalTime += measureQuerySpeed(stat, sql, false);
+            totalTimeOptimized += measureQuerySpeed(stat, sql, true);
+        }
+        // System.out.println(
+        //         TimeUnit.NANOSECONDS.toMillis(totalTime) + " " +
+        //         TimeUnit.NANOSECONDS.toMillis(totalTimeOptimized));
+        if (totalTimeOptimized > totalTime) {
+            fail("not optimized: " + TimeUnit.NANOSECONDS.toMillis(totalTime) +
+                    " optimized: " + TimeUnit.NANOSECONDS.toMillis(totalTimeOptimized) +
+                    " sql:" + sql);
+        }
+    }
+
+    private long measureQuerySpeed(Statement stat, String sql, boolean optimized) throws SQLException {
+        stat.execute("set OPTIMIZE_REUSE_RESULTS " + (optimized ? "1" : "0"));
         stat.execute(sql);
         long time = System.nanoTime();
         stat.execute(sql);
-        time = System.nanoTime() - time;
-        stat.execute("set OPTIMIZE_REUSE_RESULTS 1");
-        stat.execute(sql);
-        long time2 = System.nanoTime();
-        stat.execute(sql);
-        time2 = System.nanoTime() - time2;
-        if (time2 > time * 2) {
-            fail("not optimized: " + TimeUnit.NANOSECONDS.toMillis(time) +
-                    " optimized: " + TimeUnit.NANOSECONDS.toMillis(time2) +
-                    " sql:" + sql);
-        }
+        return System.nanoTime() - time;
     }
 
     private void testQueryCache(boolean optimize) throws SQLException {

h2/src/test/org/h2/test/scripts/TestScript.java

@@ -41,6 +41,7 @@ public class TestScript extends TestBase {
     private boolean reconnectOften;
     private Connection conn;
     private Statement stat;
+    private String fileName;
     private LineNumberReader in;
     private int outputLineNo;
     private PrintStream out;
@@ -156,6 +157,7 @@ public class TestScript extends TestBase {
         // we processed.
         conn = null;
         stat = null;
+        fileName = null;
         in = null;
         outputLineNo = 0;
         out = null;
@@ -173,7 +175,7 @@ public class TestScript extends TestBase {
         conn.close();
         out.close();
         if (errors.length() > 0) {
-            throw new Exception("errors:\n" + errors.toString());
+            throw new Exception("errors in " + scriptFileName + " found");
         }
         // new File(outFile).delete();
     }
@@ -201,6 +203,7 @@ public class TestScript extends TestBase {
         if (is == null) {
             throw new IOException("could not find " + inFile);
         }
+        fileName = inFile;
         in = new LineNumberReader(new InputStreamReader(is, "Cp1252"));
         StringBuilder buff = new StringBuilder();
         while (true) {
@@ -436,17 +439,14 @@ public class TestScript extends TestBase {
                 if (reconnectOften && sql.toUpperCase().startsWith("EXPLAIN")) {
                     return;
                 }
-                errors.append("line: ");
-                errors.append(outputLineNo);
-                errors.append("\n" + "exp: ");
-                errors.append(compare);
-                errors.append("\n" + "got: ");
-                errors.append(s);
-                errors.append("\n");
+                errors.append(fileName).append('\n');
+                errors.append("line: ").append(outputLineNo).append('\n');
+                errors.append("exp: ").append(compare).append('\n');
+                errors.append("got: ").append(s).append('\n');
                 if (e != null) {
                     TestBase.logError("script", e);
                 }
-                TestBase.logError(errors.toString(), null);
+                TestBase.logErrorMessage(errors.toString());
                 if (failFast) {
                     conn.close();
                     System.exit(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,36 @@ 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('QUARTER', 1, DATE '2010-11-16');
+> DATE '2011-02-16'
+> -----------------
+> 2011-02-16
+> rows: 1
+
+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
+
+SELECT TIMESTAMPADD('DAY', 10, TIMESTAMP '2000-01-05 15:00:30.123456789');
+> TIMESTAMP '2000-01-15 15:00:30.123456789'
+> -----------------------------------------
+> 2000-01-15 15:00:30.123456789
+> rows: 1

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

@@ -194,3 +194,34 @@ SELECT DATEDIFF('WEEK', DATE '1969-12-28', DATE '1969-12-29'), DATEDIFF('ISO_WEE
 > - -
 > 0 1
 > rows: 1
+
+SELECT DATEDIFF('QUARTER', DATE '2009-12-30', DATE '2009-12-31');
+> 0
+> -
+> 0
+> rows: 1
+
+
+SELECT DATEDIFF('QUARTER', DATE '2010-01-01', DATE '2009-12-31');
+> -1
+> --
+> -1
+> rows: 1
+
+SELECT DATEDIFF('QUARTER', DATE '2010-01-01', DATE '2010-01-02');
+> 0
+> -
+> 0
+> rows: 1
+
+SELECT DATEDIFF('QUARTER', DATE '2010-01-01', DATE '2010-03-31');
+> 0
+> -
+> 0
+> rows: 1
+
+SELECT DATEDIFF('QUARTER', DATE '-1000-01-01', DATE '2000-01-01');
+> 12000
+> -----
+> 12000
+> 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
 

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

@@ -11,6 +11,8 @@ import java.util.GregorianCalendar;
 import org.h2.test.TestBase;
 import org.h2.util.DateTimeUtils;
 
+import static org.h2.util.DateTimeUtils.dateValue;
+
 /**
  * Unit tests for the DateTimeUtils class
  */
@@ -30,6 +32,7 @@ public class TestDateTimeUtils extends TestBase {
         testParseTimeNanosDB2Format();
         testDayOfWeek();
         testWeekOfYear();
+        testDateValueFromDenormalizedDate();
     }
 
     private void testParseTimeNanosDB2Format() {
@@ -45,7 +48,7 @@ public class TestDateTimeUtils extends TestBase {
      * {@link DateTimeUtils#getIsoDayOfWeek(long)}.
      */
     private void testDayOfWeek() {
-        GregorianCalendar gc = DateTimeUtils.createGregorianCalendar();
+        GregorianCalendar gc = DateTimeUtils.createGregorianCalendar(DateTimeUtils.UTC);
         for (int i = -1_000_000; i <= 1_000_000; i++) {
             gc.clear();
             gc.setTimeInMillis(i * 86400000L);
@@ -53,7 +56,7 @@ public class TestDateTimeUtils extends TestBase {
             if (gc.get(Calendar.ERA) == GregorianCalendar.BC) {
                 year = 1 - year;
             }
-            long expectedDateValue = DateTimeUtils.dateValue(year, gc.get(Calendar.MONTH) + 1,
+            long expectedDateValue = dateValue(year, gc.get(Calendar.MONTH) + 1,
                     gc.get(Calendar.DAY_OF_MONTH));
             long dateValue = DateTimeUtils.dateValueFromAbsoluteDay(i);
             assertEquals(expectedDateValue, dateValue);
@@ -63,7 +66,8 @@ public class TestDateTimeUtils extends TestBase {
             int isoDow = (dow + 5) % 7 + 1;
             assertEquals(isoDow, DateTimeUtils.getIsoDayOfWeek(dateValue));
             assertEquals(gc.get(Calendar.WEEK_OF_YEAR),
-                    DateTimeUtils.getWeekOfYear(dateValue, gc.getFirstDayOfWeek() - 1, gc.getMinimalDaysInFirstWeek()));
+                    DateTimeUtils.getWeekOfYear(dateValue, gc.getFirstDayOfWeek() - 1,
+                    gc.getMinimalDaysInFirstWeek()));
         }
     }
 
@@ -83,11 +87,23 @@ public class TestDateTimeUtils extends TestBase {
                     gc.clear();
                     gc.setTimeInMillis(i * 86400000L);
                     assertEquals(gc.get(Calendar.DAY_OF_YEAR), DateTimeUtils.getDayOfYear(dateValue));
-                    assertEquals(gc.get(Calendar.WEEK_OF_YEAR), DateTimeUtils.getWeekOfYear(dateValue, firstDay - 1, minimalDays));
+                    assertEquals(gc.get(Calendar.WEEK_OF_YEAR),
+                            DateTimeUtils.getWeekOfYear(dateValue, firstDay - 1, minimalDays));
                     assertEquals(gc.getWeekYear(), DateTimeUtils.getWeekYear(dateValue, firstDay - 1, minimalDays));
                 }
             }
         }
     }
 
+    /**
+     * Test for {@link DateTimeUtils#dateValueFromDenormalizedDate(long, long, int)}.
+     */
+    private void testDateValueFromDenormalizedDate() {
+        assertEquals(dateValue(2017, 1, 1), DateTimeUtils.dateValueFromDenormalizedDate(2018, -11, 0));
+        assertEquals(dateValue(2001, 2, 28), DateTimeUtils.dateValueFromDenormalizedDate(2000, 14, 29));
+        assertEquals(dateValue(1999, 8, 1), DateTimeUtils.dateValueFromDenormalizedDate(2000, -4, -100));
+        assertEquals(dateValue(2100, 12, 31), DateTimeUtils.dateValueFromDenormalizedDate(2100, 12, 2000));
+        assertEquals(dateValue(-100, 2, 29), DateTimeUtils.dateValueFromDenormalizedDate(-100, 2, 30));
+    }
+
 }

h2/src/tools/org/h2/build/Build.java

@@ -610,8 +610,8 @@ public class Build extends BuildBase {
             exclude("*.DS_Store");
         files = excludeTestMetaInfFiles(files);
         long kb = jar("bin/h2-client" + getJarSuffix(), files, "temp");
-        if (kb < 350 || kb > 450) {
-            throw new RuntimeException("Expected file size 350 - 450 KB, got: " + kb);
+        if (kb < 400 || kb > 500) {
+            throw new RuntimeException("Expected file size 400 - 500 KB, got: " + kb);
         }
     }
 

h2/src/tools/org/h2/build/doc/dictionary.txt

@@ -763,3 +763,6 @@ assorted reimplemented hangups confirmation predefined
 mdy destfile hclf forbids spellchecking selfdestruct expects accident jacocoagent cli historic mitigate
 jacoco xdata invokes sourcefiles classfiles duplication crypto stacktraces prt directions handled overly asm hardcoded
 interpolated thead
+
+die weekdiff osx subprocess dow proleptic
+