Repository: phoenix Updated Branches: refs/heads/master f88cbf839 -> a4d498f34
Revert "PHOENIX-2965 Use DistinctPrefixFilter logic for COUNT(DISTINCT ...) and COUNT(...) GROUP BY." This reverts commit e7e8e130b4ec84b32ed507201c1a00939f1d3b7c. Project: http://git-wip-us.apache.org/repos/asf/phoenix/repo Commit: http://git-wip-us.apache.org/repos/asf/phoenix/commit/a4d498f3 Tree: http://git-wip-us.apache.org/repos/asf/phoenix/tree/a4d498f3 Diff: http://git-wip-us.apache.org/repos/asf/phoenix/diff/a4d498f3 Branch: refs/heads/master Commit: a4d498f349193610003b888fc501f5ce146e99b0 Parents: f88cbf8 Author: Lars Hofhansl <la...@apache.org> Authored: Fri Jun 10 19:23:19 2016 -0700 Committer: Lars Hofhansl <la...@apache.org> Committed: Fri Jun 10 19:23:19 2016 -0700 ---------------------------------------------------------------------- .../phoenix/end2end/DistinctPrefixFilterIT.java | 165 ++++++++++--------- .../apache/phoenix/compile/GroupByCompiler.java | 44 ++--- .../phoenix/compile/OrderPreservingTracker.java | 15 -- .../phoenix/iterate/BaseResultIterators.java | 2 +- 4 files changed, 102 insertions(+), 124 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/phoenix/blob/a4d498f3/phoenix-core/src/it/java/org/apache/phoenix/end2end/DistinctPrefixFilterIT.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/DistinctPrefixFilterIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/DistinctPrefixFilterIT.java index 45eb798..c2776ed 100644 --- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/DistinctPrefixFilterIT.java +++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/DistinctPrefixFilterIT.java @@ -19,10 +19,9 @@ import org.junit.BeforeClass; import org.junit.Test; public class DistinctPrefixFilterIT extends BaseHBaseManagedTimeTableReuseIT { - private static final String testTableF = generateRandomString(); - private static final String testTableV = generateRandomString(); - private static final String testSeq = testTableF + "_seq"; - private static final String PREFIX = "SERVER DISTINCT PREFIX"; + private static String testTableF = generateRandomString(); + private static String testTableV = generateRandomString(); + private static String testSeq = testTableF + "_seq"; private static Connection conn; @BeforeClass @@ -119,53 +118,104 @@ public class DistinctPrefixFilterIT extends BaseHBaseManagedTimeTableReuseIT { @Test public void testPlans() throws Exception { + final String PREFIX = "SERVER DISTINCT PREFIX"; + // use the filter even when the SkipScan filter is used - testPlan("SELECT DISTINCT prefix1, prefix2 FROM "+testTableF+ " WHERE prefix1 IN (1,2)", true); - testPlan("SELECT prefix1, 1, 2 FROM "+testTableF+" GROUP BY prefix1 HAVING prefix1 = 1", true); - testPlan("SELECT prefix1 FROM "+testTableF+" GROUP BY prefix1, TRUNC(prefix1), TRUNC(prefix2)", true); - testPlan("SELECT DISTINCT prefix1, prefix2 FROM "+testTableV+ " WHERE prefix1 IN ('1','2')", true); - testPlan("SELECT prefix1, 1, 2 FROM "+testTableV+" GROUP BY prefix1 HAVING prefix1 = '1'", true); - // make sure we do not mis-optimize this case - testPlan("SELECT DISTINCT SUM(prefix1) FROM "+testTableF+" GROUP BY prefix1", false); + String dataSql = "SELECT DISTINCT prefix1, prefix2 FROM "+testTableF+ " WHERE prefix1 IN (1,2)"; + ResultSet rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(PREFIX)); + + dataSql = "SELECT prefix1, 1, 2 FROM "+testTableF+" GROUP BY prefix1 HAVING prefix1 = 1"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(PREFIX)); + + dataSql = "SELECT prefix1 FROM "+testTableF+" GROUP BY prefix1, TRUNC(prefix1), TRUNC(prefix2)"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(PREFIX)); + + dataSql = "SELECT DISTINCT prefix1, prefix2 FROM "+testTableV+ " WHERE prefix1 IN ('1','2')"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(PREFIX)); + + dataSql = "SELECT prefix1, 1, 2 FROM "+testTableV+" GROUP BY prefix1 HAVING prefix1 = '1'"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(PREFIX)); testCommonPlans(testTableF, PREFIX); testCommonPlans(testTableV, PREFIX); } private void testCommonPlans(String testTable, String contains) throws Exception { - testPlan("SELECT DISTINCT prefix1 FROM "+testTable, true); - testPlan("SELECT COUNT(DISTINCT prefix1) FROM "+testTable, true); - testPlan("SELECT COUNT(DISTINCT prefix1), COUNT(DISTINCT prefix2) FROM "+testTable, true); - testPlan("SELECT COUNT(DISTINCT prefix1), COUNT(DISTINCT (prefix1,prefix2)) FROM "+testTable, true); - // a plain aggregate, cannot optimize - testPlan("SELECT COUNT(prefix1), COUNT(DISTINCT prefix1) FROM "+testTable, false); - testPlan("SELECT COUNT(*) FROM (SELECT DISTINCT(prefix1) FROM "+testTable+")", true); - testPlan("SELECT /*+ RANGE_SCAN */ DISTINCT prefix1 FROM "+testTable, false); - testPlan("SELECT DISTINCT prefix1, prefix2 FROM "+testTable, true); + + String dataSql = "SELECT DISTINCT prefix1 FROM "+testTable; + ResultSet rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT /*+ RANGE_SCAN */ DISTINCT prefix1 FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT DISTINCT prefix1, prefix2 FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); + // use the filter even when the boolean expression filter is used - testPlan("SELECT DISTINCT prefix1, prefix2 FROM "+testTable+ " WHERE col1 > 0.5", true); + dataSql = "SELECT DISTINCT prefix1, prefix2 FROM "+testTable+ " WHERE col1 > 0.5"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); + // do not use the filter when the distinct is on the entire key - testPlan("SELECT DISTINCT prefix1, prefix2, prefix3 FROM "+testTable, false); - testPlan("SELECT DISTINCT (prefix1, prefix2, prefix3) FROM "+testTable, false); - testPlan("SELECT DISTINCT prefix1, prefix2, col1, prefix3 FROM "+testTable, false); - testPlan("SELECT DISTINCT prefix1, prefix2, col1 FROM "+testTable, false); - testPlan("SELECT DISTINCT col1, prefix1, prefix2 FROM "+testTable, false);; - testPlan("SELECT prefix1 FROM "+testTable+" GROUP BY prefix1", true); - testPlan("SELECT COUNT(prefix1) FROM (SELECT prefix1 FROM "+testTable+" GROUP BY prefix1)", true); - // aggregate over the group by, cannot optimize - testPlan("SELECT prefix1, count(*) FROM "+testTable+" GROUP BY prefix1", false); - testPlan("SELECT prefix1 FROM "+testTable+" GROUP BY prefix1, prefix2", true); - // again using full key - testPlan("SELECT prefix1 FROM "+testTable+" GROUP BY prefix1, prefix2, prefix3", false); - testPlan("SELECT (prefix1, prefix2, prefix3) FROM "+testTable+" GROUP BY (prefix1, prefix2, prefix3)", false); - testPlan("SELECT prefix1, 1, 2 FROM "+testTable+" GROUP BY prefix1", true); - testPlan("SELECT prefix1 FROM "+testTable+" GROUP BY prefix1, col1", false); - testPlan("SELECT DISTINCT prefix1, prefix2 FROM "+testTable+" WHERE col1 > 0.5", true); - } + dataSql = "SELECT DISTINCT prefix1, prefix2, prefix3 FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT DISTINCT (prefix1, prefix2, prefix3) FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT DISTINCT prefix1, prefix2, col1, prefix3 FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT DISTINCT prefix1, prefix2, col1 FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT DISTINCT col1, prefix1, prefix2 FROM "+testTable; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT prefix1 FROM "+testTable+" GROUP BY prefix1"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT prefix1, count(*) FROM "+testTable+" GROUP BY prefix1"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT prefix1 FROM "+testTable+" GROUP BY prefix1, prefix2"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); - private void testPlan(String query, boolean optimizable) throws Exception { - ResultSet rs = conn.createStatement().executeQuery("EXPLAIN "+query); - assertEquals(QueryUtil.getExplainPlan(rs).contains(PREFIX), optimizable); + dataSql = "SELECT prefix1 FROM "+testTable+" GROUP BY prefix1, prefix2, prefix3"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT (prefix1, prefix2, prefix3) FROM "+testTable+" GROUP BY (prefix1, prefix2, prefix3)"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT prefix1, 1, 2 FROM "+testTable+" GROUP BY prefix1"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT prefix1 FROM "+testTable+" GROUP BY prefix1, col1"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertFalse(QueryUtil.getExplainPlan(rs).contains(contains)); + + dataSql = "SELECT DISTINCT prefix1, prefix2 FROM "+testTable+" WHERE col1 > 0.5"; + rs = conn.createStatement().executeQuery("EXPLAIN "+dataSql); + assertTrue(QueryUtil.getExplainPlan(rs).contains(contains)); } @Test @@ -210,9 +260,6 @@ public class DistinctPrefixFilterIT extends BaseHBaseManagedTimeTableReuseIT { // mix distinct and boolean expression filters testSkipRange("SELECT %s DISTINCT prefix1, prefix2 FROM " + testTableF + " WHERE col1 > 0.99 AND prefix1 IN (1,2)", -1); - testCount("SELECT %s COUNT(DISTINCT prefix1), COUNT(DISTINCT (prefix1, prefix2)) FROM " + testTableF + " WHERE prefix2=2", 3, 3); - testCount("SELECT %s COUNT(DISTINCT prefix1), COUNT(DISTINCT (prefix1, prefix2)) FROM " + testTableF + " WHERE prefix1=2", 1, 3); - // mix distinct prefix and SkipScan filters testSkipRange("SELECT %s DISTINCT prefix1, prefix2 FROM " + testTableV + " WHERE prefix1 IN ('1','2')", 6); testSkipRange("SELECT %s DISTINCT prefix1, prefix2 FROM " + testTableV + " WHERE prefix1 IN ('3','22')", 5); @@ -235,14 +282,6 @@ public class DistinctPrefixFilterIT extends BaseHBaseManagedTimeTableReuseIT { testSkipRange("SELECT %s DISTINCT prefix1, prefix2 FROM " + testTable + " ORDER BY prefix1, prefix2 DESC", 11); testSkipRange("SELECT %s DISTINCT prefix1, prefix2 FROM " + testTable + " WHERE col1 > 0.99", -1); testSkipRange("SELECT %s DISTINCT prefix1, prefix2 FROM " + testTable + " WHERE col1 > 0.99 ORDER BY prefix1, prefix2 DESC", -1); - - testCount("SELECT %s COUNT(DISTINCT prefix1) FROM " + testTable, 4); - testCount("SELECT COUNT(*) FROM (SELECT %s DISTINCT prefix1, prefix2 FROM " + testTable + ")", 11); - testCount("SELECT %s COUNT(DISTINCT prefix1) FROM " + testTable + " WHERE col1 > 0.99", -1); - testCount("SELECT COUNT(*) FROM (SELECT %s DISTINCT prefix1, prefix2 FROM " + testTable + " WHERE col1 > 0.99)", -1); - testCount("SELECT %s COUNT(DISTINCT prefix1), COUNT(DISTINCT prefix2) FROM " + testTable, 4, 4); - testCount("SELECT %s COUNT(DISTINCT prefix1), COUNT(DISTINCT (prefix1, prefix2)) FROM " + testTable, 4, 11); - testCount("SELECT %s COUNT(DISTINCT prefix1), COUNT(DISTINCT (prefix1, prefix2)) FROM " + testTable + " WHERE col1 > 0.99", -1, -1); } @Test @@ -296,28 +335,6 @@ public class DistinctPrefixFilterIT extends BaseHBaseManagedTimeTableReuseIT { assertEquals(count, count1); } - private void testCount(String q, int... expected) throws SQLException { - String q1 = String.format(q, ""); - PreparedStatement stmt = conn.prepareStatement(q1); - ResultSet res = stmt.executeQuery(); - int[] count = new int[expected.length]; - assertTrue(res.next()); - for (int i=0; i<expected.length; i++) { - count[i] = res.getInt(i+1); - if (expected[i] > 0) assertEquals(expected[i], count[i]); - } - assertFalse(res.next()); - - q1 = String.format(q, "/*+ RANGE_SCAN */"); - stmt = conn.prepareStatement(q1); - res = stmt.executeQuery(); - assertTrue(res.next()); - for (int i=0; i<expected.length; i++) { - assertEquals(count[i], res.getInt(i+1)); - } - assertFalse(res.next()); - } - private static void insertPrefixF(int prefix1, int prefix2) throws SQLException { String query = "UPSERT INTO " + testTableF + "(prefix1, prefix2, prefix3, col1) VALUES(?,?,NEXT VALUE FOR "+testSeq+",rand())"; http://git-wip-us.apache.org/repos/asf/phoenix/blob/a4d498f3/phoenix-core/src/main/java/org/apache/phoenix/compile/GroupByCompiler.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/GroupByCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/GroupByCompiler.java index 0d5b423..fd6d6e9 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/GroupByCompiler.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/GroupByCompiler.java @@ -59,7 +59,6 @@ public class GroupByCompiler { private final List<Expression> keyExpressions; private final boolean isOrderPreserving; private final int orderPreservingColumnCount; - private final boolean isUngroupedAggregate; public static final GroupByCompiler.GroupBy EMPTY_GROUP_BY = new GroupBy(new GroupByBuilder()) { @Override public GroupBy compile(StatementContext context, TupleProjector tupleProjector) throws SQLException { @@ -99,7 +98,6 @@ public class GroupByCompiler { ImmutableList.copyOf(builder.keyExpressions); this.isOrderPreserving = builder.isOrderPreserving; this.orderPreservingColumnCount = builder.orderPreservingColumnCount; - this.isUngroupedAggregate = builder.isUngroupedAggregate; } public List<Expression> getExpressions() { @@ -111,13 +109,9 @@ public class GroupByCompiler { } public String getScanAttribName() { - if (isUngroupedAggregate) { - return BaseScannerRegionObserver.UNGROUPED_AGG; - } else if (isOrderPreserving) { - return BaseScannerRegionObserver.KEY_ORDERED_GROUP_BY_EXPRESSIONS; - } else { - return BaseScannerRegionObserver.UNORDERED_GROUP_BY_EXPRESSIONS; - } + return isOrderPreserving ? + BaseScannerRegionObserver.KEY_ORDERED_GROUP_BY_EXPRESSIONS : + BaseScannerRegionObserver.UNORDERED_GROUP_BY_EXPRESSIONS; } public boolean isEmpty() { @@ -128,10 +122,6 @@ public class GroupByCompiler { return isOrderPreserving; } - public boolean isUngroupedAggregate() { - return isUngroupedAggregate; - } - public int getOrderPreservingColumnCount() { return orderPreservingColumnCount; } @@ -155,9 +145,7 @@ public class GroupByCompiler { if (isOrderPreserving) { return new GroupBy.GroupByBuilder(this).setOrderPreservingColumnCount(orderPreservingColumnCount).build(); } - if (isUngroupedAggregate) { - return UNGROUPED_GROUP_BY; - } + List<Expression> expressions = Lists.newArrayListWithExpectedSize(this.expressions.size()); List<Expression> keyExpressions = expressions; List<Pair<Integer,Expression>> groupBys = Lists.newArrayListWithExpectedSize(this.expressions.size()); @@ -255,7 +243,6 @@ public class GroupByCompiler { private int orderPreservingColumnCount; private List<Expression> expressions = Collections.emptyList(); private List<Expression> keyExpressions = Collections.emptyList(); - private boolean isUngroupedAggregate; public GroupByBuilder() { } @@ -265,7 +252,6 @@ public class GroupByCompiler { this.orderPreservingColumnCount = groupBy.orderPreservingColumnCount; this.expressions = groupBy.expressions; this.keyExpressions = groupBy.keyExpressions; - this.isUngroupedAggregate = groupBy.isUngroupedAggregate; } public GroupByBuilder setExpressions(List<Expression> expressions) { @@ -283,11 +269,6 @@ public class GroupByCompiler { return this; } - public GroupByBuilder setIsUngroupedAggregate(boolean isUngroupedAggregate) { - this.isUngroupedAggregate = isUngroupedAggregate; - return this; - } - public GroupByBuilder setOrderPreservingColumnCount(int orderPreservingColumnCount) { this.orderPreservingColumnCount = orderPreservingColumnCount; return this; @@ -299,9 +280,7 @@ public class GroupByCompiler { } public void explain(List<String> planSteps, Integer limit) { - if (isUngroupedAggregate) { - planSteps.add(" SERVER AGGREGATE INTO SINGLE ROW"); - } else if (isOrderPreserving) { + if (isOrderPreserving) { planSteps.add(" SERVER AGGREGATE INTO ORDERED DISTINCT ROWS BY " + getExpressions() + (limit == null ? "" : " LIMIT " + limit + " GROUP" + (limit.intValue() == 1 ? "" : "S"))); } else { planSteps.add(" SERVER AGGREGATE INTO DISTINCT ROWS BY " + getExpressions() + (limit == null ? "" : " LIMIT " + limit + " GROUP" + (limit.intValue() == 1 ? "" : "S"))); @@ -324,11 +303,11 @@ public class GroupByCompiler { * Otherwise, we need to insert a step after the Merge that dedups. * Order by only allowed on columns in the select distinct */ - boolean isUngroupedAggregate = false; if (groupByNodes.isEmpty()) { if (statement.isAggregate()) { - isUngroupedAggregate = true; - } else if (!statement.isDistinct()) { + return GroupBy.UNGROUPED_GROUP_BY; + } + if (!statement.isDistinct()) { return GroupBy.EMPTY_GROUP_BY; } @@ -346,7 +325,7 @@ public class GroupByCompiler { ParseNode node = groupByNodes.get(i); Expression expression = node.accept(compiler); if (!expression.isStateless()) { - if (!isUngroupedAggregate && compiler.isAggregate()) { + if (compiler.isAggregate()) { throw new SQLExceptionInfo.Builder(SQLExceptionCode.AGGREGATE_IN_GROUP_BY) .setMessage(expression.toString()).build().buildException(); } @@ -358,10 +337,7 @@ public class GroupByCompiler { if (expressions.isEmpty()) { return GroupBy.EMPTY_GROUP_BY; } - GroupBy groupBy = new GroupBy.GroupByBuilder() - .setIsOrderPreserving(isOrderPreserving) - .setExpressions(expressions).setKeyExpressions(expressions) - .setIsUngroupedAggregate(isUngroupedAggregate).build(); + GroupBy groupBy = new GroupBy.GroupByBuilder().setIsOrderPreserving(isOrderPreserving).setExpressions(expressions).setKeyExpressions(expressions).build(); return groupBy; } http://git-wip-us.apache.org/repos/asf/phoenix/blob/a4d498f3/phoenix-core/src/main/java/org/apache/phoenix/compile/OrderPreservingTracker.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/OrderPreservingTracker.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/OrderPreservingTracker.java index c17838e..8f09337 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/compile/OrderPreservingTracker.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/OrderPreservingTracker.java @@ -21,10 +21,8 @@ import org.apache.phoenix.expression.Expression; import org.apache.phoenix.expression.ProjectedColumnExpression; import org.apache.phoenix.expression.RowKeyColumnExpression; import org.apache.phoenix.expression.RowValueConstructorExpression; -import org.apache.phoenix.expression.function.DistinctCountAggregateFunction; import org.apache.phoenix.expression.function.FunctionExpression.OrderPreserving; import org.apache.phoenix.expression.function.ScalarFunction; -import org.apache.phoenix.expression.function.SingleAggregateFunction; import org.apache.phoenix.expression.visitor.StatelessTraverseNoExpressionVisitor; import org.apache.phoenix.schema.PTable; import org.apache.phoenix.schema.SortOrder; @@ -235,19 +233,6 @@ public class OrderPreservingTracker { } @Override - public Iterator<Expression> visitEnter(SingleAggregateFunction node) { - return node instanceof DistinctCountAggregateFunction ? - node.getChildren().iterator() : - Iterators.<Expression> emptyIterator(); - } - - @Override - public Info visitLeave(SingleAggregateFunction node, List<Info> l) { - if (l.isEmpty()) { return null; } - return l.get(0); - } - - @Override public Iterator<Expression> visitEnter(ScalarFunction node) { return node.preservesOrder() == OrderPreserving.NO ? Iterators.<Expression> emptyIterator() : Iterators .singletonIterator(node.getChildren().get(node.getKeyFormationTraversalIndex())); http://git-wip-us.apache.org/repos/asf/phoenix/blob/a4d498f3/phoenix-core/src/main/java/org/apache/phoenix/iterate/BaseResultIterators.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/iterate/BaseResultIterators.java b/phoenix-core/src/main/java/org/apache/phoenix/iterate/BaseResultIterators.java index bc962c3..f9c4a1a 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/iterate/BaseResultIterators.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/iterate/BaseResultIterators.java @@ -230,7 +230,7 @@ public abstract class BaseResultIterators extends ExplainTable implements Result !plan.getStatement().getHint().hasHint(HintNode.Hint.RANGE_SCAN) && cols < plan.getTableRef().getTable().getRowKeySchema().getFieldCount() && plan.getGroupBy().isOrderPreserving() && - (context.getAggregationManager().isEmpty() || plan.getGroupBy().isUngroupedAggregate())) + (plan.getStatement().isDistinct() || context.getAggregationManager().isEmpty())) { ScanUtil.andFilterAtEnd(context.getScan(), new DistinctPrefixFilter(plan.getTableRef().getTable().getRowKeySchema(),