From d785a39b606cca7302879f131e3b7fa519108d47 Mon Sep 17 00:00:00 2001 From: Gian Merlino Date: Wed, 10 May 2023 11:49:29 -0700 Subject: [PATCH 1/2] SQL OperatorConversions: Introduce.aggregatorBuilder, allow CAST-as-literal. Four main changes: 1) Provide aggregatorBuilder, a more consistent way of defining the SqlAggFunction we need for all of our SQL aggregators. The mechanism is analogous to the one we already use for SQL functions (OperatorConversions.operatorBuilder). 2) Allow CASTs of constants to be considered as "literalOperands". This fixes an issue where various of our operators are defined with OperandTypes.LITERAL as part of their checkers, which doesn't allow casts. However, in these cases we generally _do_ want to allow casts. The important piece is that the value must be reducible to a constant, not that the SQL text is literally a literal. 3) Update DataSketches SQL aggregators to use the new aggregatorBuilder functionality. The main user-visible effect here is [2]: the aggregators would now accept, for example, "CAST(0.99 AS DOUBLE)" as a literal argument. Other aggregators could be updated in a future patch. 4) Rename "requiredOperands" to "requiredOperandCount", because the old name was confusing. (It rhymes with "literalOperands" but the arguments mean different things.) --- ...ketchApproxCountDistinctSqlAggregator.java | 41 ++--- .../HllSketchEstimateOperatorConversion.java | 2 +- ...mateWithErrorBoundsOperatorConversion.java | 2 +- .../hll/sql/HllSketchObjectSqlAggregator.java | 40 ++--- ...blesSketchApproxQuantileSqlAggregator.java | 43 +---- .../sql/DoublesSketchObjectSqlAggregator.java | 39 +--- ...ketchApproxCountDistinctSqlAggregator.java | 41 ++--- .../sql/ThetaSketchObjectSqlAggregator.java | 39 ++-- .../hll/sql/HllSketchSqlAggregatorTest.java | 10 +- .../sql/DoublesSketchSqlAggregatorTest.java | 2 +- .../query/sql/SleepOperatorConversion.java | 2 +- .../tools/SleepOperatorConversion.java | 2 +- .../expression/OperatorConversions.java | 169 +++++++++++++----- .../builtin/BTrimOperatorConversion.java | 2 +- .../builtin/ContainsOperatorConversion.java | 2 +- .../builtin/DateTruncOperatorConversion.java | 2 +- .../builtin/LPadOperatorConversion.java | 2 +- .../builtin/LTrimOperatorConversion.java | 2 +- .../builtin/ParseLongOperatorConversion.java | 2 +- .../builtin/RPadOperatorConversion.java | 2 +- .../builtin/RTrimOperatorConversion.java | 2 +- .../RegexpExtractOperatorConversion.java | 2 +- .../builtin/RegexpLikeOperatorConversion.java | 2 +- .../builtin/RoundOperatorConversion.java | 2 +- .../builtin/SubstringOperatorConversion.java | 2 +- .../builtin/TextcatOperatorConversion.java | 2 +- .../builtin/TimeCeilOperatorConversion.java | 2 +- .../TimeExtractOperatorConversion.java | 2 +- .../builtin/TimeFloorOperatorConversion.java | 2 +- .../builtin/TimeFormatOperatorConversion.java | 2 +- .../builtin/TimeParseOperatorConversion.java | 2 +- .../builtin/TimeShiftOperatorConversion.java | 2 +- .../builtin/TruncateOperatorConversion.java | 2 +- .../expression/OperatorConversionsTest.java | 28 +-- .../calcite/planner/DruidRexExecutorTest.java | 2 +- 35 files changed, 227 insertions(+), 275 deletions(-) diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchApproxCountDistinctSqlAggregator.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchApproxCountDistinctSqlAggregator.java index 5177e9fd53a7..18b6f336076f 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchApproxCountDistinctSqlAggregator.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchApproxCountDistinctSqlAggregator.java @@ -21,24 +21,29 @@ import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlFunctionCategory; -import org.apache.calcite.sql.SqlKind; import org.apache.calcite.sql.type.InferTypes; -import org.apache.calcite.sql.type.OperandTypes; -import org.apache.calcite.sql.type.ReturnTypes; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.query.aggregation.AggregatorFactory; import org.apache.druid.query.aggregation.post.FinalizingFieldAccessPostAggregator; import org.apache.druid.sql.calcite.aggregation.Aggregation; import org.apache.druid.sql.calcite.aggregation.SqlAggregator; +import org.apache.druid.sql.calcite.expression.OperatorConversions; import java.util.Collections; public class HllSketchApproxCountDistinctSqlAggregator extends HllSketchBaseSqlAggregator implements SqlAggregator { public static final String NAME = "APPROX_COUNT_DISTINCT_DS_HLL"; - - private static final SqlAggFunction FUNCTION_INSTANCE = new HllSketchApproxCountDistinctSqlAggFunction(); + private static final SqlAggFunction FUNCTION_INSTANCE = + OperatorConversions.aggregatorBuilder(NAME) + .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.STRING) + .operandTypeInference(InferTypes.VARCHAR_1024) + .requiredOperandCount(1) + .literalOperands(1, 2) + .returnTypeNonNull(SqlTypeName.BIGINT) + .functionCategory(SqlFunctionCategory.NUMERIC) + .build(); public HllSketchApproxCountDistinctSqlAggregator() { @@ -66,30 +71,4 @@ protected Aggregation toAggregation( ) : null ); } - - private static class HllSketchApproxCountDistinctSqlAggFunction extends SqlAggFunction - { - private static final String SIGNATURE = "'" + NAME + "(column, lgK, tgtHllType)'\n"; - - HllSketchApproxCountDistinctSqlAggFunction() - { - super( - NAME, - null, - SqlKind.OTHER_FUNCTION, - ReturnTypes.explicit(SqlTypeName.BIGINT), - InferTypes.VARCHAR_1024, - OperandTypes.or( - OperandTypes.ANY, - OperandTypes.and( - OperandTypes.sequence(SIGNATURE, OperandTypes.ANY, OperandTypes.LITERAL, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.STRING) - ) - ), - SqlFunctionCategory.NUMERIC, - false, - false - ); - } - } } diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateOperatorConversion.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateOperatorConversion.java index 63980972150e..b446c450b6ca 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateOperatorConversion.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateOperatorConversion.java @@ -47,7 +47,7 @@ public class HllSketchEstimateOperatorConversion implements SqlOperatorConversio private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder(StringUtils.toUpperCase(FUNCTION_NAME)) .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.BOOLEAN) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeInference(ReturnTypes.DOUBLE) .build(); diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateWithErrorBoundsOperatorConversion.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateWithErrorBoundsOperatorConversion.java index 83a0ce43bf55..cc89d4c7a560 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateWithErrorBoundsOperatorConversion.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchEstimateWithErrorBoundsOperatorConversion.java @@ -46,7 +46,7 @@ public class HllSketchEstimateWithErrorBoundsOperatorConversion implements SqlOp private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder(StringUtils.toUpperCase(FUNCTION_NAME)) .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.INTEGER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.OTHER) .build(); diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchObjectSqlAggregator.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchObjectSqlAggregator.java index 4dc18e176e2d..62f29a0409f9 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchObjectSqlAggregator.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchObjectSqlAggregator.java @@ -21,22 +21,28 @@ import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlFunctionCategory; -import org.apache.calcite.sql.SqlKind; import org.apache.calcite.sql.type.InferTypes; -import org.apache.calcite.sql.type.OperandTypes; -import org.apache.calcite.sql.type.ReturnTypes; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.query.aggregation.AggregatorFactory; import org.apache.druid.sql.calcite.aggregation.Aggregation; import org.apache.druid.sql.calcite.aggregation.SqlAggregator; +import org.apache.druid.sql.calcite.expression.OperatorConversions; import java.util.Collections; public class HllSketchObjectSqlAggregator extends HllSketchBaseSqlAggregator implements SqlAggregator { - private static final SqlAggFunction FUNCTION_INSTANCE = new HllSketchSqlAggFunction(); private static final String NAME = "DS_HLL"; + private static final SqlAggFunction FUNCTION_INSTANCE = + OperatorConversions.aggregatorBuilder(NAME) + .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.STRING) + .operandTypeInference(InferTypes.VARCHAR_1024) + .requiredOperandCount(1) + .literalOperands(1, 2) + .returnTypeNonNull(SqlTypeName.OTHER) + .functionCategory(SqlFunctionCategory.USER_DEFINED_FUNCTION) + .build(); public HllSketchObjectSqlAggregator() { @@ -61,30 +67,4 @@ protected Aggregation toAggregation( null ); } - - private static class HllSketchSqlAggFunction extends SqlAggFunction - { - private static final String SIGNATURE = "'" + NAME + "(column, lgK, tgtHllType)'\n"; - - HllSketchSqlAggFunction() - { - super( - NAME, - null, - SqlKind.OTHER_FUNCTION, - ReturnTypes.explicit(SqlTypeName.OTHER), - InferTypes.VARCHAR_1024, - OperandTypes.or( - OperandTypes.ANY, - OperandTypes.and( - OperandTypes.sequence(SIGNATURE, OperandTypes.ANY, OperandTypes.LITERAL, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.STRING) - ) - ), - SqlFunctionCategory.USER_DEFINED_FUNCTION, - false, - false - ); - } - } } diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchApproxQuantileSqlAggregator.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchApproxQuantileSqlAggregator.java index b029eab9036d..1264514b6e68 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchApproxQuantileSqlAggregator.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchApproxQuantileSqlAggregator.java @@ -28,8 +28,6 @@ import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlFunctionCategory; import org.apache.calcite.sql.SqlKind; -import org.apache.calcite.sql.type.OperandTypes; -import org.apache.calcite.sql.type.ReturnTypes; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.java.util.common.StringUtils; @@ -45,19 +43,26 @@ import org.apache.druid.sql.calcite.aggregation.SqlAggregator; import org.apache.druid.sql.calcite.expression.DruidExpression; import org.apache.druid.sql.calcite.expression.Expressions; +import org.apache.druid.sql.calcite.expression.OperatorConversions; import org.apache.druid.sql.calcite.planner.PlannerContext; import org.apache.druid.sql.calcite.rel.VirtualColumnRegistry; import javax.annotation.Nullable; - import java.util.List; public class DoublesSketchApproxQuantileSqlAggregator implements SqlAggregator { public static final String CTX_APPROX_QUANTILE_DS_MAX_STREAM_LENGTH = "approxQuantileDsMaxStreamLength"; - private static final SqlAggFunction FUNCTION_INSTANCE = new DoublesSketchApproxQuantileSqlAggFunction(); private static final String NAME = "APPROX_QUANTILE_DS"; + private static final SqlAggFunction FUNCTION_INSTANCE = + OperatorConversions.aggregatorBuilder(NAME) + .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.EXACT_NUMERIC) + .returnTypeNonNull(SqlTypeName.DOUBLE) + .requiredOperandCount(2) + .literalOperands(1, 2) + .functionCategory(SqlFunctionCategory.NUMERIC) + .build(); @Override public SqlAggFunction calciteFunction() @@ -212,34 +217,4 @@ static long getMaxStreamLengthFromQueryContext(QueryContext queryContext) DoublesSketchAggregatorFactory.DEFAULT_MAX_STREAM_LENGTH ); } - - private static class DoublesSketchApproxQuantileSqlAggFunction extends SqlAggFunction - { - private static final String SIGNATURE1 = "'" + NAME + "(column, probability)'\n"; - private static final String SIGNATURE2 = "'" + NAME + "(column, probability, k)'\n"; - - DoublesSketchApproxQuantileSqlAggFunction() - { - super( - NAME, - null, - SqlKind.OTHER_FUNCTION, - ReturnTypes.explicit(SqlTypeName.DOUBLE), - null, - OperandTypes.or( - OperandTypes.and( - OperandTypes.sequence(SIGNATURE1, OperandTypes.ANY, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC) - ), - OperandTypes.and( - OperandTypes.sequence(SIGNATURE2, OperandTypes.ANY, OperandTypes.LITERAL, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.EXACT_NUMERIC) - ) - ), - SqlFunctionCategory.NUMERIC, - false, - false - ); - } - } } diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchObjectSqlAggregator.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchObjectSqlAggregator.java index cfe728ce4542..8ccdb0ef5c83 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchObjectSqlAggregator.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchObjectSqlAggregator.java @@ -28,8 +28,6 @@ import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlFunctionCategory; import org.apache.calcite.sql.SqlKind; -import org.apache.calcite.sql.type.OperandTypes; -import org.apache.calcite.sql.type.ReturnTypes; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.java.util.common.StringUtils; @@ -43,17 +41,24 @@ import org.apache.druid.sql.calcite.aggregation.SqlAggregator; import org.apache.druid.sql.calcite.expression.DruidExpression; import org.apache.druid.sql.calcite.expression.Expressions; +import org.apache.druid.sql.calcite.expression.OperatorConversions; import org.apache.druid.sql.calcite.planner.PlannerContext; import org.apache.druid.sql.calcite.rel.VirtualColumnRegistry; import javax.annotation.Nullable; - import java.util.List; public class DoublesSketchObjectSqlAggregator implements SqlAggregator { - private static final SqlAggFunction FUNCTION_INSTANCE = new DoublesSketchSqlAggFunction(); private static final String NAME = "DS_QUANTILES_SKETCH"; + private static final SqlAggFunction FUNCTION_INSTANCE = + OperatorConversions.aggregatorBuilder(NAME) + .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.EXACT_NUMERIC) + .returnTypeNonNull(SqlTypeName.OTHER) + .requiredOperandCount(1) + .literalOperands(1) + .functionCategory(SqlFunctionCategory.NUMERIC) + .build(); @Override public SqlAggFunction calciteFunction() @@ -139,30 +144,4 @@ public Aggregation toDruidAggregation( null ); } - - private static class DoublesSketchSqlAggFunction extends SqlAggFunction - { - private static final String SIGNATURE2 = "'" + NAME + "(column, k)'\n"; - - DoublesSketchSqlAggFunction() - { - super( - NAME, - null, - SqlKind.OTHER_FUNCTION, - ReturnTypes.explicit(SqlTypeName.OTHER), - null, - OperandTypes.or( - OperandTypes.ANY, - OperandTypes.and( - OperandTypes.sequence(SIGNATURE2, OperandTypes.ANY, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.EXACT_NUMERIC) - ) - ), - SqlFunctionCategory.USER_DEFINED_FUNCTION, - false, - false - ); - } - } } diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchApproxCountDistinctSqlAggregator.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchApproxCountDistinctSqlAggregator.java index fc252f075da3..c1fac7efa64b 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchApproxCountDistinctSqlAggregator.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchApproxCountDistinctSqlAggregator.java @@ -21,24 +21,29 @@ import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlFunctionCategory; -import org.apache.calcite.sql.SqlKind; import org.apache.calcite.sql.type.InferTypes; -import org.apache.calcite.sql.type.OperandTypes; -import org.apache.calcite.sql.type.ReturnTypes; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.query.aggregation.AggregatorFactory; import org.apache.druid.query.aggregation.post.FinalizingFieldAccessPostAggregator; import org.apache.druid.sql.calcite.aggregation.Aggregation; import org.apache.druid.sql.calcite.aggregation.SqlAggregator; +import org.apache.druid.sql.calcite.expression.OperatorConversions; import java.util.Collections; public class ThetaSketchApproxCountDistinctSqlAggregator extends ThetaSketchBaseSqlAggregator implements SqlAggregator { public static final String NAME = "APPROX_COUNT_DISTINCT_DS_THETA"; - - private static final SqlAggFunction FUNCTION_INSTANCE = new ThetaSketchSqlAggFunction(); + private static final SqlAggFunction FUNCTION_INSTANCE = + OperatorConversions.aggregatorBuilder(NAME) + .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC) + .operandTypeInference(InferTypes.VARCHAR_1024) + .requiredOperandCount(1) + .literalOperands(1) + .returnTypeNonNull(SqlTypeName.BIGINT) + .functionCategory(SqlFunctionCategory.USER_DEFINED_FUNCTION) + .build(); public ThetaSketchApproxCountDistinctSqlAggregator() { @@ -66,30 +71,4 @@ protected Aggregation toAggregation( ) : null ); } - - private static class ThetaSketchSqlAggFunction extends SqlAggFunction - { - private static final String SIGNATURE = "'" + NAME + "(column, size)'\n"; - - ThetaSketchSqlAggFunction() - { - super( - NAME, - null, - SqlKind.OTHER_FUNCTION, - ReturnTypes.explicit(SqlTypeName.BIGINT), - InferTypes.VARCHAR_1024, - OperandTypes.or( - OperandTypes.ANY, - OperandTypes.and( - OperandTypes.sequence(SIGNATURE, OperandTypes.ANY, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC) - ) - ), - SqlFunctionCategory.NUMERIC, - false, - false - ); - } - } } diff --git a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchObjectSqlAggregator.java b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchObjectSqlAggregator.java index d0e95096e7d3..743cec315803 100644 --- a/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchObjectSqlAggregator.java +++ b/extensions-core/datasketches/src/main/java/org/apache/druid/query/aggregation/datasketches/theta/sql/ThetaSketchObjectSqlAggregator.java @@ -21,20 +21,27 @@ import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlFunctionCategory; -import org.apache.calcite.sql.SqlKind; import org.apache.calcite.sql.type.InferTypes; -import org.apache.calcite.sql.type.OperandTypes; import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.druid.query.aggregation.AggregatorFactory; import org.apache.druid.sql.calcite.aggregation.Aggregation; import org.apache.druid.sql.calcite.aggregation.SqlAggregator; +import org.apache.druid.sql.calcite.expression.OperatorConversions; import java.util.Collections; public class ThetaSketchObjectSqlAggregator extends ThetaSketchBaseSqlAggregator implements SqlAggregator { - private static final SqlAggFunction FUNCTION_INSTANCE = new ThetaSketchObjectSqlAggFunction(); private static final String NAME = "DS_THETA"; + private static final SqlAggFunction FUNCTION_INSTANCE = + OperatorConversions.aggregatorBuilder(NAME) + .operandTypes(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC) + .operandTypeInference(InferTypes.VARCHAR_1024) + .requiredOperandCount(1) + .literalOperands(1) + .returnTypeInference(ThetaSketchSqlOperators.RETURN_TYPE_INFERENCE) + .functionCategory(SqlFunctionCategory.USER_DEFINED_FUNCTION) + .build(); public ThetaSketchObjectSqlAggregator() { @@ -59,30 +66,4 @@ protected Aggregation toAggregation( null ); } - - private static class ThetaSketchObjectSqlAggFunction extends SqlAggFunction - { - private static final String SIGNATURE = "'" + NAME + "(column, size)'\n"; - - ThetaSketchObjectSqlAggFunction() - { - super( - NAME, - null, - SqlKind.OTHER_FUNCTION, - ThetaSketchSqlOperators.RETURN_TYPE_INFERENCE, - InferTypes.VARCHAR_1024, - OperandTypes.or( - OperandTypes.ANY, - OperandTypes.and( - OperandTypes.sequence(SIGNATURE, OperandTypes.ANY, OperandTypes.LITERAL), - OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC) - ) - ), - SqlFunctionCategory.USER_DEFINED_FUNCTION, - false, - false - ); - } - } } diff --git a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchSqlAggregatorTest.java b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchSqlAggregatorTest.java index aa0e9afd13a1..090dd2496ad2 100644 --- a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchSqlAggregatorTest.java +++ b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/hll/sql/HllSketchSqlAggregatorTest.java @@ -154,18 +154,19 @@ public void testApproxCountDistinctHllSketch() + " APPROX_COUNT_DISTINCT(SUBSTRING(dim2, 1, 1)),\n" // on extractionFn, using generic A.C.D. + " COUNT(DISTINCT SUBSTRING(dim2, 1, 1) || 'x'),\n" // on expression, using COUNT DISTINCT + " APPROX_COUNT_DISTINCT_DS_HLL(hllsketch_dim1, 21, 'HLL_8'),\n" // on native HllSketch column - + " APPROX_COUNT_DISTINCT_DS_HLL(hllsketch_dim1)\n" // on native HllSketch column + + " APPROX_COUNT_DISTINCT_DS_HLL(hllsketch_dim1),\n" // on native HllSketch column + + " APPROX_COUNT_DISTINCT_DS_HLL(hllsketch_dim1, CAST(21 AS BIGINT))\n" // also native column + "FROM druid.foo"; final List expectedResults; if (NullHandling.replaceWithDefault()) { expectedResults = ImmutableList.of( - new Object[]{6L, 2L, 2L, 1L, 2L, 5L, 5L} + new Object[]{6L, 2L, 2L, 1L, 2L, 5L, 5L, 5L} ); } else { expectedResults = ImmutableList.of( - new Object[]{6L, 2L, 2L, 1L, 1L, 5L, 5L} + new Object[]{6L, 2L, 2L, 1L, 1L, 5L, 5L, 5L} ); } @@ -229,7 +230,8 @@ public void testApproxCountDistinctHllSketch() ROUND ), new HllSketchMergeAggregatorFactory("a5", "hllsketch_dim1", 21, "HLL_8", null, ROUND), - new HllSketchMergeAggregatorFactory("a6", "hllsketch_dim1", null, null, null, ROUND) + new HllSketchMergeAggregatorFactory("a6", "hllsketch_dim1", null, null, null, ROUND), + new HllSketchMergeAggregatorFactory("a7", "hllsketch_dim1", 21, "HLL_4", null, ROUND) ) ) .context(QUERY_CONTEXT_DEFAULT) diff --git a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchSqlAggregatorTest.java b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchSqlAggregatorTest.java index f2253462bd01..3f3b1fc8d1ab 100644 --- a/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchSqlAggregatorTest.java +++ b/extensions-core/datasketches/src/test/java/org/apache/druid/query/aggregation/datasketches/quantiles/sql/DoublesSketchSqlAggregatorTest.java @@ -207,7 +207,7 @@ public void testQuantileOnComplexColumn() + "APPROX_QUANTILE_DS(qsketch_m1, 0.01),\n" + "APPROX_QUANTILE_DS(qsketch_m1, 0.5, 64),\n" + "APPROX_QUANTILE_DS(qsketch_m1, 0.98, 256),\n" - + "APPROX_QUANTILE_DS(qsketch_m1, 0.99),\n" + + "APPROX_QUANTILE_DS(qsketch_m1, CAST(0.99 AS DOUBLE)),\n" + "APPROX_QUANTILE_DS(qsketch_m1, 0.99) FILTER(WHERE dim1 = 'abc'),\n" + "APPROX_QUANTILE_DS(qsketch_m1, 0.999) FILTER(WHERE dim1 <> 'abc'),\n" + "APPROX_QUANTILE_DS(qsketch_m1, 0.999) FILTER(WHERE dim1 = 'abc')\n" diff --git a/extensions-core/testing-tools/src/main/java/org/apache/druid/query/sql/SleepOperatorConversion.java b/extensions-core/testing-tools/src/main/java/org/apache/druid/query/sql/SleepOperatorConversion.java index 06d841af3ff3..d64947d535cb 100644 --- a/extensions-core/testing-tools/src/main/java/org/apache/druid/query/sql/SleepOperatorConversion.java +++ b/extensions-core/testing-tools/src/main/java/org/apache/druid/query/sql/SleepOperatorConversion.java @@ -42,7 +42,7 @@ public class SleepOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("SLEEP") .operandTypes(SqlTypeFamily.NUMERIC) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNullable(SqlTypeName.VARCHAR) // always null .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/SleepOperatorConversion.java b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/SleepOperatorConversion.java index cae087cf71e6..abc31d3a434d 100644 --- a/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/SleepOperatorConversion.java +++ b/integration-tests-ex/tools/src/main/java/org/apache/druid/testing/tools/SleepOperatorConversion.java @@ -42,7 +42,7 @@ public class SleepOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("SLEEP") .operandTypes(SqlTypeFamily.NUMERIC) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNullable(SqlTypeName.VARCHAR) // always null .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/OperatorConversions.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/OperatorConversions.java index c0efb1401742..776114bea508 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/OperatorConversions.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/OperatorConversions.java @@ -32,6 +32,7 @@ import org.apache.calcite.rex.RexLiteral; import org.apache.calcite.rex.RexNode; import org.apache.calcite.runtime.CalciteException; +import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.SqlCallBinding; import org.apache.calcite.sql.SqlFunction; import org.apache.calcite.sql.SqlFunctionCategory; @@ -49,6 +50,7 @@ import org.apache.calcite.sql.type.SqlTypeFamily; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.calcite.sql.type.SqlTypeTransforms; +import org.apache.calcite.util.Optionality; import org.apache.calcite.util.Static; import org.apache.druid.java.util.common.IAE; import org.apache.druid.java.util.common.ISE; @@ -57,6 +59,7 @@ import org.apache.druid.query.aggregation.post.ExpressionPostAggregator; import org.apache.druid.query.aggregation.post.FieldAccessPostAggregator; import org.apache.druid.segment.column.RowSignature; +import org.apache.druid.sql.calcite.aggregation.SqlAggregator; import org.apache.druid.sql.calcite.planner.Calcites; import org.apache.druid.sql.calcite.planner.DruidTypeSystem; import org.apache.druid.sql.calcite.planner.PlannerContext; @@ -316,22 +319,31 @@ public static PostAggregator toPostAggregator( * Returns a builder that helps {@link SqlOperatorConversion} implementations create the {@link SqlFunction} * objects they need to return from {@link SqlOperatorConversion#calciteOperator()}. */ - public static OperatorBuilder operatorBuilder(final String name) + public static OperatorBuilder operatorBuilder(final String name) { - return new OperatorBuilder(name); + return new OperatorBuilder<>(name); } - public static class OperatorBuilder + /** + * Returns a builder that helps {@link SqlAggregator} implementations create the {@link SqlAggFunction} objects + * they need to return from {@link SqlAggregator#calciteFunction()}. + */ + public static OperatorBuilder aggregatorBuilder(final String name) + { + return new AggregatorBuilder(name); + } + + public static class OperatorBuilder { - private final String name; - private SqlKind kind = SqlKind.OTHER_FUNCTION; - private SqlReturnTypeInference returnTypeInference; - private SqlFunctionCategory functionCategory = SqlFunctionCategory.USER_DEFINED_FUNCTION; + protected final String name; + protected SqlKind kind = SqlKind.OTHER_FUNCTION; + protected SqlReturnTypeInference returnTypeInference; + protected SqlFunctionCategory functionCategory = SqlFunctionCategory.USER_DEFINED_FUNCTION; // For operand type checking private SqlOperandTypeChecker operandTypeChecker; private List operandTypes; - private Integer requiredOperands = null; + private Integer requiredOperandCount = null; private int[] literalOperands = null; private SqlOperandTypeInference operandTypeInference; @@ -348,7 +360,7 @@ private OperatorBuilder(final String name) * {@link #returnTypeNullableArrayWithNullableElements}, or {@link #returnTypeInference(SqlReturnTypeInference)} * must be used before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder returnTypeNonNull(final SqlTypeName typeName) + public OperatorBuilder returnTypeNonNull(final SqlTypeName typeName) { Preconditions.checkState(this.returnTypeInference == null, "Cannot set return type multiple times"); @@ -365,7 +377,7 @@ public OperatorBuilder returnTypeNonNull(final SqlTypeName typeName) * {@link #returnTypeNullableArrayWithNullableElements}, or {@link #returnTypeInference(SqlReturnTypeInference)} * must be used before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder returnTypeNullable(final SqlTypeName typeName) + public OperatorBuilder returnTypeNullable(final SqlTypeName typeName) { Preconditions.checkState(this.returnTypeInference == null, "Cannot set return type multiple times"); @@ -382,7 +394,7 @@ public OperatorBuilder returnTypeNullable(final SqlTypeName typeName) * {@link #returnTypeNullableArrayWithNullableElements}, or {@link #returnTypeInference(SqlReturnTypeInference)} * must be used before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder returnTypeCascadeNullable(final SqlTypeName typeName) + public OperatorBuilder returnTypeCascadeNullable(final SqlTypeName typeName) { Preconditions.checkState(this.returnTypeInference == null, "Cannot set return type multiple times"); this.returnTypeInference = ReturnTypes.cascade(ReturnTypes.explicit(typeName), SqlTypeTransforms.TO_NULLABLE); @@ -396,7 +408,7 @@ public OperatorBuilder returnTypeCascadeNullable(final SqlTypeName typeName) * {@link #returnTypeArrayWithNullableElements}, or {@link #returnTypeInference(SqlReturnTypeInference)} must be * used before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder returnTypeArrayWithNullableElements(final SqlTypeName elementTypeName) + public OperatorBuilder returnTypeArrayWithNullableElements(final SqlTypeName elementTypeName) { Preconditions.checkState(this.returnTypeInference == null, "Cannot set return type multiple times"); @@ -413,7 +425,7 @@ public OperatorBuilder returnTypeArrayWithNullableElements(final SqlTypeName ele * {@link #returnTypeArrayWithNullableElements}, or {@link #returnTypeInference(SqlReturnTypeInference)} must be * used before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder returnTypeNullableArrayWithNullableElements(final SqlTypeName elementTypeName) + public OperatorBuilder returnTypeNullableArrayWithNullableElements(final SqlTypeName elementTypeName) { this.returnTypeInference = ReturnTypes.cascade( opBinding -> Calcites.createSqlArrayTypeWithNullability( @@ -434,7 +446,7 @@ public OperatorBuilder returnTypeNullableArrayWithNullableElements(final SqlType * {@link #returnTypeNullableArrayWithNullableElements}, or {@link #returnTypeInference(SqlReturnTypeInference)} * must be used before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder returnTypeInference(final SqlReturnTypeInference returnTypeInference) + public OperatorBuilder returnTypeInference(final SqlReturnTypeInference returnTypeInference) { Preconditions.checkState(this.returnTypeInference == null, "Cannot set return type multiple times"); @@ -447,7 +459,7 @@ public OperatorBuilder returnTypeInference(final SqlReturnTypeInference returnTy * * The default, if not provided, is {@link SqlFunctionCategory#USER_DEFINED_FUNCTION}. */ - public OperatorBuilder functionCategory(final SqlFunctionCategory functionCategory) + public OperatorBuilder functionCategory(final SqlFunctionCategory functionCategory) { this.functionCategory = functionCategory; return this; @@ -459,7 +471,7 @@ public OperatorBuilder functionCategory(final SqlFunctionCategory functionCatego * One of {@link #operandTypes(SqlTypeFamily...)} or {@link #operandTypeChecker(SqlOperandTypeChecker)} must be used * before calling {@link #build()}. These methods cannot be mixed; you must call exactly one. */ - public OperatorBuilder operandTypeChecker(final SqlOperandTypeChecker operandTypeChecker) + public OperatorBuilder operandTypeChecker(final SqlOperandTypeChecker operandTypeChecker) { this.operandTypeChecker = operandTypeChecker; return this; @@ -468,12 +480,12 @@ public OperatorBuilder operandTypeChecker(final SqlOperandTypeChecker operandTyp /** * Signifies that a function accepts operands of type family given by {@param operandTypes}. * - * May be used in conjunction with {@link #requiredOperands(int)} and {@link #literalOperands(int...)} in order + * May be used in conjunction with {@link #requiredOperandCount(int)} and {@link #literalOperands(int...)} in order * to further refine operand checking logic. * * For deeper control, use {@link #operandTypeChecker(SqlOperandTypeChecker)} instead. */ - public OperatorBuilder operandTypes(final SqlTypeFamily... operandTypes) + public OperatorBuilder operandTypes(final SqlTypeFamily... operandTypes) { this.operandTypes = Arrays.asList(operandTypes); return this; @@ -489,31 +501,43 @@ public OperatorBuilder operandTypes(final SqlTypeFamily... operandTypes) * Must be used in conjunction with {@link #operandTypes(SqlTypeFamily...)}; this method is not compatible with * {@link #operandTypeChecker(SqlOperandTypeChecker)}. */ - public OperatorBuilder requiredOperands(final int requiredOperands) + public OperatorBuilder requiredOperandCount(final int requiredOperandCount) { - this.requiredOperands = requiredOperands; + this.requiredOperandCount = requiredOperandCount; return this; } + /** + * Alias for {@link #requiredOperandCount(int)}. Deprecated because it means "operand count" rather than + * "specific operands", and therefore the name can cause confusion with {@link #literalOperands(int...)}. The latter + * really does mean "specific operands". + */ + @Deprecated + @SuppressWarnings("unused") // For compatibility with existing extensions + public OperatorBuilder requiredOperands(final int requiredOperands) + { + return requiredOperandCount(requiredOperands); + } + /** * Signifies that the operands at positions given by {@code literalOperands} must be literals. * * Must be used in conjunction with {@link #operandTypes(SqlTypeFamily...)}; this method is not compatible with * {@link #operandTypeChecker(SqlOperandTypeChecker)}. */ - public OperatorBuilder literalOperands(final int... literalOperands) + public OperatorBuilder literalOperands(final int... literalOperands) { this.literalOperands = literalOperands; return this; } - public OperatorBuilder operandTypeInference(SqlOperandTypeInference operandTypeInference) + public OperatorBuilder operandTypeInference(SqlOperandTypeInference operandTypeInference) { this.operandTypeInference = operandTypeInference; return this; } - public OperatorBuilder sqlKind(SqlKind kind) + public OperatorBuilder sqlKind(SqlKind kind) { this.kind = kind; return this; @@ -522,34 +546,53 @@ public OperatorBuilder sqlKind(SqlKind kind) /** * Creates a {@link SqlFunction} from this builder. */ - public SqlFunction build() + @SuppressWarnings("unchecked") + public T build() + { + final IntSet nullableOperands = buildNullableOperands(); + return (T) new SqlFunction( + name, + kind, + Preconditions.checkNotNull(returnTypeInference, "returnTypeInference"), + buildOperandTypeInference(nullableOperands), + buildOperandTypeChecker(nullableOperands), + functionCategory + ); + } + + protected IntSet buildNullableOperands() { // Create "nullableOperands" set including all optional arguments. final IntSet nullableOperands = new IntArraySet(); - if (requiredOperands != null) { - IntStream.range(requiredOperands, operandTypes.size()).forEach(nullableOperands::add); + if (requiredOperandCount != null) { + IntStream.range(requiredOperandCount, operandTypes.size()).forEach(nullableOperands::add); } + return nullableOperands; + } - final SqlOperandTypeChecker theOperandTypeChecker; - + protected SqlOperandTypeChecker buildOperandTypeChecker(final IntSet nullableOperands) + { if (operandTypeChecker == null) { - theOperandTypeChecker = new DefaultOperandTypeChecker( + return new DefaultOperandTypeChecker( operandTypes, - requiredOperands == null ? operandTypes.size() : requiredOperands, + requiredOperandCount == null ? operandTypes.size() : requiredOperandCount, nullableOperands, literalOperands ); - } else if (operandTypes == null && requiredOperands == null && literalOperands == null) { - theOperandTypeChecker = operandTypeChecker; + } else if (operandTypes == null && requiredOperandCount == null && literalOperands == null) { + return operandTypeChecker; } else { throw new ISE( "Cannot have both 'operandTypeChecker' and 'operandTypes' / 'requiredOperands' / 'literalOperands'" ); } + } + protected SqlOperandTypeInference buildOperandTypeInference(final IntSet nullableOperands) + { if (operandTypeInference == null) { SqlOperandTypeInference defaultInference = new DefaultOperandTypeInference(operandTypes, nullableOperands); - operandTypeInference = (callBinding, returnType, types) -> { + return (callBinding, returnType, types) -> { for (int i = 0; i < types.length; i++) { // calcite sql validate tries to do bad things to dynamic parameters if the type is inferred to be a string if (callBinding.operand(i).isA(ImmutableSet.of(SqlKind.DYNAMIC_PARAM))) { @@ -562,15 +605,49 @@ public SqlFunction build() } } }; + } else { + return operandTypeInference; } - return new SqlFunction( - name, - kind, - Preconditions.checkNotNull(returnTypeInference, "returnTypeInference"), - operandTypeInference, - theOperandTypeChecker, - functionCategory - ); + } + } + + public static class AggregatorBuilder extends OperatorBuilder + { + public AggregatorBuilder(String name) + { + super(name); + } + + /** + * Create a {@link SqlAggFunction} from this builder. + */ + @Override + public SqlAggFunction build() + { + final IntSet nullableOperands = buildNullableOperands(); + final SqlOperandTypeInference operandTypeInference = buildOperandTypeInference(nullableOperands); + final SqlOperandTypeChecker operandTypeChecker = buildOperandTypeChecker(nullableOperands); + + class DruidSqlAggFunction extends SqlAggFunction + { + public DruidSqlAggFunction() + { + super( + name, + null, + AggregatorBuilder.this.kind, + returnTypeInference, + operandTypeInference, + operandTypeChecker, + functionCategory, + false, + false, + Optionality.FORBIDDEN + ); + } + } + + return new DruidSqlAggFunction(); } } @@ -688,8 +765,8 @@ public boolean checkOperandTypes(SqlCallBinding callBinding, boolean throwOnFail final SqlNode operand = callBinding.operands().get(i); if (literalOperands.contains(i)) { - // Verify that 'operand' is a literal. - if (!SqlUtil.isLiteral(operand)) { + // Verify that 'operand' is a literal. Allow CAST, since we can reduce these away later. + if (!SqlUtil.isLiteral(operand, true)) { return throwOrReturn( throwOnFailure, callBinding, @@ -772,7 +849,7 @@ public static DirectOperatorConversion druidUnaryLongFn(String sqlOperator, Stri { return new DirectOperatorConversion( operatorBuilder(sqlOperator) - .requiredOperands(1) + .requiredOperandCount(1) .operandTypes(SqlTypeFamily.NUMERIC) .returnTypeNullable(SqlTypeName.BIGINT) .functionCategory(SqlFunctionCategory.NUMERIC) @@ -785,7 +862,7 @@ public static DirectOperatorConversion druidBinaryLongFn(String sqlOperator, Str { return new DirectOperatorConversion( operatorBuilder(sqlOperator) - .requiredOperands(2) + .requiredOperandCount(2) .operandTypes(SqlTypeFamily.NUMERIC, SqlTypeFamily.NUMERIC) .returnTypeNullable(SqlTypeName.BIGINT) .functionCategory(SqlFunctionCategory.NUMERIC) @@ -798,7 +875,7 @@ public static DirectOperatorConversion druidUnaryDoubleFn(String sqlOperator, St { return new DirectOperatorConversion( operatorBuilder(StringUtils.toUpperCase(sqlOperator)) - .requiredOperands(1) + .requiredOperandCount(1) .operandTypes(SqlTypeFamily.NUMERIC) .returnTypeNullable(SqlTypeName.DOUBLE) .functionCategory(SqlFunctionCategory.NUMERIC) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/BTrimOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/BTrimOperatorConversion.java index d5a24773fe29..b8ae238dcf43 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/BTrimOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/BTrimOperatorConversion.java @@ -40,7 +40,7 @@ public class BTrimOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) - .requiredOperands(1) + .requiredOperandCount(1) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ContainsOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ContainsOperatorConversion.java index 98703feb0289..5e8071fb90c1 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ContainsOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ContainsOperatorConversion.java @@ -80,7 +80,7 @@ private static SqlFunction createSqlFunction(final String functionName) return OperatorConversions .operatorBuilder(StringUtils.toUpperCase(functionName)) .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) - .requiredOperands(2) + .requiredOperandCount(2) .literalOperands(1) .returnTypeNonNull(SqlTypeName.BOOLEAN) .functionCategory(SqlFunctionCategory.STRING) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/DateTruncOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/DateTruncOperatorConversion.java index b913cd32caa8..361de42862b7 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/DateTruncOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/DateTruncOperatorConversion.java @@ -67,7 +67,7 @@ public class DateTruncOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("DATE_TRUNC") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.TIMESTAMP) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeCascadeNullable(SqlTypeName.TIMESTAMP) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LPadOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LPadOperatorConversion.java index 2dd89e7b7d6e..8ccecafa3beb 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LPadOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LPadOperatorConversion.java @@ -40,7 +40,7 @@ public class LPadOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTEGER, SqlTypeFamily.CHARACTER) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) - .requiredOperands(2) + .requiredOperandCount(2) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LTrimOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LTrimOperatorConversion.java index 64d99e84a759..eef7584632ea 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LTrimOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/LTrimOperatorConversion.java @@ -40,7 +40,7 @@ public class LTrimOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) - .requiredOperands(1) + .requiredOperandCount(1) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ParseLongOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ParseLongOperatorConversion.java index 2bb00a22914d..53b7b7902563 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ParseLongOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/ParseLongOperatorConversion.java @@ -40,7 +40,7 @@ public class ParseLongOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTEGER) .returnTypeCascadeNullable(SqlTypeName.BIGINT) .functionCategory(SqlFunctionCategory.STRING) - .requiredOperands(1) + .requiredOperandCount(1) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RPadOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RPadOperatorConversion.java index 68ee6537cd8e..8e85d7a0682a 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RPadOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RPadOperatorConversion.java @@ -40,7 +40,7 @@ public class RPadOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTEGER, SqlTypeFamily.CHARACTER) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) - .requiredOperands(2) + .requiredOperandCount(2) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RTrimOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RTrimOperatorConversion.java index 70da7fbb4e6d..bf5c9b0fe951 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RTrimOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RTrimOperatorConversion.java @@ -40,7 +40,7 @@ public class RTrimOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) - .requiredOperands(1) + .requiredOperandCount(1) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpExtractOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpExtractOperatorConversion.java index 95c0e3421b0e..804e5cad05d8 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpExtractOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpExtractOperatorConversion.java @@ -38,7 +38,7 @@ public class RegexpExtractOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("REGEXP_EXTRACT") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER, SqlTypeFamily.INTEGER) - .requiredOperands(2) + .requiredOperandCount(2) .literalOperands(1, 2) .returnTypeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpLikeOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpLikeOperatorConversion.java index b065b276cc54..cc677215cbaa 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpLikeOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RegexpLikeOperatorConversion.java @@ -44,7 +44,7 @@ public class RegexpLikeOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("REGEXP_LIKE") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) - .requiredOperands(2) + .requiredOperandCount(2) .literalOperands(1) .returnTypeNonNull(SqlTypeName.BOOLEAN) .functionCategory(SqlFunctionCategory.STRING) diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RoundOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RoundOperatorConversion.java index 76e5dc1da958..a14e3a0f0d95 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RoundOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/RoundOperatorConversion.java @@ -35,7 +35,7 @@ public class RoundOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("ROUND") .operandTypes(SqlTypeFamily.NUMERIC, SqlTypeFamily.INTEGER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeInference(ReturnTypes.ARG0) .functionCategory(SqlFunctionCategory.NUMERIC) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/SubstringOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/SubstringOperatorConversion.java index 4b9e35b71989..ae470922c1ca 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/SubstringOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/SubstringOperatorConversion.java @@ -43,7 +43,7 @@ public class SubstringOperatorConversion implements SqlOperatorConversion .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER) .functionCategory(SqlFunctionCategory.STRING) .returnTypeInference(ReturnTypes.ARG0) - .requiredOperands(2) + .requiredOperandCount(2) .build(); @Override diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TextcatOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TextcatOperatorConversion.java index 5da41c42c80f..40a13479b8c1 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TextcatOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TextcatOperatorConversion.java @@ -31,7 +31,7 @@ public class TextcatOperatorConversion extends DirectOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("textcat") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.STRING) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeCeilOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeCeilOperatorConversion.java index 75680050528d..ffa022b0ee84 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeCeilOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeCeilOperatorConversion.java @@ -41,7 +41,7 @@ public class TimeCeilOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("TIME_CEIL") .operandTypes(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER, SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeCascadeNullable(SqlTypeName.TIMESTAMP) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java index 69397bc4d3ac..6a36bf4dad02 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeExtractOperatorConversion.java @@ -43,7 +43,7 @@ public class TimeExtractOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("TIME_EXTRACT") .operandTypes(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeCascadeNullable(SqlTypeName.BIGINT) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java index 9f74e87c7971..b0b5b69acc77 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFloorOperatorConversion.java @@ -56,7 +56,7 @@ public class TimeFloorOperatorConversion implements SqlOperatorConversion public static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder(SQL_FUNCTION_NAME) .operandTypes(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER, SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeCascadeNullable(SqlTypeName.TIMESTAMP) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java index 8c07ffdf4eae..60127fc2099e 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeFormatOperatorConversion.java @@ -46,7 +46,7 @@ public class TimeFormatOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("TIME_FORMAT") .operandTypes(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeCascadeNullable(SqlTypeName.VARCHAR) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeParseOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeParseOperatorConversion.java index 99bc94cc8f1f..7e515a35168d 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeParseOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeParseOperatorConversion.java @@ -43,7 +43,7 @@ public class TimeParseOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("TIME_PARSE") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNullable(SqlTypeName.TIMESTAMP) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeShiftOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeShiftOperatorConversion.java index d2973fb6d18f..edda4d074063 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeShiftOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TimeShiftOperatorConversion.java @@ -43,7 +43,7 @@ public class TimeShiftOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("TIME_SHIFT") .operandTypes(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.CHARACTER, SqlTypeFamily.INTEGER, SqlTypeFamily.CHARACTER) - .requiredOperands(3) + .requiredOperandCount(3) .returnTypeCascadeNullable(SqlTypeName.TIMESTAMP) .functionCategory(SqlFunctionCategory.TIMEDATE) .build(); diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TruncateOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TruncateOperatorConversion.java index 8459bed7d72e..d891823dd150 100644 --- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TruncateOperatorConversion.java +++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/builtin/TruncateOperatorConversion.java @@ -37,7 +37,7 @@ public class TruncateOperatorConversion implements SqlOperatorConversion private static final SqlFunction SQL_FUNCTION = OperatorConversions .operatorBuilder("TRUNCATE") .operandTypes(SqlTypeFamily.NUMERIC, SqlTypeFamily.INTEGER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeInference(ReturnTypes.ARG0) .functionCategory(SqlFunctionCategory.NUMERIC) .build(); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java index 5f70dc5902a3..85bf3fb06b5c 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java @@ -95,7 +95,7 @@ public void testAllowFullOperands() SqlFunction function = OperatorConversions .operatorBuilder("testAllowFullOperands") .operandTypes(SqlTypeFamily.INTEGER, SqlTypeFamily.DATE) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -119,7 +119,7 @@ public void testRequiredOperandsOnly() SqlFunction function = OperatorConversions .operatorBuilder("testRequiredOperandsOnly") .operandTypes(SqlTypeFamily.INTEGER, SqlTypeFamily.DATE) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -140,7 +140,7 @@ public void testLiteralOperandCheckLiteral() SqlFunction function = OperatorConversions .operatorBuilder("testLiteralOperandCheckLiteral") .operandTypes(SqlTypeFamily.INTEGER) - .requiredOperands(1) + .requiredOperandCount(1) .literalOperands(0) .returnTypeNonNull(SqlTypeName.CHAR) .build(); @@ -162,7 +162,7 @@ public void testLiteralOperandCheckLiteralThrow() SqlFunction function = OperatorConversions .operatorBuilder("testLiteralOperandCheckLiteralThrow") .operandTypes(SqlTypeFamily.INTEGER) - .requiredOperands(1) + .requiredOperandCount(1) .literalOperands(0) .returnTypeNonNull(SqlTypeName.CHAR) .build(); @@ -184,7 +184,7 @@ public void testAnyTypeOperand() SqlFunction function = OperatorConversions .operatorBuilder("testAnyTypeOperand") .operandTypes(SqlTypeFamily.ANY) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -205,7 +205,7 @@ public void testCastableFromDateTimestampToDatetimeFamily() SqlFunction function = OperatorConversions .operatorBuilder("testCastableFromDatetimeFamilyToTimestamp") .operandTypes(SqlTypeFamily.DATETIME) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -235,7 +235,7 @@ public void testNullForNullableOperand() SqlFunction function = OperatorConversions .operatorBuilder("testNullForNullableOperand") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTERVAL_DAY_TIME) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -259,7 +259,7 @@ public void testNullLiteralForNullableOperand() SqlFunction function = OperatorConversions .operatorBuilder("testNullLiteralForNullableOperand") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTERVAL_DAY_TIME) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -283,7 +283,7 @@ public void testNullForNullableOperandNonNullOutput() SqlFunction function = OperatorConversions .operatorBuilder("testNullForNullableNonnull") .operandTypes(SqlTypeFamily.CHARACTER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -304,7 +304,7 @@ public void testNullForNullableOperandCascadeNullOutput() SqlFunction function = OperatorConversions .operatorBuilder("testNullForNullableCascade") .operandTypes(SqlTypeFamily.CHARACTER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeCascadeNullable(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -325,7 +325,7 @@ public void testNullForNullableOperandAlwaysNullableOutput() SqlFunction function = OperatorConversions .operatorBuilder("testNullForNullableNonnull") .operandTypes(SqlTypeFamily.CHARACTER) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNullable(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -346,7 +346,7 @@ public void testNullForNonNullableOperand() SqlFunction function = OperatorConversions .operatorBuilder("testNullForNonNullableOperand") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTERVAL_DAY_TIME) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -372,7 +372,7 @@ public void testNullLiteralForNonNullableOperand() SqlFunction function = OperatorConversions .operatorBuilder("testNullLiteralForNonNullableOperand") .operandTypes(SqlTypeFamily.CHARACTER, SqlTypeFamily.INTERVAL_DAY_TIME) - .requiredOperands(1) + .requiredOperandCount(1) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); @@ -398,7 +398,7 @@ public void testNonCastableType() SqlFunction function = OperatorConversions .operatorBuilder("testNonCastableType") .operandTypes(SqlTypeFamily.CURSOR, SqlTypeFamily.INTERVAL_DAY_TIME) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java index bb5edf2d94c0..205f3379d71b 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java @@ -69,7 +69,7 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest private static final SqlOperator OPERATOR = OperatorConversions .operatorBuilder(StringUtils.toUpperCase("hyper_unique")) .operandTypes(SqlTypeFamily.ANY) - .requiredOperands(0) + .requiredOperandCount(0) .returnTypeInference( opBinding -> RowSignatures.makeComplexType( opBinding.getTypeFactory(), From 06eec8763bce590ac3bc991e89f660ee12e8aed7 Mon Sep 17 00:00:00 2001 From: Gian Merlino Date: Fri, 23 Jun 2023 12:57:12 -0700 Subject: [PATCH 2/2] Adjust method calls. --- .../druid/sql/calcite/planner/DruidOperatorTableTest.java | 2 +- .../druid/sql/calcite/schema/InformationSchemaTest.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java index 1e1485176312..02e5c522f279 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java @@ -68,7 +68,7 @@ public void testCustomOperatorTable() final SqlOperator operator1 = OperatorConversions .operatorBuilder("FOO") .operandTypes(SqlTypeFamily.ANY) - .requiredOperands(0) + .requiredOperandCount(0) .returnTypeInference( opBinding -> RowSignatures.makeComplexType( opBinding.getTypeFactory(), diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java index 89e757c9c7de..43551b3e0403 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java @@ -166,7 +166,7 @@ private static Set customOperatorsToOperatorConversions() final SqlOperator operator1 = OperatorConversions .operatorBuilder("FOO") .operandTypes(SqlTypeFamily.ANY) - .requiredOperands(0) + .requiredOperandCount(0) .returnTypeInference( opBinding -> RowSignatures.makeComplexType( opBinding.getTypeFactory(), @@ -182,7 +182,7 @@ private static Set customOperatorsToOperatorConversions() .operatorBuilder("BAR") .operandTypes(SqlTypeFamily.NUMERIC) .operandTypes(SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER) - .requiredOperands(2) + .requiredOperandCount(2) .returnTypeInference( opBinding -> RowSignatures.makeComplexType( opBinding.getTypeFactory(),