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-unsubscr...@pinot.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@pinot.apache.org
For additional commands, e-mail: commits-h...@pinot.apache.org
