You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by jh...@apache.org on 2017/03/04 21:03:20 UTC

[01/10] calcite git commit: Remove tabs and trailing spaces

Repository: calcite
Updated Branches:
  refs/heads/master 952214a24 -> f85469156


Remove tabs and trailing spaces


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/33f9d0f3
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/33f9d0f3
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/33f9d0f3

Branch: refs/heads/master
Commit: 33f9d0f3ee2219b64b8aaccd3e2f73b1b3c937da
Parents: 4a3df4e
Author: Julian Hyde <jh...@apache.org>
Authored: Thu Mar 2 13:52:47 2017 -0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Fri Mar 3 10:13:29 2017 -0800

----------------------------------------------------------------------
 site/_docs/file_adapter.md | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/33f9d0f3/site/_docs/file_adapter.md
----------------------------------------------------------------------
diff --git a/site/_docs/file_adapter.md b/site/_docs/file_adapter.md
index 270eea1..b47d72a 100644
--- a/site/_docs/file_adapter.md
+++ b/site/_docs/file_adapter.md
@@ -36,8 +36,8 @@ You can then write a query like:
 
 {% highlight sql %}
 select
-	count(*) "City Count",
-	sum(100 * c."Population" / s."Population") "Pct State Population"
+    count(*) "City Count",
+    sum(100 * c."Population" / s."Population") "Pct State Population"
 from "Cities" c, "States" s
 where c."State" = s."State" and s."State" = 'California';
 {% endhighlight %}
@@ -148,7 +148,7 @@ sqlline> select * from sales.emps;
 | 120   | 20     | Wilma |
 | 130   | 40     | Alice |
 +-------+--------+------+
-5 rows selected 
+5 rows selected
 {% endhighlight %}
 
 # Mapping tables
@@ -162,8 +162,8 @@ Tables can be simply defined for immediate gratification:
 
 {% highlight json %}
 {
-	tableName: "RawCities",
-	url: "http://en.wikipedia.org/wiki/List_of_United_States_cities_by_population"
+  tableName: "RawCities",
+  url: "http://en.wikipedia.org/wiki/List_of_United_States_cities_by_population"
 }
 {% endhighlight %}
 
@@ -171,21 +171,21 @@ And subsequently refined for better usability / querying:
 
 {% highlight json %}
 {
-	tableName: "Cities",
-	url: "http://en.wikipedia.org/wiki/List_of_United_States_cities_by_population",
-	path: "#mw-content-text > table.wikitable.sortable",
-	index: 0,
-	fieldDefs: [
-	  {th: "2012 rank", name: "Rank", type: "int", pattern: "(\\d+)", matchGroup: 0},
-	  {th: "City", selector: "a", selectedElement: 0},
-	  {th: "State[5]", name: "State", selector: "a:eq(0)"},
-	  {th: "2012 estimate", name: "Population", type: "double"},
-	  {th: "2010 Census", skip: "true"},
-	  {th: "Change", skip: "true"},
-	  {th: "2012 land area", name: "Land Area (sq mi)", type: "double", selector: ":not(span)"},
-	  {th: "2012 population density", skip: "true"},
-	  {th: "ANSI", skip: "true"}
-	]
+  tableName: "Cities",
+  url: "http://en.wikipedia.org/wiki/List_of_United_States_cities_by_population",
+  path: "#mw-content-text > table.wikitable.sortable",
+  index: 0,
+  fieldDefs: [
+    {th: "2012 rank", name: "Rank", type: "int", pattern: "(\\d+)", matchGroup: 0},
+    {th: "City", selector: "a", selectedElement: 0},
+    {th: "State[5]", name: "State", selector: "a:eq(0)"},
+    {th: "2012 estimate", name: "Population", type: "double"},
+    {th: "2010 Census", skip: "true"},
+    {th: "Change", skip: "true"},
+    {th: "2012 land area", name: "Land Area (sq mi)", type: "double", selector: ":not(span)"},
+    {th: "2012 population density", skip: "true"},
+    {th: "ANSI", skip: "true"}
+  ]
 }
 {% endhighlight %}
 


[08/10] calcite git commit: [CALCITE-1641] Add parser and validator support for MATCH_RECOGNIZE (Zhiqiang-He)

Posted by jh...@apache.org.
http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index eb2ea3b..5ae0def 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -50,6 +50,7 @@ import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlJoin;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlMerge;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
@@ -74,6 +75,7 @@ import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlOperandTypeInference;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.sql.util.SqlBasicVisitor;
 import org.apache.calcite.sql.util.SqlShuttle;
 import org.apache.calcite.sql.util.SqlVisitor;
 import org.apache.calcite.util.BitString;
@@ -90,6 +92,7 @@ import com.google.common.base.Function;
 import com.google.common.base.Joiner;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 
@@ -964,6 +967,10 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     return orderScopes.get(select);
   }
 
+  public SqlValidatorScope getMatchRecognizeScope(SqlMatchRecognize node) {
+    return scopes.get(node);
+  }
+
   public SqlValidatorScope getJoinScope(SqlNode node) {
     return scopes.get(stripAs(node));
   }
@@ -1788,6 +1795,37 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     return true;
   }
 
+  private void registerMatchRecognize(
+      SqlValidatorScope parentScope,
+      SqlValidatorScope usingScope,
+      SqlMatchRecognize call,
+      SqlNode enclosingNode,
+      String alias,
+      boolean forceNullable) {
+
+    final MatchRecognizeNamespace matchRecognizeNamespace =
+        createMatchRecognizeNameSpace(call, enclosingNode);
+    registerNamespace(usingScope, alias, matchRecognizeNamespace, forceNullable);
+
+    final MatchRecognizeScope matchRecognizeScope =
+        new MatchRecognizeScope(parentScope, call);
+    scopes.put(call, matchRecognizeScope);
+
+    // parse input query
+    SqlNode expr = call.getTableRef();
+    SqlNode newExpr = registerFrom(usingScope, matchRecognizeScope, expr,
+        expr, null, null, forceNullable);
+    if (expr != newExpr) {
+      call.setOperand(0, newExpr);
+    }
+  }
+
+  protected MatchRecognizeNamespace createMatchRecognizeNameSpace(
+      SqlMatchRecognize call,
+      SqlNode enclosingNode) {
+    return new MatchRecognizeNamespace(this, call, enclosingNode);
+  }
+
   /**
    * Registers a new namespace, and adds it as a child of its parent scope.
    * Derived class can override this method to tinker with namespaces as they
@@ -1872,6 +1910,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
       case UNNEST:
       case OTHER_FUNCTION:
       case COLLECTION_TABLE:
+      case MATCH_RECOGNIZE:
 
         // give this anonymous construct a name since later
         // query processing stages rely on it
@@ -1925,7 +1964,10 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
             false);
       }
       return node;
-
+    case MATCH_RECOGNIZE:
+      registerMatchRecognize(parentScope, usingScope,
+        (SqlMatchRecognize) node, enclosingNode, alias, forceNullable);
+      return node;
     case TABLESAMPLE:
       call = (SqlCall) node;
       expr = call.operand(0);
@@ -4244,6 +4286,85 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     inWindow = false;
   }
 
+  @Override public void validateMatchRecognize(SqlCall call) {
+    SqlMatchRecognize matchRecognize = (SqlMatchRecognize) call;
+    final MatchRecognizeScope scope =
+        (MatchRecognizeScope) getMatchRecognizeScope(matchRecognize);
+
+    final MatchRecognizeNamespace ns =
+        getNamespace(call).unwrap(MatchRecognizeNamespace.class);
+    assert ns.rowType == null;
+
+    // retrieve pattern variables used in pattern and subset
+    SqlNode pattern = matchRecognize.getPattern();
+    PatternVarVisitor visitor = new PatternVarVisitor(scope);
+    pattern.accept(visitor);
+
+    validateDefinitions(matchRecognize, scope);
+    ns.setType(getNamespace(matchRecognize.getTableRef()).getRowType());
+  }
+
+  private void validateDefinitions(SqlMatchRecognize mr,
+      MatchRecognizeScope scope) {
+    final Set<String> aliases = new HashSet<>();
+    for (SqlNode item : mr.getPatternDefList().getList()) {
+      final String alias = alias(item);
+      if (!aliases.add(alias)) {
+        throw newValidationError(item,
+            Static.RESOURCE.PatternVarAlreadyDefined(alias));
+      }
+      scope.addPatternVar(alias);
+    }
+
+    final List<SqlNode> sqlNodes = new ArrayList<>();
+    for (SqlNode item : mr.getPatternDefList().getList()) {
+      final String alias = alias(item);
+      SqlNode expand = expand(item, scope);
+      expand = navigationInDefine(expand, alias);
+      setOriginal(expand, item);
+
+      inferUnknownTypes(booleanType, scope, expand);
+      expand.validate(this, scope);
+
+      // Some extra work need required here.
+      // In PREV, NEXT, FINAL and LAST, only one pattern variable is allowed.
+      sqlNodes.add(
+          SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO, expand,
+              new SqlIdentifier(alias, SqlParserPos.ZERO)));
+
+      final RelDataType type = deriveType(scope, expand);
+      if (!SqlTypeUtil.inBooleanFamily(type)) {
+        throw newValidationError(expand, RESOURCE.condMustBeBoolean("DEFINE"));
+      }
+      setValidatedNodeType(item, type);
+    }
+
+    SqlNodeList list =
+        new SqlNodeList(sqlNodes, mr.getPatternDefList().getParserPosition());
+    inferUnknownTypes(unknownType, scope, list);
+    for (SqlNode node : list) {
+      validateExpr(node, scope);
+    }
+    mr.setOperand(SqlMatchRecognize.OPERAND_PATTERN_DEFINES, list);
+  }
+
+  private static String alias(SqlNode item) {
+    assert item instanceof SqlCall;
+    final SqlIdentifier identifier = ((SqlCall) item).operand(1);
+    return identifier.getSimple();
+  }
+
+  /**
+   * check all pattern var within one function is the same
+   */
+  private SqlNode navigationInDefine(SqlNode node, String alpha) {
+    Set<String> prefix = node.accept(new PatternValidator(false));
+    Util.discard(prefix);
+    node = new NavigationExpander().go(node);
+    node = new NavigationReplacer(alpha).go(node);
+    return node;
+  }
+
   public void validateAggregateParams(SqlCall aggCall, SqlNode filter,
       SqlValidatorScope scope) {
     // For "agg(expr)", expr cannot itself contain aggregate function
@@ -4411,6 +4532,30 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     throw new UnsupportedOperationException();
   }
 
+  private static boolean isPhysicalNavigation(SqlKind kind) {
+    return kind == SqlKind.PREV || kind == SqlKind.NEXT;
+  }
+
+  private static boolean isLogicalNavigation(SqlKind kind) {
+    return kind == SqlKind.FIRST || kind == SqlKind.LAST;
+  }
+
+  private static boolean isAggregation(SqlKind kind) {
+    return kind == SqlKind.SUM || kind == SqlKind.SUM0
+        || kind == SqlKind.AVG || kind == SqlKind.COUNT
+        || kind == SqlKind.MAX || kind == SqlKind.MIN;
+  }
+
+  private static boolean isRunningOrFinal(SqlKind kind) {
+    return kind == SqlKind.RUNNING || kind == SqlKind.FINAL;
+  }
+
+  private static boolean isSingleVarRequired(SqlKind kind) {
+    return isPhysicalNavigation(kind)
+        || isLogicalNavigation(kind)
+        || isAggregation(kind);
+  }
+
   //~ Inner Classes ----------------------------------------------------------
 
   /**
@@ -4492,6 +4637,49 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
   }
 
   /**
+   * retrieve pattern variables defined
+   */
+  private class PatternVarVisitor implements SqlVisitor<Void> {
+    private MatchRecognizeScope scope;
+    public PatternVarVisitor(MatchRecognizeScope scope) {
+      this.scope = scope;
+    }
+
+    @Override public Void visit(SqlLiteral literal) {
+      return null;
+    }
+
+    @Override public Void visit(SqlCall call) {
+      for (int i = 0; i < call.getOperandList().size(); i++) {
+        call.getOperandList().get(i).accept(this);
+      }
+      return null;
+    }
+
+    @Override public Void visit(SqlNodeList nodeList) {
+      throw Util.needToImplement(nodeList);
+    }
+
+    @Override public Void visit(SqlIdentifier id) {
+      Preconditions.checkArgument(id.isSimple());
+      scope.addPatternVar(id.getSimple());
+      return null;
+    }
+
+    @Override public Void visit(SqlDataTypeSpec type) {
+      throw Util.needToImplement(type);
+    }
+
+    @Override public Void visit(SqlDynamicParam param) {
+      throw Util.needToImplement(param);
+    }
+
+    @Override public Void visit(SqlIntervalQualifier intervalQualifier) {
+      throw Util.needToImplement(intervalQualifier);
+    }
+  }
+
+  /**
    * Visitor which derives the type of a given {@link SqlNode}.
    *
    * <p>Each method must return the derived type. This visitor is basically a
@@ -4824,6 +5012,256 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     }
   }
 
+  /**
+   * Modify the nodes in navigation function
+   * such as FIRST, LAST, PREV AND NEXT.
+   */
+  private class NavigationModifier extends SqlBasicVisitor<SqlNode> {
+    @Override public SqlNode visit(SqlLiteral literal) {
+      return literal;
+    }
+
+    @Override public SqlNode visit(SqlIntervalQualifier intervalQualifier) {
+      return intervalQualifier;
+    }
+
+    @Override public SqlNode visit(SqlDataTypeSpec type) {
+      return type;
+    }
+
+    @Override public SqlNode visit(SqlDynamicParam param) {
+      return param;
+    }
+
+    public SqlNode go(SqlNode node) {
+      return node.accept(this);
+    }
+  }
+
+  /**
+   * Expand navigation expression :
+   * eg: PREV(A.price + A.amount) to PREV(A.price) + PREV(A.amount)
+   * eg: FIRST(A.price * 2) to FIST(A.PRICE) * 2
+   */
+  private class NavigationExpander extends NavigationModifier {
+    SqlOperator currentOperator;
+    SqlNode currentOffset;
+
+    public NavigationExpander() {
+
+    }
+
+    public NavigationExpander(SqlOperator operator, SqlNode offset) {
+      this.currentOffset = offset;
+      this.currentOperator = operator;
+    }
+
+    @Override public SqlNode visit(SqlCall call) {
+      SqlKind kind = call.getKind();
+      List<SqlNode> operands = call.getOperandList();
+      List<SqlNode> newOperands = new ArrayList<>();
+      if (isLogicalNavigation(kind) || isPhysicalNavigation(kind)) {
+        SqlNode inner = operands.get(0);
+        SqlNode offset = operands.get(1);
+
+        // merge two straight prev/next, update offset
+        if (isPhysicalNavigation(kind)) {
+          SqlKind innerKind = inner.getKind();
+          if (isPhysicalNavigation(innerKind)) {
+            List<SqlNode> innerOperands = ((SqlCall) inner).getOperandList();
+            SqlNode innerOffset = innerOperands.get(1);
+            SqlOperator newOperator = innerKind == kind
+              ? SqlStdOperatorTable.PLUS : SqlStdOperatorTable.MINUS;
+            offset = newOperator.createCall(SqlParserPos.ZERO,
+              offset, innerOffset);
+            inner = call.getOperator().createCall(SqlParserPos.ZERO,
+              innerOperands.get(0), offset);
+          }
+        }
+        return inner.accept(new NavigationExpander(call.getOperator(), offset));
+      }
+
+      for (SqlNode node : operands) {
+        SqlNode newNode = node.accept(new NavigationExpander());
+        if (currentOperator != null) {
+          newNode = currentOperator.createCall(SqlParserPos.ZERO, newNode, currentOffset);
+        }
+        newOperands.add(newNode);
+      }
+      return call.getOperator().createCall(SqlParserPos.ZERO, newOperands);
+    }
+
+    @Override public SqlNode visit(SqlIdentifier id) {
+      if (currentOperator == null) {
+        return id;
+      } else {
+        return currentOperator.createCall(SqlParserPos.ZERO, id, currentOffset);
+      }
+    }
+  }
+
+  /**
+   * Replace {@code A as A.price > PREV(B.price)}
+   * with {@code PREV(A.price, 0) > last(B.price, 0)}.
+   */
+  private class NavigationReplacer extends NavigationModifier {
+    private final String alpha;
+
+    public NavigationReplacer(String alpha) {
+      this.alpha = alpha;
+    }
+
+    @Override public SqlNode visit(SqlCall call) {
+      SqlKind kind = call.getKind();
+      if (isLogicalNavigation(kind)
+          || isAggregation(kind)
+          || isRunningOrFinal(kind)) {
+        return call;
+      }
+
+      List<SqlNode> operands = call.getOperandList();
+      switch (kind) {
+      case PREV:
+        String name = ((SqlIdentifier) operands.get(0)).names.get(0);
+        return name.equals(alpha) ? call
+          : SqlStdOperatorTable.LAST.createCall(SqlParserPos.ZERO, operands);
+      default:
+        List<SqlNode> newOperands = new ArrayList<>();
+        for (SqlNode op : operands) {
+          newOperands.add(op.accept(this));
+        }
+        return call.getOperator().createCall(SqlParserPos.ZERO, newOperands);
+      }
+    }
+
+    @Override public SqlNode visit(SqlIdentifier id) {
+      if (id.isSimple()) {
+        return id;
+      }
+      SqlOperator operator = id.names.get(0).equals(alpha)
+        ? SqlStdOperatorTable.PREV : SqlStdOperatorTable.LAST;
+
+      return operator.createCall(SqlParserPos.ZERO, id,
+        SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO));
+    }
+  }
+
+  /**
+   * Within one navigation function, the pattern var should be same
+   */
+  private class PatternValidator extends SqlBasicVisitor<Set<String>> {
+    private final boolean isMeasure;
+    int firstLastCount;
+    int prevNextCount;
+    int aggregateCount;
+
+    PatternValidator(boolean isMeasure) {
+      this(isMeasure, 0, 0, 0);
+    }
+
+    PatternValidator(boolean isMeasure, int firstLastCount, int prevNextCount,
+        int aggregateCount) {
+      this.isMeasure = isMeasure;
+      this.firstLastCount = firstLastCount;
+      this.prevNextCount = prevNextCount;
+      this.aggregateCount = aggregateCount;
+    }
+
+    @Override public Set<String> visit(SqlCall call) {
+      boolean isSingle = false;
+      Set<String> vars = new HashSet<>();
+      SqlKind kind = call.getKind();
+      List<SqlNode> operands = call.getOperandList();
+
+      if (isSingleVarRequired(kind)) {
+        isSingle = true;
+        if (isPhysicalNavigation(kind)) {
+          if (isMeasure) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternPrevFunctionInMeasure(call.toString()));
+          }
+          if (firstLastCount != 0) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternPrevFunctionOrder(call.toString()));
+          }
+          prevNextCount++;
+        } else if (isLogicalNavigation(kind)) {
+          if (firstLastCount != 0) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternPrevFunctionOrder(call.toString()));
+          }
+          firstLastCount++;
+        } else if (isAggregation(kind)) {
+          // cannot apply aggregation in PREV/NEXT, FIRST/LAST
+          if (firstLastCount != 0 || prevNextCount != 0) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternAggregationInNavigation(call.toString()));
+          }
+          if (kind == SqlKind.COUNT && call.getOperandList().size() > 1) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternCountFunctionArg());
+          }
+          aggregateCount++;
+        }
+      }
+
+      if (isRunningOrFinal(kind) && isMeasure) {
+        throw newValidationError(call,
+            Static.RESOURCE.PatternRunningFunctionInDefine(call.toString()));
+      }
+
+      for (SqlNode node : operands) {
+        vars.addAll(
+            node.accept(
+                new PatternValidator(isMeasure, firstLastCount, prevNextCount,
+                    aggregateCount)));
+      }
+
+      if (isSingle) {
+        switch (kind) {
+        case COUNT:
+          if (vars.size() > 1) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternFunctionVariableCheck(call.toString()));
+          }
+          break;
+        default:
+          if (vars.size() != 1) {
+            throw newValidationError(call,
+                Static.RESOURCE.PatternCountFunctionArg());
+          }
+          break;
+        }
+      }
+      return vars;
+    }
+
+    @Override public Set<String> visit(SqlIdentifier identifier) {
+      boolean check = prevNextCount > 0 || firstLastCount > 0 || aggregateCount > 0;
+      Set<String> vars = new HashSet<>();
+      if (identifier.names.size() > 1 && check) {
+        vars.add(identifier.names.get(0));
+      }
+      return vars;
+    }
+
+    @Override public Set<String> visit(SqlLiteral literal) {
+      return ImmutableSet.of();
+    }
+
+    @Override public Set<String> visit(SqlIntervalQualifier qualifier) {
+      return ImmutableSet.of();
+    }
+
+    @Override public Set<String> visit(SqlDataTypeSpec type) {
+      return ImmutableSet.of();
+    }
+
+    @Override public Set<String> visit(SqlDynamicParam param) {
+      return ImmutableSet.of();
+    }
+  }
+
   //~ Enums ------------------------------------------------------------------
 
   /**

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java b/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
index 0579d4a..e6e0ee0 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
@@ -35,6 +35,7 @@ import org.apache.calcite.rel.logical.LogicalCorrelate;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalMatch;
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
@@ -673,6 +674,10 @@ public class RelStructuredTypeFlattener implements ReflectiveVisitor {
     rewriteGeneric(rel);
   }
 
+  public void rewriteRel(LogicalMatch rel) {
+    rewriteGeneric(rel);
+  }
+
   /** Generates expressions that reference the flattened input fields from
    * a given row type. */
   private void flattenInputs(List<RelDataTypeField> fieldList, RexNode prefix,

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index f6e20e1..e832f19 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -107,6 +107,7 @@ import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlJoin;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlMerge;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
@@ -185,6 +186,7 @@ import java.util.Collections;
 import java.util.Deque;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -1903,6 +1905,10 @@ public class SqlToRelConverter {
     final SqlCall call;
     final SqlNode[] operands;
     switch (from.getKind()) {
+    case MATCH_RECOGNIZE:
+      convertMatchRecognize(bb, (SqlCall) from);
+      return;
+
     case AS:
       convertFrom(bb, ((SqlCall) from).operand(0));
       return;
@@ -2075,6 +2081,74 @@ public class SqlToRelConverter {
     }
   }
 
+  protected void convertMatchRecognize(Blackboard bb, SqlCall call) {
+    final SqlMatchRecognize matchRecognize = (SqlMatchRecognize) call;
+    final SqlValidatorNamespace ns = validator.getNamespace(matchRecognize);
+    final SqlValidatorScope scope = validator.getMatchRecognizeScope(matchRecognize);
+
+    final Blackboard mrBlackBoard = createBlackboard(scope, null, false);
+    final RelDataType rowType = ns.getRowType();
+    // convert inner query, could be a table name or a derived table
+    SqlNode expr = matchRecognize.getTableRef();
+    convertFrom(mrBlackBoard, expr);
+    final RelNode input = mrBlackBoard.root;
+
+    // convert pattern
+    final Set<String> patternVarsSet = new HashSet<>();
+    SqlNode pattern = matchRecognize.getPattern();
+    final SqlBasicVisitor<RexNode> patternVarVisitor =
+      new SqlBasicVisitor<RexNode>() {
+        @Override public RexNode visit(SqlCall call) {
+          List<SqlNode> operands = call.getOperandList();
+          List<RexNode> newOperands = Lists.newArrayList();
+          for (SqlNode node : operands) {
+            newOperands.add(node.accept(this));
+          }
+          return rexBuilder.makeCall(
+            validator.getUnknownType(), call.getOperator(), newOperands);
+        }
+
+        @Override public RexNode visit(SqlIdentifier id) {
+          assert id.isSimple();
+          patternVarsSet.add(id.getSimple());
+          return rexBuilder.makeLiteral(id.getSimple());
+        }
+
+        @Override public RexNode visit(SqlLiteral literal) {
+          if (literal instanceof SqlNumericLiteral) {
+            return rexBuilder.makeExactLiteral(BigDecimal.valueOf(literal.intValue(true)));
+          } else {
+            return rexBuilder.makeLiteral(literal.booleanValue());
+          }
+        }
+      };
+    final RexNode patternNode = pattern.accept(patternVarVisitor);
+
+    mrBlackBoard.setPatternVarRef(true);
+
+    // convert definitions
+    final ImmutableMap.Builder<String, RexNode> definitionNodes =
+        ImmutableMap.builder();
+    for (SqlNode def : matchRecognize.getPatternDefList()) {
+      List<SqlNode> operands = ((SqlCall) def).getOperandList();
+      String alias = ((SqlIdentifier) operands.get(1)).getSimple();
+      RexNode rex = mrBlackBoard.convertExpression(operands.get(0));
+      definitionNodes.put(alias, rex);
+    }
+
+    mrBlackBoard.setPatternVarRef(false);
+
+    final RelFactories.MatchFactory factory =
+        RelFactories.DEFAULT_MATCH_FACTORY;
+    final RelNode rel =
+        factory.createMatchRecognize(input, patternNode,
+            matchRecognize.getStrictStart().booleanValue(),
+            matchRecognize.getStrictEnd().booleanValue(),
+            definitionNodes.build(),
+            rowType);
+    bb.setRoot(rel, false);
+  }
+
   protected void convertCollectionTable(
       Blackboard bb,
       SqlCall call) {
@@ -3302,6 +3376,11 @@ public class SqlToRelConverter {
       return bb.convertExpression(call);
     }
 
+    String pv = null;
+    if (bb.isPatternVarRef && identifier.names.size() > 1) {
+      pv = identifier.names.get(0);
+    }
+
     final SqlQualified qualified;
     if (bb.scope != null) {
       qualified = bb.scope.fullyQualify(identifier);
@@ -3695,6 +3774,8 @@ public class SqlToRelConverter {
     private final Map<CorrelationId, RexFieldAccess> mapCorrelateToRex =
         new HashMap<>();
 
+    private boolean isPatternVarRef = false;
+
     final List<RelNode> cursors = new ArrayList<>();
 
     /**
@@ -3749,6 +3830,10 @@ public class SqlToRelConverter {
       this.top = top;
     }
 
+    public void setPatternVarRef(boolean isVarRef) {
+      this.isPatternVarRef = isVarRef;
+    }
+
     public RexNode register(
         RelNode rel,
         JoinRelType joinType) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
index 94795bb..7d6a313 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
@@ -257,7 +257,14 @@ public class StandardConvertletTable extends ReflectiveConvertletTable {
             return cx.convertExpression(expanded);
           }
         });
-
+    registerOp(
+      SqlStdOperatorTable.PATTERN_DEFINE_AS,
+      new SqlRexConvertlet() {
+        public RexNode convertCall(SqlRexContext cx, SqlCall call) {
+          SqlNode expanded = call.operand(0);
+          return cx.convertExpression(expanded);
+        }
+      });
     // "SQRT(x)" is equivalent to "POWER(x, .5)"
     registerOp(
         SqlStdOperatorTable.SQRT,

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
----------------------------------------------------------------------
diff --git a/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties b/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
index ed3d96b..792ba2a 100644
--- a/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
+++ b/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
@@ -215,4 +215,11 @@ MinusNotAllowed=MINUS is not allowed under the current SQL conformance level
 SelectMissingFrom=SELECT must have a FROM clause
 GroupFunctionMustAppearInGroupByClause=Group function ''{0}'' can only appear in GROUP BY clause
 AuxiliaryWithoutMatchingGroupCall=Call to auxiliary group function ''{0}'' must have matching call to group function ''{1}'' in GROUP BY clause
+PatternVarAlreadyDefined=Pattern variable ''{0}'' has already been defined
+PatternPrevFunctionInMeasure=Cannot use PREV/NEXT in MEASURE ''{0}''
+PatternPrevFunctionOrder=Cannot nest PREV/NEXT under LAST/FIRST ''{0}''
+PatternAggregationInNavigation=Cannot use aggregation in navigation ''{0}''
+PatternCountFunctionArg=Invalid number of parameters to COUNT method
+PatternRunningFunctionInDefine=Cannot use RUNNING/FINAL in DEFINE ''{0}''
+PatternFunctionVariableCheck=Multiple pattern variables in ''{0}''
 # End CalciteResource.properties

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java b/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
index ddc997d..f843e51 100644
--- a/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
+++ b/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
@@ -44,6 +44,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import static org.apache.calcite.sql.SqlFunctionCategory.MATCH_RECOGNIZE;
 import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR;
 import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_FUNCTION;
 import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_PROCEDURE;
@@ -95,7 +96,7 @@ public class LookupOperatorOverloadsTest {
       }
     }
     check(cats, USER_DEFINED_TABLE_FUNCTION,
-        USER_DEFINED_TABLE_SPECIFIC_FUNCTION);
+        USER_DEFINED_TABLE_SPECIFIC_FUNCTION, MATCH_RECOGNIZE);
   }
 
   @Test public void testIsSpecific() throws SQLException {

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
index 52bcab5..b6d4780 100644
--- a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
@@ -574,6 +574,356 @@ public class RelToSqlConverterTest {
         .ok(expected);
   }
 
+  @Test public void testMatchRecognizePatternExpression() {
+    String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression2() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+$)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" + $)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression3() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (^strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (^ \"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression4() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (^strt down+ up+$)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (^ \"STRT\" \"DOWN\" + \"UP\" + $)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression5() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down* up?)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" * \"UP\" ?)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression6() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt {-down-} up?)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" {- \"DOWN\" -} \"UP\" ?)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression7() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down{2} up{3,})\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" { 2 } \"UP\" { 3, })\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression8() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down{,2} up{3,5})\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" { , 2 } \"UP\" { 3, 5 })\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression9() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt {-down+-} {-up*-})\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" {- \"DOWN\" + -} {- \"UP\" * -})\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression10() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (A B C | A C B | B A C | B C A | C A B | C B A)\n"
+        + "    define\n"
+        + "      A as A.\"net_weight\" < PREV(A.\"net_weight\"),\n"
+        + "      B as B.\"net_weight\" > PREV(B.\"net_weight\"),\n"
+        + "      C as C.\"net_weight\" < PREV(C.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"A\" \"B\" \"C\" | \"A\" \"C\" \"B\" "
+        + "| \"B\" \"A\" \"C\" | \"B\" \"C\" \"A\" "
+        + "| \"C\" \"A\" \"B\" | \"C\" \"B\" \"A\")\n"
+        + "DEFINE "
+        + "\"A\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"B\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1), "
+        + "\"C\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression11() {
+    final String sql = "select *\n"
+        + "  from (select * from \"product\") match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression12() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr order by MR.\"net_weight\"";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))\n"
+        + "ORDER BY \"net_weight\"";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizePatternExpression13() {
+    final String sql = "select *\n"
+        + "  from (\n"
+        + "select *\n"
+        + "from \"sales_fact_1997\" as s\n"
+        + "join \"customer\" as c using (\"customer_id\")\n"
+        + "join \"product\" as p using (\"product_id\")\n"
+        + "join \"product_class\" as pc using (\"product_class_id\")\n"
+        + "where c.\"city\" = 'San Francisco'\n"
+        + "and pc.\"product_department\" = 'Snacks'"
+        + ") match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > prev(up.\"net_weight\")\n"
+        + "  ) mr order by MR.\"net_weight\"";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"sales_fact_1997\"\n"
+        + "INNER JOIN \"foodmart\".\"customer\" "
+        + "ON \"sales_fact_1997\".\"customer_id\" = \"customer\".\"customer_id\"\n"
+        + "INNER JOIN \"foodmart\".\"product\" "
+        + "ON \"sales_fact_1997\".\"product_id\" = \"product\".\"product_id\"\n"
+        + "INNER JOIN \"foodmart\".\"product_class\" "
+        + "ON \"product\".\"product_class_id\" = \"product_class\".\"product_class_id\"\n"
+        + "WHERE \"customer\".\"city\" = 'San Francisco' "
+        + "AND \"product_class\".\"product_department\" = 'Snacks') "
+        + "MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > PREV(\"net_weight\", 1))\n"
+        + "ORDER BY \"net_weight\"";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > NEXT(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > NEXT(PREV(\"net_weight\", 0), 1))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause2() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < FIRST(down.\"net_weight\"),\n"
+        + "      up as up.\"net_weight\" > LAST(up.\"net_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < FIRST(\"net_weight\", 0), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > LAST(\"net_weight\", 0))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause3() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\",1),\n"
+        + "      up as up.\"net_weight\" > LAST(up.\"net_weight\" + up.\"gross_weight\")\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > "
+        + "LAST(\"net_weight\", 0) + LAST(\"gross_weight\", 0))";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause4() {
+    final String sql = "select *\n"
+        + "  from \"product\" match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.\"net_weight\" < PREV(down.\"net_weight\",1),\n"
+        + "      up as up.\"net_weight\" > "
+        + "PREV(LAST(up.\"net_weight\" + up.\"gross_weight\"),3)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"foodmart\".\"product\") MATCH_RECOGNIZE(\n"
+        + "PATTERN (\"STRT\" \"DOWN\" + \"UP\" +)\n"
+        + "DEFINE "
+        + "\"DOWN\" AS PREV(\"net_weight\", 0) < PREV(\"net_weight\", 1), "
+        + "\"UP\" AS PREV(\"net_weight\", 0) > "
+        + "LAST(\"net_weight\", 0) + LAST(\"gross_weight\", 0))";
+    sql(sql).ok(expected);
+  }
+
   /** Fluid interface to run tests. */
   private static class Sql {
     private CalciteAssert.SchemaSpec schemaSpec;

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java b/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
index 9c47a4f..b3fa2fc 100644
--- a/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
@@ -190,6 +190,7 @@ public class SqlParserTest {
       "DEFAULT",                            "92", "99", "2003", "2011", "c",
       "DEFERRABLE",                         "92", "99",
       "DEFERRED",                           "92", "99",
+      "DEFINE",                                                           "c",
       "DELETE",                             "92", "99", "2003", "2011", "c",
       "DENSE_RANK",                                             "2011", "c",
       "DEPTH",                                    "99",
@@ -303,6 +304,7 @@ public class SqlParserTest {
       "LOWER",                              "92",               "2011", "c",
       "MAP",                                      "99",
       "MATCH",                              "92", "99", "2003", "2011", "c",
+      "MATCH_RECOGNIZE",                                                "c",
       "MAX",                                "92",               "2011", "c",
       "MAX_CARDINALITY",                                        "2011",
       "MEMBER",                                         "2003", "2011", "c",
@@ -357,15 +359,18 @@ public class SqlParserTest {
       "PARTIAL",                            "92", "99",
       "PARTITION",                                "99", "2003", "2011", "c",
       "PATH",                               "92", "99",
+      "PATTERN",                                                          "c",
       "PERCENTILE_CONT",                                        "2011", "c",
       "PERCENTILE_DISC",                                        "2011", "c",
       "PERCENT_RANK",                                           "2011", "c",
+      "PERMUTE",                                                        "c",
       "POSITION",                           "92",               "2011", "c",
       "POSITION_REGEX",                                         "2011",
       "POWER",                                                  "2011", "c",
       "PRECISION",                          "92", "99", "2003", "2011", "c",
       "PREPARE",                            "92", "99", "2003", "2011", "c",
       "PRESERVE",                           "92", "99",
+      "PREV",                                                             "c",
       "PRIMARY",                            "92", "99", "2003", "2011", "c",
       "PRIOR",                              "92", "99",
       "PRIVILEGES",                         "92", "99",
@@ -407,6 +412,7 @@ public class SqlParserTest {
       "ROW",                                      "99", "2003", "2011", "c",
       "ROWS",                               "92", "99", "2003", "2011", "c",
       "ROW_NUMBER",                                             "2011", "c",
+      "RUNNING",                                                          "c",
       "SAVEPOINT",                                "99", "2003", "2011", "c",
       "SCHEMA",                             "92", "99",
       "SCOPE",                                    "99", "2003", "2011", "c",
@@ -7104,6 +7110,292 @@ public class SqlParserTest {
             + "VALUES (ROW(1, (CURRENT VALUE FOR `MY_SEQ`)))");
   }
 
+  @Test public void testMatchRecognize1() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` +)) (`UP` +)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize2() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+$)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` +)) (`UP` +)) $)\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize3() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (^strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (^ ((`STRT` (`DOWN` +)) (`UP` +)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize4() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (^strt down+ up+$)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (^ ((`STRT` (`DOWN` +)) (`UP` +)) $)\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize5() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down* up?)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` *)) (`UP` ?)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize6() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt {-down-} up?)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` ({- `DOWN` -})) (`UP` ?)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize7() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down{2} up{3,})\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` { 2 })) (`UP` { 3, })))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize8() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down{,2} up{3,5})\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` { , 2 })) (`UP` { 3, 5 })))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize9() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt {-down+-} {-up*-})\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > prev(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` ({- (`DOWN` +) -})) ({- (`UP` *) -})))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize10() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern ( A B C | A C B | B A C | B C A | C A B | C B A)\n"
+        + "    define\n"
+        + "      A as A.price > PREV(A.price),\n"
+        + "      B as B.price < prev(B.price),\n"
+        + "      C as C.price > prev(C.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN ((((((((`A` `B`) `C`) | ((`A` `C`) `B`)) | ((`B` `A`) `C`)) "
+        + "| ((`B` `C`) `A`)) | ((`C` `A`) `B`)) | ((`C` `B`) `A`)))\n"
+        + "DEFINE "
+        + "`A` AS (`A`.`PRICE` > (PREV(`A`.`PRICE`, 1))), "
+        + "`B` AS (`B`.`PRICE` < (PREV(`B`.`PRICE`, 1))), "
+        + "`C` AS (`C`.`PRICE` > (PREV(`C`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognize11() {
+    final String sql = "select *\n"
+        + "  from t match_recognize (\n"
+        + "    pattern ( \"a\" \"b c\")\n"
+        + "    define\n"
+        + "      \"A\" as A.price > PREV(A.price),\n"
+        + "      \"b c\" as \"b c\".foo\n"
+        + "  ) as mr(c1, c2) join e as x on foo = baz";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN ((`a` `b c`))\n"
+        + "DEFINE `A` AS (`A`.`PRICE` > (PREV(`A`.`PRICE`, 1))),"
+        + " `b c` AS `b c`.`FOO`) AS `MR` (`C1`, `C2`)\n"
+        + "INNER JOIN `E` AS `X` ON (`FOO` = `BAZ`)";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price),\n"
+        + "      up as up.price > NEXT(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` +)) (`UP` +)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (NEXT(`UP`.`PRICE`, 1)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause2() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.price < FIRST(down.price),\n"
+        + "      up as up.price > LAST(up.price)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` +)) (`UP` +)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (FIRST(`DOWN`.`PRICE`, 0))), "
+        + "`UP` AS (`UP`.`PRICE` > (LAST(`UP`.`PRICE`, 0)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause3() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price,1),\n"
+        + "      up as up.price > LAST(up.price + up.TAX)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` +)) (`UP` +)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (LAST((`UP`.`PRICE` + `UP`.`TAX`), 0)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
+  @Test public void testMatchRecognizeDefineClause4() {
+    final String sql = "select *\n"
+        + "  from t match_recognize\n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define\n"
+        + "      down as down.price < PREV(down.price,1),\n"
+        + "      up as up.price > PREV(LAST(up.price + up.TAX),3)\n"
+        + "  ) mr";
+    final String expected = "SELECT *\n"
+        + "FROM `T` MATCH_RECOGNIZE(\n"
+        + "PATTERN (((`STRT` (`DOWN` +)) (`UP` +)))\n"
+        + "DEFINE "
+        + "`DOWN` AS (`DOWN`.`PRICE` < (PREV(`DOWN`.`PRICE`, 1))), "
+        + "`UP` AS (`UP`.`PRICE` > (PREV((LAST((`UP`.`PRICE` + `UP`.`TAX`), 0)), 3)))"
+        + ") AS `MR`";
+    sql(sql).ok(expected);
+  }
+
   //~ Inner Interfaces -------------------------------------------------------
 
   /**

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
index 76bfc51..24aae33 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
@@ -175,11 +175,13 @@ public class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(PERCENT_RANK)",
           "KEYWORD(POSITION)",
           "KEYWORD(POWER)",
+          "KEYWORD(PREV)",
           "KEYWORD(RANK)",
           "KEYWORD(REGR_SXX)",
           "KEYWORD(REGR_SYY)",
           "KEYWORD(ROW)",
           "KEYWORD(ROW_NUMBER)",
+          "KEYWORD(RUNNING)",
           "KEYWORD(SECOND)",
           "KEYWORD(SESSION_USER)",
           "KEYWORD(SPECIFIC)",
@@ -301,6 +303,7 @@ public class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(HAVING)",
           "KEYWORD(LEFT)",
           "KEYWORD(EXCEPT)",
+          "KEYWORD(MATCH_RECOGNIZE)",
           "KEYWORD(MINUS)",
           "KEYWORD(JOIN)",
           "KEYWORD(WINDOW)",

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index 938d4c7..f218064 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -7936,12 +7936,19 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
         + "DEFAULT -\n"
         + "ITEM -\n"
         + "NEXT_VALUE -\n"
+        + "PATTERN_EXCLUDE -\n"
+        + "PATTERN_PERMUTE -\n"
         + "\n"
+        + "PATTERN_QUANTIFIER -\n"
+        + "\n"
+        + " left\n"
         + "$LiteralChain -\n"
         + "+ pre\n"
         + "- pre\n"
         + ". left\n"
         + "\n"
+        + "| left\n"
+        + "\n"
         + "* left\n"
         + "/ left\n"
         + "/INT left\n"
@@ -7997,6 +8004,7 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
         + "AS -\n"
         + "DESC post\n"
         + "OVER left\n"
+        + "PATTERN_DEFINE_AS -\n"
         + "TABLESAMPLE -\n"
         + "\n"
         + "INTERSECT left\n"
@@ -8935,6 +8943,103 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
         + "from orders\n"
         + "group by session(rowtime, interval '1' hour)").ok();
   }
+
+  /** Tries to create a calls to some internal operators in
+   * MATCH_RECOGNIZE. Should fail. */
+  @Test public void testMatchRecognizeInternals() throws Exception {
+    sql("values ^pattern_define_as(1, 2)^")
+        .fails("No match found for function signature .*");
+    sql("values ^pattern_exclude(1, 2)^")
+        .fails("No match found for function signature .*");
+    sql("values ^\"|\"(1, 2)^")
+        .fails("No match found for function signature .*");
+    if (TODO) {
+      // FINAL and other functions should not be visible outside of
+      // MATCH_RECOGNIZE
+      sql("values ^\"FINAL\"(1, 2)^")
+          .fails("No match found for function signature .*");
+      sql("values ^\"RUNNING\"(1, 2)^")
+          .fails("No match found for function signature .*");
+      sql("values ^\"FIRST\"(1, 2)^")
+          .fails("No match found for function signature .*");
+      sql("values ^\"LAST\"(1, 2)^")
+          .fails("No match found for function signature .*");
+      sql("values ^\"PREV\"(1, 2)^")
+          .fails("No match found for function signature .*");
+    }
+  }
+
+  @Test public void testMatchRecognizeDefines() throws Exception {
+    final String sql = "select *\n"
+      + "  from emp match_recognize (\n"
+      + "    pattern (strt down+ up+)\n"
+      + "    define\n"
+      + "      down as down.sal < PREV(down.sal),\n"
+      + "      up as up.sal > PREV(up.sal)\n"
+      + "  ) mr";
+    sql(sql).ok();
+  }
+
+  @Test public void testMatchRecognizeDefines2() throws Exception {
+    final String sql = "select *\n"
+      + "  from t match_recognize (\n"
+      + "    pattern (strt down+ up+)\n"
+      + "    define\n"
+      + "      down as down.price < PREV(down.price),\n"
+      + "      ^down as up.price > PREV(up.price)^\n"
+      + "  ) mr";
+    sql(sql).fails("Pattern variable 'DOWN' has already been defined");
+  }
+
+  @Test public void testMatchRecognizeDefines3() throws Exception {
+    final String sql = "select *\n"
+      + "  from emp match_recognize (\n"
+      + "    pattern (strt down+up+)\n"
+      + "    define\n"
+      + "      down as down.sal < PREV(down.sal),\n"
+      + "      up as up.sal > PREV(up.sal)\n"
+      + "  ) mr";
+    sql(sql).ok();
+  }
+
+  @Test public void testMatchRecognizeDefines4() throws Exception {
+    final String sql = "select * \n"
+        + "  from emp match_recognize \n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define \n"
+        + "      down as down.sal < PREV(down.sal),\n"
+        + "      up as up.sal > FIRST(^PREV(up.sal)^)\n"
+        + "  ) mr";
+    sql(sql)
+        .fails("Cannot nest PREV/NEXT under LAST/FIRST 'PREV\\(`UP`\\.`SAL`, 1\\)'");
+  }
+
+  @Test public void testMatchRecognizeDefines5() throws Exception {
+    final String sql = "select * \n"
+        + "  from emp match_recognize \n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define \n"
+        + "      down as down.sal < PREV(down.sal),\n"
+        + "      up as up.sal > FIRST(^FIRST(up.sal)^)\n"
+        + "  ) mr";
+    sql(sql)
+        .fails("Cannot nest PREV/NEXT under LAST/FIRST 'FIRST\\(`UP`\\.`SAL`, 0\\)'");
+  }
+
+  @Test public void testMatchRecognizeDefines6() throws Exception {
+    final String sql = "select * \n"
+        + "  from emp match_recognize \n"
+        + "  (\n"
+        + "    pattern (strt down+ up+)\n"
+        + "    define \n"
+        + "      down as down.sal < PREV(down.sal),\n"
+        + "      up as up.sal > ^COUNT(down.sal, up.sal)^\n"
+        + "  ) mr";
+    sql(sql)
+        .fails("Invalid number of parameters to COUNT method");
+  }
 }
 
 // End SqlValidatorTest.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/site/_docs/reference.md
----------------------------------------------------------------------
diff --git a/site/_docs/reference.md b/site/_docs/reference.md
index 53d00c5..f5f4f6e 100644
--- a/site/_docs/reference.md
+++ b/site/_docs/reference.md
@@ -139,6 +139,7 @@ joinCondition:
 
 tableReference:
       tablePrimary
+      [ matchRecognize ]
       [ [ AS ] alias [ '(' columnAlias [, columnAlias ]* ')' ] ]
 
 tablePrimary:
@@ -359,6 +360,7 @@ DECADE,
 DEFAULTS,
 DEFERRABLE,
 DEFERRED,
+**DEFINE**,
 DEFINED,
 DEFINER,
 DEGREE,
@@ -495,6 +497,7 @@ M,
 MAP,
 **MATCH**,
 MATCHED,
+**MATCH_RECOGNIZE**,
 **MAX**,
 MAXVALUE,
 **MEMBER**,
@@ -572,9 +575,11 @@ PARTIAL,
 PASCAL,
 PASSTHROUGH,
 PATH,
+**PATTERN**,
 **PERCENTILE_CONT**,
 **PERCENTILE_DISC**,
 **PERCENT_RANK**,
+**PERMUTE**,
 PLACING,
 PLAN,
 PLI,
@@ -584,6 +589,7 @@ PRECEDING,
 **PRECISION**,
 **PREPARE**,
 PRESERVE,
+**PREV**,
 **PRIMARY**,
 PRIOR,
 PRIVILEGES,
@@ -635,6 +641,7 @@ ROUTINE_SCHEMA,
 **ROWS**,
 ROW_COUNT,
 **ROW_NUMBER**,
+**RUNNING**,
 **SAVEPOINT**,
 SCALE,
 SCHEMA,
@@ -929,8 +936,8 @@ The operator precedence and associativity, highest to lowest.
 | string1 NOT LIKE string2 [ ESCAPE string3 ]       | Whether *string1* does not match pattern *string2*
 | string1 SIMILAR TO string2 [ ESCAPE string3 ]     | Whether *string1* matches regular expression *string2*
 | string1 NOT SIMILAR TO string2 [ ESCAPE string3 ] | Whether *string1* does not match regular expression *string2*
-| value IN (value [, value]* )                      | Whether *value* is equal to a value in a list
-| value NOT IN (value [, value]* )                  | Whether *value* is not equal to every value in a list
+| value IN (value [, value]*)                       | Whether *value* is equal to a value in a list
+| value NOT IN (value [, value]*)                   | Whether *value* is not equal to every value in a list
 | value IN (sub-query)                              | Whether *value* is equal to a row returned by *sub-query*
 | value NOT IN (sub-query)                          | Whether *value* is not equal to every row returned by *sub-query*
 | EXISTS (sub-query)                                | Whether *sub-query* returns at least one row
@@ -1075,7 +1082,7 @@ Not implemented:
 | CASE value<br/>WHEN value1 [, value11 ]* THEN result1<br/>[ WHEN valueN [, valueN1 ]* THEN resultN ]*<br/>[ ELSE resultZ ]<br/> END | Simple case
 | CASE<br/>WHEN condition1 THEN result1<br/>[ WHEN conditionN THEN resultN ]*<br/>[ ELSE resultZ ]<br/>END | Searched case
 | NULLIF(value, value) | Returns NULL if the values are the same.<br/><br/>For example, <code>NULLIF(5, 5)</code> returns NULL; <code>NULLIF(5, 0)</code> returns 5.
-| COALESCE(value, value [, value ]* ) | Provides a value if the first value is null.<br/><br/>For example, <code>COALESCE(NULL, 5)</code> returns 5.
+| COALESCE(value, value [, value ]*) | Provides a value if the first value is null.<br/><br/>For example, <code>COALESCE(NULL, 5)</code> returns 5.
 
 ### Type conversion
 
@@ -1087,8 +1094,8 @@ Not implemented:
 
 | Operator syntax | Description
 |:--------------- |:-----------
-| ROW (value [, value]* ) | Creates a row from a list of values.
-| (value [, value]* )     | Creates a row from a list of values.
+| ROW (value [, value ]*)  | Creates a row from a list of values.
+| (value [, value ]* )     | Creates a row from a list of values.
 | map '[' key ']'     | Returns the element of a map with a particular key.
 | array '[' index ']' | Returns the element at a particular location in an array.
 | ARRAY '[' value [, value ]* ']' | Creates an array from a list of values.
@@ -1205,8 +1212,8 @@ Syntax:
 
 {% highlight sql %}
 aggregateCall:
-        agg( [ DISTINCT ] value [, value]* ) [ FILTER ( WHERE condition ) ]
-    |   agg(*) [ FILTER ( WHERE condition ) ]
+        agg( [ ALL | DISTINCT ] value [, value ]*) [ FILTER (WHERE condition) ]
+    |   agg(*) [ FILTER (WHERE condition) ]
 {% endhighlight %}
 
 If `FILTER` is present, the aggregate function only considers rows for which
@@ -1217,17 +1224,17 @@ passed to the aggregate function.
 
 | Operator syntax                    | Description
 |:---------------------------------- |:-----------
-| COLLECT( [ DISTINCT ] value)       | Returns a multiset of the values
-| COUNT( [ DISTINCT ] value [, value]* ) | Returns the number of input rows for which *value* is not null (wholly not null if *value* is composite)
+| COLLECT( [ ALL &#124; DISTINCT ] value)       | Returns a multiset of the values
+| COUNT( [ ALL &#124; DISTINCT ] value [, value ]*) | Returns the number of input rows for which *value* is not null (wholly not null if *value* is composite)
 | COUNT(*)                           | Returns the number of input rows
-| AVG( [ DISTINCT ] numeric)         | Returns the average (arithmetic mean) of *numeric* across all input values
-| SUM( [ DISTINCT ] numeric)         | Returns the sum of *numeric* across all input values
-| MAX( [ DISTINCT ] value)           | Returns the maximum value of *value* across all input values
-| MIN( [ DISTINCT ] value)           | Returns the minimum value of *value* across all input values
-| STDDEV_POP( [ DISTINCT ] numeric)  | Returns the population standard deviation of *numeric* across all input values
-| STDDEV_SAMP( [ DISTINCT ] numeric) | Returns the sample standard deviation of *numeric* across all input values
-| VAR_POP( [ DISTINCT ] value)       | Returns the population variance (square of the population standard deviation) of *numeric* across all input values
-| VAR_SAMP( [ DISTINCT ] numeric)    | Returns the sample variance (square of the sample standard deviation) of *numeric* across all input values
+| AVG( [ ALL &#124; DISTINCT ] numeric)         | Returns the average (arithmetic mean) of *numeric* across all input values
+| SUM( [ ALL &#124; DISTINCT ] numeric)         | Returns the sum of *numeric* across all input values
+| MAX( [ ALL &#124; DISTINCT ] value)           | Returns the maximum value of *value* across all input values
+| MIN( [ ALL &#124; DISTINCT ] value)           | Returns the minimum value of *value* across all input values
+| STDDEV_POP( [ ALL &#124; DISTINCT ] numeric)  | Returns the population standard deviation of *numeric* across all input values
+| STDDEV_SAMP( [ ALL &#124; DISTINCT ] numeric) | Returns the sample standard deviation of *numeric* across all input values
+| VAR_POP( [ ALL &#124; DISTINCT ] value)       | Returns the population variance (square of the population standard deviation) of *numeric* across all input values
+| VAR_SAMP( [ ALL &#124; DISTINCT ] numeric)    | Returns the sample variance (square of the sample standard deviation) of *numeric* across all input values
 | COVAR_POP(numeric1, numeric2)      | Returns the population covariance of the pair (*numeric1*, *numeric2*) across all input values
 | COVAR_SAMP(numeric1, numeric2)     | Returns the sample covariance of the pair (*numeric1*, *numeric2*) across all input values
 | REGR_SXX(numeric1, numeric2)       | Returns the sum of squares of the dependent expression in a linear regression model
@@ -1247,7 +1254,7 @@ Not implemented:
 
 | Operator syntax                           | Description
 |:----------------------------------------- |:-----------
-| COUNT(value [, value ]* ) OVER window     | Returns the number of rows in *window* for which *value* is not null (wholly not null if *value* is composite)
+| COUNT(value [, value ]*) OVER window     | Returns the number of rows in *window* for which *value* is not null (wholly not null if *value* is composite)
 | COUNT(*) OVER window                      | Returns the number of rows in *window*
 | AVG(numeric) OVER window                  | Returns the average (arithmetic mean) of *numeric* across all values in *window*
 | SUM(numeric) OVER window                  | Returns the sum of *numeric* across all values in *window*
@@ -1275,9 +1282,9 @@ Not implemented:
 
 | Operator syntax      | Description
 |:-------------------- |:-----------
-| GROUPING(expression [, expression ] * ) | Returns a bit vector of the given grouping expressions
+| GROUPING(expression [, expression ]*) | Returns a bit vector of the given grouping expressions
 | GROUP_ID()           | Returns an integer that uniquely identifies the combination of grouping keys
-| GROUPING_ID(expression [, expression ] * ) | Synonym for `GROUPING`
+| GROUPING_ID(expression [, expression ]*) | Synonym for `GROUPING`
 
 ### Grouped window functions
 
@@ -1425,4 +1432,75 @@ Here are some examples:
 * `f(c => 3, d => 1, a => 0)` is equivalent to `f(0, NULL, 3, 1, NULL)`;
 * `f(c => 3, d => 1)` is not legal, because you have not specified a value for
   `a` and `a` is not optional.
+```
 
+### MATCH_RECOGNIZE
+
+`MATCH_RECOGNIZE` is a SQL extension for recognizing sequences of
+events in complex event processing (CEP).
+
+It is experimental in Calcite, and yet not fully implemented.
+
+#### Syntax
+
+{% highlight sql %}
+matchRecognize:
+      MATCH_RECOGNIZE '('
+      [ PARTITION BY expression [, expression ]* ]
+      [ ORDER BY orderItem [, orderItem ]* ]
+      [ MEASURES measureColumn [, measureColumn ]* ]
+      [ ON ROW PER MATCH | ALL ROWS PER MATCH ]
+      [ AFTER MATCH
+            ( SKIP TO NEXT ROW
+            | SKIP PAST LAST ROW
+            | SKIP TO FIRST variable
+            | SKIP TO LAST variable
+            | SKIP TO variable )
+      ]
+      PATTERN '(' pattern ')'
+      [ SUBSET variable [, variable ]* ]
+      DEFINE variable AS condition [, variable AS condition ]*
+      ')'
+
+measureColumn:
+      expression AS alias
+
+pattern:
+      patternTerm ['|' patternTerm ]*
+
+patternTerm:
+      patternFactor [ patternFactor ]*
+
+patternFactor:
+      patternPrimary [ patternQuantifier ]
+
+patternPrimary:
+      variable
+  |   '$'
+  |   '^'
+  |   '(' [ pattern ] ')'
+  |   '{-' pattern '-}'
+  |   PERMUTE '(' pattern [, pattern ]* ')'
+
+patternQuantifier:
+      '*'
+  |   '*?'
+  |   '+'
+  |   '+?'
+  |   '?'
+  |   '??'
+  |   '{' { [ minRepeat ], [ maxRepeat ] } '}' ['?']
+  |   '{' repeat '}'
+{% endhighlight %}
+
+In *patternQuantifier*, *repeat* is a positive integer,
+and *minRepeat* and *maxRepeat* are non-negative integers.
+
+The following clauses are not implemented:
+
+* `PARTITION BY`
+* `ORDER BY`
+* `MEASURES`
+* `ON ROW PER MATCH`, `ALL ROWS PER MATCH`
+* `AFTER MATCH`
+* `SUBSET`


[07/10] calcite git commit: [CALCITE-1668] Simplify "1 = 1" to true, "1 > 2" to false (Kevin Risden)

Posted by jh...@apache.org.
[CALCITE-1668] Simplify "1 = 1" to true, "1 > 2" to false (Kevin Risden)

Close apache/calcite#387


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/255cd96a
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/255cd96a
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/255cd96a

Branch: refs/heads/master
Commit: 255cd96a79eb68fcf852b8e7af6299d7dfb356c7
Parents: 8df27ce
Author: Kevin Risden <ri...@avalonconsult.com>
Authored: Sun Feb 19 15:56:35 2017 -0600
Committer: Julian Hyde <jh...@apache.org>
Committed: Fri Mar 3 12:00:05 2017 -0800

----------------------------------------------------------------------
 .../java/org/apache/calcite/rex/RexUtil.java    | 81 +++++++++++++++-----
 .../org/apache/calcite/test/RelBuilderTest.java | 14 ++++
 .../org/apache/calcite/test/RexProgramTest.java | 65 ++++++++++++++++
 3 files changed, 140 insertions(+), 20 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/255cd96a/core/src/main/java/org/apache/calcite/rex/RexUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexUtil.java b/core/src/main/java/org/apache/calcite/rex/RexUtil.java
index a6b9e4e..fd60098 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -1641,33 +1641,74 @@ public class RexUtil {
     case LESS_THAN:
     case LESS_THAN_OR_EQUAL:
     case NOT_EQUALS:
-      final List<RexNode> operands = ((RexCall) e).getOperands();
-      if (RexUtil.eq(operands.get(0), operands.get(1))
-          && (unknownAsFalse
-          || (!operands.get(0).getType().isNullable()
-              && !operands.get(1).getType().isNullable()))) {
-        switch (e.getKind()) {
-        case EQUALS:
-        case GREATER_THAN_OR_EQUAL:
-        case LESS_THAN_OR_EQUAL:
-          // "x = x" simplifies to "x is not null" (similarly <= and >=)
-          return simplify(rexBuilder,
-              rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL,
-                  operands.get(0)));
-        default:
-          // "x != x" simplifies to "false" (similarly < and >)
-          return rexBuilder.makeLiteral(false);
-        }
-      }
-      return simplifyCall(rexBuilder, (RexCall) e);
+      return simplifyComparison(rexBuilder, (RexCall) e, unknownAsFalse);
     default:
       return e;
     }
   }
 
-  private static RexNode simplifyCall(RexBuilder rexBuilder, RexCall e) {
+  // e must be a comparison (=, >, >=, <, <=, !=)
+  private static RexNode simplifyComparison(RexBuilder rexBuilder, RexCall e,
+      boolean unknownAsFalse) {
     final List<RexNode> operands = new ArrayList<>(e.operands);
     simplifyList(rexBuilder, operands);
+
+    // Simplify "x <op> x"
+    final RexNode o0 = operands.get(0);
+    final RexNode o1 = operands.get(1);
+    if (RexUtil.eq(o0, o1)
+        && (unknownAsFalse
+            || (!o0.getType().isNullable()
+                && !o1.getType().isNullable()))) {
+      switch (e.getKind()) {
+      case EQUALS:
+      case GREATER_THAN_OR_EQUAL:
+      case LESS_THAN_OR_EQUAL:
+        // "x = x" simplifies to "x is not null" (similarly <= and >=)
+        return simplify(rexBuilder,
+            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, o0));
+      default:
+        // "x != x" simplifies to "false" (similarly < and >)
+        return rexBuilder.makeLiteral(false);
+      }
+    }
+
+    // Simplify "<literal1> <op> <literal2>"
+    // For example, "1 = 2" becomes FALSE;
+    // "1 != 1" becomes FALSE;
+    // "1 != NULL" becomes UNKNOWN (or FALSE if unknownAsFalse);
+    // "1 != '1'" is unchanged because the types are not the same.
+    if (o0.isA(SqlKind.LITERAL)
+        && o1.isA(SqlKind.LITERAL)
+        && o0.getType().equals(o1.getType())) {
+      final Comparable v0 = ((RexLiteral) o0).getValue();
+      final Comparable v1 = ((RexLiteral) o1).getValue();
+      if (v0 == null || v1 == null) {
+        return unknownAsFalse
+            ? rexBuilder.makeLiteral(false)
+            : rexBuilder.makeNullLiteral(e.getType());
+      }
+      @SuppressWarnings("unchecked")
+      final int comparisonResult = v0.compareTo(v1);
+      switch (e.getKind()) {
+      case EQUALS:
+        return rexBuilder.makeLiteral(comparisonResult == 0);
+      case GREATER_THAN:
+        return rexBuilder.makeLiteral(comparisonResult > 0);
+      case GREATER_THAN_OR_EQUAL:
+        return rexBuilder.makeLiteral(comparisonResult >= 0);
+      case LESS_THAN:
+        return rexBuilder.makeLiteral(comparisonResult < 0);
+      case LESS_THAN_OR_EQUAL:
+        return rexBuilder.makeLiteral(comparisonResult <= 0);
+      case NOT_EQUALS:
+        return rexBuilder.makeLiteral(comparisonResult != 0);
+      default:
+        throw new AssertionError();
+      }
+    }
+
+    // If none of the arguments were simplified, return the call unchanged.
     if (operands.equals(e.operands)) {
       return e;
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/255cd96a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java b/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
index 842caf1..4eafeae 100644
--- a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
@@ -208,6 +208,20 @@ public class RelBuilderTest {
         is("LogicalTableScan(table=[[scott, EMP]])\n"));
   }
 
+  @Test public void testScanFilterTriviallyFalse() {
+    // Equivalent SQL:
+    //   SELECT *
+    //   FROM emp
+    //   WHERE 1 = 2
+    final RelBuilder builder = RelBuilder.create(config().build());
+    RelNode root =
+        builder.scan("EMP")
+            .filter(builder.equals(builder.literal(1), builder.literal(2)))
+            .build();
+    assertThat(str(root),
+        is("LogicalValues(tuples=[[]])\n"));
+  }
+
   @Test public void testScanFilterEquals() {
     // Equivalent SQL:
     //   SELECT *

http://git-wip-us.apache.org/repos/asf/calcite/blob/255cd96a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
index 9ce8017..c1f567c 100644
--- a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
@@ -1308,6 +1308,71 @@ public class RexProgramTest {
         "1970-01-01 00:00:00"); // different from Hive
   }
 
+  @Test public void testSimplifyLiterals() {
+    final RexLiteral literalAbc = rexBuilder.makeLiteral("abc");
+    final RexLiteral literalDef = rexBuilder.makeLiteral("def");
+
+    final RexLiteral literalZero = rexBuilder.makeExactLiteral(BigDecimal.ZERO);
+    final RexLiteral literalOne = rexBuilder.makeExactLiteral(BigDecimal.ONE);
+    final RexLiteral literalOneDotZero = rexBuilder.makeExactLiteral(new BigDecimal(1.0));
+
+    // Check string comparison
+    checkSimplify(eq(literalAbc, literalAbc), "true");
+    checkSimplify(eq(literalAbc, literalDef), "false");
+    checkSimplify(ne(literalAbc, literalAbc), "false");
+    checkSimplify(ne(literalAbc, literalDef), "true");
+    checkSimplify(gt(literalAbc, literalDef), "false");
+    checkSimplify(gt(literalDef, literalAbc), "true");
+    checkSimplify(gt(literalDef, literalDef), "false");
+    checkSimplify(ge(literalAbc, literalDef), "false");
+    checkSimplify(ge(literalDef, literalAbc), "true");
+    checkSimplify(ge(literalDef, literalDef), "true");
+    checkSimplify(lt(literalAbc, literalDef), "true");
+    checkSimplify(lt(literalAbc, literalDef), "true");
+    checkSimplify(lt(literalDef, literalDef), "false");
+    checkSimplify(le(literalAbc, literalDef), "true");
+    checkSimplify(le(literalDef, literalAbc), "false");
+    checkSimplify(le(literalDef, literalDef), "true");
+
+    // Check whole number comparison
+    checkSimplify(eq(literalZero, literalOne), "false");
+    checkSimplify(eq(literalOne, literalZero), "false");
+    checkSimplify(ne(literalZero, literalOne), "true");
+    checkSimplify(ne(literalOne, literalZero), "true");
+    checkSimplify(gt(literalZero, literalOne), "false");
+    checkSimplify(gt(literalOne, literalZero), "true");
+    checkSimplify(gt(literalOne, literalOne), "false");
+    checkSimplify(ge(literalZero, literalOne), "false");
+    checkSimplify(ge(literalOne, literalZero), "true");
+    checkSimplify(ge(literalOne, literalOne), "true");
+    checkSimplify(lt(literalZero, literalOne), "true");
+    checkSimplify(lt(literalOne, literalZero), "false");
+    checkSimplify(lt(literalOne, literalOne), "false");
+    checkSimplify(le(literalZero, literalOne), "true");
+    checkSimplify(le(literalOne, literalZero), "false");
+    checkSimplify(le(literalOne, literalOne), "true");
+
+    // Check decimal equality comparison
+    checkSimplify(eq(literalOne, literalOneDotZero), "true");
+    checkSimplify(eq(literalOneDotZero, literalOne), "true");
+    checkSimplify(ne(literalOne, literalOneDotZero), "false");
+    checkSimplify(ne(literalOneDotZero, literalOne), "false");
+
+    // Check different types shouldn't change simplification
+    checkSimplifyUnchanged(eq(literalZero, literalAbc));
+    checkSimplifyUnchanged(eq(literalAbc, literalZero));
+    checkSimplifyUnchanged(ne(literalZero, literalAbc));
+    checkSimplifyUnchanged(ne(literalAbc, literalZero));
+    checkSimplifyUnchanged(gt(literalZero, literalAbc));
+    checkSimplifyUnchanged(gt(literalAbc, literalZero));
+    checkSimplifyUnchanged(ge(literalZero, literalAbc));
+    checkSimplifyUnchanged(ge(literalAbc, literalZero));
+    checkSimplifyUnchanged(lt(literalZero, literalAbc));
+    checkSimplifyUnchanged(lt(literalAbc, literalZero));
+    checkSimplifyUnchanged(le(literalZero, literalAbc));
+    checkSimplifyUnchanged(le(literalAbc, literalZero));
+  }
+
   private Calendar cal(int y, int m, int d, int h, int mm, int s) {
     final Calendar c = Util.calendar();
     c.set(Calendar.YEAR, y);


[10/10] calcite git commit: [CALCITE-1655] Druid adapter: add IN filter (Slim Bouguerra)

Posted by jh...@apache.org.
[CALCITE-1655] Druid adapter: add IN filter (Slim Bouguerra)

We cannot do end-to-end tests of IN and BETWEEN because Calcite
expands these before creating RexNode, but this change contains unit
tests of converting RexCall with IN and BETWEEN into Druid JSON.

Close apache/calcite#381


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/f8546915
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/f8546915
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/f8546915

Branch: refs/heads/master
Commit: f8546915671cc4d96fa3b5561e289c3bfd80209f
Parents: 4e10382
Author: Slim Bouguerra <sl...@gmail.com>
Authored: Thu Feb 23 16:49:47 2017 -0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Sat Mar 4 13:02:45 2017 -0800

----------------------------------------------------------------------
 druid/pom.xml                                   |   5 +
 .../calcite/adapter/druid/DruidQuery.java       |  77 ++++++++---
 .../adapter/druid/DruidQueryFilterTest.java     | 127 +++++++++++++++++++
 pom.xml                                         |   6 +-
 4 files changed, 196 insertions(+), 19 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/f8546915/druid/pom.xml
----------------------------------------------------------------------
diff --git a/druid/pom.xml b/druid/pom.xml
index 4191d3d..68e4d92 100644
--- a/druid/pom.xml
+++ b/druid/pom.xml
@@ -95,6 +95,11 @@ limitations under the License.
           <artifactId>slf4j-log4j12</artifactId>
           <scope>test</scope>
       </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>

http://git-wip-us.apache.org/repos/asf/calcite/blob/f8546915/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
----------------------------------------------------------------------
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
index 694f9c7..74c0cc0 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
@@ -66,6 +66,7 @@ import org.apache.calcite.util.Util;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
@@ -865,7 +866,8 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
   }
 
   /** Translates scalar expressions to Druid field references. */
-  private static class Translator {
+  @VisibleForTesting
+  protected static class Translator {
     final List<String> dimensions = new ArrayList<>();
     final List<String> metrics = new ArrayList<>();
     final DruidTable druidTable;
@@ -917,7 +919,7 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
       }
     }
 
-    @SuppressWarnings("incomplete-switch") private JsonFilter translateFilter(RexNode e) {
+    private JsonFilter translateFilter(RexNode e) {
       final RexCall call;
       switch (e.getKind()) {
       case EQUALS:
@@ -926,6 +928,8 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
       case GREATER_THAN_OR_EQUAL:
       case LESS_THAN:
       case LESS_THAN_OR_EQUAL:
+      case IN:
+      case BETWEEN:
         call = (RexCall) e;
         int posRef;
         int posConstant;
@@ -938,34 +942,50 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
         } else {
           throw new AssertionError("it is not a valid comparison: " + e);
         }
+        final boolean numeric =
+            call.getOperands().get(posRef).getType().getFamily()
+                == SqlTypeFamily.NUMERIC;
         switch (e.getKind()) {
         case EQUALS:
           return new JsonSelector("selector", tr(e, posRef), tr(e, posConstant));
         case NOT_EQUALS:
           return new JsonCompositeFilter("not",
-              ImmutableList.of(new JsonSelector("selector", tr(e, posRef), tr(e, posConstant))));
+              new JsonSelector("selector", tr(e, posRef), tr(e, posConstant)));
         case GREATER_THAN:
-          return new JsonBound("bound", tr(e, posRef), tr(e, posConstant), true, null, false,
-              call.getOperands().get(posRef).getType().getFamily() == SqlTypeFamily.NUMERIC);
+          return new JsonBound("bound", tr(e, posRef), tr(e, posConstant),
+              true, null, false, numeric);
         case GREATER_THAN_OR_EQUAL:
-          return new JsonBound("bound", tr(e, posRef), tr(e, posConstant), false, null, false,
-              call.getOperands().get(posRef).getType().getFamily() == SqlTypeFamily.NUMERIC);
+          return new JsonBound("bound", tr(e, posRef), tr(e, posConstant),
+              false, null, false, numeric);
         case LESS_THAN:
-          return new JsonBound("bound", tr(e, posRef), null, false, tr(e, posConstant), true,
-              call.getOperands().get(posRef).getType().getFamily() == SqlTypeFamily.NUMERIC);
+          return new JsonBound("bound", tr(e, posRef), null, false,
+              tr(e, posConstant), true, numeric);
         case LESS_THAN_OR_EQUAL:
-          return new JsonBound("bound", tr(e, posRef), null, false, tr(e, posConstant), false,
-              call.getOperands().get(posRef).getType().getFamily() == SqlTypeFamily.NUMERIC);
+          return new JsonBound("bound", tr(e, posRef), null, false,
+              tr(e, posConstant), false, numeric);
+        case IN:
+          ImmutableList.Builder<String> listBuilder = ImmutableList.builder();
+          for (RexNode rexNode: call.getOperands()) {
+            if (rexNode.getKind() == SqlKind.LITERAL) {
+              listBuilder.add(((RexLiteral) rexNode).getValue2().toString());
+            }
+          }
+          return new JsonInFilter("in", tr(e, posRef), listBuilder.build());
+        case BETWEEN:
+          return new JsonBound("bound", tr(e, posRef), tr(e, 2), false,
+              tr(e, 3), false, numeric);
+        default:
+          throw new AssertionError();
         }
-        break;
       case AND:
       case OR:
       case NOT:
         call = (RexCall) e;
         return new JsonCompositeFilter(e.getKind().lowerName,
             translateFilters(call.getOperands()));
+      default:
+        throw new AssertionError("cannot translate filter: " + e);
       }
-      throw new AssertionError("cannot translate filter: " + e);
     }
 
     private String tr(RexNode call, int index) {
@@ -1164,7 +1184,8 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
   }
 
   /** Bound filter. */
-  private static class JsonBound extends JsonFilter {
+  @VisibleForTesting
+  protected static class JsonBound extends JsonFilter {
     private final String dimension;
     private final String lower;
     private final boolean lowerStrict;
@@ -1206,9 +1227,13 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
     private final List<? extends JsonFilter> fields;
 
     private JsonCompositeFilter(String type,
-        List<? extends JsonFilter> fields) {
+        Iterable<? extends JsonFilter> fields) {
       super(type);
-      this.fields = fields;
+      this.fields = ImmutableList.copyOf(fields);
+    }
+
+    private JsonCompositeFilter(String type, JsonFilter... fields) {
+      this(type, ImmutableList.copyOf(fields));
     }
 
     public void write(JsonGenerator generator) throws IOException {
@@ -1225,6 +1250,26 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
     }
   }
 
+  /** IN filter. */
+  protected static class JsonInFilter extends JsonFilter {
+    private final String dimension;
+    private final List<String> values;
+
+    private JsonInFilter(String type, String dimension, List<String> values) {
+      super(type);
+      this.dimension = dimension;
+      this.values = values;
+    }
+
+    public void write(JsonGenerator generator) throws IOException {
+      generator.writeStartObject();
+      generator.writeStringField("type", type);
+      generator.writeStringField("dimension", dimension);
+      writeField(generator, "values", values);
+      generator.writeEndObject();
+    }
+  }
+
 }
 
 // End DruidQuery.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/f8546915/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java
----------------------------------------------------------------------
diff --git a/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java b/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java
new file mode 100644
index 0000000..2fc44de
--- /dev/null
+++ b/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.adapter.druid;
+
+import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.SqlTypeName;
+
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.hamcrest.core.Is.is;
+
+/**
+ * Tests generating Druid filters.
+ */
+public class DruidQueryFilterTest {
+
+  @Test public void testInFilter() throws NoSuchMethodException,
+      InvocationTargetException, IllegalAccessException, IOException {
+    final Fixture f = new Fixture();
+    final List<? extends RexNode> listRexNodes =
+        ImmutableList.of(f.rexBuilder.makeInputRef(f.varcharRowType, 0),
+            f.rexBuilder.makeExactLiteral(BigDecimal.valueOf(1)),
+            f.rexBuilder.makeExactLiteral(BigDecimal.valueOf(5)),
+            f.rexBuilder.makeLiteral("value1"));
+
+    RexNode inRexNode =
+        f.rexBuilder.makeCall(SqlStdOperatorTable.IN, listRexNodes);
+    Method translateFilter =
+        DruidQuery.Translator.class.getDeclaredMethod("translateFilter",
+            RexNode.class);
+    translateFilter.setAccessible(true);
+    DruidQuery.JsonInFilter returnValue =
+        (DruidQuery.JsonInFilter) translateFilter.invoke(f.translatorStringKind,
+            inRexNode);
+    JsonFactory jsonFactory = new JsonFactory();
+    final StringWriter sw = new StringWriter();
+    JsonGenerator jsonGenerator = jsonFactory.createGenerator(sw);
+    returnValue.write(jsonGenerator);
+    jsonGenerator.close();
+
+    Assert.assertThat(sw.toString(),
+        is("{\"type\":\"in\",\"dimension\":\"dimensionName\","
+            + "\"values\":[\"1\",\"5\",\"value1\"]}"));
+  }
+
+  @Test public void testBetweenFilterStringCase() throws NoSuchMethodException,
+      InvocationTargetException, IllegalAccessException, IOException {
+    final Fixture f = new Fixture();
+    final List<RexNode> listRexNodes =
+        ImmutableList.of(f.rexBuilder.makeLiteral(false),
+            f.rexBuilder.makeInputRef(f.varcharRowType, 0),
+            f.rexBuilder.makeLiteral("lower-bound"),
+            f.rexBuilder.makeLiteral("upper-bound"));
+    RelDataType relDataType = f.typeFactory.createSqlType(SqlTypeName.BOOLEAN);
+    RexNode betweenRexNode = f.rexBuilder.makeCall(relDataType,
+        SqlStdOperatorTable.BETWEEN, listRexNodes);
+
+    Method translateFilter =
+        DruidQuery.Translator.class.getDeclaredMethod("translateFilter",
+            RexNode.class);
+    translateFilter.setAccessible(true);
+    DruidQuery.JsonBound returnValue =
+        (DruidQuery.JsonBound) translateFilter.invoke(f.translatorStringKind,
+            betweenRexNode);
+    JsonFactory jsonFactory = new JsonFactory();
+    final StringWriter sw = new StringWriter();
+    JsonGenerator jsonGenerator = jsonFactory.createGenerator(sw);
+    returnValue.write(jsonGenerator);
+    jsonGenerator.close();
+    Assert.assertThat(sw.toString(),
+        is("{\"type\":\"bound\",\"dimension\":\"dimensionName\",\"lower\":\"lower-bound\","
+            + "\"lowerStrict\":false,\"upper\":\"upper-bound\",\"upperStrict\":false,"
+            + "\"alphaNumeric\":false}"));
+  }
+
+  /** Everything a test needs for a healthy, active life. */
+  static class Fixture {
+    final JavaTypeFactoryImpl typeFactory =
+        new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+    final RexBuilder rexBuilder = new RexBuilder(typeFactory);
+    final DruidTable druidTable =
+        new DruidTable(Mockito.mock(DruidSchema.class), "dataSource", null,
+            ImmutableSet.<String>of(), "timestamp", null);
+    final RelDataType varcharType =
+        typeFactory.createSqlType(SqlTypeName.VARCHAR);
+    final RelDataType varcharRowType = typeFactory.builder()
+        .add("dimensionName", varcharType)
+        .build();
+    final DruidQuery.Translator translatorStringKind =
+        new DruidQuery.Translator(druidTable, varcharRowType);
+  }
+}
+
+// End DruidQueryFilterTest.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/f8546915/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 2340596..91b275b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -103,7 +103,7 @@ limitations under the License.
     <maven-shade-plugin.version>2.1</maven-shade-plugin.version>
     <!-- Apache 18 has 3.0.0, but need 3.0.1 for [MSOURCES-94]. -->
     <maven-source-plugin.version>3.0.1</maven-source-plugin.version>
-    <mockito-all.version>1.10.19</mockito-all.version>
+    <mockito.version>2.5.5</mockito.version>
     <mongo-java-driver.version>2.12.3</mongo-java-driver.version>
     <mysql-driver.version>5.1.20</mysql-driver.version>
     <natty.version>0.13</natty.version>
@@ -352,8 +352,8 @@ limitations under the License.
       </dependency>
       <dependency>
         <groupId>org.mockito</groupId>
-        <artifactId>mockito-all</artifactId>
-        <version>${mockito-all.version}</version>
+        <artifactId>mockito-core</artifactId>
+        <version>${mockito.version}</version>
       </dependency>
       <dependency>
         <groupId>org.postgresql</groupId>


[06/10] calcite git commit: [CALCITE-1667] In Avatica, forbid calls to JDK APIs that use the default locale, time zone or character set

Posted by jh...@apache.org.
[CALCITE-1667] In Avatica, forbid calls to JDK APIs that use the default locale, time zone or character set

Use the "forbidden-apis" maven plugin to detect calls to such APIs.
Eliminate calls to such APIs.


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/8df27ce9
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/8df27ce9
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/8df27ce9

Branch: refs/heads/master
Commit: 8df27ce9dfc24c3116e6343432d581d112d83557
Parents: 75152c5
Author: Julian Hyde <jh...@apache.org>
Authored: Fri Mar 3 01:27:20 2017 -0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Fri Mar 3 11:08:49 2017 -0800

----------------------------------------------------------------------
 .../avatica/AvaticaPreparedStatement.java       |   3 +-
 .../calcite/avatica/AvaticaResultSet.java       |   3 +-
 .../org/apache/calcite/avatica/AvaticaSite.java |   3 +-
 .../apache/calcite/avatica/AvaticaUtils.java    |   1 +
 .../avatica/BuiltInConnectionProperty.java      |   3 +-
 .../calcite/avatica/ConnectionConfigImpl.java   |   3 +-
 .../org/apache/calcite/avatica/SqlState.java    |   7 +-
 .../remote/AvaticaRemoteConnectionProperty.java |   3 +-
 .../apache/calcite/avatica/remote/Driver.java   |   4 +-
 .../avatica/remote/RemoteProtobufService.java   |   4 +-
 .../calcite/avatica/util/AbstractCursor.java    |   2 +-
 .../org/apache/calcite/avatica/util/Base64.java |  24 ++--
 .../calcite/avatica/util/DateTimeUtils.java     |  32 +++--
 .../org/apache/calcite/avatica/util/Unsafe.java |  55 +++++++++
 .../AvaticaResultSetConversionsTest.java        |   5 +-
 .../calcite/avatica/MetaResultSetTest.java      |   7 +-
 .../avatica/remote/KerberosConnectionTest.java  |   4 +-
 .../calcite/avatica/remote/TypedValueTest.java  |  12 +-
 .../calcite/avatica/test/AvaticaUtilsTest.java  |   5 +-
 avatica/pom.xml                                 |  39 ++++++
 .../apache/calcite/avatica/jdbc/JdbcMeta.java   |   3 +-
 .../calcite/avatica/jdbc/JdbcResultSet.java     |   2 +-
 .../calcite/avatica/server/HttpServer.java      |   8 +-
 .../calcite/avatica/RemoteDriverTest.java       | 123 +++++++++++--------
 .../apache/calcite/avatica/SpnegoTestUtil.java  |  10 +-
 .../apache/calcite/avatica/SslDriverTest.java   |   5 +-
 .../calcite/avatica/remote/RemoteMetaTest.java  |  35 ++++--
 .../server/AbstractAvaticaHandlerTest.java      |   3 +-
 .../server/HttpServerSpnegoWithJaasTest.java    |   4 +-
 .../server/HttpServerSpnegoWithoutJaasTest.java |   4 +-
 .../main/config/forbidden-apis/signatures.txt   |  39 ++++++
 .../calcite/avatica/hsqldb/HsqldbServer.java    |   9 +-
 .../apache/calcite/avatica/tck/TestRunner.java  |  12 +-
 .../org/apache/calcite/avatica/tck/Unsafe.java  |  55 +++++++++
 34 files changed, 406 insertions(+), 125 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaPreparedStatement.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaPreparedStatement.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaPreparedStatement.java
index 31cdfd2..e611c9a 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaPreparedStatement.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaPreparedStatement.java
@@ -39,6 +39,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * Implementation of {@link java.sql.PreparedStatement}
@@ -115,7 +116,7 @@ public abstract class AvaticaPreparedStatement
    */
   protected synchronized Calendar getCalendar() {
     if (calendar == null) {
-      calendar = Calendar.getInstance(connection.getTimeZone());
+      calendar = Calendar.getInstance(connection.getTimeZone(), Locale.ROOT);
     }
     return calendar;
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaResultSet.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaResultSet.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaResultSet.java
index a102eba..51bf8fa 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaResultSet.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaResultSet.java
@@ -40,6 +40,7 @@ import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.Calendar;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.TimeZone;
 
@@ -87,7 +88,7 @@ public class AvaticaResultSet implements ResultSet, ArrayImpl.Factory {
     this.fetchSize = statement.getFetchSize();
     this.fetchDirection = statement.getFetchDirection();
     this.resultSetMetaData = resultSetMetaData;
-    this.localCalendar = Calendar.getInstance(timeZone);
+    this.localCalendar = Calendar.getInstance(timeZone, Locale.ROOT);
   }
 
   private int findColumn0(String columnLabel) throws SQLException {

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaSite.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaSite.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaSite.java
index b33b0b2..0e23866 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaSite.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaSite.java
@@ -24,6 +24,7 @@ import java.io.Reader;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.sql.Array;
 import java.sql.Blob;
 import java.sql.Clob;
@@ -477,7 +478,7 @@ public class AvaticaSite {
       return (byte[]) x;
     }
     if (x instanceof String) {
-      return ((String) x).getBytes();
+      return ((String) x).getBytes(StandardCharsets.UTF_8);
     }
     throw unsupportedCast(x.getClass(), byte[].class);
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaUtils.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaUtils.java b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaUtils.java
index 53aff83..56a23c8 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaUtils.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/AvaticaUtils.java
@@ -37,6 +37,7 @@ import java.util.Set;
 
 /** Avatica utilities. */
 public class AvaticaUtils {
+
   private static final Map<Class, Class> BOX;
 
   private static final MethodHandle SET_LARGE_MAX_ROWS =

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/BuiltInConnectionProperty.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/BuiltInConnectionProperty.java b/avatica/core/src/main/java/org/apache/calcite/avatica/BuiltInConnectionProperty.java
index aa7d710..d68bae8 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/BuiltInConnectionProperty.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/BuiltInConnectionProperty.java
@@ -20,6 +20,7 @@ import org.apache.calcite.avatica.remote.AvaticaHttpClientFactoryImpl;
 
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
@@ -90,7 +91,7 @@ public enum BuiltInConnectionProperty implements ConnectionProperty {
   static {
     NAME_TO_PROPS = new HashMap<>();
     for (BuiltInConnectionProperty p : BuiltInConnectionProperty.values()) {
-      NAME_TO_PROPS.put(p.camelName.toUpperCase(), p);
+      NAME_TO_PROPS.put(p.camelName.toUpperCase(Locale.ROOT), p);
       NAME_TO_PROPS.put(p.name(), p);
     }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/ConnectionConfigImpl.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/ConnectionConfigImpl.java b/avatica/core/src/main/java/org/apache/calcite/avatica/ConnectionConfigImpl.java
index e9d7272..a003b82 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/ConnectionConfigImpl.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/ConnectionConfigImpl.java
@@ -22,6 +22,7 @@ import org.apache.calcite.avatica.remote.Service;
 import java.io.File;
 import java.math.BigDecimal;
 import java.util.LinkedHashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 
@@ -121,7 +122,7 @@ public class ConnectionConfigImpl implements ConnectionConfig {
         new LinkedHashMap<ConnectionProperty, String>();
     for (String name : properties.stringPropertyNames()) {
       final ConnectionProperty connectionProperty =
-          nameToProps.get(name.toUpperCase());
+          nameToProps.get(name.toUpperCase(Locale.ROOT));
       if (connectionProperty == null) {
         // For now, don't throw. It messes up sub-projects.
         //throw new RuntimeException("Unknown property '" + name + "'");

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/SqlState.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/SqlState.java b/avatica/core/src/main/java/org/apache/calcite/avatica/SqlState.java
index 1459757..9f967aa 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/SqlState.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/SqlState.java
@@ -16,7 +16,10 @@
  */
 package org.apache.calcite.avatica;
 
+import java.io.BufferedWriter;
+import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -1810,7 +1813,9 @@ public enum SqlState {
 
   /** Validates the data, and generates the HTML table. */
   private static void main(String[] args) {
-    PrintWriter pw = new PrintWriter(System.out);
+    PrintWriter pw = new PrintWriter(
+        new BufferedWriter(
+            new OutputStreamWriter(System.out, StandardCharsets.UTF_8)));
     pw.println(" * <table>");
     SqlState parent = null;
     for (SqlState s : values()) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/remote/AvaticaRemoteConnectionProperty.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/remote/AvaticaRemoteConnectionProperty.java b/avatica/core/src/main/java/org/apache/calcite/avatica/remote/AvaticaRemoteConnectionProperty.java
index e0d9bb1..e965989 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/remote/AvaticaRemoteConnectionProperty.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/remote/AvaticaRemoteConnectionProperty.java
@@ -19,6 +19,7 @@ package org.apache.calcite.avatica.remote;
 import org.apache.calcite.avatica.ConnectionProperty;
 
 import java.util.HashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 
@@ -42,7 +43,7 @@ public enum AvaticaRemoteConnectionProperty implements ConnectionProperty {
     NAME_TO_PROPS = new HashMap<>();
     for (AvaticaRemoteConnectionProperty p
         : AvaticaRemoteConnectionProperty.values()) {
-      NAME_TO_PROPS.put(p.camelName.toUpperCase(), p);
+      NAME_TO_PROPS.put(p.camelName.toUpperCase(Locale.ROOT), p);
       NAME_TO_PROPS.put(p.name(), p);
     }
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/remote/Driver.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/remote/Driver.java b/avatica/core/src/main/java/org/apache/calcite/avatica/remote/Driver.java
index 86f0814..3f6d4df 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/remote/Driver.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/remote/Driver.java
@@ -35,6 +35,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Properties;
 
 /**
@@ -184,7 +185,8 @@ public class Driver extends UnregisteredDriver {
     Serialization serializationType = Serialization.JSON;
     if (null != serializationStr) {
       try {
-        serializationType = Serialization.valueOf(serializationStr.toUpperCase());
+        serializationType =
+            Serialization.valueOf(serializationStr.toUpperCase(Locale.ROOT));
       } catch (Exception e) {
         // Log a warning instead of failing harshly? Intentionally no loggers available?
         throw new RuntimeException(e);

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/remote/RemoteProtobufService.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/remote/RemoteProtobufService.java b/avatica/core/src/main/java/org/apache/calcite/avatica/remote/RemoteProtobufService.java
index 2e92662..0f4cbfb 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/remote/RemoteProtobufService.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/remote/RemoteProtobufService.java
@@ -20,6 +20,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 
 
 /**
@@ -51,7 +52,8 @@ public class RemoteProtobufService extends ProtobufService {
     try {
       resp = translation.parseResponse(response);
     } catch (IOException e) {
-      LOG.debug("Failed to deserialize reponse to {}. '{}'", request, new String(response));
+      LOG.debug("Failed to deserialize reponse to {}. '{}'", request,
+          new String(response, StandardCharsets.UTF_8));
       // Not a protobuf that we could parse.
       throw new RuntimeException(e);
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/util/AbstractCursor.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/util/AbstractCursor.java b/avatica/core/src/main/java/org/apache/calcite/avatica/util/AbstractCursor.java
index 3bf69d6..77739ab 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/util/AbstractCursor.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/util/AbstractCursor.java
@@ -792,7 +792,7 @@ public abstract class AbstractCursor implements Cursor {
       if (obj instanceof ByteString) {
         return ((ByteString) obj).getBytes();
       } else if (obj instanceof String) {
-        return ((String) obj).getBytes();
+        return ((String) obj).getBytes(StandardCharsets.UTF_8);
       } else if (obj instanceof byte[]) {
         return (byte[]) obj;
       } else {

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/util/Base64.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/util/Base64.java b/avatica/core/src/main/java/org/apache/calcite/avatica/util/Base64.java
index c2393b1..c42b1f5 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/util/Base64.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/util/Base64.java
@@ -18,6 +18,9 @@ package org.apache.calcite.avatica.util;
 
 //CHECKSTYLE: OFF
 
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+
 /**
  * <p>Encodes and decodes to and from Base64 notation.</p>
  * <p>Homepage: <a href="http://iharder.net/base64">http://iharder.net/base64</a>.</p>
@@ -713,7 +716,7 @@ public class Base64
     }   // end try
     catch (java.io.UnsupportedEncodingException uue){
       // Fall back to some Java default
-      return new String( baos.toByteArray() );
+      return new String( baos.toByteArray(), StandardCharsets.UTF_8 );
     }   // end catch
 
   }   // end encode
@@ -853,7 +856,7 @@ public class Base64
       return new String( encoded, PREFERRED_ENCODING );
     }   // end try
     catch (java.io.UnsupportedEncodingException uue) {
-      return new String( encoded );
+      return new String( encoded, StandardCharsets.UTF_8 );
     }   // end catch
 
   }   // end encodeBytes
@@ -917,7 +920,9 @@ public class Base64
 
     if( off + len > source.length  ){
       throw new IllegalArgumentException(
-          String.format( "Cannot have offset of %d and length of %d with array of length %d", off,len,source.length));
+          String.format( Locale.ROOT,
+              "Cannot have offset of %d and length of %d with array of length %d",
+              off,len,source.length ) );
     }   // end if: off < 0
 
 
@@ -1057,11 +1062,11 @@ public class Base64
       throw new NullPointerException( "Destination array was null." );
     }   // end if
     if( srcOffset < 0 || srcOffset + 3 >= source.length ){
-      throw new IllegalArgumentException( String.format(
+      throw new IllegalArgumentException( String.format( Locale.ROOT,
           "Source array with length %d cannot have offset of %d and still process four bytes.", source.length, srcOffset ) );
     }   // end if
     if( destOffset < 0 || destOffset +2 >= destination.length ){
-      throw new IllegalArgumentException( String.format(
+      throw new IllegalArgumentException( String.format( Locale.ROOT,
           "Destination array with length %d cannot have offset of %d and still store three bytes.", destination.length, destOffset ) );
     }   // end if
 
@@ -1171,7 +1176,7 @@ public class Base64
       throw new NullPointerException( "Cannot decode null source array." );
     }   // end if
     if( off < 0 || off + len > source.length ){
-      throw new IllegalArgumentException( String.format(
+      throw new IllegalArgumentException( String.format( Locale.ROOT,
           "Source array with length %d cannot have offset of %d and process %d bytes.", source.length, off, len ) );
     }   // end if
 
@@ -1216,8 +1221,9 @@ public class Base64
       }   // end if: white space, equals sign or better
       else {
         // There's a bad input character in the Base64 stream.
-        throw new java.io.IOException( String.format(
-            "Bad Base64 input character decimal %d in array position %d", ((int)source[i])&0xFF, i ) );
+        throw new java.io.IOException( String.format( Locale.ROOT,
+            "Bad Base64 input character decimal %d in array position %d",
+            ((int)source[i])&0xFF, i ) );
       }   // end else:
     }   // each input character
 
@@ -1266,7 +1272,7 @@ public class Base64
       bytes = s.getBytes( PREFERRED_ENCODING );
     }   // end try
     catch( java.io.UnsupportedEncodingException uee ) {
-      bytes = s.getBytes();
+      bytes = s.getBytes( StandardCharsets.UTF_8 );
     }   // end catch
     //</change>
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/util/DateTimeUtils.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/util/DateTimeUtils.java b/avatica/core/src/main/java/org/apache/calcite/avatica/util/DateTimeUtils.java
index 85b6d6c..406dcfd 100644
--- a/avatica/core/src/main/java/org/apache/calcite/avatica/util/DateTimeUtils.java
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/util/DateTimeUtils.java
@@ -20,6 +20,7 @@ import java.text.NumberFormat;
 import java.text.ParsePosition;
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
+import java.util.Locale;
 import java.util.TimeZone;
 
 /**
@@ -48,9 +49,15 @@ public class DateTimeUtils {
   public static final String TIMESTAMP_FORMAT_STRING =
       DATE_FORMAT_STRING + " " + TIME_FORMAT_STRING;
 
-  /** The GMT time zone. */
+  /** The GMT time zone.
+   *
+   * @deprecated Use {@link #UTC_ZONE} */
+  @Deprecated // to be removed before 2.0
   public static final TimeZone GMT_ZONE = TimeZone.getTimeZone("GMT");
 
+  /** The UTC time zone. */
+  public static final TimeZone UTC_ZONE = TimeZone.getTimeZone("UTC");
+
   /** The Java default time zone. */
   public static final TimeZone DEFAULT_ZONE = TimeZone.getDefault();
 
@@ -85,15 +92,10 @@ public class DateTimeUtils {
   public static final Calendar ZERO_CALENDAR;
 
   static {
-    ZERO_CALENDAR = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+    ZERO_CALENDAR = Calendar.getInstance(DateTimeUtils.GMT_ZONE, Locale.ROOT);
     ZERO_CALENDAR.setTimeInMillis(0);
   }
 
-  /**
-   * Calendar set to local time.
-   */
-  private static final Calendar LOCAL_CALENDAR = Calendar.getInstance();
-
   //~ Methods ----------------------------------------------------------------
 
   /**
@@ -117,11 +119,11 @@ public class DateTimeUtils {
       TimeZone tz,
       ParsePosition pp) {
     assert pattern != null;
-    SimpleDateFormat df = new SimpleDateFormat(pattern);
+    SimpleDateFormat df = new SimpleDateFormat(pattern, Locale.ROOT);
     if (tz == null) {
       tz = DEFAULT_ZONE;
     }
-    Calendar ret = Calendar.getInstance(tz);
+    Calendar ret = Calendar.getInstance(tz, Locale.ROOT);
     df.setCalendar(ret);
     df.setLenient(false);
 
@@ -204,7 +206,7 @@ public class DateTimeUtils {
         if (!secFraction.matches("\\d+")) {
           return null;
         }
-        NumberFormat nf = NumberFormat.getIntegerInstance();
+        NumberFormat nf = NumberFormat.getIntegerInstance(Locale.ROOT);
         Number num = nf.parse(s, pp);
         if ((num == null) || (pp.getIndex() != s.length())) {
           // Invalid decimal portion
@@ -248,7 +250,7 @@ public class DateTimeUtils {
    * @throws IllegalArgumentException if the given pattern is invalid
    */
   public static void checkDateFormat(String pattern) {
-    new SimpleDateFormat(pattern);
+    new SimpleDateFormat(pattern, Locale.ROOT);
   }
 
   /**
@@ -258,7 +260,7 @@ public class DateTimeUtils {
    * @param format {@link SimpleDateFormat}  pattern
    */
   public static SimpleDateFormat newDateFormat(String format) {
-    SimpleDateFormat sdf = new SimpleDateFormat(format);
+    SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.ROOT);
     sdf.setLenient(false);
     return sdf;
   }
@@ -999,6 +1001,12 @@ public class DateTimeUtils {
     return x - floorDiv(x, y) * y;
   }
 
+  /** Creates an instance of {@link Calendar} in the root locale and UTC time
+   * zone. */
+  public static Calendar calendar() {
+    return Calendar.getInstance(UTC_ZONE, Locale.ROOT);
+  }
+
   //~ Inner Classes ----------------------------------------------------------
 
   /**

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/main/java/org/apache/calcite/avatica/util/Unsafe.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/main/java/org/apache/calcite/avatica/util/Unsafe.java b/avatica/core/src/main/java/org/apache/calcite/avatica/util/Unsafe.java
new file mode 100644
index 0000000..1d0238c
--- /dev/null
+++ b/avatica/core/src/main/java/org/apache/calcite/avatica/util/Unsafe.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.avatica.util;
+
+import java.util.Calendar;
+import java.util.Locale;
+
+/**
+ * Contains methods that call JDK methods that the
+ * <a href="https://github.com/policeman-tools/forbidden-apis">forbidden
+ * APIs checker</a> does not approve of.
+ *
+ * <p>This class is excluded from the check, so methods called via this class
+ * will not fail the build.
+ */
+public class Unsafe {
+  private Unsafe() {}
+
+  /** Calls {@link System#exit}. */
+  public static void systemExit(int status) {
+    System.exit(status);
+  }
+
+  /** Calls {@link Object#notifyAll()}. */
+  public static void notifyAll(Object o) {
+    o.notifyAll();
+  }
+
+  /** Calls {@link Object#wait()}. */
+  public static void wait(Object o) throws InterruptedException {
+    o.wait();
+  }
+
+  /** Returns a {@link java.util.Calendar} with the local time zone and root
+   * locale. */
+  public static Calendar localCalendar() {
+    return Calendar.getInstance(Locale.ROOT);
+  }
+}
+
+// End Unsafe.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/test/java/org/apache/calcite/avatica/AvaticaResultSetConversionsTest.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/test/java/org/apache/calcite/avatica/AvaticaResultSetConversionsTest.java b/avatica/core/src/test/java/org/apache/calcite/avatica/AvaticaResultSetConversionsTest.java
index 95d160b..bf3047f 100644
--- a/avatica/core/src/test/java/org/apache/calcite/avatica/AvaticaResultSetConversionsTest.java
+++ b/avatica/core/src/test/java/org/apache/calcite/avatica/AvaticaResultSetConversionsTest.java
@@ -18,6 +18,7 @@ package org.apache.calcite.avatica;
 
 import org.apache.calcite.avatica.ColumnMetaData.AvaticaType;
 import org.apache.calcite.avatica.remote.TypedValue;
+import org.apache.calcite.avatica.util.DateTimeUtils;
 
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
@@ -43,7 +44,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
-import java.util.TimeZone;
 
 import static org.hamcrest.CoreMatchers.isA;
 import static org.junit.Assert.assertEquals;
@@ -913,8 +913,7 @@ public class AvaticaResultSetConversionsTest {
     }
   }
 
-  private static final Calendar DEFAULT_CALENDAR = Calendar
-      .getInstance(TimeZone.getTimeZone("GMT"));
+  private static final Calendar DEFAULT_CALENDAR = DateTimeUtils.calendar();
 
   private static Connection connection = null;
   private static ResultSet resultSet = null;

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/test/java/org/apache/calcite/avatica/MetaResultSetTest.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/test/java/org/apache/calcite/avatica/MetaResultSetTest.java b/avatica/core/src/test/java/org/apache/calcite/avatica/MetaResultSetTest.java
index 6ec1dc7..3d5eb80 100644
--- a/avatica/core/src/test/java/org/apache/calcite/avatica/MetaResultSetTest.java
+++ b/avatica/core/src/test/java/org/apache/calcite/avatica/MetaResultSetTest.java
@@ -30,6 +30,7 @@ import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Types;
 import java.util.List;
+import java.util.Locale;
 
 import static org.junit.Assert.assertEquals;
 
@@ -624,21 +625,21 @@ public class MetaResultSetTest {
   private static void assertColumn(ResultSetMetaData rsMeta, int column, String name, int type,
       int nullable) throws SQLException {
     assertEquals(
-        String.format(
+        String.format(Locale.ROOT,
             "Expected column %d to be named '%s', was '%s'.",
             column, name, rsMeta.getColumnName(column)),
         name,
         rsMeta.getColumnName(column));
 
     assertEquals(
-        String.format(
+        String.format(Locale.ROOT,
             "Expected column %d type to be '%d', was '%d'.",
             column, type, rsMeta.getColumnType(column)),
         type,
         rsMeta.getColumnType(column));
 
     assertEquals(
-        String.format(
+        String.format(Locale.ROOT,
             "Expected column %d nullability to be '%d', was '%d'.",
             column, nullable, rsMeta.isNullable(column)),
         nullable,

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/test/java/org/apache/calcite/avatica/remote/KerberosConnectionTest.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/test/java/org/apache/calcite/avatica/remote/KerberosConnectionTest.java b/avatica/core/src/test/java/org/apache/calcite/avatica/remote/KerberosConnectionTest.java
index a57b95b..ad98569 100644
--- a/avatica/core/src/test/java/org/apache/calcite/avatica/remote/KerberosConnectionTest.java
+++ b/avatica/core/src/test/java/org/apache/calcite/avatica/remote/KerberosConnectionTest.java
@@ -22,6 +22,7 @@ import org.junit.Test;
 import org.mockito.Mockito;
 
 import java.io.File;
+import java.util.Locale;
 import java.util.Map.Entry;
 
 import javax.security.auth.Subject;
@@ -135,7 +136,8 @@ public class KerberosConnectionTest {
     end = start + 1000 * 60 * 60 * 24;
     // Ten minutes prior to expiration
     now = end - 1000 * 60 * 10;
-    assertTrue(String.format("start=%d, end=%d, now=%d", start, end, now),
+    assertTrue(
+        String.format(Locale.ROOT, "start=%d, end=%d, now=%d", start, end, now),
         renewal.shouldRenew(start, end, now));
   }
 }

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/test/java/org/apache/calcite/avatica/remote/TypedValueTest.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/test/java/org/apache/calcite/avatica/remote/TypedValueTest.java b/avatica/core/src/test/java/org/apache/calcite/avatica/remote/TypedValueTest.java
index 9343ed2..7606a87 100644
--- a/avatica/core/src/test/java/org/apache/calcite/avatica/remote/TypedValueTest.java
+++ b/avatica/core/src/test/java/org/apache/calcite/avatica/remote/TypedValueTest.java
@@ -20,12 +20,12 @@ import org.apache.calcite.avatica.ColumnMetaData.Rep;
 import org.apache.calcite.avatica.proto.Common;
 import org.apache.calcite.avatica.util.Base64;
 import org.apache.calcite.avatica.util.ByteString;
+import org.apache.calcite.avatica.util.DateTimeUtils;
 
 import org.junit.Test;
 
 import java.math.BigDecimal;
 import java.util.Calendar;
-import java.util.GregorianCalendar;
 
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
@@ -123,7 +123,8 @@ public class TypedValueTest {
     assertEquals(new ByteString(bytes).toBase64String(), (String) deserializedObj);
 
     // But we should get a non-b64 byte array as the JDBC representation
-    deserializedObj = TypedValue.protoToJdbc(proto, GregorianCalendar.getInstance());
+    deserializedObj =
+        TypedValue.protoToJdbc(proto, DateTimeUtils.calendar());
     assertThat(deserializedObj, is(instanceOf(byte[].class)));
     assertArrayEquals(bytes, (byte[]) deserializedObj);
   }
@@ -151,7 +152,7 @@ public class TypedValueTest {
 
   @Test public void testLegacyDecimalParsing() {
     final BigDecimal decimal = new BigDecimal("123451234512345");
-    final Calendar calendar = GregorianCalendar.getInstance();
+    final Calendar calendar = DateTimeUtils.calendar();
 
     // CALCITE-1103 Decimals were (incorrectly) getting serialized as normal "numbers" which
     // caused them to use the numberValue field. TypedValue should still be able to handle
@@ -169,7 +170,7 @@ public class TypedValueTest {
     final byte[] b64Bytes = Base64.encodeBytes(bytes).getBytes(UTF_8);
     TypedValue tv = TypedValue.ofLocal(Rep.BYTE_STRING, new ByteString(bytes));
     // JSON encodes it as base64
-    assertEquals(new String(b64Bytes), tv.value);
+    assertEquals(new String(b64Bytes, UTF_8), tv.value);
 
     // Get the protobuf variant
     Common.TypedValue protoTv = tv.toProto();
@@ -182,7 +183,8 @@ public class TypedValueTest {
     assertArrayEquals(bytes, protoByteString.toByteArray());
 
     // We should have the b64 string as a backwards compatibility feature
-    assertEquals(new String(b64Bytes), protoTv.getStringValue());
+    assertEquals(new String(b64Bytes, UTF_8),
+        protoTv.getStringValue());
   }
 
   @Test public void testLegacyBase64StringEncodingForBytes() {

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/core/src/test/java/org/apache/calcite/avatica/test/AvaticaUtilsTest.java
----------------------------------------------------------------------
diff --git a/avatica/core/src/test/java/org/apache/calcite/avatica/test/AvaticaUtilsTest.java b/avatica/core/src/test/java/org/apache/calcite/avatica/test/AvaticaUtilsTest.java
index 366b507..b1a422c 100644
--- a/avatica/core/src/test/java/org/apache/calcite/avatica/test/AvaticaUtilsTest.java
+++ b/avatica/core/src/test/java/org/apache/calcite/avatica/test/AvaticaUtilsTest.java
@@ -28,6 +28,7 @@ import java.math.BigInteger;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
+import java.util.Locale;
 import java.util.Properties;
 import java.util.Set;
 
@@ -292,11 +293,11 @@ public class AvaticaUtilsTest {
     }
 
     public String name() {
-      return name.toUpperCase();
+      return name.toUpperCase(Locale.ROOT);
     }
 
     public String camelName() {
-      return name.toLowerCase();
+      return name.toLowerCase(Locale.ROOT);
     }
 
     public Object defaultValue() {

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/pom.xml
----------------------------------------------------------------------
diff --git a/avatica/pom.xml b/avatica/pom.xml
index d8952aa..5860bd9 100644
--- a/avatica/pom.xml
+++ b/avatica/pom.xml
@@ -58,6 +58,7 @@ limitations under the License.
     <build-helper-maven-plugin.version>1.9</build-helper-maven-plugin.version>
     <checksum-maven-plugin.version>1.2</checksum-maven-plugin.version>
     <dropwizard-metrics3.version>3.1.2</dropwizard-metrics3.version>
+    <forbiddenapis.version>2.3</forbiddenapis.version>
     <freemarker.version>2.3.19</freemarker.version>
     <git-commit-id-plugin.version>2.1.9</git-commit-id-plugin.version>
     <!-- We support guava versions as old as 14.0.1 (the version used by Hive)
@@ -300,6 +301,39 @@ limitations under the License.
     </extensions>
     <plugins>
       <plugin>
+        <groupId>de.thetaphi</groupId>
+        <artifactId>forbiddenapis</artifactId>
+        <configuration>
+          <!-- if the used Java version is too new, don't fail, just do nothing: -->
+          <failOnUnsupportedJava>false</failOnUnsupportedJava>
+          <bundledSignatures>
+            <!--
+              This will automatically choose the right
+              signatures based on 'maven.compiler.target':
+            -->
+            <bundledSignature>jdk-unsafe</bundledSignature>
+            <bundledSignature>jdk-deprecated</bundledSignature>
+            <!-- disallow undocumented classes like sun.misc.Unsafe: -->
+            <bundledSignature>jdk-non-portable</bundledSignature>
+          </bundledSignatures>
+          <signaturesFiles>
+            <signaturesFile>${top.dir}/src/main/config/forbidden-apis/signatures.txt</signaturesFile>
+          </signaturesFiles>
+          <excludes>
+            <exclude>**/org/apache/calcite/avatica/tck/Unsafe.class</exclude>
+            <exclude>**/org/apache/calcite/avatica/util/Unsafe.class</exclude>
+          </excludes>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>check</goal>
+              <goal>testCheck</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
         <groupId>org.apache.rat</groupId>
         <artifactId>apache-rat-plugin</artifactId>
         <configuration>
@@ -486,6 +520,11 @@ limitations under the License.
           </dependencies>
         </plugin>
         <plugin>
+          <groupId>de.thetaphi</groupId>
+          <artifactId>forbiddenapis</artifactId>
+          <version>${forbiddenapis.version}</version>
+        </plugin>
+        <plugin>
           <groupId>net.hydromatic</groupId>
           <artifactId>hydromatic-resource-maven-plugin</artifactId>
           <version>${hydromatic-resource.version}</version>

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcMeta.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcMeta.java b/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcMeta.java
index e90d78a..4756e8d 100644
--- a/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcMeta.java
+++ b/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcMeta.java
@@ -35,6 +35,7 @@ import org.apache.calcite.avatica.proto.Common;
 import org.apache.calcite.avatica.proto.Requests;
 import org.apache.calcite.avatica.remote.ProtobufMeta;
 import org.apache.calcite.avatica.remote.TypedValue;
+import org.apache.calcite.avatica.util.Unsafe;
 
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
@@ -85,7 +86,7 @@ public class JdbcMeta implements ProtobufMeta {
 
   // End of constants, start of member variables
 
-  final Calendar calendar = Calendar.getInstance();
+  final Calendar calendar = Unsafe.localCalendar();
 
   /** Generates ids for statements. The ids are unique across all connections
    * created by this JdbcMeta. */

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcResultSet.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcResultSet.java b/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcResultSet.java
index 5383289..17b33f8 100644
--- a/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcResultSet.java
+++ b/avatica/server/src/main/java/org/apache/calcite/avatica/jdbc/JdbcResultSet.java
@@ -77,7 +77,7 @@ class JdbcResultSet extends Meta.MetaResultSet {
   public static JdbcResultSet create(String connectionId, int statementId,
       ResultSet resultSet, int maxRowCount, Meta.Signature signature) {
     try {
-      final Calendar calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      final Calendar calendar = DateTimeUtils.calendar();
       final int fetchRowCount;
       if (maxRowCount == JdbcMeta.UNLIMITED_COUNT) {
         fetchRowCount = -1;

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/main/java/org/apache/calcite/avatica/server/HttpServer.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/main/java/org/apache/calcite/avatica/server/HttpServer.java b/avatica/server/src/main/java/org/apache/calcite/avatica/server/HttpServer.java
index 911d359..4c871f0 100644
--- a/avatica/server/src/main/java/org/apache/calcite/avatica/server/HttpServer.java
+++ b/avatica/server/src/main/java/org/apache/calcite/avatica/server/HttpServer.java
@@ -49,6 +49,7 @@ import java.security.Principal;
 import java.security.PrivilegedAction;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -246,7 +247,8 @@ public class HttpServer {
 
     final int port = connector.getLocalPort();
 
-    return new RpcMetadataResponse(String.format("%s:%d", host, port));
+    return new RpcMetadataResponse(
+        String.format(Locale.ROOT, "%s:%d", host, port));
   }
 
   /**
@@ -804,7 +806,9 @@ public class HttpServer {
         options.put("doNotPrompt", "true");
         options.put("useKeyTab", "true");
         options.put("isInitiator", "false");
-        options.put("debug", System.getProperty("sun.security.krb5.debug", "false").toLowerCase());
+        options.put("debug",
+            System.getProperty("sun.security.krb5.debug", "false")
+                .toLowerCase(Locale.ROOT));
 
         return new AppConfigurationEntry[] {new AppConfigurationEntry(getKrb5LoginModuleName(),
             AppConfigurationEntry.LoginModuleControlFlag.REQUIRED, options)};

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/RemoteDriverTest.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/RemoteDriverTest.java b/avatica/server/src/test/java/org/apache/calcite/avatica/RemoteDriverTest.java
index 10bf85f..0823a12 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/RemoteDriverTest.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/RemoteDriverTest.java
@@ -26,6 +26,7 @@ import org.apache.calcite.avatica.remote.ProtobufTranslation;
 import org.apache.calcite.avatica.remote.ProtobufTranslationImpl;
 import org.apache.calcite.avatica.remote.Service;
 import org.apache.calcite.avatica.remote.TypedValue;
+import org.apache.calcite.avatica.util.DateTimeUtils;
 
 import com.google.common.cache.Cache;
 
@@ -59,6 +60,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.TimeZone;
@@ -363,10 +365,11 @@ public class RemoteDriverTest {
   @Test public void testInsertDrop() throws Exception {
     final String t = AvaticaUtils.unique("TEST_TABLE2");
     final String create =
-        String.format("create table if not exists %s ("
+        String.format(Locale.ROOT, "create table if not exists %s ("
             + "id int not null, "
             + "msg varchar(3) not null)", t);
-    final String insert = String.format("insert into %s values(1, 'foo')", t);
+    final String insert = String.format(Locale.ROOT,
+        "insert into %s values(1, 'foo')", t);
     Connection connection = ljs();
     Statement statement = connection.createStatement();
     statement.execute(create);
@@ -558,14 +561,17 @@ public class RemoteDriverTest {
   @Test public void testCreateInsertUpdateDrop() throws Exception {
     ConnectionSpec.getDatabaseLock().lock();
     final String t = AvaticaUtils.unique("TEST_TABLE");
-    final String drop = String.format("drop table %s if exists", t);
-    final String create = String.format("create table %s("
-        + "id int not null, "
-        + "msg varchar(3) not null)",
-        t);
-    final String insert = String.format("insert into %s values(1, 'foo')", t);
+    final String drop =
+        String.format(Locale.ROOT, "drop table %s if exists", t);
+    final String create =
+        String.format(Locale.ROOT, "create table %s("
+                + "id int not null, "
+                + "msg varchar(3) not null)",
+            t);
+    final String insert = String.format(Locale.ROOT,
+        "insert into %s values(1, 'foo')", t);
     final String update =
-        String.format("update %s set msg='bar' where id=1", t);
+        String.format(Locale.ROOT, "update %s set msg='bar' where id=1", t);
     try (Connection connection = getLocalConnection();
         Statement statement = connection.createStatement();
         PreparedStatement pstmt = connection.prepareStatement("values 1")) {
@@ -681,9 +687,11 @@ public class RemoteDriverTest {
   private void assertResultSetsEqual(Statement s1, Statement s2)
       throws SQLException {
     final TimeZone moscowTz = TimeZone.getTimeZone("Europe/Moscow");
-    final Calendar moscowCalendar = Calendar.getInstance(moscowTz);
+    final Calendar moscowCalendar =
+        Calendar.getInstance(moscowTz, Locale.ROOT);
     final TimeZone alaskaTz = TimeZone.getTimeZone("America/Anchorage");
-    final Calendar alaskaCalendar = Calendar.getInstance(alaskaTz);
+    final Calendar alaskaCalendar =
+        Calendar.getInstance(alaskaTz, Locale.ROOT);
     try (ResultSet rs1 = s1.getResultSet();
         ResultSet rs2 = s2.getResultSet()) {
       assertEquals(rs1.getMetaData().getColumnCount(),
@@ -1058,12 +1066,14 @@ public class RemoteDriverTest {
     try (Statement stmt = conn.createStatement()) {
       final String tableName = AvaticaUtils.unique("BATCH_EXECUTE");
       LOG.info("Creating table {}", tableName);
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10) not null)", tableName);
+      final String createCommand = String.format(Locale.ROOT,
+          "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10) not null)", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
 
-      final String updatePrefix = String.format("INSERT INTO %s values(", tableName);
+      final String updatePrefix =
+          String.format(Locale.ROOT, "INSERT INTO %s values(", tableName);
       for (int i = 0; i < numRows;  i++) {
         stmt.addBatch(updatePrefix + i + ", '" + Integer.toString(i) + "')");
       }
@@ -1104,13 +1114,15 @@ public class RemoteDriverTest {
     final String tableName = AvaticaUtils.unique("PREPARED_BATCH_EXECUTE");
     LOG.info("Creating table {}", tableName);
     try (Statement stmt = conn.createStatement()) {
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10) not null)", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10) not null)", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
     }
 
-    final String insertSql = String.format("INSERT INTO %s values(?, ?)", tableName);
+    final String insertSql =
+        String.format(Locale.ROOT, "INSERT INTO %s values(?, ?)", tableName);
     try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
       // Add batches with the prepared statement
       for (int i = 0; i < numRows; i++) {
@@ -1157,13 +1169,15 @@ public class RemoteDriverTest {
     final String tableName = AvaticaUtils.unique("PREPARED_INSERT_EXECUTE");
     LOG.info("Creating table {}", tableName);
     try (Statement stmt = conn.createStatement()) {
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10) not null)", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10) not null)", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
     }
 
-    final String insertSql = String.format("INSERT INTO %s values(?, ?)", tableName);
+    final String insertSql =
+        String.format(Locale.ROOT, "INSERT INTO %s values(?, ?)", tableName);
     try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
       // Add batches with the prepared statement
       for (int i = 0; i < numRows; i++) {
@@ -1204,13 +1218,15 @@ public class RemoteDriverTest {
     final String tableName = AvaticaUtils.unique("PREPARED_INSERT_EXECUTE_NULLS");
     LOG.info("Creating table {}", tableName);
     try (Statement stmt = conn.createStatement()) {
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10))", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10))", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
     }
 
-    final String insertSql = String.format("INSERT INTO %s values(?, ?)", tableName);
+    final String insertSql =
+        String.format(Locale.ROOT, "INSERT INTO %s values(?, ?)", tableName);
     try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
       // Add batches with the prepared statement
       for (int i = 0; i < numRows; i++) {
@@ -1260,13 +1276,15 @@ public class RemoteDriverTest {
     final String tableName = AvaticaUtils.unique("BATCH_INSERT_EXECUTE_NULLS");
     LOG.info("Creating table {}", tableName);
     try (Statement stmt = conn.createStatement()) {
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10))", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10))", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
     }
 
-    final String insertSql = String.format("INSERT INTO %s values(?, ?)", tableName);
+    final String insertSql =
+        String.format(Locale.ROOT, "INSERT INTO %s values(?, ?)", tableName);
     try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
       // Add batches with the prepared statement
       for (int i = 0; i < numRows; i++) {
@@ -1367,22 +1385,25 @@ public class RemoteDriverTest {
   }
 
   private void executeBatchInsertWithDates(Connection conn) throws Exception {
-    final Calendar calendar = Calendar.getInstance();
+    final Calendar calendar = DateTimeUtils.calendar();
     long now = calendar.getTime().getTime();
     final int numRows = 10;
     final String tableName = AvaticaUtils.unique("BATCH_INSERT_EXECUTE_DATES");
     LOG.info("Creating table {}", tableName);
     try (Statement stmt = conn.createStatement()) {
-      final String dropCommand = String.format("drop table if exists %s", tableName);
+      final String dropCommand =
+          String.format(Locale.ROOT, "drop table if exists %s", tableName);
       assertFalse("Failed to drop table", stmt.execute(dropCommand));
-      final String createCommand = String.format("create table %s ("
-          + "id char(15) not null, "
-          + "created_date date not null, "
-          + "val_string varchar)", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table %s ("
+              + "id char(15) not null, "
+              + "created_date date not null, "
+              + "val_string varchar)", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
     }
 
-    final String insertSql = String.format("INSERT INTO %s values(?, ?, ?)", tableName);
+    final String insertSql =
+        String.format(Locale.ROOT, "INSERT INTO %s values(?, ?, ?)", tableName);
     try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
       // Add batches with the prepared statement
       for (int i = 0; i < numRows; i++) {
@@ -1472,7 +1493,7 @@ public class RemoteDriverTest {
       assertNotNull(metadata);
       String actualColumnName = metadata.getColumnName(1);
       // HSQLDB is going to upper-case the column name
-      assertEquals(columnName.toUpperCase(), actualColumnName);
+      assertEquals(columnName.toUpperCase(Locale.ROOT), actualColumnName);
     } finally {
       ConnectionSpec.getDatabaseLock().unlock();
     }
@@ -1521,13 +1542,15 @@ public class RemoteDriverTest {
     final String tableName = AvaticaUtils.unique("BATCH_CLEARS");
     LOG.info("Creating table {}", tableName);
     try (Statement stmt = conn.createStatement()) {
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10) not null)", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10) not null)", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
     }
 
-    final String insertSql = String.format("INSERT INTO %s values(?, ?)", tableName);
+    final String insertSql =
+        String.format(Locale.ROOT, "INSERT INTO %s values(?, ?)", tableName);
     try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
       // Add batches with the prepared statement
       for (int i = 0; i < numRows; i++) {
@@ -1579,12 +1602,14 @@ public class RemoteDriverTest {
     try (Statement stmt = conn.createStatement()) {
       final String tableName = AvaticaUtils.unique("BATCH_EXECUTE");
       LOG.info("Creating table {}", tableName);
-      final String createCommand = String.format("create table if not exists %s ("
-          + "id int not null, "
-          + "msg varchar(10) not null)", tableName);
+      final String createCommand =
+          String.format(Locale.ROOT, "create table if not exists %s ("
+              + "id int not null, "
+              + "msg varchar(10) not null)", tableName);
       assertFalse("Failed to create table", stmt.execute(createCommand));
 
-      final String updatePrefix = String.format("INSERT INTO %s values(", tableName);
+      final String updatePrefix =
+          String.format(Locale.ROOT, "INSERT INTO %s values(", tableName);
       for (int i = 0; i < numRows;  i++) {
         stmt.addBatch(updatePrefix + i + ", '" + Integer.toString(i) + "')");
         if (numRows / 2 - 1 == i) {
@@ -1688,7 +1713,7 @@ public class RemoteDriverTest {
       String sql = "CREATE TABLE " + tableName + " (keycolumn VARCHAR(5), column1 date)";
       assertFalse(stmt.execute(sql));
       TimeZone tzUtc = TimeZone.getTimeZone("UTC");
-      Calendar cUtc = Calendar.getInstance(tzUtc);
+      Calendar cUtc = Calendar.getInstance(tzUtc, Locale.ROOT);
       cUtc.set(Calendar.YEAR, 1970);
       cUtc.set(Calendar.MONTH, Calendar.JANUARY);
       cUtc.set(Calendar.DAY_OF_MONTH, 1);
@@ -1726,7 +1751,7 @@ public class RemoteDriverTest {
       String sql = "CREATE TABLE " + tableName + " (keycolumn VARCHAR(5), column1 date)";
       assertFalse(stmt.execute(sql));
       TimeZone tzUtc = TimeZone.getTimeZone("GMT+8");
-      Calendar cUtc = Calendar.getInstance(tzUtc);
+      Calendar cUtc = Calendar.getInstance(tzUtc, Locale.ROOT);
       cUtc.set(Calendar.YEAR, 1970);
       cUtc.set(Calendar.MONTH, Calendar.JANUARY);
       cUtc.set(Calendar.DAY_OF_MONTH, 1);

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/SpnegoTestUtil.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/SpnegoTestUtil.java b/avatica/server/src/test/java/org/apache/calcite/avatica/SpnegoTestUtil.java
index 21248f6..ab4491d 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/SpnegoTestUtil.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/SpnegoTestUtil.java
@@ -32,9 +32,11 @@ import org.eclipse.jetty.server.handler.DefaultHandler;
 
 import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileWriter;
+import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.OutputStreamWriter;
 import java.net.ServerSocket;
+import java.nio.charset.StandardCharsets;
 import java.security.AccessController;
 import java.security.Principal;
 import java.security.PrivilegedAction;
@@ -99,7 +101,11 @@ public class SpnegoTestUtil {
    */
   public static void writeSpnegoConf(File configFile, File serverKeytab)
       throws Exception {
-    try (BufferedWriter writer = new BufferedWriter(new FileWriter(configFile))) {
+    try (BufferedWriter writer =
+             new BufferedWriter(
+                 new OutputStreamWriter(
+                     new FileOutputStream(configFile),
+                     StandardCharsets.UTF_8))) {
       // Server login
       writer.write("com.sun.security.jgss.accept {\n");
       writer.write(" com.sun.security.auth.module.Krb5LoginModule required\n");

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/SslDriverTest.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/SslDriverTest.java b/avatica/server/src/test/java/org/apache/calcite/avatica/SslDriverTest.java
index 9dcdfa2..e3b89f5 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/SslDriverTest.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/SslDriverTest.java
@@ -20,6 +20,7 @@ import org.apache.calcite.avatica.jdbc.JdbcMeta;
 import org.apache.calcite.avatica.remote.Driver;
 import org.apache.calcite.avatica.remote.LocalService;
 import org.apache.calcite.avatica.server.HttpServer;
+import org.apache.calcite.avatica.util.DateTimeUtils;
 
 import org.bouncycastle.asn1.x500.X500Name;
 import org.bouncycastle.asn1.x500.style.IETFUtils;
@@ -195,8 +196,8 @@ public class SslDriverTest {
         PublicKey signerPublicKey, PrivateKey signerPrivateKey) throws IOException,
         CertIOException, OperatorCreationException, CertificateException,
         NoSuchAlgorithmException {
-      Calendar startDate = Calendar.getInstance();
-      Calendar endDate = Calendar.getInstance();
+      Calendar startDate = DateTimeUtils.calendar();
+      Calendar endDate = DateTimeUtils.calendar();
       endDate.add(Calendar.YEAR, 100);
 
       BigInteger serialNumber = BigInteger.valueOf(startDate.getTimeInMillis());

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/remote/RemoteMetaTest.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/remote/RemoteMetaTest.java b/avatica/server/src/test/java/org/apache/calcite/avatica/remote/RemoteMetaTest.java
index 24bcdc6..ebd3c76 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/remote/RemoteMetaTest.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/remote/RemoteMetaTest.java
@@ -66,6 +66,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Random;
@@ -319,14 +320,15 @@ public class RemoteMetaTest {
       AvaticaConnection conn = (AvaticaConnection) DriverManager.getConnection(url);
       Statement statement = conn.createStatement();
       final String create =
-          String.format("create table if not exists %s ("
+          String.format(Locale.ROOT, "create table if not exists %s ("
               + "  id int not null, msg varchar(255) not null)", t);
       int status = statement.executeUpdate(create);
       assertEquals(status, 0);
 
       statement = conn.createStatement();
-      final String update = String.format("insert into %s values ('%d', '%s')",
-          t, RANDOM.nextInt(Integer.MAX_VALUE), UUID.randomUUID());
+      final String update =
+          String.format(Locale.ROOT, "insert into %s values ('%d', '%s')",
+              t, RANDOM.nextInt(Integer.MAX_VALUE), UUID.randomUUID());
       status = statement.executeUpdate(update);
       assertEquals(status, 1);
     } finally {
@@ -584,26 +586,35 @@ public class RemoteMetaTest {
       assertFalse(stmt.execute("DROP TABLE IF EXISTS " + productTable));
       assertFalse(
           stmt.execute(
-              String.format("CREATE TABLE %s(id integer, stock integer)", productTable)));
+              String.format(Locale.ROOT,
+                  "CREATE TABLE %s(id integer, stock integer)",
+                  productTable)));
       assertFalse(stmt.execute("DROP TABLE IF EXISTS " + salesTable));
       assertFalse(
           stmt.execute(
-              String.format("CREATE TABLE %s(id integer, units_sold integer)", salesTable)));
+              String.format(Locale.ROOT,
+                  "CREATE TABLE %s(id integer, units_sold integer)",
+                  salesTable)));
 
       final int productId = 1;
       // No products and no sales
       assertFalse(
           stmt.execute(
-              String.format("INSERT INTO %s VALUES(%d, 0)", productTable, productId)));
+              String.format(Locale.ROOT, "INSERT INTO %s VALUES(%d, 0)",
+                  productTable, productId)));
       assertFalse(
           stmt.execute(
-              String.format("INSERT INTO %s VALUES(%d, 0)", salesTable, productId)));
+              String.format(Locale.ROOT, "INSERT INTO %s VALUES(%d, 0)",
+                  salesTable, productId)));
 
       conn.setAutoCommit(false);
       PreparedStatement productStmt = conn.prepareStatement(
-          String.format("UPDATE %s SET stock = stock + ? WHERE id = ?", productTable));
+          String.format(Locale.ROOT,
+              "UPDATE %s SET stock = stock + ? WHERE id = ?", productTable));
       PreparedStatement salesStmt = conn.prepareStatement(
-          String.format("UPDATE %s SET units_sold = units_sold + ? WHERE id = ?", salesTable));
+          String.format(Locale.ROOT,
+              "UPDATE %s SET units_sold = units_sold + ? WHERE id = ?",
+              salesTable));
 
       // No stock
       assertEquals(0, getInventory(conn, productTable, productId));
@@ -651,7 +662,8 @@ public class RemoteMetaTest {
   private int getInventory(Connection conn, String productTable, int productId) throws Exception {
     try (Statement stmt = conn.createStatement()) {
       ResultSet results = stmt.executeQuery(
-          String.format("SELECT stock FROM %s WHERE id = %d", productTable, productId));
+          String.format(Locale.ROOT, "SELECT stock FROM %s WHERE id = %d",
+              productTable, productId));
       assertTrue(results.next());
       return results.getInt(1);
     }
@@ -660,7 +672,8 @@ public class RemoteMetaTest {
   private int getSales(Connection conn, String salesTable, int productId) throws Exception {
     try (Statement stmt = conn.createStatement()) {
       ResultSet results = stmt.executeQuery(
-          String.format("SELECT units_sold FROM %s WHERE id = %d", salesTable, productId));
+          String.format(Locale.ROOT, "SELECT units_sold FROM %s WHERE id = %d",
+              salesTable, productId));
       assertTrue(results.next());
       return results.getInt(1);
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/server/AbstractAvaticaHandlerTest.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/server/AbstractAvaticaHandlerTest.java b/avatica/server/src/test/java/org/apache/calcite/avatica/server/AbstractAvaticaHandlerTest.java
index c5f9441..66eb361 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/server/AbstractAvaticaHandlerTest.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/server/AbstractAvaticaHandlerTest.java
@@ -24,6 +24,7 @@ import org.junit.Before;
 import org.junit.Test;
 
 import java.net.HttpURLConnection;
+import java.nio.charset.StandardCharsets;
 
 import javax.servlet.ServletOutputStream;
 import javax.servlet.http.HttpServletRequest;
@@ -72,7 +73,7 @@ public class AbstractAvaticaHandlerTest {
       }
 
       @Override public boolean matches(Object item) {
-        String msg = new String((byte[]) item);
+        String msg = new String((byte[]) item, StandardCharsets.UTF_8);
         return msg.contains("User is not authenticated");
       }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithJaasTest.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithJaasTest.java b/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithJaasTest.java
index e9c5299..8f6fede 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithJaasTest.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithJaasTest.java
@@ -38,6 +38,7 @@ import org.slf4j.LoggerFactory;
 import java.io.File;
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.security.Principal;
 import java.security.PrivilegedExceptionAction;
 import java.util.Set;
@@ -220,7 +221,8 @@ public class HttpServerSpnegoWithJaasTest {
 
     // We should get a response which is "OK" with our client's name
     assertNotNull(response);
-    assertEquals("OK " + SpnegoTestUtil.CLIENT_PRINCIPAL, new String(response));
+    assertEquals("OK " + SpnegoTestUtil.CLIENT_PRINCIPAL,
+        new String(response, StandardCharsets.UTF_8));
   }
 }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithoutJaasTest.java
----------------------------------------------------------------------
diff --git a/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithoutJaasTest.java b/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithoutJaasTest.java
index 1f234d2..d30b760 100644
--- a/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithoutJaasTest.java
+++ b/avatica/server/src/test/java/org/apache/calcite/avatica/server/HttpServerSpnegoWithoutJaasTest.java
@@ -38,6 +38,7 @@ import org.slf4j.LoggerFactory;
 import java.io.File;
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.security.Principal;
 import java.security.PrivilegedExceptionAction;
 import java.util.Set;
@@ -211,7 +212,8 @@ public class HttpServerSpnegoWithoutJaasTest {
 
     // We should get a response which is "OK" with our client's name
     assertNotNull(response);
-    assertEquals("OK " + SpnegoTestUtil.CLIENT_PRINCIPAL, new String(response));
+    assertEquals("OK " + SpnegoTestUtil.CLIENT_PRINCIPAL,
+        new String(response, StandardCharsets.UTF_8));
   }
 }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/src/main/config/forbidden-apis/signatures.txt
----------------------------------------------------------------------
diff --git a/avatica/src/main/config/forbidden-apis/signatures.txt b/avatica/src/main/config/forbidden-apis/signatures.txt
new file mode 100644
index 0000000..588837d
--- /dev/null
+++ b/avatica/src/main/config/forbidden-apis/signatures.txt
@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to you under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Signatures of APIs to avoid.
+# Cribbed from Elasticsearch
+
+java.lang.Character#codePointBefore(char[],int) @ Implicit start offset is error-prone when the char[] is a buffer and the first chars are random chars
+java.lang.Character#codePointAt(char[],int) @ Implicit end offset is error-prone when the char[] is a buffer and the last chars are random chars
+
+@defaultMessage Only use wait / notify when really needed try to use concurrency primitives, latches or callbacks instead.
+java.lang.Object#wait()
+java.lang.Object#wait(long)
+java.lang.Object#wait(long,int)
+java.lang.Object#notify()
+java.lang.Object#notifyAll()
+
+@defaultMessage Please do not try to stop the world
+java.lang.System#gc()
+
+@defaultMessage Please do not try to kill the world
+java.lang.System#exit(int)
+java.lang.Runtime#exit(int)
+
+@defaultMessage Don't interrupt threads; use FutureUtils#cancel(Future<T>) instead
+java.util.concurrent.Future#cancel(boolean)
+
+# End signatures.txt

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/standalone-server/src/main/java/org/apache/calcite/avatica/hsqldb/HsqldbServer.java
----------------------------------------------------------------------
diff --git a/avatica/standalone-server/src/main/java/org/apache/calcite/avatica/hsqldb/HsqldbServer.java b/avatica/standalone-server/src/main/java/org/apache/calcite/avatica/hsqldb/HsqldbServer.java
index 3e873a5..9e30dad 100644
--- a/avatica/standalone-server/src/main/java/org/apache/calcite/avatica/hsqldb/HsqldbServer.java
+++ b/avatica/standalone-server/src/main/java/org/apache/calcite/avatica/hsqldb/HsqldbServer.java
@@ -20,6 +20,7 @@ import org.apache.calcite.avatica.jdbc.JdbcMeta;
 import org.apache.calcite.avatica.remote.Driver.Serialization;
 import org.apache.calcite.avatica.remote.LocalService;
 import org.apache.calcite.avatica.server.HttpServer;
+import org.apache.calcite.avatica.util.Unsafe;
 
 import com.beust.jcommander.IStringConverter;
 import com.beust.jcommander.JCommander;
@@ -30,6 +31,8 @@ import net.hydromatic.scott.data.hsqldb.ScottHsqldb;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Locale;
+
 /**
  * An Avatica server for HSQLDB.
  */
@@ -49,7 +52,7 @@ public class HsqldbServer {
   public void start() {
     if (null != server) {
       LOG.error("The server was already started");
-      System.exit(ExitCodes.ALREADY_STARTED.ordinal());
+      Unsafe.systemExit(ExitCodes.ALREADY_STARTED.ordinal());
       return;
     }
 
@@ -71,7 +74,7 @@ public class HsqldbServer {
           serialization);
     } catch (Exception e) {
       LOG.error("Failed to start Avatica server", e);
-      System.exit(ExitCodes.START_FAILED.ordinal());
+      Unsafe.systemExit(ExitCodes.START_FAILED.ordinal());
     }
   }
 
@@ -117,7 +120,7 @@ public class HsqldbServer {
    */
   public static class SerializationConverter implements IStringConverter<Serialization> {
     @Override public Serialization convert(String value) {
-      return Serialization.valueOf(value.toUpperCase());
+      return Serialization.valueOf(value.toUpperCase(Locale.ROOT));
     }
   }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/TestRunner.java
----------------------------------------------------------------------
diff --git a/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/TestRunner.java b/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/TestRunner.java
index 9ada4a4..6807354 100644
--- a/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/TestRunner.java
+++ b/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/TestRunner.java
@@ -77,7 +77,7 @@ public class TestRunner implements Runnable {
 
     if (null == driver) {
       LOG.error("Failed to find driver for {}", jdbcUrl);
-      System.exit(TestRunnerExitCodes.NO_SUCH_DRIVER.ordinal());
+      Unsafe.systemExit(TestRunnerExitCodes.NO_SUCH_DRIVER.ordinal());
       return;
     }
 
@@ -98,10 +98,10 @@ public class TestRunner implements Runnable {
 
     if (globalResults.numFailed > 0) {
       // Tests failed, don't exit normally
-      System.exit(TestRunnerExitCodes.FAILED_TESTS.ordinal());
+      Unsafe.systemExit(TestRunnerExitCodes.FAILED_TESTS.ordinal());
     } else {
       // Exited normally
-      System.exit(TestRunnerExitCodes.NORMAL.ordinal());
+      Unsafe.systemExit(TestRunnerExitCodes.NORMAL.ordinal());
     }
   }
 
@@ -132,7 +132,7 @@ public class TestRunner implements Runnable {
       return testClasses;
     } catch (Exception e) {
       LOG.error("Failed to instantiate test classes", e);
-      System.exit(TestRunnerExitCodes.TEST_CASE_INSTANTIATION.ordinal());
+      Unsafe.systemExit(TestRunnerExitCodes.TEST_CASE_INSTANTIATION.ordinal());
       // Unreachable..
       return null;
     }
@@ -146,10 +146,10 @@ public class TestRunner implements Runnable {
       driver = DriverManager.getDriver(driverUrl);
     } catch (SQLException e) {
       LOG.error("Could not instantiate JDBC Driver with URL: '{}'", jdbcUrl, e);
-      System.exit(TestRunnerExitCodes.BAD_JDBC_URL.ordinal());
+      Unsafe.systemExit(TestRunnerExitCodes.BAD_JDBC_URL.ordinal());
     } catch (ClassNotFoundException e) {
       LOG.error("Could not load Avatica Driver class", e);
-      System.exit(TestRunnerExitCodes.MISSING_DRIVER_CLASS.ordinal());
+      Unsafe.systemExit(TestRunnerExitCodes.MISSING_DRIVER_CLASS.ordinal());
     }
   }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/8df27ce9/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/Unsafe.java
----------------------------------------------------------------------
diff --git a/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/Unsafe.java b/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/Unsafe.java
new file mode 100644
index 0000000..e88b6b7
--- /dev/null
+++ b/avatica/tck/src/main/java/org/apache/calcite/avatica/tck/Unsafe.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.avatica.tck;
+
+import java.util.Calendar;
+import java.util.Locale;
+
+/**
+ * Contains methods that call JDK methods that the
+ * <a href="https://github.com/policeman-tools/forbidden-apis">forbidden
+ * APIs checker</a> does not approve of.
+ *
+ * <p>This class is excluded from the check, so methods called via this class
+ * will not fail the build.
+ */
+class Unsafe {
+  private Unsafe() {}
+
+  /** Calls {@link System#exit}. */
+  static void systemExit(int status) {
+    System.exit(status);
+  }
+
+  /** Calls {@link Object#notifyAll()}. */
+  public static void notifyAll(Object o) {
+    o.notifyAll();
+  }
+
+  /** Calls {@link Object#wait()}. */
+  public static void wait(Object o) throws InterruptedException {
+    o.wait();
+  }
+
+  /** Returns a {@link Calendar} with the local time zone and root
+   * locale. */
+  public static Calendar localCalendar() {
+    return Calendar.getInstance(Locale.ROOT);
+  }
+}
+
+// End Unsafe.java


[09/10] calcite git commit: [CALCITE-1641] Add parser and validator support for MATCH_RECOGNIZE (Zhiqiang-He)

Posted by jh...@apache.org.
[CALCITE-1641] Add parser and validator support for MATCH_RECOGNIZE (Zhiqiang-He)

Close apache/calcite#378


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/4e103825
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/4e103825
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/4e103825

Branch: refs/heads/master
Commit: 4e1038255163792b8055d1b0c3f312bda872252d
Parents: 255cd96
Author: Zhiqiang-He <ab...@qq.com>
Authored: Tue Feb 21 19:44:11 2017 +0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Sat Mar 4 13:02:44 2017 -0800

----------------------------------------------------------------------
 core/src/main/codegen/templates/Parser.jj       | 367 +++++++++++++++-
 .../calcite/prepare/CalciteMaterializer.java    |   6 +-
 .../calcite/rel/RelHomogeneousShuttle.java      |   5 +
 .../java/org/apache/calcite/rel/RelShuttle.java |   3 +
 .../org/apache/calcite/rel/RelShuttleImpl.java  |   5 +
 .../java/org/apache/calcite/rel/core/Match.java | 274 ++++++++++++
 .../apache/calcite/rel/core/RelFactories.java   |  30 ++
 .../calcite/rel/logical/LogicalMatch.java       |  77 ++++
 .../calcite/rel/rel2sql/RelToSqlConverter.java  |  33 ++
 .../calcite/rel/rel2sql/SqlImplementor.java     |  26 ++
 .../org/apache/calcite/rex/LogicVisitor.java    |   4 +
 .../org/apache/calcite/rex/RexBiVisitor.java    |   2 +
 .../apache/calcite/rex/RexPatternFieldRef.java  |  59 +++
 .../java/org/apache/calcite/rex/RexShuttle.java |   4 +
 .../java/org/apache/calcite/rex/RexUtil.java    |   4 +
 .../java/org/apache/calcite/rex/RexVisitor.java |   2 +
 .../org/apache/calcite/rex/RexVisitorImpl.java  |   4 +
 .../apache/calcite/runtime/CalciteResource.java |  21 +
 .../apache/calcite/sql/SqlFunctionCategory.java |   3 +-
 .../java/org/apache/calcite/sql/SqlKind.java    |  55 +++
 .../apache/calcite/sql/SqlMatchRecognize.java   | 216 +++++++++
 .../java/org/apache/calcite/sql/SqlSelect.java  |  10 +-
 .../calcite/sql/fun/SqlStdOperatorTable.java    | 158 +++++++
 .../apache/calcite/sql/type/OperandTypes.java   |   3 +-
 .../calcite/sql/validate/DelegatingScope.java   |   3 +-
 .../sql/validate/MatchRecognizeNamespace.java   |  47 ++
 .../sql/validate/MatchRecognizeScope.java       |  94 ++++
 .../calcite/sql/validate/SqlValidator.java      |  16 +
 .../calcite/sql/validate/SqlValidatorImpl.java  | 440 ++++++++++++++++++-
 .../sql2rel/RelStructuredTypeFlattener.java     |   5 +
 .../calcite/sql2rel/SqlToRelConverter.java      |  85 ++++
 .../sql2rel/StandardConvertletTable.java        |   9 +-
 .../calcite/runtime/CalciteResource.properties  |   7 +
 .../prepare/LookupOperatorOverloadsTest.java    |   3 +-
 .../rel/rel2sql/RelToSqlConverterTest.java      | 350 +++++++++++++++
 .../calcite/sql/parser/SqlParserTest.java       | 292 ++++++++++++
 .../apache/calcite/sql/test/SqlAdvisorTest.java |   3 +
 .../apache/calcite/test/SqlValidatorTest.java   | 105 +++++
 site/_docs/reference.md                         | 118 ++++-
 39 files changed, 2913 insertions(+), 35 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/codegen/templates/Parser.jj
----------------------------------------------------------------------
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index b070530..6371c24 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -67,6 +67,7 @@ import org.apache.calcite.sql.SqlJdbcFunctionCall;
 import org.apache.calcite.sql.SqlJoin;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlMerge;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
@@ -226,9 +227,9 @@ public class ${parser.class} extends SqlAbstractParserImpl
 PARSER_END(${parser.class})
 
 
-/*****************************************
- * Utility Codes for Semantical Analysis *
- *****************************************/
+/***************************************
+ * Utility Codes for Semantic Analysis *
+ ***************************************/
 
 /* For Debug */
 JAVACODE
@@ -321,10 +322,6 @@ SqlNode FloorCeilOptions(SqlParserPos pos, boolean floorFlag) :
     }
 }
 
-
-
-// End Parser.jj
-
 /*
 // This file contains the heart of a parser for SQL SELECT statements.
 // code can be shared between various parsers (for example, a DDL parser and a
@@ -1823,6 +1820,14 @@ SqlNode TableRef2(boolean lateral) :
                     pos, tableRef, over);
             }
         }
+        [
+            over = MatchRecognizeOpt(tableRef)
+            {
+                if (over != null) {
+                    tableRef = over;
+                }
+            }
+        ]
     |
         [ <LATERAL> { lateral = true; } ]
         tableRef = ParenthesizedExpression(ExprContext.ACCEPT_QUERY)
@@ -1838,6 +1843,14 @@ SqlNode TableRef2(boolean lateral) :
                     getPos(), tableRef);
             }
         }
+        (
+            [ over = MatchRecognizeOpt(tableRef) ]
+            {
+                if (over != null) {
+                    tableRef = over;
+                }
+            }
+        )
     |
         <UNNEST> { pos = getPos(); }
         args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY)
@@ -2462,6 +2475,236 @@ SqlNode OrderItem() :
     }
 }
 
+/**
+ * Parses a MATCH_RECOGNIZE clause following a table expression.
+ */
+SqlMatchRecognize MatchRecognizeOpt(SqlNode tableRef) :
+{
+    final SqlParserPos startPos;
+    SqlParserPos pos;
+    SqlNode pattern;
+    SqlNodeList patternDefList;
+    SqlLiteral isStrictStarts = SqlLiteral.createBoolean(false, getPos());
+    SqlLiteral isStrictEnds = SqlLiteral.createBoolean(false, getPos());
+}
+{
+    <MATCH_RECOGNIZE> { startPos = getPos(); } <LPAREN>
+    <PATTERN>
+    <LPAREN>
+    (
+        <CARET> { isStrictStarts = SqlLiteral.createBoolean(true, getPos()); }
+    |
+        { isStrictStarts = SqlLiteral.createBoolean(false, getPos()); }
+    )
+    pattern = PatternExpression()
+    (
+        <DOLLAR> { isStrictEnds = SqlLiteral.createBoolean(true, getPos()); }
+    |
+        { isStrictEnds = SqlLiteral.createBoolean(false, getPos()); }
+    )
+    <RPAREN>
+    <DEFINE> { pos = getPos(); }
+    patternDefList = PatternDefinitionCommaList(pos)
+    <RPAREN> {
+        return new SqlMatchRecognize(startPos.plus(getPos()), tableRef,
+            pattern, isStrictStarts, isStrictEnds, patternDefList);
+    }
+}
+
+SqlNode PatternExpression() :
+{
+    SqlNode left;
+    SqlNode right;
+}
+{
+    left = PatternTerm()
+    (
+        <VERTICAL_BAR>
+        right = PatternTerm() {
+            left = SqlStdOperatorTable.PATTERN_ALTER.createCall(
+                left.getParserPosition().plus(getPos()), left, right);
+        }
+    )*
+    {
+        return left;
+    }
+}
+
+SqlNode PatternTerm() :
+{
+    SqlNode left;
+    SqlNode right;
+}
+{
+    left = PatternFactor()
+    (
+        right = PatternFactor() {
+            left = SqlStdOperatorTable.PATTERN_CONCAT.createCall(
+                left.getParserPosition().plus(getPos()), left, right);
+        }
+    )*
+    {
+        return left;
+    }
+}
+
+SqlNode PatternFactor() :
+{
+    SqlNode e;
+    SqlNode extra;
+    SqlLiteral startNum = null;
+    SqlLiteral endNum = null;
+    SqlLiteral reluctant = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
+}
+{
+    e = PatternPrimary()
+    [
+        (
+            <STAR> {
+                startNum = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
+                endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
+            }
+        |
+            <PLUS> {
+                startNum = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
+                endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
+            }
+        |
+            <HOOK> {
+                startNum = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
+                endNum = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
+            }
+        |
+            <LBRACE>
+            (
+                startNum = UnsignedNumericLiteral() { endNum = startNum; }
+                [
+                    <COMMA> {
+                        endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
+                    }
+                    [
+                        endNum = UnsignedNumericLiteral()
+                    ]
+                ]
+                <RBRACE>
+            |
+                {
+                    startNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
+                }
+                <COMMA>
+                endNum = UnsignedNumericLiteral()
+                <RBRACE>
+            |
+                <MINUS> extra = PatternExpression() <MINUS> <RBRACE> {
+                    extra = SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(
+                        extra.getParserPosition().plus(getPos()), extra);
+                    e = SqlStdOperatorTable.PATTERN_CONCAT.createCall(
+                        e.getParserPosition().plus(getPos()), e, extra);
+                    return e;
+                }
+            )
+        )
+        [
+            <HOOK>
+            {
+                if (startNum.intValue(true) != endNum.intValue(true)) {
+                    reluctant = SqlLiteral.createBoolean(true, SqlParserPos.ZERO);
+                }
+            }
+        ]
+    ]
+    {
+        if (startNum == null) {
+            return e;
+        } else {
+            return SqlStdOperatorTable.PATTERN_QUANTIFIER.createCall(
+                e.getParserPosition().plus(getPos()),
+                e, startNum, endNum, reluctant);
+        }
+    }
+}
+
+SqlNode PatternPrimary() :
+{
+    SqlParserPos pos;
+    SqlNode e;
+    List<SqlNode> eList;
+}
+{
+    (
+        e = SimpleIdentifier()
+    |
+        <LPAREN> e = PatternExpression() <RPAREN>
+    |
+        <LBRACE> { pos = getPos(); }
+        <MINUS> e = PatternExpression()
+        <MINUS> <RBRACE> {
+            e = SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(
+                pos.plus(getPos()), e);
+        }
+    |
+        (
+            <PERMUTE> { pos = getPos(); }
+            <LPAREN>
+            e = PatternExpression() {
+                eList = new ArrayList<SqlNode>();
+                eList.add(e);
+            }
+            (
+                <COMMA>
+                e = PatternExpression()
+                {
+                    eList.add(e);
+                }
+            )*
+            <RPAREN> {
+                e = SqlStdOperatorTable.PATTERN_PERMUTE.createCall(
+                    pos.plus(getPos()), eList);
+            }
+        )
+    )
+    {
+        return e;
+    }
+}
+
+SqlNodeList PatternDefinitionCommaList(SqlParserPos pos) :
+{
+    SqlNode e;
+    final List<SqlNode> eList = new ArrayList<SqlNode>();
+}
+{
+    e = PatternDefinition() {
+        if (pos == null) {
+            pos = e.getParserPosition();
+        }
+        eList.add(e);
+    }
+    (
+        <COMMA>
+        e = PatternDefinition() {
+            eList.add(e);
+        }
+    )*
+    {
+        return new SqlNodeList(eList, pos.plus(getPos()));
+    }
+}
+
+SqlNode PatternDefinition() :
+{
+    SqlNode var;
+    SqlNode e;
+}
+{
+    var = SimpleIdentifier()
+    <AS>
+    e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+        return SqlStdOperatorTable.PATTERN_DEFINE_AS.createCall(
+            var.getParserPosition().plus(getPos()), e, var);
+    }
+}
+
 // ----------------------------------------------------------------------------
 // Expressions
 
@@ -4473,6 +4716,8 @@ SqlNode BuiltinFunctionCall() :
     node = TimestampDiffFunctionCall() { return node; }
     |
     node = ExtendedBuiltinFunctionCall() { return node; }
+    |
+    node = MatchRecognizeFunctionCall() { return node; }
 }
 
 /**
@@ -4533,6 +4778,103 @@ SqlCall TimestampDiffFunctionCall() :
     }
 }
 
+SqlCall MatchRecognizeFunctionCall() :
+{
+    final SqlCall func;
+}
+{
+    (
+        func = MatchRecognizeNavigationLogical()
+    |
+        func = MatchRecognizeNavigationPhysical()
+    |
+        func = MatchRecognizeCallWithModifier()
+    )
+    { return func; }
+}
+
+SqlCall MatchRecognizeCallWithModifier() :
+{
+    final SqlParserPos pos;
+    final SqlOperator runningOp;
+    final SqlNode func;
+}
+{
+    (
+        <RUNNING> { runningOp = SqlStdOperatorTable.RUNNING; }
+    |
+        <FINAL> { runningOp = SqlStdOperatorTable.FINAL; }
+    )
+    { pos = getPos(); }
+    func = NamedFunctionCall() {
+        return runningOp.createCall(pos.plus(getPos()), func);
+    }
+}
+
+SqlCall MatchRecognizeNavigationLogical() :
+{
+    SqlParserPos pos;
+    SqlCall func;
+    final SqlOperator funcOp;
+    final SqlOperator runningOp;
+    SqlNode arg0;
+    SqlNode arg1 = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
+}
+{
+    (
+        <RUNNING> { runningOp = SqlStdOperatorTable.RUNNING; pos = getPos(); }
+    |
+        <FINAL> { runningOp = SqlStdOperatorTable.FINAL; pos = getPos(); }
+    |
+        { runningOp = null; pos = null; }
+    )
+    (
+        <FIRST> { funcOp = SqlStdOperatorTable.FIRST; }
+    |
+        <LAST> { funcOp = SqlStdOperatorTable.LAST; }
+    )
+    {
+        if (pos == null) {
+            pos = getPos();
+        }
+    }
+    <LPAREN>
+    arg0 = Expression(ExprContext.ACCEPT_SUB_QUERY)
+    [ <COMMA> arg1 = NumericLiteral() ]
+    <RPAREN>
+    {
+        func = funcOp.createCall(pos.plus(getPos()), arg0, arg1);
+        if (runningOp != null) {
+            return runningOp.createCall(pos.plus(getPos()), func);
+        } else {
+            return func;
+        }
+    }
+}
+
+SqlCall MatchRecognizeNavigationPhysical() :
+{
+    SqlParserPos pos;
+    SqlCall func;
+    SqlOperator funcOp;
+    SqlNode arg0;
+    SqlNode arg1 = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
+}
+{
+    (
+        <PREV> { funcOp = SqlStdOperatorTable.PREV; }
+    |
+        <NEXT> { funcOp = SqlStdOperatorTable.NEXT; }
+    )
+    { pos = getPos(); }
+    <LPAREN>
+    arg0 = Expression(ExprContext.ACCEPT_SUB_QUERY)
+    [ <COMMA> arg1 = NumericLiteral() ]
+    <RPAREN> {
+        return funcOp.createCall(pos.plus(getPos()), arg0, arg1);
+    }
+}
+
 /**
  * Parses a call to a named function (could be a builtin with regular
  * syntax, or else a UDF).
@@ -5181,6 +5523,7 @@ SqlPostfixOperator PostfixRowOperator() :
     | < DEFAULTS: "DEFAULTS" >
     | < DEFERRABLE: "DEFERRABLE" >
     | < DEFERRED: "DEFERRED" >
+    | < DEFINE: "DEFINE" >
     | < DEFINED: "DEFINED" >
     | < DEFINER: "DEFINER" >
     | < DEGREE: "DEGREE" >
@@ -5317,6 +5660,7 @@ SqlPostfixOperator PostfixRowOperator() :
     | < MAP: "MAP" >
     | < MATCH: "MATCH" >
     | < MATCHED: "MATCHED" >
+    | < MATCH_RECOGNIZE: "MATCH_RECOGNIZE">
     | < MAX: "MAX" >
     | < MAXVALUE: "MAXVALUE" >
     | < MEMBER: "MEMBER" >
@@ -5393,6 +5737,8 @@ SqlPostfixOperator PostfixRowOperator() :
     | < PASCAL: "PASCAL" >
     | < PASSTHROUGH: "PASSTHROUGH" >
     | < PATH: "PATH" >
+    | < PATTERN: "PATTERN" >
+    | < PERMUTE: "PERMUTE" >
     | < PERCENT_RANK: "PERCENT_RANK" >
     | < PERCENTILE_CONT: "PERCENTILE_CONT" >
     | < PERCENTILE_DISC: "PERCENTILE_DISC" >
@@ -5405,6 +5751,7 @@ SqlPostfixOperator PostfixRowOperator() :
     | < PRECISION: "PRECISION" >
     | < PREPARE: "PREPARE" >
     | < PRESERVE: "PRESERVE" >
+    | < PREV: "PREV" >
     | < PRIMARY: "PRIMARY" >
     | < PRIOR: "PRIOR" >
     | < PRIVILEGES: "PRIVILEGES" >
@@ -5456,6 +5803,7 @@ SqlPostfixOperator PostfixRowOperator() :
     | < ROW_COUNT: "ROW_COUNT" >
     | < ROW_NUMBER: "ROW_NUMBER" >
     | < ROWS: "ROWS" >
+    | < RUNNING: "RUNNING" >
     | < SAVEPOINT: "SAVEPOINT" >
     | < SCALE: "SCALE" >
     | < SCHEMA: "SCHEMA" >
@@ -6054,6 +6402,9 @@ String CommonNonReservedKeyWord() :
     | < DOUBLE_PERIOD: ".." >
     | < QUOTE: "'" >
     | < DOUBLE_QUOTE: "\"" >
+    | < VERTICAL_BAR: "|" >
+    | < CARET: "^" >
+    | < DOLLAR: "$" >
 }
 
 
@@ -6255,3 +6606,5 @@ void UnusedExtension() :
         LOOKAHEAD({false}) <ZONE>
     )
 }
+
+// End Parser.jj

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java b/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
index 3cb8557..3360627 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
@@ -34,6 +34,7 @@ import org.apache.calcite.rel.logical.LogicalExchange;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalMatch;
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
@@ -144,7 +145,7 @@ class CalciteMaterializer extends CalcitePrepareImpl.CalcitePreparingStmt {
   }
 
   /** Implementation of {@link RelShuttle} that returns each relational
-   * expression unchanged. It does not visit children. */
+   * expression unchanged. It does not visit inputs. */
   static class RelNullShuttle implements RelShuttle {
     public RelNode visit(TableScan scan) {
       return scan;
@@ -179,6 +180,9 @@ class CalciteMaterializer extends CalcitePrepareImpl.CalcitePreparingStmt {
     public RelNode visit(LogicalAggregate aggregate) {
       return aggregate;
     }
+    public RelNode visit(LogicalMatch match) {
+      return match;
+    }
     public RelNode visit(LogicalSort sort) {
       return sort;
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java b/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
index ce45689..cd7b85b 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
@@ -24,6 +24,7 @@ import org.apache.calcite.rel.logical.LogicalExchange;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalMatch;
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
@@ -39,6 +40,10 @@ public class RelHomogeneousShuttle extends RelShuttleImpl {
     return visit((RelNode) aggregate);
   }
 
+  @Override public RelNode visit(LogicalMatch match) {
+    return visit((RelNode) match);
+  }
+
   @Override public RelNode visit(TableScan scan) {
     return visit((RelNode) scan);
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/RelShuttle.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/RelShuttle.java b/core/src/main/java/org/apache/calcite/rel/RelShuttle.java
index 444506c..9e25c71 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelShuttle.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelShuttle.java
@@ -24,6 +24,7 @@ import org.apache.calcite.rel.logical.LogicalExchange;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalMatch;
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
@@ -56,6 +57,8 @@ public interface RelShuttle {
 
   RelNode visit(LogicalAggregate aggregate);
 
+  RelNode visit(LogicalMatch match);
+
   RelNode visit(LogicalSort sort);
 
   RelNode visit(LogicalExchange exchange);

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/RelShuttleImpl.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/RelShuttleImpl.java b/core/src/main/java/org/apache/calcite/rel/RelShuttleImpl.java
index a28f2b5..d822efb 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelShuttleImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelShuttleImpl.java
@@ -25,6 +25,7 @@ import org.apache.calcite.rel.logical.LogicalExchange;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalMatch;
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
@@ -74,6 +75,10 @@ public class RelShuttleImpl implements RelShuttle {
     return visitChild(aggregate, 0, aggregate.getInput());
   }
 
+  public RelNode visit(LogicalMatch match) {
+    return visitChild(match, 0, match.getInput());
+  }
+
   public RelNode visit(TableScan scan) {
     return scan;
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/core/Match.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Match.java b/core/src/main/java/org/apache/calcite/rel/core/Match.java
new file mode 100644
index 0000000..4e81fd6
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/core/Match.java
@@ -0,0 +1,274 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.core;
+
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelWriter;
+import org.apache.calcite.rel.SingleRel;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexPatternFieldRef;
+import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.fun.SqlCountAggFunction;
+import org.apache.calcite.sql.fun.SqlMinMaxAggFunction;
+import org.apache.calcite.sql.fun.SqlSumAggFunction;
+import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedSet;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * Relational expression that represent a MATCH_RECOGNIZE node.
+ *
+ * <p>Each output row has the columns defined in the measure statements.
+ */
+public abstract class Match extends SingleRel {
+  //~ Instance fields ---------------------------------------------
+  protected final ImmutableMap<String, RexNode> measures;
+  protected final RexNode pattern;
+  protected final boolean strictStart;
+  protected final boolean strictEnd;
+  protected final ImmutableMap<String, RexNode> patternDefinitions;
+  protected final Set<RexMRAggCall> aggregateCalls;
+
+  //~ Constructors -----------------------------------------------
+
+  /**
+   * Creates a Match.
+   *
+   * @param cluster Cluster
+   * @param traitSet Trait set
+   * @param input Input relational expression
+   * @param pattern Regular expression that defines pattern variables
+   * @param strictStart Whether it is a strict start pattern
+   * @param strictEnd Whether it is a strict end pattern
+   * @param patternDefinitions Pattern definitions
+   * @param rowType Row type
+   */
+  protected Match(RelOptCluster cluster, RelTraitSet traitSet,
+      RelNode input, RexNode pattern, boolean strictStart, boolean strictEnd,
+      Map<String, RexNode> patternDefinitions, RelDataType rowType) {
+    super(cluster, traitSet, input);
+    this.pattern = Preconditions.checkNotNull(pattern);
+    Preconditions.checkArgument(patternDefinitions.size() > 0);
+    this.strictStart = strictStart;
+    this.strictEnd = strictEnd;
+    this.patternDefinitions = ImmutableMap.copyOf(patternDefinitions);
+    this.rowType = rowType;
+    this.measures = ImmutableMap.of();
+
+    final AggregateFinder aggregateFinder = new AggregateFinder();
+    for (RexNode rex : this.patternDefinitions.values()) {
+      if (rex instanceof RexCall) {
+        aggregateFinder.go((RexCall) rex);
+      }
+    }
+    aggregateCalls = ImmutableSortedSet.copyOf(aggregateFinder.aggregateCalls);
+  }
+
+  //~ Methods --------------------------------------------------
+
+  public Set<RexMRAggCall> getAggregateCalls() {
+    return aggregateCalls;
+  }
+
+  public ImmutableMap<String, RexNode> getMeasures() {
+    return measures;
+  }
+
+  public RexNode getPattern() {
+    return pattern;
+  }
+
+  public boolean isStrictStart() {
+    return strictStart;
+  }
+
+  public boolean isStrictEnd() {
+    return strictEnd;
+  }
+
+  public ImmutableMap<String, RexNode> getPatternDefinitions() {
+    return patternDefinitions;
+  }
+
+  public abstract Match copy(RelNode input, RexNode pattern,
+      boolean strictStart, boolean strictEnd,
+      Map<String, RexNode> patternDefinitions, RelDataType rowType);
+
+  @Override public RelNode copy(
+      RelTraitSet traitSet,
+      List<RelNode> inputs) {
+    if (getInputs().equals(inputs)
+        && traitSet == getTraitSet()) {
+      return this;
+    }
+
+    return copy(
+        inputs.get(0),
+        pattern, strictStart, strictEnd,
+        patternDefinitions,
+        rowType);
+  }
+
+  @Override public RelWriter explainTerms(RelWriter pw) {
+    super.explainTerms(pw);
+    if (pw.nest()) {
+      pw.item("fields", rowType.getFieldNames());
+      pw.item("exprs", getMeasures().values().asList());
+    } else {
+      for (Ord<RelDataTypeField> field : Ord.zip(rowType.getFieldList())) {
+        String fieldName = field.e.getName();
+        if (fieldName == null) {
+          fieldName = "Field#" + field.i;
+        }
+        pw.item(fieldName, getMeasures().get(field.i));
+      }
+    }
+    return pw;
+  }
+
+
+  /**
+   * Find aggregate functions in operands.
+   */
+  private static class AggregateFinder extends RexVisitorImpl {
+    final SortedSet<RexMRAggCall> aggregateCalls = new TreeSet<>();
+
+    AggregateFinder() {
+      super(true);
+    }
+
+    @Override public Object visitCall(RexCall call) {
+      SqlAggFunction aggFunction = null;
+      switch (call.getKind()) {
+      case SUM:
+        aggFunction = new SqlSumAggFunction(call.getType());
+        break;
+      case SUM0:
+        aggFunction = new SqlSumEmptyIsZeroAggFunction();
+        break;
+      case MAX:
+      case MIN:
+        aggFunction = new SqlMinMaxAggFunction(call.getKind());
+        break;
+      case COUNT:
+        aggFunction = new SqlCountAggFunction();
+        break;
+      default:
+        for (RexNode rex : call.getOperands()) {
+          rex.accept(this);
+        }
+      }
+      if (aggFunction != null) {
+        RexMRAggCall aggCall = new RexMRAggCall(aggFunction,
+            call.getType(), call.getOperands(), aggregateCalls.size());
+        aggregateCalls.add(aggCall);
+        Set<String> pv = new PatternVarFinder().go(call.getOperands());
+      }
+      return null;
+    }
+
+    public void go(RexCall call) {
+      call.accept(this);
+    }
+  }
+
+  /**
+   * Visits the operands of an aggregate call to retrieve relevant pattern
+   * variables.
+   */
+  private static class PatternVarFinder extends RexVisitorImpl {
+    final Set<String> patternVars = new HashSet<>();
+
+    PatternVarFinder() {
+      super(true);
+    }
+
+    @Override public Object visitPatternFieldRef(RexPatternFieldRef fieldRef) {
+      patternVars.add(fieldRef.getAlpha());
+      return null;
+    }
+
+    @Override public Object visitCall(RexCall call) {
+      for (RexNode node : call.getOperands()) {
+        node.accept(this);
+      }
+      return null;
+    }
+
+    public Set<String> go(RexNode rex) {
+      rex.accept(this);
+      return patternVars;
+    }
+
+    public Set<String> go(List<RexNode> rexNodeList) {
+      for (RexNode rex : rexNodeList) {
+        rex.accept(this);
+      }
+      return patternVars;
+    }
+  }
+
+  /**
+   * Aggregate calls in match recognize.
+   */
+  public static class RexMRAggCall extends RexCall implements Comparable<RexMRAggCall> {
+    public final int ordinal;
+    public RexMRAggCall(
+        SqlAggFunction aggFun,
+        RelDataType type,
+        List<RexNode> operands,
+        int ordinal) {
+      super(type, aggFun, operands);
+      this.ordinal = ordinal;
+      digest = computeDigest();
+    }
+
+    public String computeDigest() {
+      return super.computeDigest(false);
+    }
+
+    @Override public int compareTo(RexMRAggCall o) {
+      if (o.computeDigest() == null) {
+        return 0;
+      }
+
+      if (computeDigest() == null) {
+        return 1;
+      }
+
+      return o.computeDigest().compareTo(computeDigest());
+    }
+  }
+}
+
+// End Match.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java b/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
index 0d439c0..7dad9a8 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
@@ -27,6 +27,7 @@ import org.apache.calcite.rel.logical.LogicalCorrelate;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.logical.LogicalMatch;
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
@@ -46,6 +47,7 @@ import org.apache.calcite.util.ImmutableBitSet;
 import com.google.common.collect.ImmutableList;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -73,6 +75,9 @@ public class RelFactories {
   public static final AggregateFactory DEFAULT_AGGREGATE_FACTORY =
     new AggregateFactoryImpl();
 
+  public static final MatchFactory DEFAULT_MATCH_FACTORY =
+      new MatchFactoryImpl();
+
   public static final SetOpFactory DEFAULT_SET_OP_FACTORY =
       new SetOpFactoryImpl();
 
@@ -92,6 +97,7 @@ public class RelFactories {
               DEFAULT_SEMI_JOIN_FACTORY,
               DEFAULT_SORT_FACTORY,
               DEFAULT_AGGREGATE_FACTORY,
+              DEFAULT_MATCH_FACTORY,
               DEFAULT_SET_OP_FACTORY,
               DEFAULT_VALUES_FACTORY,
               DEFAULT_TABLE_SCAN_FACTORY));
@@ -381,6 +387,30 @@ public class RelFactories {
       return LogicalTableScan.create(cluster, table);
     }
   }
+
+  /**
+   * Can create a {@link Match} of
+   * the appropriate type for a rule's calling convention.
+   */
+  public interface MatchFactory {
+    /** Creates a {@link Match}. */
+    RelNode createMatchRecognize(RelNode input, RexNode pattern,
+        boolean strictStarts, boolean strictEnds,
+        Map<String, RexNode> patternDefinitions, RelDataType rowType);
+  }
+
+  /**
+   * Implementation of {@link MatchFactory}
+   * that returns a {@link LogicalMatch}.
+   */
+  private static class MatchFactoryImpl implements MatchFactory {
+    public RelNode createMatchRecognize(RelNode input, RexNode pattern,
+        boolean strictStarts, boolean strictEnds,
+        Map<String, RexNode> patternDefinitions, RelDataType rowType) {
+      return LogicalMatch.create(input, pattern, strictStarts, strictEnds,
+          patternDefinitions, rowType);
+    }
+  }
 }
 
 // End RelFactories.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/logical/LogicalMatch.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/logical/LogicalMatch.java b/core/src/main/java/org/apache/calcite/rel/logical/LogicalMatch.java
new file mode 100644
index 0000000..46d7755
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/logical/LogicalMatch.java
@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.logical;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Match;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rex.RexNode;
+
+import java.util.Map;
+
+/**
+ * Sub-class of {@link Match}
+ * not targeted at any particular engine or calling convention.
+ */
+public class LogicalMatch extends Match {
+
+  /**
+   * Creates a LogicalMatch.
+   *
+   * @param cluster cluster
+   * @param traitSet Trait set
+   * @param input Input relational expression
+   * @param pattern Regular Expression defining pattern variables
+   * @param strictStart Whether it is a strict start pattern
+   * @param strictEnd Whether it is a strict end pattern
+   * @param patternDefinitions Pattern definitions
+   * @param rowType Row type
+   */
+  public LogicalMatch(RelOptCluster cluster, RelTraitSet traitSet,
+      RelNode input, RexNode pattern, boolean strictStart, boolean strictEnd,
+      Map<String, RexNode> patternDefinitions, RelDataType rowType) {
+    super(cluster, traitSet, input, pattern, strictStart, strictEnd,
+        patternDefinitions, rowType);
+  }
+
+  /**
+   * Creates a LogicalMatch.
+   */
+  public static LogicalMatch create(RelNode input, RexNode pattern,
+      boolean strictStart, boolean strictEnd,
+      Map<String, RexNode> patternDefinitions, RelDataType rowType) {
+    final RelOptCluster cluster = input.getCluster();
+    final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
+    return new LogicalMatch(cluster, traitSet, input, pattern,
+        strictStart, strictEnd, patternDefinitions, rowType);
+  }
+
+  //~ Methods ------------------------------------------------------
+
+  @Override public Match copy(RelNode input, RexNode pattern,
+      boolean strictStart, boolean strictEnd,
+      Map<String, RexNode> patternDefinitions, RelDataType rowType) {
+    final RelTraitSet traitSet = getCluster().traitSetOf(Convention.NONE);
+    return new LogicalMatch(getCluster(), traitSet,
+        input, pattern, strictStart, strictEnd, patternDefinitions, rowType);
+  }
+}
+
+// End LogicalMatch.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
index 96cfac7..eefe8b1 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
@@ -26,6 +26,7 @@ import org.apache.calcite.rel.core.Filter;
 import org.apache.calcite.rel.core.Intersect;
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.core.Match;
 import org.apache.calcite.rel.core.Minus;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
@@ -46,6 +47,7 @@ import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlInsert;
 import org.apache.calcite.sql.SqlJoin;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlSelect;
@@ -355,6 +357,37 @@ public class RelToSqlConverter extends SqlImplementor
             }), POS);
   }
 
+  /**
+   * @see #dispatch
+   */
+  public Result visit(Match e) {
+    final RelNode input = e.getInput();
+    final Result x = visitChild(0, input);
+    final Context context = matchRecognizeContext(x.qualifiedContext());
+
+    SqlNode tableRef = x.asQueryOrValues();
+
+    RexNode rexPattern = e.getPattern();
+    final SqlNode pattern = context.toSql(null, rexPattern);
+    final SqlLiteral isStrictStarts = SqlLiteral.createBoolean(e.isStrictStart(), POS);
+    final SqlLiteral isStrictEnds = SqlLiteral.createBoolean(e.isStrictEnd(), POS);
+
+    List<SqlNode> list = Lists.newArrayList();
+    for (Map.Entry<String, RexNode> entry : e.getPatternDefinitions().entrySet()) {
+      String alias = entry.getKey();
+      SqlNode sqlNode = context.toSql(null, entry.getValue());
+      sqlNode = SqlStdOperatorTable.PATTERN_DEFINE_AS.createCall(POS,
+        sqlNode, new SqlIdentifier(alias, POS));
+      list.add(sqlNode);
+    }
+
+    final SqlNodeList patternDefList = new SqlNodeList(list, POS);
+
+    final SqlNode matchRecognize = new SqlMatchRecognize(POS, tableRef,
+      pattern, isStrictStarts, isStrictEnds, patternDefList);
+    return result(matchRecognize, Expressions.list(Clause.FROM), e, null);
+  }
+
   @Override public void addSelect(List<SqlNode> selectList, SqlNode node,
       RelDataType rowType) {
     String name = rowType.getFieldNames().get(selectList.size());

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
index 3c92f29..e9c148f 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
@@ -46,6 +46,7 @@ import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlJoin;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlOperator;
@@ -61,6 +62,7 @@ import org.apache.calcite.sql.type.BasicSqlType;
 import org.apache.calcite.sql.type.InferTypes;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
@@ -471,6 +473,7 @@ public abstract class SqlImplementor {
   SqlSelect wrapSelect(SqlNode node) {
     assert node instanceof SqlJoin
         || node instanceof SqlIdentifier
+        || node instanceof SqlMatchRecognize
         || node instanceof SqlCall
             && (((SqlCall) node).getOperator() instanceof SqlSetOperator
                 || ((SqlCall) node).getOperator() == SqlStdOperatorTable.AS)
@@ -812,6 +815,29 @@ public abstract class SqlImplementor {
     return new JoinContext(leftContext, rightContext);
   }
 
+  public Context matchRecognizeContext(Context context) {
+    return new MatchRecognizeContext(((AliasContext) context).aliases);
+  }
+
+  /**
+   * Context for translating MATCH_RECOGNIZE clause
+   */
+  public class MatchRecognizeContext extends AliasContext {
+    protected MatchRecognizeContext(Map<String, RelDataType> aliases) {
+      super(aliases, false);
+    }
+
+    @Override public SqlNode toSql(RexProgram program, RexNode rex) {
+      if (rex.getKind() == SqlKind.LITERAL) {
+        final RexLiteral literal = (RexLiteral) rex;
+        if (literal.getTypeName().getFamily() == SqlTypeFamily.CHARACTER) {
+          return new SqlIdentifier(RexLiteral.stringValue(literal), POS);
+        }
+      }
+      return super.toSql(program, rex);
+    }
+  }
+
   /** Implementation of Context that precedes field references with their
    * "table alias" based on the current sub-query's FROM clause. */
   public class AliasContext extends Context {

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/LogicVisitor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/LogicVisitor.java b/core/src/main/java/org/apache/calcite/rex/LogicVisitor.java
index 721603e..a16a834 100644
--- a/core/src/main/java/org/apache/calcite/rex/LogicVisitor.java
+++ b/core/src/main/java/org/apache/calcite/rex/LogicVisitor.java
@@ -162,6 +162,10 @@ public class LogicVisitor implements RexBiVisitor<Logic, Logic> {
     }
     return end(subQuery, arg);
   }
+
+  @Override public Logic visitPatternFieldRef(RexPatternFieldRef ref, Logic arg) {
+    return end(ref, arg);
+  }
 }
 
 // End LogicVisitor.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/RexBiVisitor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexBiVisitor.java b/core/src/main/java/org/apache/calcite/rex/RexBiVisitor.java
index 8f7e0d3..8e0b014 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexBiVisitor.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexBiVisitor.java
@@ -47,6 +47,8 @@ public interface RexBiVisitor<R, P> {
   R visitFieldAccess(RexFieldAccess fieldAccess, P arg);
 
   R visitSubQuery(RexSubQuery subQuery, P arg);
+
+  R visitPatternFieldRef(RexPatternFieldRef ref, P arg);
 }
 
 // End RexBiVisitor.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/RexPatternFieldRef.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexPatternFieldRef.java b/core/src/main/java/org/apache/calcite/rex/RexPatternFieldRef.java
new file mode 100644
index 0000000..3d9ff42
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rex/RexPatternFieldRef.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rex;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlKind;
+
+/**
+ * Variable which references a field of an input relational expression
+ */
+public class RexPatternFieldRef extends RexInputRef {
+  private final String alpha;
+
+  public RexPatternFieldRef(String alpha, int index, RelDataType type) {
+    super(index, type);
+    this.alpha = alpha;
+    digest = alpha + ".$" + index;
+  }
+
+  public String getAlpha() {
+    return alpha;
+  }
+
+  public static RexPatternFieldRef of(String alpha, int index, RelDataType type) {
+    return new RexPatternFieldRef(alpha, index, type);
+  }
+
+  public static RexPatternFieldRef of(String alpha, RexInputRef ref) {
+    return new RexPatternFieldRef(alpha, ref.getIndex(), ref.getType());
+  }
+
+  @Override public <R> R accept(RexVisitor<R> visitor) {
+    return visitor.visitPatternFieldRef(this);
+  }
+
+  @Override public <R, P> R accept(RexBiVisitor<R, P> visitor, P arg) {
+    return visitor.visitPatternFieldRef(this, arg);
+  }
+
+  @Override public SqlKind getKind() {
+    return SqlKind.PATTERN_INPUT_REF;
+  }
+}
+
+// End RexPatternFieldRef.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/RexShuttle.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexShuttle.java b/core/src/main/java/org/apache/calcite/rex/RexShuttle.java
index f0e5820..36b9e40 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexShuttle.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexShuttle.java
@@ -88,6 +88,10 @@ public class RexShuttle implements RexVisitor<RexNode> {
     }
   }
 
+  @Override public RexNode visitPatternFieldRef(RexPatternFieldRef fieldRef) {
+    return fieldRef;
+  }
+
   public RexNode visitCall(final RexCall call) {
     boolean[] update = {false};
     List<RexNode> clonedOperands = visitList(call.operands, update);

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/RexUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexUtil.java b/core/src/main/java/org/apache/calcite/rex/RexUtil.java
index fd60098..2352809 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -495,6 +495,10 @@ public class RexUtil {
       return false;
     }
 
+    @Override public Boolean visitPatternFieldRef(RexPatternFieldRef fieldRef) {
+      return false;
+    }
+
     public Boolean visitCorrelVariable(RexCorrelVariable correlVariable) {
       // Correlating variables change when there is an internal restart.
       // Not good enough for our purposes.

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/RexVisitor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexVisitor.java b/core/src/main/java/org/apache/calcite/rex/RexVisitor.java
index 4c95647..bf6dd99 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexVisitor.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexVisitor.java
@@ -47,6 +47,8 @@ public interface RexVisitor<R> {
   R visitFieldAccess(RexFieldAccess fieldAccess);
 
   R visitSubQuery(RexSubQuery subQuery);
+
+  R visitPatternFieldRef(RexPatternFieldRef fieldRef);
 }
 
 // End RexVisitor.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/rex/RexVisitorImpl.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexVisitorImpl.java b/core/src/main/java/org/apache/calcite/rex/RexVisitorImpl.java
index ec31f26..4710f98 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexVisitorImpl.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexVisitorImpl.java
@@ -110,6 +110,10 @@ public class RexVisitorImpl<R> implements RexVisitor<R> {
     return r;
   }
 
+  @Override public R visitPatternFieldRef(RexPatternFieldRef fieldRef) {
+    return null;
+  }
+
   /**
    * <p>Visits an array of expressions, returning the logical 'and' of their
    * results.

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java b/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
index 4c9fa57..685344d 100644
--- a/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
+++ b/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
@@ -662,6 +662,27 @@ public interface CalciteResource {
 
   @BaseMessage("Call to auxiliary group function ''{0}'' must have matching call to group function ''{1}'' in GROUP BY clause")
   ExInst<SqlValidatorException> auxiliaryWithoutMatchingGroupCall(String func1, String func2);
+
+  @BaseMessage("Pattern variable ''{0}'' has already been defined")
+  ExInst<SqlValidatorException> PatternVarAlreadyDefined(String varName);
+
+  @BaseMessage("Cannot use PREV/NEXT in MEASURE ''{0}''")
+  ExInst<SqlValidatorException> PatternPrevFunctionInMeasure(String call);
+
+  @BaseMessage("Cannot nest PREV/NEXT under LAST/FIRST ''{0}''")
+  ExInst<SqlValidatorException> PatternPrevFunctionOrder(String call);
+
+  @BaseMessage("Cannot use aggregation in navigation ''{0}''")
+  ExInst<SqlValidatorException> PatternAggregationInNavigation(String call);
+
+  @BaseMessage("Invalid number of parameters to COUNT method")
+  ExInst<SqlValidatorException> PatternCountFunctionArg();
+
+  @BaseMessage("Cannot use RUNNING/FINAL in DEFINE ''{0}''")
+  ExInst<SqlValidatorException> PatternRunningFunctionInDefine(String call);
+
+  @BaseMessage("Multiple pattern variables in ''{0}''")
+  ExInst<SqlValidatorException> PatternFunctionVariableCheck(String call);
 }
 
 // End CalciteResource.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java b/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java
index 02cd381..288adfc 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java
@@ -46,7 +46,8 @@ public enum SqlFunctionCategory {
       USER_DEFINED, TABLE_FUNCTION),
   USER_DEFINED_TABLE_SPECIFIC_FUNCTION("TABLE_UDF_SPECIFIC",
       "User-defined table function with SPECIFIC name", USER_DEFINED,
-      TABLE_FUNCTION, SPECIFIC);
+      TABLE_FUNCTION, SPECIFIC),
+  MATCH_RECOGNIZE("MATCH_RECOGNIZE", "MATCH_RECOGNIZE function", TABLE_FUNCTION);
 
   private final EnumSet<Property> properties;
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/SqlKind.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlKind.java b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
index 8dbb55ef..454e07f 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlKind.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
@@ -227,6 +227,10 @@ public enum SqlKind {
    */
   TABLESAMPLE,
 
+  /**
+   * MATCH_RECOGNIZE clause
+   */
+  MATCH_RECOGNIZE,
   // binary operators
 
   /**
@@ -253,6 +257,16 @@ public enum SqlKind {
    */
   MINUS,
 
+  /**
+   * the alternation operator in a pattern expression within a match_recognize clause
+   */
+  PATTERN_ALTER,
+
+  /**
+   * the concatenation operator in a pattern expression within a match_recognize clause
+   */
+  PATTERN_CONCAT,
+
   // comparison operators
 
   /**
@@ -435,6 +449,26 @@ public enum SqlKind {
    */
   NEW_SPECIFICATION,
 
+
+  /**
+   * Special functions in MATCH_RECOGNIZE.
+   */
+  FINAL,
+
+  RUNNING,
+
+  PREV,
+
+  NEXT,
+
+  FIRST,
+
+  LAST,
+
+  CLASSIFIER,
+
+  MATCH_NUMBER,
+
   // postfix operators
 
   /**
@@ -515,6 +549,12 @@ public enum SqlKind {
   INPUT_REF,
 
   /**
+   * Reference to an input field, with pattern var as modifier
+   *
+   * <p>(Only used at the RexNode level.)</p>
+   */
+  PATTERN_INPUT_REF,
+  /**
    * Reference to a sub-expression computed within the current relational
    * operator.
    *
@@ -529,6 +569,11 @@ public enum SqlKind {
    */
   CORREL_VARIABLE,
 
+  /**
+   * the repetition quantifier of a pattern factor in a match_recognize clause.
+   */
+  PATTERN_QUANTIFIER,
+
   // functions
 
   /**
@@ -692,6 +737,16 @@ public enum SqlKind {
   /** The {@code GROUP_ID()} function. */
   GROUP_ID,
 
+  /**
+   * the internal permute function in match_recognize cluse
+   */
+  PATTERN_PERMUTE,
+
+  /**
+   * the special patterns to exclude enclosing pattern from output in match_recognize clause
+   */
+  PATTERN_EXCLUDED,
+
   // Aggregate functions
 
   /** The {@code COUNT} aggregate function. */

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/SqlMatchRecognize.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlMatchRecognize.java b/core/src/main/java/org/apache/calcite/sql/SqlMatchRecognize.java
new file mode 100644
index 0000000..23350fb
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlMatchRecognize.java
@@ -0,0 +1,216 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.util.SqlBasicVisitor;
+import org.apache.calcite.sql.util.SqlVisitor;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.calcite.util.ImmutableNullableList;
+
+import java.util.List;
+
+/**
+ * SqlNode for Match_recognize clause
+ */
+public class SqlMatchRecognize extends SqlCall {
+  public static final int OPERAND_TABLE_REF = 0;
+  public static final int OPERAND_PATTERN = 1;
+  public static final int OPERAND_STRICT_START = 2;
+  public static final int OPERAND_STRICT_END = 3;
+  public static final int OPERAND_PATTERN_DEFINES = 4;
+
+  //~ Instance fields -------------------------------------------
+
+  private SqlNode tableRef;
+  private SqlNode pattern;
+  private SqlLiteral strictStart;
+  private SqlLiteral strictEnd;
+  private SqlNodeList patternDefList;
+
+  /** Creates a SqlMatchRecognize. */
+  public SqlMatchRecognize(SqlParserPos pos, SqlNode tableRef, SqlNode pattern,
+      SqlLiteral strictStart, SqlLiteral strictEnd, SqlNodeList patternDefList) {
+    super(pos);
+    this.tableRef = tableRef;
+    this.pattern = pattern;
+    this.strictStart = strictStart;
+    this.strictEnd = strictEnd;
+    this.patternDefList = patternDefList;
+
+    assert tableRef != null;
+    assert pattern != null;
+    assert patternDefList != null && patternDefList.size() > 0;
+  }
+
+  // ~ Methods
+
+  @Override public SqlOperator getOperator() {
+    return SqlMatchRecognizeOperator.INSTANCE;
+  }
+
+  @Override public SqlKind getKind() {
+    return SqlKind.MATCH_RECOGNIZE;
+  }
+
+  @Override public List<SqlNode> getOperandList() {
+    return ImmutableNullableList.of(tableRef, pattern, strictStart, strictEnd,
+        patternDefList);
+  }
+
+  @Override public void unparse(SqlWriter writer, int leftPrec,
+      int rightPrec) {
+    getOperator().unparse(writer, this, 0, 0);
+  }
+
+  @Override public void validate(SqlValidator validator, SqlValidatorScope scope) {
+    validator.validateMatchRecognize(this);
+  }
+
+  @Override public void setOperand(int i, SqlNode operand) {
+    switch (i) {
+    case OPERAND_TABLE_REF:
+      tableRef = operand;
+      break;
+    case OPERAND_PATTERN:
+      pattern = operand;
+      break;
+    case OPERAND_STRICT_START:
+      strictStart = (SqlLiteral) operand;
+      break;
+    case OPERAND_STRICT_END:
+      strictEnd = (SqlLiteral) operand;
+      break;
+    case OPERAND_PATTERN_DEFINES:
+      patternDefList = (SqlNodeList) operand;
+      break;
+    default:
+      throw new AssertionError(i);
+    }
+  }
+
+  public SqlNode getTableRef() {
+    return tableRef;
+  }
+
+  public SqlNode getPattern() {
+    return pattern;
+  }
+
+  public SqlLiteral getStrictStart() {
+    return strictStart;
+  }
+
+  public SqlLiteral getStrictEnd() {
+    return strictEnd;
+  }
+
+  public SqlNodeList getPatternDefList() {
+    return patternDefList;
+  }
+
+  /**
+   * An operator describing a MATCH_RECOGNIZE specification.
+   */
+  public static class SqlMatchRecognizeOperator extends SqlOperator {
+    public static final SqlMatchRecognizeOperator INSTANCE =
+        new SqlMatchRecognizeOperator();
+
+    private SqlMatchRecognizeOperator() {
+      super("MATCH_RECOGNIZE", SqlKind.MATCH_RECOGNIZE, 2, true, null, null, null);
+    }
+
+    @Override public SqlSyntax getSyntax() {
+      return SqlSyntax.SPECIAL;
+    }
+
+    @Override public SqlCall createCall(
+        SqlLiteral functionQualifier,
+        SqlParserPos pos,
+        SqlNode... operands) {
+      assert functionQualifier == null;
+      assert operands.length == 5;
+
+      return new SqlMatchRecognize(pos, operands[0], operands[1],
+          (SqlLiteral) operands[2], (SqlLiteral) operands[3],
+          (SqlNodeList) operands[4]);
+    }
+
+    @Override public <R> void acceptCall(
+        SqlVisitor<R> visitor,
+        SqlCall call,
+        boolean onlyExpressions,
+        SqlBasicVisitor.ArgHandler<R> argHandler) {
+      if (onlyExpressions) {
+        List<SqlNode> operands = call.getOperandList();
+        for (int i = 0; i < operands.size(); i++) {
+          SqlNode operand = operands.get(i);
+          if (operand == null) {
+            continue;
+          }
+          argHandler.visitChild(visitor, call, i, operand);
+        }
+      } else {
+        super.acceptCall(visitor, call, onlyExpressions, argHandler);
+      }
+    }
+
+    @Override public void validateCall(
+        SqlCall call,
+        SqlValidator validator,
+        SqlValidatorScope scope,
+        SqlValidatorScope operandScope) {
+      validator.validateMatchRecognize(call);
+    }
+
+    @Override public void unparse(
+        SqlWriter writer,
+        SqlCall call,
+        int leftPrec,
+        int rightPrec) {
+      final SqlMatchRecognize pattern = (SqlMatchRecognize) call;
+
+      pattern.tableRef.unparse(writer, 0, 0);
+      final SqlWriter.Frame mrFrame = writer.startFunCall("MATCH_RECOGNIZE");
+
+      writer.newlineAndIndent();
+      writer.sep("PATTERN");
+
+      SqlWriter.Frame patternFrame = writer.startList("(", ")");
+      if (pattern.strictStart.booleanValue()) {
+        writer.sep("^");
+      }
+      pattern.pattern.unparse(writer, 0, 0);
+      if (pattern.strictEnd.booleanValue()) {
+        writer.sep("$");
+      }
+      writer.endList(patternFrame);
+
+      writer.newlineAndIndent();
+      writer.sep("DEFINE");
+
+      SqlWriter.Frame patternDefFrame = writer.startList("", "");
+      pattern.patternDefList.unparse(writer, 0, 0);
+      writer.endList(patternDefFrame);
+
+      writer.endList(mrFrame);
+    }
+  }
+}
+
+// End SqlMatchRecognize.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSelect.java b/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
index bb847bc..ea89b37 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
@@ -46,7 +46,7 @@ public class SqlSelect extends SqlCall {
   SqlNodeList orderBy;
   SqlNode offset;
   SqlNode fetch;
-
+  SqlMatchRecognize matchRecognize;
   //~ Constructors -----------------------------------------------------------
 
   public SqlSelect(SqlParserPos pos,
@@ -204,6 +204,14 @@ public class SqlSelect extends SqlCall {
     this.fetch = fetch;
   }
 
+  public SqlMatchRecognize getMatchRecognize() {
+    return matchRecognize;
+  }
+
+  public void setMatchRecognize(SqlMatchRecognize matchRecognize) {
+    this.matchRecognize = matchRecognize;
+  }
+
   public void validate(SqlValidator validator, SqlValidatorScope scope) {
     validator.validateQuery(this, scope, validator.getUnknownType());
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
index 764a04f..f0e7868 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
@@ -30,6 +30,8 @@ import org.apache.calcite.sql.SqlInternalOperator;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLateralOperator;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNumericLiteral;
 import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorBinding;
@@ -55,6 +57,7 @@ import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.util.ReflectiveSqlOperatorTable;
 import org.apache.calcite.sql.validate.SqlModality;
 import org.apache.calcite.util.Litmus;
+import org.apache.calcite.util.Util;
 
 /**
  * Implementation of {@link org.apache.calcite.sql.SqlOperatorTable} containing
@@ -1396,6 +1399,36 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
       new SqlBaseContextVariable("PI", ReturnTypes.DOUBLE,
           SqlFunctionCategory.NUMERIC);
 
+  /** {@code FINAL} function to be used within {@code MATCH_RECOGNIZE}. */
+  public static final SqlFunction FINAL =
+      new SqlFunction("FINAL", SqlKind.FINAL, ReturnTypes.ARG0_NULLABLE, null,
+          OperandTypes.ANY, SqlFunctionCategory.MATCH_RECOGNIZE);
+
+  /** {@code RUNNING} function to be used within {@code MATCH_RECOGNIZE}. */
+  public static final SqlFunction RUNNING =
+      new SqlFunction("RUNNING", SqlKind.RUNNING, ReturnTypes.ARG0_NULLABLE,
+          null, OperandTypes.ANY, SqlFunctionCategory.MATCH_RECOGNIZE);
+
+  /** {@code FIRST} function to be used within {@code MATCH_RECOGNIZE}. */
+  public static final SqlFunction FIRST =
+      new SqlFunction("FIRST", SqlKind.FIRST, ReturnTypes.ARG0_NULLABLE,
+          null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+
+  /** {@code LAST} function to be used within {@code MATCH_RECOGNIZE}. */
+  public static final SqlFunction LAST =
+      new SqlFunction("LAST", SqlKind.LAST, ReturnTypes.ARG0_NULLABLE,
+          null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+
+  /** {@code PREV} function to be used within {@code MATCH_RECOGNIZE}. */
+  public static final SqlFunction PREV =
+      new SqlFunction("PREV", SqlKind.PREV, ReturnTypes.ARG0_NULLABLE,
+          null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+
+  /** {@code NEXT} function to be used within {@code MATCH_RECOGNIZE}. */
+  public static final SqlFunction NEXT =
+      new SqlFunction("NEXT", SqlKind.NEXT, ReturnTypes.ARG0_NULLABLE, null,
+          OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+
   public static final SqlFunction NULLIF = new SqlNullifFunction();
 
   /**
@@ -1900,6 +1933,131 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlFunction SESSION_END =
       SESSION.auxiliary(SqlKind.SESSION_END);
 
+  /** {@code |} operator to create alternate patterns
+   * within {@code MATCH_RECOGNIZE}.
+   *
+   * <p>If {@code p1} and {@code p2} are patterns then {@code p1 | p2} is a
+   * pattern that matches {@code p1} or {@code p2}. */
+  public static final SqlBinaryOperator PATTERN_ALTER =
+      new SqlBinaryOperator("|", SqlKind.PATTERN_ALTER, 70, true, null, null, null);
+
+  /** Operator to concatenate patterns within {@code MATCH_RECOGNIZE}.
+   *
+   * <p>If {@code p1} and {@code p2} are patterns then {@code p1 p2} is a
+   * pattern that matches {@code p1} followed by {@code p2}. */
+  public static final SqlBinaryOperator PATTERN_CONCAT =
+      new SqlBinaryOperator("", SqlKind.PATTERN_CONCAT, 80, true, null, null, null);
+
+  /** Operator to quantify patterns within {@code MATCH_RECOGNIZE}.
+   *
+   * <p>If {@code p} is a pattern then {@code p{3, 5}} is a
+   * pattern that matches between 3 and 5 occurrences of {@code p}. */
+  public static final SqlSpecialOperator PATTERN_QUANTIFIER =
+      new SqlSpecialOperator("PATTERN_QUANTIFIER", SqlKind.PATTERN_QUANTIFIER,
+          90) {
+        @Override public void unparse(SqlWriter writer, SqlCall call,
+            int leftPrec, int rightPrec) {
+          call.operand(0).unparse(writer, this.getLeftPrec(), this.getRightPrec());
+          int startNum = ((SqlNumericLiteral) call.operand(1)).intValue(true);
+          SqlNumericLiteral endRepNum = call.operand(2);
+          boolean isReluctant = ((SqlLiteral) call.operand(3)).booleanValue();
+          int endNum = endRepNum.intValue(true);
+          if (startNum == endNum) {
+            writer.keyword("{ " + startNum + " }");
+          } else {
+            if (endNum == -1) {
+              if (startNum == 0) {
+                writer.keyword("*");
+              } else if (startNum == 1) {
+                writer.keyword("+");
+              } else {
+                writer.keyword("{ " + startNum + ", }");
+              }
+            } else {
+              if (startNum == 0 && endNum == 1) {
+                writer.keyword("?");
+              } else if (startNum == -1) {
+                writer.keyword("{ , " + endNum + " }");
+              } else {
+                writer.keyword("{ " + startNum + ", " + endNum + " }");
+              }
+            }
+            if (isReluctant) {
+              writer.keyword("?");
+            }
+          }
+        }
+      };
+
+  /** {@code PERMUTE} operator to combine patterns within
+   * {@code MATCH_RECOGNIZE}.
+   *
+   * <p>If {@code p1} and {@code p2} are patterns then {@code PERMUTE (p1, p2)}
+   * is a pattern that matches all permutations of {@code p1} and
+   * {@code p2}. */
+  public static final SqlSpecialOperator PATTERN_PERMUTE =
+      new SqlSpecialOperator("PATTERN_PERMUTE", SqlKind.PATTERN_PERMUTE, 100) {
+        @Override public void unparse(SqlWriter writer, SqlCall call,
+            int leftPrec, int rightPrec) {
+          writer.keyword("PERMUTE");
+          SqlWriter.Frame frame = writer.startList("(", ")");
+          for (int i = 0; i < call.getOperandList().size(); i++) {
+            SqlNode pattern = call.getOperandList().get(i);
+            pattern.unparse(writer, 0, 0);
+            if (i != call.getOperandList().size() - 1) {
+              writer.print(",");
+            }
+          }
+          writer.endList(frame);
+        }
+      };
+
+  /** {@code EXCLUDE} operator within {@code MATCH_RECOGNIZE}.
+   *
+   * <p>If {@code p} is a pattern then {@code {- p -} }} is a
+   * pattern that excludes {@code p} from the output. */
+  public static final SqlSpecialOperator PATTERN_EXCLUDE =
+      new SqlSpecialOperator("PATTERN_EXCLUDE", SqlKind.PATTERN_EXCLUDED,
+          100) {
+        @Override public void unparse(SqlWriter writer, SqlCall call,
+            int leftPrec, int rightPrec) {
+          SqlWriter.Frame frame = writer.startList("{-", "-}");
+          SqlNode node = call.getOperandList().get(0);
+          node.unparse(writer, 0, 0);
+          writer.endList(frame);
+        }
+      };
+
+  /** {@code AS} function that defines a measure inside {@code MATCH_RECOGNIZE}.
+   * The order of operands will change when the expression is unparsed. */
+  public static final SqlSpecialOperator PATTERN_DEFINE_AS =
+      new SqlAsOperator("PATTERN_DEFINE_AS", SqlKind.AS, 20, true,
+          ReturnTypes.ARG0, InferTypes.RETURN_TYPE, OperandTypes.ANY_ANY) {
+        @Override public void unparse(SqlWriter writer, SqlCall call,
+            int leftPrec, int rightPrec) {
+          assert call.operandCount() >= 2;
+          final SqlWriter.Frame frame =
+              writer.startList(
+                  SqlWriter.FrameTypeEnum.SIMPLE);
+          call.operand(1).unparse(writer, leftPrec, getLeftPrec());
+          final boolean needsSpace = true;
+          writer.setNeedWhitespace(needsSpace);
+          writer.sep("AS");
+          writer.setNeedWhitespace(needsSpace);
+          call.operand(0).unparse(writer, getRightPrec(), rightPrec);
+          if (call.operandCount() > 2) {
+            final SqlWriter.Frame frame1 =
+                writer.startList(SqlWriter.FrameTypeEnum.SIMPLE, "(", ")");
+            for (SqlNode operand : Util.skip(call.getOperandList(), 2)) {
+              writer.sep(",", false);
+              operand.unparse(writer, 0, 0);
+            }
+            writer.endList(frame1);
+          }
+          writer.endList(frame);
+        }
+      };
+
   //~ Methods ----------------------------------------------------------------
 
   /**

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java b/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
index e27e9db..ddddd08 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
@@ -407,7 +407,8 @@ public abstract class OperandTypes {
 
   public static final SqlSingleOperandTypeChecker ANY_ANY =
       family(SqlTypeFamily.ANY, SqlTypeFamily.ANY);
-
+  public static final SqlSingleOperandTypeChecker ANY_NUMERIC =
+    family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC);
   /**
    * Parameter type-checking strategy type must a nullable time interval,
    * nullable time interval

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java b/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
index 02823be..0ec59a7 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
@@ -385,7 +385,8 @@ public abstract class DelegatingScope implements SqlValidatorScope {
       //    SELECT e.empno FROM Emp as E
       //
       // change "e.empno" to "E.empno".
-      if (fromNs.getEnclosingNode() != null) {
+      if (fromNs.getEnclosingNode() != null
+          && !(this instanceof MatchRecognizeScope)) {
         String alias =
             SqlValidatorUtil.getAlias(fromNs.getEnclosingNode(), -1);
         if (alias != null

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeNamespace.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeNamespace.java
new file mode 100644
index 0000000..5b9a3e3
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeNamespace.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.validate;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlMatchRecognize;
+import org.apache.calcite.sql.SqlNode;
+
+/**
+ * Namespace for a {@code MATCH_RECOGNIZE} clause.
+ */
+public class MatchRecognizeNamespace extends AbstractNamespace {
+  private final SqlMatchRecognize matchRecognize;
+
+  /** Creates a MatchRecognizeNamespace. */
+  protected MatchRecognizeNamespace(SqlValidatorImpl validator,
+      SqlMatchRecognize matchRecognize,
+      SqlNode enclosingNode) {
+    super(validator, enclosingNode);
+    this.matchRecognize = matchRecognize;
+  }
+
+  @Override public RelDataType validateImpl(RelDataType targetRowType) {
+    validator.validateMatchRecognize(matchRecognize);
+    return rowType;
+  }
+
+  @Override public SqlMatchRecognize getNode() {
+    return matchRecognize;
+  }
+}
+
+// End MatchRecognizeNamespace.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeScope.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeScope.java b/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeScope.java
new file mode 100644
index 0000000..5050057
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/validate/MatchRecognizeScope.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.validate;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.StructKind;
+import org.apache.calcite.sql.SqlMatchRecognize;
+import org.apache.calcite.sql.SqlNode;
+
+import com.google.common.collect.Sets;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Scope for expressions in a {@code MATCH_RECOGNIZE} clause.
+ *
+ * <p>Defines variables and uses them as prefix of columns reference.
+ */
+public class MatchRecognizeScope extends ListScope {
+  private static final String STAR = "*";
+
+  //~ Instance fields ---------------------------------------------
+  private final SqlMatchRecognize matchRecognize;
+  private Set<String> patternVars;
+
+  /** Creates a MatchRecognizeScope. */
+  public MatchRecognizeScope(SqlValidatorScope parent,
+      SqlMatchRecognize matchRecognize) {
+    super(parent);
+    this.matchRecognize = matchRecognize;
+    patternVars = Sets.newHashSet(STAR);
+  }
+
+  @Override public SqlNode getNode() {
+    return matchRecognize;
+  }
+
+  public SqlMatchRecognize getMatchRecognize() {
+    return matchRecognize;
+  }
+
+  public Set<String> getPatternVars() {
+    return patternVars;
+  }
+
+  public void addPatternVar(String str) {
+    patternVars.add(str);
+  }
+
+  @Override public Map<String, ScopeChild>
+  findQualifyingTables(String columnName, SqlNameMatcher nameMatcher) {
+    final Map<String, ScopeChild> map = new HashMap<>();
+    for (ScopeChild child : children) {
+      final RelDataType rowType = child.namespace.getRowType();
+      if (nameMatcher.field(rowType, columnName) != null) {
+        map.put(STAR, child);
+      }
+    }
+    return map;
+  }
+
+  @Override public void resolve(List<String> names, SqlNameMatcher nameMatcher,
+     boolean deep, Resolved resolved) {
+    if (patternVars.contains(names.get(0))) {
+      final Step path = new EmptyPath().plus(null, 0, null, StructKind.FULLY_QUALIFIED);
+      final ScopeChild child = children.get(0);
+      resolved.found(child.namespace, child.nullable, this, path, names);
+      if (resolved.count() > 0) {
+        return;
+      }
+    }
+    super.resolve(names, nameMatcher, deep, resolved);
+  }
+
+}
+
+// End MatchRecognizeScope.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/4e103825/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
index 215b96c..a4b4297 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
@@ -32,6 +32,7 @@ import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlInsert;
 import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
 import org.apache.calcite.sql.SqlMerge;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
@@ -274,6 +275,13 @@ public interface SqlValidator {
       SqlCall call);
 
   /**
+   * Validates a MATCH_RECOGNIZE clause.
+   *
+   * @param pattern MATCH_RECOGNIZE clause
+   */
+  void validateMatchRecognize(SqlCall pattern);
+
+  /**
    * Validates a call to an operator.
    *
    * @param call  Operator call
@@ -554,6 +562,14 @@ public interface SqlValidator {
   SqlValidatorScope getOrderScope(SqlSelect select);
 
   /**
+   * Returns a scope match recognize clause.
+   *
+   * @param node Match recognize
+   * @return naming scope for Match recognize clause
+   */
+  SqlValidatorScope getMatchRecognizeScope(SqlMatchRecognize node);
+
+  /**
    * Declares a SELECT expression as a cursor.
    *
    * @param select select expression associated with the cursor


[04/10] calcite git commit: [CALCITE-1667] Forbid calls to JDK APIs that use the default locale, time zone or character set

Posted by jh...@apache.org.
http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/DiffTestCase.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/DiffTestCase.java b/core/src/test/java/org/apache/calcite/test/DiffTestCase.java
index 7e3adee..c8a9a89 100644
--- a/core/src/test/java/org/apache/calcite/test/DiffTestCase.java
+++ b/core/src/test/java/org/apache/calcite/test/DiffTestCase.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.test;
 
 import org.apache.calcite.util.ReflectUtil;
+import org.apache.calcite.util.Util;
 
 import org.incava.util.diff.Diff;
 import org.incava.util.diff.Difference;
@@ -24,15 +25,18 @@ import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.FileOutputStream;
-import java.io.FileReader;
 import java.io.IOException;
 import java.io.LineNumberReader;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.StringWriter;
 import java.io.Writer;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
@@ -71,8 +75,6 @@ public abstract class DiffTestCase {
   private String ignorePatterns;
   Matcher compiledIgnoreMatcher;
 
-  int gcInterval;
-
   /**
    * Whether to give verbose message if diff fails.
    */
@@ -92,7 +94,6 @@ public abstract class DiffTestCase {
     ignorePatterns = "";
     compiledIgnoreMatcher = null;
     compiledDiffMatcher = null;
-    gcInterval = 0;
     String verboseVal =
         System.getProperty(DiffTestCase.class.getName() + ".verbose");
     if (verboseVal != null) {
@@ -109,7 +110,6 @@ public abstract class DiffTestCase {
     ignorePatterns = "";
     compiledIgnoreMatcher = null;
     compiledDiffMatcher = null;
-    gcInterval = 0;
   }
 
   @After
@@ -142,7 +142,8 @@ public abstract class DiffTestCase {
         new File(
             testClassDir,
             testCaseName);
-    return new OutputStreamWriter(openTestLogOutputStream(testLogFile));
+    return new OutputStreamWriter(
+        openTestLogOutputStream(testLogFile), StandardCharsets.UTF_8);
   }
 
   /**
@@ -206,19 +207,9 @@ public abstract class DiffTestCase {
    */
   protected void diffFile(File logFile, File refFile) throws IOException {
     int n = 0;
-    FileReader logReader = null;
-    FileReader refReader = null;
+    BufferedReader logReader = null;
+    BufferedReader refReader = null;
     try {
-      if (compiledIgnoreMatcher != null) {
-        if (gcInterval != 0) {
-          n++;
-          if (n == gcInterval) {
-            n = 0;
-            System.gc();
-          }
-        }
-      }
-
       // NOTE: Use of diff.mask is deprecated, use diff_mask.
       String diffMask = System.getProperty("diff.mask", null);
       if (diffMask != null) {
@@ -230,8 +221,8 @@ public abstract class DiffTestCase {
         addDiffMask(diffMask);
       }
 
-      logReader = new FileReader(logFile);
-      refReader = new FileReader(refFile);
+      logReader = Util.reader(logFile);
+      refReader = Util.reader(refFile);
       LineNumberReader logLineReader = new LineNumberReader(logReader);
       LineNumberReader refLineReader = new LineNumberReader(refReader);
       for (;;) {
@@ -280,16 +271,6 @@ public abstract class DiffTestCase {
   }
 
   /**
-   * set the number of lines for garbage collection.
-   *
-   * @param n an integer, the number of line for garbage collection, 0 means
-   *          no garbage collection.
-   */
-  protected void setGC(int n) {
-    gcInterval = n;
-  }
-
-  /**
    * Adds a diff mask. Strings matching the given regular expression will be
    * masked before diffing. This can be used to suppress spurious diffs on a
    * case-by-case basis.
@@ -471,9 +452,8 @@ public abstract class DiffTestCase {
    * @return List of lines
    */
   private static List<String> fileLines(File file) {
-    List<String> lines = new ArrayList<String>();
-    try {
-      LineNumberReader r = new LineNumberReader(new FileReader(file));
+    List<String> lines = new ArrayList<>();
+    try (LineNumberReader r = new LineNumberReader(Util.reader(file))) {
       String line;
       while ((line = r.readLine()) != null) {
         lines.add(line);
@@ -492,15 +472,14 @@ public abstract class DiffTestCase {
    * @return Contents of the file
    */
   protected static String fileContents(File file) {
-    try {
-      char[] buf = new char[2048];
-      final FileReader reader = new FileReader(file);
+    byte[] buf = new byte[2048];
+    try (final FileInputStream reader = new FileInputStream(file)) {
       int readCount;
-      final StringWriter writer = new StringWriter();
+      final ByteArrayOutputStream writer = new ByteArrayOutputStream();
       while ((readCount = reader.read(buf)) >= 0) {
         writer.write(buf, 0, readCount);
       }
-      return writer.toString();
+      return writer.toString(StandardCharsets.UTF_8.name());
     } catch (IOException e) {
       throw new RuntimeException(e);
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcTest.java b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
index 5196732..2fcbb0a 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
@@ -108,7 +108,6 @@ import org.junit.Ignore;
 import org.junit.Test;
 
 import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.Reader;
@@ -132,6 +131,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -5233,8 +5233,7 @@ public class JdbcTest {
   private void checkCustomSchemaInFileInPwd(String fileName)
       throws SQLException {
     final File file = new File(fileName);
-    try (final FileWriter fw = new FileWriter(file);
-         final PrintWriter pw = new PrintWriter(fw)) {
+    try (final PrintWriter pw = Util.printWriter(file)) {
       file.deleteOnExit();
       pw.println("{\n"
           + "  version: '1.0',\n"
@@ -5673,6 +5672,8 @@ public class JdbcTest {
   @Test public void testGetTimestamp() throws Exception {
     CalciteAssert.that()
         .with("timezone", "GMT+1:00")
+        // Workaround, until [CALCITE-1667] is fixed in Avatica
+        .with("TIME_ZONE", "GMT+1:00")
         .doWithConnection(
             new Function<CalciteConnection, Void>() {
               public Void apply(CalciteConnection connection) {
@@ -5707,10 +5708,10 @@ public class JdbcTest {
     TimeZone tzGmt05 = TimeZone.getTimeZone("GMT-05"); // -0500 always
     TimeZone tzGmt13 = TimeZone.getTimeZone("GMT+13"); // +1000 always
 
-    Calendar cUtc   = Calendar.getInstance(tzUtc);
-    Calendar cGmt03 = Calendar.getInstance(tzGmt03);
-    Calendar cGmt05 = Calendar.getInstance(tzGmt05);
-    Calendar cGmt13 = Calendar.getInstance(tzGmt13);
+    Calendar cUtc   = Calendar.getInstance(tzUtc, Locale.ROOT);
+    Calendar cGmt03 = Calendar.getInstance(tzGmt03, Locale.ROOT);
+    Calendar cGmt05 = Calendar.getInstance(tzGmt05, Locale.ROOT);
+    Calendar cGmt13 = Calendar.getInstance(tzGmt13, Locale.ROOT);
 
     Timestamp ts;
     String s;

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/QuidemTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/QuidemTest.java b/core/src/test/java/org/apache/calcite/test/QuidemTest.java
index f15fe13..40a3266 100644
--- a/core/src/test/java/org/apache/calcite/test/QuidemTest.java
+++ b/core/src/test/java/org/apache/calcite/test/QuidemTest.java
@@ -42,11 +42,10 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
-import java.io.BufferedReader;
 import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
 import java.io.FilenameFilter;
+import java.io.Reader;
+import java.io.Writer;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.sql.Connection;
@@ -148,11 +147,10 @@ public class QuidemTest {
       outFile = new File(base, u2n("/surefire/") + path);
     }
     Util.discard(outFile.getParentFile().mkdirs());
-    try (final FileReader fileReader = new FileReader(inFile);
-         final BufferedReader bufferedReader = new BufferedReader(fileReader);
-         final FileWriter writer = new FileWriter(outFile);
+    try (final Reader reader = Util.reader(inFile);
+         final Writer writer = Util.printWriter(outFile);
          final Closer closer = new Closer()) {
-      new Quidem(bufferedReader, writer, env(), new QuidemConnectionFactory())
+      new Quidem(reader, writer, env(), new QuidemConnectionFactory())
           .withPropertyHandler(new Quidem.PropertyHandler() {
             public void onSet(String propertyName, Object value) {
               if (propertyName.equals("bindable")) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java b/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
index 69cccd0..84deb87 100644
--- a/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
@@ -37,6 +37,7 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.calcite.util.Holder;
 import org.apache.calcite.util.NlsString;
+import org.apache.calcite.util.Util;
 
 import org.junit.Ignore;
 import org.junit.Test;
@@ -177,7 +178,7 @@ public class RexImplicationCheckerTest {
   @Ignore("work in progress")
   @Test public void testSimpleDate() {
     final Fixture f = new Fixture();
-    final Calendar instance = Calendar.getInstance();
+    final Calendar instance = Util.calendar();
     final RexNode node1 = f.ge(f.dt, f.rexBuilder.makeDateLiteral(instance));
     final RexNode node2 = f.eq(f.dt, f.rexBuilder.makeDateLiteral(instance));
 
@@ -188,7 +189,7 @@ public class RexImplicationCheckerTest {
   @Ignore("work in progress")
   @Test public void testSimpleTimeStamp() {
     final Fixture f = new Fixture();
-    final Calendar calendar = Calendar.getInstance();
+    final Calendar calendar = Util.calendar();
     final RexNode node1 = f.le(f.ts, f.timestampLiteral(calendar));
     final RexNode node2 = f.le(f.ts, f.timestampLiteral(calendar));
 
@@ -199,7 +200,7 @@ public class RexImplicationCheckerTest {
   @Ignore("work in progress")
   @Test public void testSimpleTime() {
     final Fixture f = new Fixture();
-    final Calendar calendar = Calendar.getInstance();
+    final Calendar calendar = Util.calendar();
     final RexNode node1 = f.le(f.ts, f.timeLiteral(calendar));
     final RexNode node2 = f.le(f.ts, f.timeLiteral(calendar));
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
index 090f3ba..9ce8017 100644
--- a/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RexProgramTest.java
@@ -18,7 +18,6 @@ package org.apache.calcite.test;
 
 import org.apache.calcite.adapter.java.JavaTypeFactory;
 import org.apache.calcite.avatica.util.ByteString;
-import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
 import org.apache.calcite.plan.Strong;
 import org.apache.calcite.rel.type.RelDataType;
@@ -1310,7 +1309,7 @@ public class RexProgramTest {
   }
 
   private Calendar cal(int y, int m, int d, int h, int mm, int s) {
-    final Calendar c = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+    final Calendar c = Util.calendar();
     c.set(Calendar.YEAR, y);
     c.set(Calendar.MONTH, m);
     c.set(Calendar.DAY_OF_MONTH, d);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
index 00e789d..12ef35b 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
@@ -88,11 +88,11 @@ public class SqlFunctionsTest {
   }
 
   @Test public void testLower() {
-    assertEquals("a bcd", lower("A bCd"));
+    assertEquals("a bcd iijk", lower("A bCd Iijk"));
   }
 
   @Test public void testUpper() {
-    assertEquals("A BCD", upper("A bCd"));
+    assertEquals("A BCD IIJK", upper("A bCd iIjk"));
   }
 
   @Test public void testInitcap() {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/SqlLimitsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlLimitsTest.java b/core/src/test/java/org/apache/calcite/test/SqlLimitsTest.java
index c8d44ce..298830b 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlLimitsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlLimitsTest.java
@@ -211,11 +211,11 @@ public class SqlLimitsTest {
   private DateFormat getDateFormat(SqlTypeName typeName) {
     switch (typeName) {
     case DATE:
-      return new SimpleDateFormat("MMM d, yyyy");
+      return new SimpleDateFormat("MMM d, yyyy", Locale.ROOT);
     case TIME:
-      return new SimpleDateFormat("hh:mm:ss a");
+      return new SimpleDateFormat("hh:mm:ss a", Locale.ROOT);
     default:
-      return new SimpleDateFormat("MMM d, yyyy hh:mm:ss a");
+      return new SimpleDateFormat("MMM d, yyyy hh:mm:ss a", Locale.ROOT);
     }
   }
 }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/SqlLineTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlLineTest.java b/core/src/test/java/org/apache/calcite/test/SqlLineTest.java
index 241df75..9530e06 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlLineTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlLineTest.java
@@ -18,6 +18,7 @@ package org.apache.calcite.test;
 
 import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Util;
 
 import org.hamcrest.Matcher;
 
@@ -25,8 +26,9 @@ import org.junit.Test;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -52,7 +54,8 @@ public class SqlLineTest {
       throws Throwable {
     SqlLine sqlline = new SqlLine();
     ByteArrayOutputStream os = new ByteArrayOutputStream();
-    PrintStream sqllineOutputStream = new PrintStream(os);
+    PrintStream sqllineOutputStream =
+        new PrintStream(os, false, StandardCharsets.UTF_8.name());
     sqlline.setOutputStream(sqllineOutputStream);
     sqlline.setErrorStream(sqllineOutputStream);
     SqlLine.Status status = SqlLine.Status.OK;
@@ -92,9 +95,9 @@ public class SqlLineTest {
     // Put the script content in a temp file
     File scriptFile = File.createTempFile("foo", "temp");
     scriptFile.deleteOnExit();
-    PrintStream os = new PrintStream(new FileOutputStream(scriptFile));
-    os.print(scriptText);
-    os.close();
+    try (PrintWriter w = Util.printWriter(scriptFile)) {
+      w.print(scriptText);
+    }
 
     Pair<SqlLine.Status, String> pair = runScript(scriptFile, flag);
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlTestGen.java b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
index e330efc..95ab005 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
@@ -24,9 +24,9 @@ import org.apache.calcite.sql.test.SqlTester;
 import org.apache.calcite.sql.test.SqlTesterImpl;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.util.BarfingInvocationHandler;
+import org.apache.calcite.util.Util;
 
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.lang.reflect.InvocationTargetException;
@@ -51,8 +51,7 @@ public class SqlTestGen {
 
   private void genValidatorTest() {
     final File file = new File("validatorTest.sql");
-    try (FileOutputStream fos = new FileOutputStream(file);
-         PrintWriter pw = new PrintWriter(fos)) {
+    try (PrintWriter pw = Util.printWriter(file)) {
       Method[] methods = getJunitMethods(SqlValidatorSpooler.class);
       for (Method method : methods) {
         final SqlValidatorSpooler test = new SqlValidatorSpooler(pw);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index 8c0f268..938d4c7 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -3637,7 +3637,7 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
 
     for (String interval : tsi) {
       for (String function : functions) {
-        checkExp(String.format(function, interval));
+        checkExp(String.format(Locale.ROOT, function, interval));
       }
     }
 
@@ -7844,7 +7844,7 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
       case INTERNAL:
         break;
       default:
-        assertThat(name.toUpperCase(), equalTo(name));
+        assertThat(name.toUpperCase(Locale.ROOT), equalTo(name));
         break;
       }
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandExecutor.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandExecutor.java b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandExecutor.java
index 25d89eb..62e2b1c 100644
--- a/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandExecutor.java
+++ b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandExecutor.java
@@ -16,6 +16,8 @@
  */
 package org.apache.calcite.test.concurrent;
 
+import org.apache.calcite.util.Unsafe;
+
 import java.io.PrintStream;
 import java.sql.Connection;
 import java.sql.DriverManager;
@@ -288,13 +290,13 @@ class ConcurrentTestCommandExecutor extends Thread {
     synchronized void waitForOthers() throws InterruptedException {
       if (++numWaiting == numThreads) {
         numWaiting = 0;
-        notifyAll();
+        Unsafe.notifyAll(this);
       } else {
         // REVIEW: SZ 6/17/2004: Need a timeout here --
         // otherwise a test case will hang forever if there's
         // a deadlock.  The question is, how long should the
         // timeout be to avoid falsely detecting deadlocks?
-        wait();
+        Unsafe.wait(this);
       }
     }
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
index eebb79c..ab3f7b1 100644
--- a/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
+++ b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
@@ -17,14 +17,13 @@
 package org.apache.calcite.test.concurrent;
 
 import org.apache.calcite.jdbc.SqlTimeoutException;
+import org.apache.calcite.util.Unsafe;
 import org.apache.calcite.util.Util;
 
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileReader;
 import java.io.IOException;
-import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StringReader;
 import java.io.StringWriter;
@@ -43,6 +42,7 @@ import java.util.Arrays;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.StringTokenizer;
@@ -440,12 +440,13 @@ public class ConcurrentTestCommandScript
    * translates argument of !set force etc.
    */
   private boolean asBoolValue(String s) {
-    s = s.toLowerCase();
-    return s.equals("true") || s.equals("yes") || s.equals("on");
+    return s.equalsIgnoreCase("true")
+        || s.equalsIgnoreCase("yes")
+        || s.equalsIgnoreCase("on");
   }
 
   /**
-   * Determines if a block of SQL is a select statment or not.
+   * Determines whether a block of SQL is a SELECT statement.
    */
   private boolean isSelect(String sql) {
     BufferedReader rdr = new BufferedReader(new StringReader(sql));
@@ -453,7 +454,7 @@ public class ConcurrentTestCommandScript
     try {
       String line;
       while ((line = rdr.readLine()) != null) {
-        line = line.trim().toLowerCase();
+        line = line.trim().toLowerCase(Locale.ROOT);
         if (isComment(line)) {
           continue;
         }
@@ -520,11 +521,11 @@ public class ConcurrentTestCommandScript
     }
   }
 
-  public void printResults(BufferedWriter out) throws IOException {
+  public void printResults(PrintWriter out) throws IOException {
     final Map<Integer, String[]> results = collectResults();
     if (verbose) {
       out.write(
-          String.format(
+          String.format(Locale.ROOT,
               "script execution started at %tc (%d)%n",
               new Timestamp(scriptStartTime), scriptStartTime));
     }
@@ -538,18 +539,18 @@ public class ConcurrentTestCommandScript
     printThreadResults(out, results.get(CLEANUP_THREAD_ID));
   }
 
-  private void printThreadResults(BufferedWriter out, String[] threadResult)
+  private void printThreadResults(PrintWriter out, String[] threadResult)
       throws IOException {
     if (threadResult == null) {
       return;
     }
     String threadName = threadResult[0];
     out.write("-- " + threadName);
-    out.newLine();
+    out.println();
     out.write(threadResult[1]);
     out.write("-- end of " + threadName);
-    out.newLine();
-    out.newLine();
+    out.println();
+    out.println();
     out.flush();
   }
 
@@ -848,7 +849,7 @@ public class ConcurrentTestCommandScript
     private void load(String scriptFileName) throws IOException {
       File scriptFile = new File(currentDirectory.peek(), scriptFileName);
       currentDirectory.push(scriptDirectory = scriptFile.getParentFile());
-      try (BufferedReader in = new BufferedReader(new FileReader(scriptFile))) {
+      try (BufferedReader in = Util.reader(scriptFile)) {
         String line;
         while ((line = in.readLine()) != null) {
           line = line.trim();
@@ -1891,8 +1892,7 @@ public class ConcurrentTestCommandScript
           out.println();
         }
         if (verbose) {
-          out.printf(
-              "fetch started at %tc %d, %s at %tc %d%n",
+          out.printf(Locale.ROOT, "fetch started at %tc %d, %s at %tc %d%n",
               startTime, startTime,
               timedOut ? "timeout" : "eos",
               endTime, endTime);
@@ -1903,20 +1903,19 @@ public class ConcurrentTestCommandScript
             dt -= timeout;
           }
           assert dt >= 0;
-          out.printf(
-              "fetched %d rows in %d msecs %s%n",
+          out.printf(Locale.ROOT, "fetched %d rows in %d msecs %s%n",
               rowCount, dt, timedOut ? "(timeout)" : "(end)");
         }
       }
     }
 
     private void printRowCount(int count) {
-      out.printf("(%06d) ", count);
+      out.printf(Locale.ROOT, "(%06d) ", count);
     }
 
     private void printTimestamp(long time) {
       time -= baseTime;
-      out.printf("(% 4d.%03d) ", time / 1000, time % 1000);
+      out.printf(Locale.ROOT, "(% 4d.%03d) ", time / 1000, time % 1000);
     }
 
     // indent a heading or separator line to match a row-values line
@@ -2003,7 +2002,7 @@ public class ConcurrentTestCommandScript
 
     // returns 0 on success, 1 on error, 2 on bad invocation.
     public int run(String[] args) {
-      try {
+      try (final PrintWriter w = Util.printWriter(System.out)) {
         if (!parseCommand(args)) {
           usage();
           return 2;
@@ -2018,8 +2017,6 @@ public class ConcurrentTestCommandScript
           jdbcProps.setProperty("password", password);
         }
 
-        BufferedWriter cout =
-            new BufferedWriter(new OutputStreamWriter(System.out));
         for (String file : files) {
           ConcurrentTestCommandScript script =
               new ConcurrentTestCommandScript();
@@ -2032,7 +2029,7 @@ public class ConcurrentTestCommandScript
             script.execute();
           } finally {
             if (!quiet) {
-              script.printResults(cout);
+              script.printResults(w);
             }
           }
         }
@@ -2109,7 +2106,7 @@ public class ConcurrentTestCommandScript
    */
   public static void main(String[] args) {
     int status = new Tool().run(args);
-    System.exit(status);
+    Unsafe.systemExit(status);
   }
 }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/util/Smalls.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/util/Smalls.java b/core/src/test/java/org/apache/calcite/util/Smalls.java
index c37f320..a2ac470 100644
--- a/core/src/test/java/org/apache/calcite/util/Smalls.java
+++ b/core/src/test/java/org/apache/calcite/util/Smalls.java
@@ -49,6 +49,7 @@ import java.lang.reflect.Method;
 import java.util.AbstractList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Locale;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -427,7 +428,7 @@ public class Smalls {
     private MultipleFunction() {}
 
     // Three overloads
-    public static String fun1(String x) { return x.toLowerCase(); }
+    public static String fun1(String x) { return x.toLowerCase(Locale.ROOT); }
     public static int fun1(int x) { return x * 2; }
     public static int fun1(int x, int y) { return x + y; }
 
@@ -615,19 +616,24 @@ public class Smalls {
     }
 
     public static ScannableTable generate(int width, int height, int seed) {
-      return new MazeTable(String.format("generate(w=%d, h=%d, s=%d)", width, height, seed));
+      return new MazeTable(
+          String.format(Locale.ROOT, "generate(w=%d, h=%d, s=%d)", width,
+              height, seed));
     }
 
     public static ScannableTable generate2(
         @Parameter(name = "WIDTH") int width,
         @Parameter(name = "HEIGHT") int height,
         @Parameter(name = "SEED", optional = true) Integer seed) {
-      return new MazeTable(String.format("generate2(w=%d, h=%d, s=%d)", width, height, seed));
+      return new MazeTable(
+          String.format(Locale.ROOT, "generate2(w=%d, h=%d, s=%d)", width,
+              height, seed));
     }
 
     public static ScannableTable generate3(
         @Parameter(name = "FOO") String foo) {
-      return new MazeTable(String.format("generate3(foo=%s)", foo));
+      return new MazeTable(
+          String.format(Locale.ROOT, "generate3(foo=%s)", foo));
     }
 
     public RelDataType getRowType(RelDataTypeFactory typeFactory) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/util/UtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/util/UtilTest.java b/core/src/test/java/org/apache/calcite/util/UtilTest.java
index 8afc09b..2f48d64 100644
--- a/core/src/test/java/org/apache/calcite/util/UtilTest.java
+++ b/core/src/test/java/org/apache/calcite/util/UtilTest.java
@@ -762,10 +762,10 @@ public class UtilTest {
    */
   @Test public void testTemplate() {
     // Regular java message format.
-    assertEquals(
-        "Hello, world, what a nice day.",
-        MessageFormat.format(
-            "Hello, {0}, what a nice {1}.", "world", "day"));
+    assertThat(
+        new MessageFormat("Hello, {0}, what a nice {1}.", Locale.ROOT)
+            .format(new Object[]{"world", "day"}),
+        is("Hello, world, what a nice day."));
 
     // Our extended message format. First, just strings.
     final HashMap<Object, Object> map = new HashMap<>();
@@ -1513,8 +1513,8 @@ public class UtilTest {
 
     final Comparator<String> comparator = new Comparator<String>() {
       public int compare(String o1, String o2) {
-        String u1 = o1.toUpperCase();
-        String u2 = o2.toUpperCase();
+        String u1 = o1.toUpperCase(Locale.ROOT);
+        String u2 = o2.toUpperCase(Locale.ROOT);
         int c = u1.compareTo(u2);
         if (c == 0) {
           c = o1.compareTo(o2);
@@ -1545,7 +1545,8 @@ public class UtilTest {
   }
 
   private NavigableSet<String> checkNav(NavigableSet<String> set, String s) {
-    return set.subSet(s.toUpperCase(), true, s.toLowerCase(), true);
+    return set.subSet(s.toUpperCase(Locale.ROOT), true,
+        s.toLowerCase(Locale.ROOT), true);
   }
 
   /** Test for {@link org.apache.calcite.util.ImmutableNullableList}. */
@@ -1741,7 +1742,7 @@ public class UtilTest {
     final Map<String, String> map = Util.asIndexMap(values,
         new Function<String, String>() {
           public String apply(@Nullable String input) {
-            return input.toUpperCase();
+            return input.toUpperCase(Locale.ROOT);
           }
         });
     assertThat(map.size(), equalTo(values.size()));

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidConnectionImpl.java
----------------------------------------------------------------------
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidConnectionImpl.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidConnectionImpl.java
index d7f54fa..036a2e1 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidConnectionImpl.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidConnectionImpl.java
@@ -45,11 +45,13 @@ import com.google.common.collect.ImmutableSet;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;
@@ -71,7 +73,8 @@ class DruidConnectionImpl implements DruidConnection {
 
   static {
     final TimeZone utc = DateTimeUtils.GMT_ZONE;
-    UTC_TIMESTAMP_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
+    UTC_TIMESTAMP_FORMAT =
+        new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.ROOT);
     UTC_TIMESTAMP_FORMAT.setTimeZone(utc);
   }
 
@@ -117,7 +120,8 @@ class DruidConnectionImpl implements DruidConnection {
     if (CalcitePrepareImpl.DEBUG) {
       try {
         final byte[] bytes = AvaticaUtils.readFullyToBytes(in);
-        System.out.println("Response: " + new String(bytes));
+        System.out.println("Response: "
+            + new String(bytes, StandardCharsets.UTF_8));
         in = new ByteArrayInputStream(bytes);
       } catch (IOException e) {
         throw new RuntimeException(e);
@@ -516,7 +520,8 @@ class DruidConnectionImpl implements DruidConnection {
       try {
         final byte[] bytes = AvaticaUtils.readFullyToBytes(in);
         in.close();
-        System.out.println("Response: " + new String(bytes));
+        System.out.println("Response: "
+            + new String(bytes, StandardCharsets.UTF_8));
         in = new ByteArrayInputStream(bytes);
       } catch (IOException e) {
         throw new RuntimeException(e);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
----------------------------------------------------------------------
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
index 17ddd05..694f9c7 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
@@ -962,7 +962,7 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
       case OR:
       case NOT:
         call = (RexCall) e;
-        return new JsonCompositeFilter(e.getKind().toString().toLowerCase(),
+        return new JsonCompositeFilter(e.getKind().lowerName,
             translateFilters(call.getOperands()));
       }
       throw new AssertionError("cannot translate filter: " + e);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/druid/src/main/java/org/apache/calcite/adapter/druid/Granularity.java
----------------------------------------------------------------------
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/Granularity.java b/druid/src/main/java/org/apache/calcite/adapter/druid/Granularity.java
index b3f1e85..0ee2e20 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/Granularity.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/Granularity.java
@@ -16,6 +16,8 @@
  */
 package org.apache.calcite.adapter.druid;
 
+import java.util.Locale;
+
 /** Granularity of a Druid query. */
 public enum Granularity {
   ALL,
@@ -30,7 +32,7 @@ public enum Granularity {
   NONE;
 
   /** JSON attribute value in a Druid query. */
-  public final String value = name().toLowerCase();
+  public final String value = name().toLowerCase(Locale.ROOT);
 }
 
 // End Granularity.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
----------------------------------------------------------------------
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
index f11a7b5..ef22fa2 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
@@ -39,6 +39,7 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 
@@ -93,7 +94,8 @@ public class ElasticsearchFilter extends Filter implements ElasticsearchRel {
       final Map<String, Object> map = builder.map();
       map.put("constant_score", filterMap);
 
-      return "\"query\" : " + builder.toJsonString(map).replaceAll("\\s+", "").toLowerCase();
+      return "\"query\" : " + builder.toJsonString(map).replaceAll("\\s+", "")
+          .toLowerCase(Locale.ROOT);
     }
 
     private Object translateOr(RexNode condition) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvSchemaFactory.java
----------------------------------------------------------------------
diff --git a/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvSchemaFactory.java b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvSchemaFactory.java
index 44520c1..b544b16 100644
--- a/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvSchemaFactory.java
+++ b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvSchemaFactory.java
@@ -22,6 +22,7 @@ import org.apache.calcite.schema.SchemaFactory;
 import org.apache.calcite.schema.SchemaPlus;
 
 import java.io.File;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -56,7 +57,7 @@ public class CsvSchemaFactory implements SchemaFactory {
     if (flavorName == null) {
       flavor = CsvTable.Flavor.SCANNABLE;
     } else {
-      flavor = CsvTable.Flavor.valueOf(flavorName.toUpperCase());
+      flavor = CsvTable.Flavor.valueOf(flavorName.toUpperCase(Locale.ROOT));
     }
     return new CsvSchema(directoryFile, flavor);
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
----------------------------------------------------------------------
diff --git a/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
index 38693ce..47c9213 100644
--- a/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
+++ b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
@@ -31,7 +31,6 @@ import org.junit.Ignore;
 import org.junit.Test;
 
 import java.io.File;
-import java.io.FileWriter;
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.net.URL;
@@ -582,7 +581,7 @@ public class CsvTest {
 
     try (final Connection connection =
              DriverManager.getConnection("jdbc:calcite:model=inline:" + model);
-         final PrintWriter pw = new PrintWriter(new FileWriter(file));
+         final PrintWriter pw = Util.printWriter(file);
          final Worker<Void> worker = new Worker<>()) {
       final Thread thread = new Thread(worker);
       thread.start();

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/example/function/src/main/java/org/apache/calcite/example/maze/MazeTable.java
----------------------------------------------------------------------
diff --git a/example/function/src/main/java/org/apache/calcite/example/maze/MazeTable.java b/example/function/src/main/java/org/apache/calcite/example/maze/MazeTable.java
index 3a2dc02..a08b366 100644
--- a/example/function/src/main/java/org/apache/calcite/example/maze/MazeTable.java
+++ b/example/function/src/main/java/org/apache/calcite/example/maze/MazeTable.java
@@ -27,6 +27,7 @@ import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.schema.ScannableTable;
 import org.apache.calcite.schema.impl.AbstractTable;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.util.Util;
 
 import java.io.PrintWriter;
 import java.util.Random;
@@ -88,7 +89,7 @@ public class MazeTable extends AbstractTable implements ScannableTable {
   public Enumerable<Object[]> scan(DataContext root) {
     final Random random = seed >= 0 ? new Random(seed) : new Random();
     final Maze maze = new Maze(width, height);
-    final PrintWriter pw = new PrintWriter(System.out);
+    final PrintWriter pw = Util.printWriter(System.out);
     maze.layout(random, pw);
     if (Maze.DEBUG) {
       maze.print(pw, true);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/file/src/main/java/org/apache/calcite/adapter/file/FileReader.java
----------------------------------------------------------------------
diff --git a/file/src/main/java/org/apache/calcite/adapter/file/FileReader.java b/file/src/main/java/org/apache/calcite/adapter/file/FileReader.java
index fc6904b..6eecce4 100644
--- a/file/src/main/java/org/apache/calcite/adapter/file/FileReader.java
+++ b/file/src/main/java/org/apache/calcite/adapter/file/FileReader.java
@@ -24,6 +24,8 @@ import org.jsoup.nodes.Element;
 import org.jsoup.select.Elements;
 
 import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Iterator;
 
 /**
@@ -31,12 +33,10 @@ import java.util.Iterator;
  */
 public class FileReader implements Iterable<Elements> {
 
-  private static final String DEFAULT_CHARSET = "UTF-8";
-
   private final Source source;
   private final String selector;
   private final Integer index;
-  private final String charset = DEFAULT_CHARSET;
+  private final Charset charset = StandardCharsets.UTF_8;
   private Element tableElement;
   private Elements headings;
 
@@ -63,7 +63,7 @@ public class FileReader implements Iterable<Elements> {
     try {
       String proto = source.protocol();
       if (proto.equals("file")) {
-        doc = Jsoup.parse(source.file(), this.charset);
+        doc = Jsoup.parse(source.file(), this.charset.name());
       } else {
         doc = Jsoup.connect(source.path()).get();
       }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/file/src/main/java/org/apache/calcite/adapter/file/FileRowConverter.java
----------------------------------------------------------------------
diff --git a/file/src/main/java/org/apache/calcite/adapter/file/FileRowConverter.java b/file/src/main/java/org/apache/calcite/adapter/file/FileRowConverter.java
index a6c1bcc..827bf59 100644
--- a/file/src/main/java/org/apache/calcite/adapter/file/FileRowConverter.java
+++ b/file/src/main/java/org/apache/calcite/adapter/file/FileRowConverter.java
@@ -36,6 +36,7 @@ import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
@@ -55,6 +56,16 @@ class FileRowConverter {
   // row parser configuration
   private final List<FieldDef> fields = new ArrayList<>();
 
+  /** Format for parsing numbers. Not thread-safe, but we assume that only
+   * one thread uses this converter at a time. */
+  private final NumberFormat numberFormat =
+      NumberFormat.getInstance(Locale.ROOT);
+
+  /** Format for parsing integers. Not thread-safe, but we assume that only
+   * one thread uses this converter at a time. */
+  private final NumberFormat integerFormat =
+      NumberFormat.getIntegerInstance(Locale.ROOT);
+
   /** Creates a FileRowConverter. */
   FileRowConverter(FileReader fileReader,
       List<Map<String, Object>> fieldConfigs) {
@@ -340,43 +351,36 @@ class FileRowConverter {
         return Byte.parseByte(string);
 
       case SHORT:
-
         try {
-          return NumberFormat.getIntegerInstance().parse(string)
-              .shortValue();
+          return integerFormat.parse(string).shortValue();
         } catch (ParseException e) {
           return null;
         }
 
       case INT:
-
         try {
-          return NumberFormat.getIntegerInstance().parse(string)
-              .intValue();
+          return integerFormat.parse(string).intValue();
         } catch (ParseException e) {
           return null;
         }
 
       case LONG:
-
         try {
-          return NumberFormat.getInstance().parse(string).longValue();
+          return numberFormat.parse(string).longValue();
         } catch (ParseException e) {
           return null;
         }
 
       case FLOAT:
-
         try {
-          return NumberFormat.getInstance().parse(string).floatValue();
+          return numberFormat.parse(string).floatValue();
         } catch (ParseException e) {
           return null;
         }
 
       case DOUBLE:
-
         try {
-          return NumberFormat.getInstance().parse(string).doubleValue();
+          return numberFormat.parse(string).doubleValue();
         } catch (ParseException e) {
           return null;
         }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
----------------------------------------------------------------------
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
index f19bdd0..e55a025 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
@@ -52,6 +52,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -338,7 +339,8 @@ public class Linq4jTest {
                 return String.CASE_INSENSITIVE_ORDER.compare(v1, v2) == 0;
               }
               public int hashCode(String s) {
-                return s == null ? Objects.hashCode(null) : s.toLowerCase().hashCode();
+                return s == null ? Objects.hashCode(null)
+                    : s.toLowerCase(Locale.ROOT).hashCode();
               }
             });
     assertEquals(3, map.size());
@@ -361,7 +363,7 @@ public class Linq4jTest {
             .toMap(Functions.<String>identitySelector(),
                 new Function1<String, String>() {
                   public String apply(String x) {
-                    return x == null ? null : x.toUpperCase();
+                    return x == null ? null : x.toUpperCase(Locale.ROOT);
                   }
                 },
                 new EqualityComparer<String>() {
@@ -369,7 +371,8 @@ public class Linq4jTest {
                     return String.CASE_INSENSITIVE_ORDER.compare(v1, v2) == 0;
                   }
                   public int hashCode(String s) {
-                    return s == null ? Objects.hashCode(null) : s.toLowerCase().hashCode();
+                    return s == null ? Objects.hashCode(null)
+                        : s.toLowerCase(Locale.ROOT).hashCode();
                   }
                 });
     assertEquals(3, map.size());
@@ -2161,8 +2164,7 @@ public class Linq4jTest {
             .groupBy(EMP_DEPTNO_SELECTOR)
             .select(new Function1<Grouping<Integer, Employee>, String>() {
               public String apply(Grouping<Integer, Employee> group) {
-                return String.format("%s: %s",
-                    group.getKey(),
+                return String.format(Locale.ROOT, "%s: %s", group.getKey(),
                     stringJoin("+", group.select(new Function1<Employee, String>() {
                       public String apply(Employee element) {
                         return element.name;
@@ -2190,8 +2192,7 @@ public class Linq4jTest {
             })
             .select(new Function1<Grouping<Integer, Employee>, String>() {
               public String apply(Grouping<Integer, Employee> group) {
-                return String.format("%s: %s",
-                    group.getKey(),
+                return String.format(Locale.ROOT, "%s: %s", group.getKey(),
                     stringJoin("+", group.select(new Function1<Employee, String>() {
                       public String apply(Employee element) {
                         return element.name;
@@ -2212,7 +2213,8 @@ public class Linq4jTest {
             .groupBy(EMP_DEPTNO_SELECTOR, EMP_NAME_SELECTOR)
             .select(new Function1<Grouping<Integer, String>, String>() {
               public String apply(Grouping<Integer, String> group) {
-                return String.format("%s: %s", group.getKey(), stringJoin("+", group));
+                return String.format(Locale.ROOT, "%s: %s", group.getKey(),
+                    stringJoin("+", group));
               }
             })
             .toList()
@@ -2249,7 +2251,8 @@ public class Linq4jTest {
             })
             .select(new Function1<Grouping<Integer, String>, String>() {
               public String apply(Grouping<Integer, String> group) {
-                return String.format("%s: %s", group.getKey(), stringJoin("+", group));
+                return String.format(Locale.ROOT, "%s: %s", group.getKey(),
+                    stringJoin("+", group));
               }
             })
             .toList()
@@ -2264,8 +2267,7 @@ public class Linq4jTest {
         Linq4j.asEnumerable(emps)
             .groupBy(EMP_DEPTNO_SELECTOR, new Function2<Integer, Enumerable<Employee>, String>() {
               public String apply(Integer key, Enumerable<Employee> group) {
-                return String.format("%s: %s",
-                    key,
+                return String.format(Locale.ROOT, "%s: %s", key,
                     stringJoin("+", group.select(new Function1<Employee, String>() {
                       public String apply(Employee element) {
                         return element.name;
@@ -2285,8 +2287,7 @@ public class Linq4jTest {
         Linq4j.asEnumerable(emps)
             .groupBy(EMP_DEPTNO_SELECTOR, new Function2<Integer, Enumerable<Employee>, String>() {
               public String apply(Integer key, Enumerable<Employee> group) {
-                return String.format("%s: %s",
-                    key,
+                return String.format(Locale.ROOT, "%s: %s", key,
                     stringJoin("+", group.select(new Function1<Employee, String>() {
                       public String apply(Employee element) {
                         return element.name;
@@ -2314,7 +2315,8 @@ public class Linq4jTest {
             .groupBy(EMP_DEPTNO_SELECTOR, EMP_NAME_SELECTOR,
                 new Function2<Integer, Enumerable<String>, String>() {
                   public String apply(Integer key, Enumerable<String> group) {
-                    return String.format("%s: %s", key, stringJoin("+", group));
+                    return String.format(Locale.ROOT, "%s: %s", key,
+                        stringJoin("+", group));
                   }
                 })
             .toList()
@@ -2330,7 +2332,8 @@ public class Linq4jTest {
             .groupBy(EMP_DEPTNO_SELECTOR, EMP_NAME_SELECTOR,
                 new Function2<Integer, Enumerable<String>, String>() {
                   public String apply(Integer key, Enumerable<String> group) {
-                    return String.format("%s: %s", key, stringJoin("+", group));
+                    return String.format(Locale.ROOT, "%s: %s", key,
+                        stringJoin("+", group));
                   }
                 },
                 new EqualityComparer<Integer>() {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/plus/src/main/java/org/apache/calcite/adapter/tpcds/TpcdsSchema.java
----------------------------------------------------------------------
diff --git a/plus/src/main/java/org/apache/calcite/adapter/tpcds/TpcdsSchema.java b/plus/src/main/java/org/apache/calcite/adapter/tpcds/TpcdsSchema.java
index 5f240e3..9a430b2 100644
--- a/plus/src/main/java/org/apache/calcite/adapter/tpcds/TpcdsSchema.java
+++ b/plus/src/main/java/org/apache/calcite/adapter/tpcds/TpcdsSchema.java
@@ -41,6 +41,7 @@ import net.hydromatic.tpcds.TpcdsTable;
 import java.sql.Date;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 /** Schema that provides TPC-DS tables, populated according to a
@@ -88,7 +89,7 @@ public class TpcdsSchema extends AbstractSchema {
     final ImmutableMap.Builder<String, Table> builder = ImmutableMap.builder();
     for (TpcdsTable<?> tpcdsTable : TpcdsTable.getTables()) {
       //noinspection unchecked
-      builder.put(tpcdsTable.getTableName().toUpperCase(),
+      builder.put(tpcdsTable.getTableName().toUpperCase(Locale.ROOT),
           new TpcdsQueryableTable(tpcdsTable));
     }
     this.tableMap = builder.build();
@@ -166,7 +167,7 @@ public class TpcdsSchema extends AbstractSchema {
     public RelDataType getRowType(RelDataTypeFactory typeFactory) {
       final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder();
       for (TpcdsColumn<E> column : tpcdsTable.getColumns()) {
-        builder.add(column.getColumnName().toUpperCase(),
+        builder.add(column.getColumnName().toUpperCase(Locale.ROOT),
             typeFactory.createJavaType(realType(column)));
       }
       return builder.build();

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/plus/src/main/java/org/apache/calcite/adapter/tpch/TpchSchema.java
----------------------------------------------------------------------
diff --git a/plus/src/main/java/org/apache/calcite/adapter/tpch/TpchSchema.java b/plus/src/main/java/org/apache/calcite/adapter/tpch/TpchSchema.java
index 68e1c31..451c344 100644
--- a/plus/src/main/java/org/apache/calcite/adapter/tpch/TpchSchema.java
+++ b/plus/src/main/java/org/apache/calcite/adapter/tpch/TpchSchema.java
@@ -36,6 +36,7 @@ import io.airlift.tpch.TpchTable;
 
 import java.sql.Date;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 /** Schema that provides TPC-H tables, populated according to a
@@ -57,7 +58,7 @@ public class TpchSchema extends AbstractSchema {
 
     final ImmutableMap.Builder<String, Table> builder = ImmutableMap.builder();
     for (TpchTable<?> tpchTable : TpchTable.getTables()) {
-      builder.put(tpchTable.getTableName().toUpperCase(),
+      builder.put(tpchTable.getTableName().toUpperCase(Locale.ROOT),
           new TpchQueryableTable(tpchTable));
     }
     this.tableMap = builder.build();
@@ -140,12 +141,14 @@ public class TpchSchema extends AbstractSchema {
       final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder();
       String prefix = "";
       if (columnPrefix) {
-        prefix = columnPrefixes.get(tpchTable.getTableName().toUpperCase());
-        assert prefix != null : tpchTable.getTableName().toUpperCase();
+        final String t = tpchTable.getTableName().toUpperCase(Locale.ROOT);
+        prefix = columnPrefixes.get(t);
+        assert prefix != null : t;
       }
       for (TpchColumn<E> column : tpchTable.getColumns()) {
-        builder.add((prefix + column.getColumnName()).toUpperCase(),
-            typeFactory.createJavaType(realType(column)));
+        final String c = (prefix + column.getColumnName())
+            .toUpperCase(Locale.ROOT);
+        builder.add(c, typeFactory.createJavaType(realType(column)));
       }
       return builder.build();
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 6cda20f..2340596 100644
--- a/pom.xml
+++ b/pom.xml
@@ -65,6 +65,7 @@ limitations under the License.
     <fmpp-maven-plugin.version>1.0</fmpp-maven-plugin.version>
     <foodmart-data-hsqldb.version>0.3</foodmart-data-hsqldb.version>
     <foodmart-queries.version>0.4.1</foodmart-queries.version>
+    <forbiddenapis.version>2.3</forbiddenapis.version>
     <freemarker.version>2.3.25-incubating</freemarker.version>
     <git-commit-id-plugin.version>2.1.9</git-commit-id-plugin.version>
 
@@ -461,6 +462,43 @@ limitations under the License.
   <build>
     <plugins>
       <plugin>
+        <groupId>de.thetaphi</groupId>
+        <artifactId>forbiddenapis</artifactId>
+        <configuration>
+          <!-- if the used Java version is too new, don't fail, just do nothing: -->
+          <failOnUnsupportedJava>false</failOnUnsupportedJava>
+          <bundledSignatures>
+            <!--
+              This will automatically choose the right
+              signatures based on 'maven.compiler.target':
+            -->
+            <bundledSignature>jdk-unsafe</bundledSignature>
+            <bundledSignature>jdk-deprecated</bundledSignature>
+            <!-- disallow undocumented classes like sun.misc.Unsafe: -->
+            <bundledSignature>jdk-non-portable</bundledSignature>
+          </bundledSignatures>
+          <signaturesFiles>
+            <signaturesFile>${top.dir}/src/main/config/forbidden-apis/signatures.txt</signaturesFile>
+          </signaturesFiles>
+          <excludes>
+            <exclude>**/ParseException.class</exclude>
+            <exclude>**/SimpleCharStream.class</exclude>
+            <exclude>**/*TokenManager.class</exclude>
+            <exclude>**/TokenMgrError.class</exclude>
+            <exclude>**/org/apache/calcite/runtime/Resources$Inst.class</exclude>
+            <exclude>**/org/apache/calcite/util/Unsafe.class</exclude>
+          </excludes>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>check</goal>
+              <goal>testCheck</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
         <groupId>org.apache.rat</groupId>
         <artifactId>apache-rat-plugin</artifactId>
         <configuration>
@@ -674,6 +712,11 @@ limitations under the License.
           </dependencies>
         </plugin>
         <plugin>
+          <groupId>de.thetaphi</groupId>
+          <artifactId>forbiddenapis</artifactId>
+          <version>${forbiddenapis.version}</version>
+        </plugin>
+        <plugin>
           <groupId>net.hydromatic</groupId>
           <artifactId>hydromatic-resource-maven-plugin</artifactId>
           <version>${hydromatic-resource.version}</version>
@@ -749,7 +792,19 @@ limitations under the License.
             <threadCount>1</threadCount>
             <perCoreThreadCount>true</perCoreThreadCount>
             <parallel>both</parallel>
-            <argLine>-Xmx1536m -XX:MaxPermSize=256m -Duser.timezone=${user.timezone}</argLine>
+            <forkMode>once</forkMode>
+            <systemProperties>
+              <systemProperty>
+                <name>user.language</name>
+                <value>TR</value>
+              </systemProperty>
+              <systemProperty>
+                <name>user.country</name>
+                <value>tr</value>
+              </systemProperty>
+            </systemProperties>
+            <!--<argLine>-Xmx1536m -XX:MaxPermSize=256m -Duser.timezone=${user.timezone} -Duser.country=${user.country} -Duser.language=${user.language}</argLine>-->
+            <argLine>-Xmx1536m -XX:MaxPermSize=256m</argLine>
           </configuration>
         </plugin>
         <plugin>

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
----------------------------------------------------------------------
diff --git a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
index b67f096..a580912 100644
--- a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
+++ b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
@@ -23,14 +23,15 @@ import org.apache.calcite.plan.RelOptPlanner;
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.runtime.ArrayBindable;
+import org.apache.calcite.util.Util;
 import org.apache.calcite.util.javac.JaninoCompiler;
 
 import org.apache.spark.api.java.JavaSparkContext;
 
 import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Serializable;
+import java.io.Writer;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.util.Calendar;
@@ -63,7 +64,7 @@ public class SparkHandlerImpl implements CalcitePrepare.SparkHandler {
     // Generate a starting point for class names that is unlikely to clash with
     // previous classes. A better solution would be to clear the class directory
     // on startup.
-    final Calendar calendar = Calendar.getInstance();
+    final Calendar calendar = Util.calendar();
     classId = new AtomicInteger(
         calendar.get(Calendar.HOUR_OF_DAY) * 10000
         + calendar.get(Calendar.MINUTE) * 100
@@ -104,10 +105,9 @@ public class SparkHandlerImpl implements CalcitePrepare.SparkHandler {
   }
 
   public ArrayBindable compile(ClassDeclaration expr, String s) {
-    try {
-      String className = "CalciteProgram" + classId.getAndIncrement();
-      File file = new File(SRC_DIR, className + ".java");
-      FileWriter fileWriter = new FileWriter(file, false);
+    final String className = "CalciteProgram" + classId.getAndIncrement();
+    final File file = new File(SRC_DIR, className + ".java");
+    try (Writer w = Util.printWriter(file)) {
       String source = "public class " + className + "\n"
           + "    implements " + ArrayBindable.class.getName()
           + ", " + Serializable.class.getName()
@@ -119,8 +119,8 @@ public class SparkHandlerImpl implements CalcitePrepare.SparkHandler {
       System.out.println(source);
       System.out.println("======================");
 
-      fileWriter.write(source);
-      fileWriter.close();
+      w.write(source);
+      w.close();
       JaninoCompiler compiler = new JaninoCompiler();
       compiler.getArgs().setDestdir(CLASS_DIR.getAbsolutePath());
       compiler.getArgs().setSource(source, file.getAbsolutePath());

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
----------------------------------------------------------------------
diff --git a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
index 3adfcd9..8b355a2 100644
--- a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
+++ b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
@@ -72,6 +72,7 @@ import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Random;
 
 /**
@@ -445,7 +446,7 @@ public abstract class SparkRules {
                   return Collections.emptyList();
                 }
                 return Collections.singletonList(
-                    Pair.of(x.toUpperCase(), x.length()));
+                    Pair.of(x.toUpperCase(Locale.ROOT), x.length()));
               }
             })
             .take(5)

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
----------------------------------------------------------------------
diff --git a/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java b/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
index aeb4a91..8f08e23 100644
--- a/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
+++ b/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
@@ -19,6 +19,8 @@ package org.apache.calcite.adapter.splunk.search;
 import org.apache.calcite.adapter.splunk.util.StringUtils;
 import org.apache.calcite.linq4j.Enumerator;
 import org.apache.calcite.linq4j.Linq4j;
+import org.apache.calcite.util.Unsafe;
+import org.apache.calcite.util.Util;
 
 import au.com.bytecode.opencsv.CSVReader;
 
@@ -34,10 +36,12 @@ import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -87,7 +91,7 @@ public class SplunkConnectionImpl implements SplunkConnection {
 
     try {
       String loginUrl =
-          String.format(
+          String.format(Locale.ROOT,
               "%s://%s:%d/services/auth/login",
               url.getProtocol(),
               url.getHost(),
@@ -97,12 +101,7 @@ public class SplunkConnectionImpl implements SplunkConnection {
       appendURLEncodedArgs(
           data, "username", username, "password", password);
 
-      rd = new BufferedReader(
-          new InputStreamReader(
-              post(
-                  loginUrl,
-                  data,
-                  requestHeaders)));
+      rd = Util.reader(post(loginUrl, data, requestHeaders));
 
       String line;
       StringBuilder reply = new StringBuilder();
@@ -141,7 +140,7 @@ public class SplunkConnectionImpl implements SplunkConnection {
       List<String> wantedFields,
       SearchResultListener srl) {
     String searchUrl =
-        String.format(
+        String.format(Locale.ROOT,
             "%s://%s:%d/services/search/jobs/export",
             url.getProtocol(),
             url.getHost(),
@@ -182,7 +181,9 @@ public class SplunkConnectionImpl implements SplunkConnection {
   }
 
   private static void parseResults(InputStream in, SearchResultListener srl) {
-    try (CSVReader r = new CSVReader(new InputStreamReader(in))) {
+    try (CSVReader r = new CSVReader(
+        new BufferedReader(
+            new InputStreamReader(in, StandardCharsets.UTF_8)))) {
       String[] header = r.readNext();
       if (header != null
           && header.length > 0
@@ -237,7 +238,7 @@ public class SplunkConnectionImpl implements SplunkConnection {
     for (String s : strings) {
       System.err.println(s);
     }
-    System.exit(1);
+    Unsafe.systemExit(1);
   }
 
   public static void main(String[] args) throws MalformedURLException {
@@ -283,8 +284,7 @@ public class SplunkConnectionImpl implements SplunkConnection {
     long start = System.currentTimeMillis();
     c.getSearchResults(search, searchArgs, null, dummy);
 
-    System.out.printf(
-        "received %d results in %dms\n",
+    System.out.printf(Locale.ROOT, "received %d results in %dms\n",
         dummy.getResultCount(),
         System.currentTimeMillis() - start);
   }
@@ -310,7 +310,8 @@ public class SplunkConnectionImpl implements SplunkConnection {
       resultCount++;
       if (print) {
         for (int i = 0; i < this.fieldNames.length; ++i) {
-          System.out.printf("%s=%s\n", this.fieldNames[i], values[i]);
+          System.out.printf(Locale.ROOT, "%s=%s\n", this.fieldNames[i],
+              values[i]);
         }
         System.out.println();
       }
@@ -346,7 +347,10 @@ public class SplunkConnectionImpl implements SplunkConnection {
     private int source;
 
     public SplunkResultEnumerator(InputStream in, List<String> wantedFields) {
-      csvReader = new CSVReader(new InputStreamReader(in));
+      csvReader =
+          new CSVReader(
+              new BufferedReader(
+                  new InputStreamReader(in, StandardCharsets.UTF_8)));
       try {
         fieldNames = csvReader.readNext();
         if (fieldNames == null

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/src/main/config/forbidden-apis/signatures.txt
----------------------------------------------------------------------
diff --git a/src/main/config/forbidden-apis/signatures.txt b/src/main/config/forbidden-apis/signatures.txt
new file mode 100644
index 0000000..a0eb429
--- /dev/null
+++ b/src/main/config/forbidden-apis/signatures.txt
@@ -0,0 +1,42 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to you under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Signatures of APIs to avoid.
+# Cribbed from Elasticsearch
+
+java.lang.Character#codePointBefore(char[],int) @ Implicit start offset is error-prone when the char[] is a buffer and the first chars are random chars
+java.lang.Character#codePointAt(char[],int) @ Implicit end offset is error-prone when the char[] is a buffer and the last chars are random chars
+
+@defaultMessage Only use wait / notify when really needed try to use concurrency primitives, latches or callbacks instead.
+java.lang.Object#wait()
+java.lang.Object#wait(long)
+java.lang.Object#wait(long,int)
+java.lang.Object#notify()
+java.lang.Object#notifyAll()
+
+@defaultMessage Use StringBuilder; it is more efficient
+java.lang.StringBuffer
+
+@defaultMessage Please do not try to stop the world
+java.lang.System#gc()
+
+@defaultMessage Please do not try to kill the world
+java.lang.System#exit(int)
+java.lang.Runtime#exit(int)
+
+@defaultMessage Don't interrupt threads use FutureUtils#cancel(Future<T>) instead
+java.util.concurrent.Future#cancel(boolean)
+
+# End signatures.txt


[05/10] calcite git commit: [CALCITE-1667] Forbid calls to JDK APIs that use the default locale, time zone or character set

Posted by jh...@apache.org.
[CALCITE-1667] Forbid calls to JDK APIs that use the default locale, time zone or character set

Use the "forbidden-apis" maven plugin to detect calls to such APIs.
Eliminate calls to such APIs.


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/75152c5b
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/75152c5b
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/75152c5b

Branch: refs/heads/master
Commit: 75152c5b7fd62f60c6cdfb86605af8b34a129898
Parents: c90fddf
Author: Julian Hyde <jh...@apache.org>
Authored: Fri Mar 3 00:05:23 2017 -0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Fri Mar 3 11:04:28 2017 -0800

----------------------------------------------------------------------
 core/src/main/codegen/templates/Parser.jj       |  9 ++-
 .../apache/calcite/adapter/jdbc/JdbcSchema.java |  3 +-
 .../config/CalciteConnectionProperty.java       | 28 +++++++++-
 .../apache/calcite/interpreter/Interpreter.java |  3 +-
 .../org/apache/calcite/jdbc/CalciteSchema.java  |  7 ++-
 .../calcite/materialize/TileSuggester.java      |  4 +-
 .../org/apache/calcite/rel/core/Correlate.java  |  2 +-
 .../java/org/apache/calcite/rel/core/Join.java  |  2 +-
 .../apache/calcite/rel/core/JoinRelType.java    |  5 ++
 .../calcite/rel/externalize/RelJsonReader.java  |  4 +-
 .../calcite/rel/rel2sql/RelToSqlConverter.java  |  8 ++-
 .../calcite/rel/rel2sql/SqlImplementor.java     |  3 +-
 .../calcite/rel/rules/DateRangeRules.java       |  4 +-
 .../rel/rules/MultiJoinOptimizeBushyRule.java   |  5 +-
 .../java/org/apache/calcite/rex/RexBuilder.java |  6 +-
 .../org/apache/calcite/runtime/HttpUtils.java   |  8 ++-
 .../apache/calcite/runtime/SqlFunctions.java    |  8 ++-
 .../java/org/apache/calcite/sql/JoinType.java   |  5 ++
 .../org/apache/calcite/sql/SemiJoinType.java    |  5 ++
 .../org/apache/calcite/sql/SqlAccessType.java   |  6 +-
 .../org/apache/calcite/sql/SqlCollation.java    |  3 +-
 .../java/org/apache/calcite/sql/SqlDialect.java |  7 ++-
 .../java/org/apache/calcite/sql/SqlKind.java    |  4 ++
 .../java/org/apache/calcite/sql/SqlUtil.java    | 10 ++--
 .../apache/calcite/sql/advise/SqlAdvisor.java   |  4 +-
 .../calcite/sql/advise/SqlSimpleParser.java     |  3 +-
 .../calcite/sql/parser/SqlParserUtil.java       |  6 +-
 .../calcite/sql/pretty/SqlPrettyWriter.java     | 10 +++-
 .../apache/calcite/sql/type/SqlTypeName.java    |  7 +--
 .../sql/util/ReflectiveSqlOperatorTable.java    |  3 +-
 .../calcite/sql/validate/SqlValidatorImpl.java  |  3 +-
 .../org/apache/calcite/tools/RelBuilder.java    |  3 +-
 .../org/apache/calcite/util/ConversionUtil.java | 11 ++--
 .../java/org/apache/calcite/util/NameMap.java   |  4 +-
 .../org/apache/calcite/util/NameMultimap.java   |  4 +-
 .../java/org/apache/calcite/util/NameSet.java   |  6 +-
 .../java/org/apache/calcite/util/NlsString.java |  3 +-
 .../org/apache/calcite/util/NumberUtil.java     | 16 ++++--
 .../java/org/apache/calcite/util/Sources.java   | 12 +---
 .../java/org/apache/calcite/util/Template.java  |  8 +--
 .../java/org/apache/calcite/util/Unsafe.java    | 54 ++++++++++++++++++
 .../main/java/org/apache/calcite/util/Util.java | 58 +++++++++++++++++++-
 .../apache/calcite/util/ZonelessDatetime.java   |  3 +-
 .../calcite/util/javac/JaninoCompiler.java      |  3 +-
 .../calcite/util/trace/CalciteTimingTracer.java |  4 +-
 .../calcite/jdbc/CalciteRemoteDriverTest.java   | 31 +++++++----
 .../org/apache/calcite/rex/RexExecutorTest.java |  6 +-
 .../calcite/sql/parser/SqlParserTest.java       | 10 ++--
 .../calcite/sql/test/SqlOperatorBaseTest.java   | 12 ++--
 .../sql/validate/SqlValidatorUtilTest.java      | 10 ++--
 .../org/apache/calcite/test/CalciteAssert.java  | 13 +++--
 .../org/apache/calcite/test/DiffRepository.java |  3 +-
 .../org/apache/calcite/test/DiffTestCase.java   | 55 ++++++-------------
 .../java/org/apache/calcite/test/JdbcTest.java  | 15 ++---
 .../org/apache/calcite/test/QuidemTest.java     | 12 ++--
 .../calcite/test/RexImplicationCheckerTest.java |  7 ++-
 .../org/apache/calcite/test/RexProgramTest.java |  3 +-
 .../apache/calcite/test/SqlFunctionsTest.java   |  4 +-
 .../org/apache/calcite/test/SqlLimitsTest.java  |  6 +-
 .../org/apache/calcite/test/SqlLineTest.java    | 13 +++--
 .../org/apache/calcite/test/SqlTestGen.java     |  5 +-
 .../apache/calcite/test/SqlValidatorTest.java   |  4 +-
 .../ConcurrentTestCommandExecutor.java          |  6 +-
 .../concurrent/ConcurrentTestCommandScript.java | 45 +++++++--------
 .../java/org/apache/calcite/util/Smalls.java    | 14 +++--
 .../java/org/apache/calcite/util/UtilTest.java  | 17 +++---
 .../adapter/druid/DruidConnectionImpl.java      | 11 +++-
 .../calcite/adapter/druid/DruidQuery.java       |  2 +-
 .../calcite/adapter/druid/Granularity.java      |  4 +-
 .../elasticsearch/ElasticsearchFilter.java      |  4 +-
 .../calcite/adapter/csv/CsvSchemaFactory.java   |  3 +-
 .../java/org/apache/calcite/test/CsvTest.java   |  3 +-
 .../apache/calcite/example/maze/MazeTable.java  |  3 +-
 .../apache/calcite/adapter/file/FileReader.java |  8 +--
 .../calcite/adapter/file/FileRowConverter.java  | 28 ++++++----
 .../apache/calcite/linq4j/test/Linq4jTest.java  | 33 ++++++-----
 .../calcite/adapter/tpcds/TpcdsSchema.java      |  5 +-
 .../apache/calcite/adapter/tpch/TpchSchema.java | 13 +++--
 pom.xml                                         | 57 ++++++++++++++++++-
 .../calcite/adapter/spark/SparkHandlerImpl.java | 16 +++---
 .../calcite/adapter/spark/SparkRules.java       |  3 +-
 .../splunk/search/SplunkConnectionImpl.java     | 32 ++++++-----
 src/main/config/forbidden-apis/signatures.txt   | 42 ++++++++++++++
 83 files changed, 622 insertions(+), 310 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/codegen/templates/Parser.jj
----------------------------------------------------------------------
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index dcc0558..b070530 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -115,6 +115,7 @@ import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 
 import static org.apache.calcite.util.Static.RESOURCE;
 
@@ -3036,7 +3037,8 @@ SqlSetOption SqlSetOption(SqlParserPos pos, String scope) :
         |
             <ON> {
                 // OFF is handled by SimpleIdentifier, ON handled here.
-                val = new SqlIdentifier(token.image.toUpperCase(), getPos());
+                val = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT),
+                    getPos());
             }
         )
         {
@@ -3050,7 +3052,8 @@ SqlSetOption SqlSetOption(SqlParserPos pos, String scope) :
             name = CompoundIdentifier()
         |
             <ALL> {
-                name = new SqlIdentifier(token.image.toUpperCase(), getPos());
+                name = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT),
+                    getPos());
             }
         )
         {
@@ -3092,7 +3095,7 @@ String Scope() :
 {
 }
 {
-    ( <SYSTEM> | <SESSION> ) { return token.image.toUpperCase(); }
+    ( <SYSTEM> | <SESSION> ) { return token.image.toUpperCase(Locale.ROOT); }
 }
 
 <#if parser.createStatementParserMethods?size != 0>

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
index 5ac3a38..faf0e94 100644
--- a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
+++ b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
@@ -46,6 +46,7 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Collection;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import javax.sql.DataSource;
@@ -210,7 +211,7 @@ public class JdbcSchema implements Schema {
         final String tableTypeName2 =
             tableTypeName == null
             ? null
-            : tableTypeName.toUpperCase().replace(' ', '_');
+            : tableTypeName.toUpperCase(Locale.ROOT).replace(' ', '_');
         final TableType tableType =
             Util.enumVal(TableType.OTHER, tableTypeName2);
         if (tableType == TableType.OTHER  && tableTypeName2 != null) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java b/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
index 86fbb6a..b576aac 100644
--- a/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
+++ b/core/src/main/java/org/apache/calcite/config/CalciteConnectionProperty.java
@@ -21,13 +21,15 @@ import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.avatica.util.Quoting;
 import org.apache.calcite.model.JsonSchema;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
+import org.apache.calcite.util.Bug;
 
 import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 
 import static org.apache.calcite.avatica.ConnectionConfigImpl.PropEnv;
-import static org.apache.calcite.avatica.ConnectionConfigImpl.parse;
 
 /**
  * Properties that may be specified on the JDBC connect string.
@@ -151,7 +153,7 @@ public enum CalciteConnectionProperty implements ConnectionProperty {
   static {
     NAME_TO_PROPS = new HashMap<>();
     for (CalciteConnectionProperty p : CalciteConnectionProperty.values()) {
-      NAME_TO_PROPS.put(p.camelName.toUpperCase(), p);
+      NAME_TO_PROPS.put(p.camelName.toUpperCase(Locale.ROOT), p);
       NAME_TO_PROPS.put(p.name(), p);
     }
   }
@@ -194,7 +196,27 @@ public enum CalciteConnectionProperty implements ConnectionProperty {
   }
 
   public PropEnv wrap(Properties properties) {
-    return new PropEnv(parse(properties, NAME_TO_PROPS), this);
+    return new PropEnv(parse2(properties, NAME_TO_PROPS), this);
+  }
+
+  /** Fixed version of
+   * {@link org.apache.calcite.avatica.ConnectionConfigImpl#parse}
+   * until we upgrade Avatica. */
+  private static Map<ConnectionProperty, String> parse2(Properties properties,
+      Map<String, ? extends ConnectionProperty> nameToProps) {
+    Bug.upgrade("avatica-1.10");
+    final Map<ConnectionProperty, String> map = new LinkedHashMap<>();
+    for (String name : properties.stringPropertyNames()) {
+      final ConnectionProperty connectionProperty =
+          nameToProps.get(name.toUpperCase(Locale.ROOT));
+      if (connectionProperty == null) {
+        // For now, don't throw. It messes up sub-projects.
+        //throw new RuntimeException("Unknown property '" + name + "'");
+        continue;
+      }
+      map.put(connectionProperty, properties.getProperty(name));
+    }
+    return map;
   }
 
 }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java b/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
index 0e154eb..51aa082 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
@@ -49,6 +49,7 @@ import com.google.common.collect.Maps;
 import java.math.BigDecimal;
 import java.util.ArrayDeque;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NoSuchElementException;
 
@@ -211,7 +212,7 @@ public class Interpreter extends AbstractEnumerable<Object[]>
                 if (s0 == null) {
                   return null;
                 }
-                return s0.toUpperCase();
+                return s0.toUpperCase(Locale.ROOT);
               }
               if (call.getOperator() == SqlStdOperatorTable.SUBSTRING) {
                 argScalar.execute(context, args);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/jdbc/CalciteSchema.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteSchema.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteSchema.java
index cb61627..4b1bc02 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteSchema.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteSchema.java
@@ -40,6 +40,7 @@ import com.google.common.collect.Lists;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NavigableMap;
 import java.util.NavigableSet;
@@ -347,14 +348,16 @@ public abstract class CalciteSchema {
   protected static <V> NavigableMap<String, V> find(NavigableMap<String, V> map,
       String s) {
     assert map.comparator() == NameSet.COMPARATOR;
-    return map.subMap(s.toUpperCase(), true, s.toLowerCase(), true);
+    return map.subMap(s.toUpperCase(Locale.ROOT), true,
+        s.toLowerCase(Locale.ROOT), true);
   }
 
   /** Returns a subset of a set whose values match the given string
    * case-insensitively. */
   protected static Iterable<String> find(NavigableSet<String> set, String name) {
     assert set.comparator() == NameSet.COMPARATOR;
-    return set.subSet(name.toUpperCase(), true, name.toLowerCase(), true);
+    return set.subSet(name.toUpperCase(Locale.ROOT), true,
+        name.toLowerCase(Locale.ROOT), true);
   }
 
   /** Creates a root schema.

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/materialize/TileSuggester.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/materialize/TileSuggester.java b/core/src/main/java/org/apache/calcite/materialize/TileSuggester.java
index 29b54b9..e94781d 100644
--- a/core/src/main/java/org/apache/calcite/materialize/TileSuggester.java
+++ b/core/src/main/java/org/apache/calcite/materialize/TileSuggester.java
@@ -16,6 +16,8 @@
  */
 package org.apache.calcite.materialize;
 
+import org.apache.calcite.util.Util;
+
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -59,7 +61,7 @@ public class TileSuggester {
 
   public Iterable<? extends Lattice.Tile> tiles() {
     final Algorithm algorithm = new MonteCarloAlgorithm();
-    final PrintWriter pw = new PrintWriter(System.out);
+    final PrintWriter pw = Util.printWriter(System.out);
     final Progress progress = new ArgumentUtils.TextProgress(pw);
     final StatisticsProvider statisticsProvider =
         new StatisticsProviderImpl(lattice);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/core/Correlate.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Correlate.java b/core/src/main/java/org/apache/calcite/rel/core/Correlate.java
index 1af9f80..6f218b1 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Correlate.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Correlate.java
@@ -156,7 +156,7 @@ public abstract class Correlate extends BiRel {
   @Override public RelWriter explainTerms(RelWriter pw) {
     return super.explainTerms(pw)
         .item("correlation", correlationId)
-        .item("joinType", joinType.name().toLowerCase())
+        .item("joinType", joinType.lowerName)
         .item("requiredColumns", requiredColumns.toString());
   }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/core/Join.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Join.java b/core/src/main/java/org/apache/calcite/rel/core/Join.java
index 2952fd1..a9e0441 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Join.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Join.java
@@ -204,7 +204,7 @@ public abstract class Join extends BiRel {
   @Override public RelWriter explainTerms(RelWriter pw) {
     return super.explainTerms(pw)
         .item("condition", condition)
-        .item("joinType", joinType.name().toLowerCase())
+        .item("joinType", joinType.lowerName)
         .itemIf(
             "systemFields",
             getSystemFieldList(),

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/core/JoinRelType.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/core/JoinRelType.java b/core/src/main/java/org/apache/calcite/rel/core/JoinRelType.java
index 677021e..5d75742 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/JoinRelType.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/JoinRelType.java
@@ -16,12 +16,17 @@
  */
 package org.apache.calcite.rel.core;
 
+import java.util.Locale;
+
 /**
  * Enumeration of join types.
  */
 public enum JoinRelType {
   INNER, LEFT, RIGHT, FULL;
 
+  /** Lower-case name. */
+  public final String lowerName = name().toLowerCase(Locale.ROOT);
+
   /**
    * Returns whether a join of this type may generate NULL values on the
    * right-hand side.

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
index 57a7f76..a3d6dd4 100644
--- a/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
+++ b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
@@ -46,6 +46,7 @@ import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -188,7 +189,8 @@ public class RelJsonReader {
       }
 
       public <E extends Enum<E>> E getEnum(String tag, Class<E> enumClass) {
-        return Util.enumVal(enumClass, getString(tag).toUpperCase());
+        return Util.enumVal(enumClass,
+            getString(tag).toUpperCase(Locale.ROOT));
       }
 
       public List<RexNode> getExpressionList(String tag) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
index c2fe284..96cfac7 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
@@ -65,6 +65,7 @@ import com.google.common.collect.Lists;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -358,9 +359,10 @@ public class RelToSqlConverter extends SqlImplementor
       RelDataType rowType) {
     String name = rowType.getFieldNames().get(selectList.size());
     String alias = SqlValidatorUtil.getAlias(node, -1);
-    if (name.toLowerCase().startsWith("expr$")) {
-      //Put it in ordinalMap
-      ordinalMap.put(name.toLowerCase(), node);
+    final String lowerName = name.toLowerCase(Locale.ROOT);
+    if (lowerName.startsWith("expr$")) {
+      // Put it in ordinalMap
+      ordinalMap.put(lowerName, node);
     } else if (alias == null || !alias.equals(name)) {
       node = SqlStdOperatorTable.AS.createCall(
           POS, node, new SqlIdentifier(name, POS));

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
index 206716b..3c92f29 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/SqlImplementor.java
@@ -84,6 +84,7 @@ import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
@@ -831,7 +832,7 @@ public abstract class SqlImplementor {
         if (ordinal < fields.size()) {
           RelDataTypeField field = fields.get(ordinal);
           final SqlNode mappedSqlNode =
-              ordinalMap.get(field.getName().toLowerCase());
+              ordinalMap.get(field.getName().toLowerCase(Locale.ROOT));
           if (mappedSqlNode != null) {
             return mappedSqlNode;
           }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
index a052140..3102f42 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
@@ -16,7 +16,6 @@
  */
 package org.apache.calcite.rel.rules;
 
-import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
@@ -36,6 +35,7 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RelBuilderFactory;
 import org.apache.calcite.util.Bug;
+import org.apache.calcite.util.Util;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.BoundType;
@@ -290,7 +290,7 @@ public abstract class DateRangeRules {
         final Calendar c;
         switch (timeUnit) {
         case YEAR:
-          c = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+          c = Util.calendar();
           c.clear();
           c.set(v, Calendar.JANUARY, 1);
           s2.add(baz(timeUnit, comparison, c));

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java b/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
index b63e3a4..790aed7 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/MultiJoinOptimizeBushyRule.java
@@ -69,8 +69,9 @@ public class MultiJoinOptimizeBushyRule extends RelOptRule {
   public static final MultiJoinOptimizeBushyRule INSTANCE =
       new MultiJoinOptimizeBushyRule(RelFactories.LOGICAL_BUILDER);
 
-  private final PrintWriter pw =
-      CalcitePrepareImpl.DEBUG ? new PrintWriter(System.out, true) : null;
+  private final PrintWriter pw = CalcitePrepareImpl.DEBUG
+      ? Util.printWriter(System.out)
+      : null;
 
   /** Creates an MultiJoinOptimizeBushyRule. */
   public MultiJoinOptimizeBushyRule(RelBuilderFactory relBuilderFactory) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
index 3e34ec9..2a4667c 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
@@ -1402,14 +1402,14 @@ public class RexBuilder {
       if (o instanceof Calendar) {
         return o;
       }
-      calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      calendar = Util.calendar();
       calendar.setTimeInMillis((Integer) o);
       return calendar;
     case DATE:
       if (o instanceof Calendar) {
         return o;
       }
-      calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      calendar = Util.calendar();
       calendar.setTimeInMillis(0);
       calendar.add(Calendar.DAY_OF_YEAR, (Integer) o);
       return calendar;
@@ -1417,7 +1417,7 @@ public class RexBuilder {
       if (o instanceof Calendar) {
         return o;
       }
-      calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      calendar = Util.calendar();
       calendar.setTimeInMillis((Long) o);
       return calendar;
     default:

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java b/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
index 50deeef..bc790d6 100644
--- a/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
+++ b/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
@@ -25,6 +25,7 @@ import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.HttpsURLConnection;
@@ -67,8 +68,8 @@ public class HttpUtils {
         if (i++ != 0) {
           out.append("&");
         }
-        out.append(URLEncoder.encode(me.getKey(), "UTF-8"));
-        out.append("=")
+        out.append(URLEncoder.encode(me.getKey(), "UTF-8"))
+            .append("=")
             .append(URLEncoder.encode(me.getValue(), "UTF-8"));
       }
     } catch (UnsupportedEncodingException ignore) {
@@ -136,7 +137,8 @@ public class HttpUtils {
       return conn.getInputStream();
     }
     conn.setDoOutput(true);
-    try (Writer w = new OutputStreamWriter(conn.getOutputStream())) {
+    try (Writer w = new OutputStreamWriter(conn.getOutputStream(),
+        StandardCharsets.UTF_8)) {
       w.write(data.toString());
       w.flush(); // Get the response
       return conn.getInputStream();

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index 634067c..baa2c6f 100644
--- a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -32,6 +32,7 @@ import org.apache.calcite.linq4j.function.NonDeterministic;
 import org.apache.calcite.linq4j.tree.Primitive;
 import org.apache.calcite.runtime.FlatLists.ComparableList;
 import org.apache.calcite.util.Bug;
+import org.apache.calcite.util.NumberUtil;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -45,6 +46,7 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.TimeZone;
@@ -66,7 +68,7 @@ import java.util.regex.Pattern;
 @Deterministic
 public class SqlFunctions {
   private static final DecimalFormat DOUBLE_FORMAT =
-      new DecimalFormat("0.0E0");
+      NumberUtil.decimalFormat("0.0E0");
 
   private static final TimeZone LOCAL_TZ = TimeZone.getDefault();
 
@@ -138,12 +140,12 @@ public class SqlFunctions {
 
   /** SQL UPPER(string) function. */
   public static String upper(String s) {
-    return s.toUpperCase();
+    return s.toUpperCase(Locale.ROOT);
   }
 
   /** SQL LOWER(string) function. */
   public static String lower(String s) {
-    return s.toLowerCase();
+    return s.toLowerCase(Locale.ROOT);
   }
 
   /** SQL INITCAP(string) function. */

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/JoinType.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/JoinType.java b/core/src/main/java/org/apache/calcite/sql/JoinType.java
index 0e4cc05..4759324 100644
--- a/core/src/main/java/org/apache/calcite/sql/JoinType.java
+++ b/core/src/main/java/org/apache/calcite/sql/JoinType.java
@@ -18,6 +18,8 @@ package org.apache.calcite.sql;
 
 import org.apache.calcite.sql.parser.SqlParserPos;
 
+import java.util.Locale;
+
 /**
  * Enumerates the types of join.
  */
@@ -54,6 +56,9 @@ public enum JoinType {
    */
   COMMA;
 
+  /** Lower-case name. */
+  public final String lowerName = name().toLowerCase(Locale.ROOT);
+
   /**
    * Creates a parse-tree node representing an occurrence of this
    * condition type keyword at a particular position in the parsed

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/SemiJoinType.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SemiJoinType.java b/core/src/main/java/org/apache/calcite/sql/SemiJoinType.java
index 38cabba..473e812 100644
--- a/core/src/main/java/org/apache/calcite/sql/SemiJoinType.java
+++ b/core/src/main/java/org/apache/calcite/sql/SemiJoinType.java
@@ -20,6 +20,8 @@ import org.apache.calcite.linq4j.CorrelateJoinType;
 import org.apache.calcite.rel.core.JoinRelType;
 import org.apache.calcite.sql.parser.SqlParserPos;
 
+import java.util.Locale;
+
 /**
  * Enumeration representing different join types used in correlation
  * relations.
@@ -48,6 +50,9 @@ public enum SemiJoinType {
    */
   ANTI;
 
+  /** Lower-case name. */
+  public final String lowerName = name().toLowerCase(Locale.ROOT);
+
   /**
    * Creates a parse-tree node representing an occurrence of this
    * condition type keyword at a particular position in the parsed

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/SqlAccessType.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlAccessType.java b/core/src/main/java/org/apache/calcite/sql/SqlAccessType.java
index 5da1b56..5efab84 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlAccessType.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlAccessType.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.sql;
 
 import java.util.EnumSet;
+import java.util.Locale;
 
 /**
  * SqlAccessType is represented by a set of allowed access types
@@ -54,10 +55,9 @@ public class SqlAccessType {
   public static SqlAccessType create(String[] accessNames) {
     assert accessNames != null;
     EnumSet<SqlAccessEnum> enumSet = EnumSet.noneOf(SqlAccessEnum.class);
-    for (int i = 0; i < accessNames.length; i++) {
+    for (String accessName : accessNames) {
       enumSet.add(
-          SqlAccessEnum.valueOf(
-              accessNames[i].trim().toUpperCase()));
+          SqlAccessEnum.valueOf(accessName.trim().toUpperCase(Locale.ROOT)));
     }
     return new SqlAccessType(enumSet);
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/SqlCollation.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlCollation.java b/core/src/main/java/org/apache/calcite/sql/SqlCollation.java
index 66fd7ac..a3ac712 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlCollation.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlCollation.java
@@ -88,7 +88,8 @@ public class SqlCollation implements Serializable {
     this.wrappedCharset = SerializableCharset.forCharset(charset);
     locale = parseValues.getLocale();
     strength = parseValues.getStrength();
-    String c = charset.name().toUpperCase() + "$" + locale.toString();
+    String c =
+        charset.name().toUpperCase(Locale.ROOT) + "$" + locale.toString();
     if ((strength != null) && (strength.length() > 0)) {
       c += "$" + strength;
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
index d3ea0f7..3f9e6b0 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
@@ -27,6 +27,7 @@ import java.sql.SQLException;
 import java.sql.Timestamp;
 import java.text.SimpleDateFormat;
 import java.util.List;
+import java.util.Locale;
 import java.util.regex.Pattern;
 
 /**
@@ -183,7 +184,8 @@ public class SqlDialect {
   public static DatabaseProduct getProduct(
       String productName,
       String productVersion) {
-    final String upperProductName = productName.toUpperCase().trim();
+    final String upperProductName =
+        productName.toUpperCase(Locale.ROOT).trim();
     switch (upperProductName) {
     case "ACCESS":
       return DatabaseProduct.ACCESS;
@@ -470,7 +472,8 @@ public class SqlDialect {
   public String quoteTimestampLiteral(Timestamp timestamp) {
     final SimpleDateFormat format =
         new SimpleDateFormat(
-            "'TIMESTAMP' ''yyyy-MM-DD HH:mm:SS''");
+            "'TIMESTAMP' ''yyyy-MM-DD HH:mm:SS''",
+            Locale.ROOT);
     format.setTimeZone(DateTimeUtils.GMT_ZONE);
     return format.format(timestamp);
   }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlKind.java b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
index e3cff7c..8dbb55ef 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlKind.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
@@ -18,6 +18,7 @@ package org.apache.calcite.sql;
 
 import java.util.Collection;
 import java.util.EnumSet;
+import java.util.Locale;
 import java.util.Set;
 
 /**
@@ -1006,6 +1007,9 @@ public enum SqlKind {
           LESS_THAN, GREATER_THAN,
           GREATER_THAN_OR_EQUAL, LESS_THAN_OR_EQUAL);
 
+  /** Lower-case name. */
+  public final String lowerName = name().toLowerCase(Locale.ROOT);
+
   /** Returns the kind that corresponds to this operator but in the opposite
    * direction. Or returns this, if this kind is not reversible.
    *

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUtil.java b/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
index 71e79c7..98e7f0e 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
@@ -54,6 +54,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 import static org.apache.calcite.util.Static.RESOURCE;
@@ -743,8 +744,8 @@ public abstract class SqlUtil {
         if (i > 0) {
           ret.append(", ");
         }
-        ret.append("<").append(
-            typeList.get(i).toString().toUpperCase()).append(">");
+        final String t = typeList.get(i).toString().toUpperCase(Locale.ROOT);
+        ret.append("<").append(t).append(">");
       }
       ret.append(")'");
     } else {
@@ -752,9 +753,10 @@ public abstract class SqlUtil {
       values[0] = opName;
       ret.append("'");
       for (int i = 0; i < typeList.size(); i++) {
-        values[i + 1] = "<" + typeList.get(i).toString().toUpperCase() + ">";
+        final String t = typeList.get(i).toString().toUpperCase(Locale.ROOT);
+        values[i + 1] = "<" + t + ">";
       }
-      ret.append(MessageFormat.format(template, values));
+      ret.append(new MessageFormat(template, Locale.ROOT).format(values));
       ret.append("'");
       assert (typeList.size() + 1) == values.length;
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
index 1b2481e..0216cc3 100644
--- a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
+++ b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
@@ -44,6 +44,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * An assistant which offers hints and corrections to a partially-formed SQL
@@ -54,7 +55,8 @@ public class SqlAdvisor {
 
   public static final Logger LOGGER = CalciteTrace.PARSER_LOGGER;
   private static final String HINT_TOKEN = "_suggest_";
-  private static final String UPPER_HINT_TOKEN = HINT_TOKEN.toUpperCase();
+  private static final String UPPER_HINT_TOKEN =
+      HINT_TOKEN.toUpperCase(Locale.ROOT);
 
   //~ Instance fields --------------------------------------------------------
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/advise/SqlSimpleParser.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/advise/SqlSimpleParser.java b/core/src/main/java/org/apache/calcite/sql/advise/SqlSimpleParser.java
index 85dfa10..f9a0d31 100644
--- a/core/src/main/java/org/apache/calcite/sql/advise/SqlSimpleParser.java
+++ b/core/src/main/java/org/apache/calcite/sql/advise/SqlSimpleParser.java
@@ -21,6 +21,7 @@ import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.List;
 import java.util.ListIterator;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -379,7 +380,7 @@ public class SqlSimpleParser {
               }
             }
             String name = sql.substring(start, pos);
-            TokenType tokenType = map.get(name.toUpperCase());
+            TokenType tokenType = map.get(name.toUpperCase(Locale.ROOT));
             if (tokenType == null) {
               return new IdToken(TokenType.ID, name);
             } else {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
index 228b5f7..d4b7237 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
@@ -135,7 +135,7 @@ public final class SqlParserUtil {
    * @param pattern {@link SimpleDateFormat}  pattern
    */
   public static void checkDateFormat(String pattern) {
-    SimpleDateFormat df = new SimpleDateFormat(pattern);
+    SimpleDateFormat df = new SimpleDateFormat(pattern, Locale.ROOT);
     Util.discard(df);
   }
 
@@ -279,9 +279,9 @@ public final class SqlParserUtil {
     }
     switch (casing) {
     case TO_UPPER:
-      return s.toUpperCase();
+      return s.toUpperCase(Locale.ROOT);
     case TO_LOWER:
-      return s.toLowerCase();
+      return s.toLowerCase(Locale.ROOT);
     default:
       return s;
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java b/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
index c2b206a..ec78b04 100644
--- a/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
+++ b/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
@@ -22,6 +22,7 @@ import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.util.SqlBuilder;
 import org.apache.calcite.sql.util.SqlString;
+import org.apache.calcite.util.Unsafe;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.trace.CalciteLogger;
 
@@ -37,6 +38,7 @@ import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Properties;
@@ -275,7 +277,7 @@ public class SqlPrettyWriter implements SqlWriter {
 
   public void reset() {
     pw.flush();
-    sw.getBuffer().setLength(0);
+    Unsafe.clear(sw);
     setNeedWhitespace(false);
     nextWhitespace = " ";
   }
@@ -821,7 +823,9 @@ public class SqlPrettyWriter implements SqlWriter {
   public void keyword(String s) {
     maybeWhitespace(s);
     pw.print(
-        isKeywordsLowerCase() ? s.toLowerCase() : s.toUpperCase());
+        isKeywordsLowerCase()
+            ? s.toLowerCase(Locale.ROOT)
+            : s.toUpperCase(Locale.ROOT));
     charCount += s.length();
     if (!s.equals("")) {
       setNeedWhitespace(needWhitespaceAfter(s));
@@ -1148,7 +1152,7 @@ public class SqlPrettyWriter implements SqlWriter {
     }
 
     private String stripPrefix(String name, int offset) {
-      return name.substring(offset, offset + 1).toLowerCase()
+      return name.substring(offset, offset + 1).toLowerCase(Locale.ROOT)
           + name.substring(offset + 1);
     }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
index f55f9b9..f34ea11 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
@@ -16,7 +16,6 @@
  */
 package org.apache.calcite.sql.type;
 
-import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.parser.SqlParserPos;
@@ -591,7 +590,7 @@ public enum SqlTypeName {
       return bytes;
 
     case DATE:
-      calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      calendar = Util.calendar();
       switch (limit) {
       case ZERO:
 
@@ -639,7 +638,7 @@ public enum SqlTypeName {
       if (beyond) {
         return null; // invalid values are impossible to represent
       }
-      calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      calendar = Util.calendar();
       switch (limit) {
       case ZERO:
 
@@ -664,7 +663,7 @@ public enum SqlTypeName {
       return calendar;
 
     case TIMESTAMP:
-      calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+      calendar = Util.calendar();
       switch (limit) {
       case ZERO:
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/util/ReflectiveSqlOperatorTable.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/util/ReflectiveSqlOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/util/ReflectiveSqlOperatorTable.java
index a9d2ae1..0812b24 100644
--- a/core/src/main/java/org/apache/calcite/sql/util/ReflectiveSqlOperatorTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/util/ReflectiveSqlOperatorTable.java
@@ -32,6 +32,7 @@ import com.google.common.collect.Multimap;
 import java.lang.reflect.Field;
 import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * ReflectiveSqlOperatorTable implements the {@link SqlOperatorTable} interface
@@ -145,7 +146,7 @@ public abstract class ReflectiveSqlOperatorTable implements SqlOperatorTable {
    * store case-insensitively, even in a case-sensitive session. */
   private static class Key extends Pair<String, SqlSyntax> {
     Key(String name, SqlSyntax syntax) {
-      super(name.toUpperCase(), normalize(syntax));
+      super(name.toUpperCase(Locale.ROOT), normalize(syntax));
     }
 
     private static SqlSyntax normalize(SqlSyntax syntax) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index d270f57..eb2ea3b 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -111,6 +111,7 @@ import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
@@ -3073,7 +3074,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
       names = Lists.transform(names,
           new Function<String, String>() {
             public String apply(String s) {
-              return s.toUpperCase();
+              return s.toUpperCase(Locale.ROOT);
             }
           });
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
index a0846c8..ddc0c43 100644
--- a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
+++ b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
@@ -87,6 +87,7 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Locale;
 import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
@@ -431,7 +432,7 @@ public class RelBuilder {
           return field(inputCount, inputCount - 1 - inputOrdinal, p.i);
         }
         fields.add(
-            String.format("{aliases=%s,fieldName=%s}", p.e.left,
+            String.format(Locale.ROOT, "{aliases=%s,fieldName=%s}", p.e.left,
                 p.e.right.getName()));
       }
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/ConversionUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/ConversionUtil.java b/core/src/main/java/org/apache/calcite/util/ConversionUtil.java
index 193cc7c..29a2614 100644
--- a/core/src/main/java/org/apache/calcite/util/ConversionUtil.java
+++ b/core/src/main/java/org/apache/calcite/util/ConversionUtil.java
@@ -18,6 +18,7 @@ package org.apache.calcite.util;
 
 import java.nio.ByteOrder;
 import java.text.NumberFormat;
+import java.util.Locale;
 
 import static org.apache.calcite.util.Static.RESOURCE;
 
@@ -68,14 +69,12 @@ public class ConversionUtil {
     }
 
     int trick = radix * radix;
-    StringBuffer ret = new StringBuffer();
-    for (int i = 0; i < value.length; i++) {
-      ret.append(
-          Integer.toString(trick | (0x0ff & value[i]), radix).substring(
-              1));
+    StringBuilder ret = new StringBuilder();
+    for (byte b : value) {
+      ret.append(Integer.toString(trick | (0x0ff & b), radix).substring(1));
     }
 
-    return ret.toString().toUpperCase();
+    return ret.toString().toUpperCase(Locale.ROOT);
   }
 
   /**

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/NameMap.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/NameMap.java b/core/src/main/java/org/apache/calcite/util/NameMap.java
index a0c69bc..19a5507 100644
--- a/core/src/main/java/org/apache/calcite/util/NameMap.java
+++ b/core/src/main/java/org/apache/calcite/util/NameMap.java
@@ -18,6 +18,7 @@ package org.apache.calcite.util;
 
 import com.google.common.collect.ImmutableSortedMap;
 
+import java.util.Locale;
 import java.util.Map;
 import java.util.NavigableMap;
 import java.util.TreeMap;
@@ -62,7 +63,8 @@ public class NameMap<V> {
         return ImmutableSortedMap.of();
       }
     } else {
-      return map.subMap(name.toUpperCase(), true, name.toLowerCase(), true);
+      return map.subMap(name.toUpperCase(Locale.ROOT), true,
+          name.toLowerCase(Locale.ROOT), true);
     }
   }
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/NameMultimap.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/NameMultimap.java b/core/src/main/java/org/apache/calcite/util/NameMultimap.java
index 1b3734a..4d42a29 100644
--- a/core/src/main/java/org/apache/calcite/util/NameMultimap.java
+++ b/core/src/main/java/org/apache/calcite/util/NameMultimap.java
@@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.NavigableMap;
 import java.util.TreeMap;
@@ -75,7 +76,8 @@ public class NameMultimap<V> {
       final ImmutableList.Builder<Map.Entry<String, V>> builder =
           ImmutableList.builder();
       NavigableMap<String, List<V>> m =
-          map.subMap(name.toUpperCase(), true, name.toLowerCase(), true);
+          map.subMap(name.toUpperCase(Locale.ROOT), true,
+              name.toLowerCase(Locale.ROOT), true);
       for (Map.Entry<String, List<V>> entry : m.entrySet()) {
         for (V v : entry.getValue()) {
           builder.add(Pair.of(entry.getKey(), v));

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/NameSet.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/NameSet.java b/core/src/main/java/org/apache/calcite/util/NameSet.java
index ccdd5d5..a51f949 100644
--- a/core/src/main/java/org/apache/calcite/util/NameSet.java
+++ b/core/src/main/java/org/apache/calcite/util/NameSet.java
@@ -22,6 +22,7 @@ import com.google.common.collect.ImmutableSortedSet;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.Locale;
 import java.util.NavigableSet;
 import java.util.Set;
 import java.util.TreeSet;
@@ -77,7 +78,8 @@ public class NameSet {
         return ImmutableList.of();
       }
     } else {
-      return names.subSet(name.toUpperCase(), true, name.toLowerCase(), true);
+      return names.subSet(name.toUpperCase(Locale.ROOT), true,
+          name.toLowerCase(Locale.ROOT), true);
     }
   }
 
@@ -88,7 +90,7 @@ public class NameSet {
       return true;
     }
     if (!caseSensitive) {
-      final String s = names.ceiling(name.toLowerCase());
+      final String s = names.ceiling(name.toLowerCase(Locale.ROOT));
       return s != null
           && s.equalsIgnoreCase(name);
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/NlsString.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/NlsString.java b/core/src/main/java/org/apache/calcite/util/NlsString.java
index aa68eec..eee7884 100644
--- a/core/src/main/java/org/apache/calcite/util/NlsString.java
+++ b/core/src/main/java/org/apache/calcite/util/NlsString.java
@@ -27,6 +27,7 @@ import java.nio.charset.CharsetEncoder;
 import java.nio.charset.IllegalCharsetNameException;
 import java.nio.charset.UnsupportedCharsetException;
 import java.util.List;
+import java.util.Locale;
 import java.util.Objects;
 
 import static org.apache.calcite.util.Static.RESOURCE;
@@ -63,7 +64,7 @@ public class NlsString implements Comparable<NlsString> {
       SqlCollation collation) {
     assert value != null;
     if (null != charsetName) {
-      charsetName = charsetName.toUpperCase();
+      charsetName = charsetName.toUpperCase(Locale.ROOT);
       this.charsetName = charsetName;
       String javaCharsetName =
           SqlUtil.translateCharacterSetName(charsetName);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/NumberUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/NumberUtil.java b/core/src/main/java/org/apache/calcite/util/NumberUtil.java
index a33b416..d0e2d84 100644
--- a/core/src/main/java/org/apache/calcite/util/NumberUtil.java
+++ b/core/src/main/java/org/apache/calcite/util/NumberUtil.java
@@ -20,10 +20,12 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.math.RoundingMode;
 import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
 import java.text.NumberFormat;
+import java.util.Locale;
 
 /**
- * Utility functions for working with numbers This class is JDK 1.4 compatible.
+ * Utility functions for working with numbers.
  */
 public class NumberUtil {
   private NumberUtil() {}
@@ -39,12 +41,10 @@ public class NumberUtil {
   static {
     // TODO: DecimalFormat uses ROUND_HALF_EVEN, not ROUND_HALF_UP
     // Float: precision of 7 (6 digits after .)
-    FLOAT_FORMATTER = new DecimalFormat();
-    FLOAT_FORMATTER.applyPattern("0.######E0");
+    FLOAT_FORMATTER = decimalFormat("0.######E0");
 
     // Double: precision of 16 (15 digits after .)
-    DOUBLE_FORMATTER = new DecimalFormat();
-    DOUBLE_FORMATTER.applyPattern("0.###############E0");
+    DOUBLE_FORMATTER = decimalFormat("0.###############E0");
 
     BIG_INT_TEN_POW = new BigInteger[20];
     BIG_INT_MIN_UNSCALED = new BigInteger[20];
@@ -64,6 +64,12 @@ public class NumberUtil {
 
   //~ Methods ----------------------------------------------------------------
 
+  /** Creates a format. Locale-independent. */
+  public static DecimalFormat decimalFormat(String pattern) {
+    return new DecimalFormat(pattern,
+        DecimalFormatSymbols.getInstance(Locale.ROOT));
+  }
+
   public static BigInteger powTen(int exponent) {
     if ((exponent >= 0) && (exponent < BIG_INT_TEN_POW.length)) {
       return BIG_INT_TEN_POW[exponent];

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/Sources.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/Sources.java b/core/src/main/java/org/apache/calcite/util/Sources.java
index 946102f..01a864a 100644
--- a/core/src/main/java/org/apache/calcite/util/Sources.java
+++ b/core/src/main/java/org/apache/calcite/util/Sources.java
@@ -20,13 +20,13 @@ import com.google.common.base.Preconditions;
 
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.zip.GZIPInputStream;
 
 /**
@@ -57,11 +57,6 @@ public abstract class Sources {
     }
   }
 
-  private static String trim(String s, String suffix) {
-    String trimmed = trimOrNull(s, suffix);
-    return trimmed != null ? trimmed : s;
-  }
-
   /** Looks for a suffix on a path and returns
    * either the path with the suffix removed
    * or null. */
@@ -126,12 +121,9 @@ public abstract class Sources {
         final InputStream fis = openStream();
         is = new GZIPInputStream(fis);
       } else {
-        if (file != null) {
-          return new FileReader(file);
-        }
         is = openStream();
       }
-      return new InputStreamReader(is);
+      return new InputStreamReader(is, StandardCharsets.UTF_8);
     }
 
     public InputStream openStream() throws IOException {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/Template.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/Template.java b/core/src/main/java/org/apache/calcite/util/Template.java
index 1936f8e..88d268a 100644
--- a/core/src/main/java/org/apache/calcite/util/Template.java
+++ b/core/src/main/java/org/apache/calcite/util/Template.java
@@ -86,7 +86,7 @@ public class Template extends MessageFormat {
    * @throws IllegalArgumentException if the pattern is invalid
    */
   public static Template of(String pattern, Locale locale) {
-    final List<String> parameterNames = new ArrayList<String>();
+    final List<String> parameterNames = new ArrayList<>();
     final String processedPattern = process(pattern, parameterNames);
     return new Template(processedPattern, parameterNames, locale);
   }
@@ -110,9 +110,9 @@ public class Template extends MessageFormat {
    * @return Pattern with named parameters substituted with ordinals
    */
   private static String process(String pattern, List<String> parameterNames) {
-    StringBuffer[] segments = new StringBuffer[4];
+    StringBuilder[] segments = new StringBuilder[4];
     for (int i = 0; i < segments.length; ++i) {
-      segments[i] = new StringBuffer();
+      segments[i] = new StringBuilder();
     }
     int part = 0;
     boolean inQuote = false;
@@ -184,7 +184,7 @@ public class Template extends MessageFormat {
    * @param parameterNames List of parameter names seen so far
    */
   private static void makeFormat(
-      StringBuffer[] segments,
+      StringBuilder[] segments,
       List<String> parameterNames) {
     final String parameterName = segments[1].toString();
     final int parameterOrdinal = parameterNames.size();

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/Unsafe.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/Unsafe.java b/core/src/main/java/org/apache/calcite/util/Unsafe.java
new file mode 100644
index 0000000..61805ab
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/Unsafe.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util;
+
+import java.io.StringWriter;
+
+/**
+ * Contains methods that call JDK methods that the
+ * <a href="https://github.com/policeman-tools/forbidden-apis">forbidden
+ * APIs checker</a> does not approve of.
+ *
+ * <p>This class is excluded from the check, so methods called via this class
+ * will not fail the build.
+ */
+public class Unsafe {
+  private Unsafe() {}
+
+  /** Calls {@link System#exit}. */
+  public static void systemExit(int status) {
+    System.exit(status);
+  }
+
+  /** Calls {@link Object#notifyAll()}. */
+  public static void notifyAll(Object o) {
+    o.notifyAll();
+  }
+
+  /** Calls {@link Object#wait()}. */
+  public static void wait(Object o) throws InterruptedException {
+    o.wait();
+  }
+
+  /** Clears the contents of a {@link StringWriter}. */
+  public static void clear(StringWriter sw) {
+    // Included in this class because StringBuffer is banned.
+    sw.getBuffer().setLength(0);
+  }
+}
+
+// End Unsafe.java

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/Util.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/Util.java b/core/src/main/java/org/apache/calcite/util/Util.java
index 8d85ad9..24d9ab5 100644
--- a/core/src/main/java/org/apache/calcite/util/Util.java
+++ b/core/src/main/java/org/apache/calcite/util/Util.java
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.util;
 
+import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.avatica.util.Spaces;
 import org.apache.calcite.linq4j.Ord;
 import org.apache.calcite.runtime.CalciteException;
@@ -43,10 +44,16 @@ import org.slf4j.Logger;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
+import java.io.BufferedWriter;
 import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.io.OutputStream;
+import java.io.OutputStreamWriter;
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.io.Reader;
@@ -60,6 +67,7 @@ import java.math.BigDecimal;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
@@ -70,6 +78,7 @@ import java.util.AbstractMap;
 import java.util.AbstractSet;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Calendar;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HashMap;
@@ -619,7 +628,8 @@ public class Util {
    */
   @Deprecated // to be removed before 2.0
   public static String getFileTimestamp() {
-    SimpleDateFormat sdf = new SimpleDateFormat(FILE_TIMESTAMP_FORMAT);
+    SimpleDateFormat sdf =
+        new SimpleDateFormat(FILE_TIMESTAMP_FORMAT, Locale.ROOT);
     return sdf.format(new java.util.Date());
   }
 
@@ -1304,13 +1314,13 @@ public class Util {
    */
   public static String toPosix(TimeZone tz, boolean verbose) {
     StringBuilder buf = new StringBuilder();
-    buf.append(tz.getDisplayName(false, TimeZone.SHORT));
+    buf.append(tz.getDisplayName(false, TimeZone.SHORT, Locale.ROOT));
     appendPosixTime(buf, tz.getRawOffset());
     final int dstSavings = tz.getDSTSavings();
     if (dstSavings == 0) {
       return buf.toString();
     }
-    buf.append(tz.getDisplayName(true, TimeZone.SHORT));
+    buf.append(tz.getDisplayName(true, TimeZone.SHORT, Locale.ROOT));
     if (verbose || (dstSavings != 3600000)) {
       // POSIX allows us to omit DST offset if it is 1:00:00
       appendPosixTime(buf, dstSavings);
@@ -2368,6 +2378,48 @@ public class Util {
     return builder.build();
   }
 
+  /** Creates a {@link PrintWriter} to a given output stream using UTF-8
+   * character set.
+   *
+   * <p>Does not use the default character set. */
+  public static PrintWriter printWriter(OutputStream out) {
+    return new PrintWriter(
+        new BufferedWriter(
+            new OutputStreamWriter(out, StandardCharsets.UTF_8)));
+  }
+
+  /** Creates a {@link PrintWriter} to a given file using UTF-8
+   * character set.
+   *
+   * <p>Does not use the default character set. */
+  public static PrintWriter printWriter(File file)
+      throws FileNotFoundException {
+    return printWriter(new FileOutputStream(file));
+  }
+
+  /** Creates a {@link BufferedReader} to a given input stream using UTF-8
+   * character set.
+   *
+   * <p>Does not use the default character set. */
+  public static BufferedReader reader(InputStream in) {
+    return new BufferedReader(
+        new InputStreamReader(in, StandardCharsets.UTF_8));
+  }
+
+  /** Creates a {@link BufferedReader} to read a given file using UTF-8
+   * character set.
+   *
+   * <p>Does not use the default character set. */
+  public static BufferedReader reader(File file) throws FileNotFoundException {
+    return reader(new FileInputStream(file));
+  }
+
+  /** Creates a {@link Calendar} in the GMT time zone and root locale.
+   * Does not use the time zone or locale. */
+  public static Calendar calendar() {
+    return Calendar.getInstance(DateTimeUtils.GMT_ZONE, Locale.ROOT);
+  }
+
   //~ Inner Classes ----------------------------------------------------------
 
   /**

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/ZonelessDatetime.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/ZonelessDatetime.java b/core/src/main/java/org/apache/calcite/util/ZonelessDatetime.java
index 13e956b..ab311e7 100644
--- a/core/src/main/java/org/apache/calcite/util/ZonelessDatetime.java
+++ b/core/src/main/java/org/apache/calcite/util/ZonelessDatetime.java
@@ -21,6 +21,7 @@ import org.apache.calcite.avatica.util.DateTimeUtils;
 import java.io.Serializable;
 import java.text.DateFormat;
 import java.util.Calendar;
+import java.util.Locale;
 import java.util.TimeZone;
 
 /**
@@ -171,7 +172,7 @@ public abstract class ZonelessDatetime implements BasicDatetime, Serializable {
    */
   protected Calendar getCalendar(TimeZone zone) {
     if (tempCal == null) {
-      tempCal = Calendar.getInstance(zone);
+      tempCal = Calendar.getInstance(zone, Locale.ROOT);
     } else {
       tempCal.setTimeZone(zone);
     }

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java b/core/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
index af170d9..1ac6a39 100644
--- a/core/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
+++ b/core/src/main/java/org/apache/calcite/util/javac/JaninoCompiler.java
@@ -24,6 +24,7 @@ import org.codehaus.janino.util.resource.ResourceFinder;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -67,7 +68,7 @@ public class JaninoCompiler implements JavaCompiler {
     Map<String, byte[]> sourceMap = new HashMap<String, byte[]>();
     sourceMap.put(
         ClassFile.getSourceResourceName(args.fullClassName),
-        args.source.getBytes());
+        args.source.getBytes(StandardCharsets.UTF_8));
     MapResourceFinder sourceFinder = new MapResourceFinder(sourceMap);
 
     classLoader =

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/main/java/org/apache/calcite/util/trace/CalciteTimingTracer.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/trace/CalciteTimingTracer.java b/core/src/main/java/org/apache/calcite/util/trace/CalciteTimingTracer.java
index 792ab79..07ada81 100644
--- a/core/src/main/java/org/apache/calcite/util/trace/CalciteTimingTracer.java
+++ b/core/src/main/java/org/apache/calcite/util/trace/CalciteTimingTracer.java
@@ -16,6 +16,8 @@
  */
 package org.apache.calcite.util.trace;
 
+import org.apache.calcite.util.NumberUtil;
+
 import org.slf4j.Logger;
 
 import java.text.DecimalFormat;
@@ -28,7 +30,7 @@ public class CalciteTimingTracer {
   //~ Static fields/initializers ---------------------------------------------
 
   private static final DecimalFormat DECIMAL_FORMAT =
-      new DecimalFormat("###,###,###,###,###");
+      NumberUtil.decimalFormat("###,###,###,###,###");
 
   //~ Instance fields --------------------------------------------------------
 

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
index 4578822..e08e3c0 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -30,6 +30,7 @@ import org.apache.calcite.prepare.CalcitePrepareImpl;
 import org.apache.calcite.test.CalciteAssert;
 import org.apache.calcite.test.JdbcFrontLinqBackTest;
 import org.apache.calcite.test.JdbcTest;
+import org.apache.calcite.util.Util;
 
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableList;
@@ -42,11 +43,12 @@ import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.sql.Array;
 import java.sql.Blob;
 import java.sql.Clob;
@@ -70,6 +72,7 @@ import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -85,9 +88,9 @@ import static org.junit.Assert.assertThat;
 public class CalciteRemoteDriverTest {
   public static final String LJS = Factory2.class.getName();
 
-  private final PrintStream out =
-      CalcitePrepareImpl.DEBUG ? System.out
-          : new PrintStream(new ByteArrayOutputStream());
+  private final PrintWriter out =
+      CalcitePrepareImpl.DEBUG ? Util.printWriter(System.out)
+          : new PrintWriter(new StringWriter());
 
   private static final CalciteAssert.ConnectionFactory
   REMOTE_CONNECTION_FACTORY =
@@ -429,9 +432,10 @@ public class CalciteRemoteDriverTest {
       SqlType.NCHAR, SqlType.NVARCHAR, SqlType.LONGNVARCHAR, SqlType.NCLOB,
       SqlType.SQLXML
     };
-    final PrintStream out =
-        CalcitePrepareImpl.DEBUG ? System.out
-            : new PrintStream(new ByteArrayOutputStream());
+    final PrintWriter out =
+        CalcitePrepareImpl.DEBUG
+            ? Util.printWriter(System.out)
+            : new PrintWriter(new StringWriter());
     for (SqlType.Method row : SqlType.Method.values()) {
       out.print(pad(row.methodName));
       for (SqlType column : columns) {
@@ -632,7 +636,7 @@ public class CalciteRemoteDriverTest {
           // string
           "", "foo", " foo! Baz ",
           // byte[]
-          new byte[0], "hello".getBytes());
+          new byte[0], "hello".getBytes(StandardCharsets.UTF_8));
 
   private static List<Object> values(Class clazz) {
     final List<Object> list = Lists.newArrayList();
@@ -659,7 +663,7 @@ public class CalciteRemoteDriverTest {
     }
     if (clazz == byte[].class) {
       if (o instanceof String) {
-        return ((String) o).getBytes();
+        return ((String) o).getBytes(StandardCharsets.UTF_8);
       }
     }
     if (clazz == Timestamp.class) {
@@ -679,12 +683,15 @@ public class CalciteRemoteDriverTest {
     }
     if (clazz == java.util.Date.class) {
       if (o instanceof String) {
-        return DateFormat.getInstance().parse((String) o);
+        final DateFormat dateFormat =
+            DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT,
+                Locale.ROOT);
+        return dateFormat.parse((String) o);
       }
     }
     if (clazz == Calendar.class) {
       if (o instanceof String) {
-        return Calendar.getInstance(); // TODO:
+        return Util.calendar(); // TODO:
       }
     }
     if (o instanceof Boolean) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
index cd453cd..3a1227f 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
@@ -19,7 +19,6 @@ package org.apache.calcite.rex;
 import org.apache.calcite.DataContext;
 import org.apache.calcite.adapter.java.JavaTypeFactory;
 import org.apache.calcite.avatica.util.ByteString;
-import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.linq4j.QueryProvider;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptSchema;
@@ -38,6 +37,7 @@ import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.calcite.util.NlsString;
+import org.apache.calcite.util.Util;
 
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableList;
@@ -159,7 +159,7 @@ public class RexExecutorTest {
     checkConstant(true,
         new Function<RexBuilder, RexNode>() {
           public RexNode apply(RexBuilder rexBuilder) {
-            Calendar calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+            Calendar calendar = Util.calendar();
             return rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN_OR_EQUAL,
                 rexBuilder.makeDateLiteral(calendar),
                 rexBuilder.makeDateLiteral(calendar));
@@ -169,7 +169,7 @@ public class RexExecutorTest {
     checkConstant(false,
         new Function<RexBuilder, RexNode>() {
           public RexNode apply(RexBuilder rexBuilder) {
-            Calendar calendar = Calendar.getInstance(DateTimeUtils.GMT_ZONE);
+            Calendar calendar = Util.calendar();
             return rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN,
                 rexBuilder.makeDateLiteral(calendar),
                 rexBuilder.makeDateLiteral(calendar));

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java b/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
index 54fce65..9c47a4f 100644
--- a/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/parser/SqlParserTest.java
@@ -46,7 +46,6 @@ import org.junit.Test;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileOutputStream;
-import java.io.FileReader;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.net.URL;
@@ -6595,8 +6594,9 @@ public class SqlParserTest {
     for (Map.Entry<String, List<String>> intervalGroup : tsi.entrySet()) {
       for (String function : functions) {
         for (String interval : intervalGroup.getValue()) {
-          checkExp(String.format(function, interval, ""),
-              String.format(function, intervalGroup.getKey(), "`").toUpperCase());
+          checkExp(String.format(Locale.ROOT, function, interval, ""),
+              String.format(Locale.ROOT, function, intervalGroup.getKey(), "`")
+                  .toUpperCase(Locale.ROOT));
         }
       }
     }
@@ -6819,9 +6819,9 @@ public class SqlParserTest {
     final File inFile = new File(base, "site/_docs/reference.md");
     final File outFile = new File(base, "core/target/surefire/reference.md");
     outFile.getParentFile().mkdirs();
-    try (BufferedReader r = new BufferedReader(new FileReader(inFile));
+    try (BufferedReader r = Util.reader(inFile);
          FileOutputStream fos = new FileOutputStream(outFile);
-         PrintWriter w = new PrintWriter(fos)) {
+         PrintWriter w = Util.printWriter(outFile)) {
       String line;
       int stage = 0;
       while ((line = r.readLine()) != null) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
index 95000f6..1fd1933 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
@@ -51,6 +51,7 @@ import org.apache.calcite.test.SqlLimitsTest;
 import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.Holder;
 import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Util;
 
 import com.google.common.base.Function;
 import com.google.common.base.Throwables;
@@ -72,6 +73,7 @@ import java.util.Calendar;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import java.util.TimeZone;
 import java.util.regex.Pattern;
 
@@ -1202,7 +1204,7 @@ public abstract class SqlOperatorBaseTest {
     // is guaranteed to be good for at least 2 minutes, which should give
     // us time to run the rest of the tests.
     final String today =
-        new SimpleDateFormat("yyyy-MM-dd").format(
+        new SimpleDateFormat("yyyy-MM-dd", Locale.ROOT).format(
             getCalendarNotTooNear(Calendar.DAY_OF_MONTH).getTime());
 
     tester.checkScalar(
@@ -1384,7 +1386,7 @@ public abstract class SqlOperatorBaseTest {
    * @return calendar
    */
   protected static Calendar getCalendarNotTooNear(int timeUnit) {
-    final Calendar cal = Calendar.getInstance();
+    final Calendar cal = Util.calendar();
     while (true) {
       cal.setTimeInMillis(System.currentTimeMillis());
       try {
@@ -4517,7 +4519,7 @@ public abstract class SqlOperatorBaseTest {
         public void close() {}
       };
     } else {
-      calendar = Calendar.getInstance();
+      calendar = Util.calendar();
       calendar.set(Calendar.YEAR, 2014);
       calendar.set(Calendar.MONTH, 8);
       calendar.set(Calendar.DATE, 7);
@@ -4535,7 +4537,7 @@ public abstract class SqlOperatorBaseTest {
           });
     }
 
-    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:");
+    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:", Locale.ROOT);
     sdf.setTimeZone(tz);
     return Pair.of(sdf.format(calendar.getTime()), closeable);
   }
@@ -6662,7 +6664,7 @@ public abstract class SqlOperatorBaseTest {
       case VARCHAR:
         return SqlLiteral.createCharString(value.toString(), SqlParserPos.ZERO);
       case TIMESTAMP:
-        Calendar calendar = Calendar.getInstance();
+        Calendar calendar = Util.calendar();
         calendar.setTimeInMillis((Long) value);
         return SqlLiteral.createTimestamp(calendar, type.getPrecision(),
             SqlParserPos.ZERO);

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
index 87de5f5..5fe474f 100644
--- a/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
@@ -22,6 +22,7 @@ import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 
 import static org.hamcrest.CoreMatchers.anyOf;
 import static org.hamcrest.CoreMatchers.is;
@@ -48,14 +49,15 @@ public class SqlValidatorUtilTest {
     // Make sure each name is unique
     List<String> copyResultList  = new ArrayList<>(resultList.size());
     for (String result : resultList) {
-      copyResultList.add(result.toLowerCase());
+      copyResultList.add(result.toLowerCase(Locale.ROOT));
     }
 
     for (String result : resultList) {
-      assertThat(copyResultList.contains(result.toLowerCase()), is(true));
-      copyResultList.remove(result.toLowerCase());
+      final String lowerResult = result.toLowerCase(Locale.ROOT);
+      assertThat(copyResultList.contains(lowerResult), is(true));
+      copyResultList.remove(lowerResult);
       if (!caseSensitive) {
-        assertThat(copyResultList.contains(result.toLowerCase()), is(false));
+        assertThat(copyResultList.contains(lowerResult), is(false));
       }
     }
     assertThat(copyResultList.size(), is(0));

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/CalciteAssert.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/CalciteAssert.java b/core/src/test/java/org/apache/calcite/test/CalciteAssert.java
index fad0812..dd7168c 100644
--- a/core/src/test/java/org/apache/calcite/test/CalciteAssert.java
+++ b/core/src/test/java/org/apache/calcite/test/CalciteAssert.java
@@ -77,6 +77,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Properties;
@@ -114,7 +115,7 @@ public class CalciteAssert {
   public static final DatabaseInstance DB =
       DatabaseInstance.valueOf(
           Util.first(System.getProperty("calcite.test.db"), "HSQLDB")
-              .toUpperCase());
+              .toUpperCase(Locale.ROOT));
 
   /** Whether to enable slow tests. Default is false. */
   public static final boolean ENABLE_SLOW =
@@ -125,11 +126,12 @@ public class CalciteAssert {
   private static final DateFormat UTC_TIMESTAMP_FORMAT;
   static {
     final TimeZone utc = DateTimeUtils.GMT_ZONE;
-    UTC_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
+    UTC_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd", Locale.ROOT);
     UTC_DATE_FORMAT.setTimeZone(utc);
-    UTC_TIME_FORMAT = new SimpleDateFormat("HH:mm:ss");
+    UTC_TIME_FORMAT = new SimpleDateFormat("HH:mm:ss", Locale.ROOT);
     UTC_TIME_FORMAT.setTimeZone(utc);
-    UTC_TIMESTAMP_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+    UTC_TIMESTAMP_FORMAT =
+        new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.ROOT);
     UTC_TIMESTAMP_FORMAT.setTimeZone(utc);
   }
 
@@ -1418,7 +1420,8 @@ public class CalciteAssert {
       boolean save = materializationsEnabled;
       try {
         materializationsEnabled = false;
-        final boolean ordered = sql.toUpperCase().contains("ORDER BY");
+        final boolean ordered =
+            sql.toUpperCase(Locale.ROOT).contains("ORDER BY");
         final Function<ResultSet, Void> checker = consistentResult(ordered);
         returns(checker);
         materializationsEnabled = true;

http://git-wip-us.apache.org/repos/asf/calcite/blob/75152c5b/core/src/test/java/org/apache/calcite/test/DiffRepository.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/DiffRepository.java b/core/src/test/java/org/apache/calcite/test/DiffRepository.java
index 622c526..ee48d9d 100644
--- a/core/src/test/java/org/apache/calcite/test/DiffRepository.java
+++ b/core/src/test/java/org/apache/calcite/test/DiffRepository.java
@@ -34,7 +34,6 @@ import org.w3c.dom.Text;
 import org.xml.sax.SAXException;
 
 import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.net.URL;
@@ -526,7 +525,7 @@ public class DiffRepository {
     try {
       boolean b = logFile.getParentFile().mkdirs();
       Util.discard(b);
-      try (FileWriter w = new FileWriter(logFile)) {
+      try (Writer w = Util.printWriter(logFile)) {
         write(doc, w, indent);
       }
     } catch (IOException e) {


[03/10] calcite git commit: [CALCITE-1656] Improve cost function in DruidQuery to encourage early column pruning (Nishant Bangarwa)

Posted by jh...@apache.org.
[CALCITE-1656] Improve cost function in DruidQuery to encourage early column pruning (Nishant Bangarwa)

The cost function now includes:
 * Number of fields being queried
 * Type of DruidQuery generated

Close apache/calcite#382


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/c90fddfb
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/c90fddfb
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/c90fddfb

Branch: refs/heads/master
Commit: c90fddfb1c600e6c870558778c50ebfbcd5f1799
Parents: 33f9d0f
Author: Nishant <ni...@gmail.com>
Authored: Fri Feb 24 21:40:42 2017 +0530
Committer: Julian Hyde <jh...@apache.org>
Committed: Fri Mar 3 10:13:36 2017 -0800

----------------------------------------------------------------------
 .../apache/calcite/rel/metadata/RelMdUtil.java  | 31 +++++++++++++++
 .../apache/calcite/test/RelMetadataTest.java    | 11 ++++++
 .../calcite/adapter/druid/DruidQuery.java       | 27 ++++++++++++-
 .../org/apache/calcite/test/DruidAdapterIT.java | 41 +++++++++++++++++++-
 4 files changed, 108 insertions(+), 2 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/c90fddfb/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
index 089f551..7b63ac9 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
@@ -44,6 +44,7 @@ import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.NumberUtil;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 
 import java.math.BigDecimal;
@@ -719,6 +720,36 @@ public class RelMdUtil {
         * mq.getSelectivity(child, condition);
   }
 
+  /** Returns a point on a line.
+   *
+   * <p>The result is always a value between {@code minY} and {@code maxY},
+   * even if {@code x} is not between {@code minX} and {@code maxX}.
+   *
+   * <p>Examples:<ul>
+   *   <li>{@code linear(0, 0, 10, 100, 200}} returns 100 because 0 is minX
+   *   <li>{@code linear(5, 0, 10, 100, 200}} returns 150 because 5 is
+   *   mid-way between minX and maxX
+   *   <li>{@code linear(5, 0, 10, 100, 200}} returns 160
+   *   <li>{@code linear(10, 0, 10, 100, 200}} returns 200 because 10 is maxX
+   *   <li>{@code linear(-2, 0, 10, 100, 200}} returns 100 because -2 is
+   *   less than minX and is therefore treated as minX
+   *   <li>{@code linear(12, 0, 10, 100, 200}} returns 100 because 12 is
+   *   greater than maxX and is therefore treated as maxX
+   * </ul>
+   */
+  public static double linear(int x, int minX, int maxX, double minY, double
+      maxY) {
+    Preconditions.checkArgument(minX < maxX);
+    Preconditions.checkArgument(minY < maxY);
+    if (x < minX) {
+      return minY;
+    }
+    if (x > maxX) {
+      return maxY;
+    }
+    return minY + (double) (x - minX) / (double) (maxX - minX) * (maxY - minY);
+  }
+
   //~ Inner Classes ----------------------------------------------------------
 
   /** Visitor that walks over a scalar expression and computes the

http://git-wip-us.apache.org/repos/asf/calcite/blob/c90fddfb/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java b/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
index 54e3b5e..234b666 100644
--- a/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
@@ -60,6 +60,7 @@ import org.apache.calcite.rel.metadata.MetadataHandler;
 import org.apache.calcite.rel.metadata.ReflectiveRelMetadataProvider;
 import org.apache.calcite.rel.metadata.RelColumnOrigin;
 import org.apache.calcite.rel.metadata.RelMdCollation;
+import org.apache.calcite.rel.metadata.RelMdUtil;
 import org.apache.calcite.rel.metadata.RelMetadataProvider;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.type.RelDataType;
@@ -1470,6 +1471,16 @@ public class RelMetadataTest extends SqlToRelTestBase {
     assertThat(d, is(dist));
   }
 
+  /** Unit test for {@link RelMdUtil#linear(int, int, int, double, double)}. */
+  @Test public void testLinear() {
+    assertThat(RelMdUtil.linear(0, 0, 10, 100, 200), is(100d));
+    assertThat(RelMdUtil.linear(5, 0, 10, 100, 200), is(150d));
+    assertThat(RelMdUtil.linear(6, 0, 10, 100, 200), is(160d));
+    assertThat(RelMdUtil.linear(10, 0, 10, 100, 200), is(200d));
+    assertThat(RelMdUtil.linear(-2, 0, 10, 100, 200), is(100d));
+    assertThat(RelMdUtil.linear(12, 0, 10, 100, 200), is(200d));
+  }
+
   /**
    * Matcher that succeeds for any collection that, when converted to strings
    * and sorted on those strings, matches the given reference string.

http://git-wip-us.apache.org/repos/asf/calcite/blob/c90fddfb/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
----------------------------------------------------------------------
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
index b76652c..17ddd05 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
@@ -44,6 +44,7 @@ import org.apache.calcite.rel.core.Filter;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableScan;
+import org.apache.calcite.rel.metadata.RelMdUtil;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeField;
@@ -346,7 +347,31 @@ public class DruidQuery extends AbstractRelNode implements BindableRel {
 
   @Override public RelOptCost computeSelfCost(RelOptPlanner planner,
       RelMetadataQuery mq) {
-    return Util.last(rels).computeSelfCost(planner, mq).multiplyBy(.1);
+    return Util.last(rels)
+        .computeSelfCost(planner, mq)
+        // Cost increases with the number of fields queried.
+        // A plan returning 100 or more columns will have 2x the cost of a
+        // plan returning 2 columns.
+        // A plan where all extra columns are pruned will be preferred.
+        .multiplyBy(
+            RelMdUtil.linear(querySpec.fieldNames.size(), 2, 100, 1d, 2d))
+        .multiplyBy(getQueryTypeCostMultiplier());
+  }
+
+  private double getQueryTypeCostMultiplier() {
+    // Cost of Select > GroupBy > Timeseries > TopN
+    switch (querySpec.queryType) {
+    case SELECT:
+      return .1;
+    case GROUP_BY:
+      return .08;
+    case TIMESERIES:
+      return .06;
+    case TOP_N:
+      return .04;
+    default:
+      return .2;
+    }
   }
 
   @Override public void register(RelOptPlanner planner) {

http://git-wip-us.apache.org/repos/asf/calcite/blob/c90fddfb/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
----------------------------------------------------------------------
diff --git a/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java b/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
index 15cf7e0..cd28362 100644
--- a/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
+++ b/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
@@ -1335,7 +1335,7 @@ public class DruidAdapterIT {
     final String explain = "EnumerableInterpreter\n"
         + "  BindableAggregate(group=[{}], C=[COUNT()])\n"
         + "    BindableFilter(condition=[AND(>=(/INT(Reinterpret($0), 86400000), 1997-01-01), <(/INT(Reinterpret($0), 86400000), 1998-01-01), OR(AND(>=(/INT(Reinterpret($0), 86400000), 1997-04-01), <(/INT(Reinterpret($0), 86400000), 1997-05-01)), AND(>=(/INT(Reinterpret($0), 86400000), 1997-06-01), <(/INT(Reinterpret($0), 86400000), 1997-07-01))))])\n"
-        + "      DruidQuery(table=[[foodmart, foodmart]], intervals=[[1900-01-09T00:00:00.000/2992-01-10T00:00:00.000]])";
+        + "      DruidQuery(table=[[foodmart, foodmart]], intervals=[[1900-01-09T00:00:00.000/2992-01-10T00:00:00.000]], projects=[[$0]])";
     sql(sql)
         .explainContains(explain)
         .returnsUnordered("C=13500");
@@ -1368,6 +1368,45 @@ public class DruidAdapterIT {
     sql(sql, WIKI)
         .returnsCount(9);
   }
+
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-1656">[CALCITE-1656]
+   * Improve cost function in DruidQuery to encourage early column
+   * pruning</a>. */
+  @Test public void testFieldBasedCostColumnPruning() {
+    // A query where filter cannot be pushed to Druid but
+    // the project can still be pushed in order to prune extra columns.
+    String sql = "select \"countryName\", floor(\"time\" to DAY),\n"
+        + "  cast(count(*) as integer) as c\n"
+        + "from \"wiki\"\n"
+        + "where floor(\"time\" to DAY) >= '1997-01-01 00:00:00'\n"
+        + "and floor(\"time\" to DAY) < '1997-09-01 00:00:00'\n"
+        + "group by \"countryName\", floor(\"time\" TO DAY)\n"
+        + "order by c limit 5";
+
+    String plan = "BindableProject(countryName=[$0], EXPR$1=[$1], C=[CAST($2):INTEGER NOT NULL])\n"
+        + "    BindableSort(sort0=[$2], dir0=[ASC], fetch=[5])\n"
+        + "      BindableAggregate(group=[{0, 1}], agg#0=[COUNT()])\n"
+        + "        BindableProject(countryName=[$1], EXPR$1=[FLOOR($0, FLAG(DAY))])\n"
+        + "          BindableFilter(condition=[AND(>=(FLOOR($0, FLAG(DAY)), 1997-01-01 00:00:00), <(FLOOR($0, FLAG(DAY)), 1997-09-01 00:00:00))])\n"
+        + "            DruidQuery(table=[[wiki, wiki]], intervals=[[1900-01-09T00:00:00.000/2992-01-10T00:00:00.000]], projects=[[$0, $5]])";
+
+    // NOTE: Druid query only has countryName as the dimension
+    // being queried after project is pushed to druid query.
+    String druidQuery = "{\"queryType\":\"select\","
+        + "\"dataSource\":\"wikiticker\","
+        + "\"descending\":false,"
+        + "\"intervals\":[\"1900-01-09T00:00:00.000/2992-01-10T00:00:00.000\"],"
+        + "\"dimensions\":[\"countryName\"],"
+        + "\"metrics\":[],"
+        + "\"granularity\":\"all\","
+        + "\"pagingSpec\":{\"threshold\":16384,\"fromNext\":true},"
+        + "\"context\":{\"druid.query.fetch\":false}}";
+    sql(sql, WIKI).explainContains(plan);
+    sql(sql, WIKI).queryContains(druidChecker(druidQuery));
+  }
+
 }
 
 // End DruidAdapterIT.java


[02/10] calcite git commit: Improved plan due to [CALCITE-1601] fix

Posted by jh...@apache.org.
Improved plan due to [CALCITE-1601] fix


Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/4a3df4ef
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/4a3df4ef
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/4a3df4ef

Branch: refs/heads/master
Commit: 4a3df4ef9746760b17c639c6b5be609a31adcd5c
Parents: 952214a
Author: Julian Hyde <jh...@apache.org>
Authored: Thu Mar 2 16:44:07 2017 -0800
Committer: Julian Hyde <jh...@apache.org>
Committed: Fri Mar 3 10:13:29 2017 -0800

----------------------------------------------------------------------
 druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/calcite/blob/4a3df4ef/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
----------------------------------------------------------------------
diff --git a/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java b/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
index 974cae9..15cf7e0 100644
--- a/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
+++ b/druid/src/test/java/org/apache/calcite/test/DruidAdapterIT.java
@@ -1334,11 +1334,11 @@ public class DruidAdapterIT {
         + "and extract(month from \"timestamp\") in (4, 6)\n";
     final String explain = "EnumerableInterpreter\n"
         + "  BindableAggregate(group=[{}], C=[COUNT()])\n"
-        + "    BindableFilter(condition=[AND(>=(/INT(Reinterpret($0), 86400000), 1997-01-01), <(/INT(Reinterpret($0), 86400000), 1998-01-01), >=(/INT(Reinterpret($0), 86400000), 1997-04-01), <(/INT(Reinterpret($0), 86400000), 1997-05-01))])\n"
+        + "    BindableFilter(condition=[AND(>=(/INT(Reinterpret($0), 86400000), 1997-01-01), <(/INT(Reinterpret($0), 86400000), 1998-01-01), OR(AND(>=(/INT(Reinterpret($0), 86400000), 1997-04-01), <(/INT(Reinterpret($0), 86400000), 1997-05-01)), AND(>=(/INT(Reinterpret($0), 86400000), 1997-06-01), <(/INT(Reinterpret($0), 86400000), 1997-07-01))))])\n"
         + "      DruidQuery(table=[[foodmart, foodmart]], intervals=[[1900-01-09T00:00:00.000/2992-01-10T00:00:00.000]])";
     sql(sql)
         .explainContains(explain)
-        .returnsUnordered("C=6588");
+        .returnsUnordered("C=13500");
   }
 
   @Test public void testFilterSwapped() {