Bump webrick from 1.7.0 to 1.8.2 in /site

babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java

@@ -123,6 +123,7 @@ public static void main(String[] args) throws Exception {
                   ConnectionFactories.addType("TIMESTAMP", typeFactory ->
                       typeFactory.createSqlType(
                           SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)))
+              .with(CalciteConnectionProperty.TIME_ZONE, "UTC")
               .connect();
         case "scott-postgresql":
           return CalciteAssert.that()

babel/src/test/resources/sql/big-query.iq

@@ -410,14 +410,12 @@ SELECT
 # In the following example, EXTRACT returns values corresponding to
 # different date parts from a column of dates near the end of the
 # year.
-
-!if (false) {
 SELECT
   d,
   EXTRACT(ISOYEAR FROM d) AS isoyear,
-  EXTRACT(ISOWEEK FROM d) AS isoweek,
-  EXTRACT(YEAR FROM d) AS year,
-  EXTRACT(WEEK FROM d) AS week
+  EXTRACT(ISOWEEK FROM d) as isoweek,
+  EXTRACT(WEEK(TUESDAY) FROM d) AS week_tues,
+  EXTRACT(YEAR FROM d) AS year
 FROM UNNEST(
   ARRAY [DATE '2015-12-23',
          DATE '2015-12-24',
@@ -438,48 +436,62 @@ FROM UNNEST(
          DATE '2016-01-08',
          DATE '2016-01-09']) AS d
 ORDER BY d;
-+------------+---------+---------+------+------+
-| date       | isoyear | isoweek | year | week |
-+------------+---------+---------+------+------+
-| 2015-12-23 | 2015    | 52      | 2015 | 51   |
-| 2015-12-24 | 2015    | 52      | 2015 | 51   |
-| 2015-12-25 | 2015    | 52      | 2015 | 51   |
-| 2015-12-26 | 2015    | 52      | 2015 | 51   |
-| 2015-12-27 | 2015    | 52      | 2015 | 52   |
-| 2015-12-28 | 2015    | 53      | 2015 | 52   |
-| 2015-12-29 | 2015    | 53      | 2015 | 52   |
-| 2015-12-30 | 2015    | 53      | 2015 | 52   |
-| 2015-12-31 | 2015    | 53      | 2015 | 52   |
-| 2016-01-01 | 2015    | 53      | 2016 | 0    |
-| 2016-01-02 | 2015    | 53      | 2016 | 0    |
-| 2016-01-03 | 2015    | 53      | 2016 | 1    |
-| 2016-01-04 | 2016    | 1       | 2016 | 1    |
-| 2016-01-05 | 2016    | 1       | 2016 | 1    |
-| 2016-01-06 | 2016    | 1       | 2016 | 1    |
-| 2016-01-07 | 2016    | 1       | 2016 | 1    |
-| 2016-01-08 | 2016    | 1       | 2016 | 1    |
-| 2016-01-09 | 2016    | 1       | 2016 | 1    |
-+------------+---------+---------+------+------+
++------------+---------+---------+-----------+------+
+| d          | isoyear | isoweek | week_tues | year |
++------------+---------+---------+-----------+------+
+| 2015-12-23 |    2015 |      52 |        51 | 2015 |
+| 2015-12-24 |    2015 |      52 |        51 | 2015 |
+| 2015-12-25 |    2015 |      52 |        51 | 2015 |
+| 2015-12-26 |    2015 |      52 |        51 | 2015 |
+| 2015-12-27 |    2015 |      52 |        51 | 2015 |
+| 2015-12-28 |    2015 |      53 |        51 | 2015 |
+| 2015-12-29 |    2015 |      53 |        52 | 2015 |
+| 2015-12-30 |    2015 |      53 |        52 | 2015 |
+| 2015-12-31 |    2015 |      53 |        52 | 2015 |
+| 2016-01-01 |    2015 |      53 |         0 | 2016 |
+| 2016-01-02 |    2015 |      53 |         0 | 2016 |
+| 2016-01-03 |    2015 |      53 |         0 | 2016 |
+| 2016-01-04 |    2016 |       1 |         0 | 2016 |
+| 2016-01-05 |    2016 |       1 |         1 | 2016 |
+| 2016-01-06 |    2016 |       1 |         1 | 2016 |
+| 2016-01-07 |    2016 |       1 |         1 | 2016 |
+| 2016-01-08 |    2016 |       1 |         1 | 2016 |
+| 2016-01-09 |    2016 |       1 |         1 | 2016 |
++------------+---------+---------+-----------+------+
+(18 rows)
+
 !ok
-!}
+
 
 # In the following example, date_expression falls on a Sunday. EXTRACT
 # calculates the first column using weeks that begin on Sunday, and it
 # calculates the second column using weeks that begin on Monday.
 
-!if (false) {
 WITH t AS (SELECT DATE('2017-11-05') AS d)
 SELECT
   d,
+  EXTRACT(ISOWEEK FROM d) AS isoweek,
   EXTRACT(WEEK(SUNDAY) FROM d) AS week_sunday,
   EXTRACT(WEEK(MONDAY) FROM d) AS week_monday FROM t;
-+------------+-------------+-------------+
-| date       | week_sunday | week_monday |
-+------------+-------------+-------------+
-| 2017-11-05 | 45          | 44          |
-+------------+-------------+-------------+
++------------+---------+-------------+-------------+
+| d          | isoweek | week_sunday | week_monday |
++------------+---------+-------------+-------------+
+| 2017-11-05 |      44 |          45 |          44 |
++------------+---------+-------------+-------------+
+(1 row)
+
+!ok
+
+SELECT EXTRACT(DAYOFWEEK FROM DATE '2008-12-25') as dow,
+    EXTRACT(DAYOFYEAR FROM DATE '2008-12-25') as doy;
++-----+-----+
+| dow | doy |
++-----+-----+
+|   5 | 360 |
++-----+-----+
+(1 row)
+
 !ok
-!}
 
 # In the following example, EXTRACT returns a value corresponding to
 # the HOUR time part.
@@ -2716,6 +2728,18 @@ SELECT TIMESTAMP(DATE "2008-12-25") AS timestamp_date;
 
 !ok
 
+# This tests the no-op TIMESTAMP and DATETIME functions.
+select TIMESTAMP(TIMESTAMP "2008-01-01 01:03:05") as ts,
+       DATETIME(DATETIME "2008-01-01 01:03:05") as dt;
++---------------------+---------------------+
+| ts                  | dt                  |
++---------------------+---------------------+
+| 2008-01-01 01:03:05 | 2008-01-01 01:03:05 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
 # All these timestamps should be equal.
 # This tests the BQ timestamp literal string formatter
 # (optional 'T', optional leading zeros, optional offset with conversion).
@@ -3436,7 +3460,8 @@ SELECT
 (1 row)
 
 !ok
-
+# Bug.CALCITE_2539_FIXED
+!if (false) {
 #####################################################################
 # DATE_DIFF
 #
@@ -3747,6 +3772,8 @@ SELECT TIMESTAMP_DIFF(TIMESTAMP '2008-12-25', TIMESTAMP '2008-09-25', `quarter`)
 (1 row)
 
 !ok
+
+!}
 #####################################################################
 # DATE_TRUNC
 #

core/src/main/codegen/templates/Parser.jj

@@ -6167,6 +6167,15 @@ SqlTypeNameSpec DateTimeTypeName() :
         typeName = SqlTypeName.DATE;
         return new SqlBasicTypeNameSpec(typeName, getPos());
     }
+|
+    // DATETIME is the BigQuery-specific name for ISO SQL's TIMESTAMP type.
+    // In order to support this, the schema UDT map must be properly configued.
+    // See the BigQuery Quidem tests in the babel component for an example.
+    <DATETIME> {
+        s = span();
+        return new SqlUserDefinedTypeNameSpec(
+            unquotedIdentifier(), precision, s.end(this));
+    }
 |
     LOOKAHEAD(2)
     <TIME> { s = span(); }
@@ -6180,7 +6189,12 @@ SqlTypeNameSpec DateTimeTypeName() :
     precision = PrecisionOpt()
     typeName = TimeZoneOpt(false)
     {
-        return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));
+        // Like DATETIME above, TIMESTAMP may have a different meaning for
+        // certain SQL dialects (namely, BigQuery). Unlike DATETIME, TIMESTAMP
+        // types names have default standard types that will be used in the
+        // absence of a UDT mapping.
+        return new SqlUserDefinedTypeNameSpec(
+            typeName.getSpaceName(), precision, s.end(this));
     }
 }
 

core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java

@@ -869,8 +869,8 @@ void populate2() {
       // datetime
       define(DATETIME_PLUS, new DatetimeArithmeticImplementor());
       define(MINUS_DATE, new DatetimeArithmeticImplementor());
-      define(EXTRACT, new ExtractImplementor());
-      define(DATE_PART, new ExtractImplementor());
+      define(EXTRACT, new ExtractImplementor(true));
+      define(DATE_PART, new ExtractImplementor(false));
       define(FLOOR,
           new FloorImplementor(BuiltInMethod.FLOOR.method,
               BuiltInMethod.UNIX_TIMESTAMP_FLOOR.method,
@@ -3281,12 +3281,20 @@ private static class UnaryImplementor extends AbstractRexCallImplementor {
 
   /** Implementor for the {@code EXTRACT(unit FROM datetime)} function. */
   private static class ExtractImplementor extends AbstractRexCallImplementor {
-    ExtractImplementor() {
+
+    private final boolean supportDayOfWeek;
+
+    ExtractImplementor(boolean supportDayOfWeek) {
       super("extract", NullPolicy.STRICT, false);
+      this.supportDayOfWeek = supportDayOfWeek;
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
         final RexCall call, final List<Expression> argValueList) {
+      if (argValueList.get(0).getType() == String.class && supportDayOfWeek) {
+        return Expressions.call(BuiltInMethod.CUSTOM_DATE_EXTRACT.method,
+            translator.getRoot(), argValueList.get(0), argValueList.get(1));
+      }
       // May need to convert the first argument from a String to a TimeUnitRange
       final Object timeUnitRangeObj = translator.getLiteralValue(argValueList.get(0));
       final TimeUnitRange timeUnitRange;

core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactory.java

@@ -32,7 +32,7 @@ MetaColumn createColumn(Table table, String tableCat, String tableSchem,
       String tableName, String columnName, int dataType, String typeName,
       Integer columnSize, @Nullable Integer decimalDigits, int numPrecRadix,
       int nullable, Integer charOctetLength, int ordinalPosition,
-      String isNullable);
+      String isNullable, String isAutoincrement, String isGeneratedcolumn);
 
   /** Returns the list of expected column names.
    *

core/src/main/java/org/apache/calcite/jdbc/CalciteMetaColumnFactoryImpl.java

@@ -46,7 +46,9 @@ protected CalciteMetaColumnFactoryImpl() {}
       int nullable,
       Integer charOctetLength,
       int ordinalPosition,
-      String isNullable) {
+      String isNullable,
+      String isAutoincrement,
+      String isGeneratedcolumn) {
     return new MetaColumn(
         tableCat,
         tableSchem,
@@ -60,7 +62,9 @@ protected CalciteMetaColumnFactoryImpl() {}
         nullable,
         charOctetLength,
         ordinalPosition,
-        isNullable);
+        isNullable,
+        isAutoincrement,
+        isGeneratedcolumn);
   }
 
   @Override public Class<? extends MetaColumn> getMetaColumnClass() {

core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java

@@ -566,7 +566,11 @@ public Enumerable<MetaColumn> columns(final MetaTable table_) {
                   : DatabaseMetaData.columnNoNulls,
               precision,
               field.getIndex() + 1,
-              field.getType().isNullable() ? "YES" : "NO");
+              field.getType().isNullable() ? "YES" : "NO",
+              "NO",
+              field.getType().getSqlTypeName() == SqlTypeName.MEASURE
+                  ? "YES"
+                  : "NO");
         });
   }
 

core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java

@@ -512,9 +512,8 @@ public Aggregate.AggCallBinding createBinding(
     final RelDataTypeFactory typeFactory =
         aggregateRelBase.getCluster().getTypeFactory();
 
-    if (aggFunction.getKind() == SqlKind.PERCENTILE_DISC
-        || aggFunction.getKind() == SqlKind.PERCENTILE_CONT) {
-      assert collation.getKeys().size() == 1;
+    if (this.argList.size() == 1 && (aggFunction.getKind() == SqlKind.PERCENTILE_DISC
+        || aggFunction.getKind() == SqlKind.PERCENTILE_CONT)) {
       return new Aggregate.PercentileDiscAggCallBinding(typeFactory,
           aggFunction, SqlTypeUtil.projectTypes(rowType, argList),
           SqlTypeUtil.projectTypes(rowType, collation.getKeys()).get(0),

core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java

@@ -629,6 +629,7 @@ public Object toJson(RexNode node) {
         }
         map.put("operands", list);
         switch (node.getKind()) {
+        case TIMESTAMP_DIFF:
         case MINUS:
         case CAST:
         case SAFE_CAST:

core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java

@@ -16,7 +16,6 @@
  */
 package org.apache.calcite.rel.rel2sql;
 
-import org.apache.calcite.config.CalciteSystemProperty;
 import org.apache.calcite.linq4j.Ord;
 import org.apache.calcite.linq4j.tree.Expressions;
 import org.apache.calcite.plan.RelOptUtil;
@@ -95,7 +94,6 @@
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.ImmutableBitSet;
-import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.RangeSets;
 import org.apache.calcite.util.Sarg;
@@ -578,6 +576,8 @@ private boolean requiresAlias(SqlNode node) {
     case JOIN:
     case EXPLICIT_TABLE:
       return false;
+    case SELECT:
+      return node instanceof SqlSelect; // TODO workaround asIs hack
     default:
       return true;
     }
@@ -625,17 +625,9 @@ protected Context(SqlDialect dialect, int fieldCount, boolean ignoreCast) {
      */
     public SqlNode orderField(int ordinal) {
       final SqlNode node = field(ordinal);
-      if (node instanceof SqlNumericLiteral
-          && dialect.getConformance().isSortByOrdinal()) {
-        // An integer literal will be wrongly interpreted as a field ordinal.
-        // Convert it to a character literal, which will have the same effect.
-        final String strValue = ((SqlNumericLiteral) node).toValue();
-        return SqlLiteral.createCharString(strValue, node.getParserPosition());
-      }
-      if (node instanceof SqlCall
-          && dialect.getConformance().isSortByOrdinal()) {
-        // If the field is expression and sort by ordinal is set in dialect,
-        // convert it to ordinal.
+      if (!(node instanceof SqlIdentifier) && dialect.getConformance().shouldSortByOrdinal()) {
+        // If the dialect allows sorting by ordinal, and the field is anything but a named field
+        // reference, prefer to sort by ordinal instead.
         return SqlLiteral.createExactNumeric(
             Integer.toString(ordinal + 1), SqlParserPos.ZERO);
       }
@@ -1478,20 +1470,8 @@ public static SqlNode toSql(RexLiteral literal) {
             () -> "literal " + literal
                 + " has null SqlTypeFamily, and is SqlTypeName is " + typeName);
     switch (family) {
-    case CHARACTER: {
-      final NlsString value = literal.getValueAs(NlsString.class);
-      if (value != null) {
-        final String defaultCharset = CalciteSystemProperty.DEFAULT_CHARSET.value();
-        final String charsetName = value.getCharsetName();
-        if (!defaultCharset.equals(charsetName)) {
-          // Set the charset only if it is not the same as the default charset
-          return SqlLiteral.createCharString(
-              castNonNull(value).getValue(), charsetName, POS);
-        }
-      }
-      // Create a string without specifying a charset
+    case CHARACTER:
       return SqlLiteral.createCharString((String) castNonNull(literal.getValue2()), POS);
-    }
     case NUMERIC:
     case EXACT_NUMERIC: {
       if (SqlTypeName.APPROX_TYPES.contains(typeName)) {

core/src/main/java/org/apache/calcite/rel/type/TimeFrameSet.java

@@ -287,6 +287,41 @@ public long diffTimestamp(long timestamp, long timestamp2, TimeFrame frame) {
     return timestamp;
   }
 
+  /** For ISOWEEK and WEEK(WEEKDAY), EXTRACT can be rewritten
+   * as the composition of DATE_DIFF and DATE_TRUNC. DAYOFWEEK and DAYOFYEAR
+   * are just translated to DOW and DOY respectively. */
+  public long extractDate(int date, TimeFrame timeFrame) {
+    TimeUnitRange timeUnitRange;
+    int offset = 0;
+    // Date will be truncated to either ISOYEAR or YEAR depending on time frame.
+    switch (timeFrame.name()) {
+    case "DAYOFWEEK":
+      return DateTimeUtils.unixDateExtract(TimeUnitRange.DOW, date);
+    case "DAYOFYEAR":
+      return DateTimeUtils.unixDateExtract(TimeUnitRange.DOY, date);
+    case "ISOWEEK":
+      timeUnitRange = TimeUnitRange.ISOYEAR;
+      offset += 1;
+      break;
+    default:
+      if (TimeFrames.WEEK_FRAME_NAMES.contains(timeFrame.name())) {
+        timeUnitRange = TimeUnitRange.YEAR;
+      } else {
+        throw new IllegalArgumentException("Unsupported frame for EXTRACT: " + timeFrame.name());
+      }
+      break;
+    }
+    // Date is truncated first to year/isoyear and then to the provided time frame.
+    int y0 = (int) DateTimeUtils.unixDateFloor(timeUnitRange, date);
+    int date2 = floorDate(y0, timeFrame);
+
+    // For WEEK(WEEKDAY), if year starts on WEEKDAY then offset of +1 is required.
+    if (date2 == y0 && timeUnitRange != TimeUnitRange.ISOYEAR) {
+      offset += 1;
+    }
+    return (long) diffDate(date2, date, timeFrame) + offset;
+  }
+
   /** Builds a collection of time frames. */
   public interface Builder {
     /** Creates a {@code TimeFrameSet}. */