From 083035da0efe922826a936f4c7243468abe1eef6 Mon Sep 17 00:00:00 2001 From: Assaf Bern Date: Thu, 17 Feb 2022 14:54:49 +0200 Subject: [PATCH] Rename AggregateFunction#inputs to arguments --- .../spi/connector/AggregateFunction.java | 22 +++++++++---------- .../AggregateFunctionPatterns.java | 14 ++++++------ .../aggregation/BaseImplementAvgBigint.java | 14 ++++++------ .../jdbc/aggregation/ImplementAvgDecimal.java | 12 +++++----- .../ImplementAvgFloatingPoint.java | 12 +++++----- .../jdbc/aggregation/ImplementCorr.java | 16 +++++++------- .../jdbc/aggregation/ImplementCount.java | 10 ++++----- .../jdbc/aggregation/ImplementCountAll.java | 4 ++-- .../aggregation/ImplementCountDistinct.java | 10 ++++----- .../aggregation/ImplementCovariancePop.java | 16 +++++++------- .../aggregation/ImplementCovarianceSamp.java | 16 +++++++------- .../jdbc/aggregation/ImplementMinMax.java | 10 ++++----- .../aggregation/ImplementRegrIntercept.java | 16 +++++++------- .../jdbc/aggregation/ImplementRegrSlope.java | 16 +++++++------- .../jdbc/aggregation/ImplementStddevPop.java | 12 +++++----- .../jdbc/aggregation/ImplementStddevSamp.java | 12 +++++----- .../plugin/jdbc/aggregation/ImplementSum.java | 10 ++++----- .../aggregation/ImplementVariancePop.java | 12 +++++----- .../aggregation/ImplementVarianceSamp.java | 12 +++++----- .../io/trino/plugin/pinot/PinotMetadata.java | 4 ++-- .../aggregation/ImplementApproxDistinct.java | 10 ++++----- .../pinot/query/aggregation/ImplementAvg.java | 16 +++++++------- .../query/aggregation/ImplementCountAll.java | 4 ++-- .../aggregation/ImplementCountDistinct.java | 10 ++++----- .../query/aggregation/ImplementMinMax.java | 16 +++++++------- .../pinot/query/aggregation/ImplementSum.java | 16 +++++++------- .../sqlserver/ImplementSqlServerCountBig.java | 10 ++++----- .../ImplementSqlServerCountBigAll.java | 4 ++-- .../ImplementSqlServerStddevPop.java | 12 +++++----- .../sqlserver/ImplementSqlServerStdev.java | 12 +++++----- .../sqlserver/ImplementSqlServerVariance.java | 12 +++++----- .../ImplementSqlServerVariancePop.java | 12 +++++----- 32 files changed, 192 insertions(+), 192 deletions(-) diff --git a/core/trino-spi/src/main/java/io/trino/spi/connector/AggregateFunction.java b/core/trino-spi/src/main/java/io/trino/spi/connector/AggregateFunction.java index 11369c4b77ee..59ae7c69dfb2 100644 --- a/core/trino-spi/src/main/java/io/trino/spi/connector/AggregateFunction.java +++ b/core/trino-spi/src/main/java/io/trino/spi/connector/AggregateFunction.java @@ -27,7 +27,7 @@ public class AggregateFunction { private final String functionName; private final Type outputType; - private final List inputs; + private final List arguments; private final List sortItems; private final boolean isDistinct; private final Optional filter; @@ -35,20 +35,20 @@ public class AggregateFunction public AggregateFunction( String aggregateFunctionName, Type outputType, - List inputs, + List arguments, List sortItems, boolean isDistinct, Optional filter) { - if (isDistinct && inputs.isEmpty()) { - throw new IllegalArgumentException("DISTINCT requires inputs"); + if (isDistinct && arguments.isEmpty()) { + throw new IllegalArgumentException("DISTINCT requires arguments"); } this.functionName = requireNonNull(aggregateFunctionName, "aggregateFunctionName is null"); this.outputType = requireNonNull(outputType, "outputType is null"); - requireNonNull(inputs, "inputs is null"); + requireNonNull(arguments, "arguments is null"); requireNonNull(sortItems, "sortItems is null"); - this.inputs = List.copyOf(inputs); + this.arguments = List.copyOf(arguments); this.sortItems = List.copyOf(sortItems); this.isDistinct = isDistinct; this.filter = requireNonNull(filter, "filter is null"); @@ -59,9 +59,9 @@ public String getFunctionName() return functionName; } - public List getInputs() + public List getArguments() { - return inputs; + return arguments; } public Type getOutputType() @@ -89,7 +89,7 @@ public String toString() { return new StringJoiner(", ", AggregateFunction.class.getSimpleName() + "[", "]") .add("aggregationName='" + functionName + "'") - .add("inputs=" + inputs) + .add("arguments=" + arguments) .add("outputType=" + outputType) .add("sortOrder=" + sortItems) .add("isDistinct=" + isDistinct) @@ -111,7 +111,7 @@ public boolean equals(Object o) AggregateFunction that = (AggregateFunction) o; return isDistinct == that.isDistinct && Objects.equals(functionName, that.functionName) && - Objects.equals(inputs, that.inputs) && + Objects.equals(arguments, that.arguments) && Objects.equals(outputType, that.outputType) && Objects.equals(sortItems, that.sortItems) && Objects.equals(filter, that.filter); @@ -120,6 +120,6 @@ public boolean equals(Object o) @Override public int hashCode() { - return Objects.hash(functionName, inputs, outputType, sortItems, isDistinct, filter); + return Objects.hash(functionName, arguments, outputType, sortItems, isDistinct, filter); } } diff --git a/lib/trino-plugin-toolkit/src/main/java/io/trino/plugin/base/aggregation/AggregateFunctionPatterns.java b/lib/trino-plugin-toolkit/src/main/java/io/trino/plugin/base/aggregation/AggregateFunctionPatterns.java index 47a338601a04..11a0f16e984d 100644 --- a/lib/trino-plugin-toolkit/src/main/java/io/trino/plugin/base/aggregation/AggregateFunctionPatterns.java +++ b/lib/trino-plugin-toolkit/src/main/java/io/trino/plugin/base/aggregation/AggregateFunctionPatterns.java @@ -54,19 +54,19 @@ public static Pattern basicAggregation() return Property.property("outputType", AggregateFunction::getOutputType); } - public static Property> inputs() + public static Property> arguments() { - return Property.property("inputs", AggregateFunction::getInputs); + return Property.property("arguments", AggregateFunction::getArguments); } - public static Property singleInput() + public static Property singleArgument() { - return Property.optionalProperty("inputs", aggregateFunction -> { - List inputs = aggregateFunction.getInputs(); - if (inputs.size() != 1) { + return Property.optionalProperty("arguments", aggregateFunction -> { + List arguments = aggregateFunction.getArguments(); + if (arguments.size() != 1) { return Optional.empty(); } - return Optional.of(inputs.get(0)); + return Optional.of(arguments.get(0)); }); } diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/BaseImplementAvgBigint.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/BaseImplementAvgBigint.java index ffd01e545d7a..98b99eb6cbcb 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/BaseImplementAvgBigint.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/BaseImplementAvgBigint.java @@ -31,7 +31,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; import static io.trino.spi.type.DoubleType.DOUBLE; @@ -45,11 +45,11 @@ public abstract class BaseImplementAvgBigint implements AggregateFunctionRule { - private final Capture input; + private final Capture argument; public BaseImplementAvgBigint() { - this.input = newCapture(); + this.argument = newCapture(); } @Override @@ -57,17 +57,17 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("avg")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(type -> type == BIGINT)) - .capturedAs(this.input))); + .capturedAs(this.argument))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(this.input); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(this.argument); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == DOUBLE); String columnName = context.getIdentifierQuote().apply(columnHandle.getColumnName()); diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgDecimal.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgDecimal.java index 977c07e7247c..363c9b277b2a 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgDecimal.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgDecimal.java @@ -30,7 +30,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; @@ -40,24 +40,24 @@ public class ImplementAvgDecimal implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("avg")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DecimalType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); DecimalType type = (DecimalType) columnHandle.getColumnType(); verify(aggregateFunction.getOutputType().equals(type)); diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgFloatingPoint.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgFloatingPoint.java index 100de91a43d0..b07c7b1faf2a 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgFloatingPoint.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementAvgFloatingPoint.java @@ -29,7 +29,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; @@ -41,24 +41,24 @@ public class ImplementAvgFloatingPoint implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("avg")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(type -> type == REAL || type == DOUBLE)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == columnHandle.getColumnType()); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCorr.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCorr.java index 672ce2e056aa..adb645634ef3 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCorr.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCorr.java @@ -27,10 +27,10 @@ import static com.google.common.base.Verify.verify; import static io.trino.matching.Capture.newCapture; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionTypes; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variables; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; @@ -39,27 +39,27 @@ public class ImplementCorr implements AggregateFunctionRule { - private static final Capture> INPUTS = newCapture(); + private static final Capture> ARGUMENTS = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("corr")) - .with(inputs().matching( + .with(arguments().matching( variables() .matching(expressionTypes(REAL, REAL).or(expressionTypes(DOUBLE, DOUBLE))) - .capturedAs(INPUTS))); + .capturedAs(ARGUMENTS))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - List inputs = captures.get(INPUTS); - verify(inputs.size() == 2); + List arguments = captures.get(ARGUMENTS); + verify(arguments.size() == 2); - JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(inputs.get(0).getName()); - JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(inputs.get(1).getName()); + JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(arguments.get(0).getName()); + JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(arguments.get(1).getName()); verify(aggregateFunction.getOutputType().equals(columnHandle1.getColumnType())); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCount.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCount.java index d9015f7ebc7a..b9aa08b4d8b3 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCount.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCount.java @@ -31,7 +31,7 @@ import static io.trino.matching.Capture.newCapture; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; import static java.lang.String.format; @@ -43,7 +43,7 @@ public class ImplementCount implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); private final JdbcTypeHandle bigintTypeHandle; @@ -60,14 +60,14 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("count")) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == BIGINT); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountAll.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountAll.java index 7d0d671028bf..f14c009932d5 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountAll.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountAll.java @@ -26,9 +26,9 @@ import java.util.Optional; import static com.google.common.base.Verify.verify; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.spi.type.BigintType.BIGINT; import static java.util.Objects.requireNonNull; @@ -53,7 +53,7 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("count")) - .with(inputs().equalTo(List.of())); + .with(arguments().equalTo(List.of())); } @Override diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountDistinct.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountDistinct.java index 2600687d665f..cb337fbcbf2e 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountDistinct.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCountDistinct.java @@ -34,7 +34,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.distinct; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.hasFilter; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; import static java.lang.String.format; @@ -46,7 +46,7 @@ public class ImplementCountDistinct implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); private final JdbcTypeHandle bigintTypeHandle; private final boolean isRemoteCollationSensitive; @@ -67,14 +67,14 @@ public Pattern getPattern() .with(distinct().equalTo(true)) .with(hasFilter().equalTo(false)) .with(functionName().equalTo("count")) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == BIGINT); boolean isCaseSensitiveType = columnHandle.getColumnType() instanceof CharType || columnHandle.getColumnType() instanceof VarcharType; diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovariancePop.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovariancePop.java index 4ecd03599bbb..f94e24881102 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovariancePop.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovariancePop.java @@ -27,10 +27,10 @@ import static com.google.common.base.Verify.verify; import static io.trino.matching.Capture.newCapture; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionTypes; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variables; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; @@ -39,27 +39,27 @@ public class ImplementCovariancePop implements AggregateFunctionRule { - private static final Capture> INPUTS = newCapture(); + private static final Capture> ARGUMENTS = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("covar_pop")) - .with(inputs().matching( + .with(arguments().matching( variables() .matching(expressionTypes(REAL, REAL).or(expressionTypes(DOUBLE, DOUBLE))) - .capturedAs(INPUTS))); + .capturedAs(ARGUMENTS))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - List inputs = captures.get(INPUTS); - verify(inputs.size() == 2); + List arguments = captures.get(ARGUMENTS); + verify(arguments.size() == 2); - JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(inputs.get(0).getName()); - JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(inputs.get(1).getName()); + JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(arguments.get(0).getName()); + JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(arguments.get(1).getName()); verify(aggregateFunction.getOutputType().equals(columnHandle1.getColumnType())); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovarianceSamp.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovarianceSamp.java index c7f9b952b55a..6506ce6e377f 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovarianceSamp.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementCovarianceSamp.java @@ -27,10 +27,10 @@ import static com.google.common.base.Verify.verify; import static io.trino.matching.Capture.newCapture; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionTypes; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variables; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; @@ -39,27 +39,27 @@ public class ImplementCovarianceSamp implements AggregateFunctionRule { - private static final Capture> INPUTS = newCapture(); + private static final Capture> ARGUMENTS = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("covar_samp")) - .with(inputs().matching( + .with(arguments().matching( variables() .matching(expressionTypes(REAL, REAL).or(expressionTypes(DOUBLE, DOUBLE))) - .capturedAs(INPUTS))); + .capturedAs(ARGUMENTS))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - List inputs = captures.get(INPUTS); - verify(inputs.size() == 2); + List arguments = captures.get(ARGUMENTS); + verify(arguments.size() == 2); - JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(inputs.get(0).getName()); - JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(inputs.get(1).getName()); + JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(arguments.get(0).getName()); + JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(arguments.get(1).getName()); verify(aggregateFunction.getOutputType().equals(columnHandle1.getColumnType())); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementMinMax.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementMinMax.java index 9ad3453d109a..253034e2b2f0 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementMinMax.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementMinMax.java @@ -31,7 +31,7 @@ import static io.trino.matching.Capture.newCapture; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; @@ -41,7 +41,7 @@ public class ImplementMinMax implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); private final boolean isRemoteCollationSensitive; @@ -55,14 +55,14 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().matching(Set.of("min", "max")::contains)) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(columnHandle.getColumnType().equals(aggregateFunction.getOutputType())); // Remote database is case insensitive or sorts values differently from Trino diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrIntercept.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrIntercept.java index 754da56daa10..35f007bdcb13 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrIntercept.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrIntercept.java @@ -27,10 +27,10 @@ import static com.google.common.base.Verify.verify; import static io.trino.matching.Capture.newCapture; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionTypes; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variables; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; @@ -39,27 +39,27 @@ public class ImplementRegrIntercept implements AggregateFunctionRule { - private static final Capture> INPUTS = newCapture(); + private static final Capture> ARGUMENTS = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("regr_intercept")) - .with(inputs().matching( + .with(arguments().matching( variables() .matching(expressionTypes(REAL, REAL).or(expressionTypes(DOUBLE, DOUBLE))) - .capturedAs(INPUTS))); + .capturedAs(ARGUMENTS))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - List inputs = captures.get(INPUTS); - verify(inputs.size() == 2); + List arguments = captures.get(ARGUMENTS); + verify(arguments.size() == 2); - JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(inputs.get(0).getName()); - JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(inputs.get(1).getName()); + JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(arguments.get(0).getName()); + JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(arguments.get(1).getName()); verify(aggregateFunction.getOutputType().equals(columnHandle1.getColumnType())); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrSlope.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrSlope.java index db2f1bc237a7..8d8223f7805e 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrSlope.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementRegrSlope.java @@ -27,10 +27,10 @@ import static com.google.common.base.Verify.verify; import static io.trino.matching.Capture.newCapture; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionTypes; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variables; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; @@ -39,27 +39,27 @@ public class ImplementRegrSlope implements AggregateFunctionRule { - private static final Capture> INPUTS = newCapture(); + private static final Capture> ARGUMENTS = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("regr_slope")) - .with(inputs().matching( + .with(arguments().matching( variables() .matching(expressionTypes(REAL, REAL).or(expressionTypes(DOUBLE, DOUBLE))) - .capturedAs(INPUTS))); + .capturedAs(ARGUMENTS))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - List inputs = captures.get(INPUTS); - verify(inputs.size() == 2); + List arguments = captures.get(ARGUMENTS); + verify(arguments.size() == 2); - JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(inputs.get(0).getName()); - JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(inputs.get(1).getName()); + JdbcColumnHandle columnHandle1 = (JdbcColumnHandle) context.getAssignment(arguments.get(0).getName()); + JdbcColumnHandle columnHandle2 = (JdbcColumnHandle) context.getAssignment(arguments.get(1).getName()); verify(aggregateFunction.getOutputType().equals(columnHandle1.getColumnType())); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevPop.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevPop.java index d35d15a93407..c627e116e494 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevPop.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevPop.java @@ -30,31 +30,31 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; public class ImplementStddevPop implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("stddev_pop")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == columnHandle.getColumnType()); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevSamp.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevSamp.java index 17544834a901..a1e59e524374 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevSamp.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementStddevSamp.java @@ -30,31 +30,31 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; public class ImplementStddevSamp implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("stddev")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == columnHandle.getColumnType()); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementSum.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementSum.java index 348d6250ca57..80399252c55b 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementSum.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementSum.java @@ -30,7 +30,7 @@ import static io.trino.matching.Capture.newCapture; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; import static java.util.Objects.requireNonNull; @@ -41,7 +41,7 @@ public class ImplementSum implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); private final Function> decimalTypeHandle; @@ -55,14 +55,14 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("sum")) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); JdbcTypeHandle resultTypeHandle; if (columnHandle.getColumnType().equals(aggregateFunction.getOutputType())) { diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVariancePop.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVariancePop.java index 3a23728e6cef..ce155df16995 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVariancePop.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVariancePop.java @@ -30,31 +30,31 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; public class ImplementVariancePop implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("var_pop")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == columnHandle.getColumnType()); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVarianceSamp.java b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVarianceSamp.java index 46b72877faa0..842ab1d92aea 100644 --- a/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVarianceSamp.java +++ b/plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/aggregation/ImplementVarianceSamp.java @@ -30,31 +30,31 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static java.lang.String.format; public class ImplementVarianceSamp implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("variance")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == columnHandle.getColumnType()); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/PinotMetadata.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/PinotMetadata.java index 1bd9f0ee3df1..e571e417ae72 100755 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/PinotMetadata.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/PinotMetadata.java @@ -447,14 +447,14 @@ public ConnectorSession getSession() }; if (implementCountDistinct.getPattern().matches(aggregate, context)) { - Variable input = (Variable) getOnlyElement(aggregate.getInputs()); + Variable argument = (Variable) getOnlyElement(aggregate.getArguments()); // If this is the second pass to applyAggregation for count distinct then // the first pass will have added the distinct column to the grouping columns, // otherwise do not push down the aggregation. // This is to avoid count(column_name) being pushed into pinot, which is currently unsupported. // Currently Pinot treats count(column_name) as count(*), i.e. it counts nulls. if (tableHandle.getQuery().isEmpty() || tableHandle.getQuery().get().getGroupingColumns().stream() - .noneMatch(groupingExpression -> groupingExpression.getColumnName().equals(input.getName()))) { + .noneMatch(groupingExpression -> groupingExpression.getColumnName().equals(argument.getName()))) { return Optional.empty(); } } diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementApproxDistinct.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementApproxDistinct.java index f14312c975f0..afbcfa606e3e 100644 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementApproxDistinct.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementApproxDistinct.java @@ -27,7 +27,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.outputType; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; @@ -35,7 +35,7 @@ public class ImplementApproxDistinct implements AggregateFunctionRule { // Extracted from io.trino.plugin.jdbc.expression - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() @@ -43,13 +43,13 @@ public Pattern getPattern() return basicAggregation() .with(functionName().equalTo("approx_distinct")) .with(outputType().equalTo(BIGINT)) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - return Optional.of(new AggregateExpression("distinctcounthll", context.getIdentifierQuote().apply(input.getName()), false)); + Variable argument = captures.get(ARGUMENT); + return Optional.of(new AggregateExpression("distinctcounthll", context.getIdentifierQuote().apply(argument.getName()), false)); } } diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementAvg.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementAvg.java index c6a77c4f5aa4..2a0372b33a7d 100644 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementAvg.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementAvg.java @@ -30,7 +30,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; import static io.trino.spi.type.DoubleType.DOUBLE; @@ -40,24 +40,24 @@ public class ImplementAvg implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); - private static final Set SUPPORTED_INPUT_TYPES = ImmutableSet.of(INTEGER, BIGINT, REAL, DOUBLE); + private static final Capture ARGUMENT = newCapture(); + private static final Set SUPPORTED_ARGUMENT_TYPES = ImmutableSet.of(INTEGER, BIGINT, REAL, DOUBLE); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("avg")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() - .with(expressionType().matching(SUPPORTED_INPUT_TYPES::contains)) - .capturedAs(INPUT))); + .with(expressionType().matching(SUPPORTED_ARGUMENT_TYPES::contains)) + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - return Optional.of(new AggregateExpression(aggregateFunction.getFunctionName(), context.getIdentifierQuote().apply(input.getName()), true)); + Variable argument = captures.get(ARGUMENT); + return Optional.of(new AggregateExpression(aggregateFunction.getFunctionName(), context.getIdentifierQuote().apply(argument.getName()), true)); } } diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountAll.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountAll.java index a9f0328a7d08..5b94b7ca25c2 100644 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountAll.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountAll.java @@ -22,9 +22,9 @@ import java.util.List; import java.util.Optional; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.outputType; import static io.trino.spi.type.BigintType.BIGINT; @@ -39,7 +39,7 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("count")) - .with(inputs().equalTo(List.of())) + .with(arguments().equalTo(List.of())) .with(outputType().equalTo(BIGINT)); } diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountDistinct.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountDistinct.java index 64e4fa80785a..c1de84f9cb59 100644 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountDistinct.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementCountDistinct.java @@ -28,7 +28,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.outputType; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.plugin.pinot.PinotSessionProperties.isCountDistinctPushdownEnabled; import static io.trino.spi.type.BigintType.BIGINT; @@ -36,7 +36,7 @@ public class ImplementCountDistinct implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() @@ -44,7 +44,7 @@ public Pattern getPattern() return basicAggregation() .with(functionName().equalTo("count")) .with(outputType().equalTo(BIGINT)) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override @@ -53,8 +53,8 @@ public Optional rewrite(AggregateFunction aggregateFunction if (!isCountDistinctPushdownEnabled(context.getSession())) { return Optional.empty(); } - Variable input = captures.get(INPUT); + Variable argument = captures.get(ARGUMENT); verify(aggregateFunction.getOutputType() == BIGINT); - return Optional.of(new AggregateExpression("distinctcount", context.getIdentifierQuote().apply(input.getName()), false)); + return Optional.of(new AggregateExpression("distinctcount", context.getIdentifierQuote().apply(argument.getName()), false)); } } diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementMinMax.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementMinMax.java index dc8d707ed292..e92b77eadab2 100644 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementMinMax.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementMinMax.java @@ -32,7 +32,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; import static io.trino.spi.type.DoubleType.DOUBLE; @@ -45,25 +45,25 @@ public class ImplementMinMax implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); - private static final Set SUPPORTED_INPUT_TYPES = ImmutableSet.of(INTEGER, BIGINT, REAL, DOUBLE); + private static final Capture ARGUMENT = newCapture(); + private static final Set SUPPORTED_ARGUMENT_TYPES = ImmutableSet.of(INTEGER, BIGINT, REAL, DOUBLE); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().matching(Set.of("min", "max")::contains)) - .with(singleInput().matching( + .with(singleArgument().matching( variable() - .with(expressionType().matching(SUPPORTED_INPUT_TYPES::contains)) - .capturedAs(INPUT))); + .with(expressionType().matching(SUPPORTED_ARGUMENT_TYPES::contains)) + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - PinotColumnHandle columnHandle = (PinotColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + PinotColumnHandle columnHandle = (PinotColumnHandle) context.getAssignment(argument.getName()); verify(columnHandle.getDataType().equals(aggregateFunction.getOutputType())); return Optional.of(new AggregateExpression(aggregateFunction.getFunctionName(), context.getIdentifierQuote().apply(columnHandle.getColumnName()), true)); } diff --git a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementSum.java b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementSum.java index a7654c26f228..cdcd6d4a9fbe 100644 --- a/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementSum.java +++ b/plugin/trino-pinot/src/main/java/io/trino/plugin/pinot/query/aggregation/ImplementSum.java @@ -31,7 +31,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.BigintType.BIGINT; import static io.trino.spi.type.DoubleType.DOUBLE; @@ -44,25 +44,25 @@ public class ImplementSum implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); - private static final Set SUPPORTED_INPUT_TYPES = ImmutableSet.of(INTEGER, BIGINT, REAL, DOUBLE); + private static final Capture ARGUMENT = newCapture(); + private static final Set SUPPORTED_ARGUMENT_TYPES = ImmutableSet.of(INTEGER, BIGINT, REAL, DOUBLE); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("sum")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() - .with(expressionType().matching(SUPPORTED_INPUT_TYPES::contains)) - .capturedAs(INPUT))); + .with(expressionType().matching(SUPPORTED_ARGUMENT_TYPES::contains)) + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - PinotColumnHandle columnHandle = (PinotColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + PinotColumnHandle columnHandle = (PinotColumnHandle) context.getAssignment(argument.getName()); return Optional.of(new AggregateExpression(aggregateFunction.getFunctionName(), context.getIdentifierQuote().apply(columnHandle.getColumnName()), true)); } } diff --git a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBig.java b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBig.java index 54294823f1a4..d0e05fc3fd6f 100644 --- a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBig.java +++ b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBig.java @@ -28,7 +28,7 @@ import static io.trino.matching.Capture.newCapture; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.plugin.sqlserver.SqlServerClient.BIGINT_TYPE; import static io.trino.spi.type.BigintType.BIGINT; @@ -40,21 +40,21 @@ public class ImplementSqlServerCountBig implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("count")) - .with(singleInput().matching(variable().capturedAs(INPUT))); + .with(singleArgument().matching(variable().capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(aggregateFunction.getOutputType() == BIGINT); return Optional.of(new JdbcExpression( diff --git a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBigAll.java b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBigAll.java index 2fd2969b15fd..654681ad241e 100644 --- a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBigAll.java +++ b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerCountBigAll.java @@ -23,9 +23,9 @@ import java.util.Optional; import static com.google.common.base.Verify.verify; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.arguments; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.inputs; import static io.trino.plugin.sqlserver.SqlServerClient.BIGINT_TYPE; import static io.trino.spi.type.BigintType.BIGINT; @@ -40,7 +40,7 @@ public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("count")) - .with(inputs().equalTo(List.of())); + .with(arguments().equalTo(List.of())); } @Override diff --git a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStddevPop.java b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStddevPop.java index 5b43c671db80..ced8ac301b14 100644 --- a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStddevPop.java +++ b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStddevPop.java @@ -30,7 +30,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.DoubleType.DOUBLE; import static java.lang.String.format; @@ -38,24 +38,24 @@ public class ImplementSqlServerStddevPop implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("stddev_pop")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, AggregateFunctionRule.RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(columnHandle.getColumnType().equals(DOUBLE)); verify(aggregateFunction.getOutputType().equals(DOUBLE)); diff --git a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStdev.java b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStdev.java index 374315cc748c..22b3afb8113d 100644 --- a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStdev.java +++ b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerStdev.java @@ -30,7 +30,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.DoubleType.DOUBLE; import static java.lang.String.format; @@ -38,24 +38,24 @@ public class ImplementSqlServerStdev implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("stddev")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(columnHandle.getColumnType().equals(DOUBLE)); verify(aggregateFunction.getOutputType().equals(DOUBLE)); diff --git a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariance.java b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariance.java index fd06cc78788b..5c4e165d59e8 100644 --- a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariance.java +++ b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariance.java @@ -30,7 +30,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.DoubleType.DOUBLE; import static java.lang.String.format; @@ -38,24 +38,24 @@ public class ImplementSqlServerVariance implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("variance")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(columnHandle.getColumnType().equals(DOUBLE)); verify(aggregateFunction.getOutputType().equals(DOUBLE)); diff --git a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariancePop.java b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariancePop.java index d075fe195d56..9f3d97d26a2e 100644 --- a/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariancePop.java +++ b/plugin/trino-sqlserver/src/main/java/io/trino/plugin/sqlserver/ImplementSqlServerVariancePop.java @@ -30,7 +30,7 @@ import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.basicAggregation; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.expressionType; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.functionName; -import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleInput; +import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.singleArgument; import static io.trino.plugin.base.aggregation.AggregateFunctionPatterns.variable; import static io.trino.spi.type.DoubleType.DOUBLE; import static java.lang.String.format; @@ -38,24 +38,24 @@ public class ImplementSqlServerVariancePop implements AggregateFunctionRule { - private static final Capture INPUT = newCapture(); + private static final Capture ARGUMENT = newCapture(); @Override public Pattern getPattern() { return basicAggregation() .with(functionName().equalTo("var_pop")) - .with(singleInput().matching( + .with(singleArgument().matching( variable() .with(expressionType().matching(DoubleType.class::isInstance)) - .capturedAs(INPUT))); + .capturedAs(ARGUMENT))); } @Override public Optional rewrite(AggregateFunction aggregateFunction, Captures captures, RewriteContext context) { - Variable input = captures.get(INPUT); - JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(input.getName()); + Variable argument = captures.get(ARGUMENT); + JdbcColumnHandle columnHandle = (JdbcColumnHandle) context.getAssignment(argument.getName()); verify(columnHandle.getColumnType().equals(DOUBLE)); verify(aggregateFunction.getOutputType().equals(DOUBLE));