You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pinot.apache.org by GitBox <gi...@apache.org> on 2022/02/09 09:16:13 UTC
[GitHub] [pinot] atris commented on a change in pull request #8172: Fix filtered aggregation when it is mixed with regular aggregation
atris commented on a change in pull request #8172:
URL: https://github.com/apache/pinot/pull/8172#discussion_r802384374
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/reduce/PostAggregationHandler.java
##########
@@ -117,19 +115,19 @@ public ValueExtractor getValueExtractor(ExpressionContext expression) {
}
}
FunctionContext function = expression.getFunction();
- Preconditions
- .checkState(function != null, "Failed to find SELECT expression: %s in the GROUP-BY clause", expression);
+ Preconditions.checkState(function != null, "Failed to find SELECT expression: %s in the GROUP-BY clause",
Review comment:
Whitespace changes?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -459,104 +457,87 @@ public QueryContext build() {
* Helper method to generate the aggregation functions for the query.
*/
private void generateAggregationFunctions(QueryContext queryContext) {
- List<AggregationFunction> aggregationFunctions = new ArrayList<>();
- List<Pair<AggregationFunction, FilterContext>> filteredAggregations = new ArrayList<>();
- Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
- Map<Pair<FunctionContext, FilterContext>, Integer> filterExpressionIndexMap = new HashMap<>();
+ List<Pair<AggregationFunction, FilterContext>> filteredAggregationFunctions = new ArrayList<>();
+ Map<Pair<FunctionContext, FilterContext>, Integer> filteredAggregationsIndexMap = new HashMap<>();
// Add aggregation functions in the SELECT clause
// NOTE: DO NOT deduplicate the aggregation functions in the SELECT clause because that involves protocol change.
- List<Pair<FilterContext, FunctionContext>> aggregationsInSelect = new ArrayList<>();
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations = new ArrayList<>();
for (ExpressionContext selectExpression : queryContext._selectExpressions) {
- getAggregations(selectExpression, aggregationsInSelect);
+ getAggregations(selectExpression, filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInSelect) {
- FunctionContext function = pair.getRight();
- int functionIndex = filteredAggregations.size();
- AggregationFunction aggregationFunction =
- AggregationFunctionFactory.getAggregationFunction(function, queryContext);
-
- FilterContext filterContext = null;
- // If the left pair is not null, implies a filtered aggregation
- if (pair.getLeft() != null) {
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ if (filter != null) {
+ // Filtered aggregation
if (_groupByExpressions != null) {
throw new IllegalStateException("GROUP BY with FILTER clauses is not supported");
}
queryContext._hasFilteredAggregations = true;
- filterContext = pair.getLeft();
- Pair<FunctionContext, FilterContext> filterContextPair =
- Pair.of(function, filterContext);
- if (!filterExpressionIndexMap.containsKey(filterContextPair)) {
- int filterMapIndex = filterExpressionIndexMap.size();
- filterExpressionIndexMap.put(filterContextPair, filterMapIndex);
- }
}
- filteredAggregations.add(Pair.of(aggregationFunction, filterContext));
- aggregationFunctionIndexMap.put(function, functionIndex);
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
- // Add aggregation functions in the HAVING clause but not in the SELECT clause
+ // Add aggregation functions in the HAVING and ORDER-BY clause but not in the SELECT clause
+ filteredAggregations.clear();
if (queryContext._havingFilter != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInHaving = new ArrayList<>();
- getAggregations(queryContext._havingFilter, aggregationsInHaving);
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInHaving) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
- }
+ getAggregations(queryContext._havingFilter, filteredAggregations);
}
-
- // Add aggregation functions in the ORDER-BY clause but not in the SELECT or HAVING clause
if (queryContext._orderByExpressions != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInOrderBy = new ArrayList<>();
for (OrderByExpressionContext orderByExpression : queryContext._orderByExpressions) {
- getAggregations(orderByExpression.getExpression(), aggregationsInOrderBy);
+ getAggregations(orderByExpression.getExpression(), filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInOrderBy) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
+ }
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ if (!filteredAggregationsIndexMap.containsKey(pair)) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
}
- if (!filteredAggregations.isEmpty()) {
- for (Pair<AggregationFunction, FilterContext> pair : filteredAggregations) {
- aggregationFunctions.add(pair.getLeft());
+ if (!filteredAggregationFunctions.isEmpty()) {
+ int numAggregations = filteredAggregationFunctions.size();
+ AggregationFunction[] aggregationFunctions = new AggregationFunction[numAggregations];
+ for (int i = 0; i < numAggregations; i++) {
+ aggregationFunctions[i] = filteredAggregationFunctions.get(i).getLeft();
}
-
- queryContext._aggregationFunctions = aggregationFunctions.toArray(new AggregationFunction[0]);
- queryContext._filteredAggregations = filteredAggregations;
+ Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
+ for (Map.Entry<Pair<FunctionContext, FilterContext>, Integer> entry : filteredAggregationsIndexMap.entrySet()) {
+ aggregationFunctionIndexMap.put(entry.getKey().getLeft(), entry.getValue());
+ }
+ queryContext._aggregationFunctions = aggregationFunctions;
+ queryContext._filteredAggregationFunctions = filteredAggregationFunctions;
queryContext._aggregationFunctionIndexMap = aggregationFunctionIndexMap;
- queryContext._filteredAggregationsIndexMap = filterExpressionIndexMap;
+ queryContext._filteredAggregationsIndexMap = filteredAggregationsIndexMap;
}
}
/**
- * Helper method to extract AGGREGATION FunctionContexts from the given expression.
- *
- * NOTE: The left pair of aggregations should be set only for filtered aggregations
+ * Helper method to extract AGGREGATION FunctionContexts and FILTER FilterContexts from the given expression.
*/
private static void getAggregations(ExpressionContext expression,
- List<Pair<FilterContext, FunctionContext>> aggregations) {
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations) {
Review comment:
Same comment as above
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -234,11 +233,11 @@ public BrokerRequest getBrokerRequest() {
}
/**
- * Returns the filtered aggregations for a query
+ * Returns the filtered aggregation functions for a query, or {@code null} if the query does not have any aggregation.
*/
@Nullable
- public List<Pair<AggregationFunction, FilterContext>> getFilteredAggregations() {
- return _filteredAggregations;
+ public List<Pair<AggregationFunction, FilterContext>> getFilteredAggregationFunctions() {
Review comment:
Renaming change?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -459,104 +457,87 @@ public QueryContext build() {
* Helper method to generate the aggregation functions for the query.
*/
private void generateAggregationFunctions(QueryContext queryContext) {
- List<AggregationFunction> aggregationFunctions = new ArrayList<>();
- List<Pair<AggregationFunction, FilterContext>> filteredAggregations = new ArrayList<>();
- Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
- Map<Pair<FunctionContext, FilterContext>, Integer> filterExpressionIndexMap = new HashMap<>();
+ List<Pair<AggregationFunction, FilterContext>> filteredAggregationFunctions = new ArrayList<>();
+ Map<Pair<FunctionContext, FilterContext>, Integer> filteredAggregationsIndexMap = new HashMap<>();
// Add aggregation functions in the SELECT clause
// NOTE: DO NOT deduplicate the aggregation functions in the SELECT clause because that involves protocol change.
- List<Pair<FilterContext, FunctionContext>> aggregationsInSelect = new ArrayList<>();
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations = new ArrayList<>();
for (ExpressionContext selectExpression : queryContext._selectExpressions) {
- getAggregations(selectExpression, aggregationsInSelect);
+ getAggregations(selectExpression, filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInSelect) {
- FunctionContext function = pair.getRight();
- int functionIndex = filteredAggregations.size();
- AggregationFunction aggregationFunction =
- AggregationFunctionFactory.getAggregationFunction(function, queryContext);
-
- FilterContext filterContext = null;
- // If the left pair is not null, implies a filtered aggregation
- if (pair.getLeft() != null) {
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ if (filter != null) {
+ // Filtered aggregation
if (_groupByExpressions != null) {
throw new IllegalStateException("GROUP BY with FILTER clauses is not supported");
}
queryContext._hasFilteredAggregations = true;
- filterContext = pair.getLeft();
- Pair<FunctionContext, FilterContext> filterContextPair =
- Pair.of(function, filterContext);
- if (!filterExpressionIndexMap.containsKey(filterContextPair)) {
- int filterMapIndex = filterExpressionIndexMap.size();
- filterExpressionIndexMap.put(filterContextPair, filterMapIndex);
- }
}
- filteredAggregations.add(Pair.of(aggregationFunction, filterContext));
- aggregationFunctionIndexMap.put(function, functionIndex);
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
- // Add aggregation functions in the HAVING clause but not in the SELECT clause
+ // Add aggregation functions in the HAVING and ORDER-BY clause but not in the SELECT clause
+ filteredAggregations.clear();
if (queryContext._havingFilter != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInHaving = new ArrayList<>();
- getAggregations(queryContext._havingFilter, aggregationsInHaving);
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInHaving) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
- }
+ getAggregations(queryContext._havingFilter, filteredAggregations);
}
-
- // Add aggregation functions in the ORDER-BY clause but not in the SELECT or HAVING clause
if (queryContext._orderByExpressions != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInOrderBy = new ArrayList<>();
for (OrderByExpressionContext orderByExpression : queryContext._orderByExpressions) {
- getAggregations(orderByExpression.getExpression(), aggregationsInOrderBy);
+ getAggregations(orderByExpression.getExpression(), filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInOrderBy) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
+ }
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ if (!filteredAggregationsIndexMap.containsKey(pair)) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
}
- if (!filteredAggregations.isEmpty()) {
- for (Pair<AggregationFunction, FilterContext> pair : filteredAggregations) {
- aggregationFunctions.add(pair.getLeft());
+ if (!filteredAggregationFunctions.isEmpty()) {
+ int numAggregations = filteredAggregationFunctions.size();
+ AggregationFunction[] aggregationFunctions = new AggregationFunction[numAggregations];
+ for (int i = 0; i < numAggregations; i++) {
+ aggregationFunctions[i] = filteredAggregationFunctions.get(i).getLeft();
}
-
- queryContext._aggregationFunctions = aggregationFunctions.toArray(new AggregationFunction[0]);
- queryContext._filteredAggregations = filteredAggregations;
+ Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
+ for (Map.Entry<Pair<FunctionContext, FilterContext>, Integer> entry : filteredAggregationsIndexMap.entrySet()) {
+ aggregationFunctionIndexMap.put(entry.getKey().getLeft(), entry.getValue());
+ }
+ queryContext._aggregationFunctions = aggregationFunctions;
+ queryContext._filteredAggregationFunctions = filteredAggregationFunctions;
queryContext._aggregationFunctionIndexMap = aggregationFunctionIndexMap;
- queryContext._filteredAggregationsIndexMap = filterExpressionIndexMap;
+ queryContext._filteredAggregationsIndexMap = filteredAggregationsIndexMap;
}
}
/**
- * Helper method to extract AGGREGATION FunctionContexts from the given expression.
- *
- * NOTE: The left pair of aggregations should be set only for filtered aggregations
+ * Helper method to extract AGGREGATION FunctionContexts and FILTER FilterContexts from the given expression.
*/
private static void getAggregations(ExpressionContext expression,
- List<Pair<FilterContext, FunctionContext>> aggregations) {
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations) {
FunctionContext function = expression.getFunction();
if (function == null) {
return;
}
if (function.getType() == FunctionContext.Type.AGGREGATION) {
// Aggregation
- aggregations.add(Pair.of(null, function));
+ filteredAggregations.add(Pair.of(function, null));
} else {
- List<ExpressionContext> arguments = function.getArguments();
if (function.getFunctionName().equalsIgnoreCase("filter")) {
// Filtered aggregation
+ List<ExpressionContext> arguments = function.getArguments();
Review comment:
Where are we using this declaration?
##########
File path: pinot-core/src/test/java/org/apache/pinot/queries/FilteredAggregationsTest.java
##########
@@ -143,287 +139,172 @@ private void buildSegment(String segmentName)
}
}
- private void testInterSegmentAggregationQueryHelper(String firstQuery, String secondQuery) {
- // SQL
- BrokerResponseNative firstBrokerResponseNative = getBrokerResponseForSqlQuery(firstQuery);
- BrokerResponseNative secondBrokerResponseNative = getBrokerResponseForSqlQuery(secondQuery);
- ResultTable firstResultTable = firstBrokerResponseNative.getResultTable();
- ResultTable secondResultTable = secondBrokerResponseNative.getResultTable();
- DataSchema firstDataSchema = firstResultTable.getDataSchema();
- DataSchema secondDataSchema = secondResultTable.getDataSchema();
-
- Assert.assertEquals(firstDataSchema.size(), secondDataSchema.size());
-
- List<Object[]> firstSetOfRows = firstResultTable.getRows();
- List<Object[]> secondSetOfRows = secondResultTable.getRows();
-
- Assert.assertEquals(firstSetOfRows.size(), secondSetOfRows.size());
-
- for (int i = 0; i < firstSetOfRows.size(); i++) {
- Object[] firstSetRow = firstSetOfRows.get(i);
- Object[] secondSetRow = secondSetOfRows.get(i);
-
- Assert.assertEquals(firstSetRow.length, secondSetRow.length);
-
- for (int j = 0; j < firstSetRow.length; j++) {
- //System.out.println("FIRST " + firstSetRow[j] + " SECOND " + secondSetRow[j] + " j " + j);
- Assert.assertEquals(firstSetRow[j], secondSetRow[j]);
- }
+ private void testQuery(String filterQuery, String nonFilterQuery) {
+ List<Object[]> filterQueryResults = getBrokerResponseForSqlQuery(filterQuery).getResultTable().getRows();
+ List<Object[]> nonFilterQueryResults = getBrokerResponseForSqlQuery(nonFilterQuery).getResultTable().getRows();
+ assertEquals(filterQueryResults.size(), nonFilterQueryResults.size());
+ for (int i = 0; i < filterQueryResults.size(); i++) {
+ assertEquals(filterQueryResults.get(i), nonFilterQueryResults.get(i));
}
}
@Test
- public void testInterSegment() {
-
- String query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 9999)"
- + "FROM MyTable WHERE INT_COL < 1000000";
-
- String nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 9999 AND INT_COL < 1000000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 1234 AND INT_COL < 22000)"
- + "FROM MyTable";
-
- nonFilterQuery = "SELECT SUM(CASE "
- + "WHEN (INT_COL > 1234 AND INT_COL < 22000) THEN INT_COL ELSE 0 "
- + "END) AS total_sum FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL < 3)"
- + "FROM MyTable WHERE INT_COL > 1";
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 1 AND INT_COL < 3";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT COUNT(*) FILTER(WHERE INT_COL = 4)"
- + "FROM MyTable";
- nonFilterQuery =
- "SELECT COUNT(*)"
- + "FROM MyTable WHERE INT_COL = 4";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 8000)"
- + "FROM MyTable ";
-
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 8000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE NO_INDEX_COL <= 1)"
- + "FROM MyTable WHERE INT_COL > 1";
-
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL <= 1 AND INT_COL > 1";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT AVG(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > -1";
- nonFilterQuery =
- "SELECT AVG(NO_INDEX_COL)"
- + "FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),SUM(NO_INDEX_COL),MAX(INT_COL) "
- + "FROM MyTable";
-
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,SUM(NO_INDEX_COL),"
- + "MAX(INT_COL) FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT AVG(INT_COL) FILTER(WHERE NO_INDEX_COL > -1) FROM MyTable";
- nonFilterQuery =
- "SELECT AVG(NO_INDEX_COL) FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL) FROM MyTable";
-
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,MAX(NO_INDEX_COL)"
- + "FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > 5";
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,MAX(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > 5";
+ public void testSimpleQueries() {
+ String filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 9999) FROM MyTable WHERE INT_COL < 1000000";
+ String nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE INT_COL > 9999 AND INT_COL < 1000000";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL < 3) FROM MyTable WHERE INT_COL > 1";
+ nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE INT_COL > 1 AND INT_COL < 3";
+ testQuery(filterQuery, nonFilterQuery);
- query =
- "SELECT MAX(INT_COL) FILTER(WHERE INT_COL < 100) FROM MyTable";
+ filterQuery = "SELECT COUNT(*) FILTER(WHERE INT_COL = 4) FROM MyTable";
+ nonFilterQuery = "SELECT COUNT(*) FROM MyTable WHERE INT_COL = 4";
+ testQuery(filterQuery, nonFilterQuery);
- nonFilterQuery =
- "SELECT MAX(CASE WHEN (INT_COL < 100) THEN INT_COL ELSE 0 END) AS total_max FROM MyTable";
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 8000) FROM MyTable ";
+ nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE INT_COL > 8000";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE NO_INDEX_COL <= 1) FROM MyTable WHERE INT_COL > 1";
+ nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE NO_INDEX_COL <= 1 AND INT_COL > 1";
+ testQuery(filterQuery, nonFilterQuery);
- query =
- "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL < 100) FROM MyTable";
+ filterQuery = "SELECT AVG(NO_INDEX_COL) FROM MyTable WHERE NO_INDEX_COL > -1";
+ nonFilterQuery = "SELECT AVG(NO_INDEX_COL) FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
- nonFilterQuery =
- "SELECT MIN(CASE WHEN (INT_COL < 100) THEN NO_INDEX_COL ELSE 0 END) AS total_min "
- + "FROM MyTable";
+ filterQuery = "SELECT AVG(INT_COL) FILTER(WHERE NO_INDEX_COL > -1) FROM MyTable";
+ nonFilterQuery = "SELECT AVG(NO_INDEX_COL) FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL > 29990),MAX(INT_COL) FILTER(WHERE INT_COL > 29990)"
- + "FROM MyTable";
-
- nonFilterQuery =
- "SELECT MIN(NO_INDEX_COL), MAX(INT_COL) FROM MyTable WHERE INT_COL > 29990";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
+ filterQuery = "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL > 29990), MAX(INT_COL) FILTER(WHERE INT_COL > 29990) "
+ + "FROM MyTable";
+ nonFilterQuery = "SELECT MIN(NO_INDEX_COL), MAX(INT_COL) FROM MyTable WHERE INT_COL > 29990";
+ testQuery(filterQuery, nonFilterQuery);
}
@Test
- public void testCaseVsFilter() {
- String query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 3),"
- + "SUM(INT_COL) FILTER(WHERE INT_COL < 4)"
- + "FROM MyTable WHERE INT_COL > 2";
-
- String nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 3) THEN INT_COL ELSE 0 "
- + "END) AS total_sum,SUM(CASE WHEN (INT_COL < 4) THEN INT_COL ELSE 0 END) AS total_sum2 "
+ public void testFilterVsCase() {
+ String filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 1234 AND INT_COL < 22000) FROM MyTable";
+ String nonFilterQuery =
+ "SELECT SUM(CASE WHEN (INT_COL > 1234 AND INT_COL < 22000) THEN INT_COL ELSE 0 END) AS total_sum FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0), SUM(NO_INDEX_COL), MAX(INT_COL) FROM MyTable";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "SUM(NO_INDEX_COL), MAX(INT_COL) FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0), MAX(NO_INDEX_COL) FROM MyTable";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "MAX(NO_INDEX_COL) FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery =
+ "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL) FROM MyTable WHERE NO_INDEX_COL > 5";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "MAX(NO_INDEX_COL) FROM MyTable WHERE NO_INDEX_COL > 5";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT MAX(INT_COL) FILTER(WHERE INT_COL < 100) FROM MyTable";
+ nonFilterQuery = "SELECT MAX(CASE WHEN (INT_COL < 100) THEN INT_COL ELSE 0 END) AS total_max FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL < 100) FROM MyTable";
+ nonFilterQuery = "SELECT MIN(CASE WHEN (INT_COL < 100) THEN NO_INDEX_COL ELSE 0 END) AS total_min FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 3), SUM(INT_COL) FILTER(WHERE INT_COL < 4) "
+ "FROM MyTable WHERE INT_COL > 2";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 3) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "SUM(CASE WHEN (INT_COL < 4) THEN INT_COL ELSE 0 END) AS total_sum2 FROM MyTable WHERE INT_COL > 2";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 12345),SUM(INT_COL) FILTER(WHERE INT_COL < 59999),"
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 12345), SUM(INT_COL) FILTER(WHERE INT_COL < 59999), "
+ "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) FROM MyTable WHERE INT_COL > 1000";
-
- nonFilterQuery = "SELECT SUM( CASE WHEN (INT_COL > 12345) THEN INT_COL ELSE 0 "
- + "END) AS total_sum,SUM(CASE WHEN (INT_COL < 59999) THEN INT_COL ELSE 0 "
- + "END) AS total_sum2,MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL "
- + "ELSE 9999999 END) AS total_min FROM MyTable WHERE INT_COL > 1000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 12345),"
- + "SUM(NO_INDEX_COL) FILTER(WHERE INT_COL < 59999),"
- + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) "
+ nonFilterQuery = "SELECT SUM( CASE WHEN (INT_COL > 12345) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "SUM(CASE WHEN (INT_COL < 59999) THEN INT_COL ELSE 0 END) AS total_sum2, "
+ + "MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL ELSE 9999999 END) AS total_min "
+ "FROM MyTable WHERE INT_COL > 1000";
+ testQuery(filterQuery, nonFilterQuery);
- nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 12345) THEN INT_COL "
- + "ELSE 0 END) AS total_sum,SUM(CASE WHEN (INT_COL < 59999) THEN NO_INDEX_COL "
- + "ELSE 0 END) AS total_sum2,MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL "
- + "ELSE 9999999 END) AS total_min FROM MyTable WHERE INT_COL > 1000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 12345),"
- + "SUM(NO_INDEX_COL) FILTER(WHERE INT_COL < 59999),"
- + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) "
- + "FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000 ";
-
- nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 12345) THEN INT_COL ELSE 0 "
- + "END) AS total_sum,SUM(CASE WHEN (INT_COL < 59999) THEN NO_INDEX_COL "
- + "ELSE 0 END) AS total_sum2,MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL "
- + "ELSE 9999999 END) AS total_min FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE ABS(INT_COL) > 12345),"
- + "SUM(NO_INDEX_COL) FILTER(WHERE LN(INT_COL) < 59999),"
- + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) "
- + "FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000 ";
-
- nonFilterQuery = "SELECT SUM("
- + "CASE WHEN (ABS(INT_COL) > 12345) THEN INT_COL ELSE 0 "
- + "END) AS total_sum,SUM(CASE WHEN (LN(INT_COL) < 59999) THEN NO_INDEX_COL "
- + "ELSE 0 END) AS total_sum2,MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL "
- + "ELSE 9999999 END) AS total_min FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE MOD(INT_COL, STATIC_INT_COL) = 0),"
- + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) "
- + "FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000 ";
-
- nonFilterQuery = "SELECT SUM(CASE WHEN (MOD(INT_COL, STATIC_INT_COL) = 0) THEN INT_COL "
- + "ELSE 0 END) AS total_sum,MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL "
- + "ELSE 9999999 END) AS total_min FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 123 AND INT_COL < 25000),"
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 12345), SUM(NO_INDEX_COL) FILTER(WHERE INT_COL < 59999), "
+ + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) FROM MyTable WHERE INT_COL > 1000";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 12345) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "SUM(CASE WHEN (INT_COL < 59999) THEN NO_INDEX_COL ELSE 0 END) AS total_sum2, "
+ + "MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL ELSE 9999999 END) AS total_min "
+ + "FROM MyTable WHERE INT_COL > 1000";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 12345), SUM(NO_INDEX_COL) FILTER(WHERE INT_COL < 59999), "
+ + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 12345) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "SUM(CASE WHEN (INT_COL < 59999) THEN NO_INDEX_COL ELSE 0 END) AS total_sum2, "
+ + "MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL ELSE 9999999 END) AS total_min "
+ + "FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE ABS(INT_COL) > 12345), "
+ + "SUM(NO_INDEX_COL) FILTER(WHERE LN(INT_COL) < 59999), MIN(INT_COL) FILTER(WHERE INT_COL > 5000) "
+ + "FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (ABS(INT_COL) > 12345) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "SUM(CASE WHEN (LN(INT_COL) < 59999) THEN NO_INDEX_COL ELSE 0 END) AS total_sum2, "
+ + "MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL ELSE 9999999 END) AS total_min "
+ + "FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
+ testQuery(filterQuery, nonFilterQuery);
+
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE MOD(INT_COL, STATIC_INT_COL) = 0), "
+ + "MIN(INT_COL) FILTER(WHERE INT_COL > 5000) FROM MyTable WHERE INT_COL < 28000 AND NO_INDEX_COL > 3000";
+ nonFilterQuery = "SELECT SUM(CASE WHEN (MOD(INT_COL, STATIC_INT_COL) = 0) THEN INT_COL ELSE 0 END) AS total_sum, "
+ + "MIN(CASE WHEN (INT_COL > 5000) THEN INT_COL ELSE 9999999 END) AS total_min "
Review comment:
The changes in this file predominantly seem to be oriented around whitespacing and/or test function name changes. Suggest isolating changes relevant to the main changes and performing whitespace related changes in a separate PR.
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -90,12 +90,11 @@
// Pre-calculate the aggregation functions and columns for the query so that it can be shared across all the segments
private AggregationFunction[] _aggregationFunctions;
+ private List<Pair<AggregationFunction, FilterContext>> _filteredAggregationFunctions;
Review comment:
Same comment as above -- renaming change?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -459,104 +457,87 @@ public QueryContext build() {
* Helper method to generate the aggregation functions for the query.
*/
private void generateAggregationFunctions(QueryContext queryContext) {
- List<AggregationFunction> aggregationFunctions = new ArrayList<>();
- List<Pair<AggregationFunction, FilterContext>> filteredAggregations = new ArrayList<>();
- Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
- Map<Pair<FunctionContext, FilterContext>, Integer> filterExpressionIndexMap = new HashMap<>();
+ List<Pair<AggregationFunction, FilterContext>> filteredAggregationFunctions = new ArrayList<>();
+ Map<Pair<FunctionContext, FilterContext>, Integer> filteredAggregationsIndexMap = new HashMap<>();
// Add aggregation functions in the SELECT clause
// NOTE: DO NOT deduplicate the aggregation functions in the SELECT clause because that involves protocol change.
- List<Pair<FilterContext, FunctionContext>> aggregationsInSelect = new ArrayList<>();
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations = new ArrayList<>();
for (ExpressionContext selectExpression : queryContext._selectExpressions) {
- getAggregations(selectExpression, aggregationsInSelect);
+ getAggregations(selectExpression, filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInSelect) {
- FunctionContext function = pair.getRight();
- int functionIndex = filteredAggregations.size();
- AggregationFunction aggregationFunction =
- AggregationFunctionFactory.getAggregationFunction(function, queryContext);
-
- FilterContext filterContext = null;
- // If the left pair is not null, implies a filtered aggregation
- if (pair.getLeft() != null) {
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ if (filter != null) {
+ // Filtered aggregation
if (_groupByExpressions != null) {
throw new IllegalStateException("GROUP BY with FILTER clauses is not supported");
}
queryContext._hasFilteredAggregations = true;
- filterContext = pair.getLeft();
- Pair<FunctionContext, FilterContext> filterContextPair =
- Pair.of(function, filterContext);
- if (!filterExpressionIndexMap.containsKey(filterContextPair)) {
- int filterMapIndex = filterExpressionIndexMap.size();
- filterExpressionIndexMap.put(filterContextPair, filterMapIndex);
- }
}
- filteredAggregations.add(Pair.of(aggregationFunction, filterContext));
- aggregationFunctionIndexMap.put(function, functionIndex);
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
- // Add aggregation functions in the HAVING clause but not in the SELECT clause
+ // Add aggregation functions in the HAVING and ORDER-BY clause but not in the SELECT clause
+ filteredAggregations.clear();
if (queryContext._havingFilter != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInHaving = new ArrayList<>();
- getAggregations(queryContext._havingFilter, aggregationsInHaving);
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInHaving) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
- }
+ getAggregations(queryContext._havingFilter, filteredAggregations);
}
-
- // Add aggregation functions in the ORDER-BY clause but not in the SELECT or HAVING clause
if (queryContext._orderByExpressions != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInOrderBy = new ArrayList<>();
for (OrderByExpressionContext orderByExpression : queryContext._orderByExpressions) {
- getAggregations(orderByExpression.getExpression(), aggregationsInOrderBy);
+ getAggregations(orderByExpression.getExpression(), filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInOrderBy) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
+ }
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ if (!filteredAggregationsIndexMap.containsKey(pair)) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
}
- if (!filteredAggregations.isEmpty()) {
- for (Pair<AggregationFunction, FilterContext> pair : filteredAggregations) {
- aggregationFunctions.add(pair.getLeft());
+ if (!filteredAggregationFunctions.isEmpty()) {
+ int numAggregations = filteredAggregationFunctions.size();
+ AggregationFunction[] aggregationFunctions = new AggregationFunction[numAggregations];
+ for (int i = 0; i < numAggregations; i++) {
+ aggregationFunctions[i] = filteredAggregationFunctions.get(i).getLeft();
}
-
- queryContext._aggregationFunctions = aggregationFunctions.toArray(new AggregationFunction[0]);
- queryContext._filteredAggregations = filteredAggregations;
+ Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
+ for (Map.Entry<Pair<FunctionContext, FilterContext>, Integer> entry : filteredAggregationsIndexMap.entrySet()) {
+ aggregationFunctionIndexMap.put(entry.getKey().getLeft(), entry.getValue());
+ }
+ queryContext._aggregationFunctions = aggregationFunctions;
+ queryContext._filteredAggregationFunctions = filteredAggregationFunctions;
queryContext._aggregationFunctionIndexMap = aggregationFunctionIndexMap;
- queryContext._filteredAggregationsIndexMap = filterExpressionIndexMap;
+ queryContext._filteredAggregationsIndexMap = filteredAggregationsIndexMap;
}
}
/**
- * Helper method to extract AGGREGATION FunctionContexts from the given expression.
- *
- * NOTE: The left pair of aggregations should be set only for filtered aggregations
+ * Helper method to extract AGGREGATION FunctionContexts and FILTER FilterContexts from the given expression.
*/
private static void getAggregations(ExpressionContext expression,
- List<Pair<FilterContext, FunctionContext>> aggregations) {
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations) {
FunctionContext function = expression.getFunction();
if (function == null) {
return;
}
if (function.getType() == FunctionContext.Type.AGGREGATION) {
// Aggregation
- aggregations.add(Pair.of(null, function));
+ filteredAggregations.add(Pair.of(function, null));
Review comment:
Naming change? Also relates to my original question around need to change the order of the pair.
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -459,104 +457,87 @@ public QueryContext build() {
* Helper method to generate the aggregation functions for the query.
*/
private void generateAggregationFunctions(QueryContext queryContext) {
- List<AggregationFunction> aggregationFunctions = new ArrayList<>();
- List<Pair<AggregationFunction, FilterContext>> filteredAggregations = new ArrayList<>();
- Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
- Map<Pair<FunctionContext, FilterContext>, Integer> filterExpressionIndexMap = new HashMap<>();
+ List<Pair<AggregationFunction, FilterContext>> filteredAggregationFunctions = new ArrayList<>();
+ Map<Pair<FunctionContext, FilterContext>, Integer> filteredAggregationsIndexMap = new HashMap<>();
Review comment:
Renaming changes?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -90,12 +90,11 @@
// Pre-calculate the aggregation functions and columns for the query so that it can be shared across all the segments
private AggregationFunction[] _aggregationFunctions;
+ private List<Pair<AggregationFunction, FilterContext>> _filteredAggregationFunctions;
- private List<Pair<AggregationFunction, FilterContext>> _filteredAggregations;
-
+ private Map<FunctionContext, Integer> _aggregationFunctionIndexMap;
Review comment:
Unintended relocation of declaration?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -459,104 +457,87 @@ public QueryContext build() {
* Helper method to generate the aggregation functions for the query.
*/
private void generateAggregationFunctions(QueryContext queryContext) {
- List<AggregationFunction> aggregationFunctions = new ArrayList<>();
- List<Pair<AggregationFunction, FilterContext>> filteredAggregations = new ArrayList<>();
- Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
- Map<Pair<FunctionContext, FilterContext>, Integer> filterExpressionIndexMap = new HashMap<>();
+ List<Pair<AggregationFunction, FilterContext>> filteredAggregationFunctions = new ArrayList<>();
+ Map<Pair<FunctionContext, FilterContext>, Integer> filteredAggregationsIndexMap = new HashMap<>();
// Add aggregation functions in the SELECT clause
// NOTE: DO NOT deduplicate the aggregation functions in the SELECT clause because that involves protocol change.
- List<Pair<FilterContext, FunctionContext>> aggregationsInSelect = new ArrayList<>();
+ List<Pair<FunctionContext, FilterContext>> filteredAggregations = new ArrayList<>();
for (ExpressionContext selectExpression : queryContext._selectExpressions) {
- getAggregations(selectExpression, aggregationsInSelect);
+ getAggregations(selectExpression, filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInSelect) {
- FunctionContext function = pair.getRight();
- int functionIndex = filteredAggregations.size();
- AggregationFunction aggregationFunction =
- AggregationFunctionFactory.getAggregationFunction(function, queryContext);
-
- FilterContext filterContext = null;
- // If the left pair is not null, implies a filtered aggregation
- if (pair.getLeft() != null) {
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ if (filter != null) {
+ // Filtered aggregation
if (_groupByExpressions != null) {
throw new IllegalStateException("GROUP BY with FILTER clauses is not supported");
}
queryContext._hasFilteredAggregations = true;
- filterContext = pair.getLeft();
- Pair<FunctionContext, FilterContext> filterContextPair =
- Pair.of(function, filterContext);
- if (!filterExpressionIndexMap.containsKey(filterContextPair)) {
- int filterMapIndex = filterExpressionIndexMap.size();
- filterExpressionIndexMap.put(filterContextPair, filterMapIndex);
- }
}
- filteredAggregations.add(Pair.of(aggregationFunction, filterContext));
- aggregationFunctionIndexMap.put(function, functionIndex);
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
- // Add aggregation functions in the HAVING clause but not in the SELECT clause
+ // Add aggregation functions in the HAVING and ORDER-BY clause but not in the SELECT clause
+ filteredAggregations.clear();
if (queryContext._havingFilter != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInHaving = new ArrayList<>();
- getAggregations(queryContext._havingFilter, aggregationsInHaving);
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInHaving) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
- }
+ getAggregations(queryContext._havingFilter, filteredAggregations);
}
-
- // Add aggregation functions in the ORDER-BY clause but not in the SELECT or HAVING clause
if (queryContext._orderByExpressions != null) {
- List<Pair<FilterContext, FunctionContext>> aggregationsInOrderBy = new ArrayList<>();
for (OrderByExpressionContext orderByExpression : queryContext._orderByExpressions) {
- getAggregations(orderByExpression.getExpression(), aggregationsInOrderBy);
+ getAggregations(orderByExpression.getExpression(), filteredAggregations);
}
- for (Pair<FilterContext, FunctionContext> pair : aggregationsInOrderBy) {
- FunctionContext function = pair.getRight();
- if (!aggregationFunctionIndexMap.containsKey(function)) {
- int functionIndex = filteredAggregations.size();
- filteredAggregations.add(Pair.of(
- AggregationFunctionFactory.getAggregationFunction(function, queryContext), null));
- aggregationFunctionIndexMap.put(function, functionIndex);
- }
+ }
+ for (Pair<FunctionContext, FilterContext> pair : filteredAggregations) {
+ if (!filteredAggregationsIndexMap.containsKey(pair)) {
+ FunctionContext aggregation = pair.getLeft();
+ FilterContext filter = pair.getRight();
+ int functionIndex = filteredAggregationFunctions.size();
+ AggregationFunction aggregationFunction =
+ AggregationFunctionFactory.getAggregationFunction(aggregation, queryContext);
+ filteredAggregationFunctions.add(Pair.of(aggregationFunction, filter));
+ filteredAggregationsIndexMap.put(Pair.of(aggregation, filter), functionIndex);
}
}
- if (!filteredAggregations.isEmpty()) {
- for (Pair<AggregationFunction, FilterContext> pair : filteredAggregations) {
- aggregationFunctions.add(pair.getLeft());
+ if (!filteredAggregationFunctions.isEmpty()) {
+ int numAggregations = filteredAggregationFunctions.size();
+ AggregationFunction[] aggregationFunctions = new AggregationFunction[numAggregations];
+ for (int i = 0; i < numAggregations; i++) {
+ aggregationFunctions[i] = filteredAggregationFunctions.get(i).getLeft();
}
-
- queryContext._aggregationFunctions = aggregationFunctions.toArray(new AggregationFunction[0]);
- queryContext._filteredAggregations = filteredAggregations;
+ Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
+ for (Map.Entry<Pair<FunctionContext, FilterContext>, Integer> entry : filteredAggregationsIndexMap.entrySet()) {
+ aggregationFunctionIndexMap.put(entry.getKey().getLeft(), entry.getValue());
Review comment:
Is aggregationFunctionIndexMap really needed anymore?
##########
File path: pinot-core/src/test/java/org/apache/pinot/queries/FilteredAggregationsTest.java
##########
@@ -106,27 +104,25 @@ public void tearDown() {
FileUtils.deleteQuietly(INDEX_DIR);
}
- private List<GenericRow> createTestData(int numRows) {
- List<GenericRow> rows = new ArrayList<>();
-
- for (int i = 0; i < numRows; i++) {
+ private List<GenericRow> createTestData() {
+ List<GenericRow> rows = new ArrayList<>(NUM_ROWS);
+ for (int i = 0; i < NUM_ROWS; i++) {
GenericRow row = new GenericRow();
- row.putField(INT_COL_NAME, INT_BASE_VALUE + i);
- row.putField(NO_INDEX_INT_COL_NAME, i);
- row.putField(STATIC_INT_COL_NAME, 10);
-
+ row.putValue(INT_COL_NAME, INT_BASE_VALUE + i);
+ row.putValue(NO_INDEX_INT_COL_NAME, i);
Review comment:
Whitespace changes?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/request/context/QueryContext.java
##########
@@ -459,104 +457,87 @@ public QueryContext build() {
* Helper method to generate the aggregation functions for the query.
*/
private void generateAggregationFunctions(QueryContext queryContext) {
- List<AggregationFunction> aggregationFunctions = new ArrayList<>();
- List<Pair<AggregationFunction, FilterContext>> filteredAggregations = new ArrayList<>();
- Map<FunctionContext, Integer> aggregationFunctionIndexMap = new HashMap<>();
- Map<Pair<FunctionContext, FilterContext>, Integer> filterExpressionIndexMap = new HashMap<>();
+ List<Pair<AggregationFunction, FilterContext>> filteredAggregationFunctions = new ArrayList<>();
+ Map<Pair<FunctionContext, FilterContext>, Integer> filteredAggregationsIndexMap = new HashMap<>();
// Add aggregation functions in the SELECT clause
// NOTE: DO NOT deduplicate the aggregation functions in the SELECT clause because that involves protocol change.
- List<Pair<FilterContext, FunctionContext>> aggregationsInSelect = new ArrayList<>();
Review comment:
I am not sure about this change. In the original PR, the initial implementation had `Pair<FunctionContext, FilterContext>`, but you (rightly) suggested that we do FilterContext first to follow convention. Also, looking at the usage of the same below, there seems to be no difference in using the prior or the later. Am I missing something, please?
##########
File path: pinot-core/src/main/java/org/apache/pinot/core/query/reduce/PostAggregationHandler.java
##########
@@ -117,19 +115,19 @@ public ValueExtractor getValueExtractor(ExpressionContext expression) {
}
}
FunctionContext function = expression.getFunction();
- Preconditions
- .checkState(function != null, "Failed to find SELECT expression: %s in the GROUP-BY clause", expression);
+ Preconditions.checkState(function != null, "Failed to find SELECT expression: %s in the GROUP-BY clause",
+ expression);
if (function.getType() == FunctionContext.Type.AGGREGATION) {
// Aggregation function
- return new ColumnValueExtractor(_aggregationFunctionIndexMap.get(function) + _numGroupByExpressions);
- } else if (function.getType() == FunctionContext.Type.TRANSFORM
- && function.getFunctionName().equalsIgnoreCase("filter")) {
+ return new ColumnValueExtractor(
+ _filteredAggregationsIndexMap.get(Pair.of(function, null)) + _numGroupByExpressions);
Review comment:
The main change here is that regular aggregations also refer to the filtered aggregation functions index map, instead of the standard index map. The remaining changes seem whitespace/naming changes?
##########
File path: pinot-core/src/test/java/org/apache/pinot/queries/FilteredAggregationsTest.java
##########
@@ -143,287 +139,172 @@ private void buildSegment(String segmentName)
}
}
- private void testInterSegmentAggregationQueryHelper(String firstQuery, String secondQuery) {
- // SQL
- BrokerResponseNative firstBrokerResponseNative = getBrokerResponseForSqlQuery(firstQuery);
- BrokerResponseNative secondBrokerResponseNative = getBrokerResponseForSqlQuery(secondQuery);
- ResultTable firstResultTable = firstBrokerResponseNative.getResultTable();
- ResultTable secondResultTable = secondBrokerResponseNative.getResultTable();
- DataSchema firstDataSchema = firstResultTable.getDataSchema();
- DataSchema secondDataSchema = secondResultTable.getDataSchema();
-
- Assert.assertEquals(firstDataSchema.size(), secondDataSchema.size());
-
- List<Object[]> firstSetOfRows = firstResultTable.getRows();
- List<Object[]> secondSetOfRows = secondResultTable.getRows();
-
- Assert.assertEquals(firstSetOfRows.size(), secondSetOfRows.size());
-
- for (int i = 0; i < firstSetOfRows.size(); i++) {
- Object[] firstSetRow = firstSetOfRows.get(i);
- Object[] secondSetRow = secondSetOfRows.get(i);
-
- Assert.assertEquals(firstSetRow.length, secondSetRow.length);
-
- for (int j = 0; j < firstSetRow.length; j++) {
- //System.out.println("FIRST " + firstSetRow[j] + " SECOND " + secondSetRow[j] + " j " + j);
- Assert.assertEquals(firstSetRow[j], secondSetRow[j]);
- }
+ private void testQuery(String filterQuery, String nonFilterQuery) {
+ List<Object[]> filterQueryResults = getBrokerResponseForSqlQuery(filterQuery).getResultTable().getRows();
+ List<Object[]> nonFilterQueryResults = getBrokerResponseForSqlQuery(nonFilterQuery).getResultTable().getRows();
+ assertEquals(filterQueryResults.size(), nonFilterQueryResults.size());
+ for (int i = 0; i < filterQueryResults.size(); i++) {
+ assertEquals(filterQueryResults.get(i), nonFilterQueryResults.get(i));
}
}
@Test
- public void testInterSegment() {
-
- String query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 9999)"
- + "FROM MyTable WHERE INT_COL < 1000000";
-
- String nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 9999 AND INT_COL < 1000000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 1234 AND INT_COL < 22000)"
- + "FROM MyTable";
-
- nonFilterQuery = "SELECT SUM(CASE "
- + "WHEN (INT_COL > 1234 AND INT_COL < 22000) THEN INT_COL ELSE 0 "
- + "END) AS total_sum FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL < 3)"
- + "FROM MyTable WHERE INT_COL > 1";
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 1 AND INT_COL < 3";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT COUNT(*) FILTER(WHERE INT_COL = 4)"
- + "FROM MyTable";
- nonFilterQuery =
- "SELECT COUNT(*)"
- + "FROM MyTable WHERE INT_COL = 4";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 8000)"
- + "FROM MyTable ";
-
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 8000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE NO_INDEX_COL <= 1)"
- + "FROM MyTable WHERE INT_COL > 1";
-
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL <= 1 AND INT_COL > 1";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT AVG(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > -1";
- nonFilterQuery =
- "SELECT AVG(NO_INDEX_COL)"
- + "FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),SUM(NO_INDEX_COL),MAX(INT_COL) "
- + "FROM MyTable";
-
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,SUM(NO_INDEX_COL),"
- + "MAX(INT_COL) FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT AVG(INT_COL) FILTER(WHERE NO_INDEX_COL > -1) FROM MyTable";
- nonFilterQuery =
- "SELECT AVG(NO_INDEX_COL) FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL) FROM MyTable";
-
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,MAX(NO_INDEX_COL)"
- + "FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > 5";
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,MAX(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > 5";
+ public void testSimpleQueries() {
Review comment:
Naming + whitespace changes?
##########
File path: pinot-core/src/test/java/org/apache/pinot/queries/FilteredAggregationsTest.java
##########
@@ -143,287 +139,172 @@ private void buildSegment(String segmentName)
}
}
- private void testInterSegmentAggregationQueryHelper(String firstQuery, String secondQuery) {
- // SQL
- BrokerResponseNative firstBrokerResponseNative = getBrokerResponseForSqlQuery(firstQuery);
- BrokerResponseNative secondBrokerResponseNative = getBrokerResponseForSqlQuery(secondQuery);
- ResultTable firstResultTable = firstBrokerResponseNative.getResultTable();
- ResultTable secondResultTable = secondBrokerResponseNative.getResultTable();
- DataSchema firstDataSchema = firstResultTable.getDataSchema();
- DataSchema secondDataSchema = secondResultTable.getDataSchema();
-
- Assert.assertEquals(firstDataSchema.size(), secondDataSchema.size());
-
- List<Object[]> firstSetOfRows = firstResultTable.getRows();
- List<Object[]> secondSetOfRows = secondResultTable.getRows();
-
- Assert.assertEquals(firstSetOfRows.size(), secondSetOfRows.size());
-
- for (int i = 0; i < firstSetOfRows.size(); i++) {
- Object[] firstSetRow = firstSetOfRows.get(i);
- Object[] secondSetRow = secondSetOfRows.get(i);
-
- Assert.assertEquals(firstSetRow.length, secondSetRow.length);
-
- for (int j = 0; j < firstSetRow.length; j++) {
- //System.out.println("FIRST " + firstSetRow[j] + " SECOND " + secondSetRow[j] + " j " + j);
- Assert.assertEquals(firstSetRow[j], secondSetRow[j]);
- }
+ private void testQuery(String filterQuery, String nonFilterQuery) {
+ List<Object[]> filterQueryResults = getBrokerResponseForSqlQuery(filterQuery).getResultTable().getRows();
Review comment:
I am not sure if this method has the same intent as the original method -- the original method had extra checks around row lengths and number of rows, and the result schemas. Can we please revert this? This anyways does not seem related to the problem the PR is solving.
##########
File path: pinot-core/src/test/java/org/apache/pinot/queries/FilteredAggregationsTest.java
##########
@@ -143,287 +139,172 @@ private void buildSegment(String segmentName)
}
}
- private void testInterSegmentAggregationQueryHelper(String firstQuery, String secondQuery) {
- // SQL
- BrokerResponseNative firstBrokerResponseNative = getBrokerResponseForSqlQuery(firstQuery);
- BrokerResponseNative secondBrokerResponseNative = getBrokerResponseForSqlQuery(secondQuery);
- ResultTable firstResultTable = firstBrokerResponseNative.getResultTable();
- ResultTable secondResultTable = secondBrokerResponseNative.getResultTable();
- DataSchema firstDataSchema = firstResultTable.getDataSchema();
- DataSchema secondDataSchema = secondResultTable.getDataSchema();
-
- Assert.assertEquals(firstDataSchema.size(), secondDataSchema.size());
-
- List<Object[]> firstSetOfRows = firstResultTable.getRows();
- List<Object[]> secondSetOfRows = secondResultTable.getRows();
-
- Assert.assertEquals(firstSetOfRows.size(), secondSetOfRows.size());
-
- for (int i = 0; i < firstSetOfRows.size(); i++) {
- Object[] firstSetRow = firstSetOfRows.get(i);
- Object[] secondSetRow = secondSetOfRows.get(i);
-
- Assert.assertEquals(firstSetRow.length, secondSetRow.length);
-
- for (int j = 0; j < firstSetRow.length; j++) {
- //System.out.println("FIRST " + firstSetRow[j] + " SECOND " + secondSetRow[j] + " j " + j);
- Assert.assertEquals(firstSetRow[j], secondSetRow[j]);
- }
+ private void testQuery(String filterQuery, String nonFilterQuery) {
+ List<Object[]> filterQueryResults = getBrokerResponseForSqlQuery(filterQuery).getResultTable().getRows();
+ List<Object[]> nonFilterQueryResults = getBrokerResponseForSqlQuery(nonFilterQuery).getResultTable().getRows();
+ assertEquals(filterQueryResults.size(), nonFilterQueryResults.size());
+ for (int i = 0; i < filterQueryResults.size(); i++) {
+ assertEquals(filterQueryResults.get(i), nonFilterQueryResults.get(i));
}
}
@Test
- public void testInterSegment() {
-
- String query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 9999)"
- + "FROM MyTable WHERE INT_COL < 1000000";
-
- String nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 9999 AND INT_COL < 1000000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 1234 AND INT_COL < 22000)"
- + "FROM MyTable";
-
- nonFilterQuery = "SELECT SUM(CASE "
- + "WHEN (INT_COL > 1234 AND INT_COL < 22000) THEN INT_COL ELSE 0 "
- + "END) AS total_sum FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL < 3)"
- + "FROM MyTable WHERE INT_COL > 1";
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 1 AND INT_COL < 3";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT COUNT(*) FILTER(WHERE INT_COL = 4)"
- + "FROM MyTable";
- nonFilterQuery =
- "SELECT COUNT(*)"
- + "FROM MyTable WHERE INT_COL = 4";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 8000)"
- + "FROM MyTable ";
-
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE INT_COL > 8000";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE NO_INDEX_COL <= 1)"
- + "FROM MyTable WHERE INT_COL > 1";
-
- nonFilterQuery =
- "SELECT SUM(INT_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL <= 1 AND INT_COL > 1";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT AVG(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > -1";
- nonFilterQuery =
- "SELECT AVG(NO_INDEX_COL)"
- + "FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),SUM(NO_INDEX_COL),MAX(INT_COL) "
- + "FROM MyTable";
-
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,SUM(NO_INDEX_COL),"
- + "MAX(INT_COL) FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT AVG(INT_COL) FILTER(WHERE NO_INDEX_COL > -1) FROM MyTable";
- nonFilterQuery =
- "SELECT AVG(NO_INDEX_COL) FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL) FROM MyTable";
-
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,MAX(NO_INDEX_COL)"
- + "FROM MyTable";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT SUM(INT_COL) FILTER(WHERE INT_COL % 10 = 0),MAX(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > 5";
- nonFilterQuery =
- "SELECT SUM(CASE WHEN (INT_COL % 10 = 0) THEN INT_COL ELSE 0 END) AS total_sum,MAX(NO_INDEX_COL)"
- + "FROM MyTable WHERE NO_INDEX_COL > 5";
+ public void testSimpleQueries() {
+ String filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 9999) FROM MyTable WHERE INT_COL < 1000000";
+ String nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE INT_COL > 9999 AND INT_COL < 1000000";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL < 3) FROM MyTable WHERE INT_COL > 1";
+ nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE INT_COL > 1 AND INT_COL < 3";
+ testQuery(filterQuery, nonFilterQuery);
- query =
- "SELECT MAX(INT_COL) FILTER(WHERE INT_COL < 100) FROM MyTable";
+ filterQuery = "SELECT COUNT(*) FILTER(WHERE INT_COL = 4) FROM MyTable";
+ nonFilterQuery = "SELECT COUNT(*) FROM MyTable WHERE INT_COL = 4";
+ testQuery(filterQuery, nonFilterQuery);
- nonFilterQuery =
- "SELECT MAX(CASE WHEN (INT_COL < 100) THEN INT_COL ELSE 0 END) AS total_max FROM MyTable";
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 8000) FROM MyTable ";
+ nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE INT_COL > 8000";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
+ filterQuery = "SELECT SUM(INT_COL) FILTER(WHERE NO_INDEX_COL <= 1) FROM MyTable WHERE INT_COL > 1";
+ nonFilterQuery = "SELECT SUM(INT_COL) FROM MyTable WHERE NO_INDEX_COL <= 1 AND INT_COL > 1";
+ testQuery(filterQuery, nonFilterQuery);
- query =
- "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL < 100) FROM MyTable";
+ filterQuery = "SELECT AVG(NO_INDEX_COL) FROM MyTable WHERE NO_INDEX_COL > -1";
+ nonFilterQuery = "SELECT AVG(NO_INDEX_COL) FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
- nonFilterQuery =
- "SELECT MIN(CASE WHEN (INT_COL < 100) THEN NO_INDEX_COL ELSE 0 END) AS total_min "
- + "FROM MyTable";
+ filterQuery = "SELECT AVG(INT_COL) FILTER(WHERE NO_INDEX_COL > -1) FROM MyTable";
+ nonFilterQuery = "SELECT AVG(NO_INDEX_COL) FROM MyTable";
+ testQuery(filterQuery, nonFilterQuery);
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
-
- query =
- "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL > 29990),MAX(INT_COL) FILTER(WHERE INT_COL > 29990)"
- + "FROM MyTable";
-
- nonFilterQuery =
- "SELECT MIN(NO_INDEX_COL), MAX(INT_COL) FROM MyTable WHERE INT_COL > 29990";
-
- testInterSegmentAggregationQueryHelper(query, nonFilterQuery);
+ filterQuery = "SELECT MIN(NO_INDEX_COL) FILTER(WHERE INT_COL > 29990), MAX(INT_COL) FILTER(WHERE INT_COL > 29990) "
+ + "FROM MyTable";
+ nonFilterQuery = "SELECT MIN(NO_INDEX_COL), MAX(INT_COL) FROM MyTable WHERE INT_COL > 29990";
+ testQuery(filterQuery, nonFilterQuery);
}
@Test
- public void testCaseVsFilter() {
- String query = "SELECT SUM(INT_COL) FILTER(WHERE INT_COL > 3),"
- + "SUM(INT_COL) FILTER(WHERE INT_COL < 4)"
- + "FROM MyTable WHERE INT_COL > 2";
-
- String nonFilterQuery = "SELECT SUM(CASE WHEN (INT_COL > 3) THEN INT_COL ELSE 0 "
- + "END) AS total_sum,SUM(CASE WHEN (INT_COL < 4) THEN INT_COL ELSE 0 END) AS total_sum2 "
+ public void testFilterVsCase() {
Review comment:
Naming + whitespace changes?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@pinot.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pinot.apache.org
For additional commands, e-mail: commits-help@pinot.apache.org