IMPALA-7818: Standardize use of Expr predicates The Expr node provide two kinds of queries about node categories: predicates and isMumble() functions. This change standardizes two existing methods to use predicates instead.
First, the existing isLiteral() method is replaced by a new IS_LITERAL predicate. The key purpose is to clean up the confusing use of the existing isNullLiteral() method, which actually is a check for either a null literal or a cast of a null. To make this clearer, replaced this method with a new IS_NULL_VALUE() predicate. Added a new IS_NULL_LITERAL predicate for the case when a node must be exactly the NULL literal, not a cast to NULL. Replaced instances of foo instanceof NullLiteral with a use of the new IS_NULL_LITERAL predicate. (This revealed bugs which will be addressed separately.) Added an IS_NON_NULL_LITERAL to replace the two-method idiom used in several places. Tests: No functional change. Reran all tests to ensure nothing changed. Change-Id: I09a089c0f2484246e5c6444b78990fa9260c036a Reviewed-on: http://gerrit.cloudera.org:8080/11887 Reviewed-by: Impala Public Jenkins <impala-public-jenk...@cloudera.com> Tested-by: Impala Public Jenkins <impala-public-jenk...@cloudera.com> Project: http://git-wip-us.apache.org/repos/asf/impala/repo Commit: http://git-wip-us.apache.org/repos/asf/impala/commit/8dfbe3c8 Tree: http://git-wip-us.apache.org/repos/asf/impala/tree/8dfbe3c8 Diff: http://git-wip-us.apache.org/repos/asf/impala/diff/8dfbe3c8 Branch: refs/heads/branch-3.1.0 Commit: 8dfbe3c82d4acfae60d58636af041ac13708ef1e Parents: ccabc49 Author: Paul Rogers <prog...@cloudera.com> Authored: Tue Nov 6 10:34:30 2018 -0800 Committer: Zoltan Borok-Nagy <borokna...@cloudera.com> Committed: Tue Nov 13 12:51:49 2018 +0100 ---------------------------------------------------------------------- fe/src/main/cup/sql-parser.cup | 2 +- .../org/apache/impala/analysis/Analyzer.java | 2 +- .../org/apache/impala/analysis/CaseExpr.java | 7 +- .../org/apache/impala/analysis/CastExpr.java | 2 +- .../org/apache/impala/analysis/ColumnDef.java | 2 +- .../java/org/apache/impala/analysis/Expr.java | 90 ++++++++++++++------ .../impala/analysis/FunctionCallExpr.java | 2 +- .../apache/impala/analysis/LikePredicate.java | 4 +- .../org/apache/impala/analysis/LiteralExpr.java | 6 +- .../impala/analysis/PartitionKeyValue.java | 5 +- .../apache/impala/analysis/PartitionSet.java | 2 +- .../apache/impala/analysis/PartitionSpec.java | 2 +- .../apache/impala/analysis/RangePartition.java | 2 +- .../org/apache/impala/analysis/SelectStmt.java | 2 +- .../impala/analysis/TupleIsNullPredicate.java | 2 +- .../apache/impala/catalog/FeCatalogUtils.java | 2 +- .../org/apache/impala/catalog/FeFsTable.java | 3 +- .../org/apache/impala/catalog/HdfsTable.java | 5 +- .../impala/catalog/local/LocalFsTable.java | 4 +- .../impala/planner/HdfsPartitionPruner.java | 14 +-- .../org/apache/impala/planner/HdfsScanNode.java | 6 +- .../org/apache/impala/planner/KuduScanNode.java | 6 +- .../impala/rewrite/FoldConstantsRule.java | 6 +- .../impala/rewrite/NormalizeCountStarRule.java | 4 +- .../rewrite/RemoveRedundantStringCast.java | 4 +- .../rewrite/SimplifyConditionalsRule.java | 37 ++++---- .../org/apache/impala/service/FeSupport.java | 2 +- .../impala/analysis/ExprRewriterTest.java | 4 +- .../impala/catalog/local/LocalCatalogTest.java | 3 +- 29 files changed, 138 insertions(+), 94 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/cup/sql-parser.cup ---------------------------------------------------------------------- diff --git a/fe/src/main/cup/sql-parser.cup b/fe/src/main/cup/sql-parser.cup index ebe653a..50418d0 100644 --- a/fe/src/main/cup/sql-parser.cup +++ b/fe/src/main/cup/sql-parser.cup @@ -2916,7 +2916,7 @@ sign_chain_expr ::= // integrate signs into literals // integer literals require analysis to set their type, so the instance check below // is not equivalent to e.getType().isNumericType() - if (e.isLiteral() && e instanceof NumericLiteral) { + if (e instanceof NumericLiteral) { ((LiteralExpr)e).swapSign(); RESULT = e; } else { http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/Analyzer.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/Analyzer.java b/fe/src/main/java/org/apache/impala/analysis/Analyzer.java index 0672cfb..ca5ac72 100644 --- a/fe/src/main/java/org/apache/impala/analysis/Analyzer.java +++ b/fe/src/main/java/org/apache/impala/analysis/Analyzer.java @@ -1165,7 +1165,7 @@ public class Analyzer { public void createAuxEqPredicate(Expr lhs, Expr rhs) { // Check the expr type as well as the class because NullLiteral could have been // implicitly cast to a type different than NULL. - if (lhs instanceof NullLiteral || rhs instanceof NullLiteral || + if (Expr.IS_NULL_LITERAL.apply(lhs) || Expr.IS_NULL_LITERAL.apply(rhs) || lhs.getType().isNull() || rhs.getType().isNull()) { return; } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/CaseExpr.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/CaseExpr.java b/fe/src/main/java/org/apache/impala/analysis/CaseExpr.java index 196c5cd..7158f8d 100644 --- a/fe/src/main/java/org/apache/impala/analysis/CaseExpr.java +++ b/fe/src/main/java/org/apache/impala/analysis/CaseExpr.java @@ -32,7 +32,6 @@ import org.apache.impala.thrift.TExprNode; import org.apache.impala.thrift.TExprNodeType; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; -import com.google.common.base.Predicates; import com.google.common.collect.Lists; import com.google.common.collect.Sets; @@ -127,8 +126,8 @@ public class CaseExpr extends Expr { // Add the key_expr/val_expr pairs while (childIdx + 2 <= decodeExpr.getChildren().size()) { Expr candidate = decodeExpr.getChild(childIdx++); - if (candidate.isLiteral()) { - if (candidate.isNullLiteral()) { + if (IS_LITERAL.apply(candidate)) { + if (IS_NULL_VALUE.apply(candidate)) { // An example case is DECODE(foo, NULL, bar), since NULLs are considered // equal, this becomes CASE WHEN foo IS NULL THEN bar END. children_.add(encodedIsNull.clone()); @@ -402,7 +401,7 @@ public class CaseExpr extends Expr { Expr outputExpr = children_.get(i); if (outputExpr.isConstant()) { - if (outputExpr.isLiteral()) { + if (IS_LITERAL.apply(outputExpr)) { LiteralExpr outputLiteral = (LiteralExpr) outputExpr; if (constLiteralSet.add(outputLiteral)) ++numOutputConstants; } else { http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/CastExpr.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/CastExpr.java b/fe/src/main/java/org/apache/impala/analysis/CastExpr.java index a674f4a..e76a558 100644 --- a/fe/src/main/java/org/apache/impala/analysis/CastExpr.java +++ b/fe/src/main/java/org/apache/impala/analysis/CastExpr.java @@ -248,7 +248,7 @@ public class CastExpr extends Expr { // Ensure child has non-null type (even if it's a null literal). This is required // for the UDF interface. - if (children_.get(0) instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(children_.get(0))) { NullLiteral nullChild = (NullLiteral)(children_.get(0)); nullChild.uncheckedCastTo(type_); } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/ColumnDef.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/ColumnDef.java b/fe/src/main/java/org/apache/impala/analysis/ColumnDef.java index 24f6029..fa158e3 100644 --- a/fe/src/main/java/org/apache/impala/analysis/ColumnDef.java +++ b/fe/src/main/java/org/apache/impala/analysis/ColumnDef.java @@ -269,7 +269,7 @@ public class ColumnDef { e.analyze(analyzer); defaultValLiteral = LiteralExpr.create(e, analyzer.getQueryCtx()); Preconditions.checkNotNull(defaultValLiteral); - if (defaultValLiteral.isNullLiteral()) { + if (Expr.IS_NULL_VALUE.apply(defaultValLiteral)) { throw new AnalysisException(String.format("String %s cannot be cast " + "to a TIMESTAMP literal.", defaultValue_.toSql())); } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/Expr.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/Expr.java b/fe/src/main/java/org/apache/impala/analysis/Expr.java index fdf639e..ac5c394 100644 --- a/fe/src/main/java/org/apache/impala/analysis/Expr.java +++ b/fe/src/main/java/org/apache/impala/analysis/Expr.java @@ -208,7 +208,7 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl public boolean apply(Expr arg) { return arg instanceof BinaryPredicate && ((BinaryPredicate) arg).getOp() == Operator.EQ - && (((BinaryPredicate) arg).getChild(1).isLiteral()); + && IS_LITERAL.apply(((BinaryPredicate) arg).getChild(1)); } }; @@ -231,6 +231,65 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl } }; + /** + * @return true if the expression is a literal. + */ + public final static com.google.common.base.Predicate<Expr> IS_LITERAL = + new com.google.common.base.Predicate<Expr>() { + @Override + public boolean apply(Expr arg) { + return arg instanceof LiteralExpr; + } + }; + + /** + * @return true if the expression is a null literal. + */ + public final static com.google.common.base.Predicate<Expr> IS_NULL_LITERAL = + new com.google.common.base.Predicate<Expr>() { + @Override + public boolean apply(Expr arg) { + return arg instanceof NullLiteral; + } + }; + + /** + * @return true if the expression is a literal value other than NULL. + */ + public final static com.google.common.base.Predicate<Expr> IS_NON_NULL_LITERAL = + new com.google.common.base.Predicate<Expr>() { + @Override + public boolean apply(Expr arg) { + return IS_LITERAL.apply(arg) && !IS_NULL_LITERAL.apply(arg); + } + }; + + /** + * @return true if the expression is a null literal, or a + * cast of a null (as created by the ConstantFoldingRule.) + */ + public final static com.google.common.base.Predicate<Expr> IS_NULL_VALUE = + new com.google.common.base.Predicate<Expr>() { + @Override + public boolean apply(Expr arg) { + if (arg instanceof NullLiteral) return true; + if (! (arg instanceof CastExpr)) return false; + return IS_NULL_VALUE.apply(((CastExpr) arg).getChild(0)); + } + }; + + /** + * @return true if the expression is a literal, or a + * cast of a null (as created by the ConstantFoldingRule.) + */ + public final static com.google.common.base.Predicate<Expr> IS_LITERAL_VALUE = + new com.google.common.base.Predicate<Expr>() { + @Override + public boolean apply(Expr arg) { + return IS_LITERAL.apply(arg) || IS_NULL_VALUE.apply(arg); + } + }; + // id that's unique across the entire query statement and is assigned by // Analyzer.registerConjuncts(); only assigned for the top-level terms of a // conjunction, and therefore null for most Exprs @@ -638,7 +697,8 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl // Hack to ensure BE never sees TYPE_NULL. If an expr makes it this far without // being cast to a non-NULL type, the type doesn't matter and we can cast it // arbitrarily. - Preconditions.checkState(this instanceof NullLiteral || this instanceof SlotRef); + Preconditions.checkState(IS_NULL_LITERAL.apply(this) || + this instanceof SlotRef); return NullLiteral.create(ScalarType.BOOLEAN).treeToThrift(); } TExpr result = new TExpr(); @@ -1106,13 +1166,13 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl // Remove constant boolean literal expressions. N.B. - we may have // expressions determined to be constant which can not yet be discarded // because they can't be evaluated if expr rewriting is turned off. - if (rewritten instanceof NullLiteral || - Expr.IS_FALSE_LITERAL.apply(rewritten)) { + if (IS_NULL_LITERAL.apply(rewritten) || + IS_FALSE_LITERAL.apply(rewritten)) { conjuncts.clear(); conjuncts.add(rewritten); return false; } - if (Expr.IS_TRUE_LITERAL.apply(rewritten)) { + if (IS_TRUE_LITERAL.apply(rewritten)) { pruned++; conjuncts.remove(index); } @@ -1183,13 +1243,6 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl } /** - * @return true if this is an instance of LiteralExpr - */ - public boolean isLiteral() { - return this instanceof LiteralExpr; - } - - /** * Returns true if this expression should be treated as constant. I.e. if the frontend * and backend should assume that two evaluations of the expression within a query will * return the same value. Examples of constant expressions include: @@ -1220,17 +1273,6 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl } /** - * @return true if this expr is either a null literal or a cast from - * a null literal. - */ - public boolean isNullLiteral() { - if (this instanceof NullLiteral) return true; - if (!(this instanceof CastExpr)) return false; - Preconditions.checkState(children_.size() == 1); - return children_.get(0).isNullLiteral(); - } - - /** * Return true if this expr is a scalar subquery. */ public boolean isScalarSubquery() { @@ -1404,7 +1446,7 @@ abstract public class Expr extends TreeNode<Expr> implements ParseNode, Cloneabl */ public static Expr pushNegationToOperands(Expr root) { Preconditions.checkNotNull(root); - if (Expr.IS_NOT_PREDICATE.apply(root)) { + if (IS_NOT_PREDICATE.apply(root)) { try { // Make sure we call function 'negate' only on classes that support it, // otherwise we may recurse infinitely. http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/FunctionCallExpr.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/FunctionCallExpr.java b/fe/src/main/java/org/apache/impala/analysis/FunctionCallExpr.java index 2716199..6fd3e97 100644 --- a/fe/src/main/java/org/apache/impala/analysis/FunctionCallExpr.java +++ b/fe/src/main/java/org/apache/impala/analysis/FunctionCallExpr.java @@ -429,7 +429,7 @@ public class FunctionCallExpr extends Expr { // The second argument to these functions is the desired scale, otherwise // the default is 0. Preconditions.checkState(children_.size() == 2); - if (children_.get(1).isNullLiteral()) { + if (IS_NULL_VALUE.apply(children_.get(1))) { throw new AnalysisException(fnName_.getFunction() + "() cannot be called with a NULL second argument."); } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/LikePredicate.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/LikePredicate.java b/fe/src/main/java/org/apache/impala/analysis/LikePredicate.java index 3830c95..181c7f7 100644 --- a/fe/src/main/java/org/apache/impala/analysis/LikePredicate.java +++ b/fe/src/main/java/org/apache/impala/analysis/LikePredicate.java @@ -129,7 +129,7 @@ public class LikePredicate extends Predicate { Preconditions.checkState(fn_ != null); Preconditions.checkState(fn_.getReturnType().isBoolean()); - if (getChild(1).isLiteral() && !getChild(1).isNullLiteral() + if (Expr.IS_NON_NULL_LITERAL.apply(getChild(1)) && (op_ == Operator.RLIKE || op_ == Operator.REGEXP || op_ == Operator.IREGEXP)) { // let's make sure the pattern works // TODO: this checks that it's a Java-supported regex, but the syntax supported @@ -147,7 +147,7 @@ public class LikePredicate extends Predicate { @Override protected float computeEvalCost() { if (!hasChildCosts()) return UNKNOWN_COST; - if (getChild(1).isLiteral() && !getChild(1).isNullLiteral() && + if (Expr.IS_NON_NULL_LITERAL.apply(getChild(1)) && Pattern.matches("[%_]*[^%_]*[%_]*", ((StringLiteral) getChild(1)).getValueWithOriginalEscapes())) { // This pattern only has wildcards as leading or trailing character, http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/LiteralExpr.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/LiteralExpr.java b/fe/src/main/java/org/apache/impala/analysis/LiteralExpr.java index 2a5e502..cde3db3 100644 --- a/fe/src/main/java/org/apache/impala/analysis/LiteralExpr.java +++ b/fe/src/main/java/org/apache/impala/analysis/LiteralExpr.java @@ -275,9 +275,9 @@ public abstract class LiteralExpr extends Expr implements Comparable<LiteralExpr // Order NullLiterals based on the SQL ORDER BY default behavior: NULLS LAST. @Override public int compareTo(LiteralExpr other) { - if (this instanceof NullLiteral && other instanceof NullLiteral) return 0; - if (this instanceof NullLiteral) return -1; - if (other instanceof NullLiteral) return 1; + if (Expr.IS_NULL_LITERAL.apply(this) && Expr.IS_NULL_LITERAL.apply(other)) return 0; + if (Expr.IS_NULL_LITERAL.apply(this)) return -1; + if (Expr.IS_NULL_LITERAL.apply(other)) return 1; if (getClass() != other.getClass()) return -1; return 0; } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/PartitionKeyValue.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/PartitionKeyValue.java b/fe/src/main/java/org/apache/impala/analysis/PartitionKeyValue.java index b35a567..8b3b556 100644 --- a/fe/src/main/java/org/apache/impala/analysis/PartitionKeyValue.java +++ b/fe/src/main/java/org/apache/impala/analysis/PartitionKeyValue.java @@ -69,7 +69,7 @@ public class PartitionKeyValue { */ public String toPredicateSql() { String ident = ToSqlUtils.getIdentSql(colName_); - if (literalValue_ instanceof NullLiteral || + if (Expr.IS_NULL_LITERAL.apply(literalValue_) || literalValue_.getStringValue().isEmpty()) { return ident + " IS NULL"; } @@ -84,7 +84,8 @@ public class PartitionKeyValue { public static String getPartitionKeyValueString(LiteralExpr literalValue, String nullPartitionKeyValue) { Preconditions.checkNotNull(literalValue); - if (literalValue instanceof NullLiteral || literalValue.getStringValue().isEmpty()) { + if (Expr.IS_NULL_LITERAL.apply(literalValue) || + literalValue.getStringValue().isEmpty()) { return nullPartitionKeyValue; } return literalValue.getStringValue(); http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/PartitionSet.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/PartitionSet.java b/fe/src/main/java/org/apache/impala/analysis/PartitionSet.java index 46a5d7b..1aa30ac 100644 --- a/fe/src/main/java/org/apache/impala/analysis/PartitionSet.java +++ b/fe/src/main/java/org/apache/impala/analysis/PartitionSet.java @@ -152,7 +152,7 @@ public class PartitionSet extends PartitionSpecBase { if (bp.getOp() == Operator.EQ) { SlotRef leftChild = bp.getChild(0) instanceof SlotRef ? ((SlotRef) bp.getChild(0)) : null; - NullLiteral nullChild = bp.getChild(1) instanceof NullLiteral ? + NullLiteral nullChild = Expr.IS_NULL_LITERAL.apply(bp.getChild(1)) ? ((NullLiteral) bp.getChild(1)) : null; StringLiteral stringChild = bp.getChild(1) instanceof StringLiteral ? ((StringLiteral) bp.getChild(1)) : null; http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/PartitionSpec.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/PartitionSpec.java b/fe/src/main/java/org/apache/impala/analysis/PartitionSpec.java index 1a82dca..ac0551d 100644 --- a/fe/src/main/java/org/apache/impala/analysis/PartitionSpec.java +++ b/fe/src/main/java/org/apache/impala/analysis/PartitionSpec.java @@ -88,7 +88,7 @@ public class PartitionSpec extends PartitionSpecBase { throw new AnalysisException(String.format( "Column '%s' is not a partition column in table: %s", pk.getColName(), tableName_)); - } else if (pk.getValue() instanceof NullLiteral) { + } else if (Expr.IS_NULL_LITERAL.apply(pk.getValue())) { // No need for further analysis checks of this partition key value. continue; } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/RangePartition.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/RangePartition.java b/fe/src/main/java/org/apache/impala/analysis/RangePartition.java index e0441f8..515bf24 100644 --- a/fe/src/main/java/org/apache/impala/analysis/RangePartition.java +++ b/fe/src/main/java/org/apache/impala/analysis/RangePartition.java @@ -182,7 +182,7 @@ public class RangePartition implements ParseNode { e.analyze(analyzer); literal = LiteralExpr.create(e, analyzer.getQueryCtx()); Preconditions.checkNotNull(literal); - if (literal.isNullLiteral()) { + if (Expr.IS_NULL_VALUE.apply(literal)) { throw new AnalysisException(String.format("Range partition value %s cannot be " + "cast to target TIMESTAMP partitioning column.", value.toSql())); } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/SelectStmt.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/SelectStmt.java b/fe/src/main/java/org/apache/impala/analysis/SelectStmt.java index ce90cd3..8debd95 100644 --- a/fe/src/main/java/org/apache/impala/analysis/SelectStmt.java +++ b/fe/src/main/java/org/apache/impala/analysis/SelectStmt.java @@ -958,7 +958,7 @@ public class SelectStmt extends QueryStmt { private Expr rewriteCheckOrdinalResult(ExprRewriter rewriter, Expr expr) throws AnalysisException { Expr rewrittenExpr = rewriter.rewrite(expr, analyzer_); - if (rewrittenExpr.isLiteral() && rewrittenExpr.getType().isIntegerType()) { + if (Expr.IS_LITERAL.apply(rewrittenExpr) && rewrittenExpr.getType().isIntegerType()) { return expr; } else { return rewrittenExpr; http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/analysis/TupleIsNullPredicate.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/analysis/TupleIsNullPredicate.java b/fe/src/main/java/org/apache/impala/analysis/TupleIsNullPredicate.java index 25d6c51..b77735e 100644 --- a/fe/src/main/java/org/apache/impala/analysis/TupleIsNullPredicate.java +++ b/fe/src/main/java/org/apache/impala/analysis/TupleIsNullPredicate.java @@ -173,7 +173,7 @@ public class TupleIsNullPredicate extends Predicate { List<Expr> params = fnCallExpr.getParams().exprs(); if (fnCallExpr.getFnName().getFunction().equals("if") && params.get(0) instanceof TupleIsNullPredicate && - params.get(1) instanceof NullLiteral) { + Expr.IS_NULL_LITERAL.apply(params.get(1))) { return unwrapExpr(params.get(2)); } } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/catalog/FeCatalogUtils.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/FeCatalogUtils.java b/fe/src/main/java/org/apache/impala/catalog/FeCatalogUtils.java index 8c865fe..c50f406 100644 --- a/fe/src/main/java/org/apache/impala/catalog/FeCatalogUtils.java +++ b/fe/src/main/java/org/apache/impala/catalog/FeCatalogUtils.java @@ -292,7 +292,7 @@ public abstract class FeCatalogUtils { for (int i = 0; i < partColSql.size(); ++i) { LiteralExpr partVal = part.getPartitionValues().get(i); String partValSql = partVal.toSql(); - if (partVal instanceof NullLiteral || partValSql.isEmpty()) { + if (Expr.IS_NULL_LITERAL.apply(partVal) || partValSql.isEmpty()) { conjuncts.add(partColSql.get(i) + " IS NULL"); } else { conjuncts.add(partColSql.get(i) + "=" + partValSql); http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/catalog/FeFsTable.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/FeFsTable.java b/fe/src/main/java/org/apache/impala/catalog/FeFsTable.java index e9ef929..0c861af 100644 --- a/fe/src/main/java/org/apache/impala/catalog/FeFsTable.java +++ b/fe/src/main/java/org/apache/impala/catalog/FeFsTable.java @@ -26,6 +26,7 @@ import java.util.Set; import java.util.TreeMap; import org.apache.hadoop.hive.metastore.api.FieldSchema; +import org.apache.impala.analysis.Expr; import org.apache.impala.analysis.LiteralExpr; import org.apache.impala.analysis.NullLiteral; import org.apache.impala.analysis.PartitionKeyValue; @@ -409,7 +410,7 @@ public interface FeFsTable extends FeTable { boolean matchFound = true; for (int i = 0; i < targetValues.size(); ++i) { String value; - if (partitionValues.get(i) instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(partitionValues.get(i))) { value = table.getNullPartitionKeyValue(); } else { value = partitionValues.get(i).getStringValue(); http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/catalog/HdfsTable.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/HdfsTable.java b/fe/src/main/java/org/apache/impala/catalog/HdfsTable.java index 1087e87..768e0bf 100644 --- a/fe/src/main/java/org/apache/impala/catalog/HdfsTable.java +++ b/fe/src/main/java/org/apache/impala/catalog/HdfsTable.java @@ -50,6 +50,7 @@ import org.apache.hadoop.hive.metastore.api.FieldSchema; import org.apache.hadoop.hive.metastore.api.Partition; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; import org.apache.hadoop.hive.serde.serdeConstants; +import org.apache.impala.analysis.Expr; import org.apache.impala.analysis.LiteralExpr; import org.apache.impala.analysis.NullLiteral; import org.apache.impala.analysis.NumericLiteral; @@ -1047,7 +1048,7 @@ public class HdfsTable extends Table implements FeFsTable { ColumnStats stats = getColumns().get(i).getStats(); LiteralExpr literal = partition.getPartitionValues().get(i); // Store partitions with null partition values separately - if (literal instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(literal)) { stats.setNumNulls(stats.getNumNulls() + 1); if (nullPartitionIds_.get(i).isEmpty()) { stats.setNumDistinctValues(stats.getNumDistinctValues() + 1); @@ -1105,7 +1106,7 @@ public class HdfsTable extends Table implements FeFsTable { ColumnStats stats = getColumns().get(i).getStats(); LiteralExpr literal = partition.getPartitionValues().get(i); // Check if this is a null literal. - if (literal instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(literal)) { nullPartitionIds_.get(i).remove(partitionId); stats.setNumNulls(stats.getNumNulls() - 1); if (nullPartitionIds_.get(i).isEmpty()) { http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/catalog/local/LocalFsTable.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/catalog/local/LocalFsTable.java b/fe/src/main/java/org/apache/impala/catalog/local/LocalFsTable.java index 3ace234..5b16fbe 100644 --- a/fe/src/main/java/org/apache/impala/catalog/local/LocalFsTable.java +++ b/fe/src/main/java/org/apache/impala/catalog/local/LocalFsTable.java @@ -32,8 +32,8 @@ import org.apache.hadoop.hive.metastore.api.Partition; import org.apache.hadoop.hive.metastore.api.StorageDescriptor; import org.apache.hadoop.hive.metastore.api.Table; import org.apache.hadoop.hive.serde.serdeConstants; +import org.apache.impala.analysis.Expr; import org.apache.impala.analysis.LiteralExpr; -import org.apache.impala.analysis.NullLiteral; import org.apache.impala.catalog.CatalogException; import org.apache.impala.catalog.CatalogObject.ThriftObjectType; import org.apache.impala.catalog.Column; @@ -442,7 +442,7 @@ public class LocalFsTable extends LocalTable implements FeFsTable { List<LiteralExpr> vals = partition.getPartitionValues(); for (int i = 0; i < getNumClusteringCols(); i++) { LiteralExpr val = vals.get(i); - if (val instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(val)) { nullParts.get(i).add(partition.getId()); continue; } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/planner/HdfsPartitionPruner.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/planner/HdfsPartitionPruner.java b/fe/src/main/java/org/apache/impala/planner/HdfsPartitionPruner.java index 1584d44..f2723a6 100644 --- a/fe/src/main/java/org/apache/impala/planner/HdfsPartitionPruner.java +++ b/fe/src/main/java/org/apache/impala/planner/HdfsPartitionPruner.java @@ -193,7 +193,7 @@ public class HdfsPartitionPruner { SlotRef slot = bp.getBoundSlot(); if (slot == null) return false; Expr bindingExpr = bp.getSlotBinding(slot.getSlotId()); - if (bindingExpr == null || !bindingExpr.isLiteral()) return false; + if (bindingExpr == null || !Expr.IS_LITERAL.apply(bindingExpr)) return false; return true; } else if (expr instanceof CompoundPredicate) { boolean res = canEvalUsingPartitionMd(expr.getChild(0), analyzer); @@ -217,7 +217,7 @@ public class HdfsPartitionPruner { SlotRef slot = ((InPredicate)expr).getBoundSlot(); if (slot == null) return false; for (int i = 1; i < expr.getChildren().size(); ++i) { - if (!(expr.getChild(i).isLiteral())) return false; + if (!Expr.IS_LITERAL.apply(expr.getChild(i))) return false; } return true; } @@ -233,7 +233,7 @@ public class HdfsPartitionPruner { Preconditions.checkNotNull(expr); Preconditions.checkState(expr instanceof BinaryPredicate); boolean isSlotOnLeft = true; - if (expr.getChild(0).isLiteral()) isSlotOnLeft = false; + if (Expr.IS_LITERAL.apply(expr.getChild(0))) isSlotOnLeft = false; // Get the operands BinaryPredicate bp = (BinaryPredicate)expr; @@ -241,10 +241,10 @@ public class HdfsPartitionPruner { Preconditions.checkNotNull(slot); Expr bindingExpr = bp.getSlotBinding(slot.getSlotId()); Preconditions.checkNotNull(bindingExpr); - Preconditions.checkState(bindingExpr.isLiteral()); + Preconditions.checkState(Expr.IS_LITERAL.apply(bindingExpr)); LiteralExpr literal = (LiteralExpr)bindingExpr; Operator op = bp.getOp(); - if ((literal instanceof NullLiteral) && (op != Operator.NOT_DISTINCT) + if (Expr.IS_NULL_LITERAL.apply(literal) && (op != Operator.NOT_DISTINCT) && (op != Operator.DISTINCT_FROM)) { return Sets.newHashSet(); } @@ -260,7 +260,7 @@ public class HdfsPartitionPruner { // Compute the matching partition ids if (op == Operator.NOT_DISTINCT) { // Case: SlotRef <=> Literal - if (literal instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(literal)) { Set<Long> ids = tbl_.getNullPartitionIds(partitionPos); if (ids != null) matchingIds.addAll(ids); return matchingIds; @@ -277,7 +277,7 @@ public class HdfsPartitionPruner { if (op == Operator.DISTINCT_FROM) { // Case: SlotRef IS DISTINCT FROM Literal matchingIds.addAll(tbl_.getPartitionIds()); - if (literal instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(literal)) { Set<Long> nullIds = tbl_.getNullPartitionIds(partitionPos); matchingIds.removeAll(nullIds); } else { http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/planner/HdfsScanNode.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/planner/HdfsScanNode.java b/fe/src/main/java/org/apache/impala/planner/HdfsScanNode.java index c1ff092..4338bbc 100644 --- a/fe/src/main/java/org/apache/impala/planner/HdfsScanNode.java +++ b/fe/src/main/java/org/apache/impala/planner/HdfsScanNode.java @@ -513,7 +513,7 @@ public class HdfsScanNode extends ScanNode { // Only constant exprs can be evaluated against parquet::Statistics. This includes // LiteralExpr, but can also be an expr like "1 + 2". if (!constExpr.isConstant()) return; - if (constExpr.isNullLiteral()) return; + if (Expr.IS_NULL_VALUE.apply(constExpr)) return; BinaryPredicate.Operator op = binaryPred.getOp(); if (op == BinaryPredicate.Operator.LT || op == BinaryPredicate.Operator.LE || @@ -545,10 +545,10 @@ public class HdfsScanNode extends ScanNode { Expr child = children.get(i); // If any child is not a literal, then nothing can be done - if (!child.isLiteral()) return; + if (!Expr.IS_LITERAL.apply(child)) return; LiteralExpr literalChild = (LiteralExpr) child; // If any child is NULL, then there is not a valid min/max. Nothing can be done. - if (literalChild instanceof NullLiteral) return; + if (Expr.IS_NULL_LITERAL.apply(literalChild)) return; if (min == null || literalChild.compareTo(min) < 0) min = literalChild; if (max == null || literalChild.compareTo(max) > 0) max = literalChild; http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/planner/KuduScanNode.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/planner/KuduScanNode.java b/fe/src/main/java/org/apache/impala/planner/KuduScanNode.java index fc1f371..348f45f 100644 --- a/fe/src/main/java/org/apache/impala/planner/KuduScanNode.java +++ b/fe/src/main/java/org/apache/impala/planner/KuduScanNode.java @@ -378,7 +378,7 @@ public class KuduScanNode extends ScanNode { LiteralExpr literal = (LiteralExpr) predicate.getChild(1); // Cannot push predicates with null literal values (KUDU-1595). - if (literal instanceof NullLiteral) return false; + if (Expr.IS_NULL_LITERAL.apply(literal)) return false; String colName = ((KuduColumn) ref.getDesc().getColumn()).getKuduName(); ColumnSchema column = table.getSchema().getColumn(colName); @@ -462,11 +462,11 @@ public class KuduScanNode extends ScanNode { // KuduPredicate takes a list of values as Objects. List<Object> values = Lists.newArrayList(); for (int i = 1; i < predicate.getChildren().size(); ++i) { - if (!(predicate.getChild(i).isLiteral())) return false; + if (!Expr.IS_LITERAL.apply(predicate.getChild(i))) return false; LiteralExpr literal = (LiteralExpr) predicate.getChild(i); // Cannot push predicates with null literal values (KUDU-1595). - if (literal instanceof NullLiteral) return false; + if (Expr.IS_NULL_LITERAL.apply(literal)) return false; Object value = getKuduInListValue(analyzer, literal); if (value == null) return false; http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/rewrite/FoldConstantsRule.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/rewrite/FoldConstantsRule.java b/fe/src/main/java/org/apache/impala/rewrite/FoldConstantsRule.java index 3437531..dd0052f 100644 --- a/fe/src/main/java/org/apache/impala/rewrite/FoldConstantsRule.java +++ b/fe/src/main/java/org/apache/impala/rewrite/FoldConstantsRule.java @@ -48,14 +48,14 @@ public class FoldConstantsRule implements ExprRewriteRule { // Avoid calling Expr.isConstant() because that would lead to repeated traversals // of the Expr tree. Assumes the bottom-up application of this rule. Constant // children should have been folded at this point. - for (Expr child: expr.getChildren()) if (!child.isLiteral()) return expr; - if (expr.isLiteral() || !expr.isConstant()) return expr; + for (Expr child: expr.getChildren()) if (!Expr.IS_LITERAL.apply(child)) return expr; + if (Expr.IS_LITERAL.apply(expr) || !expr.isConstant()) return expr; // Do not constant fold cast(null as dataType) because we cannot preserve the // cast-to-types and that can lead to query failures, e.g., CTAS if (expr instanceof CastExpr) { CastExpr castExpr = (CastExpr) expr; - if (castExpr.getChild(0) instanceof NullLiteral) { + if (Expr.IS_NULL_LITERAL.apply(castExpr.getChild(0))) { return expr; } } http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/rewrite/NormalizeCountStarRule.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/rewrite/NormalizeCountStarRule.java b/fe/src/main/java/org/apache/impala/rewrite/NormalizeCountStarRule.java index 2128211..f7d5c57 100644 --- a/fe/src/main/java/org/apache/impala/rewrite/NormalizeCountStarRule.java +++ b/fe/src/main/java/org/apache/impala/rewrite/NormalizeCountStarRule.java @@ -43,8 +43,8 @@ public class NormalizeCountStarRule implements ExprRewriteRule { if (origExpr.getParams().isDistinct()) return expr; if (origExpr.getParams().exprs().size() != 1) return expr; Expr child = origExpr.getChild(0); - if (!child.isLiteral()) return expr; - if (child.isNullLiteral()) return expr; + if (!Expr.IS_LITERAL.apply(child)) return expr; + if (Expr.IS_NULL_VALUE.apply(child)) return expr; FunctionCallExpr result = new FunctionCallExpr(new FunctionName("count"), FunctionParams.createStarParam()); return result; http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/rewrite/RemoveRedundantStringCast.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/rewrite/RemoveRedundantStringCast.java b/fe/src/main/java/org/apache/impala/rewrite/RemoveRedundantStringCast.java index d305f27..97dcdbb 100644 --- a/fe/src/main/java/org/apache/impala/rewrite/RemoveRedundantStringCast.java +++ b/fe/src/main/java/org/apache/impala/rewrite/RemoveRedundantStringCast.java @@ -67,7 +67,7 @@ public class RemoveRedundantStringCast implements ExprRewriteRule { (expr.getChild(0).ignoreImplicitCast() instanceof CastExpr) && expr.getChild(0).ignoreImplicitCast().getType().isStringType() && expr.getChild(1).getType().isStringType() && - expr.getChild(1).isLiteral(); + Expr.IS_LITERAL.apply(expr.getChild(1)); if (!isPotentiallyRedundantCast) return expr; // Ignore the implicit casts added during parsing. @@ -83,7 +83,7 @@ public class RemoveRedundantStringCast implements ExprRewriteRule { // Need to trim() while comparing char(n) types as conversion might add trailing // spaces to the 'resultOfReverseCast'. if (resultOfReverseCast != null && - !resultOfReverseCast.isNullLiteral() && + !Expr.IS_NULL_VALUE.apply(resultOfReverseCast) && resultOfReverseCast.getStringValue().trim() .equals(literalExpr.getStringValue().trim())) { return new BinaryPredicate(op, castExprChild, http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/rewrite/SimplifyConditionalsRule.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/rewrite/SimplifyConditionalsRule.java b/fe/src/main/java/org/apache/impala/rewrite/SimplifyConditionalsRule.java index 1a887b1..2d0c2d9 100644 --- a/fe/src/main/java/org/apache/impala/rewrite/SimplifyConditionalsRule.java +++ b/fe/src/main/java/org/apache/impala/rewrite/SimplifyConditionalsRule.java @@ -92,15 +92,14 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { */ private Expr simplifyIfFunctionCallExpr(FunctionCallExpr expr) { Preconditions.checkState(expr.getChildren().size() == 3); - if (expr.getChild(0) instanceof BoolLiteral) { - if (((BoolLiteral) expr.getChild(0)).getValue()) { - // IF(TRUE) - return expr.getChild(1); - } else { - // IF(FALSE) - return expr.getChild(2); - } - } else if (expr.getChild(0) instanceof NullLiteral) { + Expr head = expr.getChild(0); + if (Expr.IS_TRUE_LITERAL.apply(head)) { + // IF(TRUE) + return expr.getChild(1); + } else if (Expr.IS_FALSE_LITERAL.apply(head)) { + // IF(FALSE) + return expr.getChild(2); + } else if (Expr.IS_NULL_LITERAL.apply(head)) { // IF(NULL) return expr.getChild(2); } @@ -116,8 +115,8 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { private Expr simplifyIfNullFunctionCallExpr(FunctionCallExpr expr) { Preconditions.checkState(expr.getChildren().size() == 2); Expr child0 = expr.getChild(0); - if (child0 instanceof NullLiteral) return expr.getChild(1); - if (child0.isLiteral()) return child0; + if (Expr.IS_NULL_LITERAL.apply(child0)) return expr.getChild(1); + if (Expr.IS_LITERAL.apply(child0)) return child0; return expr; } @@ -132,8 +131,8 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { for (int i = 0; i < numChildren; ++i) { Expr childExpr = expr.getChildren().get(i); // Skip leading nulls. - if (childExpr.isNullLiteral()) continue; - if ((i == numChildren - 1) || childExpr.isLiteral()) { + if (Expr.IS_NULL_VALUE.apply(childExpr)) continue; + if ((i == numChildren - 1) || Expr.IS_LITERAL.apply(childExpr)) { result = childExpr; } else if (i == 0) { result = expr; @@ -178,7 +177,7 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { if (!(leftChild instanceof BoolLiteral)) return expr; if (expr.getOp() == CompoundPredicate.Operator.AND) { - if (((BoolLiteral) leftChild).getValue()) { + if (Expr.IS_TRUE_LITERAL.apply(leftChild)) { // TRUE AND 'expr', so return 'expr'. return expr.getChild(1); } else { @@ -186,7 +185,7 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { return leftChild; } } else if (expr.getOp() == CompoundPredicate.Operator.OR) { - if (((BoolLiteral) leftChild).getValue()) { + if (Expr.IS_TRUE_LITERAL.apply(leftChild)) { // TRUE OR 'expr', so return TRUE. return leftChild; } else { @@ -209,14 +208,14 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { private Expr simplifyCaseExpr(CaseExpr expr, Analyzer analyzer) throws AnalysisException { Expr caseExpr = expr.hasCaseExpr() ? expr.getChild(0) : null; - if (expr.hasCaseExpr() && !caseExpr.isLiteral()) return expr; + if (expr.hasCaseExpr() && !Expr.IS_LITERAL.apply(caseExpr)) return expr; int numChildren = expr.getChildren().size(); int loopStart = expr.hasCaseExpr() ? 1 : 0; // Check and return early if there's nothing that can be simplified. boolean canSimplify = false; for (int i = loopStart; i < numChildren - 1; i += 2) { - if (expr.getChild(i).isLiteral()) { + if (Expr.IS_LITERAL.apply(expr.getChild(i))) { canSimplify = true; break; } @@ -230,11 +229,11 @@ public class SimplifyConditionalsRule implements ExprRewriteRule { Expr elseExpr = null; for (int i = loopStart; i < numChildren - 1; i += 2) { Expr child = expr.getChild(i); - if (child instanceof NullLiteral) continue; + if (Expr.IS_NULL_LITERAL.apply(child)) continue; Expr whenExpr; if (expr.hasCaseExpr()) { - if (child.isLiteral()) { + if (Expr.IS_LITERAL.apply(child)) { BinaryPredicate pred = new BinaryPredicate( BinaryPredicate.Operator.EQ, caseExpr, expr.getChild(i)); pred.analyze(analyzer); http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/main/java/org/apache/impala/service/FeSupport.java ---------------------------------------------------------------------- diff --git a/fe/src/main/java/org/apache/impala/service/FeSupport.java b/fe/src/main/java/org/apache/impala/service/FeSupport.java index 41cd2d9..e67bf9d 100644 --- a/fe/src/main/java/org/apache/impala/service/FeSupport.java +++ b/fe/src/main/java/org/apache/impala/service/FeSupport.java @@ -229,7 +229,7 @@ public class FeSupport { throws InternalException { // Shortcuts to avoid expensive BE evaluation. if (pred instanceof BoolLiteral) return ((BoolLiteral) pred).getValue(); - if (pred instanceof NullLiteral) return false; + if (Expr.IS_NULL_LITERAL.apply(pred)) return false; Preconditions.checkState(pred.getType().isBoolean()); TColumnValue val = EvalExprWithoutRow(pred, queryCtx); // Return false if pred evaluated to false or NULL. True otherwise. http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/test/java/org/apache/impala/analysis/ExprRewriterTest.java ---------------------------------------------------------------------- diff --git a/fe/src/test/java/org/apache/impala/analysis/ExprRewriterTest.java b/fe/src/test/java/org/apache/impala/analysis/ExprRewriterTest.java index 20d4fd9..77595e4 100644 --- a/fe/src/test/java/org/apache/impala/analysis/ExprRewriterTest.java +++ b/fe/src/test/java/org/apache/impala/analysis/ExprRewriterTest.java @@ -45,7 +45,7 @@ public class ExprRewriterTest extends AnalyzerTest { @Override public Expr apply(Expr expr, Analyzer analyzer) throws AnalysisException { if (expr.contains(Subquery.class)) return expr; - if (Predicate.IS_TRUE_LITERAL.apply(expr)) return expr; + if (Expr.IS_TRUE_LITERAL.apply(expr)) return expr; return new BoolLiteral(true); } @@ -60,7 +60,7 @@ public class ExprRewriterTest extends AnalyzerTest { @Override public Expr apply(Expr expr, Analyzer analyzer) throws AnalysisException { - if (Predicate.IS_TRUE_LITERAL.apply(expr)) return new BoolLiteral(false); + if (Expr.IS_TRUE_LITERAL.apply(expr)) return new BoolLiteral(false); return expr; } private TrueToFalseRule() {} http://git-wip-us.apache.org/repos/asf/impala/blob/8dfbe3c8/fe/src/test/java/org/apache/impala/catalog/local/LocalCatalogTest.java ---------------------------------------------------------------------- diff --git a/fe/src/test/java/org/apache/impala/catalog/local/LocalCatalogTest.java b/fe/src/test/java/org/apache/impala/catalog/local/LocalCatalogTest.java index 859ab74..acef882 100644 --- a/fe/src/test/java/org/apache/impala/catalog/local/LocalCatalogTest.java +++ b/fe/src/test/java/org/apache/impala/catalog/local/LocalCatalogTest.java @@ -22,6 +22,7 @@ import static org.junit.Assert.*; import java.util.List; import java.util.Set; +import org.apache.impala.analysis.Expr; import org.apache.impala.analysis.ToSqlUtils; import org.apache.impala.catalog.CatalogTest; import org.apache.impala.catalog.ColumnStats; @@ -142,7 +143,7 @@ public class LocalCatalogTest { assertEquals(1, ids.size()); FeFsPartition partition = FeCatalogUtils.loadPartition( t, Iterables.getOnlyElement(ids)); - assertTrue(partition.getPartitionValue(dayCol).isNullLiteral()); + assertTrue(Expr.IS_NULL_VALUE.apply(partition.getPartitionValue(dayCol))); } @Test
