Repository: phoenix Updated Branches: refs/heads/3.0 80e218c24 -> 9cf34400a
PHOENIX-1030 Change Expression.isDeterministic() to return a enum of values ALWAYS, PER_STATEMENT, PER_ROW (Thomas D'Silva) Project: http://git-wip-us.apache.org/repos/asf/phoenix/repo Commit: http://git-wip-us.apache.org/repos/asf/phoenix/commit/9cf34400 Tree: http://git-wip-us.apache.org/repos/asf/phoenix/tree/9cf34400 Diff: http://git-wip-us.apache.org/repos/asf/phoenix/diff/9cf34400 Branch: refs/heads/3.0 Commit: 9cf34400a1da6520e0573258287049242ed22c10 Parents: 80e218c Author: James Taylor <jtay...@salesforce.com> Authored: Fri Oct 3 22:39:36 2014 -0700 Committer: James Taylor <jtay...@salesforce.com> Committed: Fri Oct 3 22:39:36 2014 -0700 ---------------------------------------------------------------------- .../phoenix/compile/CreateTableCompiler.java | 4 +- .../phoenix/compile/ExpressionCompiler.java | 64 ++++++------- .../apache/phoenix/compile/SequenceManager.java | 5 +- .../apache/phoenix/compile/UpsertCompiler.java | 7 +- .../apache/phoenix/compile/WhereCompiler.java | 3 +- .../apache/phoenix/compile/WhereOptimizer.java | 3 +- .../apache/phoenix/execute/HashJoinPlan.java | 3 +- .../phoenix/expression/AndExpression.java | 6 +- .../expression/BaseCompoundExpression.java | 11 +-- .../phoenix/expression/BaseExpression.java | 6 +- .../expression/ComparisonExpression.java | 34 +++---- .../expression/CurrentDateTimeFunction.java | 4 +- .../apache/phoenix/expression/Determinism.java | 19 ++++ .../apache/phoenix/expression/Expression.java | 6 +- .../phoenix/expression/InListExpression.java | 4 +- .../phoenix/expression/IsNullExpression.java | 4 +- .../phoenix/expression/LiteralExpression.java | 99 +++++++++++--------- .../phoenix/expression/NotExpression.java | 4 +- .../expression/function/AggregateFunction.java | 5 +- .../function/CeilDecimalExpression.java | 8 +- .../expression/function/CoalesceFunction.java | 3 +- .../function/CountAggregateFunction.java | 4 +- .../function/FloorDecimalExpression.java | 8 +- .../function/RoundDateExpression.java | 5 +- .../function/RoundDecimalExpression.java | 5 +- .../function/SingleAggregateFunction.java | 4 +- .../apache/phoenix/parse/FunctionParseNode.java | 10 +- .../org/apache/phoenix/util/ExpressionUtil.java | 28 +++--- .../phoenix/expression/DeterminismTest.java | 37 ++++++++ 29 files changed, 248 insertions(+), 155 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java index 7794416..7a8ebf4 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java @@ -32,6 +32,7 @@ import org.apache.phoenix.exception.SQLExceptionInfo; import org.apache.phoenix.execute.MutationState; import org.apache.phoenix.expression.AndExpression; import org.apache.phoenix.expression.ComparisonExpression; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.IsNullExpression; import org.apache.phoenix.expression.KeyValueColumnExpression; @@ -257,7 +258,8 @@ public class CreateTableCompiler { @Override public Iterator<Expression> visitEnter(ComparisonExpression node) { - if (node.getFilterOp() == CompareOp.EQUAL && node.getChildren().get(1).isStateless() && node.getChildren().get(1).isDeterministic()) { + if (node.getFilterOp() == CompareOp.EQUAL && node.getChildren().get(1).isStateless() + && node.getChildren().get(1).getDeterminism() == Determinism.ALWAYS ) { return Iterators.singletonIterator(node.getChildren().get(0)); } return super.visitEnter(node); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java index bd68ccb..41f6d83 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java @@ -41,6 +41,7 @@ import org.apache.phoenix.expression.DecimalAddExpression; import org.apache.phoenix.expression.DecimalDivideExpression; import org.apache.phoenix.expression.DecimalMultiplyExpression; import org.apache.phoenix.expression.DecimalSubtractExpression; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.DoubleAddExpression; import org.apache.phoenix.expression.DoubleDivideExpression; import org.apache.phoenix.expression.DoubleMultiplyExpression; @@ -223,7 +224,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio private Expression orExpression(List<Expression> children) throws SQLException { Iterator<Expression> iterator = children.iterator(); - boolean isDeterministic = true; + Determinism determinism = Determinism.ALWAYS; while (iterator.hasNext()) { Expression child = iterator.next(); if (child.getDataType() != PDataType.BOOLEAN) { @@ -235,10 +236,10 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio if (LiteralExpression.isTrue(child)) { return child; } - isDeterministic &= child.isDeterministic(); + determinism = determinism.combine(child.getDeterminism()); } if (children.size() == 0) { - return LiteralExpression.newConstant(true, isDeterministic); + return LiteralExpression.newConstant(true, determinism); } if (children.size() == 1) { return children.get(0); @@ -376,12 +377,12 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio @Override public Expression visit(BindParseNode node) throws SQLException { Object value = context.getBindManager().getBindValue(node); - return LiteralExpression.newConstant(value, true); + return LiteralExpression.newConstant(value, Determinism.ALWAYS); } @Override public Expression visit(LiteralParseNode node) throws SQLException { - return LiteralExpression.newConstant(node.getValue(), node.getType(), true); + return LiteralExpression.newConstant(node.getValue(), node.getType(), Determinism.ALWAYS); } @Override @@ -401,13 +402,12 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio return true; } - private static boolean isDeterministic(List<Expression> l) { + private static Determinism getDeterminism(List<Expression> l) { + Determinism determinism = Determinism.ALWAYS; for (Expression e : l) { - if (!e.isDeterministic()) { - return false; - } + determinism.combine(e.getDeterminism()); } - return true; + return determinism; } @Override @@ -423,7 +423,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio ImmutableBytesWritable ptr = context.getTempPtr(); int index = caseExpression.evaluateIndexOf(null, ptr); if (index < 0) { - return LiteralExpression.newConstant(null, isDeterministic(l)); + return LiteralExpression.newConstant(null, getDeterminism(l)); } return caseExpression.getChildren().get(index); } @@ -455,7 +455,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio if (rhs instanceof LiteralExpression) { String pattern = (String)((LiteralExpression)rhs).getValue(); if (pattern == null || pattern.length() == 0) { - return LiteralExpression.newConstant(null, rhs.isDeterministic()); + return LiteralExpression.newConstant(null, rhs.getDeterminism()); } // TODO: for pattern of '%' optimize to strlength(lhs) > 0 // We can't use lhs IS NOT NULL b/c if lhs is NULL we need @@ -464,19 +464,19 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio // Can't possibly be as long as the constant, then FALSE Integer lhsMaxLength = lhs.getMaxLength(); if (lhsMaxLength != null && lhsMaxLength < index) { - return LiteralExpression.newConstant(false, rhs.isDeterministic()); + return LiteralExpression.newConstant(false, rhs.getDeterminism()); } if (index == -1) { String rhsLiteral = LikeExpression.unescapeLike(pattern); if (lhsMaxLength != null && lhsMaxLength != rhsLiteral.length()) { - return LiteralExpression.newConstant(false, rhs.isDeterministic()); + return LiteralExpression.newConstant(false, rhs.getDeterminism()); } if (node.getLikeType() == LikeType.CASE_SENSITIVE) { CompareOp op = node.isNegate() ? CompareOp.NOT_EQUAL : CompareOp.EQUAL; if (pattern.equals(rhsLiteral)) { return new ComparisonExpression(op, children); } else { - rhs = LiteralExpression.newConstant(rhsLiteral, PDataType.CHAR, rhs.isDeterministic()); + rhs = LiteralExpression.newConstant(rhsLiteral, PDataType.CHAR, rhs.getDeterminism()); return new ComparisonExpression(op, Arrays.asList(lhs,rhs)); } } @@ -486,9 +486,9 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio if (ExpressionUtil.isConstant(expression)) { ImmutableBytesWritable ptr = context.getTempPtr(); if (!expression.evaluate(null, ptr)) { - return LiteralExpression.newConstant(null, expression.isDeterministic()); + return LiteralExpression.newConstant(null, expression.getDeterminism()); } else { - return LiteralExpression.newConstant(Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(ptr)) ^ node.isNegate(), expression.isDeterministic()); + return LiteralExpression.newConstant(Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(ptr)) ^ node.isNegate(), expression.getDeterminism()); } } if (node.isNegate()) { @@ -672,7 +672,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio return ExpressionUtil.getConstantExpression(expression, ptr); } else if (isNull) { - return LiteralExpression.newConstant(null, expression.getDataType(), expression.isDeterministic()); + return LiteralExpression.newConstant(null, expression.getDataType(), expression.getDeterminism()); } // Otherwise create and return the expression return wrapGroupByExpression(expression); @@ -721,11 +721,11 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio @Override public Expression create(ArithmeticParseNode node, List<Expression> children) throws SQLException { boolean foundDate = false; - boolean isDeterministic = true; + Determinism determinism = Determinism.ALWAYS; PDataType theType = null; for(int i = 0; i < children.size(); i++) { Expression e = children.get(i); - isDeterministic &= e.isDeterministic(); + determinism = determinism.combine(e.getDeterminism()); PDataType type = e.getDataType(); if (type == null) { continue; @@ -760,7 +760,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio } else if (theType == PDataType.DOUBLE) { return new DoubleAddExpression(children); } else if (theType == null) { - return LiteralExpression.newConstant(null, theType, isDeterministic); + return LiteralExpression.newConstant(null, theType, determinism); } else if (theType == PDataType.TIMESTAMP || theType == PDataType.UNSIGNED_TIMESTAMP) { return new TimestampAddExpression(children); } else if (theType.isCoercibleTo(PDataType.DATE)) { @@ -848,7 +848,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio PDataType theType = null; Expression e1 = children.get(0); Expression e2 = children.get(1); - boolean isDeterministic = e1.isDeterministic() && e2.isDeterministic(); + Determinism determinism = e1.getDeterminism().combine(e2.getDeterminism()); PDataType type1 = e1.getDataType(); PDataType type2 = e2.getDataType(); // TODO: simplify this special case for DATE conversion @@ -900,7 +900,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio // This logic finds the common type to which all child types are coercible // without losing precision. Expression e = children.get(i); - isDeterministic &= e.isDeterministic(); + determinism = determinism.combine(e.getDeterminism()); PDataType type = e.getDataType(); if (type == null) { continue; @@ -933,7 +933,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio } else if (theType == PDataType.DOUBLE) { return new DoubleSubtractExpression(children); } else if (theType == null) { - return LiteralExpression.newConstant(null, theType, isDeterministic); + return LiteralExpression.newConstant(null, theType, determinism); } else if (theType == PDataType.TIMESTAMP || theType == PDataType.UNSIGNED_TIMESTAMP) { return new TimestampSubtractExpression(children); } else if (theType.isCoercibleTo(PDataType.DATE)) { @@ -956,10 +956,10 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio @Override public Expression create(ArithmeticParseNode node, List<Expression> children) throws SQLException { PDataType theType = null; - boolean isDeterministic = true; + Determinism determinism = Determinism.ALWAYS; for(int i = 0; i < children.size(); i++) { Expression e = children.get(i); - isDeterministic &= e.isDeterministic(); + determinism = determinism.combine(e.getDeterminism()); PDataType type = e.getDataType(); if (type == null) { continue; @@ -985,7 +985,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio case DOUBLE: return new DoubleMultiplyExpression( children); default: - return LiteralExpression.newConstant(null, theType, isDeterministic); + return LiteralExpression.newConstant(null, theType, determinism); } } }); @@ -1017,10 +1017,10 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio @Override public Expression create(ArithmeticParseNode node, List<Expression> children) throws SQLException { PDataType theType = null; - boolean isDeterministic = true; + Determinism determinism = Determinism.ALWAYS; for(int i = 0; i < children.size(); i++) { Expression e = children.get(i); - isDeterministic &= e.isDeterministic(); + determinism = determinism.combine(e.getDeterminism()); PDataType type = e.getDataType(); if (type == null) { continue; @@ -1046,7 +1046,7 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio case DOUBLE: return new DoubleDivideExpression(children); default: - return LiteralExpression.newConstant(null, theType, isDeterministic); + return LiteralExpression.newConstant(null, theType, determinism); } } }); @@ -1211,11 +1211,11 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio Expression child = children.get(i); child.evaluate(null, ptr); Object value = arrayElemDataType.toObject(ptr, child.getDataType(), child.getSortOrder()); - elements[i] = LiteralExpression.newConstant(value, child.getDataType(), child.isDeterministic()).getValue(); + elements[i] = LiteralExpression.newConstant(value, child.getDataType(), child.getDeterminism()).getValue(); } Object value = PArrayDataType.instantiatePhoenixArray(arrayElemDataType, elements); return LiteralExpression.newConstant(value, - PDataType.fromTypeId(arrayElemDataType.getSqlType() + PDataType.ARRAY_TYPE_BASE), true); + PDataType.fromTypeId(arrayElemDataType.getSqlType() + PDataType.ARRAY_TYPE_BASE), Determinism.ALWAYS); } return wrapGroupByExpression(arrayExpression); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/compile/SequenceManager.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/SequenceManager.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/SequenceManager.java index de352b5..9be45a4 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/SequenceManager.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/SequenceManager.java @@ -26,6 +26,7 @@ import java.util.Map; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; import org.apache.phoenix.expression.BaseTerminalExpression; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.jdbc.PhoenixStatement; import org.apache.phoenix.parse.SequenceValueParseNode; import org.apache.phoenix.parse.TableName; @@ -202,8 +203,8 @@ public class SequenceManager { } @Override - public boolean isDeterministic() { - return false; + public Determinism getDeterminism() { + return Determinism.PER_ROW; } @Override http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java index b8e1a6d..add8e61 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java @@ -42,6 +42,7 @@ import org.apache.phoenix.exception.SQLExceptionCode; import org.apache.phoenix.exception.SQLExceptionInfo; import org.apache.phoenix.execute.AggregatePlan; import org.apache.phoenix.execute.MutationState; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.hbase.index.util.ImmutableBytesPtr; @@ -511,7 +512,7 @@ public class UpsertCompiler { } // Add literal null for missing PK columns pos = projectedExpressions.size(); - Expression literalNull = LiteralExpression.newConstant(null, column.getDataType(), true); + Expression literalNull = LiteralExpression.newConstant(null, column.getDataType(), Determinism.ALWAYS); projectedExpressions.add(literalNull); allColumnsIndexes[pos] = column.getPosition(); } @@ -812,7 +813,7 @@ public class UpsertCompiler { if (isTopLevel()) { context.getBindManager().addParamMetaData(node, column); Object value = context.getBindManager().getBindValue(node); - return LiteralExpression.newConstant(value, column.getDataType(), column.getSortOrder(), true); + return LiteralExpression.newConstant(value, column.getDataType(), column.getSortOrder(), Determinism.ALWAYS); } return super.visit(node); } @@ -820,7 +821,7 @@ public class UpsertCompiler { @Override public Expression visit(LiteralParseNode node) throws SQLException { if (isTopLevel()) { - return LiteralExpression.newConstant(node.getValue(), column.getDataType(), column.getSortOrder(), true); + return LiteralExpression.newConstant(node.getValue(), column.getDataType(), column.getSortOrder(), Determinism.ALWAYS); } return super.visit(node); } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereCompiler.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereCompiler.java index cd06554..b5f120f 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereCompiler.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereCompiler.java @@ -29,6 +29,7 @@ import org.apache.hadoop.hbase.filter.Filter; import org.apache.phoenix.exception.SQLExceptionCode; import org.apache.phoenix.exception.SQLExceptionInfo; import org.apache.phoenix.expression.AndExpression; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.KeyValueColumnExpression; import org.apache.phoenix.expression.LiteralExpression; @@ -118,7 +119,7 @@ public class WhereCompiler { Set<Expression> extractedNodes = Sets.<Expression>newHashSet(); WhereExpressionCompiler whereCompiler = new WhereExpressionCompiler(context); - Expression expression = where == null ? LiteralExpression.newConstant(true,PDataType.BOOLEAN,true) : where.accept(whereCompiler); + Expression expression = where == null ? LiteralExpression.newConstant(true,PDataType.BOOLEAN,Determinism.ALWAYS) : where.accept(whereCompiler); if (whereCompiler.isAggregate()) { throw new SQLExceptionInfo.Builder(SQLExceptionCode.AGGREGATE_IN_WHERE).build().buildException(); } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java index 634bd15..ec763fd 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java @@ -37,6 +37,7 @@ import org.apache.phoenix.expression.BaseExpression.ExpressionComparabilityWrapp import org.apache.phoenix.expression.BaseTerminalExpression; import org.apache.phoenix.expression.CoerceExpression; import org.apache.phoenix.expression.ComparisonExpression; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.InListExpression; import org.apache.phoenix.expression.IsNullExpression; @@ -407,7 +408,7 @@ public class WhereOptimizer { if (l.size() != node.getChildren().size()) { if (l.isEmpty()) { // Don't return null here, because then our defaultReturn will kick in - return LiteralExpression.newConstant(true, true); + return LiteralExpression.newConstant(true, Determinism.ALWAYS); } if (l.size() == 1) { return l.get(0); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java b/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java index 5ffcaeb..8d141dd 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java @@ -47,6 +47,7 @@ import org.apache.phoenix.exception.SQLExceptionCode; import org.apache.phoenix.exception.SQLExceptionInfo; import org.apache.phoenix.expression.AndExpression; import org.apache.phoenix.expression.ComparisonExpression; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.InListExpression; import org.apache.phoenix.expression.LiteralExpression; @@ -213,7 +214,7 @@ public class HashJoinPlan implements QueryPlan { Expression rhsExpression, List<ImmutableBytesWritable> rhsValues, ImmutableBytesWritable ptr, boolean hasFilters) throws SQLException { if (rhsValues.isEmpty()) - return LiteralExpression.newConstant(null, PDataType.BOOLEAN, true); + return LiteralExpression.newConstant(null, PDataType.BOOLEAN, Determinism.ALWAYS); PDataType type = rhsExpression.getDataType(); if (!useInClause(hasFilters)) { http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/AndExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/AndExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/AndExpression.java index 2806394..e9c2740 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/AndExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/AndExpression.java @@ -37,7 +37,7 @@ public class AndExpression extends AndOrExpression { private static final String AND = "AND"; public static Expression create(List<Expression> children) throws SQLException { - boolean isDeterministic = true; + Determinism determinism = Determinism.ALWAYS; Iterator<Expression> iterator = children.iterator(); while (iterator.hasNext()) { Expression child = iterator.next(); @@ -50,10 +50,10 @@ public class AndExpression extends AndOrExpression { if (LiteralExpression.isTrue(child)) { iterator.remove(); } - isDeterministic &= child.isDeterministic(); + determinism.combine(child.getDeterminism()); } if (children.size() == 0) { - return LiteralExpression.newConstant(true, isDeterministic); + return LiteralExpression.newConstant(true, determinism); } if (children.size() == 1) { return children.get(0); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseCompoundExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseCompoundExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseCompoundExpression.java index 03df653..bd6161c 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseCompoundExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseCompoundExpression.java @@ -34,7 +34,7 @@ public abstract class BaseCompoundExpression extends BaseExpression { protected List<Expression> children; private boolean isNullable; private boolean isStateless; - private boolean isDeterministic; + private Determinism determinism; private boolean requiresFinalEvaluation; public BaseCompoundExpression() { @@ -48,18 +48,17 @@ public abstract class BaseCompoundExpression extends BaseExpression { private void init(List<Expression> children) { this.children = ImmutableList.copyOf(children); boolean isStateless = true; - boolean isDeterministic = true; boolean isNullable = false; boolean requiresFinalEvaluation = false; + this.determinism = Determinism.ALWAYS; for (int i = 0; i < children.size(); i++) { Expression child = children.get(i); isNullable |= child.isNullable(); isStateless &= child.isStateless(); - isDeterministic &= child.isDeterministic(); + this.determinism = this.determinism.combine(child.getDeterminism()); requiresFinalEvaluation |= child.requiresFinalEvaluation(); } this.isStateless = isStateless; - this.isDeterministic = isDeterministic; this.isNullable = isNullable; this.requiresFinalEvaluation = requiresFinalEvaluation; } @@ -71,8 +70,8 @@ public abstract class BaseCompoundExpression extends BaseExpression { @Override - public boolean isDeterministic() { - return isDeterministic; + public Determinism getDeterminism() { + return determinism; } @Override http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseExpression.java index fac82a8..8993e37 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/BaseExpression.java @@ -168,7 +168,7 @@ public abstract class BaseExpression implements Expression { } else if (lhs == null) { return rhs; } else if (rhs == null) { - return LiteralExpression.newConstant(null, lhs.getDataType(), lhs.isDeterministic()); + return LiteralExpression.newConstant(null, lhs.getDataType(), lhs.getDeterminism()); } else { if (rhs.getDataType() != null && lhs.getDataType() != null && !rhs.getDataType().isCastableTo(lhs.getDataType())) { throw TypeMismatchException.newException(lhs.getDataType(), rhs.getDataType()); @@ -239,8 +239,8 @@ public abstract class BaseExpression implements Expression { } @Override - public boolean isDeterministic() { - return true; + public Determinism getDeterminism() { + return Determinism.ALWAYS; } @Override http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/ComparisonExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/ComparisonExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/ComparisonExpression.java index 8e352e6..a1ed221 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/ComparisonExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/ComparisonExpression.java @@ -133,7 +133,7 @@ public class ComparisonExpression extends BaseCompoundExpression { } else if(lhsExprDataType != null && rhsExprDataType != null && !lhsExprDataType.isComparableTo(rhsExprDataType)) { throw TypeMismatchException.newException(lhsExprDataType, rhsExprDataType, toString(op, children)); } - boolean isDeterministic = lhsExpr.isDeterministic() || rhsExpr.isDeterministic(); + Determinism determinism = lhsExpr.getDeterminism().combine(rhsExpr.getDeterminism()); Object lhsValue = null; // Can't use lhsNode.isConstant(), because we have cases in which we don't know @@ -142,7 +142,7 @@ public class ComparisonExpression extends BaseCompoundExpression { if (lhsExpr instanceof LiteralExpression) { lhsValue = ((LiteralExpression)lhsExpr).getValue(); if (lhsValue == null) { - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, lhsExpr.isDeterministic()); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, lhsExpr.getDeterminism()); } } Object rhsValue = null; @@ -150,11 +150,11 @@ public class ComparisonExpression extends BaseCompoundExpression { if (rhsExpr instanceof LiteralExpression) { rhsValue = ((LiteralExpression)rhsExpr).getValue(); if (rhsValue == null) { - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, rhsExpr.isDeterministic()); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, rhsExpr.getDeterminism()); } } if (lhsValue != null && rhsValue != null) { - return LiteralExpression.newConstant(ByteUtil.compare(op,lhsExprDataType.compareTo(lhsValue, rhsValue, rhsExprDataType)), isDeterministic); + return LiteralExpression.newConstant(ByteUtil.compare(op,lhsExprDataType.compareTo(lhsValue, rhsValue, rhsExprDataType)), determinism); } // Coerce constant to match type of lhs so that we don't need to // convert at filter time. Since we normalize the select statement @@ -168,11 +168,11 @@ public class ComparisonExpression extends BaseCompoundExpression { // TODO: if lengths are unequal and fixed width? if (rhsExprDataType.isCoercibleTo(lhsExprDataType, rhsValue)) { // will convert 2.0 -> 2 children = Arrays.asList(children.get(0), LiteralExpression.newConstant(rhsValue, lhsExprDataType, - lhsExpr.getMaxLength(), null, lhsExpr.getSortOrder(), isDeterministic)); + lhsExpr.getMaxLength(), null, lhsExpr.getSortOrder(), determinism)); } else if (op == CompareOp.EQUAL) { - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, true); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, Determinism.ALWAYS); } else if (op == CompareOp.NOT_EQUAL) { - return LiteralExpression.newConstant(true, PDataType.BOOLEAN, true); + return LiteralExpression.newConstant(true, PDataType.BOOLEAN, Determinism.ALWAYS); } else { // TODO: generalize this with PDataType.getMinValue(), PDataTypeType.getMaxValue() methods switch(rhsExprDataType) { case DECIMAL: @@ -190,7 +190,7 @@ public class ComparisonExpression extends BaseCompoundExpression { default: // Else, we truncate the value BigDecimal bd = (BigDecimal)rhsValue; rhsValue = bd.longValue() + increment; - children = Arrays.asList(lhsExpr, LiteralExpression.newConstant(rhsValue, lhsExprDataType, lhsExpr.getSortOrder(), rhsExpr.isDeterministic())); + children = Arrays.asList(lhsExpr, LiteralExpression.newConstant(rhsValue, lhsExprDataType, lhsExpr.getSortOrder(), rhsExpr.getDeterminism())); break; } break; @@ -212,16 +212,16 @@ public class ComparisonExpression extends BaseCompoundExpression { case LESS: case LESS_OR_EQUAL: if ((Long)rhsValue > 0) { - return LiteralExpression.newConstant(true, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(true, PDataType.BOOLEAN, determinism); } else { - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, determinism); } case GREATER: case GREATER_OR_EQUAL: if ((Long)rhsValue > 0) { - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, determinism); } else { - return LiteralExpression.newConstant(true, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(true, PDataType.BOOLEAN, determinism); } default: break; @@ -230,15 +230,15 @@ public class ComparisonExpression extends BaseCompoundExpression { switch (op) { case LESS: case LESS_OR_EQUAL: - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, determinism); case GREATER: case GREATER_OR_EQUAL: - return LiteralExpression.newConstant(true, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(true, PDataType.BOOLEAN, determinism); default: break; } } - children = Arrays.asList(lhsExpr, LiteralExpression.newConstant(rhsValue, rhsExprDataType, lhsExpr.getSortOrder(), isDeterministic)); + children = Arrays.asList(lhsExpr, LiteralExpression.newConstant(rhsValue, rhsExprDataType, lhsExpr.getSortOrder(), determinism)); break; } } @@ -249,9 +249,9 @@ public class ComparisonExpression extends BaseCompoundExpression { if (children.get(1).getMaxLength() != null && lhsExpr.getMaxLength() != null && lhsExpr.getMaxLength() < children.get(1).getMaxLength()) { switch (op) { case EQUAL: - return LiteralExpression.newConstant(false, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(false, PDataType.BOOLEAN, determinism); case NOT_EQUAL: - return LiteralExpression.newConstant(true, PDataType.BOOLEAN, isDeterministic); + return LiteralExpression.newConstant(true, PDataType.BOOLEAN, determinism); default: break; } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/CurrentDateTimeFunction.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/CurrentDateTimeFunction.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/CurrentDateTimeFunction.java index 63e6d23..0b5faa2 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/CurrentDateTimeFunction.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/CurrentDateTimeFunction.java @@ -36,7 +36,7 @@ public abstract class CurrentDateTimeFunction extends ScalarFunction { } @Override - public boolean isDeterministic() { - return false; + public Determinism getDeterminism() { + return Determinism.PER_STATEMENT; } } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/Determinism.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/Determinism.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/Determinism.java new file mode 100644 index 0000000..b2f3524 --- /dev/null +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/Determinism.java @@ -0,0 +1,19 @@ +/* + * 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.phoenix.expression; + +public enum Determinism { + + ALWAYS, PER_STATEMENT, PER_ROW; + + public Determinism combine (Determinism that) { + return Determinism.values()[Math.max(this.ordinal(), that.ordinal())]; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/Expression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/Expression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/Expression.java index ccd4d7b..aeea0c8 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/Expression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/Expression.java @@ -34,6 +34,7 @@ import org.apache.phoenix.schema.tuple.Tuple; * @since 0.1 */ public interface Expression extends PDatum, Writable { + /** * Access the value by setting a pointer to it (as opposed to making * a copy of it which can be expensive) @@ -75,10 +76,9 @@ public interface Expression extends PDatum, Writable { boolean isStateless(); /** - * @return true if the expression returns the same output every - * time given the same input. + * @return Determinism enum */ - boolean isDeterministic(); + Determinism getDeterminism(); /** * Determines if an evaluate is required after partial evaluation http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/InListExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/InListExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/InListExpression.java index c171153..fdb20ff 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/InListExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/InListExpression.java @@ -60,7 +60,7 @@ public class InListExpression extends BaseSingleExpression { Expression firstChild = children.get(0); if (firstChild.isStateless() && (!firstChild.evaluate(null, ptr) || ptr.getLength() == 0)) { - return LiteralExpression.newConstant(null, PDataType.BOOLEAN, firstChild.isDeterministic()); + return LiteralExpression.newConstant(null, PDataType.BOOLEAN, firstChild.getDeterminism()); } if (children.size() == 2) { return ComparisonExpression.create(isNegate ? CompareOp.NOT_EQUAL : CompareOp.EQUAL, children, ptr); @@ -86,7 +86,7 @@ public class InListExpression extends BaseSingleExpression { throw sqlE; } if (coercedKeyExpressions.size() == 2 && addedNull) { - return LiteralExpression.newConstant(null, PDataType.BOOLEAN, true); + return LiteralExpression.newConstant(null, PDataType.BOOLEAN, Determinism.ALWAYS); } Expression expression = new InListExpression(coercedKeyExpressions); if (isNegate) { http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/IsNullExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/IsNullExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/IsNullExpression.java index 4162dfc..3fb7a62 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/IsNullExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/IsNullExpression.java @@ -42,11 +42,11 @@ public class IsNullExpression extends BaseSingleExpression { public static Expression create(Expression child, boolean negate, ImmutableBytesWritable ptr) throws SQLException { if (!child.isNullable()) { - return LiteralExpression.newConstant(negate, PDataType.BOOLEAN, child.isDeterministic()); + return LiteralExpression.newConstant(negate, PDataType.BOOLEAN, child.getDeterminism()); } if (ExpressionUtil.isConstant(child)) { boolean evaluated = child.evaluate(null, ptr); - return LiteralExpression.newConstant(negate ^ (!evaluated || ptr.getLength() == 0), PDataType.BOOLEAN, child.isDeterministic()); + return LiteralExpression.newConstant(negate ^ (!evaluated || ptr.getLength() == 0), PDataType.BOOLEAN, child.getDeterminism()); } return new IsNullExpression(child, negate); } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java index 91a3125..a84135c 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java @@ -48,25 +48,25 @@ import com.google.common.base.Preconditions; * @since 0.1 */ public class LiteralExpression extends BaseTerminalExpression { - public static final LiteralExpression NULL_EXPRESSION = new LiteralExpression(null, true); - private static final LiteralExpression ND_NULL_EXPRESSION = new LiteralExpression(null, false); + public static final LiteralExpression NULL_EXPRESSION = new LiteralExpression(null, Determinism.ALWAYS); + private static final LiteralExpression ND_NULL_EXPRESSION = new LiteralExpression(null, Determinism.PER_ROW); private static final LiteralExpression[] TYPED_NULL_EXPRESSIONS = new LiteralExpression[PDataType.values().length * 2]; static { for (int i = 0; i < PDataType.values().length; i++) { - TYPED_NULL_EXPRESSIONS[i] = new LiteralExpression(PDataType.values()[i], true); + TYPED_NULL_EXPRESSIONS[i] = new LiteralExpression(PDataType.values()[i], Determinism.ALWAYS); } for (int i = 0; i < PDataType.values().length; i++) { - TYPED_NULL_EXPRESSIONS[i+PDataType.values().length] = new LiteralExpression(PDataType.values()[i], false); + TYPED_NULL_EXPRESSIONS[i+PDataType.values().length] = new LiteralExpression(PDataType.values()[i], Determinism.PER_ROW); } } - private static final LiteralExpression FALSE_EXPRESSION = new LiteralExpression(Boolean.FALSE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.FALSE), true); - private static final LiteralExpression TRUE_EXPRESSION = new LiteralExpression(Boolean.TRUE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.TRUE), true); - private static final LiteralExpression ND_FALSE_EXPRESSION = new LiteralExpression(Boolean.FALSE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.FALSE), false); - private static final LiteralExpression ND_TRUE_EXPRESSION = new LiteralExpression(Boolean.TRUE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.TRUE), false); + private static final LiteralExpression FALSE_EXPRESSION = new LiteralExpression(Boolean.FALSE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.FALSE), Determinism.ALWAYS); + private static final LiteralExpression TRUE_EXPRESSION = new LiteralExpression(Boolean.TRUE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.TRUE), Determinism.ALWAYS); + private static final LiteralExpression ND_FALSE_EXPRESSION = new LiteralExpression(Boolean.FALSE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.FALSE), Determinism.PER_ROW); + private static final LiteralExpression ND_TRUE_EXPRESSION = new LiteralExpression(Boolean.TRUE, PDataType.BOOLEAN, PDataType.BOOLEAN.toBytes(Boolean.TRUE), Determinism.PER_ROW); private Object value; private PDataType type; - private boolean isDeterministic; + private Determinism determinism; private byte[] byteValue; private Integer maxLength; private Integer scale; @@ -82,24 +82,24 @@ public class LiteralExpression extends BaseTerminalExpression { } public static LiteralExpression newConstant(Object value) { - return newConstant(value, true); + return newConstant(value, Determinism.ALWAYS); } // TODO: cache? - public static LiteralExpression newConstant(Object value, boolean isDeterministic) { + public static LiteralExpression newConstant(Object value, Determinism determinism) { if (Boolean.FALSE.equals(value)) { - return isDeterministic ? FALSE_EXPRESSION : ND_FALSE_EXPRESSION; + return determinism == Determinism.ALWAYS ? FALSE_EXPRESSION : ND_FALSE_EXPRESSION; } if (Boolean.TRUE.equals(value)) { - return isDeterministic ? TRUE_EXPRESSION : ND_TRUE_EXPRESSION; + return determinism == Determinism.ALWAYS ? TRUE_EXPRESSION : ND_TRUE_EXPRESSION; } if (value == null) { - return isDeterministic ? NULL_EXPRESSION : ND_NULL_EXPRESSION; + return determinism == Determinism.ALWAYS ? NULL_EXPRESSION : ND_NULL_EXPRESSION; } PDataType type = PDataType.fromLiteral(value); byte[] b = type.toBytes(value); if (type.isNull(b)) { - return TYPED_NULL_EXPRESSIONS[type.ordinal() + ( isDeterministic ? 0 : TYPED_NULL_EXPRESSIONS.length/2)]; + return TYPED_NULL_EXPRESSIONS[type.ordinal() + ( determinism == Determinism.ALWAYS ? 0 : TYPED_NULL_EXPRESSIONS.length/2)]; } if (type == PDataType.VARCHAR) { String s = (String) value; @@ -107,35 +107,35 @@ public class LiteralExpression extends BaseTerminalExpression { type = PDataType.CHAR; } } - return new LiteralExpression(value, type, b, isDeterministic); + return new LiteralExpression(value, type, b, determinism); } public static LiteralExpression newConstant(Object value, PDataType type) throws SQLException { - return newConstant(value, type, true); + return newConstant(value, type, Determinism.ALWAYS); } - public static LiteralExpression newConstant(Object value, PDataType type, boolean isDeterministic) throws SQLException { - return newConstant(value, type, SortOrder.getDefault(), isDeterministic); + public static LiteralExpression newConstant(Object value, PDataType type, Determinism determinism) throws SQLException { + return newConstant(value, type, SortOrder.getDefault(), determinism); } public static LiteralExpression newConstant(Object value, PDataType type, SortOrder sortOrder) throws SQLException { - return newConstant(value, type, null, null, sortOrder, true); + return newConstant(value, type, null, null, sortOrder, Determinism.ALWAYS); } - public static LiteralExpression newConstant(Object value, PDataType type, SortOrder sortOrder, boolean isDeterministic) throws SQLException { - return newConstant(value, type, null, null, sortOrder, isDeterministic); + public static LiteralExpression newConstant(Object value, PDataType type, SortOrder sortOrder, Determinism determinism) throws SQLException { + return newConstant(value, type, null, null, sortOrder, determinism); } public static LiteralExpression newConstant(Object value, PDataType type, Integer maxLength, Integer scale) throws SQLException { - return newConstant(value, type, maxLength, scale, SortOrder.getDefault(), true); + return newConstant(value, type, maxLength, scale, SortOrder.getDefault(), Determinism.ALWAYS); } - public static LiteralExpression newConstant(Object value, PDataType type, Integer maxLength, Integer scale, boolean isDeterministic) throws SQLException { // remove? - return newConstant(value, type, maxLength, scale, SortOrder.getDefault(), isDeterministic); + public static LiteralExpression newConstant(Object value, PDataType type, Integer maxLength, Integer scale, Determinism determinism) throws SQLException { // remove? + return newConstant(value, type, maxLength, scale, SortOrder.getDefault(), determinism); } // TODO: cache? - public static LiteralExpression newConstant(Object value, PDataType type, Integer maxLength, Integer scale, SortOrder sortOrder, boolean isDeterministic) + public static LiteralExpression newConstant(Object value, PDataType type, Integer maxLength, Integer scale, SortOrder sortOrder, Determinism determinism) throws SQLException { if (value == null) { if (type == null) { @@ -144,10 +144,10 @@ public class LiteralExpression extends BaseTerminalExpression { return TYPED_NULL_EXPRESSIONS[type.ordinal()]; } if (Boolean.FALSE.equals(value)) { - return isDeterministic ? FALSE_EXPRESSION : ND_FALSE_EXPRESSION; + return determinism == Determinism.ALWAYS ? FALSE_EXPRESSION : ND_FALSE_EXPRESSION; } if (Boolean.TRUE.equals(value)) { - return isDeterministic ? TRUE_EXPRESSION : ND_TRUE_EXPRESSION; + return determinism == Determinism.ALWAYS ? TRUE_EXPRESSION : ND_TRUE_EXPRESSION; } PDataType actualType = PDataType.fromLiteral(value); // For array we should check individual element in it? @@ -173,7 +173,7 @@ public class LiteralExpression extends BaseTerminalExpression { if (maxLength == null) { maxLength = type == null || !type.isFixedWidth() ? null : type.getMaxLength(value); } - return new LiteralExpression(value, type, b, maxLength, scale, sortOrder, isDeterministic); + return new LiteralExpression(value, type, b, maxLength, scale, sortOrder, determinism); } catch (IllegalDataException e) { throw new SQLExceptionInfo.Builder(SQLExceptionCode.ILLEGAL_DATA).setRootCause(e).build().buildException(); } @@ -182,16 +182,16 @@ public class LiteralExpression extends BaseTerminalExpression { public LiteralExpression() { } - private LiteralExpression(PDataType type, boolean isDeterministic) { - this(null, type, ByteUtil.EMPTY_BYTE_ARRAY, isDeterministic); + private LiteralExpression(PDataType type, Determinism determinism) { + this(null, type, ByteUtil.EMPTY_BYTE_ARRAY, determinism); } - private LiteralExpression(Object value, PDataType type, byte[] byteValue, boolean isDeterministic) { - this(value, type, byteValue, type == null || !type.isFixedWidth() ? null : type.getMaxLength(value), null, SortOrder.getDefault(), isDeterministic); + private LiteralExpression(Object value, PDataType type, byte[] byteValue, Determinism determinism) { + this(value, type, byteValue, type == null || !type.isFixedWidth() ? null : type.getMaxLength(value), null, SortOrder.getDefault(), determinism); } private LiteralExpression(Object value, PDataType type, byte[] byteValue, - Integer maxLength, Integer scale, SortOrder sortOrder, boolean isDeterministic) { + Integer maxLength, Integer scale, SortOrder sortOrder, Determinism deterministic) { Preconditions.checkNotNull(sortOrder); this.value = value; this.type = type; @@ -199,12 +199,12 @@ public class LiteralExpression extends BaseTerminalExpression { this.maxLength = maxLength; this.scale = scale != null ? scale : type == null ? null : type.getScale(value); this.sortOrder = sortOrder; - this.isDeterministic = isDeterministic; + this.determinism = deterministic; } @Override - public boolean isDeterministic() { - return isDeterministic; + public Determinism getDeterminism() { + return determinism; } @Override @@ -234,12 +234,22 @@ public class LiteralExpression extends BaseTerminalExpression { @Override public void readFields(DataInput input) throws IOException { - int encodedByteLengthAndBool = WritableUtils.readVInt(input); - this.isDeterministic = encodedByteLengthAndBool > 0; + int encodedByteLengthAndBool = WritableUtils.readVInt(input); int byteLength = Math.abs(encodedByteLengthAndBool)-1; this.byteValue = new byte[byteLength]; input.readFully(byteValue, 0, byteLength); - sortOrder = SortOrder.fromSystemValue(WritableUtils.readVInt(input)); + int sortOrderAndDeterminism = WritableUtils.readVInt(input); + if (sortOrderAndDeterminism<=2) { + //client is on an older version + this.determinism = encodedByteLengthAndBool > 0 ? Determinism.ALWAYS : Determinism.PER_ROW; + this.sortOrder = SortOrder.fromSystemValue(sortOrderAndDeterminism);; + } + else { + int determinismOrdinal = (sortOrderAndDeterminism>>2)-1; + this.determinism = Determinism.values()[determinismOrdinal]; + int sortOrderValue = sortOrderAndDeterminism & ((1 << 2) - 1); //get the least 2 significant bits + this.sortOrder = SortOrder.fromSystemValue(sortOrderValue); + } int typeOrdinal = WritableUtils.readVInt(input); if (typeOrdinal < 0) { this.type = null; @@ -255,10 +265,13 @@ public class LiteralExpression extends BaseTerminalExpression { @Override public void write(DataOutput output) throws IOException { - WritableUtils.writeVInt(output, (byteValue.length + 1) * (this.isDeterministic ? 1 : -1)); + WritableUtils.writeVInt(output, (byteValue.length + 1) * (this.determinism==Determinism.ALWAYS ? 1 : -1)); output.write(byteValue); - WritableUtils.writeVInt(output, sortOrder.getSystemValue()); - WritableUtils.writeVInt(output, type == null ? -1 : this.type.ordinal()); + // since we need to support clients of a lower version, serialize the determinism enum ordinal in the int used to + // serialize sort order system value (which is either 1 or 2) + int sortOrderAndDeterminism = ((this.determinism.ordinal()+1)<<2) + sortOrder.getSystemValue(); + WritableUtils.writeVInt(output, sortOrderAndDeterminism); + WritableUtils.writeVInt(output, this.type == null ? -1 : this.type.ordinal()); } @Override http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/NotExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/NotExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/NotExpression.java index e25f1e2..0c17ab8 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/NotExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/NotExpression.java @@ -43,9 +43,9 @@ public class NotExpression extends BaseSingleExpression { } if (child.isStateless()) { if (!child.evaluate(null, ptr) || ptr.getLength() == 0) { - return LiteralExpression.newConstant(null, PDataType.BOOLEAN, child.isDeterministic()); + return LiteralExpression.newConstant(null, PDataType.BOOLEAN, child.getDeterminism()); } - return LiteralExpression.newConstant(!(Boolean)PDataType.BOOLEAN.toObject(ptr), PDataType.BOOLEAN, child.isDeterministic()); + return LiteralExpression.newConstant(!(Boolean)PDataType.BOOLEAN.toObject(ptr), PDataType.BOOLEAN, child.getDeterminism()); } return new NotExpression(child); } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/AggregateFunction.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/AggregateFunction.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/AggregateFunction.java index 257890c..32cae19 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/AggregateFunction.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/AggregateFunction.java @@ -19,6 +19,7 @@ package org.apache.phoenix.expression.function; import java.util.List; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; @@ -46,7 +47,7 @@ abstract public class AggregateFunction extends FunctionExpression { } @Override - public boolean isDeterministic() { - return false; + public Determinism getDeterminism() { + return Determinism.PER_ROW; } } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CeilDecimalExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CeilDecimalExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CeilDecimalExpression.java index d6b4e45..bd36d0f 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CeilDecimalExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CeilDecimalExpression.java @@ -21,13 +21,17 @@ import java.math.RoundingMode; import java.sql.SQLException; import java.util.List; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.schema.PDataType; import com.google.common.collect.Lists; + import java.math.BigDecimal; + import org.apache.phoenix.query.KeyRange; + import static org.apache.phoenix.schema.PDataType.DECIMAL; /** @@ -53,7 +57,7 @@ public class CeilDecimalExpression extends RoundDecimalExpression { if (expr.getDataType().isCoercibleTo(PDataType.LONG)) { return expr; } - Expression scaleExpr = LiteralExpression.newConstant(scale, PDataType.INTEGER, true); + Expression scaleExpr = LiteralExpression.newConstant(scale, PDataType.INTEGER, Determinism.ALWAYS); List<Expression> expressions = Lists.newArrayList(expr, scaleExpr); return new CeilDecimalExpression(expressions); } @@ -64,7 +68,7 @@ public class CeilDecimalExpression extends RoundDecimalExpression { return expr; } if (exprs.size() == 1) { - Expression scaleExpr = LiteralExpression.newConstant(0, PDataType.INTEGER, true); + Expression scaleExpr = LiteralExpression.newConstant(0, PDataType.INTEGER, Determinism.ALWAYS); exprs = Lists.newArrayList(expr, scaleExpr); } return new CeilDecimalExpression(exprs); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CoalesceFunction.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CoalesceFunction.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CoalesceFunction.java index 87fc908..2eef8b3 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CoalesceFunction.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CoalesceFunction.java @@ -30,6 +30,7 @@ import org.apache.phoenix.parse.FunctionParseNode.Argument; import org.apache.phoenix.parse.FunctionParseNode.BuiltInFunction; import org.apache.phoenix.schema.PDataType; import org.apache.phoenix.schema.tuple.Tuple; +import org.apache.phoenix.util.ExpressionUtil; /** @@ -59,7 +60,7 @@ public class CoalesceFunction extends ScalarFunction { Expression firstChild = children.get(0); Expression secondChild = children.get(1); - if (secondChild.isStateless() && secondChild.isDeterministic()) { // is literal + if (ExpressionUtil.isConstant(secondChild)) { // is literal ImmutableBytesWritable ptr = new ImmutableBytesPtr(); secondChild.evaluate(null, ptr); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CountAggregateFunction.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CountAggregateFunction.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CountAggregateFunction.java index b7a5861..f1e8ab5 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CountAggregateFunction.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/CountAggregateFunction.java @@ -22,7 +22,7 @@ import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; - +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.expression.aggregator.Aggregator; @@ -45,7 +45,7 @@ import org.apache.phoenix.util.SchemaUtil; @BuiltInFunction(name=CountAggregateFunction.NAME, args= {@Argument()} ) public class CountAggregateFunction extends SingleAggregateFunction { public static final String NAME = "COUNT"; - public static final List<Expression> STAR = Arrays.<Expression>asList(LiteralExpression.newConstant(1, true)); + public static final List<Expression> STAR = Arrays.<Expression>asList(LiteralExpression.newConstant(1, Determinism.ALWAYS)); public static final String NORMALIZED_NAME = SchemaUtil.normalizeIdentifier(NAME); public CountAggregateFunction() { http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/FloorDecimalExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/FloorDecimalExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/FloorDecimalExpression.java index b5566ca..037fcc5 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/FloorDecimalExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/FloorDecimalExpression.java @@ -21,13 +21,17 @@ import java.math.RoundingMode; import java.sql.SQLException; import java.util.List; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.schema.PDataType; import com.google.common.collect.Lists; + import java.math.BigDecimal; + import org.apache.phoenix.query.KeyRange; + import static org.apache.phoenix.schema.PDataType.DECIMAL; /** @@ -54,7 +58,7 @@ public class FloorDecimalExpression extends RoundDecimalExpression { if (expr.getDataType().isCoercibleTo(PDataType.LONG)) { return expr; } - Expression scaleExpr = LiteralExpression.newConstant(scale, PDataType.INTEGER, true); + Expression scaleExpr = LiteralExpression.newConstant(scale, PDataType.INTEGER, Determinism.ALWAYS); List<Expression> expressions = Lists.newArrayList(expr, scaleExpr); return new FloorDecimalExpression(expressions); } @@ -65,7 +69,7 @@ public class FloorDecimalExpression extends RoundDecimalExpression { return expr; } if (exprs.size() == 1) { - Expression scaleExpr = LiteralExpression.newConstant(0, PDataType.INTEGER, true); + Expression scaleExpr = LiteralExpression.newConstant(0, PDataType.INTEGER, Determinism.ALWAYS); exprs = Lists.newArrayList(expr, scaleExpr); } return new FloorDecimalExpression(exprs); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDateExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDateExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDateExpression.java index f928218..58ff652 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDateExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDateExpression.java @@ -29,6 +29,7 @@ import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; import org.apache.hadoop.io.WritableUtils; import org.apache.phoenix.compile.KeyPart; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.query.KeyRange; @@ -92,11 +93,11 @@ public class RoundDateExpression extends ScalarFunction { } static Expression getTimeUnitExpr(TimeUnit timeUnit) throws SQLException { - return LiteralExpression.newConstant(timeUnit.name(), PDataType.VARCHAR, true); + return LiteralExpression.newConstant(timeUnit.name(), PDataType.VARCHAR, Determinism.ALWAYS); } static Expression getMultiplierExpr(int multiplier) throws SQLException { - return LiteralExpression.newConstant(multiplier, PDataType.INTEGER, true); + return LiteralExpression.newConstant(multiplier, PDataType.INTEGER, Determinism.ALWAYS); } RoundDateExpression(List<Expression> children) { http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDecimalExpression.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDecimalExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDecimalExpression.java index 7e76234..713bfad 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDecimalExpression.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/RoundDecimalExpression.java @@ -32,6 +32,7 @@ import org.apache.hadoop.hbase.filter.CompareFilter; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; import org.apache.hadoop.io.WritableUtils; import org.apache.phoenix.compile.KeyPart; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.query.KeyRange; @@ -62,7 +63,7 @@ public class RoundDecimalExpression extends ScalarFunction { if (expr.getDataType().isCoercibleTo(PDataType.LONG)) { return expr; } - Expression scaleExpr = LiteralExpression.newConstant(scale, PDataType.INTEGER, true); + Expression scaleExpr = LiteralExpression.newConstant(scale, PDataType.INTEGER, Determinism.ALWAYS); List<Expression> expressions = Lists.newArrayList(expr, scaleExpr); return new RoundDecimalExpression(expressions); } @@ -81,7 +82,7 @@ public class RoundDecimalExpression extends ScalarFunction { return expr; } if (exprs.size() == 1) { - Expression scaleExpr = LiteralExpression.newConstant(0, PDataType.INTEGER, true); + Expression scaleExpr = LiteralExpression.newConstant(0, PDataType.INTEGER, Determinism.ALWAYS); exprs = Lists.newArrayList(expr, scaleExpr); } return new RoundDecimalExpression(exprs); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/expression/function/SingleAggregateFunction.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/SingleAggregateFunction.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/SingleAggregateFunction.java index 154bdf8..d33d555 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/SingleAggregateFunction.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/SingleAggregateFunction.java @@ -25,7 +25,7 @@ import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; - +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.expression.aggregator.Aggregator; @@ -43,7 +43,7 @@ import org.apache.phoenix.schema.tuple.Tuple; * @since 0.1 */ abstract public class SingleAggregateFunction extends AggregateFunction { - private static final List<Expression> DEFAULT_EXPRESSION_LIST = Arrays.<Expression>asList(LiteralExpression.newConstant(1, true)); + private static final List<Expression> DEFAULT_EXPRESSION_LIST = Arrays.<Expression>asList(LiteralExpression.newConstant(1, Determinism.ALWAYS)); protected boolean isConstant; private Aggregator aggregator; http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/parse/FunctionParseNode.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/parse/FunctionParseNode.java b/phoenix-core/src/main/java/org/apache/phoenix/parse/FunctionParseNode.java index 10c7208..ea8c1fb 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/parse/FunctionParseNode.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/parse/FunctionParseNode.java @@ -33,7 +33,9 @@ import java.util.Set; import org.apache.http.annotation.Immutable; import com.google.common.collect.ImmutableSet; + import org.apache.phoenix.compile.StatementContext; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.expression.function.AggregateFunction; @@ -137,7 +139,7 @@ public class FunctionParseNode extends CompoundParseNode { if (args.length > children.size()) { List<Expression> moreChildren = new ArrayList<Expression>(children); for (int i = children.size(); i < info.getArgs().length; i++) { - moreChildren.add(LiteralExpression.newConstant(null, args[i].allowedTypes.length == 0 ? null : args[i].allowedTypes[0], true)); + moreChildren.add(LiteralExpression.newConstant(null, args[i].allowedTypes.length == 0 ? null : args[i].allowedTypes[0], Determinism.ALWAYS)); } children = moreChildren; } @@ -174,7 +176,7 @@ public class FunctionParseNode extends CompoundParseNode { // based on the function argument annonation set the parameter meta data. if (child.getDataType() == null) { if (allowedTypes.length > 0) { - context.getBindManager().addParamMetaData(bindNode, LiteralExpression.newConstant(null, allowedTypes[0], true)); + context.getBindManager().addParamMetaData(bindNode, LiteralExpression.newConstant(null, allowedTypes[0], Determinism.ALWAYS)); } } else { // Use expression as is, since we already have the data type set context.getBindManager().addParamMetaData(bindNode, child); @@ -376,11 +378,11 @@ public class FunctionParseNode extends CompoundParseNode { SQLParser parser = new SQLParser(strValue); try { LiteralParseNode node = parser.parseLiteral(); - LiteralExpression defaultValue = LiteralExpression.newConstant(node.getValue(), this.allowedTypes[0], true); + LiteralExpression defaultValue = LiteralExpression.newConstant(node.getValue(), this.allowedTypes[0], Determinism.ALWAYS); if (this.getAllowedTypes().length > 0) { for (PDataType type : this.getAllowedTypes()) { if (defaultValue.getDataType() == null || defaultValue.getDataType().isCoercibleTo(type, node.getValue())) { - return LiteralExpression.newConstant(node.getValue(), type, true); + return LiteralExpression.newConstant(node.getValue(), type, Determinism.ALWAYS); } } throw new IllegalStateException("Unable to coerce default value " + strValue + " to any of the allowed types of " + Arrays.toString(this.getAllowedTypes())); http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/main/java/org/apache/phoenix/util/ExpressionUtil.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/util/ExpressionUtil.java b/phoenix-core/src/main/java/org/apache/phoenix/util/ExpressionUtil.java index 227a385..eac396b 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/util/ExpressionUtil.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/util/ExpressionUtil.java @@ -13,6 +13,7 @@ import java.sql.SQLException; import java.util.List; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; +import org.apache.phoenix.expression.Determinism; import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.LiteralExpression; import org.apache.phoenix.expression.function.CurrentDateFunction; @@ -24,16 +25,20 @@ import com.google.common.collect.Lists; public class ExpressionUtil { - @SuppressWarnings("unchecked") - private static final List<Class<? extends FunctionExpression>> OVERRIDE_LITERAL_FUNCTIONS = Lists - .<Class<? extends FunctionExpression>> newArrayList(CurrentDateFunction.class, CurrentTimeFunction.class); + @SuppressWarnings("unchecked") + private static final List<Class<? extends FunctionExpression>> OVERRIDE_LITERAL_FUNCTIONS = Lists + .<Class<? extends FunctionExpression>> newArrayList( + CurrentDateFunction.class, CurrentTimeFunction.class); - private ExpressionUtil() {} + private ExpressionUtil() { + } - public static boolean isConstant(Expression expression) { - return (expression.isStateless() && expression.isDeterministic() || OVERRIDE_LITERAL_FUNCTIONS - .contains(expression.getClass())); - } + public static boolean isConstant(Expression expression) { + return (expression.isStateless() && (expression.getDeterminism() == Determinism.ALWAYS + || expression.getDeterminism() == Determinism.PER_STATEMENT + // TODO remove this in 3.4/4.4 (need to support clients on 3.1/4.1) + || OVERRIDE_LITERAL_FUNCTIONS.contains(expression.getClass()))); + } public static LiteralExpression getConstantExpression(Expression expression, ImmutableBytesWritable ptr) throws SQLException { @@ -42,16 +47,15 @@ public class ExpressionUtil { if (expression.evaluate(null, ptr) && ptr.getLength() != 0) { value = type.toObject(ptr); } - return LiteralExpression.newConstant(value, type, expression.isDeterministic()); + return LiteralExpression.newConstant(value, type, expression.getDeterminism()); } public static boolean isNull(Expression expression, ImmutableBytesWritable ptr) { - return expression.isStateless() && expression.isDeterministic() - && (!expression.evaluate(null, ptr) || ptr.getLength() == 0); + return isConstant(expression) && (!expression.evaluate(null, ptr) || ptr.getLength() == 0); } public static LiteralExpression getNullExpression(Expression expression) throws SQLException { - return LiteralExpression.newConstant(null, expression.getDataType(), expression.isDeterministic()); + return LiteralExpression.newConstant(null, expression.getDataType(), expression.getDeterminism()); } } http://git-wip-us.apache.org/repos/asf/phoenix/blob/9cf34400/phoenix-core/src/test/java/org/apache/phoenix/expression/DeterminismTest.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/test/java/org/apache/phoenix/expression/DeterminismTest.java b/phoenix-core/src/test/java/org/apache/phoenix/expression/DeterminismTest.java new file mode 100644 index 0000000..4e4a648 --- /dev/null +++ b/phoenix-core/src/test/java/org/apache/phoenix/expression/DeterminismTest.java @@ -0,0 +1,37 @@ +/* + * 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.phoenix.expression; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +public class DeterminismTest { + @Test + public void testCombine() { + // combining a determinism enum with ALWAYS should always return the + // other determinism + assertEquals("Unexpected result ", Determinism.PER_ROW, + Determinism.ALWAYS.combine(Determinism.PER_ROW)); + assertEquals("Unexpected result ", Determinism.PER_STATEMENT, + Determinism.ALWAYS.combine(Determinism.PER_STATEMENT)); + assertEquals("Unexpected result ", Determinism.PER_STATEMENT, + Determinism.PER_STATEMENT.combine(Determinism.ALWAYS)); + assertEquals("Unexpected result ", Determinism.PER_ROW, + Determinism.PER_ROW.combine(Determinism.ALWAYS)); + + // combining PER_STATEMENT and PER_ROW should return PER_ROW + assertEquals("Unexpected result ", Determinism.PER_ROW, + Determinism.PER_STATEMENT.combine(Determinism.PER_ROW)); + assertEquals("Unexpected result ", Determinism.PER_ROW, + Determinism.PER_ROW.combine(Determinism.PER_STATEMENT)); + + } +}
