This is an automated email from the ASF dual-hosted git repository.
jackie pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pinot.git
The following commit(s) were added to refs/heads/master by this push:
new daa6d11839 Add argument check for aggregation functions with single
argument (#11556)
daa6d11839 is described below
commit daa6d118396834135457d253cba0d6540b3cfa61
Author: Xiaotian (Jackie) Jiang <[email protected]>
AuthorDate: Wed Sep 13 00:24:23 2023 -0700
Add argument check for aggregation functions with single argument (#11556)
---
.../function/AggregationFunctionFactory.java | 181 ++++++++++-----------
.../function/AvgAggregationFunction.java | 7 +-
.../function/AvgMVAggregationFunction.java | 5 +-
.../BaseSingleInputAggregationFunction.java | 7 +
.../function/BooleanAndAggregationFunction.java | 9 +-
.../function/BooleanOrAggregationFunction.java | 9 +-
.../function/CountAggregationFunction.java | 12 +-
.../function/CountMVAggregationFunction.java | 9 +-
.../function/DistinctAvgAggregationFunction.java | 5 +-
.../function/DistinctAvgMVAggregationFunction.java | 5 +-
.../function/DistinctCountAggregationFunction.java | 6 +-
.../DistinctCountBitmapAggregationFunction.java | 7 +-
.../DistinctCountBitmapMVAggregationFunction.java | 5 +-
.../DistinctCountMVAggregationFunction.java | 6 +-
.../function/DistinctSumAggregationFunction.java | 5 +-
.../function/DistinctSumMVAggregationFunction.java | 5 +-
.../function/FastHLLAggregationFunction.java | 9 +-
.../function/FourthMomentAggregationFunction.java | 5 +-
.../function/MaxAggregationFunction.java | 7 +-
.../function/MaxMVAggregationFunction.java | 5 +-
.../function/MinAggregationFunction.java | 7 +-
.../function/MinMVAggregationFunction.java | 5 +-
.../function/MinMaxRangeAggregationFunction.java | 7 +-
.../function/MinMaxRangeMVAggregationFunction.java | 5 +-
...artitionedDistinctCountAggregationFunction.java | 5 +-
.../function/StUnionAggregationFunction.java | 10 +-
.../function/SumAggregationFunction.java | 7 +-
.../function/SumMVAggregationFunction.java | 5 +-
.../function/VarianceAggregationFunction.java | 9 +-
.../org/apache/pinot/queries/ExprMinMaxTest.java | 11 +-
30 files changed, 202 insertions(+), 178 deletions(-)
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AggregationFunctionFactory.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AggregationFunctionFactory.java
index 504a09391c..7f5695aa6c 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AggregationFunctionFactory.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AggregationFunctionFactory.java
@@ -46,6 +46,7 @@ public class AggregationFunctionFactory {
String upperCaseFunctionName =
AggregationFunctionType.getNormalizedAggregationFunctionName(function.getFunctionName());
List<ExpressionContext> arguments = function.getArguments();
+ int numArguments = arguments.size();
ExpressionContext firstArgument = arguments.get(0);
if (upperCaseFunctionName.startsWith("PERCENTILE")) {
String remainingFunctionName = upperCaseFunctionName.substring(10);
@@ -64,7 +65,6 @@ public class AggregationFunctionFactory {
if (remainingFunctionName.equals("RAWKLLMV")) {
return new PercentileRawKLLMVAggregationFunction(arguments);
}
- int numArguments = arguments.size();
if (numArguments == 1) {
// Single argument percentile (e.g. Percentile99(foo),
PercentileTDigest95(bar), etc.)
// NOTE: This convention is deprecated. DO NOT add new functions here
@@ -181,88 +181,85 @@ public class AggregationFunctionFactory {
}
throw new IllegalArgumentException("Invalid percentile function: " +
function);
} else {
- switch (AggregationFunctionType.valueOf(upperCaseFunctionName)) {
+ AggregationFunctionType functionType =
AggregationFunctionType.valueOf(upperCaseFunctionName);
+ switch (functionType) {
case COUNT:
- return new CountAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new CountAggregationFunction(arguments,
nullHandlingEnabled);
case MIN:
- return new MinAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new MinAggregationFunction(arguments, nullHandlingEnabled);
case MAX:
- return new MaxAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new MaxAggregationFunction(arguments, nullHandlingEnabled);
case SUM:
case SUM0:
- return new SumAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new SumAggregationFunction(arguments, nullHandlingEnabled);
case SUMPRECISION:
return new SumPrecisionAggregationFunction(arguments,
nullHandlingEnabled);
case AVG:
- return new AvgAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new AvgAggregationFunction(arguments, nullHandlingEnabled);
case MODE:
return new ModeAggregationFunction(arguments);
- case FIRSTWITHTIME:
- if (arguments.size() == 3) {
- ExpressionContext timeCol = arguments.get(1);
- ExpressionContext dataType = arguments.get(2);
- if (dataType.getType() != ExpressionContext.Type.LITERAL) {
- throw new IllegalArgumentException("Third argument of
firstWithTime Function should be literal."
- + " The function can be used as firstWithTime(dataColumn,
timeColumn, 'dataType')");
- }
- DataType fieldDataType =
DataType.valueOf(dataType.getLiteral().getStringValue().toUpperCase());
- switch (fieldDataType) {
- case BOOLEAN:
- case INT:
- return new
FirstIntValueWithTimeAggregationFunction(firstArgument, timeCol,
- fieldDataType == DataType.BOOLEAN);
- case LONG:
- return new
FirstLongValueWithTimeAggregationFunction(firstArgument, timeCol);
- case FLOAT:
- return new
FirstFloatValueWithTimeAggregationFunction(firstArgument, timeCol);
- case DOUBLE:
- return new
FirstDoubleValueWithTimeAggregationFunction(firstArgument, timeCol);
- case STRING:
- return new
FirstStringValueWithTimeAggregationFunction(firstArgument, timeCol);
- default:
- throw new IllegalArgumentException("Unsupported Value Type
for firstWithTime Function:" + dataType);
- }
- } else {
- throw new IllegalArgumentException("Three arguments are required
for firstWithTime Function."
- + " The function can be used as firstWithTime(dataColumn,
timeColumn, 'dataType')");
+ case FIRSTWITHTIME: {
+ Preconditions.checkArgument(numArguments == 3,
+ "FIRST_WITH_TIME expects 3 arguments, got: %s. The function
can be used as "
+ + "firstWithTime(dataColumn, timeColumn, 'dataType')",
numArguments);
+ ExpressionContext timeCol = arguments.get(1);
+ ExpressionContext dataTypeExp = arguments.get(2);
+ Preconditions.checkArgument(dataTypeExp.getType() ==
ExpressionContext.Type.LITERAL,
+ "FIRST_WITH_TIME expects the 3rd argument to be literal, got:
%s. The function can be used as "
+ + "firstWithTime(dataColumn, timeColumn, 'dataType')",
dataTypeExp.getType());
+ DataType dataType =
DataType.valueOf(dataTypeExp.getLiteral().getStringValue().toUpperCase());
+ switch (dataType) {
+ case BOOLEAN:
+ return new
FirstIntValueWithTimeAggregationFunction(firstArgument, timeCol, true);
+ case INT:
+ return new
FirstIntValueWithTimeAggregationFunction(firstArgument, timeCol, false);
+ case LONG:
+ return new
FirstLongValueWithTimeAggregationFunction(firstArgument, timeCol);
+ case FLOAT:
+ return new
FirstFloatValueWithTimeAggregationFunction(firstArgument, timeCol);
+ case DOUBLE:
+ return new
FirstDoubleValueWithTimeAggregationFunction(firstArgument, timeCol);
+ case STRING:
+ return new
FirstStringValueWithTimeAggregationFunction(firstArgument, timeCol);
+ default:
+ throw new IllegalArgumentException("Unsupported data type for
FIRST_WITH_TIME: " + dataType);
}
- case LASTWITHTIME:
- if (arguments.size() == 3) {
- ExpressionContext timeCol = arguments.get(1);
- ExpressionContext dataType = arguments.get(2);
- if (dataType.getType() != ExpressionContext.Type.LITERAL) {
- throw new IllegalArgumentException("Third argument of
lastWithTime Function should be literal."
- + " The function can be used as lastWithTime(dataColumn,
timeColumn, 'dataType')");
- }
- DataType fieldDataType =
DataType.valueOf(dataType.getLiteral().getStringValue().toUpperCase());
- switch (fieldDataType) {
- case BOOLEAN:
- case INT:
- return new
LastIntValueWithTimeAggregationFunction(firstArgument, timeCol,
- fieldDataType == DataType.BOOLEAN);
- case LONG:
- return new
LastLongValueWithTimeAggregationFunction(firstArgument, timeCol);
- case FLOAT:
- return new
LastFloatValueWithTimeAggregationFunction(firstArgument, timeCol);
- case DOUBLE:
- return new
LastDoubleValueWithTimeAggregationFunction(firstArgument, timeCol);
- case STRING:
- return new
LastStringValueWithTimeAggregationFunction(firstArgument, timeCol);
- default:
- throw new IllegalArgumentException("Unsupported Value Type
for lastWithTime Function:" + dataType);
- }
- } else {
- throw new IllegalArgumentException("Three arguments are required
for lastWithTime Function."
- + " The function can be used as lastWithTime(dataColumn,
timeColumn, 'dataType')");
+ }
+ case LASTWITHTIME: {
+ Preconditions.checkArgument(numArguments == 3,
+ "LAST_WITH_TIME expects 3 arguments, got: %s. The function can
be used as "
+ + "lastWithTime(dataColumn, timeColumn, 'dataType')",
numArguments);
+ ExpressionContext timeCol = arguments.get(1);
+ ExpressionContext dataTypeExp = arguments.get(2);
+ Preconditions.checkArgument(dataTypeExp.getType() ==
ExpressionContext.Type.LITERAL,
+ "LAST_WITH_TIME expects the 3rd argument to be literal, got:
%s. The function can be used as "
+ + "lastWithTime(dataColumn, timeColumn, 'dataType')",
dataTypeExp.getType());
+ DataType dataType =
DataType.valueOf(dataTypeExp.getLiteral().getStringValue().toUpperCase());
+ switch (dataType) {
+ case BOOLEAN:
+ return new
LastIntValueWithTimeAggregationFunction(firstArgument, timeCol, true);
+ case INT:
+ return new
LastIntValueWithTimeAggregationFunction(firstArgument, timeCol, false);
+ case LONG:
+ return new
LastLongValueWithTimeAggregationFunction(firstArgument, timeCol);
+ case FLOAT:
+ return new
LastFloatValueWithTimeAggregationFunction(firstArgument, timeCol);
+ case DOUBLE:
+ return new
LastDoubleValueWithTimeAggregationFunction(firstArgument, timeCol);
+ case STRING:
+ return new
LastStringValueWithTimeAggregationFunction(firstArgument, timeCol);
+ default:
+ throw new IllegalArgumentException("Unsupported data type for
LAST_WITH_TIME: " + dataType);
}
+ }
case MINMAXRANGE:
- return new MinMaxRangeAggregationFunction(firstArgument);
+ return new MinMaxRangeAggregationFunction(arguments);
case DISTINCTCOUNT:
- return new DistinctCountAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new DistinctCountAggregationFunction(arguments,
nullHandlingEnabled);
case DISTINCTCOUNTBITMAP:
- return new DistinctCountBitmapAggregationFunction(firstArgument);
+ return new DistinctCountBitmapAggregationFunction(arguments);
case SEGMENTPARTITIONEDDISTINCTCOUNT:
- return new
SegmentPartitionedDistinctCountAggregationFunction(firstArgument);
+ return new
SegmentPartitionedDistinctCountAggregationFunction(arguments);
case DISTINCTCOUNTHLL:
return new DistinctCountHLLAggregationFunction(arguments);
case DISTINCTCOUNTRAWHLL:
@@ -270,43 +267,43 @@ public class AggregationFunctionFactory {
case DISTINCTCOUNTSMARTHLL:
return new DistinctCountSmartHLLAggregationFunction(arguments);
case FASTHLL:
- return new FastHLLAggregationFunction(firstArgument);
+ return new FastHLLAggregationFunction(arguments);
case DISTINCTCOUNTTHETASKETCH:
return new DistinctCountThetaSketchAggregationFunction(arguments);
case DISTINCTCOUNTRAWTHETASKETCH:
return new
DistinctCountRawThetaSketchAggregationFunction(arguments);
case DISTINCTSUM:
- return new DistinctSumAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new DistinctSumAggregationFunction(arguments,
nullHandlingEnabled);
case DISTINCTAVG:
- return new DistinctAvgAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new DistinctAvgAggregationFunction(arguments,
nullHandlingEnabled);
case IDSET:
return new IdSetAggregationFunction(arguments);
case COUNTMV:
- return new CountMVAggregationFunction(firstArgument);
+ return new CountMVAggregationFunction(arguments);
case MINMV:
- return new MinMVAggregationFunction(firstArgument);
+ return new MinMVAggregationFunction(arguments);
case MAXMV:
- return new MaxMVAggregationFunction(firstArgument);
+ return new MaxMVAggregationFunction(arguments);
case SUMMV:
- return new SumMVAggregationFunction(firstArgument);
+ return new SumMVAggregationFunction(arguments);
case AVGMV:
- return new AvgMVAggregationFunction(firstArgument);
+ return new AvgMVAggregationFunction(arguments);
case MINMAXRANGEMV:
- return new MinMaxRangeMVAggregationFunction(firstArgument);
+ return new MinMaxRangeMVAggregationFunction(arguments);
case DISTINCTCOUNTMV:
- return new DistinctCountMVAggregationFunction(firstArgument);
+ return new DistinctCountMVAggregationFunction(arguments);
case DISTINCTCOUNTBITMAPMV:
- return new DistinctCountBitmapMVAggregationFunction(firstArgument);
+ return new DistinctCountBitmapMVAggregationFunction(arguments);
case DISTINCTCOUNTHLLMV:
return new DistinctCountHLLMVAggregationFunction(arguments);
case DISTINCTCOUNTRAWHLLMV:
return new DistinctCountRawHLLMVAggregationFunction(arguments);
case DISTINCTSUMMV:
- return new DistinctSumMVAggregationFunction(firstArgument);
+ return new DistinctSumMVAggregationFunction(arguments);
case DISTINCTAVGMV:
- return new DistinctAvgMVAggregationFunction(firstArgument);
+ return new DistinctAvgMVAggregationFunction(arguments);
case STUNION:
- return new StUnionAggregationFunction(firstArgument);
+ return new StUnionAggregationFunction(arguments);
case HISTOGRAM:
return new HistogramAggregationFunction(arguments);
case COVARPOP:
@@ -314,23 +311,23 @@ public class AggregationFunctionFactory {
case COVARSAMP:
return new CovarianceAggregationFunction(arguments, true);
case BOOLAND:
- return new BooleanAndAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new BooleanAndAggregationFunction(arguments,
nullHandlingEnabled);
case BOOLOR:
- return new BooleanOrAggregationFunction(firstArgument,
nullHandlingEnabled);
+ return new BooleanOrAggregationFunction(arguments,
nullHandlingEnabled);
case VARPOP:
- return new VarianceAggregationFunction(firstArgument, false,
false, nullHandlingEnabled);
+ return new VarianceAggregationFunction(arguments, false, false,
nullHandlingEnabled);
case VARSAMP:
- return new VarianceAggregationFunction(firstArgument, true, false,
nullHandlingEnabled);
+ return new VarianceAggregationFunction(arguments, true, false,
nullHandlingEnabled);
case STDDEVPOP:
- return new VarianceAggregationFunction(firstArgument, false, true,
nullHandlingEnabled);
+ return new VarianceAggregationFunction(arguments, false, true,
nullHandlingEnabled);
case STDDEVSAMP:
- return new VarianceAggregationFunction(firstArgument, true, true,
nullHandlingEnabled);
+ return new VarianceAggregationFunction(arguments, true, true,
nullHandlingEnabled);
case SKEWNESS:
- return new FourthMomentAggregationFunction(firstArgument,
FourthMomentAggregationFunction.Type.SKEWNESS);
+ return new FourthMomentAggregationFunction(arguments,
FourthMomentAggregationFunction.Type.SKEWNESS);
case KURTOSIS:
- return new FourthMomentAggregationFunction(firstArgument,
FourthMomentAggregationFunction.Type.KURTOSIS);
+ return new FourthMomentAggregationFunction(arguments,
FourthMomentAggregationFunction.Type.KURTOSIS);
case FOURTHMOMENT:
- return new FourthMomentAggregationFunction(firstArgument,
FourthMomentAggregationFunction.Type.MOMENT);
+ return new FourthMomentAggregationFunction(arguments,
FourthMomentAggregationFunction.Type.MOMENT);
case DISTINCTCOUNTTUPLESKETCH:
// mode actually doesn't matter here because we only care about
keys, not values
return new
DistinctCountIntegerTupleSketchAggregationFunction(arguments,
IntegerSummary.Mode.Sum);
@@ -351,12 +348,12 @@ public class AggregationFunctionFactory {
case EXPRMAX:
case EXPRMIN:
throw new IllegalArgumentException(
- "Aggregation function: " + function + " is only supported in
selection without alias.");
+ "Aggregation function: " + functionType + " is only supported
in selection without alias.");
case FUNNELCOUNT:
return new FunnelCountAggregationFunctionFactory(arguments).get();
default:
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException("Unsupported aggregation
function type: " + functionType);
}
}
} catch (Exception e) {
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgAggregationFunction.java
index af25be19fb..9dbfb6cec5 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -37,11 +38,11 @@ public class AvgAggregationFunction extends
BaseSingleInputAggregationFunction<A
private static final double DEFAULT_FINAL_RESULT = Double.NEGATIVE_INFINITY;
private final boolean _nullHandlingEnabled;
- public AvgAggregationFunction(ExpressionContext expression) {
- this(expression, false);
+ public AvgAggregationFunction(List<ExpressionContext> arguments, boolean
nullHandlingEnabled) {
+ this(verifySingleArgument(arguments, "AVG"), nullHandlingEnabled);
}
- public AvgAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
+ protected AvgAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
super(expression);
_nullHandlingEnabled = nullHandlingEnabled;
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgMVAggregationFunction.java
index 39b429117a..50be99a05a 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/AvgMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -28,8 +29,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
public class AvgMVAggregationFunction extends AvgAggregationFunction {
- public AvgMVAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public AvgMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "AVG_MV"), false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BaseSingleInputAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BaseSingleInputAggregationFunction.java
index 84ff537a9c..6c15d06e08 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BaseSingleInputAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BaseSingleInputAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -60,4 +61,10 @@ public abstract class BaseSingleInputAggregationFunction<I,
F extends Comparable
}
return stringBuilder.append(')').toString();
}
+
+ protected static ExpressionContext
verifySingleArgument(List<ExpressionContext> arguments, String functionName) {
+ Preconditions.checkArgument(arguments.size() == 1, "%s expects 1 argument,
got: %s", functionName,
+ arguments.size());
+ return arguments.get(0);
+ }
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanAndAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanAndAggregationFunction.java
index c385e1dcfb..d328356a40 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanAndAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanAndAggregationFunction.java
@@ -19,18 +19,15 @@
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.segment.spi.AggregationFunctionType;
public class BooleanAndAggregationFunction extends
BaseBooleanAggregationFunction {
- public BooleanAndAggregationFunction(ExpressionContext expression) {
- this(expression, false);
- }
-
- public BooleanAndAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
- super(expression, nullHandlingEnabled, BooleanMerge.AND);
+ public BooleanAndAggregationFunction(List<ExpressionContext> arguments,
boolean nullHandlingEnabled) {
+ super(verifySingleArgument(arguments, "BOOL_AND"), nullHandlingEnabled,
BooleanMerge.AND);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanOrAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanOrAggregationFunction.java
index 6ee96fad49..eb7582e23a 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanOrAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/BooleanOrAggregationFunction.java
@@ -19,18 +19,15 @@
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.segment.spi.AggregationFunctionType;
public class BooleanOrAggregationFunction extends
BaseBooleanAggregationFunction {
- public BooleanOrAggregationFunction(ExpressionContext expression) {
- this(expression, false);
- }
-
- protected BooleanOrAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
- super(expression, nullHandlingEnabled, BooleanMerge.OR);
+ public BooleanOrAggregationFunction(List<ExpressionContext> arguments,
boolean nullHandlingEnabled) {
+ super(verifySingleArgument(arguments, "BOOL_OR"), nullHandlingEnabled,
BooleanMerge.OR);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountAggregationFunction.java
index e9861193f4..bc730adb05 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountAggregationFunction.java
@@ -42,18 +42,18 @@ public class CountAggregationFunction extends
BaseSingleInputAggregationFunction
private final boolean _nullHandlingEnabled;
- public CountAggregationFunction(ExpressionContext expression) {
- this(expression, false);
+ public CountAggregationFunction(List<ExpressionContext> arguments, boolean
nullHandlingEnabled) {
+ this(verifySingleArgument(arguments, "COUNT"), nullHandlingEnabled);
}
- public CountAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
+ protected CountAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
super(expression);
// Consider null values only when null handling is enabled and function is
not COUNT(*)
// Note COUNT on any literal gives same result as COUNT(*)
// So allow for identifiers that are not * and functions, disable for
literals and *
- _nullHandlingEnabled = nullHandlingEnabled
- && ((expression.getType() == ExpressionContext.Type.IDENTIFIER &&
!expression.getIdentifier().equals("*"))
- || (expression.getType() == ExpressionContext.Type.FUNCTION));
+ _nullHandlingEnabled = nullHandlingEnabled && (
+ (expression.getType() == ExpressionContext.Type.IDENTIFIER &&
!expression.getIdentifier().equals("*")) || (
+ expression.getType() == ExpressionContext.Type.FUNCTION));
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountMVAggregationFunction.java
index cb7ab591fb..6ca1121770 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/CountMVAggregationFunction.java
@@ -30,14 +30,9 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
public class CountMVAggregationFunction extends CountAggregationFunction {
- /**
- * Constructor for the class.
- *
- * @param expression Expression to aggregate on.
- */
- public CountMVAggregationFunction(ExpressionContext expression) {
+ public CountMVAggregationFunction(List<ExpressionContext> arguments) {
// TODO(nhejazi): support proper null handling for aggregation functions
on MV columns.
- super(expression);
+ super(verifySingleArgument(arguments, "COUNT_MV"), false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgAggregationFunction.java
index f3d45eed27..7194783910 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -33,8 +34,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
*/
public class DistinctAvgAggregationFunction extends
BaseDistinctAggregateAggregationFunction<Double> {
- public DistinctAvgAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
- super(expression, AggregationFunctionType.DISTINCTAVG,
nullHandlingEnabled);
+ public DistinctAvgAggregationFunction(List<ExpressionContext> arguments,
boolean nullHandlingEnabled) {
+ super(verifySingleArgument(arguments, "DISTINCT_AVG"),
AggregationFunctionType.DISTINCTAVG, nullHandlingEnabled);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgMVAggregationFunction.java
index 5f7f04e8ee..37f877000c 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctAvgMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -33,8 +34,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
*/
public class DistinctAvgMVAggregationFunction extends
BaseDistinctAggregateAggregationFunction<Double> {
- public DistinctAvgMVAggregationFunction(ExpressionContext expression) {
- super(expression, AggregationFunctionType.DISTINCTAVGMV, false);
+ public DistinctAvgMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "DISTINCT_AVG_MV"),
AggregationFunctionType.DISTINCTAVGMV, false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountAggregationFunction.java
index a31779ab6b..61588bbecb 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -33,8 +34,9 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
*/
public class DistinctCountAggregationFunction extends
BaseDistinctAggregateAggregationFunction<Integer> {
- public DistinctCountAggregationFunction(ExpressionContext expression,
boolean nullHandlingEnabled) {
- super(expression, AggregationFunctionType.DISTINCTCOUNT,
nullHandlingEnabled);
+ public DistinctCountAggregationFunction(List<ExpressionContext> arguments,
boolean nullHandlingEnabled) {
+ super(verifySingleArgument(arguments, "DISTINCT_COUNT"),
AggregationFunctionType.DISTINCTCOUNT,
+ nullHandlingEnabled);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapAggregationFunction.java
index a2faa1d0ea..d37851acf9 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -41,7 +42,11 @@ import org.roaringbitmap.RoaringBitmap;
*/
public class DistinctCountBitmapAggregationFunction extends
BaseSingleInputAggregationFunction<RoaringBitmap, Integer> {
- public DistinctCountBitmapAggregationFunction(ExpressionContext expression) {
+ public DistinctCountBitmapAggregationFunction(List<ExpressionContext>
arguments) {
+ this(verifySingleArgument(arguments, "DISTINCT_COUNT_BITMAP"));
+ }
+
+ protected DistinctCountBitmapAggregationFunction(ExpressionContext
expression) {
super(expression);
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapMVAggregationFunction.java
index 14739419a3..cb278ec586 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountBitmapMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -36,8 +37,8 @@ import org.roaringbitmap.RoaringBitmap;
*/
public class DistinctCountBitmapMVAggregationFunction extends
DistinctCountBitmapAggregationFunction {
- public DistinctCountBitmapMVAggregationFunction(ExpressionContext
expression) {
- super(expression);
+ public DistinctCountBitmapMVAggregationFunction(List<ExpressionContext>
arguments) {
+ super(verifySingleArgument(arguments, "DISTINCT_COUNT_BITMAP_MV"));
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountMVAggregationFunction.java
index cd03a0071f..b0ec975348 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctCountMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -33,11 +34,10 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
*/
public class DistinctCountMVAggregationFunction extends
BaseDistinctAggregateAggregationFunction<Integer> {
- public DistinctCountMVAggregationFunction(ExpressionContext expression) {
- super(expression, AggregationFunctionType.DISTINCTCOUNTMV, false);
+ public DistinctCountMVAggregationFunction(List<ExpressionContext> arguments)
{
+ super(verifySingleArgument(arguments, "DISTINCT_COUNT_MV"),
AggregationFunctionType.DISTINCTCOUNTMV, false);
}
-
@Override
public void aggregate(int length, AggregationResultHolder
aggregationResultHolder,
Map<ExpressionContext, BlockValSet> blockValSetMap) {
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumAggregationFunction.java
index c0ee5907dd..a7bb1894c3 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -33,8 +34,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
*/
public class DistinctSumAggregationFunction extends
BaseDistinctAggregateAggregationFunction<Double> {
- public DistinctSumAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
- super(expression, AggregationFunctionType.DISTINCTSUM,
nullHandlingEnabled);
+ public DistinctSumAggregationFunction(List<ExpressionContext> arguments,
boolean nullHandlingEnabled) {
+ super(verifySingleArgument(arguments, "DISTINCT_SUM"),
AggregationFunctionType.DISTINCTSUM, nullHandlingEnabled);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumMVAggregationFunction.java
index 78b3d2cf09..acd20a5348 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/DistinctSumMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -33,8 +34,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
*/
public class DistinctSumMVAggregationFunction extends
BaseDistinctAggregateAggregationFunction<Double> {
- public DistinctSumMVAggregationFunction(ExpressionContext expression) {
- super(expression, AggregationFunctionType.DISTINCTSUMMV, false);
+ public DistinctSumMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "DISTINCT_SUM_MV"),
AggregationFunctionType.DISTINCTSUMMV, false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FastHLLAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FastHLLAggregationFunction.java
index 009ee9897a..e1c7db767d 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FastHLLAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FastHLLAggregationFunction.java
@@ -20,6 +20,7 @@ package org.apache.pinot.core.query.aggregation.function;
import com.clearspring.analytics.stream.cardinality.HyperLogLog;
import com.google.common.base.Preconditions;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -40,8 +41,8 @@ public class FastHLLAggregationFunction extends
BaseSingleInputAggregationFuncti
public static final int DEFAULT_LOG2M = 8;
private static final int BYTE_TO_CHAR_OFFSET = 129;
- public FastHLLAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public FastHLLAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "FAST_HLL"));
}
@Override
@@ -150,8 +151,8 @@ public class FastHLLAggregationFunction extends
BaseSingleInputAggregationFuncti
if (intermediateResult1.cardinality() == 0) {
return intermediateResult2;
} else {
- Preconditions
- .checkState(intermediateResult2.cardinality() == 0, "Cannot merge
HyperLogLogs of different sizes");
+ Preconditions.checkState(intermediateResult2.cardinality() == 0,
+ "Cannot merge HyperLogLogs of different sizes");
return intermediateResult1;
}
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FourthMomentAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FourthMomentAggregationFunction.java
index a6f4b707ff..81609cb79b 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FourthMomentAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/FourthMomentAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema;
@@ -39,8 +40,8 @@ public class FourthMomentAggregationFunction extends
BaseSingleInputAggregationF
KURTOSIS, SKEWNESS, MOMENT
}
- public FourthMomentAggregationFunction(ExpressionContext expression, Type
type) {
- super(expression);
+ public FourthMomentAggregationFunction(List<ExpressionContext> arguments,
Type type) {
+ super(verifySingleArgument(arguments, type.name()));
_type = type;
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxAggregationFunction.java
index 79c08bd2be..25654fac59 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxAggregationFunction.java
@@ -19,6 +19,7 @@
package org.apache.pinot.core.query.aggregation.function;
import java.math.BigDecimal;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -37,11 +38,11 @@ public class MaxAggregationFunction extends
BaseSingleInputAggregationFunction<D
private static final double DEFAULT_INITIAL_VALUE = Double.NEGATIVE_INFINITY;
private final boolean _nullHandlingEnabled;
- public MaxAggregationFunction(ExpressionContext expression) {
- this(expression, false);
+ public MaxAggregationFunction(List<ExpressionContext> arguments, boolean
nullHandlingEnabled) {
+ this(verifySingleArgument(arguments, "MAX"), nullHandlingEnabled);
}
- public MaxAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
+ protected MaxAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
super(expression);
_nullHandlingEnabled = nullHandlingEnabled;
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxMVAggregationFunction.java
index 81f99775b5..436077c375 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MaxMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -28,8 +29,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
public class MaxMVAggregationFunction extends MaxAggregationFunction {
- public MaxMVAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public MaxMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "MAX_MV"), false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinAggregationFunction.java
index b2ed9390d3..aa2ca50bbc 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinAggregationFunction.java
@@ -19,6 +19,7 @@
package org.apache.pinot.core.query.aggregation.function;
import java.math.BigDecimal;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -37,11 +38,11 @@ public class MinAggregationFunction extends
BaseSingleInputAggregationFunction<D
private static final double DEFAULT_VALUE = Double.POSITIVE_INFINITY;
private final boolean _nullHandlingEnabled;
- public MinAggregationFunction(ExpressionContext expression) {
- this(expression, false);
+ public MinAggregationFunction(List<ExpressionContext> arguments, boolean
nullHandlingEnabled) {
+ this(verifySingleArgument(arguments, "MIN"), nullHandlingEnabled);
}
- public MinAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
+ protected MinAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
super(expression);
_nullHandlingEnabled = nullHandlingEnabled;
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMVAggregationFunction.java
index f6a4edcfa9..ec231407d4 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -28,8 +29,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
public class MinMVAggregationFunction extends MinAggregationFunction {
- public MinMVAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public MinMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "MIN_MV"), false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeAggregationFunction.java
index f0bcf93ff3..1c039b9d14 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -34,7 +35,11 @@ import org.apache.pinot.spi.data.FieldSpec.DataType;
public class MinMaxRangeAggregationFunction extends
BaseSingleInputAggregationFunction<MinMaxRangePair, Double> {
- public MinMaxRangeAggregationFunction(ExpressionContext expression) {
+ public MinMaxRangeAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "MIN_MAX_RANGE"));
+ }
+
+ protected MinMaxRangeAggregationFunction(ExpressionContext expression) {
super(expression);
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeMVAggregationFunction.java
index a39c0dc1fe..466a6b044f 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/MinMaxRangeMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -28,8 +29,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
public class MinMaxRangeMVAggregationFunction extends
MinMaxRangeAggregationFunction {
- public MinMaxRangeMVAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public MinMaxRangeMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "MIN_MAX_RANGE_MV"));
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SegmentPartitionedDistinctCountAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SegmentPartitionedDistinctCountAggregationFunction.java
index f273fa8b61..996a077c0a 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SegmentPartitionedDistinctCountAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SegmentPartitionedDistinctCountAggregationFunction.java
@@ -23,6 +23,7 @@ import it.unimi.dsi.fastutil.floats.FloatOpenHashSet;
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
import java.util.Collection;
+import java.util.List;
import java.util.Map;
import javax.annotation.Nullable;
import org.apache.pinot.common.request.context.ExpressionContext;
@@ -48,8 +49,8 @@ import org.roaringbitmap.RoaringBitmap;
*/
public class SegmentPartitionedDistinctCountAggregationFunction extends
BaseSingleInputAggregationFunction<Long, Long> {
- public SegmentPartitionedDistinctCountAggregationFunction(ExpressionContext
expression) {
- super(expression);
+ public
SegmentPartitionedDistinctCountAggregationFunction(List<ExpressionContext>
arguments) {
+ super(verifySingleArgument(arguments,
"SEGMENT_PARTITIONED_DISTINCT_COUNT"));
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/StUnionAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/StUnionAggregationFunction.java
index 0e0ff6f493..8b6a6ed45a 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/StUnionAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/StUnionAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema;
@@ -35,13 +36,8 @@ import org.locationtech.jts.geom.Geometry;
public class StUnionAggregationFunction extends
BaseSingleInputAggregationFunction<Geometry, ByteArray> {
- /**
- * Constructor for the class.
- *
- * @param expression Expression to aggregate on.
- */
- public StUnionAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public StUnionAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "ST_UNION"));
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumAggregationFunction.java
index 04f63bd4e2..46e734349a 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumAggregationFunction.java
@@ -19,6 +19,7 @@
package org.apache.pinot.core.query.aggregation.function;
import java.math.BigDecimal;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema.ColumnDataType;
@@ -37,11 +38,11 @@ public class SumAggregationFunction extends
BaseSingleInputAggregationFunction<D
private static final double DEFAULT_VALUE = 0.0;
private final boolean _nullHandlingEnabled;
- public SumAggregationFunction(ExpressionContext expression) {
- this(expression, false);
+ public SumAggregationFunction(List<ExpressionContext> arguments, boolean
nullHandlingEnabled) {
+ this(verifySingleArgument(arguments, "SUM"), nullHandlingEnabled);
}
- public SumAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
+ protected SumAggregationFunction(ExpressionContext expression, boolean
nullHandlingEnabled) {
super(expression);
_nullHandlingEnabled = nullHandlingEnabled;
}
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumMVAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumMVAggregationFunction.java
index eb39d3adf0..4dfdf50202 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumMVAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/SumMVAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.core.common.BlockValSet;
@@ -28,8 +29,8 @@ import org.apache.pinot.segment.spi.AggregationFunctionType;
public class SumMVAggregationFunction extends SumAggregationFunction {
- public SumMVAggregationFunction(ExpressionContext expression) {
- super(expression);
+ public SumMVAggregationFunction(List<ExpressionContext> arguments) {
+ super(verifySingleArgument(arguments, "SUM_MV"), false);
}
@Override
diff --git
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/VarianceAggregationFunction.java
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/VarianceAggregationFunction.java
index 5498731442..6c49dfaa7a 100644
---
a/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/VarianceAggregationFunction.java
+++
b/pinot-core/src/main/java/org/apache/pinot/core/query/aggregation/function/VarianceAggregationFunction.java
@@ -18,6 +18,7 @@
*/
package org.apache.pinot.core.query.aggregation.function;
+import java.util.List;
import java.util.Map;
import org.apache.pinot.common.request.context.ExpressionContext;
import org.apache.pinot.common.utils.DataSchema;
@@ -45,14 +46,18 @@ public class VarianceAggregationFunction extends
BaseSingleInputAggregationFunct
protected final boolean _isStdDev;
protected final boolean _nullHandlingEnabled;
- public VarianceAggregationFunction(ExpressionContext expression, boolean
isSample, boolean isStdDev,
+ public VarianceAggregationFunction(List<ExpressionContext> arguments,
boolean isSample, boolean isStdDev,
boolean nullHandlingEnabled) {
- super(expression);
+ super(verifySingleArgument(arguments, getFunctionName(isSample,
isStdDev)));
_isSample = isSample;
_isStdDev = isStdDev;
_nullHandlingEnabled = nullHandlingEnabled;
}
+ private static String getFunctionName(boolean isSample, boolean isStdDev) {
+ return isSample ? (isStdDev ? "STD_DEV_SAMP" : "VAR_SAMP") : (isStdDev ?
"STD_DEV_POP" : "VAR_POP");
+ }
+
@Override
public AggregationFunctionType getType() {
if (_isSample) {
diff --git
a/pinot-core/src/test/java/org/apache/pinot/queries/ExprMinMaxTest.java
b/pinot-core/src/test/java/org/apache/pinot/queries/ExprMinMaxTest.java
index df7a9bdb58..b4e8f23973 100644
--- a/pinot-core/src/test/java/org/apache/pinot/queries/ExprMinMaxTest.java
+++ b/pinot-core/src/test/java/org/apache/pinot/queries/ExprMinMaxTest.java
@@ -41,6 +41,7 @@ import org.apache.pinot.spi.config.table.TableType;
import org.apache.pinot.spi.data.FieldSpec.DataType;
import org.apache.pinot.spi.data.Schema;
import org.apache.pinot.spi.data.readers.GenericRow;
+import org.apache.pinot.spi.exception.BadQueryRequestException;
import org.apache.pinot.spi.utils.ReadMode;
import org.apache.pinot.spi.utils.builder.TableConfigBuilder;
import org.apache.pinot.sql.parsers.rewriter.QueryRewriterFactory;
@@ -610,9 +611,9 @@ public class ExprMinMaxTest extends BaseQueriesTest {
ResultTable resultTable = brokerResponse.getResultTable();
List<Object[]> rows = resultTable.getRows();
fail();
- } catch (Exception e) {
- assertTrue(e.getMessage().contains("Aggregation function:
exprmax(longColumn,intColumn) "
- + "is only supported in selection without alias."));
+ } catch (BadQueryRequestException e) {
+ assertTrue(
+ e.getMessage().contains("Aggregation function: EXPRMAX is only
supported in selection without alias."));
}
}
@@ -627,8 +628,8 @@ public class ExprMinMaxTest extends BaseQueriesTest {
List<Object[]> rows = resultTable.getRows();
fail();
} catch (Exception e) {
- assertTrue(e.getMessage().contains("Aggregation function:
exprmax(longColumn,intColumn) "
- + "is only supported in selection without alias."));
+ assertTrue(
+ e.getMessage().contains("Aggregation function: EXPRMAX is only
supported in selection without alias."));
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
