diff --git a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/CountAggregationBenchmark.java b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/CountAggregationBenchmark.java index 137ea7f786715..0cc604eb4f5fe 100644 --- a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/CountAggregationBenchmark.java +++ b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/CountAggregationBenchmark.java @@ -29,7 +29,6 @@ import static com.facebook.presto.benchmark.BenchmarkQueryRunner.createLocalQueryRunner; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; -import static com.facebook.presto.testing.TestingSession.testSessionBuilder; public class CountAggregationBenchmark extends AbstractSimpleOperatorBenchmark @@ -45,7 +44,7 @@ protected List createOperatorFactories() OperatorFactory tableScanOperator = createTableScanOperator(0, new PlanNodeId("test"), "orders", "orderkey"); FunctionManager functionManager = localQueryRunner.getMetadata().getFunctionManager(); InternalAggregationFunction countFunction = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(testSessionBuilder().build(), QualifiedName.of("count"), fromTypes(BIGINT))); + functionManager.lookupFunction(QualifiedName.of("count"), fromTypes(BIGINT))); AggregationOperatorFactory aggregationOperator = new AggregationOperatorFactory(1, new PlanNodeId("test"), Step.SINGLE, ImmutableList.of(countFunction.bind(ImmutableList.of(0), Optional.empty())), false); return ImmutableList.of(tableScanOperator, aggregationOperator); } diff --git a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/DoubleSumAggregationBenchmark.java b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/DoubleSumAggregationBenchmark.java index 05201aa544d8e..87837fc44571c 100644 --- a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/DoubleSumAggregationBenchmark.java +++ b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/DoubleSumAggregationBenchmark.java @@ -30,7 +30,6 @@ import static com.facebook.presto.benchmark.BenchmarkQueryRunner.createLocalQueryRunner; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; -import static com.facebook.presto.testing.TestingSession.testSessionBuilder; public class DoubleSumAggregationBenchmark extends AbstractSimpleOperatorBenchmark @@ -46,7 +45,7 @@ protected List createOperatorFactories() OperatorFactory tableScanOperator = createTableScanOperator(0, new PlanNodeId("test"), "orders", "totalprice"); FunctionManager functionManager = MetadataManager.createTestMetadataManager().getFunctionManager(); InternalAggregationFunction doubleSum = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(testSessionBuilder().build(), QualifiedName.of("sum"), fromTypes(DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE))); AggregationOperatorFactory aggregationOperator = new AggregationOperatorFactory(1, new PlanNodeId("test"), Step.SINGLE, ImmutableList.of(doubleSum.bind(ImmutableList.of(0), Optional.empty())), false); return ImmutableList.of(tableScanOperator, aggregationOperator); } diff --git a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery1.java b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery1.java index b49ad3083f741..1be1603a39699 100644 --- a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery1.java +++ b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery1.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.benchmark; -import com.facebook.presto.Session; import com.facebook.presto.benchmark.HandTpchQuery1.TpchQuery1Operator.TpchQuery1OperatorFactory; import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.operator.DriverContext; @@ -44,7 +43,6 @@ import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; -import static com.facebook.presto.testing.TestingSession.testSessionBuilder; import static com.google.common.base.Preconditions.checkState; import static io.airlift.units.DataSize.Unit.MEGABYTE; import static java.util.Objects.requireNonNull; @@ -62,15 +60,14 @@ public HandTpchQuery1(LocalQueryRunner localQueryRunner) super(localQueryRunner, "hand_tpch_query_1", 1, 5); FunctionManager functionManager = localQueryRunner.getMetadata().getFunctionManager(); - Session session = testSessionBuilder().setCatalog("tpch").setSchema("tiny").build(); longAverage = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(session, QualifiedName.of("avg"), fromTypes(BIGINT))); + functionManager.lookupFunction(QualifiedName.of("avg"), fromTypes(BIGINT))); doubleAverage = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(session, QualifiedName.of("avg"), fromTypes(DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("avg"), fromTypes(DOUBLE))); doubleSum = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(session, QualifiedName.of("sum"), fromTypes(DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE))); countFunction = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(session, QualifiedName.of("count"), ImmutableList.of())); + functionManager.lookupFunction(QualifiedName.of("count"), ImmutableList.of())); } @Override diff --git a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery6.java b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery6.java index 4ee67bcb953b6..25ffcbfa4fb48 100644 --- a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery6.java +++ b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HandTpchQuery6.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.benchmark; -import com.facebook.presto.Session; import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.operator.AggregationOperator.AggregationOperatorFactory; import com.facebook.presto.operator.FilterAndProjectOperator; @@ -46,7 +45,6 @@ import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.field; -import static com.facebook.presto.testing.TestingSession.testSessionBuilder; import static io.airlift.units.DataSize.Unit.BYTE; public class HandTpchQuery6 @@ -58,9 +56,8 @@ public HandTpchQuery6(LocalQueryRunner localQueryRunner) { super(localQueryRunner, "hand_tpch_query_6", 10, 100); FunctionManager functionManager = localQueryRunner.getMetadata().getFunctionManager(); - Session session = testSessionBuilder().setCatalog("tpch").setSchema("tiny").build(); doubleSum = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(session, QualifiedName.of("sum"), fromTypes(DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE))); } @Override diff --git a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HashAggregationBenchmark.java b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HashAggregationBenchmark.java index a5f7a4560d830..076c446e3c9e5 100644 --- a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HashAggregationBenchmark.java +++ b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/HashAggregationBenchmark.java @@ -32,7 +32,6 @@ import static com.facebook.presto.benchmark.BenchmarkQueryRunner.createLocalQueryRunner; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; -import static com.facebook.presto.testing.TestingSession.testSessionBuilder; import static io.airlift.units.DataSize.Unit.MEGABYTE; public class HashAggregationBenchmark @@ -46,7 +45,7 @@ public HashAggregationBenchmark(LocalQueryRunner localQueryRunner) FunctionManager functionManager = localQueryRunner.getMetadata().getFunctionManager(); doubleSum = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(testSessionBuilder().build(), QualifiedName.of("sum"), fromTypes(DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE))); } @Override diff --git a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/PredicateFilterBenchmark.java b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/PredicateFilterBenchmark.java index 76fdf9c9ad3bd..6a7e2673f8f2e 100644 --- a/presto-benchmark/src/main/java/com/facebook/presto/benchmark/PredicateFilterBenchmark.java +++ b/presto-benchmark/src/main/java/com/facebook/presto/benchmark/PredicateFilterBenchmark.java @@ -13,6 +13,7 @@ */ package com.facebook.presto.benchmark; +import com.facebook.presto.metadata.Metadata; import com.facebook.presto.operator.FilterAndProjectOperator; import com.facebook.presto.operator.OperatorFactory; import com.facebook.presto.operator.project.PageProcessor; @@ -29,10 +30,10 @@ import java.util.function.Supplier; import static com.facebook.presto.benchmark.BenchmarkQueryRunner.createLocalQueryRunner; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; import static com.facebook.presto.spi.function.OperatorType.GREATER_THAN_OR_EQUAL; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -49,13 +50,14 @@ public PredicateFilterBenchmark(LocalQueryRunner localQueryRunner) @Override protected List createOperatorFactories() { + Metadata metadata = localQueryRunner.getMetadata(); OperatorFactory tableScanOperator = createTableScanOperator(0, new PlanNodeId("test"), "orders", "totalprice"); RowExpression filter = call( - internalOperator(GREATER_THAN_OR_EQUAL, BOOLEAN.getTypeSignature(), ImmutableList.of(DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature())), + metadata.getFunctionManager().resolveOperator(GREATER_THAN_OR_EQUAL, fromTypes(DOUBLE, DOUBLE)), BOOLEAN, field(0, DOUBLE), constant(50000.0, DOUBLE)); - ExpressionCompiler expressionCompiler = new ExpressionCompiler(localQueryRunner.getMetadata(), new PageFunctionCompiler(localQueryRunner.getMetadata(), 0)); + ExpressionCompiler expressionCompiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); Supplier pageProcessor = expressionCompiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field(0, DOUBLE))); FilterAndProjectOperator.FilterAndProjectOperatorFactory filterAndProjectOperator = new FilterAndProjectOperator.FilterAndProjectOperatorFactory( diff --git a/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/TestSpatialPartitioningInternalAggregation.java b/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/TestSpatialPartitioningInternalAggregation.java index 1b19b0e02e260..571d119c00c61 100644 --- a/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/TestSpatialPartitioningInternalAggregation.java +++ b/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/TestSpatialPartitioningInternalAggregation.java @@ -39,7 +39,6 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.geospatial.KdbTree.buildKdbTree; import static com.facebook.presto.geospatial.serde.GeometrySerde.serialize; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.createGroupByIdBlock; @@ -99,7 +98,7 @@ private InternalAggregationFunction getFunction() { FunctionManager functionManager = functionAssertions.getMetadata().getFunctionManager(); return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("spatial_partitioning"), fromTypes(GEOMETRY, INTEGER))); + functionManager.lookupFunction(QualifiedName.of("spatial_partitioning"), fromTypes(GEOMETRY, INTEGER))); } private List makeGeometries() diff --git a/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/aggregation/AbstractTestGeoAggregationFunctions.java b/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/aggregation/AbstractTestGeoAggregationFunctions.java index d3d1541bc1ab4..34fbd0ce733c3 100644 --- a/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/aggregation/AbstractTestGeoAggregationFunctions.java +++ b/presto-geospatial/src/test/java/com/facebook/presto/plugin/geospatial/aggregation/AbstractTestGeoAggregationFunctions.java @@ -32,7 +32,6 @@ import java.util.function.BiFunction; import java.util.stream.Collectors; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.FunctionExtractor.extractFunctions; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.assertAggregation; import static com.facebook.presto.plugin.geospatial.GeometryType.GEOMETRY; @@ -53,7 +52,7 @@ public void registerFunctions() functionAssertions.getMetadata().addFunctions(extractFunctions(plugin.getFunctions())); FunctionManager functionManager = functionAssertions.getMetadata().getFunctionManager(); function = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(getFunctionName()), fromTypes(GEOMETRY))); + functionManager.lookupFunction(QualifiedName.of(getFunctionName()), fromTypes(GEOMETRY))); } protected void assertAggregatedGeometries(String testDescription, String expectedWkt, String... wkts) diff --git a/presto-main/src/main/java/com/facebook/presto/cost/StatsUtil.java b/presto-main/src/main/java/com/facebook/presto/cost/StatsUtil.java index 61dbd65c35d62..1b19d80ce999a 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/StatsUtil.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/StatsUtil.java @@ -32,7 +32,7 @@ import java.util.OptionalDouble; -import static com.facebook.presto.spi.function.OperatorType.CAST; +import static com.facebook.presto.metadata.CastType.CAST; import static java.util.Collections.singletonList; final class StatsUtil diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/CastType.java b/presto-main/src/main/java/com/facebook/presto/metadata/CastType.java new file mode 100644 index 0000000000000..f8927e7fb3e3e --- /dev/null +++ b/presto-main/src/main/java/com/facebook/presto/metadata/CastType.java @@ -0,0 +1,75 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.facebook.presto.metadata; + +import com.facebook.presto.spi.function.OperatorType; + +import static com.facebook.presto.metadata.OperatorSignatureUtils.mangleOperatorName; +import static com.facebook.presto.operator.scalar.JsonStringToArrayCast.JSON_STRING_TO_ARRAY_NAME; +import static com.facebook.presto.operator.scalar.JsonStringToMapCast.JSON_STRING_TO_MAP_NAME; +import static com.facebook.presto.operator.scalar.JsonStringToRowCast.JSON_STRING_TO_ROW_NAME; +import static com.facebook.presto.operator.scalar.TryCastFunction.TRY_CAST_NAME; +import static java.lang.String.format; + +public enum CastType +{ + CAST(mangleOperatorName(OperatorType.CAST.name()), true), + SATURATED_FLOOR_CAST(mangleOperatorName(OperatorType.SATURATED_FLOOR_CAST.name()), true), + TRY_CAST(TRY_CAST_NAME, false), + JSON_TO_ARRAY_CAST(JSON_STRING_TO_ARRAY_NAME, false), + JSON_TO_MAP_CAST(JSON_STRING_TO_MAP_NAME, false), + JSON_TO_ROW_CAST(JSON_STRING_TO_ROW_NAME, false); + + private final String castName; + private final boolean isOperatorType; + + CastType(String castName, boolean isOperatorType) + { + this.castName = castName; + this.isOperatorType = isOperatorType; + } + + public String getCastName() + { + return castName; + } + + public boolean isOperatorType() + { + return isOperatorType; + } + + public static OperatorType toOperatorType(CastType castType) + { + switch (castType) { + case CAST: + return OperatorType.CAST; + case SATURATED_FLOOR_CAST: + return OperatorType.SATURATED_FLOOR_CAST; + default: + throw new IllegalArgumentException(format("No OperatorType for CastType %s", castType)); + } + } + + public static CastType fromOperatorType(OperatorType operatorType) + { + if (operatorType == OperatorType.CAST) { + return CAST; + } + if (operatorType == OperatorType.SATURATED_FLOOR_CAST) { + return SATURATED_FLOOR_CAST; + } + throw new IllegalArgumentException((format("No CastType for OperatorType %s", operatorType))); + } +} diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/FunctionManager.java b/presto-main/src/main/java/com/facebook/presto/metadata/FunctionManager.java index 1831e0a92e910..55595d991fb54 100644 --- a/presto-main/src/main/java/com/facebook/presto/metadata/FunctionManager.java +++ b/presto-main/src/main/java/com/facebook/presto/metadata/FunctionManager.java @@ -21,7 +21,6 @@ import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.OperatorType; import com.facebook.presto.spi.function.Signature; -import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeManager; import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.sql.analyzer.FeaturesConfig; @@ -64,6 +63,19 @@ public List listFunctions() return globalFunctionNamespace.listFunctions(); } + /** + * Lookup up a function with a fully qualified name and fully bound types. + * @throws PrestoException if function could not be found + */ + public FunctionHandle lookupFunction(QualifiedName name, List parameterTypes) + { + return globalFunctionNamespace.lookupFunction(name, parameterTypes); + } + + /** + * Resolves a function using the SQL path, and implicit type coercions. + * @throws PrestoException if there are no matches or multiple matches + */ public FunctionHandle resolveFunction(Session session, QualifiedName name, List parameterTypes) { // TODO Actually use session @@ -74,11 +86,6 @@ public FunctionHandle resolveFunction(Session session, QualifiedName name, List< return globalFunctionNamespace.resolveFunction(name, parameterTypes); } - public Signature resolveFunction(QualifiedName name, List parameterTypes) - { - return globalFunctionNamespace.resolveFunction(name, parameterTypes).getSignature(); - } - public WindowFunctionSupplier getWindowFunctionImplementation(FunctionHandle functionHandle) { return globalFunctionNamespace.getWindowFunctionImplementation(functionHandle); @@ -104,17 +111,12 @@ public boolean isAggregationFunction(QualifiedName name) return globalFunctionNamespace.isAggregationFunction(name); } - public FunctionHandle resolveOperator(OperatorType operatorType, List argumentTypes) + public FunctionHandle resolveOperator(OperatorType operatorType, List argumentTypes) { return globalFunctionNamespace.resolveOperator(operatorType, argumentTypes); } - public boolean isRegistered(Signature signature) - { - return globalFunctionNamespace.isRegistered(signature); - } - - public FunctionHandle lookupCast(OperatorType castType, TypeSignature fromType, TypeSignature toType) + public FunctionHandle lookupCast(CastType castType, TypeSignature fromType, TypeSignature toType) { return globalFunctionNamespace.lookupCast(castType, fromType, toType); } diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/FunctionNamespace.java b/presto-main/src/main/java/com/facebook/presto/metadata/FunctionNamespace.java index 2217278c8b768..c00b95cb8e8b5 100644 --- a/presto-main/src/main/java/com/facebook/presto/metadata/FunctionNamespace.java +++ b/presto-main/src/main/java/com/facebook/presto/metadata/FunctionNamespace.java @@ -19,7 +19,6 @@ import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.OperatorType; import com.facebook.presto.spi.function.Signature; -import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.sql.analyzer.TypeSignatureProvider; import com.facebook.presto.sql.tree.QualifiedName; @@ -50,6 +49,11 @@ public List listFunctions() return registry.list(); } + public FunctionHandle lookupFunction(QualifiedName name, List parameterTypes) + { + return registry.lookupFunction(name, parameterTypes); + } + public FunctionHandle resolveFunction(QualifiedName name, List parameterTypes) { return registry.resolveFunction(name, parameterTypes); @@ -75,19 +79,14 @@ public boolean isAggregationFunction(QualifiedName name) return registry.isAggregationFunction(name); } - public FunctionHandle resolveOperator(OperatorType operatorType, List argumentTypes) + public FunctionHandle resolveOperator(OperatorType operatorType, List argumentTypes) throws OperatorNotFoundException { return registry.resolveOperator(operatorType, argumentTypes); } - public FunctionHandle lookupCast(OperatorType castType, TypeSignature fromType, TypeSignature toType) + public FunctionHandle lookupCast(CastType castType, TypeSignature fromType, TypeSignature toType) { return registry.lookupCast(castType, fromType, toType); } - - public boolean isRegistered(Signature signature) - { - return registry.isRegistered(signature); - } } diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/FunctionRegistry.java b/presto-main/src/main/java/com/facebook/presto/metadata/FunctionRegistry.java index 3c611b2107fd3..66ac3d0b6dc70 100644 --- a/presto-main/src/main/java/com/facebook/presto/metadata/FunctionRegistry.java +++ b/presto-main/src/main/java/com/facebook/presto/metadata/FunctionRegistry.java @@ -212,7 +212,8 @@ import java.util.Set; import java.util.stream.Collectors; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; +import static com.facebook.presto.metadata.CastType.toOperatorType; +import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; import static com.facebook.presto.metadata.OperatorSignatureUtils.mangleOperatorName; import static com.facebook.presto.metadata.SignatureBinder.applyBoundVariables; import static com.facebook.presto.operator.aggregation.ArbitraryAggregationFunction.ARBITRARY_AGGREGATION; @@ -297,7 +298,6 @@ import static com.facebook.presto.spi.function.FunctionKind.WINDOW; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; -import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.planner.LiteralEncoder.MAGIC_LITERAL_FUNCTION_PREFIX; import static com.facebook.presto.sql.planner.LiteralEncoder.getMagicLiteralFunctionSignature; import static com.facebook.presto.type.DecimalCasts.BIGINT_TO_DECIMAL_CAST; @@ -685,7 +685,7 @@ public boolean isAggregationFunction(QualifiedName name) return Iterables.any(functions.get(name), function -> function.getSignature().getKind() == AGGREGATE); } - public FunctionHandle resolveFunction(QualifiedName name, List parameterTypes) + public FunctionHandle lookupFunction(QualifiedName name, List parameterTypes) { Collection allCandidates = functions.get(name); List exactCandidates = allCandidates.stream() @@ -706,23 +706,24 @@ public FunctionHandle resolveFunction(QualifiedName name, List expectedParameters = new ArrayList<>(); - for (SqlFunction function : allCandidates) { - expectedParameters.add(format("%s(%s) %s", - name, - Joiner.on(", ").join(function.getSignature().getArgumentTypes()), - Joiner.on(", ").join(function.getSignature().getTypeVariableConstraints()))); + public FunctionHandle resolveFunction(QualifiedName name, List parameterTypes) + { + try { + return lookupFunction(name, parameterTypes); } - String parameters = Joiner.on(", ").join(parameterTypes); - String message = format("Function %s not registered", name); - if (!expectedParameters.isEmpty()) { - String expected = Joiner.on(", ").join(expectedParameters); - message = format("Unexpected parameters (%s) for function %s. Expected: %s", parameters, name, expected); + catch (PrestoException e) { + if (e.getErrorCode().getCode() != FUNCTION_NOT_FOUND.toErrorCode().getCode()) { + throw e; + } + } + + Collection allCandidates = functions.get(name); + Optional match = matchFunctionWithCoercion(allCandidates, parameterTypes); + if (match.isPresent()) { + return new FunctionHandle(match.get()); } if (name.getSuffix().startsWith(MAGIC_LITERAL_FUNCTION_PREFIX)) { @@ -738,7 +739,25 @@ public FunctionHandle resolveFunction(QualifiedName name, List parameterTypes, Collection candidates) + { + List expectedParameters = new ArrayList<>(); + for (SqlFunction function : candidates) { + expectedParameters.add(format("%s(%s) %s", + name, + Joiner.on(", ").join(function.getSignature().getArgumentTypes()), + Joiner.on(", ").join(function.getSignature().getTypeVariableConstraints()))); + } + String parameters = Joiner.on(", ").join(parameterTypes); + String message = format("Function %s not registered", name); + if (!expectedParameters.isEmpty()) { + String expected = Joiner.on(", ").join(expectedParameters); + message = format("Unexpected parameters (%s) for function %s. Expected: %s", parameters, name, expected); + } + return message; } private Optional matchFunctionExact(List candidates, List actualParameters) @@ -1056,33 +1075,18 @@ public List listOperators() .collect(toImmutableList()); } - public boolean isRegistered(Signature signature) - { - try { - // TODO: this is hacky, but until the magic literal and row field reference hacks are cleaned up it's difficult to implement this. - getScalarFunctionImplementation(signature); - return true; - } - catch (PrestoException e) { - if (e.getErrorCode().getCode() == FUNCTION_IMPLEMENTATION_MISSING.toErrorCode().getCode()) { - return false; - } - throw e; - } - } - - public FunctionHandle resolveOperator(OperatorType operatorType, List argumentTypes) + public FunctionHandle resolveOperator(OperatorType operatorType, List argumentTypes) throws OperatorNotFoundException { try { - return new FunctionHandle(resolveFunction(QualifiedName.of(mangleOperatorName(operatorType)), fromTypes(argumentTypes)).getSignature()); + return resolveFunction(QualifiedName.of(mangleOperatorName(operatorType)), argumentTypes); } catch (PrestoException e) { if (e.getErrorCode().getCode() == FUNCTION_NOT_FOUND.toErrorCode().getCode()) { throw new OperatorNotFoundException( operatorType, argumentTypes.stream() - .map(Type::getTypeSignature) + .map(TypeSignatureProvider::getTypeSignature) .collect(toImmutableList())); } else { @@ -1091,16 +1095,15 @@ public FunctionHandle resolveOperator(OperatorType operatorType, List missingOperators = HashMultimap.create(); for (Type type : typeManager.getTypes()) { if (type.isComparable()) { - if (!canResolveOperator(HASH_CODE, BIGINT, ImmutableList.of(type))) { + if (!canResolveOperator(HASH_CODE, fromTypes(type))) { missingOperators.put(type, HASH_CODE); } - if (!canResolveOperator(EQUAL, BOOLEAN, ImmutableList.of(type, type))) { + if (!canResolveOperator(EQUAL, fromTypes(type, type))) { missingOperators.put(type, EQUAL); } - if (!canResolveOperator(NOT_EQUAL, BOOLEAN, ImmutableList.of(type, type))) { + if (!canResolveOperator(NOT_EQUAL, fromTypes(type, type))) { missingOperators.put(type, NOT_EQUAL); } } if (type.isOrderable()) { for (OperatorType operator : ImmutableList.of(LESS_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL)) { - if (!canResolveOperator(operator, BOOLEAN, ImmutableList.of(type, type))) { + if (!canResolveOperator(operator, fromTypes(type, type))) { missingOperators.put(type, operator); } } - if (!canResolveOperator(BETWEEN, BOOLEAN, ImmutableList.of(type, type, type))) { + if (!canResolveOperator(BETWEEN, fromTypes(type, type, type))) { missingOperators.put(type, BETWEEN); } } @@ -1189,7 +1189,7 @@ private static JsonCodec createTestingViewCodec() return new JsonCodecFactory(provider).jsonCodec(ViewDefinition.class); } - private boolean canResolveOperator(OperatorType operatorType, Type returnType, List argumentTypes) + private boolean canResolveOperator(OperatorType operatorType, List argumentTypes) { try { getFunctionManager().resolveOperator(operatorType, argumentTypes); diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/OperatorNotFoundException.java b/presto-main/src/main/java/com/facebook/presto/metadata/OperatorNotFoundException.java index 78aafd4da18c2..d0539679f466d 100644 --- a/presto-main/src/main/java/com/facebook/presto/metadata/OperatorNotFoundException.java +++ b/presto-main/src/main/java/com/facebook/presto/metadata/OperatorNotFoundException.java @@ -33,7 +33,7 @@ public class OperatorNotFoundException private final TypeSignature returnType; private final List argumentTypes; - public OperatorNotFoundException(OperatorType operatorType, List argumentTypes) + public OperatorNotFoundException(OperatorType operatorType, List argumentTypes) { super(OPERATOR_NOT_FOUND, formatErrorMessage(operatorType, argumentTypes, Optional.empty())); this.operatorType = requireNonNull(operatorType, "operatorType is null"); @@ -41,7 +41,7 @@ public OperatorNotFoundException(OperatorType operatorType, List argumentTypes, TypeSignature returnType) + public OperatorNotFoundException(OperatorType operatorType, List argumentTypes, TypeSignature returnType) { super(OPERATOR_NOT_FOUND, formatErrorMessage(operatorType, argumentTypes, Optional.of(returnType))); this.operatorType = requireNonNull(operatorType, "operatorType is null"); @@ -49,7 +49,7 @@ public OperatorNotFoundException(OperatorType operatorType, List argumentTypes, Optional returnType) + private static String formatErrorMessage(OperatorType operatorType, List argumentTypes, Optional returnType) { String operatorString; switch (operatorType) { diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/PolymorphicScalarFunction.java b/presto-main/src/main/java/com/facebook/presto/metadata/PolymorphicScalarFunction.java index 94e76c1147eed..76a90b723869b 100644 --- a/presto-main/src/main/java/com/facebook/presto/metadata/PolymorphicScalarFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/metadata/PolymorphicScalarFunction.java @@ -24,7 +24,6 @@ import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeManager; -import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.util.Reflection; import com.google.common.collect.ImmutableList; import com.google.common.primitives.Primitives; @@ -38,7 +37,6 @@ import static com.facebook.presto.metadata.SignatureBinder.applyBoundVariables; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.BLOCK_AND_POSITION; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.USE_NULL_FLAG; -import static com.facebook.presto.type.TypeUtils.resolveTypes; import static com.google.common.base.Preconditions.checkState; import static java.util.Collections.emptyList; import static java.util.Objects.requireNonNull; @@ -102,10 +100,8 @@ private ScalarImplementationChoice getScalarFunctionImplementationChoice( FunctionManager functionManager, PolymorphicScalarFunctionChoice choice) { - List resolvedParameterTypeSignatures = applyBoundVariables(getSignature().getArgumentTypes(), boundVariables); - List resolvedParameterTypes = resolveTypes(resolvedParameterTypeSignatures, typeManager); - TypeSignature resolvedReturnTypeSignature = applyBoundVariables(getSignature().getReturnType(), boundVariables); - Type resolvedReturnType = typeManager.getType(resolvedReturnTypeSignature); + List resolvedParameterTypes = applyBoundVariables(typeManager, getSignature().getArgumentTypes(), boundVariables); + Type resolvedReturnType = applyBoundVariables(typeManager, getSignature().getReturnType(), boundVariables); SpecializeContext context = new SpecializeContext(boundVariables, resolvedParameterTypes, resolvedReturnType, typeManager, functionManager); Optional matchingMethod = Optional.empty(); @@ -114,7 +110,7 @@ private ScalarImplementationChoice getScalarFunctionImplementationChoice( for (MethodAndNativeContainerTypes candidateMethod : candidateMethodsGroup.getMethods()) { if (matchesParameterAndReturnTypes(candidateMethod, resolvedParameterTypes, resolvedReturnType, choice.getArgumentProperties(), choice.isNullableResult())) { if (matchingMethod.isPresent()) { - throw new IllegalStateException("two matching methods (" + matchingMethod.get().getMethod().getName() + " and " + candidateMethod.getMethod().getName() + ") for parameter types " + resolvedParameterTypeSignatures); + throw new IllegalStateException("two matching methods (" + matchingMethod.get().getMethod().getName() + " and " + candidateMethod.getMethod().getName() + ") for parameter types " + resolvedParameterTypes); } matchingMethod = Optional.of(candidateMethod); diff --git a/presto-main/src/main/java/com/facebook/presto/metadata/SignatureBinder.java b/presto-main/src/main/java/com/facebook/presto/metadata/SignatureBinder.java index 7797f94891634..7ae156a244e88 100644 --- a/presto-main/src/main/java/com/facebook/presto/metadata/SignatureBinder.java +++ b/presto-main/src/main/java/com/facebook/presto/metadata/SignatureBinder.java @@ -177,6 +177,30 @@ public static TypeSignature applyBoundVariables(TypeSignature typeSignature, Bou return new TypeSignature(baseType, parameters); } + public static List applyBoundVariables(TypeManager typeManager, List typeSignatures, BoundVariables boundVariables) + { + ImmutableList.Builder builder = ImmutableList.builder(); + for (TypeSignature typeSignature : typeSignatures) { + builder.add(applyBoundVariables(typeManager, typeSignature, boundVariables)); + } + return builder.build(); + } + + public static Type applyBoundVariables(TypeManager typeManager, TypeSignature typeSignature, BoundVariables boundVariables) + { + String baseType = typeSignature.getBase(); + if (boundVariables.containsTypeVariable(baseType)) { + checkState(typeSignature.getParameters().isEmpty(), "Type parameters cannot have parameters"); + return boundVariables.getTypeVariable(baseType); + } + + List parameters = typeSignature.getParameters().stream() + .map(typeSignatureParameter -> applyBoundVariables(typeSignatureParameter, boundVariables)) + .collect(toList()); + + return typeManager.getParameterizedType(baseType, parameters); + } + /** * Example of not allowed literal variable usages across typeSignatures: *

    diff --git a/presto-main/src/main/java/com/facebook/presto/operator/SimplePagesHashStrategy.java b/presto-main/src/main/java/com/facebook/presto/operator/SimplePagesHashStrategy.java index 6caa4f5a7431c..27bf24af7cb1f 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/SimplePagesHashStrategy.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/SimplePagesHashStrategy.java @@ -29,6 +29,7 @@ import static com.facebook.presto.spi.function.OperatorType.IS_DISTINCT_FROM; import static com.facebook.presto.spi.type.BigintType.BIGINT; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.util.Failures.internalError; import static com.google.common.base.Preconditions.checkArgument; import static java.util.Objects.requireNonNull; @@ -74,7 +75,7 @@ public SimplePagesHashStrategy( ImmutableList.Builder distinctFromMethodHandlesBuilder = ImmutableList.builder(); for (Type type : types) { distinctFromMethodHandlesBuilder.add( - functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(IS_DISTINCT_FROM, ImmutableList.of(type, type))).getMethodHandle()); + functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(IS_DISTINCT_FROM, fromTypes(type, type))).getMethodHandle()); } distinctFromMethodHandles = distinctFromMethodHandlesBuilder.build(); } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/ApproximateCountDistinctAggregation.java b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/ApproximateCountDistinctAggregation.java index 99e4b4469025c..93378b106ae44 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/ApproximateCountDistinctAggregation.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/ApproximateCountDistinctAggregation.java @@ -61,7 +61,7 @@ public static void input( @InputFunction @TypeParameter("T") public static void input( - @OperatorDependency(operator = XX_HASH_64, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle methodHandle, + @OperatorDependency(operator = XX_HASH_64, argumentTypes = {"T"}) MethodHandle methodHandle, @AggregationState HyperLogLogState state, @SqlType("T") long value, @SqlType(StandardTypes.DOUBLE) double maxStandardError) @@ -82,7 +82,7 @@ public static void input( @InputFunction @TypeParameter("T") public static void input( - @OperatorDependency(operator = XX_HASH_64, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle methodHandle, + @OperatorDependency(operator = XX_HASH_64, argumentTypes = {"T"}) MethodHandle methodHandle, @AggregationState HyperLogLogState state, @SqlType("T") double value, @SqlType(StandardTypes.DOUBLE) double maxStandardError) @@ -103,7 +103,7 @@ public static void input( @InputFunction @TypeParameter("T") public static void input( - @OperatorDependency(operator = XX_HASH_64, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle methodHandle, + @OperatorDependency(operator = XX_HASH_64, argumentTypes = {"T"}) MethodHandle methodHandle, @AggregationState HyperLogLogState state, @SqlType("T") Slice value, @SqlType(StandardTypes.DOUBLE) double maxStandardError) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalAverageAggregation.java b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalAverageAggregation.java index 57030ee2280f0..46de39cd2ed9c 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalAverageAggregation.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalAverageAggregation.java @@ -90,7 +90,7 @@ public String getDescription() @Override public InternalAggregationFunction specialize(BoundVariables boundVariables, int arity, TypeManager typeManager, FunctionManager functionManager) { - Type type = typeManager.getType(getOnlyElement(applyBoundVariables(getSignature().getArgumentTypes(), boundVariables))); + Type type = getOnlyElement(applyBoundVariables(typeManager, getSignature().getArgumentTypes(), boundVariables)); return generateAggregation(type); } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalSumAggregation.java b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalSumAggregation.java index 67088ce905b95..888093a3b0ac6 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalSumAggregation.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DecimalSumAggregation.java @@ -83,8 +83,8 @@ public String getDescription() @Override public InternalAggregationFunction specialize(BoundVariables boundVariables, int arity, TypeManager typeManager, FunctionManager functionManager) { - Type inputType = typeManager.getType(getOnlyElement(applyBoundVariables(getSignature().getArgumentTypes(), boundVariables))); - Type outputType = typeManager.getType(applyBoundVariables(getSignature().getReturnType(), boundVariables)); + Type inputType = getOnlyElement(applyBoundVariables(typeManager, getSignature().getArgumentTypes(), boundVariables)); + Type outputType = applyBoundVariables(typeManager, getSignature().getReturnType(), boundVariables); return generateAggregation(inputType, outputType); } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DefaultApproximateCountDistinctAggregation.java b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DefaultApproximateCountDistinctAggregation.java index 984dfc2e173d1..95bf69b42a8c0 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DefaultApproximateCountDistinctAggregation.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/DefaultApproximateCountDistinctAggregation.java @@ -53,7 +53,7 @@ public static void input( @InputFunction @TypeParameter("T") public static void input( - @OperatorDependency(operator = XX_HASH_64, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle methodHandle, + @OperatorDependency(operator = XX_HASH_64, argumentTypes = {"T"}) MethodHandle methodHandle, @AggregationState HyperLogLogState state, @SqlType("T") long value) { @@ -63,7 +63,7 @@ public static void input( @InputFunction @TypeParameter("T") public static void input( - @OperatorDependency(operator = XX_HASH_64, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle methodHandle, + @OperatorDependency(operator = XX_HASH_64, argumentTypes = {"T"}) MethodHandle methodHandle, @AggregationState HyperLogLogState state, @SqlType("T") double value) { @@ -73,7 +73,7 @@ public static void input( @InputFunction @TypeParameter("T") public static void input( - @OperatorDependency(operator = XX_HASH_64, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle methodHandle, + @OperatorDependency(operator = XX_HASH_64, argumentTypes = {"T"}) MethodHandle methodHandle, @AggregationState HyperLogLogState state, @SqlType("T") Slice value) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/minmaxby/AbstractMinMaxBy.java b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/minmaxby/AbstractMinMaxBy.java index ec6221e1c4bce..f45073bf314f7 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/aggregation/minmaxby/AbstractMinMaxBy.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/aggregation/minmaxby/AbstractMinMaxBy.java @@ -60,6 +60,7 @@ import static com.facebook.presto.spi.function.Signature.orderableTypeParameter; import static com.facebook.presto.spi.function.Signature.typeVariable; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.gen.BytecodeUtils.loadConstant; import static com.facebook.presto.sql.gen.SqlTypeBytecodeExpression.constantType; import static com.facebook.presto.util.CompilerUtils.defineClass; @@ -135,7 +136,7 @@ private InternalAggregationFunction generateAggregation(Type valueType, Type key CallSiteBinder binder = new CallSiteBinder(); OperatorType operator = min ? LESS_THAN : GREATER_THAN; - MethodHandle compareMethod = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(operator, ImmutableList.of(keyType, keyType))).getMethodHandle(); + MethodHandle compareMethod = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(operator, fromTypes(keyType, keyType))).getMethodHandle(); ClassDefinition definition = new ClassDefinition( a(PUBLIC, FINAL), diff --git a/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionImplementationDependency.java b/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionImplementationDependency.java index 8b225ca3f7b7f..c1b47c16510ec 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionImplementationDependency.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionImplementationDependency.java @@ -13,19 +13,58 @@ */ package com.facebook.presto.operator.annotations; +import com.facebook.presto.metadata.BoundVariables; +import com.facebook.presto.metadata.FunctionManager; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.InvocationConvention; import com.facebook.presto.spi.type.TypeSignature; +import com.facebook.presto.sql.tree.QualifiedName; +import com.google.common.collect.ImmutableList; import java.util.List; +import java.util.Objects; import java.util.Optional; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; +import static com.facebook.presto.metadata.SignatureBinder.applyBoundVariables; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; +import static java.util.Objects.requireNonNull; public final class FunctionImplementationDependency extends ScalarImplementationDependency { - public FunctionImplementationDependency(String name, TypeSignature returnType, List argumentTypes, Optional invocationConvention) + private final String name; + private final List argumentTypes; + + public FunctionImplementationDependency(String name, List argumentTypes, Optional invocationConvention) + { + super(invocationConvention); + this.name = requireNonNull(name, "name is null"); + this.argumentTypes = ImmutableList.copyOf(requireNonNull(argumentTypes, "argumentTypes is null")); + } + + @Override + protected FunctionHandle getFunctionHandle(BoundVariables boundVariables, FunctionManager functionManager) + { + return functionManager.lookupFunction(QualifiedName.of(name), fromTypeSignatures(applyBoundVariables(argumentTypes, boundVariables))); + } + + @Override + public boolean equals(Object o) + { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + FunctionImplementationDependency that = (FunctionImplementationDependency) o; + return Objects.equals(name, that.name) && + Objects.equals(argumentTypes, that.argumentTypes); + } + + @Override + public int hashCode() { - super(internalScalarFunction(name, returnType, argumentTypes), invocationConvention); + return Objects.hash(name, argumentTypes); } } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionsParserHelper.java b/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionsParserHelper.java index a3382f034043c..8da6c9c4d420b 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionsParserHelper.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/annotations/FunctionsParserHelper.java @@ -92,7 +92,7 @@ public static List createTypeVariableConstraints(Iterabl if (operator == CAST) { continue; } - Set argumentTypes = ((OperatorImplementationDependency) dependency).getSignature().getArgumentTypes().stream() + Set argumentTypes = ((OperatorImplementationDependency) dependency).getArgumentTypes().stream() .map(TypeSignature::getBase) .collect(toImmutableSet()); checkArgument(argumentTypes.size() == 1, "Operator dependency must only have arguments of a single type"); diff --git a/presto-main/src/main/java/com/facebook/presto/operator/annotations/ImplementationDependency.java b/presto-main/src/main/java/com/facebook/presto/operator/annotations/ImplementationDependency.java index 834e8d79f0db2..ddf9a80cd28ca 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/annotations/ImplementationDependency.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/annotations/ImplementationDependency.java @@ -106,7 +106,6 @@ public static ImplementationDependency createDependency(Annotation annotation, S FunctionDependency functionDependency = (FunctionDependency) annotation; return new FunctionImplementationDependency( functionDependency.name(), - parseTypeSignature(functionDependency.returnType(), literalParameters), Arrays.stream(functionDependency.argumentTypes()) .map(signature -> parseTypeSignature(signature, literalParameters)) .collect(toImmutableList()), @@ -116,7 +115,6 @@ public static ImplementationDependency createDependency(Annotation annotation, S OperatorDependency operatorDependency = (OperatorDependency) annotation; return new OperatorImplementationDependency( operatorDependency.operator(), - parseTypeSignature(operatorDependency.returnType(), literalParameters), Arrays.stream(operatorDependency.argumentTypes()) .map(signature -> parseTypeSignature(signature, literalParameters)) .collect(toImmutableList()), diff --git a/presto-main/src/main/java/com/facebook/presto/operator/annotations/OperatorImplementationDependency.java b/presto-main/src/main/java/com/facebook/presto/operator/annotations/OperatorImplementationDependency.java index 2138bb6e5ce90..d185951245280 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/annotations/OperatorImplementationDependency.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/annotations/OperatorImplementationDependency.java @@ -13,29 +13,68 @@ */ package com.facebook.presto.operator.annotations; +import com.facebook.presto.metadata.BoundVariables; +import com.facebook.presto.metadata.FunctionManager; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.InvocationConvention; import com.facebook.presto.spi.function.OperatorType; import com.facebook.presto.spi.type.TypeSignature; +import com.google.common.collect.ImmutableList; import java.util.List; +import java.util.Objects; import java.util.Optional; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; +import static com.facebook.presto.metadata.SignatureBinder.applyBoundVariables; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; import static java.util.Objects.requireNonNull; public final class OperatorImplementationDependency extends ScalarImplementationDependency { private final OperatorType operator; + private final List argumentTypes; - public OperatorImplementationDependency(OperatorType operator, TypeSignature returnType, List argumentTypes, Optional invocationConvention) + public OperatorImplementationDependency(OperatorType operator, List argumentTypes, Optional invocationConvention) { - super(internalOperator(operator, returnType, argumentTypes), invocationConvention); + super(invocationConvention); this.operator = requireNonNull(operator, "operator is null"); + this.argumentTypes = ImmutableList.copyOf(requireNonNull(argumentTypes, "argumentTypes is null")); } public OperatorType getOperator() { return operator; } + + public List getArgumentTypes() + { + return argumentTypes; + } + + @Override + protected FunctionHandle getFunctionHandle(BoundVariables boundVariables, FunctionManager functionManager) + { + return functionManager.resolveOperator(operator, fromTypeSignatures(applyBoundVariables(argumentTypes, boundVariables))); + } + + @Override + public boolean equals(Object o) + { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + OperatorImplementationDependency that = (OperatorImplementationDependency) o; + return Objects.equals(operator, that.operator) && + Objects.equals(argumentTypes, that.argumentTypes); + } + + @Override + public int hashCode() + { + return Objects.hash(operator, argumentTypes); + } } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/annotations/ScalarImplementationDependency.java b/presto-main/src/main/java/com/facebook/presto/operator/annotations/ScalarImplementationDependency.java index 79faa95064ec7..c07b6e92377d3 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/annotations/ScalarImplementationDependency.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/annotations/ScalarImplementationDependency.java @@ -15,63 +15,39 @@ import com.facebook.presto.metadata.BoundVariables; import com.facebook.presto.metadata.FunctionManager; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.InvocationConvention; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.TypeManager; import java.lang.invoke.MethodHandle; -import java.util.Objects; import java.util.Optional; -import static com.facebook.presto.metadata.SignatureBinder.applyBoundVariables; -import static java.util.Objects.requireNonNull; - public abstract class ScalarImplementationDependency implements ImplementationDependency { - private final Signature signature; private final Optional invocationConvention; - protected ScalarImplementationDependency(Signature signature, Optional invocationConvention) + protected ScalarImplementationDependency(Optional invocationConvention) { - this.signature = requireNonNull(signature, "signature is null"); this.invocationConvention = invocationConvention; } - public Signature getSignature() - { - return signature; - } - + protected abstract FunctionHandle getFunctionHandle(BoundVariables boundVariables, FunctionManager functionManager); @Override public MethodHandle resolve(BoundVariables boundVariables, TypeManager typeManager, FunctionManager functionManager) { - Signature signature = applyBoundVariables(this.signature, boundVariables, this.signature.getArgumentTypes().size()); + FunctionHandle functionHandle = getFunctionHandle(boundVariables, functionManager); if (invocationConvention.isPresent()) { - return functionManager.getFunctionInvokerProvider().createFunctionInvoker(signature, invocationConvention).methodHandle(); + return functionManager.getFunctionInvokerProvider().createFunctionInvoker(functionHandle, invocationConvention).methodHandle(); } else { - return functionManager.getScalarFunctionImplementation(signature).getMethodHandle(); + return functionManager.getScalarFunctionImplementation(functionHandle).getMethodHandle(); } } @Override - public boolean equals(Object o) - { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - ScalarImplementationDependency that = (ScalarImplementationDependency) o; - return Objects.equals(signature, that.signature) && - Objects.equals(invocationConvention, that.invocationConvention); - } + public abstract boolean equals(Object o); @Override - public int hashCode() - { - return Objects.hash(signature, invocationConvention); - } + public abstract int hashCode(); } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/annotations/TypeImplementationDependency.java b/presto-main/src/main/java/com/facebook/presto/operator/annotations/TypeImplementationDependency.java index 1a37b78fc0235..5abad3652c244 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/annotations/TypeImplementationDependency.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/annotations/TypeImplementationDependency.java @@ -38,7 +38,7 @@ public TypeImplementationDependency(String signature) @Override public Type resolve(BoundVariables boundVariables, TypeManager typeManager, FunctionManager functionManager) { - return typeManager.getType(applyBoundVariables(signature, boundVariables)); + return applyBoundVariables(typeManager, signature, boundVariables); } @Override diff --git a/presto-main/src/main/java/com/facebook/presto/operator/project/PageFieldsToInputParametersRewriter.java b/presto-main/src/main/java/com/facebook/presto/operator/project/PageFieldsToInputParametersRewriter.java index 8b7da048b841a..f22bf4102cb9a 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/project/PageFieldsToInputParametersRewriter.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/project/PageFieldsToInputParametersRewriter.java @@ -19,6 +19,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.collect.ImmutableList; @@ -77,7 +78,7 @@ private Integer getParameterForField(InputReferenceExpression reference) public RowExpression visitCall(CallExpression call, Void context) { return new CallExpression( - call.getSignature(), + call.getFunctionHandle(), call.getType(), call.getArguments().stream() .map(expression -> expression.accept(this, context)) @@ -104,6 +105,17 @@ public RowExpression visitVariableReference(VariableReferenceExpression referenc { return reference; } + + @Override + public RowExpression visitSpecialForm(SpecialFormExpression specialForm, Void context) + { + return new SpecialFormExpression( + specialForm.getForm(), + specialForm.getType(), + specialForm.getArguments().stream() + .map(expression -> expression.accept(this, context)) + .collect(toImmutableList())); + } } public static class Result diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayContains.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayContains.java index adc685ed65f65..46bbef39c5645 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayContains.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayContains.java @@ -42,7 +42,7 @@ private ArrayContains() {} @SqlNullable public static Boolean contains( @TypeParameter("T") Type elementType, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equals, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equals, @SqlType("array(T)") Block arrayBlock, @SqlType("T") Block value) { @@ -74,7 +74,7 @@ public static Boolean contains( @SqlNullable public static Boolean contains( @TypeParameter("T") Type elementType, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equals, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equals, @SqlType("array(T)") Block arrayBlock, @SqlType("T") Slice value) { @@ -106,7 +106,7 @@ public static Boolean contains( @SqlNullable public static Boolean contains( @TypeParameter("T") Type elementType, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equals, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equals, @SqlType("array(T)") Block arrayBlock, @SqlType("T") long value) { @@ -138,7 +138,7 @@ public static Boolean contains( @SqlNullable public static Boolean contains( @TypeParameter("T") Type elementType, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equals, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equals, @SqlType("array(T)") Block arrayBlock, @SqlType("T") boolean value) { @@ -170,7 +170,7 @@ public static Boolean contains( @SqlNullable public static Boolean contains( @TypeParameter("T") Type elementType, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equals, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equals, @SqlType("array(T)") Block arrayBlock, @SqlType("T") double value) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayDistinctFromOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayDistinctFromOperator.java index 4823acddea7cd..0bfa66c348d42 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayDistinctFromOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayDistinctFromOperator.java @@ -42,7 +42,6 @@ private ArrayDistinctFromOperator() {} public static boolean isDistinctFrom( @OperatorDependency( operator = IS_DISTINCT_FROM, - returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}, convention = @Convention(arguments = {BLOCK_POSITION, BLOCK_POSITION}, result = FAIL_ON_NULL)) MethodHandle function, @SqlType("array(E)") Block left, @@ -81,7 +80,6 @@ public static boolean isDistinctFrom( public static boolean isDistinctFrom( @OperatorDependency( operator = IS_DISTINCT_FROM, - returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}, convention = @Convention(arguments = {BLOCK_POSITION, BLOCK_POSITION}, result = FAIL_ON_NULL)) MethodHandle elementIsDistinctFrom, @TypeParameter("array(E)") Type type, diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayEqualOperator.java index 628b3b2fa7117..3c6034705ba75 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayEqualOperator.java @@ -38,7 +38,7 @@ private ArrayEqualOperator() {} @SqlType(StandardTypes.BOOLEAN) @SqlNullable public static Boolean equals( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) @@ -80,7 +80,7 @@ else if (!result) { @SqlType(StandardTypes.BOOLEAN) @SqlNullable public static Boolean equalsLong( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) @@ -122,7 +122,7 @@ else if (!result) { @SqlType(StandardTypes.BOOLEAN) @SqlNullable public static Boolean equalsDouble( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOperator.java index 2d590c16d0de3..d0699023c1486 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOperator.java @@ -38,7 +38,7 @@ private ArrayGreaterThanOperator() {} @TypeParameter("T") @SqlType(StandardTypes.BOOLEAN) public static boolean greaterThan( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle greaterThanFunction, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle greaterThanFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block leftArray, @SqlType("array(T)") Block rightArray) @@ -71,7 +71,7 @@ public static boolean greaterThan( @TypeParameterSpecialization(name = "T", nativeContainerType = long.class) @SqlType(StandardTypes.BOOLEAN) public static boolean greaterThanLong( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle greaterThanFunction, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle greaterThanFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block leftArray, @SqlType("array(T)") Block rightArray) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOrEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOrEqualOperator.java index d0a0661851900..4789eca177164 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOrEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayGreaterThanOrEqualOperator.java @@ -38,7 +38,7 @@ private ArrayGreaterThanOrEqualOperator() {} @TypeParameter("T") @SqlType(StandardTypes.BOOLEAN) public static boolean greaterThanOrEqual( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle greaterThanFunction, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle greaterThanFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block leftArray, @SqlType("array(T)") Block rightArray) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayHashCodeOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayHashCodeOperator.java index cc26bf36d930e..db0418bbb10a7 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayHashCodeOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayHashCodeOperator.java @@ -38,7 +38,7 @@ private ArrayHashCodeOperator() {} @TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long hash( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"T"}) MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { @@ -58,7 +58,7 @@ public static long hash( @TypeParameterSpecialization(name = "T", nativeContainerType = long.class) @SqlType(StandardTypes.BIGINT) public static long hashLong( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"T"}) MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { @@ -78,7 +78,7 @@ public static long hashLong( @TypeParameterSpecialization(name = "T", nativeContainerType = boolean.class) @SqlType(StandardTypes.BIGINT) public static long hashBoolean( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"T"}) MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { @@ -98,7 +98,7 @@ public static long hashBoolean( @TypeParameterSpecialization(name = "T", nativeContainerType = Slice.class) @SqlType(StandardTypes.BIGINT) public static long hashSlice( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"T"}) MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { @@ -118,7 +118,7 @@ public static long hashSlice( @TypeParameterSpecialization(name = "T", nativeContainerType = double.class) @SqlType(StandardTypes.BIGINT) public static long hashDouble( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"T"}) MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"T"}) MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayIndeterminateOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayIndeterminateOperator.java index 2fc733ab4ccb5..006dec7151b08 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayIndeterminateOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayIndeterminateOperator.java @@ -36,7 +36,7 @@ private ArrayIndeterminateOperator() {} @TypeParameter("T") @SqlType(StandardTypes.BOOLEAN) public static boolean indeterminate( - @OperatorDependency(operator = INDETERMINATE, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T"}) MethodHandle elementIndeterminateFunction, + @OperatorDependency(operator = INDETERMINATE, argumentTypes = {"T"}) MethodHandle elementIndeterminateFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block, @IsNull boolean isNull) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayJoin.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayJoin.java index 2cd46090561af..5ed26c55f5b55 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayJoin.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayJoin.java @@ -40,12 +40,12 @@ import java.util.Map; import java.util.Optional; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentProperty.valueTypeArgumentProperty; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.USE_BOXED_TYPE; import static com.facebook.presto.spi.StandardErrorCode.GENERIC_INTERNAL_ERROR; import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT; -import static com.facebook.presto.spi.function.OperatorType.CAST; import static com.facebook.presto.spi.function.Signature.typeVariable; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOperator.java index c7e2c11e817b1..cb78f8d1c5616 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOperator.java @@ -38,7 +38,7 @@ private ArrayLessThanOperator() {} @TypeParameter("E") @SqlType(StandardTypes.BOOLEAN) public static boolean lessThan( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) @@ -71,7 +71,7 @@ public static boolean lessThan( @TypeParameterSpecialization(name = "E", nativeContainerType = long.class) @SqlType(StandardTypes.BOOLEAN) public static boolean lessThanLong( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOrEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOrEqualOperator.java index 1f843c2ae653f..3caf67a389a9a 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOrEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayLessThanOrEqualOperator.java @@ -39,7 +39,7 @@ private ArrayLessThanOrEqualOperator() {} @TypeParameter("E") @SqlType(StandardTypes.BOOLEAN) public static boolean lessThanOrEqual( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) @@ -72,7 +72,7 @@ public static boolean lessThanOrEqual( @TypeParameterSpecialization(name = "E", nativeContainerType = long.class) @SqlType(StandardTypes.BOOLEAN) public static boolean lessThanOrEqualLong( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMaxFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMaxFunction.java index 5dff5eb634ca8..3ee7c217f3517 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMaxFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMaxFunction.java @@ -20,7 +20,6 @@ import com.facebook.presto.spi.function.SqlNullable; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.function.TypeParameter; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import io.airlift.slice.Slice; @@ -43,7 +42,7 @@ private ArrayMaxFunction() {} @SqlType("T") @SqlNullable public static Long longArrayMax( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -54,7 +53,7 @@ public static Long longArrayMax( @SqlType("T") @SqlNullable public static Boolean booleanArrayMax( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -65,7 +64,7 @@ public static Boolean booleanArrayMax( @SqlType("T") @SqlNullable public static Double doubleArrayMax( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -76,7 +75,7 @@ public static Double doubleArrayMax( @SqlType("T") @SqlNullable public static Slice sliceArrayMax( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -87,7 +86,7 @@ public static Slice sliceArrayMax( @SqlType("T") @SqlNullable public static Block blockArrayMax( - @OperatorDependency(operator = GREATER_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = GREATER_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMinFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMinFunction.java index e3bb12be369c9..69be9b5381e07 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMinFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayMinFunction.java @@ -20,7 +20,6 @@ import com.facebook.presto.spi.function.SqlNullable; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.function.TypeParameter; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import io.airlift.slice.Slice; @@ -43,7 +42,7 @@ private ArrayMinFunction() {} @SqlType("T") @SqlNullable public static Long longArrayMin( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -54,7 +53,7 @@ public static Long longArrayMin( @SqlType("T") @SqlNullable public static Boolean booleanArrayMin( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -65,7 +64,7 @@ public static Boolean booleanArrayMin( @SqlType("T") @SqlNullable public static Double doubleArrayMin( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -76,7 +75,7 @@ public static Double doubleArrayMin( @SqlType("T") @SqlNullable public static Slice sliceArrayMin( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { @@ -87,7 +86,7 @@ public static Slice sliceArrayMin( @SqlType("T") @SqlNullable public static Block blockArrayMin( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"T", "T"}) MethodHandle compareMethodHandle, @TypeParameter("T") Type elementType, @SqlType("array(T)") Block block) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayNotEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayNotEqualOperator.java index 5c949b1a4d126..31de3a4cb28fd 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayNotEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayNotEqualOperator.java @@ -36,7 +36,7 @@ private ArrayNotEqualOperator() {} @SqlType(StandardTypes.BOOLEAN) @SqlNullable public static Boolean notEqual( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block left, @SqlType("array(E)") Block right) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayPositionFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayPositionFunction.java index 5563ab563549c..72dd598157491 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayPositionFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayPositionFunction.java @@ -40,7 +40,7 @@ private ArrayPositionFunction() {} @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") boolean element) { @@ -67,7 +67,7 @@ public static long arrayPosition( @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") long element) { @@ -94,7 +94,7 @@ public static long arrayPosition( @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") double element) { @@ -121,7 +121,7 @@ public static long arrayPosition( @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") Slice element) { @@ -148,7 +148,7 @@ public static long arrayPosition( @SqlType(StandardTypes.BIGINT) public static long arrayPosition( @TypeParameter("T") Type type, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, + @OperatorDependency(operator = EQUAL, argumentTypes = {"T", "T"}) MethodHandle equalMethodHandle, @SqlType("array(T)") Block array, @SqlType("T") Block element) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayRemoveFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayRemoveFunction.java index f9f51995e4d72..0b662a3da0e5c 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayRemoveFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayRemoveFunction.java @@ -22,7 +22,6 @@ import com.facebook.presto.spi.function.ScalarFunction; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.function.TypeParameter; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import com.google.common.collect.ImmutableList; @@ -50,7 +49,7 @@ public ArrayRemoveFunction(@TypeParameter("E") Type elementType) @TypeParameter("E") @SqlType("array(E)") public Block remove( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block array, @SqlType("E") long value) @@ -61,7 +60,7 @@ public Block remove( @TypeParameter("E") @SqlType("array(E)") public Block remove( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block array, @SqlType("E") double value) @@ -72,7 +71,7 @@ public Block remove( @TypeParameter("E") @SqlType("array(E)") public Block remove( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block array, @SqlType("E") boolean value) @@ -83,7 +82,7 @@ public Block remove( @TypeParameter("E") @SqlType("array(E)") public Block remove( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"E", "E"}) MethodHandle equalsFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block array, @SqlType("E") Object value) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraySortFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraySortFunction.java index a538a84c658fc..896d14ab419e8 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraySortFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraySortFunction.java @@ -21,7 +21,6 @@ import com.facebook.presto.spi.function.ScalarFunction; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.function.TypeParameter; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import com.google.common.collect.ImmutableList; import com.google.common.primitives.Ints; @@ -50,7 +49,7 @@ public ArraySortFunction(@TypeParameter("E") Type elementType) @TypeParameter("E") @SqlType("array(E)") public Block sort( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block block) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayToArrayCast.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayToArrayCast.java index 4943c541b27c6..950a9dc610979 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayToArrayCast.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArrayToArrayCast.java @@ -37,6 +37,7 @@ import java.lang.invoke.MethodHandle; +import static com.facebook.presto.metadata.CastType.fromOperatorType; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentProperty.valueTypeArgumentProperty; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; import static com.facebook.presto.spi.function.OperatorType.CAST; @@ -75,7 +76,7 @@ public ScalarFunctionImplementation specialize(BoundVariables boundVariables, in Type fromType = boundVariables.getTypeVariable("F"); Type toType = boundVariables.getTypeVariable("T"); - FunctionHandle functionHandle = functionManager.lookupCast(CAST, fromType.getTypeSignature(), toType.getTypeSignature()); + FunctionHandle functionHandle = functionManager.lookupCast(fromOperatorType(CAST), fromType.getTypeSignature(), toType.getTypeSignature()); ScalarFunctionImplementation function = functionManager.getScalarFunctionImplementation(functionHandle); Class castOperatorClass = generateArrayCast(typeManager, functionHandle.getSignature(), function); MethodHandle methodHandle = methodHandle(castOperatorClass, "castArray", ConnectorSession.class, Block.class); diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraysOverlapFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraysOverlapFunction.java index a3687327dc2f2..942a012a7b0cb 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraysOverlapFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/ArraysOverlapFunction.java @@ -71,7 +71,7 @@ public int compare(int left, int right) @SqlNullable @SqlType(StandardTypes.BOOLEAN) public Boolean arraysOverlapInt( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"integer", "integer"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"integer", "integer"}) MethodHandle lessThanFunction, @SqlType("array(integer)") Block leftArray, @SqlType("array(integer)") Block rightArray) { @@ -81,7 +81,7 @@ public Boolean arraysOverlapInt( @SqlNullable @SqlType(StandardTypes.BOOLEAN) public Boolean arraysOverlapBigInt( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"bigint", "bigint"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"bigint", "bigint"}) MethodHandle lessThanFunction, @SqlType("array(bigint)") Block leftArray, @SqlType("array(bigint)") Block rightArray) { @@ -92,7 +92,7 @@ public Boolean arraysOverlapBigInt( @TypeParameter("E") @SqlType(StandardTypes.BOOLEAN) public Boolean arraysOverlap( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {"E", "E"}) MethodHandle lessThanFunction, @TypeParameter("E") Type type, @SqlType("array(E)") Block leftArray, @SqlType("array(E)") Block rightArray) diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapConstructor.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapConstructor.java index e93f1fc6eaf6f..5bb4e526646bf 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapConstructor.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapConstructor.java @@ -47,6 +47,7 @@ import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.StandardTypes.MAP; import static com.facebook.presto.spi.type.TypeUtils.readNativeValue; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.util.Failures.checkCondition; import static com.facebook.presto.util.Failures.internalError; import static com.facebook.presto.util.Reflection.constructorMethodHandle; @@ -108,8 +109,8 @@ public ScalarFunctionImplementation specialize(BoundVariables boundVariables, in Type valueType = boundVariables.getTypeVariable("V"); Type mapType = typeManager.getParameterizedType(MAP, ImmutableList.of(TypeSignatureParameter.of(keyType.getTypeSignature()), TypeSignatureParameter.of(valueType.getTypeSignature()))); - MethodHandle keyHashCode = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(OperatorType.HASH_CODE, ImmutableList.of(keyType))).getMethodHandle(); - MethodHandle keyEqual = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(OperatorType.EQUAL, ImmutableList.of(keyType, keyType))).getMethodHandle(); + MethodHandle keyHashCode = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(OperatorType.HASH_CODE, fromTypes(keyType))).getMethodHandle(); + MethodHandle keyEqual = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(OperatorType.EQUAL, fromTypes(keyType, keyType))).getMethodHandle(); MethodHandle keyIndeterminate = functionManager.getScalarFunctionImplementation(internalOperator(INDETERMINATE.name(), BOOLEAN.getTypeSignature(), ImmutableList.of(keyType.getTypeSignature()))).getMethodHandle(); MethodHandle instanceFactory = constructorMethodHandle(State.class, MapType.class).bindTo(mapType); diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapDistinctFromOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapDistinctFromOperator.java index 85da781a7d55a..0fce999342e96 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapDistinctFromOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapDistinctFromOperator.java @@ -41,7 +41,7 @@ private MapDistinctFromOperator() {} @TypeParameter("V") @SqlType(StandardTypes.BOOLEAN) public static boolean isDistinctFrom( - @OperatorDependency(operator = IS_DISTINCT_FROM, returnType = StandardTypes.BOOLEAN, argumentTypes = {"V", "V"}, convention = @Convention(arguments = {BLOCK_POSITION, BLOCK_POSITION}, result = FAIL_ON_NULL)) + @OperatorDependency(operator = IS_DISTINCT_FROM, argumentTypes = {"V", "V"}, convention = @Convention(arguments = {BLOCK_POSITION, BLOCK_POSITION}, result = FAIL_ON_NULL)) MethodHandle valueDistinctFromFunction, @TypeParameter("map(K, V)") Type mapType, @SqlType("map(K,V)") Block leftMapBlock, @@ -67,7 +67,7 @@ public static boolean isDistinctFrom( @TypeParameter("V") @SqlType(StandardTypes.BOOLEAN) public static boolean isDistinctFrom( - @OperatorDependency(operator = IS_DISTINCT_FROM, returnType = StandardTypes.BOOLEAN, argumentTypes = {"V", "V"}, convention = @Convention(arguments = {BLOCK_POSITION, BLOCK_POSITION}, result = FAIL_ON_NULL)) + @OperatorDependency(operator = IS_DISTINCT_FROM, argumentTypes = {"V", "V"}, convention = @Convention(arguments = {BLOCK_POSITION, BLOCK_POSITION}, result = FAIL_ON_NULL)) MethodHandle valueDistinctFromFunction, @TypeParameter("map(K, V)") Type mapType, @BlockPosition @SqlType(value = "map(K,V)", nativeContainerType = Block.class) Block left, diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapEqualOperator.java index 515a89fd90d1f..8c9e306793645 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapEqualOperator.java @@ -38,9 +38,9 @@ private MapEqualOperator() {} @SqlNullable @SqlType(StandardTypes.BOOLEAN) public static Boolean equals( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"K", "K"}) MethodHandle keyEqualsFunction, - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"K"}) MethodHandle keyHashcodeFunction, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"V", "V"}) MethodHandle valueEqualsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"K", "K"}) MethodHandle keyEqualsFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"K"}) MethodHandle keyHashcodeFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"V", "V"}) MethodHandle valueEqualsFunction, @TypeParameter("K") Type keyType, @TypeParameter("V") Type valueType, @SqlType("map(K,V)") Block leftMapBlock, diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapIndeterminateOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapIndeterminateOperator.java index e2e7260ef6be6..e7c91a28d1517 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapIndeterminateOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapIndeterminateOperator.java @@ -37,7 +37,7 @@ private MapIndeterminateOperator() {} @TypeParameter("V") @SqlType(StandardTypes.BOOLEAN) public static boolean indeterminate( - @OperatorDependency(operator = INDETERMINATE, returnType = StandardTypes.BOOLEAN, argumentTypes = {"V"}) MethodHandle valueIndeterminateFunction, + @OperatorDependency(operator = INDETERMINATE, argumentTypes = {"V"}) MethodHandle valueIndeterminateFunction, @TypeParameter("K") Type keyType, @TypeParameter("V") Type valueType, @SqlType("map(K,V)") Block block, diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapNotEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapNotEqualOperator.java index 3bb36bd744841..1485ac258b6b6 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapNotEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapNotEqualOperator.java @@ -38,9 +38,9 @@ private MapNotEqualOperator() {} @SqlNullable @SqlType(StandardTypes.BOOLEAN) public static Boolean notEqual( - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"K", "K"}) MethodHandle keyEqualsFunction, - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = {"K"}) MethodHandle keyHashcodeFunction, - @OperatorDependency(operator = EQUAL, returnType = StandardTypes.BOOLEAN, argumentTypes = {"V", "V"}) MethodHandle valueEqualsFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"K", "K"}) MethodHandle keyEqualsFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = {"K"}) MethodHandle keyHashcodeFunction, + @OperatorDependency(operator = EQUAL, argumentTypes = {"V", "V"}) MethodHandle valueEqualsFunction, @TypeParameter("K") Type keyType, @TypeParameter("V") Type valueType, @SqlType("map(K,V)") Block left, diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapSubscriptOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapSubscriptOperator.java index 01c4cf0483c11..c7d142216977f 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapSubscriptOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapSubscriptOperator.java @@ -21,9 +21,9 @@ import com.facebook.presto.spi.PrestoException; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.SingleMapBlock; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeManager; -import com.facebook.presto.spi.type.VarcharType; import com.facebook.presto.sql.InterpretedFunctionInvoker; import com.google.common.collect.ImmutableList; import com.google.common.primitives.Primitives; @@ -32,6 +32,7 @@ import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentProperty.valueTypeArgumentProperty; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT; @@ -39,18 +40,18 @@ import static com.facebook.presto.spi.function.Signature.typeVariable; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.readNativeValue; -import static com.facebook.presto.sql.relational.Signatures.castSignature; +import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.util.Reflection.methodHandle; import static java.lang.String.format; public class MapSubscriptOperator extends SqlOperator { - private static final MethodHandle METHOD_HANDLE_BOOLEAN = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, InterpretedFunctionInvoker.class, Type.class, Type.class, ConnectorSession.class, Block.class, boolean.class); - private static final MethodHandle METHOD_HANDLE_LONG = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, InterpretedFunctionInvoker.class, Type.class, Type.class, ConnectorSession.class, Block.class, long.class); - private static final MethodHandle METHOD_HANDLE_DOUBLE = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, InterpretedFunctionInvoker.class, Type.class, Type.class, ConnectorSession.class, Block.class, double.class); - private static final MethodHandle METHOD_HANDLE_SLICE = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, InterpretedFunctionInvoker.class, Type.class, Type.class, ConnectorSession.class, Block.class, Slice.class); - private static final MethodHandle METHOD_HANDLE_OBJECT = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, InterpretedFunctionInvoker.class, Type.class, Type.class, ConnectorSession.class, Block.class, Object.class); + private static final MethodHandle METHOD_HANDLE_BOOLEAN = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, MissingKeyExceptionFactory.class, Type.class, Type.class, ConnectorSession.class, Block.class, boolean.class); + private static final MethodHandle METHOD_HANDLE_LONG = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, MissingKeyExceptionFactory.class, Type.class, Type.class, ConnectorSession.class, Block.class, long.class); + private static final MethodHandle METHOD_HANDLE_DOUBLE = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, MissingKeyExceptionFactory.class, Type.class, Type.class, ConnectorSession.class, Block.class, double.class); + private static final MethodHandle METHOD_HANDLE_SLICE = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, MissingKeyExceptionFactory.class, Type.class, Type.class, ConnectorSession.class, Block.class, Slice.class); + private static final MethodHandle METHOD_HANDLE_OBJECT = methodHandle(MapSubscriptOperator.class, "subscript", boolean.class, MissingKeyExceptionFactory.class, Type.class, Type.class, ConnectorSession.class, Block.class, Object.class); private final boolean legacyMissingKey; @@ -87,8 +88,8 @@ else if (keyType.getJavaType() == Slice.class) { methodHandle = METHOD_HANDLE_OBJECT; } methodHandle = MethodHandles.insertArguments(methodHandle, 0, legacyMissingKey); - InterpretedFunctionInvoker functionInvoker = new InterpretedFunctionInvoker(functionManager); - methodHandle = methodHandle.bindTo(functionInvoker).bindTo(keyType).bindTo(valueType); + MissingKeyExceptionFactory missingKeyExceptionFactory = new MissingKeyExceptionFactory(functionManager, keyType); + methodHandle = methodHandle.bindTo(missingKeyExceptionFactory).bindTo(keyType).bindTo(valueType); methodHandle = methodHandle.asType(methodHandle.type().changeReturnType(Primitives.wrap(valueType.getJavaType()))); return new ScalarFunctionImplementation( @@ -101,7 +102,7 @@ else if (keyType.getJavaType() == Slice.class) { } @UsedByGeneratedCode - public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvoker functionInvoker, Type keyType, Type valueType, ConnectorSession session, Block map, boolean key) + public static Object subscript(boolean legacyMissingKey, MissingKeyExceptionFactory missingKeyExceptionFactory, Type keyType, Type valueType, ConnectorSession session, Block map, boolean key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); @@ -109,13 +110,13 @@ public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvo if (legacyMissingKey) { return null; } - throw throwMissingKeyException(keyType, functionInvoker, key, session); + throw missingKeyExceptionFactory.create(session, key); } return readNativeValue(valueType, mapBlock, valuePosition); } @UsedByGeneratedCode - public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvoker functionInvoker, Type keyType, Type valueType, ConnectorSession session, Block map, long key) + public static Object subscript(boolean legacyMissingKey, MissingKeyExceptionFactory missingKeyExceptionFactory, Type keyType, Type valueType, ConnectorSession session, Block map, long key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); @@ -123,13 +124,13 @@ public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvo if (legacyMissingKey) { return null; } - throw throwMissingKeyException(keyType, functionInvoker, key, session); + throw missingKeyExceptionFactory.create(session, key); } return readNativeValue(valueType, mapBlock, valuePosition); } @UsedByGeneratedCode - public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvoker functionInvoker, Type keyType, Type valueType, ConnectorSession session, Block map, double key) + public static Object subscript(boolean legacyMissingKey, MissingKeyExceptionFactory missingKeyExceptionFactory, Type keyType, Type valueType, ConnectorSession session, Block map, double key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); @@ -137,13 +138,13 @@ public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvo if (legacyMissingKey) { return null; } - throw throwMissingKeyException(keyType, functionInvoker, key, session); + throw missingKeyExceptionFactory.create(session, key); } return readNativeValue(valueType, mapBlock, valuePosition); } @UsedByGeneratedCode - public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvoker functionInvoker, Type keyType, Type valueType, ConnectorSession session, Block map, Slice key) + public static Object subscript(boolean legacyMissingKey, MissingKeyExceptionFactory missingKeyExceptionFactory, Type keyType, Type valueType, ConnectorSession session, Block map, Slice key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact(key); @@ -151,13 +152,13 @@ public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvo if (legacyMissingKey) { return null; } - throw throwMissingKeyException(keyType, functionInvoker, key, session); + throw missingKeyExceptionFactory.create(session, key); } return readNativeValue(valueType, mapBlock, valuePosition); } @UsedByGeneratedCode - public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvoker functionInvoker, Type keyType, Type valueType, ConnectorSession session, Block map, Object key) + public static Object subscript(boolean legacyMissingKey, MissingKeyExceptionFactory missingKeyExceptionFactory, Type keyType, Type valueType, ConnectorSession session, Block map, Object key) { SingleMapBlock mapBlock = (SingleMapBlock) map; int valuePosition = mapBlock.seekKeyExact((Block) key); @@ -165,20 +166,40 @@ public static Object subscript(boolean legacyMissingKey, InterpretedFunctionInvo if (legacyMissingKey) { return null; } - throw throwMissingKeyException(keyType, functionInvoker, key, session); + throw missingKeyExceptionFactory.create(session, key); } return readNativeValue(valueType, mapBlock, valuePosition); } - private static RuntimeException throwMissingKeyException(Type type, InterpretedFunctionInvoker functionInvoker, Object value, ConnectorSession session) + private static class MissingKeyExceptionFactory { - String stringValue; - try { - stringValue = ((Slice) functionInvoker.invoke(castSignature(VarcharType.VARCHAR, type), session, value)).toStringUtf8(); + private final InterpretedFunctionInvoker functionInvoker; + private final FunctionHandle castFunction; + + public MissingKeyExceptionFactory(FunctionManager functionManager, Type keyType) + { + functionInvoker = new InterpretedFunctionInvoker(functionManager); + + FunctionHandle castFunction = null; + try { + castFunction = functionManager.lookupCast(CAST, keyType.getTypeSignature(), VARCHAR.getTypeSignature()); + } + catch (PrestoException ignored) { + } + this.castFunction = castFunction; } - catch (RuntimeException e) { - throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Key not present in map"); + + public PrestoException create(ConnectorSession session, Object value) + { + if (castFunction != null) { + try { + Slice varcharValue = (Slice) functionInvoker.invoke(castFunction, session, value); + return new PrestoException(INVALID_FUNCTION_ARGUMENT, format("Key not present in map: %s", varcharValue.toStringUtf8())); + } + catch (RuntimeException ignored) { + } + } + return new PrestoException(INVALID_FUNCTION_ARGUMENT, "Key not present in map"); } - throw new PrestoException(INVALID_FUNCTION_ARGUMENT, format("Key not present in map: %s", stringValue)); } } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapToMapCast.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapToMapCast.java index ec1db99236f22..d996286a296af 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapToMapCast.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/MapToMapCast.java @@ -31,6 +31,7 @@ import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; +import static com.facebook.presto.metadata.CastType.fromOperatorType; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentProperty.valueTypeArgumentProperty; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; import static com.facebook.presto.spi.StandardErrorCode.INVALID_CAST_ARGUMENT; @@ -106,7 +107,7 @@ private MethodHandle buildProcessor(FunctionManager functionManager, Type fromTy MethodHandle getter = nativeValueGetter(fromType); // Adapt cast that takes ([ConnectorSession,] ?) to one that takes (?, ConnectorSession), where ? is the return type of getter. - ScalarFunctionImplementation castImplementation = functionManager.getScalarFunctionImplementation(functionManager.lookupCast(CAST, fromType.getTypeSignature(), toType.getTypeSignature())); + ScalarFunctionImplementation castImplementation = functionManager.getScalarFunctionImplementation(functionManager.lookupCast(fromOperatorType(CAST), fromType.getTypeSignature(), toType.getTypeSignature())); MethodHandle cast = castImplementation.getMethodHandle(); if (cast.type().parameterArray()[0] != ConnectorSession.class) { cast = MethodHandles.dropArguments(cast, 0, ConnectorSession.class); diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowComparisonOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowComparisonOperator.java index c5c8c15c6457d..2c73c36729cd2 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowComparisonOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowComparisonOperator.java @@ -29,6 +29,7 @@ import static com.facebook.presto.spi.function.Signature.orderableWithVariadicBound; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.readNativeValue; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.type.TypeUtils.checkElementNotNull; import static com.facebook.presto.util.Failures.internalError; @@ -48,7 +49,7 @@ protected List getMethodHandles(RowType type, FunctionManager func { ImmutableList.Builder argumentMethods = ImmutableList.builder(); for (Type parameterType : type.getTypeParameters()) { - FunctionHandle operatorHandle = functionManager.resolveOperator(operatorType, ImmutableList.of(parameterType, parameterType)); + FunctionHandle operatorHandle = functionManager.resolveOperator(operatorType, fromTypes(parameterType, parameterType)); argumentMethods.add(functionManager.getScalarFunctionImplementation(operatorHandle).getMethodHandle()); } return argumentMethods.build(); diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowDistinctFromOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowDistinctFromOperator.java index d51e66fec862c..fe458d6ef56a8 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowDistinctFromOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowDistinctFromOperator.java @@ -39,6 +39,7 @@ import static com.facebook.presto.spi.function.Signature.comparableWithVariadicBound; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.readNativeValue; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.util.Failures.internalError; import static com.facebook.presto.util.Reflection.methodHandle; import static com.google.common.base.Defaults.defaultValue; @@ -65,7 +66,7 @@ public ScalarFunctionImplementation specialize(BoundVariables boundVariables, in ImmutableList.Builder argumentMethods = ImmutableList.builder(); Type type = boundVariables.getTypeVariable("T"); for (Type parameterType : type.getTypeParameters()) { - FunctionHandle operatorHandle = functionManager.resolveOperator(IS_DISTINCT_FROM, ImmutableList.of(parameterType, parameterType)); + FunctionHandle operatorHandle = functionManager.resolveOperator(IS_DISTINCT_FROM, fromTypes(parameterType, parameterType)); FunctionInvoker functionInvoker = functionManager.getFunctionInvokerProvider().createFunctionInvoker( operatorHandle, Optional.of(new InvocationConvention( diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowEqualOperator.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowEqualOperator.java index 875cac819d704..b3d188bb21aae 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowEqualOperator.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowEqualOperator.java @@ -33,6 +33,7 @@ import static com.facebook.presto.spi.function.Signature.comparableWithVariadicBound; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.readNativeValue; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.util.Failures.internalError; import static com.facebook.presto.util.Reflection.methodHandle; import static com.google.common.collect.ImmutableList.toImmutableList; @@ -76,7 +77,7 @@ public static List resolveFieldEqualOperators(RowType rowType, Fun private static MethodHandle resolveEqualOperator(Type type, FunctionManager functionManager) { - FunctionHandle operator = functionManager.resolveOperator(EQUAL, ImmutableList.of(type, type)); + FunctionHandle operator = functionManager.resolveOperator(EQUAL, fromTypes(type, type)); ScalarFunctionImplementation implementation = functionManager.getScalarFunctionImplementation(operator); return implementation.getMethodHandle(); } diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowToRowCast.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowToRowCast.java index 9c756e72eecee..4ab1df7c38f66 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowToRowCast.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/RowToRowCast.java @@ -43,6 +43,7 @@ import java.lang.invoke.MethodHandle; import java.util.List; +import static com.facebook.presto.metadata.CastType.fromOperatorType; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentProperty.valueTypeArgumentProperty; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; import static com.facebook.presto.spi.function.OperatorType.CAST; @@ -141,7 +142,7 @@ private static Class generateRowCast(Type fromType, Type toType, FunctionMana // loop through to append member blocks for (int i = 0; i < toTypes.size(); i++) { - FunctionHandle functionHandle = functionManager.lookupCast(CAST, fromTypes.get(i).getTypeSignature(), toTypes.get(i).getTypeSignature()); + FunctionHandle functionHandle = functionManager.lookupCast(fromOperatorType(CAST), fromTypes.get(i).getTypeSignature(), toTypes.get(i).getTypeSignature()); ScalarFunctionImplementation function = functionManager.getScalarFunctionImplementation(functionHandle); Type currentFromType = fromTypes.get(i); if (currentFromType.equals(UNKNOWN)) { diff --git a/presto-main/src/main/java/com/facebook/presto/operator/scalar/TryCastFunction.java b/presto-main/src/main/java/com/facebook/presto/operator/scalar/TryCastFunction.java index 3f6ed1255650f..7f439debb86e3 100644 --- a/presto-main/src/main/java/com/facebook/presto/operator/scalar/TryCastFunction.java +++ b/presto-main/src/main/java/com/facebook/presto/operator/scalar/TryCastFunction.java @@ -28,7 +28,7 @@ import java.lang.invoke.MethodHandle; import java.util.List; -import static com.facebook.presto.spi.function.OperatorType.CAST; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.spi.function.Signature.typeVariable; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static java.lang.invoke.MethodHandles.catchException; @@ -40,11 +40,12 @@ public class TryCastFunction extends SqlScalarFunction { public static final TryCastFunction TRY_CAST = new TryCastFunction(); + public static final String TRY_CAST_NAME = "TRY_CAST"; public TryCastFunction() { super(new Signature( - "TRY_CAST", + TRY_CAST_NAME, FunctionKind.SCALAR, ImmutableList.of(typeVariable("F"), typeVariable("T")), ImmutableList.of(), diff --git a/presto-main/src/main/java/com/facebook/presto/sql/InterpretedFunctionInvoker.java b/presto-main/src/main/java/com/facebook/presto/sql/InterpretedFunctionInvoker.java index 149ed7ac3e515..f5777f9a0875e 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/InterpretedFunctionInvoker.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/InterpretedFunctionInvoker.java @@ -51,11 +51,6 @@ public Object invoke(FunctionHandle functionHandle, ConnectorSession session, Li return invoke(functionManager.getScalarFunctionImplementation(functionHandle), session, arguments); } - public Object invoke(Signature function, ConnectorSession session, Object... arguments) - { - return invoke(function, session, Arrays.asList(arguments)); - } - public Object invoke(Signature function, ConnectorSession session, List arguments) { return invoke(functionManager.getScalarFunctionImplementation(function), session, arguments); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java b/presto-main/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java index 28cec45e1fcd1..f0e42845246a3 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java @@ -118,7 +118,7 @@ import java.util.function.Function; import static com.facebook.presto.SystemSessionProperties.isLegacyRowFieldOrdinalAccessEnabled; -import static com.facebook.presto.spi.function.OperatorType.CAST; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.spi.function.OperatorType.SUBSCRIPT; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; @@ -146,6 +146,7 @@ import static com.facebook.presto.sql.analyzer.SemanticErrorCode.STANDALONE_LAMBDA; import static com.facebook.presto.sql.analyzer.SemanticErrorCode.TYPE_MISMATCH; import static com.facebook.presto.sql.analyzer.SemanticExceptions.missingAttributeException; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.tree.Extract.Field.TIMEZONE_HOUR; import static com.facebook.presto.sql.tree.Extract.Field.TIMEZONE_MINUTE; import static com.facebook.presto.type.ArrayParametricType.ARRAY; @@ -1244,7 +1245,7 @@ private Type getOperator(StackableAstVisitorContext context, Expression Signature operatorSignature; try { - operatorSignature = functionManager.resolveOperator(operatorType, argumentTypes.build()).getSignature(); + operatorSignature = functionManager.resolveOperator(operatorType, fromTypes(argumentTypes.build())).getSignature(); } catch (OperatorNotFoundException e) { throw new SemanticException(TYPE_MISMATCH, node, "%s", e.getMessage()); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/analyzer/StatementAnalyzer.java b/presto-main/src/main/java/com/facebook/presto/sql/analyzer/StatementAnalyzer.java index ba8cbcaee0d03..03c825dc75407 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/analyzer/StatementAnalyzer.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/analyzer/StatementAnalyzer.java @@ -194,6 +194,7 @@ import static com.facebook.presto.sql.analyzer.SemanticErrorCode.VIEW_PARSE_ERROR; import static com.facebook.presto.sql.analyzer.SemanticErrorCode.WILDCARD_WITHOUT_FROM; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.planner.DeterminismEvaluator.isDeterministic; import static com.facebook.presto.sql.planner.ExpressionInterpreter.expressionOptimizer; import static com.facebook.presto.sql.tree.ExplainType.Type.DISTRIBUTED; @@ -1238,7 +1239,7 @@ private Scope analyzeJoinUsing(Join node, List columns, Optional analyzeWindowFunctions(QuerySpecification node, List< List argumentTypes = Lists.transform(windowFunction.getArguments(), expression -> analysis.getType(expression).getTypeSignature()); - FunctionKind kind = metadata.getFunctionManager().resolveFunction(windowFunction.getName(), fromTypeSignatures(argumentTypes)).getKind(); + FunctionKind kind = metadata.getFunctionManager().resolveFunction(session, windowFunction.getName(), fromTypeSignatures(argumentTypes)).getSignature().getKind(); if (kind != AGGREGATE && kind != WINDOW) { throw new SemanticException(MUST_BE_WINDOW_FUNCTION, node, "Not a window function: %s", windowFunction.getName()); } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/analyzer/TypeSignatureProvider.java b/presto-main/src/main/java/com/facebook/presto/sql/analyzer/TypeSignatureProvider.java index 6d81a1f6e9e0a..e5e796339db18 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/analyzer/TypeSignatureProvider.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/analyzer/TypeSignatureProvider.java @@ -73,6 +73,11 @@ public static List fromTypes(List types) .collect(toImmutableList()); } + public static List fromTypeSignatures(TypeSignature... typeSignatures) + { + return fromTypeSignatures(ImmutableList.copyOf(typeSignatures)); + } + public static List fromTypeSignatures(List typeSignatures) { return typeSignatures.stream() diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/AndCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/AndCodeGenerator.java index f954454030288..beb40fdfbbc46 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/AndCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/AndCodeGenerator.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import com.google.common.base.Preconditions; @@ -26,14 +25,14 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; public class AndCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generator, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generator, Type returnType, List arguments, Optional outputBlockVariable) { Preconditions.checkArgument(arguments.size() == 2); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/BindCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/BindCodeGenerator.java index 3d4dcf8cab7d5..e2415652af45b 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/BindCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/BindCodeGenerator.java @@ -14,7 +14,6 @@ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.LambdaBytecodeGenerator.CompiledLambda; import com.facebook.presto.sql.relational.LambdaDefinitionExpression; @@ -30,7 +29,7 @@ import static com.google.common.base.Preconditions.checkState; public class BindCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { private final Map compiledLambdaMap; private final Class lambdaInterface; @@ -42,7 +41,7 @@ public BindCodeGenerator(Map compile } @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable) { // Bind expression is used to generate captured lambda. // It takes the captured values and the uncaptured lambda, and produces captured lambda as the output. diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/CastCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/CastCodeGenerator.java deleted file mode 100644 index d9cca8788c753..0000000000000 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/CastCodeGenerator.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.facebook.presto.sql.gen; - -import com.facebook.presto.spi.function.FunctionHandle; -import com.facebook.presto.spi.function.Signature; -import com.facebook.presto.spi.type.Type; -import com.facebook.presto.sql.relational.RowExpression; -import com.google.common.collect.ImmutableList; -import io.airlift.bytecode.BytecodeBlock; -import io.airlift.bytecode.BytecodeNode; -import io.airlift.bytecode.Variable; - -import java.util.List; -import java.util.Optional; - -import static com.facebook.presto.spi.function.OperatorType.CAST; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; - -public class CastCodeGenerator - implements BytecodeGenerator -{ - @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) - { - RowExpression argument = arguments.get(0); - - FunctionHandle function = generatorContext - .getFunctionManager() - .lookupCast(CAST, argument.getType().getTypeSignature(), returnType.getTypeSignature()); - - BytecodeBlock block = new BytecodeBlock() - .append(generatorContext.generateCall( - CAST.name(), - generatorContext.getFunctionManager().getScalarFunctionImplementation(function), - ImmutableList.of(generatorContext.generate(argument, Optional.empty())))); - outputBlockVariable.ifPresent(output -> block.append(generateWrite(generatorContext, returnType, output))); - return block; - } -} diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/CoalesceCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/CoalesceCodeGenerator.java index fa4ec92d6f0f6..631d2d9ac55c1 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/CoalesceCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/CoalesceCodeGenerator.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import com.google.common.collect.Lists; @@ -26,15 +25,15 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; import static io.airlift.bytecode.expression.BytecodeExpressions.constantTrue; public class CoalesceCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) { List operands = new ArrayList<>(); for (RowExpression expression : arguments) { diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/CursorProcessorCompiler.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/CursorProcessorCompiler.java index 0602884e3ca72..5bf584a4081e5 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/CursorProcessorCompiler.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/CursorProcessorCompiler.java @@ -28,6 +28,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -348,6 +349,12 @@ public BytecodeNode visitVariableReference(VariableReferenceExpression reference { throw new UnsupportedOperationException(); } + + @Override + public BytecodeNode visitSpecialForm(SpecialFormExpression specialForm, Scope context) + { + throw new UnsupportedOperationException(); + } }; } } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/DereferenceCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/DereferenceCodeGenerator.java index 49ee1f1587d96..799af84790cbb 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/DereferenceCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/DereferenceCodeGenerator.java @@ -14,7 +14,6 @@ package com.facebook.presto.sql.gen; import com.facebook.presto.spi.block.Block; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.ConstantExpression; import com.facebook.presto.sql.relational.RowExpression; @@ -28,16 +27,16 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static com.facebook.presto.sql.gen.SqlTypeBytecodeExpression.constantType; import static com.google.common.base.Preconditions.checkArgument; import static io.airlift.bytecode.expression.BytecodeExpressions.constantInt; public class DereferenceCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generator, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generator, Type returnType, List arguments, Optional outputBlockVariable) { checkArgument(arguments.size() == 2); CallSiteBinder callSiteBinder = generator.getCallSiteBinder(); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/FunctionCallCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/FunctionCallCodeGenerator.java index d50dac1f19f98..39a40dc88a2da 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/FunctionCallCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/FunctionCallCodeGenerator.java @@ -29,10 +29,8 @@ import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentType.VALUE_TYPE; public class FunctionCallCodeGenerator - implements BytecodeGenerator { - @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateCall(Signature signature, BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable) { FunctionManager functionManager = context.getFunctionManager(); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/IfCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/IfCodeGenerator.java index 4eb47f440abb1..74e1b58cdec9a 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/IfCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/IfCodeGenerator.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import com.google.common.base.Preconditions; @@ -25,13 +24,13 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; public class IfCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable) { Preconditions.checkArgument(arguments.size() == 3); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/InCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/InCodeGenerator.java index c5dd2f3566e02..b027eacb23a61 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/InCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/InCodeGenerator.java @@ -16,7 +16,6 @@ import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.operator.scalar.ScalarFunctionImplementation; import com.facebook.presto.spi.function.FunctionHandle; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.BigintType; import com.facebook.presto.spi.type.DateType; import com.facebook.presto.spi.type.IntegerType; @@ -46,10 +45,11 @@ import static com.facebook.presto.spi.function.OperatorType.EQUAL; import static com.facebook.presto.spi.function.OperatorType.HASH_CODE; import static com.facebook.presto.spi.function.OperatorType.INDETERMINATE; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.gen.BytecodeUtils.ifWasNullPopAndGoto; import static com.facebook.presto.sql.gen.BytecodeUtils.invoke; import static com.facebook.presto.sql.gen.BytecodeUtils.loadConstant; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static com.facebook.presto.util.FastutilSetHelper.toFastutilHashSet; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Throwables.throwIfUnchecked; @@ -61,7 +61,7 @@ import static java.util.Objects.requireNonNull; public class InCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { private final FunctionManager functionManager; @@ -110,7 +110,7 @@ static SwitchGenerationCase checkSwitchGenerationCase(Type type, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) { List values = arguments.subList(1, arguments.size()); // empty IN statements are not allowed by the standard, and not possible here @@ -122,9 +122,9 @@ public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorCon SwitchGenerationCase switchGenerationCase = checkSwitchGenerationCase(type, values); - FunctionHandle hashCodeHandle = generatorContext.getFunctionManager().resolveOperator(HASH_CODE, ImmutableList.of(type)); + FunctionHandle hashCodeHandle = generatorContext.getFunctionManager().resolveOperator(HASH_CODE, fromTypes(type)); MethodHandle hashCodeFunction = generatorContext.getFunctionManager().getScalarFunctionImplementation(hashCodeHandle).getMethodHandle(); - FunctionHandle isIndeterminateHandle = generatorContext.getFunctionManager().resolveOperator(INDETERMINATE, ImmutableList.of(type)); + FunctionHandle isIndeterminateHandle = generatorContext.getFunctionManager().resolveOperator(INDETERMINATE, fromTypes(type)); ScalarFunctionImplementation isIndeterminateFunction = generatorContext.getFunctionManager().getScalarFunctionImplementation(isIndeterminateHandle); ImmutableListMultimap.Builder hashBucketsBuilder = ImmutableListMultimap.builder(); @@ -331,7 +331,7 @@ private static BytecodeBlock buildInCase( elseBlock.gotoLabel(noMatchLabel); - FunctionHandle equalsHandle = generatorContext.getFunctionManager().resolveOperator(EQUAL, ImmutableList.of(type, type)); + FunctionHandle equalsHandle = generatorContext.getFunctionManager().resolveOperator(EQUAL, fromTypes(type, type)); ScalarFunctionImplementation equalsFunction = generatorContext.getFunctionManager().getScalarFunctionImplementation(equalsHandle); BytecodeNode elseNode = elseBlock; diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/InputReferenceCompiler.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/InputReferenceCompiler.java index 358b611ae4701..367e04951f807 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/InputReferenceCompiler.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/InputReferenceCompiler.java @@ -19,6 +19,7 @@ import com.facebook.presto.sql.relational.InputReferenceExpression; import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.collect.ImmutableList; import com.google.common.primitives.Primitives; @@ -97,6 +98,12 @@ public BytecodeNode visitVariableReference(VariableReferenceExpression reference throw new UnsupportedOperationException(); } + @Override + public BytecodeNode visitSpecialForm(SpecialFormExpression specialForm, Scope context) + { + throw new UnsupportedOperationException(); + } + static class InputReferenceNode implements BytecodeNode { diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/IsNullCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/IsNullCodeGenerator.java index 2b8e42883e417..beba56a0ddf8b 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/IsNullCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/IsNullCodeGenerator.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import com.google.common.base.Preconditions; @@ -24,16 +23,16 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static com.facebook.presto.type.UnknownType.UNKNOWN; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; import static io.airlift.bytecode.instruction.Constant.loadBoolean; public class IsNullCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) { Preconditions.checkArgument(arguments.size() == 1); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/JoinCompiler.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/JoinCompiler.java index f27a76e84124d..ff45d0822741e 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/JoinCompiler.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/JoinCompiler.java @@ -66,6 +66,7 @@ import java.util.OptionalInt; import java.util.stream.IntStream; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.gen.InputReferenceCompiler.generateInputReference; import static com.facebook.presto.sql.gen.SqlTypeBytecodeExpression.constantType; import static com.facebook.presto.util.CompilerUtils.defineClass; @@ -706,8 +707,8 @@ private void generatePositionNotDistinctFromRowWithPageMethod( continue; } } - ScalarFunctionImplementation operator = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(OperatorType.IS_DISTINCT_FROM, ImmutableList.of(type, type))); - Binding binding = callSiteBinder.bind(operator.getMethodHandle()); + ScalarFunctionImplementation operator = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(OperatorType.IS_DISTINCT_FROM, fromTypes(type, type))); + callSiteBinder.bind(operator.getMethodHandle()); List argumentsBytecode = new ArrayList<>(); argumentsBytecode.add(generateInputReference(callSiteBinder, scope, type, leftBlock, leftBlockPosition)); argumentsBytecode.add(generateInputReference(callSiteBinder, scope, type, rightBlock, rightPosition)); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaBytecodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaBytecodeGenerator.java index 6aa04d8f0254e..dda2347232daa 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaBytecodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaBytecodeGenerator.java @@ -23,6 +23,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.base.VerifyException; import com.google.common.collect.ImmutableList; @@ -351,6 +352,12 @@ public BytecodeNode visitVariableReference(VariableReferenceExpression reference .append(parameter) .append(unboxPrimitiveIfNecessary(context, type)); } + + @Override + public BytecodeNode visitSpecialForm(SpecialFormExpression specialForm, Scope context) + { + throw new UnsupportedOperationException(); + } }; } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaExpressionExtractor.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaExpressionExtractor.java index 5a78f8d870691..faf81e17dbaf9 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaExpressionExtractor.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/LambdaExpressionExtractor.java @@ -19,6 +19,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.collect.ImmutableList; @@ -79,6 +80,15 @@ public Void visitVariableReference(VariableReferenceExpression reference, Contex return null; } + @Override + public Void visitSpecialForm(SpecialFormExpression specialForm, Context context) + { + for (RowExpression rowExpression : specialForm.getArguments()) { + rowExpression.accept(this, context); + } + return null; + } + private List getLambdaExpressionsPostOrder() { return lambdaExpressions.build(); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/NullIfCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/NullIfCodeGenerator.java index c01a7ff0142e6..d487bdb14dfed 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/NullIfCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/NullIfCodeGenerator.java @@ -15,7 +15,6 @@ import com.facebook.presto.operator.scalar.ScalarFunctionImplementation; import com.facebook.presto.spi.function.FunctionHandle; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.sql.relational.RowExpression; @@ -30,17 +29,19 @@ import java.util.List; import java.util.Optional; +import static com.facebook.presto.metadata.CastType.fromOperatorType; import static com.facebook.presto.spi.function.OperatorType.CAST; import static com.facebook.presto.spi.function.OperatorType.EQUAL; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.gen.BytecodeUtils.ifWasNullPopAndGoto; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static io.airlift.bytecode.expression.BytecodeExpressions.constantTrue; public class NullIfCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) { Scope scope = generatorContext.getScope(); @@ -62,7 +63,7 @@ public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorCon Type secondType = second.getType(); // if (equal(cast(first as ), cast(second as )) - FunctionHandle equalFunction = generatorContext.getFunctionManager().resolveOperator(EQUAL, ImmutableList.of(firstType, secondType)); + FunctionHandle equalFunction = generatorContext.getFunctionManager().resolveOperator(EQUAL, fromTypes(firstType, secondType)); ScalarFunctionImplementation equalsFunction = generatorContext.getFunctionManager().getScalarFunctionImplementation(equalFunction); BytecodeNode equalsCall = generatorContext.generateCall( EQUAL.name(), @@ -103,7 +104,7 @@ private static BytecodeNode cast( FunctionHandle functionHandle = generatorContext .getFunctionManager() - .lookupCast(CAST, actualType.getTypeSignature(), requiredType); + .lookupCast(fromOperatorType(CAST), actualType.getTypeSignature(), requiredType); // TODO: do we need a full function call? (nullability checks, etc) return generatorContext.generateCall(CAST.name(), generatorContext.getFunctionManager().getScalarFunctionImplementation(functionHandle), ImmutableList.of(argument)); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/OrCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/OrCodeGenerator.java index 409ef4e8123d9..99c0cfb38923e 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/OrCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/OrCodeGenerator.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import com.google.common.base.Preconditions; @@ -26,14 +25,14 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; public class OrCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generator, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generator, Type returnType, List arguments, Optional outputBlockVariable) { Preconditions.checkArgument(arguments.size() == 2); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/RowConstructorCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/RowConstructorCodeGenerator.java index daac8952de45f..8ace86e45e9e3 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/RowConstructorCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/RowConstructorCodeGenerator.java @@ -16,7 +16,6 @@ import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; import com.facebook.presto.spi.block.BlockBuilderStatus; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import io.airlift.bytecode.BytecodeBlock; @@ -28,17 +27,17 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; import static com.facebook.presto.sql.gen.SqlTypeBytecodeExpression.constantType; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; import static io.airlift.bytecode.expression.BytecodeExpressions.constantInt; import static io.airlift.bytecode.expression.BytecodeExpressions.constantNull; public class RowConstructorCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext context, Type rowType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext context, Type rowType, List arguments, Optional outputBlockVariable) { BytecodeBlock block = new BytecodeBlock().setDescription("Constructor for " + rowType.toString()); CallSiteBinder binder = context.getCallSiteBinder(); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/RowExpressionCompiler.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/RowExpressionCompiler.java index 93893e5d409a7..63b61d7514047 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/RowExpressionCompiler.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/RowExpressionCompiler.java @@ -21,6 +21,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.base.VerifyException; import com.google.common.collect.ImmutableList; @@ -35,16 +36,6 @@ import static com.facebook.presto.sql.gen.BytecodeUtils.generateWrite; import static com.facebook.presto.sql.gen.BytecodeUtils.loadConstant; import static com.facebook.presto.sql.gen.LambdaBytecodeGenerator.generateLambda; -import static com.facebook.presto.sql.relational.Signatures.BIND; -import static com.facebook.presto.sql.relational.Signatures.CAST; -import static com.facebook.presto.sql.relational.Signatures.COALESCE; -import static com.facebook.presto.sql.relational.Signatures.DEREFERENCE; -import static com.facebook.presto.sql.relational.Signatures.IF; -import static com.facebook.presto.sql.relational.Signatures.IN; -import static com.facebook.presto.sql.relational.Signatures.IS_NULL; -import static com.facebook.presto.sql.relational.Signatures.NULL_IF; -import static com.facebook.presto.sql.relational.Signatures.ROW_CONSTRUCTOR; -import static com.facebook.presto.sql.relational.Signatures.SWITCH; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; import static io.airlift.bytecode.expression.BytecodeExpressions.constantTrue; @@ -95,56 +86,6 @@ private class Visitor @Override public BytecodeNode visitCall(CallExpression call, Context context) { - BytecodeGenerator generator; - // special-cased in function manager - if (call.getSignature().getName().equals(CAST)) { - generator = new CastCodeGenerator(); - } - else { - switch (call.getSignature().getName()) { - // lazy evaluation - case IF: - generator = new IfCodeGenerator(); - break; - case NULL_IF: - generator = new NullIfCodeGenerator(); - break; - case SWITCH: - // (SWITCH (WHEN ) (WHEN ) ) - generator = new SwitchCodeGenerator(); - break; - // functions that take null as input - case IS_NULL: - generator = new IsNullCodeGenerator(); - break; - case COALESCE: - generator = new CoalesceCodeGenerator(); - break; - // functions that require varargs and/or complex types (e.g., lists) - case IN: - generator = new InCodeGenerator(functionManager); - break; - // optimized implementations (shortcircuiting behavior) - case "AND": - generator = new AndCodeGenerator(); - break; - case "OR": - generator = new OrCodeGenerator(); - break; - case DEREFERENCE: - generator = new DereferenceCodeGenerator(); - break; - case ROW_CONSTRUCTOR: - generator = new RowConstructorCodeGenerator(); - break; - case BIND: - generator = new BindCodeGenerator(compiledLambdaMap, context.getLambdaInterface().get()); - break; - default: - generator = new FunctionCallCodeGenerator(); - } - } - BytecodeGeneratorContext generatorContext = new BytecodeGeneratorContext( RowExpressionCompiler.this, context.getScope(), @@ -152,7 +93,7 @@ public BytecodeNode visitCall(CallExpression call, Context context) cachedInstanceBinder, functionManager); - return generator.generateExpression(call.getSignature(), generatorContext, call.getType(), call.getArguments(), context.getOutputBlockVariable()); + return (new FunctionCallCodeGenerator()).generateCall(call.getFunctionHandle().getSignature(), generatorContext, call.getType(), call.getArguments(), context.getOutputBlockVariable()); } @Override @@ -270,6 +211,62 @@ public BytecodeNode visitVariableReference(VariableReferenceExpression reference reference.getType(), context.getOutputBlockVariable().get())); } + + @Override + public BytecodeNode visitSpecialForm(SpecialFormExpression specialForm, Context context) + { + SpecialFormBytecodeGenerator generator; + switch (specialForm.getForm()) { + // lazy evaluation + case IF: + generator = new IfCodeGenerator(); + break; + case NULL_IF: + generator = new NullIfCodeGenerator(); + break; + case SWITCH: + // (SWITCH (WHEN ) (WHEN ) ) + generator = new SwitchCodeGenerator(); + break; + // functions that take null as input + case IS_NULL: + generator = new IsNullCodeGenerator(); + break; + case COALESCE: + generator = new CoalesceCodeGenerator(); + break; + // functions that require varargs and/or complex types (e.g., lists) + case IN: + generator = new InCodeGenerator(functionManager); + break; + // optimized implementations (shortcircuiting behavior) + case AND: + generator = new AndCodeGenerator(); + break; + case OR: + generator = new OrCodeGenerator(); + break; + case DEREFERENCE: + generator = new DereferenceCodeGenerator(); + break; + case ROW_CONSTRUCTOR: + generator = new RowConstructorCodeGenerator(); + break; + case BIND: + generator = new BindCodeGenerator(compiledLambdaMap, context.getLambdaInterface().get()); + break; + default: + throw new IllegalStateException("Can not compile special form: " + specialForm.getForm()); + } + BytecodeGeneratorContext generatorContext = new BytecodeGeneratorContext( + RowExpressionCompiler.this, + context.getScope(), + callSiteBinder, + cachedInstanceBinder, + functionManager); + + return generator.generateExpression(generatorContext, specialForm.getType(), specialForm.getArguments(), context.getOutputBlockVariable()); + } } private static class Context diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/BytecodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/SpecialFormBytecodeGenerator.java similarity index 81% rename from presto-main/src/main/java/com/facebook/presto/sql/gen/BytecodeGenerator.java rename to presto-main/src/main/java/com/facebook/presto/sql/gen/SpecialFormBytecodeGenerator.java index 0e0a5fbde4615..3ed82b664fb40 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/BytecodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/SpecialFormBytecodeGenerator.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; import io.airlift.bytecode.BytecodeNode; @@ -22,9 +21,9 @@ import java.util.List; import java.util.Optional; -public interface BytecodeGenerator +public interface SpecialFormBytecodeGenerator { - BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable); + BytecodeNode generateExpression(BytecodeGeneratorContext context, Type returnType, List arguments, Optional outputBlockVariable); static BytecodeNode generateWrite(BytecodeGeneratorContext context, Type returnType, Variable outputBlock) { diff --git a/presto-main/src/main/java/com/facebook/presto/sql/gen/SwitchCodeGenerator.java b/presto-main/src/main/java/com/facebook/presto/sql/gen/SwitchCodeGenerator.java index 63547bf10fd61..5a894afe4cd7a 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/gen/SwitchCodeGenerator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/gen/SwitchCodeGenerator.java @@ -14,10 +14,9 @@ package com.facebook.presto.sql.gen; import com.facebook.presto.spi.function.FunctionHandle; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Type; -import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; @@ -33,15 +32,17 @@ import java.util.Optional; import static com.facebook.presto.spi.function.OperatorType.EQUAL; -import static com.facebook.presto.sql.gen.BytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; +import static com.facebook.presto.sql.gen.SpecialFormBytecodeGenerator.generateWrite; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.WHEN; import static io.airlift.bytecode.expression.BytecodeExpressions.constantFalse; import static io.airlift.bytecode.expression.BytecodeExpressions.constantTrue; public class SwitchCodeGenerator - implements BytecodeGenerator + implements SpecialFormBytecodeGenerator { @Override - public BytecodeNode generateExpression(Signature signature, BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) + public BytecodeNode generateExpression(BytecodeGeneratorContext generatorContext, Type returnType, List arguments, Optional outputBlockVariable) { // TODO: compile as /* @@ -82,7 +83,7 @@ else if ( == ) { List whenClauses; RowExpression last = arguments.get(arguments.size() - 1); - if (last instanceof CallExpression && ((CallExpression) last).getSignature().getName().equals("WHEN")) { + if (last instanceof SpecialFormExpression && ((SpecialFormExpression) last).getForm().equals(WHEN)) { whenClauses = arguments.subList(1, arguments.size()); elseValue = new BytecodeBlock() .append(generatorContext.wasNull().set(constantTrue())) @@ -110,13 +111,13 @@ else if ( == ) { elseValue = new BytecodeBlock().visitLabel(nullValue).append(elseValue); // reverse list because current if statement builder doesn't support if/else so we need to build the if statements bottom up for (RowExpression clause : Lists.reverse(whenClauses)) { - Preconditions.checkArgument(clause instanceof CallExpression && ((CallExpression) clause).getSignature().getName().equals("WHEN")); + Preconditions.checkArgument(clause instanceof SpecialFormExpression && ((SpecialFormExpression) clause).getForm().equals(WHEN)); - RowExpression operand = ((CallExpression) clause).getArguments().get(0); - RowExpression result = ((CallExpression) clause).getArguments().get(1); + RowExpression operand = ((SpecialFormExpression) clause).getArguments().get(0); + RowExpression result = ((SpecialFormExpression) clause).getArguments().get(1); // call equals(value, operand) - FunctionHandle equalsFunction = generatorContext.getFunctionManager().resolveOperator(EQUAL, ImmutableList.of(value.getType(), operand.getType())); + FunctionHandle equalsFunction = generatorContext.getFunctionManager().resolveOperator(EQUAL, fromTypes(value.getType(), operand.getType())); // TODO: what if operand is null? It seems that the call will return "null" (which is cleared below) // and the code only does the right thing because the value in the stack for that scenario is diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/DomainTranslator.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/DomainTranslator.java index 937b311164a4e..67c27530a7511 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/DomainTranslator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/DomainTranslator.java @@ -60,8 +60,8 @@ import java.util.Map; import java.util.Optional; -import static com.facebook.presto.spi.function.OperatorType.CAST; -import static com.facebook.presto.spi.function.OperatorType.SATURATED_FLOOR_CAST; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.CastType.SATURATED_FLOOR_CAST; import static com.facebook.presto.sql.ExpressionUtils.and; import static com.facebook.presto.sql.ExpressionUtils.combineConjuncts; import static com.facebook.presto.sql.ExpressionUtils.combineDisjunctsWithDefault; diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/ExpressionInterpreter.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/ExpressionInterpreter.java index 544f0fd0bd391..d99c7d0456559 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/ExpressionInterpreter.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/ExpressionInterpreter.java @@ -27,7 +27,6 @@ import com.facebook.presto.spi.block.RowBlockBuilder; import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.OperatorType; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.CharType; import com.facebook.presto.spi.type.RowType; @@ -114,9 +113,9 @@ import java.util.stream.Stream; import static com.facebook.presto.SystemSessionProperties.isLegacyRowFieldOrdinalAccessEnabled; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; import static com.facebook.presto.spi.StandardErrorCode.NOT_SUPPORTED; -import static com.facebook.presto.spi.function.OperatorType.CAST; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.writeNativeValue; import static com.facebook.presto.spi.type.VarcharType.createVarcharType; @@ -145,7 +144,8 @@ public class ExpressionInterpreter private final Expression expression; private final Metadata metadata; private final LiteralEncoder literalEncoder; - private final ConnectorSession session; + private final Session session; + private final ConnectorSession connectorSession; private final boolean optimize; private final Map, Type> expressionTypes; private final InterpretedFunctionInvoker functionInvoker; @@ -233,7 +233,8 @@ private ExpressionInterpreter(Expression expression, Metadata metadata, Session this.expression = requireNonNull(expression, "expression is null"); this.metadata = requireNonNull(metadata, "metadata is null"); this.literalEncoder = new LiteralEncoder(metadata.getBlockEncodingSerde()); - this.session = requireNonNull(session, "session is null").toConnectorSession(); + this.session = requireNonNull(session, "session is null"); + this.connectorSession = session.toConnectorSession(); this.expressionTypes = ImmutableMap.copyOf(requireNonNull(expressionTypes, "expressionTypes is null")); verify((expressionTypes.containsKey(NodeRef.of(expression)))); this.optimize = optimize; @@ -396,7 +397,7 @@ protected Object visitSymbolReference(SymbolReference node, Object context) @Override protected Object visitLiteral(Literal node, Object context) { - return LiteralInterpreter.evaluate(metadata, session, node); + return LiteralInterpreter.evaluate(metadata, connectorSession, node); } @Override @@ -709,7 +710,7 @@ protected Object visitArithmeticUnary(ArithmeticUnaryExpression node, Object con case PLUS: return value; case MINUS: - FunctionHandle operatorHandle = metadata.getFunctionManager().resolveOperator(OperatorType.NEGATION, types(node.getValue())); + FunctionHandle operatorHandle = metadata.getFunctionManager().resolveOperator(OperatorType.NEGATION, fromTypes(types(node.getValue()))); MethodHandle handle = metadata.getFunctionManager().getScalarFunctionImplementation(operatorHandle).getMethodHandle(); if (handle.type().parameterCount() > 0 && handle.type().parameterType(0) == ConnectorSession.class) { @@ -832,8 +833,8 @@ protected Object visitNullIfExpression(NullIfExpression node, Object context) OperatorType.EQUAL, ImmutableList.of(commonType, commonType), ImmutableList.of( - functionInvoker.invoke(firstCast, session, ImmutableList.of(first)), - functionInvoker.invoke(secondCast, session, ImmutableList.of(second))))); + functionInvoker.invoke(firstCast, connectorSession, ImmutableList.of(first)), + functionInvoker.invoke(secondCast, connectorSession, ImmutableList.of(second))))); if (equal) { return null; @@ -927,8 +928,8 @@ protected Object visitFunctionCall(FunctionCall node, Object context) argumentValues.add(value); argumentTypes.add(type); } - Signature functionSignature = metadata.getFunctionManager().resolveFunction(node.getName(), fromTypes(argumentTypes)); - ScalarFunctionImplementation function = metadata.getFunctionManager().getScalarFunctionImplementation(functionSignature); + FunctionHandle functionHandle = metadata.getFunctionManager().resolveFunction(session, node.getName(), fromTypes(argumentTypes)); + ScalarFunctionImplementation function = metadata.getFunctionManager().getScalarFunctionImplementation(functionHandle); for (int i = 0; i < argumentValues.size(); i++) { Object value = argumentValues.get(i); if (value == null && function.getArgumentProperty(i).getNullConvention() == RETURN_NULL_ON_NULL) { @@ -940,7 +941,7 @@ protected Object visitFunctionCall(FunctionCall node, Object context) if (optimize && (!function.isDeterministic() || hasUnresolvedValue(argumentValues) || node.getName().equals(QualifiedName.of("fail")))) { return new FunctionCall(node.getName(), node.getWindow(), node.isDistinct(), toExpressions(argumentValues, argumentTypes)); } - return functionInvoker.invoke(functionSignature, session, argumentValues); + return functionInvoker.invoke(functionHandle, connectorSession, argumentValues); } @Override @@ -1135,7 +1136,7 @@ public Object visitCast(Cast node, Object context) FunctionHandle operator = metadata.getFunctionManager().lookupCast(CAST, sourceType.getTypeSignature(), targetType.getTypeSignature()); try { - return functionInvoker.invoke(operator, session, ImmutableList.of(value)); + return functionInvoker.invoke(operator, connectorSession, ImmutableList.of(value)); } catch (RuntimeException e) { if (node.isSafe()) { @@ -1263,8 +1264,8 @@ private boolean hasUnresolvedValue(List values) private Object invokeOperator(OperatorType operatorType, List argumentTypes, List argumentValues) { - FunctionHandle operatorHandle = metadata.getFunctionManager().resolveOperator(operatorType, argumentTypes); - return functionInvoker.invoke(operatorHandle, session, argumentValues); + FunctionHandle operatorHandle = metadata.getFunctionManager().resolveOperator(operatorType, fromTypes(argumentTypes)); + return functionInvoker.invoke(operatorHandle, connectorSession, argumentValues); } private Expression toExpression(Object base, Type type) diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/LiteralInterpreter.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/LiteralInterpreter.java index 1d3ff8a31e0cf..a853f3c4cccb0 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/LiteralInterpreter.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/LiteralInterpreter.java @@ -16,7 +16,6 @@ import com.facebook.presto.metadata.Metadata; import com.facebook.presto.spi.ConnectorSession; import com.facebook.presto.spi.function.FunctionHandle; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.Decimals; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.InterpretedFunctionInvoker; @@ -33,18 +32,19 @@ import com.facebook.presto.sql.tree.Literal; import com.facebook.presto.sql.tree.LongLiteral; import com.facebook.presto.sql.tree.NullLiteral; +import com.facebook.presto.sql.tree.QualifiedName; import com.facebook.presto.sql.tree.StringLiteral; import com.facebook.presto.sql.tree.TimeLiteral; import com.facebook.presto.sql.tree.TimestampLiteral; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slice; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; -import static com.facebook.presto.spi.function.OperatorType.CAST; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.sql.analyzer.SemanticErrorCode.INVALID_LITERAL; import static com.facebook.presto.sql.analyzer.SemanticErrorCode.TYPE_MISMATCH; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.type.JsonType.JSON; import static com.facebook.presto.util.DateTimeUtils.parseDayTimeInterval; import static com.facebook.presto.util.DateTimeUtils.parseTimeLiteral; @@ -133,8 +133,8 @@ protected Object visitGenericLiteral(GenericLiteral node, ConnectorSession sessi } if (JSON.equals(type)) { - Signature operatorSignature = new Signature("json_parse", SCALAR, JSON.getTypeSignature(), VARCHAR.getTypeSignature()); - return functionInvoker.invoke(operatorSignature, session, ImmutableList.of(utf8Slice(node.getValue()))); + FunctionHandle functionHandle = metadata.getFunctionManager().lookupFunction(QualifiedName.of("json_parse"), fromTypes(VARCHAR)); + return functionInvoker.invoke(functionHandle, session, ImmutableList.of(utf8Slice(node.getValue()))); } try { diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/LocalExecutionPlanner.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/LocalExecutionPlanner.java index 85dfdfe431439..579e234e8f7ec 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/LocalExecutionPlanner.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/LocalExecutionPlanner.java @@ -234,7 +234,6 @@ import static com.facebook.presto.operator.UnnestOperator.UnnestOperatorFactory; import static com.facebook.presto.operator.WindowFunctionDefinition.window; import static com.facebook.presto.spi.StandardErrorCode.COMPILER_ERROR; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.TypeUtils.writeNativeValue; import static com.facebook.presto.sql.analyzer.ExpressionAnalyzer.getExpressionTypes; @@ -1261,7 +1260,7 @@ private PhysicalOperation visitScanFilterAndProject( private RowExpression toRowExpression(Expression expression, Map, Type> types) { - return SqlToRowExpressionTranslator.translate(expression, SCALAR, types, metadata.getFunctionManager(), metadata.getTypeManager(), session, true); + return SqlToRowExpressionTranslator.translate(expression, types, metadata.getFunctionManager(), metadata.getTypeManager(), session, true); } private Map getInputTypes(Map layout, List types) diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/StatisticsAggregationPlanner.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/StatisticsAggregationPlanner.java index f43132970d825..77ed3b65a4f49 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/StatisticsAggregationPlanner.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/StatisticsAggregationPlanner.java @@ -83,7 +83,7 @@ public TableStatisticAggregation createStatisticsAggregation(TableStatisticsMeta QualifiedName count = QualifiedName.of("count"); AggregationNode.Aggregation aggregation = new AggregationNode.Aggregation( new FunctionCall(count, ImmutableList.of()), - functionManager.resolveFunction(session, count, ImmutableList.of()), + functionManager.lookupFunction(count, ImmutableList.of()), Optional.empty()); Symbol symbol = symbolAllocator.newSymbol("rowCount", BIGINT); aggregations.put(symbol, aggregation); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/RewriteSpatialPartitioningAggregation.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/RewriteSpatialPartitioningAggregation.java index 7e630ec4f2307..10e49c3d478c6 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/RewriteSpatialPartitioningAggregation.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/RewriteSpatialPartitioningAggregation.java @@ -107,7 +107,7 @@ public Result apply(AggregationNode node, Captures captures, Context context) aggregations.put(entry.getKey(), new Aggregation( new FunctionCall(name, ImmutableList.of(envelopeSymbol.toSymbolReference(), partitionCountSymbol.toSymbolReference())), - metadata.getFunctionManager().resolveFunction(context.getSession(), QualifiedName.of(NAME), fromTypes(geometryType, INTEGER)), + metadata.getFunctionManager().lookupFunction(QualifiedName.of(NAME), fromTypes(geometryType, INTEGER)), aggregation.getMask())); } else { diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/SimplifyCountOverConstant.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/SimplifyCountOverConstant.java index e160e7052f5eb..a83f3cb23b674 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/SimplifyCountOverConstant.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/SimplifyCountOverConstant.java @@ -35,8 +35,6 @@ import java.util.Map.Entry; import static com.facebook.presto.matching.Capture.newCapture; -import static com.facebook.presto.spi.type.BigintType.BIGINT; -import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.planner.plan.Patterns.aggregation; import static com.facebook.presto.sql.planner.plan.Patterns.project; import static com.facebook.presto.sql.planner.plan.Patterns.source; @@ -79,7 +77,7 @@ public Result apply(AggregationNode parent, Captures captures, Context context) changed = true; aggregations.put(symbol, new AggregationNode.Aggregation( new FunctionCall(QualifiedName.of("count"), ImmutableList.of()), - functionManager.resolveFunction(context.getSession(), QualifiedName.of("count"), fromTypes(BIGINT)), + functionManager.lookupFunction(QualifiedName.of("count"), ImmutableList.of()), aggregation.getMask())); } } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedInPredicateToJoin.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedInPredicateToJoin.java index 67da6f9278ffe..bac6d1dd34f47 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedInPredicateToJoin.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedInPredicateToJoin.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.planner.iterative.rule; -import com.facebook.presto.Session; import com.facebook.presto.matching.Captures; import com.facebook.presto.matching.Pattern; import com.facebook.presto.metadata.FunctionManager; @@ -125,11 +124,10 @@ public Result apply(ApplyNode apply, Captures captures, Context context) InPredicate inPredicate = (InPredicate) assignmentExpression; Symbol inPredicateOutputSymbol = getOnlyElement(subqueryAssignments.getSymbols()); - return apply(context.getSession(), apply, inPredicate, inPredicateOutputSymbol, context.getLookup(), context.getIdAllocator(), context.getSymbolAllocator()); + return apply(apply, inPredicate, inPredicateOutputSymbol, context.getLookup(), context.getIdAllocator(), context.getSymbolAllocator()); } private Result apply( - Session session, ApplyNode apply, InPredicate inPredicate, Symbol inPredicateOutputSymbol, @@ -145,7 +143,6 @@ private Result apply( } PlanNode projection = buildInPredicateEquivalent( - session, apply, inPredicate, inPredicateOutputSymbol, @@ -157,7 +154,6 @@ private Result apply( } private PlanNode buildInPredicateEquivalent( - Session session, ApplyNode apply, InPredicate inPredicate, Symbol inPredicateOutputSymbol, @@ -209,8 +205,8 @@ private PlanNode buildInPredicateEquivalent( idAllocator.getNextId(), leftOuterJoin, ImmutableMap.builder() - .put(countMatchesSymbol, countWithFilter(session, matchCondition)) - .put(countNullMatchesSymbol, countWithFilter(session, nullMatchCondition)) + .put(countMatchesSymbol, countWithFilter(matchCondition)) + .put(countNullMatchesSymbol, countWithFilter(nullMatchCondition)) .build(), singleGroupingSet(probeSide.getOutputSymbols()), ImmutableList.of(), @@ -251,7 +247,7 @@ private static JoinNode leftOuterJoin(PlanNodeIdAllocator idAllocator, AssignUni Optional.empty()); } - private AggregationNode.Aggregation countWithFilter(Session session, Expression condition) + private AggregationNode.Aggregation countWithFilter(Expression condition) { FunctionCall countCall = new FunctionCall( QualifiedName.of("count"), @@ -263,7 +259,7 @@ private AggregationNode.Aggregation countWithFilter(Session session, Expression return new AggregationNode.Aggregation( countCall, - functionManager.resolveFunction(session, QualifiedName.of("count"), ImmutableList.of()), + functionManager.lookupFunction(QualifiedName.of("count"), ImmutableList.of()), Optional.empty()); /* mask */ } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedScalarAggregationToJoin.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedScalarAggregationToJoin.java index c7c545c353052..2919d22916332 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedScalarAggregationToJoin.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformCorrelatedScalarAggregationToJoin.java @@ -96,7 +96,7 @@ public Result apply(LateralJoinNode lateralJoinNode, Captures captures, Context return Result.empty(); } - ScalarAggregationToJoinRewriter rewriter = new ScalarAggregationToJoinRewriter(functionManager, context.getSession(), context.getSymbolAllocator(), context.getIdAllocator(), context.getLookup()); + ScalarAggregationToJoinRewriter rewriter = new ScalarAggregationToJoinRewriter(functionManager, context.getSymbolAllocator(), context.getIdAllocator(), context.getLookup()); PlanNode rewrittenNode = rewriter.rewriteScalarAggregation(lateralJoinNode, aggregation.get()); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformExistsApplyToLateralNode.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformExistsApplyToLateralNode.java index 22da0c631605f..3257b2c2f807c 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformExistsApplyToLateralNode.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/TransformExistsApplyToLateralNode.java @@ -163,7 +163,7 @@ private PlanNode rewriteToDefaultAggregation(ApplyNode parent, Context context) parent.getSubquery(), ImmutableMap.of(count, new Aggregation( COUNT_CALL, - functionManager.resolveFunction(context.getSession(), COUNT, ImmutableList.of()), + functionManager.lookupFunction(COUNT, ImmutableList.of()), Optional.empty())), globalAggregation(), ImmutableList.of(), diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ExpressionEquivalence.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ExpressionEquivalence.java index 948c516158b7d..f2b07d874992e 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ExpressionEquivalence.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ExpressionEquivalence.java @@ -15,8 +15,9 @@ import com.facebook.presto.Session; import com.facebook.presto.execution.warnings.WarningCollector; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.Metadata; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.parser.SqlParser; import com.facebook.presto.sql.planner.Symbol; @@ -28,6 +29,8 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; +import com.facebook.presto.sql.relational.SpecialFormExpression.Form; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.facebook.presto.sql.tree.Expression; import com.facebook.presto.sql.tree.NodeRef; @@ -45,9 +48,7 @@ import java.util.Map.Entry; import java.util.Set; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; import static com.facebook.presto.metadata.OperatorSignatureUtils.mangleOperatorName; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.function.OperatorType.EQUAL; import static com.facebook.presto.spi.function.OperatorType.GREATER_THAN; import static com.facebook.presto.spi.function.OperatorType.GREATER_THAN_OR_EQUAL; @@ -57,6 +58,9 @@ import static com.facebook.presto.spi.function.OperatorType.NOT_EQUAL; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.sql.analyzer.ExpressionAnalyzer.getExpressionTypesFromInput; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.AND; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.OR; import static com.facebook.presto.sql.relational.SqlToRowExpressionTranslator.translate; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.collect.ImmutableList.toImmutableList; @@ -67,14 +71,15 @@ public class ExpressionEquivalence { private static final Ordering ROW_EXPRESSION_ORDERING = Ordering.from(new RowExpressionComparator()); - private static final CanonicalizationVisitor CANONICALIZATION_VISITOR = new CanonicalizationVisitor(); private final Metadata metadata; private final SqlParser sqlParser; + private final CanonicalizationVisitor canonicalizationVisitor; public ExpressionEquivalence(Metadata metadata, SqlParser sqlParser) { this.metadata = requireNonNull(metadata, "metadata is null"); this.sqlParser = requireNonNull(sqlParser, "sqlParser is null"); + this.canonicalizationVisitor = new CanonicalizationVisitor(metadata.getFunctionManager()); } public boolean areExpressionsEquivalent(Session session, Expression leftExpression, Expression rightExpression, TypeProvider types) @@ -90,8 +95,8 @@ public boolean areExpressionsEquivalent(Session session, Expression leftExpressi RowExpression leftRowExpression = toRowExpression(session, leftExpression, symbolInput, inputTypes); RowExpression rightRowExpression = toRowExpression(session, rightExpression, symbolInput, inputTypes); - RowExpression canonicalizedLeft = leftRowExpression.accept(CANONICALIZATION_VISITOR, null); - RowExpression canonicalizedRight = rightRowExpression.accept(CANONICALIZATION_VISITOR, null); + RowExpression canonicalizedLeft = leftRowExpression.accept(canonicalizationVisitor, null); + RowExpression canonicalizedRight = rightRowExpression.accept(canonicalizationVisitor, null); return canonicalizedLeft.equals(canonicalizedRight); } @@ -112,68 +117,47 @@ private RowExpression toRowExpression(Session session, Expression expression, Ma WarningCollector.NOOP); // convert to row expression - return translate(expressionWithInputReferences, SCALAR, expressionTypes, metadata.getFunctionManager(), metadata.getTypeManager(), session, false); + return translate(expressionWithInputReferences, expressionTypes, metadata.getFunctionManager(), metadata.getTypeManager(), session, false); } private static class CanonicalizationVisitor implements RowExpressionVisitor { + private final FunctionManager functionManager; + + public CanonicalizationVisitor(FunctionManager functionManager) + { + this.functionManager = requireNonNull(functionManager, "functionManager is null"); + } + @Override public RowExpression visitCall(CallExpression call, Void context) { call = new CallExpression( - call.getSignature(), + call.getFunctionHandle(), call.getType(), call.getArguments().stream() .map(expression -> expression.accept(this, context)) .collect(toImmutableList())); - String callName = call.getSignature().getName(); - - if (callName.equals("AND") || callName.equals("OR")) { - // if we have nested calls (of the same type) flatten them - List flattenedArguments = flattenNestedCallArgs(call); - - // only consider distinct arguments - Set distinctArguments = ImmutableSet.copyOf(flattenedArguments); - if (distinctArguments.size() == 1) { - return Iterables.getOnlyElement(distinctArguments); - } - - // canonicalize the argument order (i.e., sort them) - List sortedArguments = ROW_EXPRESSION_ORDERING.sortedCopy(distinctArguments); - - return new CallExpression( - internalScalarFunction( - callName, - BOOLEAN.getTypeSignature(), - distinctArguments.stream() - .map(RowExpression::getType) - .map(Type::getTypeSignature) - .collect(toImmutableList())), - BOOLEAN, - sortedArguments); - } + String callName = call.getFunctionHandle().getSignature().getName(); if (callName.equals(mangleOperatorName(EQUAL)) || callName.equals(mangleOperatorName(NOT_EQUAL)) || callName.equals(mangleOperatorName(IS_DISTINCT_FROM))) { // sort arguments return new CallExpression( - call.getSignature(), + call.getFunctionHandle(), call.getType(), ROW_EXPRESSION_ORDERING.sortedCopy(call.getArguments())); } if (callName.equals(mangleOperatorName(GREATER_THAN)) || callName.equals(mangleOperatorName(GREATER_THAN_OR_EQUAL))) { // convert greater than to less than + + FunctionHandle functionHandle = functionManager.resolveOperator( + callName.equals(mangleOperatorName(GREATER_THAN)) ? LESS_THAN : LESS_THAN_OR_EQUAL, + swapPair(fromTypes(call.getArguments().stream().map(RowExpression::getType).collect(toImmutableList())))); return new CallExpression( - new Signature( - callName.equals(mangleOperatorName(GREATER_THAN)) ? mangleOperatorName(LESS_THAN) : mangleOperatorName(LESS_THAN_OR_EQUAL), - SCALAR, - call.getSignature().getTypeVariableConstraints(), - call.getSignature().getLongVariableConstraints(), - call.getSignature().getReturnType(), - swapPair(call.getSignature().getArgumentTypes()), - false), + functionHandle, call.getType(), swapPair(call.getArguments())); } @@ -181,14 +165,14 @@ public RowExpression visitCall(CallExpression call, Void context) return call; } - public static List flattenNestedCallArgs(CallExpression call) + public static List flattenNestedSpecialForms(SpecialFormExpression specialForm) { - String callName = call.getSignature().getName(); + Form form = specialForm.getForm(); ImmutableList.Builder newArguments = ImmutableList.builder(); - for (RowExpression argument : call.getArguments()) { - if (argument instanceof CallExpression && callName.equals(((CallExpression) argument).getSignature().getName())) { - // same call type, so flatten the args - newArguments.addAll(flattenNestedCallArgs((CallExpression) argument)); + for (RowExpression argument : specialForm.getArguments()) { + if (argument instanceof SpecialFormExpression && form.equals(((SpecialFormExpression) argument).getForm())) { + // same special form type, so flatten the args + newArguments.addAll(flattenNestedSpecialForms((SpecialFormExpression) argument)); } else { newArguments.add(argument); @@ -220,6 +204,35 @@ public RowExpression visitVariableReference(VariableReferenceExpression referenc { return reference; } + + @Override + public RowExpression visitSpecialForm(SpecialFormExpression specialForm, Void context) + { + specialForm = new SpecialFormExpression( + specialForm.getForm(), + specialForm.getType(), + specialForm.getArguments().stream() + .map(expression -> expression.accept(this, context)) + .collect(toImmutableList())); + + if (specialForm.getForm() == AND || specialForm.getForm() == OR) { + // if we have nested calls (of the same type) flatten them + List flattenedArguments = flattenNestedSpecialForms(specialForm); + + // only consider distinct arguments + Set distinctArguments = ImmutableSet.copyOf(flattenedArguments); + if (distinctArguments.size() == 1) { + return Iterables.getOnlyElement(distinctArguments); + } + + // canonicalize the argument order (i.e., sort them) + List sortedArguments = ROW_EXPRESSION_ORDERING.sortedCopy(distinctArguments); + + return new SpecialFormExpression(specialForm.getForm(), BOOLEAN, sortedArguments); + } + + return specialForm; + } } private static class RowExpressionComparator @@ -240,7 +253,7 @@ public int compare(RowExpression left, RowExpression right) CallExpression leftCall = (CallExpression) left; CallExpression rightCall = (CallExpression) right; return ComparisonChain.start() - .compare(leftCall.getSignature().toString(), rightCall.getSignature().toString()) + .compare(leftCall.getFunctionHandle().toString(), rightCall.getFunctionHandle().toString()) .compare(leftCall.getArguments(), rightCall.getArguments(), argumentComparator) .result(); } @@ -319,6 +332,17 @@ else if (rightValue == null) { .result(); } + if (left instanceof SpecialFormExpression) { + SpecialFormExpression leftSpecialForm = (SpecialFormExpression) left; + SpecialFormExpression rightSpecialForm = (SpecialFormExpression) right; + + return ComparisonChain.start() + .compare(leftSpecialForm.getForm(), rightSpecialForm.getForm()) + .compare(leftSpecialForm.getType(), rightSpecialForm.getType(), Comparator.comparing(Object::toString)) + .compare(leftSpecialForm.getArguments(), rightSpecialForm.getArguments(), argumentComparator) + .result(); + } + throw new IllegalArgumentException("Unsupported RowExpression type " + left.getClass().getSimpleName()); } } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ImplementIntersectAndExceptAsUnion.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ImplementIntersectAndExceptAsUnion.java index b1890ab7bcd3c..a6ec052f9aaff 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ImplementIntersectAndExceptAsUnion.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/ImplementIntersectAndExceptAsUnion.java @@ -248,7 +248,7 @@ private AggregationNode computeCounts(UnionNode sourceNode, List origina QualifiedName name = QualifiedName.of("count"); aggregations.put(output, new Aggregation( new FunctionCall(name, ImmutableList.of(markers.get(i).toSymbolReference())), - functionManager.resolveFunction(session, name, fromTypes(BIGINT)), + functionManager.lookupFunction(name, fromTypes(BIGINT)), Optional.empty())); } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/OptimizeMixedDistinctAggregations.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/OptimizeMixedDistinctAggregations.java index 27f3e94c3dd94..4cebb5f851d35 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/OptimizeMixedDistinctAggregations.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/OptimizeMixedDistinctAggregations.java @@ -86,7 +86,7 @@ public OptimizeMixedDistinctAggregations(Metadata metadata) public PlanNode optimize(PlanNode plan, Session session, TypeProvider types, SymbolAllocator symbolAllocator, PlanNodeIdAllocator idAllocator, WarningCollector warningCollector) { if (isOptimizeDistinctAggregationEnabled(session)) { - return SimplePlanRewriter.rewriteWith(new Optimizer(idAllocator, symbolAllocator, metadata, session), plan, Optional.empty()); + return SimplePlanRewriter.rewriteWith(new Optimizer(idAllocator, symbolAllocator, metadata), plan, Optional.empty()); } return plan; @@ -98,14 +98,12 @@ private static class Optimizer private final PlanNodeIdAllocator idAllocator; private final SymbolAllocator symbolAllocator; private final Metadata metadata; - private final Session session; - private Optimizer(PlanNodeIdAllocator idAllocator, SymbolAllocator symbolAllocator, Metadata metadata, Session session) + private Optimizer(PlanNodeIdAllocator idAllocator, SymbolAllocator symbolAllocator, Metadata metadata) { this.idAllocator = requireNonNull(idAllocator, "idAllocator is null"); this.symbolAllocator = requireNonNull(symbolAllocator, "symbolAllocator is null"); this.metadata = requireNonNull(metadata, "metadata is null"); - this.session = requireNonNull(session, "session is null"); } @Override @@ -174,7 +172,7 @@ public PlanNode visitAggregation(AggregationNode node, RewriteContext createAggregationNode( new FunctionCall( COUNT, ImmutableList.of(nonNullableAggregationSourceSymbol.toSymbolReference())), - functionManager.resolveFunction( - session, + functionManager.lookupFunction( COUNT, fromTypeSignatures(scalarAggregationSourceTypeSignatures)), entry.getValue().getMask())); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/TransformQuantifiedComparisonApplyToLateralJoin.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/TransformQuantifiedComparisonApplyToLateralJoin.java index 89df84a030e2e..3639078862159 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/TransformQuantifiedComparisonApplyToLateralJoin.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/TransformQuantifiedComparisonApplyToLateralJoin.java @@ -148,19 +148,19 @@ private PlanNode rewriteQuantifiedApplyNode(ApplyNode node, QuantifiedComparison ImmutableMap.of( minValue, new Aggregation( new FunctionCall(MIN, outputColumnReferences), - functionManager.resolveFunction(session, MIN, outputColumnTypeSignatures), + functionManager.lookupFunction(MIN, outputColumnTypeSignatures), Optional.empty()), maxValue, new Aggregation( new FunctionCall(MAX, outputColumnReferences), - functionManager.resolveFunction(session, MAX, outputColumnTypeSignatures), + functionManager.lookupFunction(MAX, outputColumnTypeSignatures), Optional.empty()), countAllValue, new Aggregation( new FunctionCall(COUNT, emptyList()), - functionManager.resolveFunction(session, COUNT, emptyList()), + functionManager.lookupFunction(COUNT, emptyList()), Optional.empty()), countNonNullValue, new Aggregation( new FunctionCall(COUNT, outputColumnReferences), - functionManager.resolveFunction(session, COUNT, outputColumnTypeSignatures), + functionManager.lookupFunction(COUNT, outputColumnTypeSignatures), Optional.empty())), globalAggregation(), ImmutableList.of(), diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java index 18e50e3ef6da9..4217d7b97b9ea 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java @@ -116,7 +116,7 @@ import java.util.stream.Stream; import static com.facebook.presto.execution.StageInfo.getAllStages; -import static com.facebook.presto.spi.function.OperatorType.CAST; +import static com.facebook.presto.metadata.CastType.CAST; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.sql.planner.SystemPartitioningHandle.SINGLE_DISTRIBUTION; import static com.facebook.presto.sql.planner.planPrinter.PlanNodeStatsSummarizer.aggregateStageStats; diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/CallExpression.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/CallExpression.java index a2f4800cf49a3..95db84df56e44 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/CallExpression.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/CallExpression.java @@ -13,7 +13,7 @@ */ package com.facebook.presto.sql.relational; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.Type; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; @@ -26,24 +26,24 @@ public final class CallExpression extends RowExpression { - private final Signature signature; + private final FunctionHandle functionHandle; private final Type returnType; private final List arguments; - public CallExpression(Signature signature, Type returnType, List arguments) + public CallExpression(FunctionHandle functionHandle, Type returnType, List arguments) { - requireNonNull(signature, "signature is null"); + requireNonNull(functionHandle, "functionHandle is null"); requireNonNull(arguments, "arguments is null"); requireNonNull(returnType, "returnType is null"); - this.signature = signature; + this.functionHandle = functionHandle; this.returnType = returnType; this.arguments = ImmutableList.copyOf(arguments); } - public Signature getSignature() + public FunctionHandle getFunctionHandle() { - return signature; + return functionHandle; } @Override @@ -60,13 +60,13 @@ public List getArguments() @Override public String toString() { - return signature.getName() + "(" + Joiner.on(", ").join(arguments) + ")"; + return functionHandle.getSignature().getName() + "(" + Joiner.on(", ").join(arguments) + ")"; } @Override public int hashCode() { - return Objects.hash(signature, arguments); + return Objects.hash(functionHandle, arguments); } @Override @@ -79,7 +79,7 @@ public boolean equals(Object obj) return false; } CallExpression other = (CallExpression) obj; - return Objects.equals(this.signature, other.signature) && Objects.equals(this.arguments, other.arguments); + return Objects.equals(this.functionHandle, other.functionHandle) && Objects.equals(this.arguments, other.arguments); } @Override diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/DeterminismEvaluator.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/DeterminismEvaluator.java index 76ad86b2558ad..8c07a253b7cb7 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/DeterminismEvaluator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/DeterminismEvaluator.java @@ -14,8 +14,10 @@ package com.facebook.presto.sql.relational; import com.facebook.presto.metadata.FunctionManager; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.PrestoException; +import com.facebook.presto.spi.function.FunctionHandle; +import static com.facebook.presto.spi.StandardErrorCode.FUNCTION_IMPLEMENTATION_MISSING; import static java.util.Objects.requireNonNull; public class DeterminismEvaluator @@ -57,9 +59,16 @@ public Boolean visitConstant(ConstantExpression literal, Void context) @Override public Boolean visitCall(CallExpression call, Void context) { - Signature signature = call.getSignature(); - if (functionManager.isRegistered(signature) && !functionManager.getScalarFunctionImplementation(signature).isDeterministic()) { - return false; + FunctionHandle functionHandle = call.getFunctionHandle(); + try { + if (!functionManager.getScalarFunctionImplementation(functionHandle).isDeterministic()) { + return false; + } + } + catch (PrestoException e) { + if (e.getErrorCode().getCode() != FUNCTION_IMPLEMENTATION_MISSING.toErrorCode().getCode()) { + throw e; + } } return call.getArguments().stream() @@ -77,5 +86,12 @@ public Boolean visitVariableReference(VariableReferenceExpression reference, Voi { return true; } + + @Override + public Boolean visitSpecialForm(SpecialFormExpression specialForm, Void context) + { + return specialForm.getArguments().stream() + .allMatch(expression -> expression.accept(this, context)); + } } } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/Expressions.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/Expressions.java index 4322139b84d62..2cbe7421a7613 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/Expressions.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/Expressions.java @@ -13,8 +13,9 @@ */ package com.facebook.presto.sql.relational; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.Type; +import com.facebook.presto.sql.relational.SpecialFormExpression.Form; import com.google.common.collect.ImmutableList; import java.util.Arrays; @@ -36,14 +37,14 @@ public static ConstantExpression constantNull(Type type) return new ConstantExpression(null, type); } - public static CallExpression call(Signature signature, Type returnType, RowExpression... arguments) + public static CallExpression call(FunctionHandle functionHandle, Type returnType, RowExpression... arguments) { - return new CallExpression(signature, returnType, Arrays.asList(arguments)); + return new CallExpression(functionHandle, returnType, Arrays.asList(arguments)); } - public static CallExpression call(Signature signature, Type returnType, List arguments) + public static CallExpression call(FunctionHandle functionHandle, Type returnType, List arguments) { - return new CallExpression(signature, returnType, arguments); + return new CallExpression(functionHandle, returnType, arguments); } public static InputReferenceExpression field(int field, Type type) @@ -51,6 +52,16 @@ public static InputReferenceExpression field(int field, Type type) return new InputReferenceExpression(field, type); } + public static SpecialFormExpression specialForm(Form form, Type returnType, RowExpression... arguments) + { + return new SpecialFormExpression(form, returnType, arguments); + } + + public static SpecialFormExpression specialForm(Form form, Type returnType, List arguments) + { + return new SpecialFormExpression(form, returnType, arguments); + } + public static List subExpressions(Iterable expressions) { final ImmutableList.Builder builder = ImmutableList.builder(); @@ -96,6 +107,16 @@ public Void visitVariableReference(VariableReferenceExpression reference, Void c builder.add(reference); return null; } + + @Override + public Void visitSpecialForm(SpecialFormExpression specialForm, Void context) + { + builder.add(specialForm); + for (RowExpression argument : specialForm.getArguments()) { + argument.accept(this, context); + } + return null; + } }, null); } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/RowExpressionVisitor.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/RowExpressionVisitor.java index c4f90c880f8b9..96ee5919537b6 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/RowExpressionVisitor.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/RowExpressionVisitor.java @@ -24,4 +24,6 @@ public interface RowExpressionVisitor R visitLambda(LambdaDefinitionExpression lambda, C context); R visitVariableReference(VariableReferenceExpression reference, C context); + + R visitSpecialForm(SpecialFormExpression specialForm, C context); } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/Signatures.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/Signatures.java index 194167db0ab69..adca7de55d7c8 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/Signatures.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/Signatures.java @@ -15,15 +15,12 @@ import com.facebook.presto.spi.function.OperatorType; import com.facebook.presto.spi.function.Signature; -import com.facebook.presto.spi.type.BigintType; import com.facebook.presto.spi.type.CharType; -import com.facebook.presto.spi.type.RowType; import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.sql.tree.ArithmeticBinaryExpression; import com.facebook.presto.sql.tree.ComparisonExpression; -import com.facebook.presto.sql.tree.LogicalBinaryExpression; import com.facebook.presto.type.LikePatternType; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; @@ -33,27 +30,19 @@ import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; import static com.facebook.presto.metadata.OperatorSignatureUtils.mangleOperatorName; +import static com.facebook.presto.operator.scalar.TryCastFunction.TRY_CAST_NAME; import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.function.OperatorType.SUBSCRIPT; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.sql.tree.ArrayConstructor.ARRAY_CONSTRUCTOR; import static com.google.common.base.Preconditions.checkArgument; -import static com.google.common.collect.ImmutableList.toImmutableList; public final class Signatures { - public static final String IF = "IF"; - public static final String NULL_IF = "NULL_IF"; - public static final String SWITCH = "SWITCH"; public static final String CAST = mangleOperatorName("CAST"); - public static final String TRY_CAST = "TRY_CAST"; - public static final String IS_NULL = "IS_NULL"; public static final String COALESCE = "COALESCE"; public static final String IN = "IN"; public static final String TRY = "TRY"; - public static final String DEREFERENCE = "DEREFERENCE"; - public static final String ROW_CONSTRUCTOR = "ROW_CONSTRUCTOR"; - public static final String BIND = "$INTERNAL$BIND"; private Signatures() { @@ -94,12 +83,7 @@ public static Signature castSignature(Type returnType, Type valueType) public static Signature tryCastSignature(Type returnType, Type valueType) { - return internalScalarFunction(TRY_CAST, returnType.getTypeSignature(), valueType.getTypeSignature()); - } - - public static Signature logicalExpressionSignature(LogicalBinaryExpression.Operator operator) - { - return internalScalarFunction(operator.name(), parseTypeSignature(StandardTypes.BOOLEAN), parseTypeSignature(StandardTypes.BOOLEAN), parseTypeSignature(StandardTypes.BOOLEAN)); + return internalScalarFunction(TRY_CAST_NAME, returnType.getTypeSignature(), valueType.getTypeSignature()); } public static Signature arithmeticNegationSignature(Type returnType, Type valueType) @@ -138,65 +122,8 @@ public static Signature comparisonExpressionSignature(ComparisonExpression.Opera } // **************** special forms (lazy evaluation, etc) **************** - public static Signature ifSignature(Type returnType) - { - return new Signature(IF, SCALAR, returnType.getTypeSignature()); - } - - public static Signature nullIfSignature(Type returnType, Type firstType, Type secondType) - { - return new Signature(NULL_IF, SCALAR, returnType.getTypeSignature(), firstType.getTypeSignature(), secondType.getTypeSignature()); - } - - public static Signature switchSignature(Type returnType) - { - return new Signature(SWITCH, SCALAR, returnType.getTypeSignature()); - } - - public static Signature whenSignature(Type returnType) - { - return new Signature("WHEN", SCALAR, returnType.getTypeSignature()); - } - public static Signature trySignature(Type returnType) { return new Signature(TRY, SCALAR, returnType.getTypeSignature()); } - - public static Signature bindSignature(Type returnType, List valueTypes, Type functionType) - { - ImmutableList.Builder typeSignatureBuilder = ImmutableList.builder(); - for (Type valueType : valueTypes) { - typeSignatureBuilder.add(valueType.getTypeSignature()); - } - typeSignatureBuilder.add(functionType.getTypeSignature()); - return new Signature(BIND, SCALAR, returnType.getTypeSignature(), typeSignatureBuilder.build()); - } - - // **************** functions that require varargs and/or complex types (e.g., lists) **************** - public static Signature inSignature() - { - return internalScalarFunction(IN, parseTypeSignature(StandardTypes.BOOLEAN)); - } - - public static Signature rowConstructorSignature(Type returnType, List argumentTypes) - { - return internalScalarFunction(ROW_CONSTRUCTOR, returnType.getTypeSignature(), argumentTypes.stream().map(Type::getTypeSignature).collect(toImmutableList())); - } - - // **************** functions that need to do special null handling **************** - public static Signature isNullSignature(Type argumentType) - { - return internalScalarFunction(IS_NULL, parseTypeSignature(StandardTypes.BOOLEAN), argumentType.getTypeSignature()); - } - - public static Signature coalesceSignature(Type returnType, List argumentTypes) - { - return internalScalarFunction(COALESCE, returnType.getTypeSignature(), Lists.transform(argumentTypes, Type::getTypeSignature)); - } - - public static Signature dereferenceSignature(Type returnType, RowType rowType) - { - return internalScalarFunction(DEREFERENCE, returnType.getTypeSignature(), ImmutableList.of(rowType.getTypeSignature(), BigintType.BIGINT.getTypeSignature())); - } } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/SpecialFormExpression.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/SpecialFormExpression.java new file mode 100644 index 0000000000000..30e48eb06f9bd --- /dev/null +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/SpecialFormExpression.java @@ -0,0 +1,107 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.facebook.presto.sql.relational; + +import com.facebook.presto.spi.type.Type; +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableList; + +import java.util.List; +import java.util.Objects; + +import static java.util.Objects.requireNonNull; + +public class SpecialFormExpression + extends RowExpression +{ + private final Form form; + private final Type returnType; + private final List arguments; + + public SpecialFormExpression(Form form, Type returnType, RowExpression... arguments) + { + this(form, returnType, ImmutableList.copyOf(arguments)); + } + + public SpecialFormExpression(Form form, Type returnType, List arguments) + { + this.form = requireNonNull(form, "form is null"); + this.returnType = requireNonNull(returnType, "returnType is null"); + this.arguments = requireNonNull(arguments, "arguments is null"); + } + + public Form getForm() + { + return form; + } + + @Override + public Type getType() + { + return returnType; + } + + public List getArguments() + { + return arguments; + } + + @Override + public String toString() + { + return form.name() + "(" + Joiner.on(", ").join(arguments) + ")"; + } + + @Override + public int hashCode() + { + return Objects.hash(form, arguments); + } + + @Override + public boolean equals(Object obj) + { + if (this == obj) { + return true; + } + if (obj == null || getClass() != obj.getClass()) { + return false; + } + SpecialFormExpression other = (SpecialFormExpression) obj; + return this.form == other.form && + Objects.equals(this.arguments, other.arguments); + } + + @Override + public R accept(RowExpressionVisitor visitor, C context) + { + return visitor.visitSpecialForm(this, context); + } + + public enum Form + { + IF, + NULL_IF, + SWITCH, + WHEN, + IS_NULL, + COALESCE, + IN, + AND, + OR, + DEREFERENCE, + ROW_CONSTRUCTOR, + BIND, + } +} diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/SqlToRowExpressionTranslator.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/SqlToRowExpressionTranslator.java index 7b6ec038cb0f6..e83ab5027c7a0 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/SqlToRowExpressionTranslator.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/SqlToRowExpressionTranslator.java @@ -14,20 +14,17 @@ package com.facebook.presto.sql.relational; import com.facebook.presto.Session; -import com.facebook.presto.SystemSessionProperties; import com.facebook.presto.metadata.FunctionManager; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.CharType; import com.facebook.presto.spi.type.DecimalParseResult; import com.facebook.presto.spi.type.Decimals; import com.facebook.presto.spi.type.RowType; import com.facebook.presto.spi.type.RowType.Field; -import com.facebook.presto.spi.type.TimeZoneKey; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeManager; -import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.spi.type.VarcharType; +import com.facebook.presto.sql.analyzer.TypeSignatureProvider; +import com.facebook.presto.sql.relational.SpecialFormExpression.Form; import com.facebook.presto.sql.relational.optimizer.ExpressionOptimizer; import com.facebook.presto.sql.tree.ArithmeticBinaryExpression; import com.facebook.presto.sql.tree.ArithmeticUnaryExpression; @@ -64,6 +61,7 @@ import com.facebook.presto.sql.tree.NotExpression; import com.facebook.presto.sql.tree.NullIfExpression; import com.facebook.presto.sql.tree.NullLiteral; +import com.facebook.presto.sql.tree.QualifiedName; import com.facebook.presto.sql.tree.Row; import com.facebook.presto.sql.tree.SearchedCaseExpression; import com.facebook.presto.sql.tree.SimpleCaseExpression; @@ -84,7 +82,12 @@ import java.util.OptionalInt; import static com.facebook.presto.SystemSessionProperties.isLegacyRowFieldOrdinalAccessEnabled; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; +import static com.facebook.presto.SystemSessionProperties.isLegacyTimestamp; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.CastType.TRY_CAST; +import static com.facebook.presto.spi.function.OperatorType.BETWEEN; +import static com.facebook.presto.spi.function.OperatorType.NEGATION; +import static com.facebook.presto.spi.function.OperatorType.SUBSCRIPT; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.CharType.createCharType; @@ -95,29 +98,24 @@ import static com.facebook.presto.spi.type.VarbinaryType.VARBINARY; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.spi.type.VarcharType.createVarcharType; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.constantNull; import static com.facebook.presto.sql.relational.Expressions.field; -import static com.facebook.presto.sql.relational.Signatures.arithmeticExpressionSignature; -import static com.facebook.presto.sql.relational.Signatures.arithmeticNegationSignature; -import static com.facebook.presto.sql.relational.Signatures.arrayConstructorSignature; -import static com.facebook.presto.sql.relational.Signatures.betweenSignature; -import static com.facebook.presto.sql.relational.Signatures.bindSignature; -import static com.facebook.presto.sql.relational.Signatures.castSignature; -import static com.facebook.presto.sql.relational.Signatures.coalesceSignature; -import static com.facebook.presto.sql.relational.Signatures.comparisonExpressionSignature; -import static com.facebook.presto.sql.relational.Signatures.dereferenceSignature; -import static com.facebook.presto.sql.relational.Signatures.likeCharSignature; -import static com.facebook.presto.sql.relational.Signatures.likePatternSignature; -import static com.facebook.presto.sql.relational.Signatures.likeVarcharSignature; -import static com.facebook.presto.sql.relational.Signatures.logicalExpressionSignature; -import static com.facebook.presto.sql.relational.Signatures.nullIfSignature; -import static com.facebook.presto.sql.relational.Signatures.rowConstructorSignature; -import static com.facebook.presto.sql.relational.Signatures.subscriptSignature; -import static com.facebook.presto.sql.relational.Signatures.switchSignature; -import static com.facebook.presto.sql.relational.Signatures.tryCastSignature; -import static com.facebook.presto.sql.relational.Signatures.whenSignature; +import static com.facebook.presto.sql.relational.Expressions.specialForm; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.AND; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.BIND; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.COALESCE; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.DEREFERENCE; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.IF; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.IN; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.IS_NULL; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.NULL_IF; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.OR; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.ROW_CONSTRUCTOR; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.SWITCH; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.WHEN; import static com.facebook.presto.type.JsonType.JSON; import static com.facebook.presto.type.LikePatternType.LIKE_PATTERN; import static com.facebook.presto.util.DateTimeUtils.parseDayTimeInterval; @@ -139,7 +137,6 @@ private SqlToRowExpressionTranslator() {} public static RowExpression translate( Expression expression, - FunctionKind functionKind, Map, Type> types, FunctionManager functionManager, TypeManager typeManager, @@ -147,12 +144,10 @@ public static RowExpression translate( boolean optimize) { Visitor visitor = new Visitor( - functionKind, types, typeManager, - session.getTimeZoneKey(), - isLegacyRowFieldOrdinalAccessEnabled(session), - SystemSessionProperties.isLegacyTimestamp(session)); + functionManager, + session); RowExpression result = visitor.process(expression, null); requireNonNull(result, "translated expression is null"); @@ -168,28 +163,23 @@ public static RowExpression translate( private static class Visitor extends AstVisitor { - private final FunctionKind functionKind; private final Map, Type> types; private final TypeManager typeManager; - private final TimeZoneKey timeZoneKey; - private final boolean legacyRowFieldOrdinalAccess; - @Deprecated - private final boolean isLegacyTimestamp; + private final FunctionManager functionManager; + private final Session session; + private final StandardFunctionResolution standardFunctionResolution; private Visitor( - FunctionKind functionKind, Map, Type> types, TypeManager typeManager, - TimeZoneKey timeZoneKey, - boolean legacyRowFieldOrdinalAccess, - boolean isLegacyTimestamp) + FunctionManager functionManager, + Session session) { - this.functionKind = functionKind; this.types = ImmutableMap.copyOf(requireNonNull(types, "types is null")); this.typeManager = typeManager; - this.timeZoneKey = timeZoneKey; - this.legacyRowFieldOrdinalAccess = legacyRowFieldOrdinalAccess; - this.isLegacyTimestamp = isLegacyTimestamp; + this.functionManager = functionManager; + this.session = session; + this.standardFunctionResolution = new StandardFunctionResolution(functionManager); } private Type getType(Expression node) @@ -274,13 +264,13 @@ protected RowExpression visitGenericLiteral(GenericLiteral node, Void context) if (JSON.equals(type)) { return call( - new Signature("json_parse", SCALAR, getType(node).getTypeSignature(), VARCHAR.getTypeSignature()), + functionManager.lookupFunction(QualifiedName.of("json_parse"), fromTypes(VARCHAR)), getType(node), constant(utf8Slice(node.getValue()), VARCHAR)); } return call( - castSignature(getType(node), VARCHAR), + functionManager.lookupCast(CAST, VARCHAR.getTypeSignature(), getType(node).getTypeSignature()), getType(node), constant(utf8Slice(node.getValue()), VARCHAR)); } @@ -293,9 +283,9 @@ protected RowExpression visitTimeLiteral(TimeLiteral node, Void context) value = parseTimeWithTimeZone(node.getValue()); } else { - if (isLegacyTimestamp) { + if (isLegacyTimestamp(session)) { // parse in time zone of client - value = parseTimeWithoutTimeZone(timeZoneKey, node.getValue()); + value = parseTimeWithoutTimeZone(session.getTimeZoneKey(), node.getValue()); } else { value = parseTimeWithoutTimeZone(node.getValue()); @@ -308,8 +298,8 @@ protected RowExpression visitTimeLiteral(TimeLiteral node, Void context) protected RowExpression visitTimestampLiteral(TimestampLiteral node, Void context) { long value; - if (isLegacyTimestamp) { - value = parseTimestampLiteral(timeZoneKey, node.getValue()); + if (isLegacyTimestamp(session)) { + value = parseTimestampLiteral(session.getTimeZoneKey(), node.getValue()); } else { value = parseTimestampLiteral(node.getValue()); @@ -337,7 +327,7 @@ protected RowExpression visitComparisonExpression(ComparisonExpression node, Voi RowExpression right = process(node.getRight(), context); return call( - comparisonExpressionSignature(node.getOperator(), left.getType(), right.getType()), + standardFunctionResolution.comparisonFunction(node.getOperator(), left.getType(), right.getType()), BOOLEAN, left, right); @@ -350,14 +340,13 @@ protected RowExpression visitFunctionCall(FunctionCall node, Void context) .map(value -> process(value, context)) .collect(toImmutableList()); - List argumentTypes = arguments.stream() + List argumentTypes = arguments.stream() .map(RowExpression::getType) .map(Type::getTypeSignature) + .map(TypeSignatureProvider::new) .collect(toImmutableList()); - Signature signature = new Signature(node.getName().getSuffix(), functionKind, getType(node).getTypeSignature(), argumentTypes); - - return call(signature, getType(node), arguments); + return call(functionManager.resolveFunction(session, node.getName(), argumentTypes), getType(node), arguments); } @Override @@ -395,10 +384,7 @@ protected RowExpression visitBindExpression(BindExpression node, Void context) RowExpression function = process(node.getFunction(), context); argumentsBuilder.add(function); - return call( - bindSignature(getType(node), valueTypesBuilder.build(), function.getType()), - getType(node), - argumentsBuilder.build()); + return specialForm(BIND, getType(node), argumentsBuilder.build()); } @Override @@ -408,7 +394,7 @@ protected RowExpression visitArithmeticBinary(ArithmeticBinaryExpression node, V RowExpression right = process(node.getRight(), context); return call( - arithmeticExpressionSignature(node.getOperator(), getType(node), left.getType(), right.getType()), + standardFunctionResolution.arithmeticFunction(node.getOperator(), left.getType(), right.getType()), getType(node), left, right); @@ -424,7 +410,7 @@ protected RowExpression visitArithmeticUnary(ArithmeticUnaryExpression node, Voi return expression; case MINUS: return call( - arithmeticNegationSignature(getType(node), expression.getType()), + functionManager.resolveOperator(NEGATION, fromTypes(expression.getType())), getType(node), expression); } @@ -435,11 +421,18 @@ protected RowExpression visitArithmeticUnary(ArithmeticUnaryExpression node, Voi @Override protected RowExpression visitLogicalBinaryExpression(LogicalBinaryExpression node, Void context) { - return call( - logicalExpressionSignature(node.getOperator()), - BOOLEAN, - process(node.getLeft(), context), - process(node.getRight(), context)); + Form form; + switch (node.getOperator()) { + case AND: + form = AND; + break; + case OR: + form = OR; + break; + default: + throw new IllegalStateException("Unknown logical operator: " + node.getOperator()); + } + return specialForm(form, BOOLEAN, process(node.getLeft(), context), process(node.getRight(), context)); } @Override @@ -452,10 +445,10 @@ protected RowExpression visitCast(Cast node, Void context) } if (node.isSafe()) { - return call(tryCastSignature(getType(node), value.getType()), getType(node), value); + return call(functionManager.lookupCast(TRY_CAST, value.getType().getTypeSignature(), getType(node).getTypeSignature()), getType(node), value); } - return call(castSignature(getType(node), value.getType()), getType(node), value); + return call(functionManager.lookupCast(CAST, value.getType().getTypeSignature(), getType(node).getTypeSignature()), getType(node), value); } private static RowExpression changeType(RowExpression value, Type targetType) @@ -477,7 +470,7 @@ private ChangeTypeVisitor(Type targetType) @Override public RowExpression visitCall(CallExpression call, Void context) { - return new CallExpression(call.getSignature(), targetType, call.getArguments()); + return new CallExpression(call.getFunctionHandle(), targetType, call.getArguments()); } @Override @@ -503,6 +496,12 @@ public RowExpression visitVariableReference(VariableReferenceExpression referenc { return new VariableReferenceExpression(reference.getName(), targetType); } + + @Override + public RowExpression visitSpecialForm(SpecialFormExpression specialForm, Void context) + { + return specialForm(specialForm.getForm(), targetType, specialForm.getArguments()); + } } @Override @@ -512,8 +511,7 @@ protected RowExpression visitCoalesceExpression(CoalesceExpression node, Void co .map(value -> process(value, context)) .collect(toImmutableList()); - List argumentTypes = arguments.stream().map(RowExpression::getType).collect(toImmutableList()); - return call(coalesceSignature(getType(node), argumentTypes), getType(node), arguments); + return specialForm(COALESCE, getType(node), arguments); } @Override @@ -524,7 +522,8 @@ protected RowExpression visitSimpleCaseExpression(SimpleCaseExpression node, Voi arguments.add(process(node.getOperand(), context)); for (WhenClause clause : node.getWhenClauses()) { - arguments.add(call(whenSignature(getType(clause)), + arguments.add(specialForm( + WHEN, getType(clause), process(clause.getOperand(), context), process(clause.getResult(), context))); @@ -536,7 +535,7 @@ protected RowExpression visitSimpleCaseExpression(SimpleCaseExpression node, Voi .map((value) -> process(value, context)) .orElse(constantNull(returnType))); - return call(switchSignature(returnType), returnType, arguments.build()); + return specialForm(SWITCH, returnType, arguments.build()); } @Override @@ -567,8 +566,8 @@ protected RowExpression visitSearchedCaseExpression(SearchedCaseExpression node, .orElse(constantNull(getType(node))); for (WhenClause clause : Lists.reverse(node.getWhenClauses())) { - expression = call( - Signatures.ifSignature(getType(node)), + expression = specialForm( + IF, getType(node), process(clause.getOperand(), context), process(clause.getResult(), context), @@ -593,7 +592,7 @@ protected RowExpression visitDereferenceExpression(DereferenceExpression node, V } } - if (legacyRowFieldOrdinalAccess && index < 0) { + if (isLegacyRowFieldOrdinalAccessEnabled(session) && index < 0) { OptionalInt rowIndex = parseAnonymousRowFieldOrdinalAccess(fieldName, fields); if (rowIndex.isPresent()) { index = rowIndex.getAsInt(); @@ -602,7 +601,7 @@ protected RowExpression visitDereferenceExpression(DereferenceExpression node, V checkState(index >= 0, "could not find field name: %s", node.getField()); Type returnType = getType(node); - return call(dereferenceSignature(returnType, rowType), returnType, process(node.getBase(), context), constant(index, INTEGER)); + return specialForm(DEREFERENCE, returnType, process(node.getBase(), context), constant(index, INTEGER)); } @Override @@ -620,13 +619,13 @@ protected RowExpression visitIfExpression(IfExpression node, Void context) arguments.add(constantNull(getType(node))); } - return call(Signatures.ifSignature(getType(node)), getType(node), arguments.build()); + return specialForm(IF, getType(node), arguments.build()); } @Override protected RowExpression visitTryExpression(TryExpression node, Void context) { - return call(Signatures.trySignature(getType(node)), getType(node), process(node.getInnerExpression(), context)); + return call(standardFunctionResolution.tryFunction(getType(node)), getType(node), process(node.getInnerExpression(), context)); } @Override @@ -639,7 +638,7 @@ protected RowExpression visitInPredicate(InPredicate node, Void context) arguments.add(process(value, context)); } - return call(Signatures.inSignature(), BOOLEAN, arguments.build()); + return specialForm(IN, BOOLEAN, arguments.build()); } @Override @@ -648,9 +647,9 @@ protected RowExpression visitIsNotNullPredicate(IsNotNullPredicate node, Void co RowExpression expression = process(node.getValue(), context); return call( - Signatures.notSignature(), + standardFunctionResolution.notFunction(), BOOLEAN, - call(Signatures.isNullSignature(expression.getType()), BOOLEAN, ImmutableList.of(expression))); + specialForm(IS_NULL, BOOLEAN, ImmutableList.of(expression))); } @Override @@ -658,13 +657,13 @@ protected RowExpression visitIsNullPredicate(IsNullPredicate node, Void context) { RowExpression expression = process(node.getValue(), context); - return call(Signatures.isNullSignature(expression.getType()), BOOLEAN, expression); + return specialForm(IS_NULL, BOOLEAN, expression); } @Override protected RowExpression visitNotExpression(NotExpression node, Void context) { - return call(Signatures.notSignature(), BOOLEAN, process(node.getValue(), context)); + return call(standardFunctionResolution.notFunction(), BOOLEAN, process(node.getValue(), context)); } @Override @@ -673,11 +672,7 @@ protected RowExpression visitNullIfExpression(NullIfExpression node, Void contex RowExpression first = process(node.getFirst(), context); RowExpression second = process(node.getSecond(), context); - return call( - nullIfSignature(getType(node), first.getType(), second.getType()), - getType(node), - first, - second); + return specialForm(NULL_IF, getType(node), first, second); } @Override @@ -688,7 +683,7 @@ protected RowExpression visitBetweenPredicate(BetweenPredicate node, Void contex RowExpression max = process(node.getMax(), context); return call( - betweenSignature(value.getType(), min.getType(), max.getType()), + functionManager.resolveOperator(BETWEEN, fromTypes(value.getType(), min.getType(), max.getType())), BOOLEAN, value, min, @@ -703,20 +698,20 @@ protected RowExpression visitLikePredicate(LikePredicate node, Void context) if (node.getEscape().isPresent()) { RowExpression escape = process(node.getEscape().get(), context); - return likeFunctionCall(value, call(likePatternSignature(), LIKE_PATTERN, pattern, escape)); + return likeFunctionCall(value, call(standardFunctionResolution.likePatternFunction(), LIKE_PATTERN, pattern, escape)); } - return likeFunctionCall(value, call(castSignature(LIKE_PATTERN, VARCHAR), LIKE_PATTERN, pattern)); + return likeFunctionCall(value, call(functionManager.lookupCast(CAST, VARCHAR.getTypeSignature(), LIKE_PATTERN.getTypeSignature()), LIKE_PATTERN, pattern)); } private RowExpression likeFunctionCall(RowExpression value, RowExpression pattern) { if (value.getType() instanceof VarcharType) { - return call(likeVarcharSignature(), BOOLEAN, value, pattern); + return call(standardFunctionResolution.likeVarcharFunction(), BOOLEAN, value, pattern); } checkState(value.getType() instanceof CharType, "LIKE value type is neither VARCHAR or CHAR"); - return call(likeCharSignature(value.getType()), BOOLEAN, value, pattern); + return call(standardFunctionResolution.likeCharFunction(value.getType()), BOOLEAN, value, pattern); } @Override @@ -726,7 +721,7 @@ protected RowExpression visitSubscriptExpression(SubscriptExpression node, Void RowExpression index = process(node.getIndex(), context); return call( - subscriptSignature(getType(node), base.getType(), index.getType()), + functionManager.resolveOperator(SUBSCRIPT, fromTypes(base.getType(), index.getType())), getType(node), base, index); @@ -741,7 +736,7 @@ protected RowExpression visitArrayConstructor(ArrayConstructor node, Void contex List argumentTypes = arguments.stream() .map(RowExpression::getType) .collect(toImmutableList()); - return call(arrayConstructorSignature(getType(node), argumentTypes), getType(node), arguments); + return call(standardFunctionResolution.arrayConstructor(argumentTypes), getType(node), arguments); } @Override @@ -751,10 +746,7 @@ protected RowExpression visitRow(Row node, Void context) .map(value -> process(value, context)) .collect(toImmutableList()); Type returnType = getType(node); - List argumentTypes = node.getItems().stream() - .map(this::getType) - .collect(toImmutableList()); - return call(rowConstructorSignature(returnType, argumentTypes), returnType, arguments); + return specialForm(ROW_CONSTRUCTOR, returnType, arguments); } } } diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/StandardFunctionResolution.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/StandardFunctionResolution.java new file mode 100644 index 0000000000000..bc130d2ed807f --- /dev/null +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/StandardFunctionResolution.java @@ -0,0 +1,143 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.facebook.presto.sql.relational; + +import com.facebook.presto.metadata.FunctionManager; +import com.facebook.presto.spi.function.FunctionHandle; +import com.facebook.presto.spi.function.OperatorType; +import com.facebook.presto.spi.type.CharType; +import com.facebook.presto.spi.type.Type; +import com.facebook.presto.sql.tree.ArithmeticBinaryExpression; +import com.facebook.presto.sql.tree.ComparisonExpression; +import com.facebook.presto.sql.tree.QualifiedName; + +import java.util.List; + +import static com.facebook.presto.spi.function.OperatorType.ADD; +import static com.facebook.presto.spi.function.OperatorType.DIVIDE; +import static com.facebook.presto.spi.function.OperatorType.EQUAL; +import static com.facebook.presto.spi.function.OperatorType.GREATER_THAN; +import static com.facebook.presto.spi.function.OperatorType.GREATER_THAN_OR_EQUAL; +import static com.facebook.presto.spi.function.OperatorType.IS_DISTINCT_FROM; +import static com.facebook.presto.spi.function.OperatorType.LESS_THAN; +import static com.facebook.presto.spi.function.OperatorType.LESS_THAN_OR_EQUAL; +import static com.facebook.presto.spi.function.OperatorType.MODULUS; +import static com.facebook.presto.spi.function.OperatorType.MULTIPLY; +import static com.facebook.presto.spi.function.OperatorType.NOT_EQUAL; +import static com.facebook.presto.spi.function.OperatorType.SUBTRACT; +import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; +import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; +import static com.facebook.presto.sql.tree.ArrayConstructor.ARRAY_CONSTRUCTOR; +import static com.facebook.presto.type.LikePatternType.LIKE_PATTERN; +import static com.google.common.base.Preconditions.checkArgument; +import static java.util.Objects.requireNonNull; + +public final class StandardFunctionResolution +{ + private final FunctionManager functionManager; + + public StandardFunctionResolution(FunctionManager functionManager) + { + this.functionManager = requireNonNull(functionManager, "functionManager is null"); + } + + public FunctionHandle notFunction() + { + return functionManager.lookupFunction(QualifiedName.of("not"), fromTypes(BOOLEAN)); + } + + public FunctionHandle likeVarcharFunction() + { + return functionManager.lookupFunction(QualifiedName.of("LIKE"), fromTypes(VARCHAR, LIKE_PATTERN)); + } + + public FunctionHandle likeCharFunction(Type valueType) + { + checkArgument(valueType instanceof CharType, "Expected CHAR value type"); + return functionManager.lookupFunction(QualifiedName.of("LIKE"), fromTypes(valueType, LIKE_PATTERN)); + } + + public FunctionHandle likePatternFunction() + { + return functionManager.lookupFunction(QualifiedName.of("LIKE_PATTERN"), fromTypes(VARCHAR, VARCHAR)); + } + + public FunctionHandle arithmeticFunction(ArithmeticBinaryExpression.Operator operator, Type leftType, Type rightType) + { + OperatorType operatorType; + switch (operator) { + case ADD: + operatorType = ADD; + break; + case SUBTRACT: + operatorType = SUBTRACT; + break; + case MULTIPLY: + operatorType = MULTIPLY; + break; + case DIVIDE: + operatorType = DIVIDE; + break; + case MODULUS: + operatorType = MODULUS; + break; + default: + throw new IllegalStateException("Unknown arithmetic operator: " + operator); + } + return functionManager.resolveOperator(operatorType, fromTypes(leftType, rightType)); + } + + public FunctionHandle arrayConstructor(List argumentTypes) + { + return functionManager.lookupFunction(QualifiedName.of(ARRAY_CONSTRUCTOR), fromTypes(argumentTypes)); + } + + public FunctionHandle comparisonFunction(ComparisonExpression.Operator operator, Type leftType, Type rightType) + { + OperatorType operatorType; + switch (operator) { + case EQUAL: + operatorType = EQUAL; + break; + case NOT_EQUAL: + operatorType = NOT_EQUAL; + break; + case LESS_THAN: + operatorType = LESS_THAN; + break; + case LESS_THAN_OR_EQUAL: + operatorType = LESS_THAN_OR_EQUAL; + break; + case GREATER_THAN: + operatorType = GREATER_THAN; + break; + case GREATER_THAN_OR_EQUAL: + operatorType = GREATER_THAN_OR_EQUAL; + break; + case IS_DISTINCT_FROM: + operatorType = IS_DISTINCT_FROM; + break; + default: + throw new IllegalStateException("Unsupported comparison operator type: " + operator); + } + + return functionManager.resolveOperator(operatorType, fromTypes(leftType, rightType)); + } + + public FunctionHandle tryFunction(Type returnType) + { + return functionManager.lookupFunction(QualifiedName.of("TRY"), fromTypes(returnType)); + } +} diff --git a/presto-main/src/main/java/com/facebook/presto/sql/relational/optimizer/ExpressionOptimizer.java b/presto-main/src/main/java/com/facebook/presto/sql/relational/optimizer/ExpressionOptimizer.java index 4f18e67426ed1..e521bb0cb5d94 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/relational/optimizer/ExpressionOptimizer.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/relational/optimizer/ExpressionOptimizer.java @@ -17,8 +17,7 @@ import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.operator.scalar.ScalarFunctionImplementation; import com.facebook.presto.spi.ConnectorSession; -import com.facebook.presto.spi.function.OperatorType; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.TypeManager; import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.sql.relational.CallExpression; @@ -27,6 +26,8 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.RowExpressionVisitor; +import com.facebook.presto.sql.relational.SpecialFormExpression; +import com.facebook.presto.sql.relational.SpecialFormExpression.Form; import com.facebook.presto.sql.relational.VariableReferenceExpression; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -35,11 +36,12 @@ import java.util.ArrayList; import java.util.List; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; -import static com.facebook.presto.operator.scalar.JsonStringToArrayCast.JSON_STRING_TO_ARRAY_NAME; -import static com.facebook.presto.operator.scalar.JsonStringToMapCast.JSON_STRING_TO_MAP_NAME; -import static com.facebook.presto.operator.scalar.JsonStringToRowCast.JSON_STRING_TO_ROW_NAME; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.CastType.JSON_TO_ARRAY_CAST; +import static com.facebook.presto.metadata.CastType.JSON_TO_MAP_CAST; +import static com.facebook.presto.metadata.CastType.JSON_TO_ROW_CAST; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.NullConvention.RETURN_NULL_ON_NULL; +import static com.facebook.presto.operator.scalar.TryCastFunction.TRY_CAST_NAME; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.StandardTypes.ARRAY; import static com.facebook.presto.spi.type.StandardTypes.MAP; @@ -49,17 +51,7 @@ import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.constantNull; -import static com.facebook.presto.sql.relational.Signatures.BIND; -import static com.facebook.presto.sql.relational.Signatures.CAST; -import static com.facebook.presto.sql.relational.Signatures.COALESCE; -import static com.facebook.presto.sql.relational.Signatures.DEREFERENCE; -import static com.facebook.presto.sql.relational.Signatures.IF; -import static com.facebook.presto.sql.relational.Signatures.IN; -import static com.facebook.presto.sql.relational.Signatures.IS_NULL; -import static com.facebook.presto.sql.relational.Signatures.NULL_IF; -import static com.facebook.presto.sql.relational.Signatures.ROW_CONSTRUCTOR; -import static com.facebook.presto.sql.relational.Signatures.SWITCH; -import static com.facebook.presto.sql.relational.Signatures.TRY_CAST; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.BIND; import static com.facebook.presto.type.JsonType.JSON; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; @@ -102,70 +94,19 @@ public RowExpression visitConstant(ConstantExpression literal, Void context) @Override public RowExpression visitCall(CallExpression call, Void context) { - if (call.getSignature().getName().equals(CAST)) { - call = rewriteCast(call); + FunctionHandle functionHandle = call.getFunctionHandle(); + if (functionHandle.getSignature().getName().equals(TRY_CAST_NAME)) { + List arguments = call.getArguments().stream() + .map(argument -> argument.accept(this, null)) + .collect(toImmutableList()); + return call(functionHandle, call.getType(), arguments); } - Signature signature = call.getSignature(); - - switch (signature.getName()) { - // TODO: optimize these special forms - case IF: { - checkState(call.getArguments().size() == 3, "IF function should have 3 arguments. Get " + call.getArguments().size()); - RowExpression optimizedOperand = call.getArguments().get(0).accept(this, context); - if (optimizedOperand instanceof ConstantExpression) { - ConstantExpression constantOperand = (ConstantExpression) optimizedOperand; - checkState(constantOperand.getType().equals(BOOLEAN), "Operand of IF function should be BOOLEAN type. Get type " + constantOperand.getType().getDisplayName()); - if (Boolean.TRUE.equals(constantOperand.getValue())) { - return call.getArguments().get(1).accept(this, context); - } - // FALSE and NULL - else { - return call.getArguments().get(2).accept(this, context); - } - } - List arguments = call.getArguments().stream() - .map(argument -> argument.accept(this, null)) - .collect(toImmutableList()); - return call(signature, call.getType(), arguments); - } - case BIND: { - checkState(call.getArguments().size() >= 1, BIND + " function should have at least 1 argument. Got " + call.getArguments().size()); - - boolean allConstantExpression = true; - ImmutableList.Builder optimizedArgumentsBuilder = ImmutableList.builder(); - for (RowExpression argument : call.getArguments()) { - RowExpression optimizedArgument = argument.accept(this, context); - if (!(optimizedArgument instanceof ConstantExpression)) { - allConstantExpression = false; - } - optimizedArgumentsBuilder.add(optimizedArgument); - } - if (allConstantExpression) { - // Here, optimizedArguments should be merged together into a new ConstantExpression. - // It's not implemented because it would be dead code anyways because visitLambda does not produce ConstantExpression. - throw new UnsupportedOperationException(); - } - return call(signature, call.getType(), optimizedArgumentsBuilder.build()); - } - case NULL_IF: - case SWITCH: - case "WHEN": - case TRY_CAST: - case IS_NULL: - case COALESCE: - case "AND": - case "OR": - case IN: - case DEREFERENCE: - case ROW_CONSTRUCTOR: { - List arguments = call.getArguments().stream() - .map(argument -> argument.accept(this, null)) - .collect(toImmutableList()); - return call(signature, call.getType(), arguments); - } + if (functionHandle.getSignature().getName().equals(CAST.getCastName())) { + call = rewriteCast(call); + functionHandle = call.getFunctionHandle(); } - ScalarFunctionImplementation function = functionManager.getScalarFunctionImplementation(signature); + ScalarFunctionImplementation function = functionManager.getScalarFunctionImplementation(functionHandle); List arguments = call.getArguments().stream() .map(argument -> argument.accept(this, context)) .collect(toImmutableList()); @@ -201,7 +142,7 @@ public RowExpression visitCall(CallExpression call, Void context) } } - return call(signature, typeManager.getType(signature.getReturnType()), arguments); + return call(functionHandle, call.getType(), arguments); } @Override @@ -216,39 +157,103 @@ public RowExpression visitVariableReference(VariableReferenceExpression referenc return reference; } + @Override + public RowExpression visitSpecialForm(SpecialFormExpression specialForm, Void context) + { + Form form = specialForm.getForm(); + switch (form) { + // TODO: optimize these special forms + case IF: { + checkState(specialForm.getArguments().size() == 3, "IF function should have 3 arguments. Get " + specialForm.getArguments().size()); + RowExpression optimizedOperand = specialForm.getArguments().get(0).accept(this, context); + if (optimizedOperand instanceof ConstantExpression) { + ConstantExpression constantOperand = (ConstantExpression) optimizedOperand; + checkState(constantOperand.getType().equals(BOOLEAN), "Operand of IF function should be BOOLEAN type. Get type " + constantOperand.getType().getDisplayName()); + if (Boolean.TRUE.equals(constantOperand.getValue())) { + return specialForm.getArguments().get(1).accept(this, context); + } + // FALSE and NULL + else { + return specialForm.getArguments().get(2).accept(this, context); + } + } + List arguments = specialForm.getArguments().stream() + .map(argument -> argument.accept(this, null)) + .collect(toImmutableList()); + return new SpecialFormExpression(form, specialForm.getType(), arguments); + } + case BIND: { + checkState(specialForm.getArguments().size() >= 1, BIND.name() + " function should have at least 1 argument. Got " + specialForm.getArguments().size()); + + boolean allConstantExpression = true; + ImmutableList.Builder optimizedArgumentsBuilder = ImmutableList.builder(); + for (RowExpression argument : specialForm.getArguments()) { + RowExpression optimizedArgument = argument.accept(this, context); + if (!(optimizedArgument instanceof ConstantExpression)) { + allConstantExpression = false; + } + optimizedArgumentsBuilder.add(optimizedArgument); + } + if (allConstantExpression) { + // Here, optimizedArguments should be merged together into a new ConstantExpression. + // It's not implemented because it would be dead code anyways because visitLambda does not produce ConstantExpression. + throw new UnsupportedOperationException(); + } + return new SpecialFormExpression(form, specialForm.getType(), optimizedArgumentsBuilder.build()); + } + case NULL_IF: + case SWITCH: + case WHEN: + case IS_NULL: + case COALESCE: + case AND: + case OR: + case IN: + case DEREFERENCE: + case ROW_CONSTRUCTOR: { + List arguments = specialForm.getArguments().stream() + .map(argument -> argument.accept(this, null)) + .collect(toImmutableList()); + return new SpecialFormExpression(form, specialForm.getType(), arguments); + } + default: + throw new IllegalArgumentException("Unsupported special form " + specialForm.getForm()); + } + } + private CallExpression rewriteCast(CallExpression call) { if (call.getArguments().get(0) instanceof CallExpression) { // Optimization for CAST(JSON_PARSE(...) AS ARRAY/MAP/ROW) CallExpression innerCall = (CallExpression) call.getArguments().get(0); - if (innerCall.getSignature().getName().equals("json_parse")) { + if (innerCall.getFunctionHandle().getSignature().getName().equals("json_parse")) { checkArgument(innerCall.getType().equals(JSON)); checkArgument(innerCall.getArguments().size() == 1); - TypeSignature returnType = call.getSignature().getReturnType(); + TypeSignature returnType = call.getFunctionHandle().getSignature().getReturnType(); if (returnType.getBase().equals(ARRAY)) { return call( - internalScalarFunction( - JSON_STRING_TO_ARRAY_NAME, - returnType, - ImmutableList.of(parseTypeSignature(VARCHAR))), + functionManager.lookupCast( + JSON_TO_ARRAY_CAST, + parseTypeSignature(VARCHAR), + returnType), call.getType(), innerCall.getArguments()); } if (returnType.getBase().equals(MAP)) { return call( - internalScalarFunction( - JSON_STRING_TO_MAP_NAME, - returnType, - ImmutableList.of(parseTypeSignature(VARCHAR))), + functionManager.lookupCast( + JSON_TO_MAP_CAST, + parseTypeSignature(VARCHAR), + returnType), call.getType(), innerCall.getArguments()); } if (returnType.getBase().equals(ROW)) { return call( - internalScalarFunction( - JSON_STRING_TO_ROW_NAME, - returnType, - ImmutableList.of(parseTypeSignature(VARCHAR))), + functionManager.lookupCast( + JSON_TO_ROW_CAST, + parseTypeSignature(VARCHAR), + returnType), call.getType(), innerCall.getArguments()); } @@ -256,7 +261,10 @@ private CallExpression rewriteCast(CallExpression call) } return call( - functionManager.lookupCast(OperatorType.CAST, call.getArguments().get(0).getType().getTypeSignature(), call.getType().getTypeSignature()).getSignature(), + functionManager.lookupCast( + CAST, + call.getArguments().get(0).getType().getTypeSignature(), + call.getType().getTypeSignature()), call.getType(), call.getArguments()); } diff --git a/presto-main/src/main/java/com/facebook/presto/type/TypeRegistry.java b/presto-main/src/main/java/com/facebook/presto/type/TypeRegistry.java index 24029f1071bfb..a779ca8e0364c 100644 --- a/presto-main/src/main/java/com/facebook/presto/type/TypeRegistry.java +++ b/presto-main/src/main/java/com/facebook/presto/type/TypeRegistry.java @@ -72,6 +72,7 @@ import static com.facebook.presto.spi.type.VarbinaryType.VARBINARY; import static com.facebook.presto.spi.type.VarcharType.createUnboundedVarcharType; import static com.facebook.presto.spi.type.VarcharType.createVarcharType; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.type.ArrayParametricType.ARRAY; import static com.facebook.presto.type.CodePointsType.CODE_POINTS; import static com.facebook.presto.type.ColorType.COLOR; @@ -662,7 +663,7 @@ public static boolean isCovariantTypeBase(String typeBase) public MethodHandle resolveOperator(OperatorType operatorType, List argumentTypes) { requireNonNull(functionManager, "functionManager is null"); - return functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(operatorType, argumentTypes)).getMethodHandle(); + return functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(operatorType, fromTypes(argumentTypes))).getMethodHandle(); } public static class TypeCompatibility diff --git a/presto-main/src/main/java/com/facebook/presto/util/FastutilSetHelper.java b/presto-main/src/main/java/com/facebook/presto/util/FastutilSetHelper.java index c7ce65ffd4deb..d1e1364545f93 100644 --- a/presto-main/src/main/java/com/facebook/presto/util/FastutilSetHelper.java +++ b/presto-main/src/main/java/com/facebook/presto/util/FastutilSetHelper.java @@ -16,7 +16,6 @@ import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.spi.PrestoException; import com.facebook.presto.spi.type.Type; -import com.google.common.collect.ImmutableList; import it.unimi.dsi.fastutil.Hash; import it.unimi.dsi.fastutil.booleans.BooleanOpenHashSet; import it.unimi.dsi.fastutil.doubles.DoubleHash; @@ -33,6 +32,7 @@ import static com.facebook.presto.spi.StandardErrorCode.GENERIC_INTERNAL_ERROR; import static com.facebook.presto.spi.function.OperatorType.EQUAL; import static com.facebook.presto.spi.function.OperatorType.HASH_CODE; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.google.common.base.Throwables.throwIfInstanceOf; import static com.google.common.base.Verify.verify; import static java.lang.Boolean.TRUE; @@ -94,8 +94,8 @@ private static final class LongStrategy private LongStrategy(FunctionManager functionManager, Type type) { - hashCodeHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(HASH_CODE, ImmutableList.of(type))).getMethodHandle(); - equalsHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(EQUAL, ImmutableList.of(type, type))).getMethodHandle(); + hashCodeHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(HASH_CODE, fromTypes(type))).getMethodHandle(); + equalsHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(EQUAL, fromTypes(type, type))).getMethodHandle(); } @Override @@ -136,8 +136,8 @@ private static final class DoubleStrategy private DoubleStrategy(FunctionManager functionManager, Type type) { - hashCodeHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(HASH_CODE, ImmutableList.of(type))).getMethodHandle(); - equalsHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(EQUAL, ImmutableList.of(type, type))).getMethodHandle(); + hashCodeHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(HASH_CODE, fromTypes(type))).getMethodHandle(); + equalsHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(EQUAL, fromTypes(type, type))).getMethodHandle(); } @Override @@ -178,10 +178,10 @@ private static final class ObjectStrategy private ObjectStrategy(FunctionManager functionManager, Type type) { - hashCodeHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(HASH_CODE, ImmutableList.of(type))) + hashCodeHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(HASH_CODE, fromTypes(type))) .getMethodHandle() .asType(MethodType.methodType(long.class, Object.class)); - equalsHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(EQUAL, ImmutableList.of(type, type))) + equalsHandle = functionManager.getScalarFunctionImplementation(functionManager.resolveOperator(EQUAL, fromTypes(type, type))) .getMethodHandle() .asType(MethodType.methodType(Boolean.class, Object.class, Object.class)); } diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java b/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java index 5de3391b2e9ae..c3c6420e04653 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java @@ -72,7 +72,6 @@ import java.util.Optional; import java.util.function.Function; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; @@ -766,7 +765,7 @@ private AggregationNode aggregation(String id, PlanNode source) { AggregationNode.Aggregation aggregation = new AggregationNode.Aggregation( new FunctionCall(QualifiedName.of("count"), ImmutableList.of()), - metadata.getFunctionManager().resolveFunction(TEST_SESSION, QualifiedName.of("count"), ImmutableList.of()), + metadata.getFunctionManager().lookupFunction(QualifiedName.of("count"), ImmutableList.of()), Optional.empty()); return new AggregationNode( diff --git a/presto-main/src/test/java/com/facebook/presto/metadata/TestFunctionRegistry.java b/presto-main/src/test/java/com/facebook/presto/metadata/TestFunctionRegistry.java index b38d9612314cf..ecd7d80efe552 100644 --- a/presto-main/src/test/java/com/facebook/presto/metadata/TestFunctionRegistry.java +++ b/presto-main/src/test/java/com/facebook/presto/metadata/TestFunctionRegistry.java @@ -36,6 +36,7 @@ import java.lang.invoke.MethodHandles; import java.util.List; +import static com.facebook.presto.metadata.CastType.fromOperatorType; import static com.facebook.presto.metadata.OperatorSignatureUtils.mangleOperatorName; import static com.facebook.presto.metadata.OperatorSignatureUtils.unmangleOperator; import static com.facebook.presto.operator.scalar.ScalarFunctionImplementation.ArgumentProperty.valueTypeArgumentProperty; @@ -49,7 +50,6 @@ import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; import static com.facebook.presto.sql.planner.LiteralEncoder.getMagicLiteralFunctionSignature; -import static com.facebook.presto.type.TypeUtils.resolveTypes; import static com.google.common.collect.ImmutableList.toImmutableList; import static com.google.common.collect.Lists.transform; import static java.lang.String.format; @@ -67,7 +67,7 @@ public void testIdentityCast() { TypeRegistry typeManager = new TypeRegistry(); FunctionRegistry registry = createFunctionRegistry(typeManager); - FunctionHandle exactOperator = registry.lookupCast(CAST, HYPER_LOG_LOG.getTypeSignature(), HYPER_LOG_LOG.getTypeSignature()); + FunctionHandle exactOperator = registry.lookupCast(fromOperatorType(CAST), HYPER_LOG_LOG.getTypeSignature(), HYPER_LOG_LOG.getTypeSignature()); assertEquals(exactOperator, new FunctionHandle(new Signature(mangleOperatorName(CAST.name()), SCALAR, HYPER_LOG_LOG.getTypeSignature(), HYPER_LOG_LOG.getTypeSignature()))); } @@ -88,7 +88,7 @@ public void testExactMatchBeforeCoercion() if (function.getSignature().getArgumentTypes().stream().anyMatch(TypeSignature::isCalculated)) { continue; } - FunctionHandle exactOperator = registry.resolveOperator(operatorType, resolveTypes(function.getSignature().getArgumentTypes(), typeManager)); + FunctionHandle exactOperator = registry.resolveOperator(operatorType, fromTypeSignatures(function.getSignature().getArgumentTypes())); assertEquals(exactOperator.getSignature(), function.getSignature()); foundOperator = true; } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/BenchmarkHashAndStreamingAggregationOperators.java b/presto-main/src/test/java/com/facebook/presto/operator/BenchmarkHashAndStreamingAggregationOperators.java index 9256797006401..74bee8a69d16c 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/BenchmarkHashAndStreamingAggregationOperators.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/BenchmarkHashAndStreamingAggregationOperators.java @@ -84,9 +84,9 @@ public class BenchmarkHashAndStreamingAggregationOperators private static final FunctionManager functionManager = metadata.getFunctionManager(); private static final InternalAggregationFunction LONG_SUM = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(BIGINT))); + functionManager.lookupFunction(QualifiedName.of("sum"), fromTypes(BIGINT))); private static final InternalAggregationFunction COUNT = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("count"), ImmutableList.of())); + functionManager.lookupFunction(QualifiedName.of("count"), ImmutableList.of())); @State(Thread) public static class Context diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestAggregationOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestAggregationOperator.java index fa3404d9531fa..da375107f0f4d 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestAggregationOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestAggregationOperator.java @@ -164,6 +164,6 @@ private void testMemoryTracking(boolean useSystemMemory) private static InternalAggregationFunction getAggregation(String name, Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(name), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of(name), fromTypes(arguments))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestAnnotationEngineForAggregates.java b/presto-main/src/test/java/com/facebook/presto/operator/TestAnnotationEngineForAggregates.java index 5779263eb6453..6c81e492f0a66 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestAnnotationEngineForAggregates.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestAnnotationEngineForAggregates.java @@ -49,7 +49,6 @@ import com.facebook.presto.spi.function.TypeParameter; import com.facebook.presto.spi.function.TypeParameterSpecialization; import com.facebook.presto.spi.type.DoubleType; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeManager; import com.facebook.presto.spi.type.TypeSignature; @@ -756,7 +755,7 @@ public static class InjectOperatorAggregateFunction { @InputFunction public static void input( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle, @AggregationState NullableDoubleState state, @SqlType(DOUBLE) double value) { @@ -765,7 +764,7 @@ public static void input( @CombineFunction public static void combine( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle, @AggregationState NullableDoubleState combine1, @AggregationState NullableDoubleState combine2) { @@ -774,7 +773,7 @@ public static void combine( @OutputFunction(DOUBLE) public static void output( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle, + @OperatorDependency(operator = LESS_THAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle, @AggregationState NullableDoubleState state, BlockBuilder out) { @@ -783,7 +782,7 @@ public static void output( @AggregationStateSerializerFactory(NullableDoubleState.class) public static CustomStateSerializerAggregationFunction.CustomSerializer createSerializer( - @OperatorDependency(operator = LESS_THAN, returnType = StandardTypes.BOOLEAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle) + @OperatorDependency(operator = LESS_THAN, argumentTypes = {DOUBLE, DOUBLE}) MethodHandle methodHandle) { return new CustomStateSerializerAggregationFunction.CustomSerializer(); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestFilterAndProjectOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestFilterAndProjectOperator.java index f36f3f5cb7e58..1a164d56c5df8 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestFilterAndProjectOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestFilterAndProjectOperator.java @@ -13,7 +13,7 @@ */ package com.facebook.presto.operator; -import com.facebook.presto.metadata.InternalSignatureUtils; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; @@ -44,6 +44,7 @@ import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -86,8 +87,10 @@ public void test() .addSequencePage(100, 0, 0) .build(); + MetadataManager metadata = createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); RowExpression filter = call( - InternalSignatureUtils.internalOperator(BETWEEN, BOOLEAN.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature())), + functionManager.resolveOperator(BETWEEN, fromTypes(BIGINT, BIGINT, BIGINT)), BOOLEAN, field(1, BIGINT), constant(10L, BIGINT), @@ -95,12 +98,11 @@ public void test() RowExpression field0 = field(0, VARCHAR); RowExpression add5 = call( - InternalSignatureUtils.internalOperator(ADD, BIGINT.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), BIGINT.getTypeSignature())), + functionManager.resolveOperator(ADD, fromTypes(BIGINT, BIGINT)), BIGINT, field(1, BIGINT), constant(5L, BIGINT)); - MetadataManager metadata = createTestMetadataManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); Supplier processor = compiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field0, add5)); @@ -137,14 +139,14 @@ public void testMergeOutput() .addSequencePage(100, 0, 0) .addSequencePage(100, 0, 0) .build(); + MetadataManager metadata = createTestMetadataManager(); RowExpression filter = call( - InternalSignatureUtils.internalOperator(EQUAL, BOOLEAN.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), BIGINT.getTypeSignature())), + metadata.getFunctionManager().resolveOperator(EQUAL, fromTypes(BIGINT, BIGINT)), BOOLEAN, field(1, BIGINT), constant(10L, BIGINT)); - MetadataManager metadata = createTestMetadataManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); Supplier processor = compiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field(1, BIGINT))); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestHashAggregationOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestHashAggregationOperator.java index 514ac83fdf97b..fd7ace6234ae2 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestHashAggregationOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestHashAggregationOperator.java @@ -100,7 +100,7 @@ public class TestHashAggregationOperator private static final InternalAggregationFunction LONG_AVERAGE = getAggregation("avg", BIGINT); private static final InternalAggregationFunction LONG_SUM = getAggregation("sum", BIGINT); private static final InternalAggregationFunction COUNT = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("count"), ImmutableList.of())); + functionManager.lookupFunction(QualifiedName.of("count"), ImmutableList.of())); private static final int MAX_BLOCK_SIZE_IN_BYTES = 64 * 1024; @@ -739,7 +739,7 @@ private int getHashCapacity(Operator operator) private static InternalAggregationFunction getAggregation(String name, Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(name), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of(name), fromTypes(arguments))); } private static class DummySpillerFactory diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestRealAverageAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/TestRealAverageAggregation.java index c1f96e31bec8a..3393d8fe9683a 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestRealAverageAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestRealAverageAggregation.java @@ -27,7 +27,6 @@ import java.util.List; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createBlockOfReals; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.assertAggregation; import static com.facebook.presto.spi.type.RealType.REAL; @@ -45,7 +44,7 @@ public void setUp() { FunctionManager functionManager = MetadataManager.createTestMetadataManager().getFunctionManager(); avgFunction = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("avg"), fromTypes(REAL))); + functionManager.lookupFunction(QualifiedName.of("avg"), fromTypes(REAL))); } @Test diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestScanFilterAndProjectOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestScanFilterAndProjectOperator.java index cb6d199e8ed79..c9a34416eaad1 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestScanFilterAndProjectOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestScanFilterAndProjectOperator.java @@ -16,7 +16,7 @@ import com.facebook.presto.SequencePageBuilder; import com.facebook.presto.block.BlockAssertions; import com.facebook.presto.connector.ConnectorId; -import com.facebook.presto.metadata.InternalSignatureUtils; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.Metadata; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.metadata.Split; @@ -37,6 +37,7 @@ import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.planner.plan.PlanNodeId; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.facebook.presto.testing.MaterializedResult; import com.facebook.presto.testing.TestingSplit; import com.facebook.presto.testing.TestingTransactionHandle; @@ -53,7 +54,6 @@ import static com.facebook.presto.RowPagesBuilder.rowPagesBuilder; import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.toValues; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.OperatorAssertion.toMaterializedResult; import static com.facebook.presto.operator.PageAssertions.assertPageEquals; @@ -62,6 +62,7 @@ import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -135,7 +136,7 @@ public void testPageSourceMergeOutput() .build(); RowExpression filter = call( - InternalSignatureUtils.internalOperator(EQUAL, BOOLEAN.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), BIGINT.getTypeSignature())), + createTestMetadataManager().getFunctionManager().resolveOperator(EQUAL, fromTypes(BIGINT, BIGINT)), BOOLEAN, field(0, BIGINT), constant(10L, BIGINT)); @@ -259,13 +260,14 @@ public void testPageYield() })); } Metadata metadata = functionAssertions.getMetadata(); - metadata.getFunctionManager().addFunctions(functions.build()); + FunctionManager functionManager = metadata.getFunctionManager(); + functionManager.addFunctions(functions.build()); // match each column with a projection ExpressionCompiler expressionCompiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder projections = ImmutableList.builder(); for (int i = 0; i < totalColumns; i++) { - projections.add(call(internalScalarFunction("generic_long_page_col" + i, BIGINT.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature())), BIGINT, field(0, BIGINT))); + projections.add(call(functionManager.lookupFunction(QualifiedName.of("generic_long_page_col" + i), fromTypes(BIGINT)), BIGINT, field(0, BIGINT))); } Supplier cursorProcessor = expressionCompiler.compileCursorProcessor(Optional.empty(), projections.build(), "key"); Supplier pageProcessor = expressionCompiler.compilePageProcessor(Optional.empty(), projections.build(), MAX_BATCH_SIZE); @@ -321,14 +323,15 @@ public void testRecordCursorYield() // set up generic long function with a callback to force yield Metadata metadata = functionAssertions.getMetadata(); - metadata.getFunctionManager().addFunctions(ImmutableList.of(new GenericLongFunction("record_cursor", value -> { + FunctionManager functionManager = metadata.getFunctionManager(); + functionManager.addFunctions(ImmutableList.of(new GenericLongFunction("record_cursor", value -> { driverContext.getYieldSignal().forceYieldForTesting(); return value; }))); ExpressionCompiler expressionCompiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); List projections = ImmutableList.of(call( - InternalSignatureUtils.internalScalarFunction("generic_long_record_cursor", BIGINT.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature())), + functionManager.lookupFunction(QualifiedName.of("generic_long_record_cursor"), fromTypes(BIGINT)), BIGINT, field(0, BIGINT))); Supplier cursorProcessor = expressionCompiler.compileCursorProcessor(Optional.empty(), projections, "key"); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestStreamingAggregationOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestStreamingAggregationOperator.java index 3172c847399ac..93dde1f24d068 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestStreamingAggregationOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestStreamingAggregationOperator.java @@ -54,9 +54,9 @@ public class TestStreamingAggregationOperator private static final FunctionManager functionManager = MetadataManager.createTestMetadataManager().getFunctionManager(); private static final InternalAggregationFunction LONG_SUM = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(BIGINT))); + functionManager.lookupFunction(QualifiedName.of("sum"), fromTypes(BIGINT))); private static final InternalAggregationFunction COUNT = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("count"), ImmutableList.of())); + functionManager.lookupFunction(QualifiedName.of("count"), ImmutableList.of())); private ExecutorService executor; private ScheduledExecutorService scheduledExecutor; diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestTableFinishOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestTableFinishOperator.java index a56b7322da32f..b4b7fdbcf1c9b 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestTableFinishOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestTableFinishOperator.java @@ -42,7 +42,6 @@ import java.util.concurrent.ScheduledExecutorService; import static com.facebook.presto.RowPagesBuilder.rowPagesBuilder; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.assertBlockEquals; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.PageAssertions.assertPageEquals; @@ -67,7 +66,7 @@ public class TestTableFinishOperator { private static final FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); private static final InternalAggregationFunction LONG_MAX = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("max"), fromTypes(BIGINT))); + functionManager.lookupFunction(QualifiedName.of("max"), fromTypes(BIGINT))); private ScheduledExecutorService scheduledExecutor; diff --git a/presto-main/src/test/java/com/facebook/presto/operator/TestTableWriterOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/TestTableWriterOperator.java index 174dd72b5af77..4db39e78a7ca6 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/TestTableWriterOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/TestTableWriterOperator.java @@ -202,7 +202,7 @@ public void testStatisticsAggregation() .addDriverContext(); FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); InternalAggregationFunction longMaxFunction = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("max"), fromTypes(BIGINT))); + functionManager.lookupFunction(QualifiedName.of("max"), fromTypes(BIGINT))); TableWriterOperator operator = (TableWriterOperator) createTableWriterOperator( pageSinkManager, new AggregationOperatorFactory( diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkArrayAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkArrayAggregation.java index 3181c6968a083..bedbf43ca5818 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkArrayAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkArrayAggregation.java @@ -45,7 +45,6 @@ import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeUnit; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -107,7 +106,7 @@ public void setup() } ArrayType arrayType = new ArrayType(elementType); InternalAggregationFunction function = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(name), fromTypes(elementType))); + functionManager.lookupFunction(QualifiedName.of(name), fromTypes(elementType))); accumulator = function.bind(ImmutableList.of(0), Optional.empty()).createAccumulator(); block = createChannel(ARRAY_SIZE, elementType); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkGroupedTypedHistogram.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkGroupedTypedHistogram.java index 791071aa0bec3..2a46f554fa1bd 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkGroupedTypedHistogram.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/BenchmarkGroupedTypedHistogram.java @@ -47,7 +47,6 @@ import java.util.stream.Collectors; import java.util.stream.IntStream; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createStringsBlock; import static com.facebook.presto.operator.aggregation.histogram.Histogram.NAME; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; @@ -159,7 +158,7 @@ private static InternalAggregationFunction getInternalAggregationFunctionVarChar FunctionManager functionManager = getMetadata(groupMode).getFunctionManager(); return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(VARCHAR))); + functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(VARCHAR))); } private static MetadataManager getMetadata(HistogramGroupImplementation groupMode) diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctBoolean.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctBoolean.java index 79628906387df..185b23ab72a3b 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctBoolean.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctBoolean.java @@ -24,7 +24,6 @@ import java.util.List; import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -36,7 +35,7 @@ public class TestApproximateCountDistinctBoolean public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(BOOLEAN, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(BOOLEAN, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctDouble.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctDouble.java index 5ea1caa6104e1..9d5d6af4e7084 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctDouble.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctDouble.java @@ -18,7 +18,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -29,7 +28,7 @@ public class TestApproximateCountDistinctDouble public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(DOUBLE, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(DOUBLE, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctInteger.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctInteger.java index 86f1d5afa71a8..52d522f7fc677 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctInteger.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctInteger.java @@ -18,7 +18,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.IntegerType.INTEGER; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -30,7 +29,7 @@ public class TestApproximateCountDistinctInteger public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(INTEGER, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(INTEGER, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctIpAddress.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctIpAddress.java index 354e6eed8ae93..09cca15a61684 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctIpAddress.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctIpAddress.java @@ -19,7 +19,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.type.IpAddressType.IPADDRESS; @@ -31,7 +30,7 @@ public class TestApproximateCountDistinctIpAddress public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(IPADDRESS, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(IPADDRESS, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLong.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLong.java index fbd8eb8135676..d2052505aa0b8 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLong.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLong.java @@ -18,7 +18,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -30,7 +29,7 @@ public class TestApproximateCountDistinctLong public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(BIGINT, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(BIGINT, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLongDecimal.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLongDecimal.java index db4a85daefe5e..a6767bd765a07 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLongDecimal.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctLongDecimal.java @@ -19,7 +19,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DecimalType.createDecimalType; import static com.facebook.presto.spi.type.Decimals.MAX_PRECISION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -34,7 +33,7 @@ public class TestApproximateCountDistinctLongDecimal public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(LONG_DECIMAL, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(LONG_DECIMAL, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctSmallint.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctSmallint.java index ee4d1a3351217..ae2518c6d38fb 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctSmallint.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctSmallint.java @@ -18,7 +18,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.SmallintType.SMALLINT; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -30,7 +29,7 @@ public class TestApproximateCountDistinctSmallint public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(SMALLINT, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(SMALLINT, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctTinyint.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctTinyint.java index 973c21d3375c2..e07e52692d93f 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctTinyint.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctTinyint.java @@ -18,7 +18,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.TinyintType.TINYINT; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -30,7 +29,7 @@ public class TestApproximateCountDistinctTinyint public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(TINYINT, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(TINYINT, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctVarBinary.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctVarBinary.java index 6fbf85ab9b668..b71bd13c7b17a 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctVarBinary.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximateCountDistinctVarBinary.java @@ -19,7 +19,6 @@ import java.util.concurrent.ThreadLocalRandom; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -31,7 +30,7 @@ public class TestApproximateCountDistinctVarBinary public InternalAggregationFunction getAggregationFunction() { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_distinct"), fromTypes(VARCHAR, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("approx_distinct"), fromTypes(VARCHAR, DOUBLE))); } @Override diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximatePercentileAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximatePercentileAggregation.java index fcdd954ecb1dd..38ab4bba02d0d 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximatePercentileAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestApproximatePercentileAggregation.java @@ -23,7 +23,6 @@ import com.google.common.collect.ImmutableList; import org.testng.annotations.Test; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createBlockOfReals; import static com.facebook.presto.block.BlockAssertions.createDoubleSequenceBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; @@ -445,7 +444,7 @@ public void testDoublePartialStep() private static InternalAggregationFunction getAggregation(Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("approx_percentile"), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of("approx_percentile"), fromTypes(arguments))); } private static RunLengthEncodedBlock createRLEBlock(double percentile, int positionCount) diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArbitraryAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArbitraryAggregation.java index 18f5ed1a26a8a..48976549de8d0 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArbitraryAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArbitraryAggregation.java @@ -24,7 +24,6 @@ import java.util.Arrays; import java.util.Set; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createArrayBigintBlock; import static com.facebook.presto.block.BlockAssertions.createBooleansBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; @@ -168,6 +167,6 @@ public void testValidInt() private static InternalAggregationFunction getAggregation(Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("arbitrary"), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of("arbitrary"), fromTypes(arguments))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArrayAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArrayAggregation.java index 7d2b868606774..cd09c43ca8f91 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArrayAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestArrayAggregation.java @@ -35,7 +35,6 @@ import java.util.Optional; import java.util.Random; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createArrayBigintBlock; import static com.facebook.presto.block.BlockAssertions.createBooleansBlock; import static com.facebook.presto.block.BlockAssertions.createLongsBlock; @@ -225,6 +224,6 @@ private GroupedAccumulator createGroupedAccumulator(InternalAggregationFunction private InternalAggregationFunction getAggregation(Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("array_agg"), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of("array_agg"), fromTypes(arguments))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestChecksumAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestChecksumAggregation.java index 274dabce8d69c..eb082ddc16f24 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestChecksumAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestChecksumAggregation.java @@ -23,7 +23,6 @@ import com.facebook.presto.sql.tree.QualifiedName; import org.testng.annotations.Test; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createArrayBigintBlock; import static com.facebook.presto.block.BlockAssertions.createBooleansBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; @@ -128,6 +127,6 @@ private static SqlVarbinary expectedChecksum(Type type, Block block) private InternalAggregationFunction getAggregation(Type argument) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("checksum"), fromTypes(argument))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of("checksum"), fromTypes(argument))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestDoubleHistogramAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestDoubleHistogramAggregation.java index bae7de379def5..4285c477201b3 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestDoubleHistogramAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestDoubleHistogramAggregation.java @@ -28,7 +28,6 @@ import java.util.Map; import java.util.Optional; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.getFinalBlock; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.getIntermediateBlock; import static com.facebook.presto.spi.type.BigintType.BIGINT; @@ -47,7 +46,7 @@ public TestDoubleHistogramAggregation() { FunctionManager functionManager = MetadataManager.createTestMetadataManager().getFunctionManager(); InternalAggregationFunction function = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("numeric_histogram"), fromTypes(BIGINT, DOUBLE, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("numeric_histogram"), fromTypes(BIGINT, DOUBLE, DOUBLE))); factory = function.bind(ImmutableList.of(0, 1, 2), Optional.empty()); input = makeInput(10); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestHistogram.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestHistogram.java index 23ca80c7c094c..75864541d7c66 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestHistogram.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestHistogram.java @@ -47,7 +47,6 @@ import java.util.stream.Collectors; import java.util.stream.IntStream; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createBooleansBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; import static com.facebook.presto.block.BlockAssertions.createLongsBlock; @@ -391,7 +390,7 @@ private InternalAggregationFunction getInternalDefaultVarCharAggregationn() private InternalAggregationFunction getAggregation(Type... arguments) { FunctionManager functionManager = getFunctionManager(NEW); - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(arguments))); } public FunctionManager getFunctionManager() diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapAggAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapAggAggregation.java index acc30da22ee00..e48abe2ec85e3 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapAggAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapAggAggregation.java @@ -28,7 +28,6 @@ import java.util.LinkedHashMap; import java.util.Map; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createBooleansBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; import static com.facebook.presto.block.BlockAssertions.createStringArraysBlock; @@ -190,6 +189,6 @@ public void testArrayDoubleMap() private InternalAggregationFunction getAggregation(Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(arguments))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapUnionAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapUnionAggregation.java index e45772ed9d02a..34d3ef25549ff 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapUnionAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMapUnionAggregation.java @@ -26,7 +26,6 @@ import java.util.HashMap; import java.util.Map; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.assertAggregation; import static com.facebook.presto.operator.aggregation.MapUnionAggregation.NAME; import static com.facebook.presto.spi.type.BigintType.BIGINT; @@ -47,7 +46,7 @@ public class TestMapUnionAggregation public void testSimpleWithDuplicates() { MapType mapType = mapType(DOUBLE, VARCHAR); - FunctionHandle functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); InternalAggregationFunction aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); assertAggregation( aggFunc, @@ -58,7 +57,7 @@ public void testSimpleWithDuplicates() mapBlockOf(DOUBLE, VARCHAR, ImmutableMap.of(43.0, "ccc", 53.0, "ddd", 13.0, "eee")))); mapType = mapType(DOUBLE, BIGINT); - functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); assertAggregation( aggFunc, @@ -69,7 +68,7 @@ public void testSimpleWithDuplicates() mapBlockOf(DOUBLE, BIGINT, ImmutableMap.of(1.0, 44L, 2.0, 44L, 4.0, 44L)))); mapType = mapType(BOOLEAN, BIGINT); - functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); assertAggregation( aggFunc, @@ -84,7 +83,7 @@ public void testSimpleWithDuplicates() public void testSimpleWithNulls() { MapType mapType = mapType(DOUBLE, VARCHAR); - FunctionHandle functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); InternalAggregationFunction aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); Map expected = mapOf(23.0, "aaa", 33.0, null, 43.0, "ccc", 53.0, "ddd"); @@ -103,7 +102,7 @@ public void testSimpleWithNulls() public void testStructural() { MapType mapType = mapType(DOUBLE, new ArrayType(VARCHAR)); - FunctionHandle functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); InternalAggregationFunction aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); assertAggregation( aggFunc, @@ -136,7 +135,7 @@ public void testStructural() ImmutableList.of("w", "z"))))); mapType = mapType(DOUBLE, mapType(VARCHAR, VARCHAR)); - functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); assertAggregation( aggFunc, @@ -162,7 +161,7 @@ public void testStructural() ImmutableMap.of("e", "f"))))); mapType = mapType(new ArrayType(VARCHAR), DOUBLE); - functionHandle = functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(mapType)); + functionHandle = functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(mapType)); aggFunc = functionManager.getAggregateFunctionImplementation(functionHandle); assertAggregation( aggFunc, diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMultimapAggAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMultimapAggAggregation.java index 030dbca4eea64..b4bf501f4e264 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMultimapAggAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestMultimapAggAggregation.java @@ -39,7 +39,6 @@ import java.util.Optional; import java.util.Random; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.assertAggregation; import static com.facebook.presto.operator.aggregation.multimapagg.MultimapAggregationFunction.NAME; @@ -183,7 +182,7 @@ private static void testMultimapAgg(Type keyType, List expectedKeys, T private static InternalAggregationFunction getInternalAggregationFunction(Type keyType, Type valueType) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of(NAME), fromTypes(keyType, valueType))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of(NAME), fromTypes(keyType, valueType))); } private static void testMultimapAgg(InternalAggregationFunction aggFunc, Type keyType, List expectedKeys, Type valueType, List expectedValues) diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestQuantileDigestAggregationFunction.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestQuantileDigestAggregationFunction.java index d7e72c4396fa1..b9e4f52f3a586 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestQuantileDigestAggregationFunction.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestQuantileDigestAggregationFunction.java @@ -33,7 +33,6 @@ import java.util.stream.Collectors; import java.util.stream.LongStream; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createBlockOfReals; import static com.facebook.presto.block.BlockAssertions.createDoubleSequenceBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; @@ -169,7 +168,7 @@ private InternalAggregationFunction getAggregationFunction(Type... type) { FunctionManager functionManager = METADATA.getFunctionManager(); return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("qdigest_agg"), fromTypes(type))); + functionManager.lookupFunction(QualifiedName.of("qdigest_agg"), fromTypes(type))); } private void testAggregationBigint(Block inputBlock, Block weightsBlock, double maxError, long... inputs) diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestRealHistogramAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestRealHistogramAggregation.java index ae19d0f9cddff..9a18187389115 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestRealHistogramAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/TestRealHistogramAggregation.java @@ -30,7 +30,6 @@ import java.util.Map; import java.util.Optional; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.getFinalBlock; import static com.facebook.presto.operator.aggregation.AggregationTestUtils.getIntermediateBlock; import static com.facebook.presto.spi.type.BigintType.BIGINT; @@ -51,7 +50,7 @@ public TestRealHistogramAggregation() TypeRegistry typeRegistry = new TypeRegistry(); FunctionManager functionManager = new FunctionManager(typeRegistry, new BlockEncodingManager(typeRegistry), new FeaturesConfig()); InternalAggregationFunction function = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("numeric_histogram"), fromTypes(BIGINT, REAL, DOUBLE))); + functionManager.lookupFunction(QualifiedName.of("numeric_histogram"), fromTypes(BIGINT, REAL, DOUBLE))); factory = function.bind(ImmutableList.of(0, 1, 2), Optional.empty()); input = makeInput(10); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByAggregation.java index 0584ab79a68c4..978e6cfb04c66 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByAggregation.java @@ -28,7 +28,6 @@ import java.util.List; import java.util.Set; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createArrayBigintBlock; import static com.facebook.presto.block.BlockAssertions.createBooleansBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; @@ -579,11 +578,11 @@ public void testMaxUnknownLongArray() private InternalAggregationFunction getMinByAggregation(Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("min_by"), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of("min_by"), fromTypes(arguments))); } private InternalAggregationFunction getMaxByAggregation(Type... arguments) { - return functionManager.getAggregateFunctionImplementation(functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("max_by"), fromTypes(arguments))); + return functionManager.getAggregateFunctionImplementation(functionManager.lookupFunction(QualifiedName.of("max_by"), fromTypes(arguments))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByNAggregation.java b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByNAggregation.java index 74a969fb71fd2..2f008a1868b1a 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByNAggregation.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/aggregation/minmaxby/TestMinMaxByNAggregation.java @@ -26,7 +26,6 @@ import java.util.Arrays; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.createArrayBigintBlock; import static com.facebook.presto.block.BlockAssertions.createDoublesBlock; import static com.facebook.presto.block.BlockAssertions.createLongsBlock; @@ -298,12 +297,12 @@ public void testOutOfBound() private InternalAggregationFunction getMaxByAggregation(Type... arguments) { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("max_by"), fromTypes(arguments))); + functionManager.lookupFunction(QualifiedName.of("max_by"), fromTypes(arguments))); } private InternalAggregationFunction getMinByAggregation(Type... arguments) { return functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("min_by"), fromTypes(arguments))); + functionManager.lookupFunction(QualifiedName.of("min_by"), fromTypes(arguments))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/project/TestPageProcessor.java b/presto-main/src/test/java/com/facebook/presto/operator/project/TestPageProcessor.java index ac2495a5eaae2..1fad8da19f17f 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/project/TestPageProcessor.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/project/TestPageProcessor.java @@ -15,6 +15,7 @@ import com.facebook.presto.memory.context.AggregatedMemoryContext; import com.facebook.presto.memory.context.LocalMemoryContext; +import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.CompletedWork; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.Work; @@ -49,7 +50,6 @@ import static com.facebook.presto.block.BlockAssertions.createStringsBlock; import static com.facebook.presto.execution.executor.PrioritizedSplitRunner.SPLIT_RUN_QUANTA; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.PageAssertions.assertPageEquals; import static com.facebook.presto.operator.project.PageProcessor.MAX_BATCH_SIZE; @@ -59,6 +59,7 @@ import static com.facebook.presto.spi.function.OperatorType.ADD; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -383,14 +384,15 @@ public void testYieldProjection() @Test public void testExpressionProfiler() { + MetadataManager metadata = createTestMetadataManager(); CallExpression add10Expression = call( - internalOperator(ADD, BIGINT.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), BIGINT.getTypeSignature())), + metadata.getFunctionManager().resolveOperator(ADD, fromTypes(BIGINT, BIGINT)), BIGINT, field(0, BIGINT), constant(10L, BIGINT)); TestingTicker testingTicker = new TestingTicker(); - PageFunctionCompiler functionCompiler = new PageFunctionCompiler(createTestMetadataManager(), 0); + PageFunctionCompiler functionCompiler = new PageFunctionCompiler(metadata, 0); Supplier projectionSupplier = functionCompiler.compileProjection(add10Expression, Optional.empty()); PageProjection projection = projectionSupplier.get(); Page page = new Page(createLongSequenceBlock(1, 11)); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayDistinct.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayDistinct.java index e862a6aee14fe..a238b5627d4a2 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayDistinct.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayDistinct.java @@ -13,6 +13,7 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.aggregation.TypedSet; @@ -20,9 +21,8 @@ import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.ScalarFunction; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.Type; @@ -30,6 +30,7 @@ import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.base.Verify; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slices; @@ -58,6 +59,7 @@ import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; import static com.facebook.presto.metadata.FunctionExtractor.extractFunctions; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -105,6 +107,7 @@ public static class BenchmarkData public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); metadata.addFunctions(extractFunctions(BenchmarkArrayDistinct.class)); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); @@ -112,8 +115,8 @@ public void setup() for (int i = 0; i < TYPES.size(); i++) { Type elementType = TYPES.get(i); ArrayType arrayType = new ArrayType(elementType); - Signature signature = new Signature(name, FunctionKind.SCALAR, arrayType.getTypeSignature(), arrayType.getTypeSignature()); - projectionsBuilder.add(new CallExpression(signature, arrayType, ImmutableList.of(field(i, arrayType)))); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(name), fromTypes(arrayType)); + projectionsBuilder.add(new CallExpression(functionHandle, arrayType, ImmutableList.of(field(i, arrayType)))); blocks[i] = createChannel(POSITIONS, ARRAY_SIZE, arrayType); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayFilter.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayFilter.java index ee51cee9335e8..376ce97b1ee27 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayFilter.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayFilter.java @@ -23,6 +23,7 @@ import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.FunctionKind; import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.ArrayType; @@ -34,6 +35,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.base.Verify; import com.google.common.collect.ImmutableList; import org.openjdk.jmh.annotations.Benchmark; @@ -69,6 +71,8 @@ import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.readNativeValue; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -120,6 +124,7 @@ public static class BenchmarkData public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); metadata.addFunctions(new FunctionListBuilder().function(EXACT_ARRAY_FILTER_FUNCTION).getFunctions()); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); @@ -127,9 +132,9 @@ public void setup() for (int i = 0; i < TYPES.size(); i++) { Type elementType = TYPES.get(i); ArrayType arrayType = new ArrayType(elementType); - Signature signature = new Signature(name, FunctionKind.SCALAR, arrayType.getTypeSignature(), arrayType.getTypeSignature(), parseTypeSignature("function(bigint,boolean)")); - Signature greaterThan = new Signature("$operator$" + GREATER_THAN.name(), FunctionKind.SCALAR, BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()); - projectionsBuilder.add(new CallExpression(signature, arrayType, ImmutableList.of( + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(name), fromTypeSignatures(arrayType.getTypeSignature(), parseTypeSignature("function(bigint,boolean)"))); + FunctionHandle greaterThan = functionManager.resolveOperator(GREATER_THAN, fromTypes(BIGINT, BIGINT)); + projectionsBuilder.add(new CallExpression(functionHandle, arrayType, ImmutableList.of( field(0, arrayType), new LambdaDefinitionExpression( ImmutableList.of(BIGINT), diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayHashCodeOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayHashCodeOperator.java index f53263ac14340..8cc06e51e8f4e 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayHashCodeOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayHashCodeOperator.java @@ -14,6 +14,7 @@ package com.facebook.presto.operator.scalar; import com.facebook.presto.metadata.FunctionListBuilder; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; @@ -21,10 +22,9 @@ import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; import com.facebook.presto.spi.function.Description; -import com.facebook.presto.spi.function.FunctionKind; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.OperatorDependency; import com.facebook.presto.spi.function.ScalarFunction; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.function.TypeParameter; import com.facebook.presto.spi.type.ArrayType; @@ -34,6 +34,7 @@ import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slices; import org.openjdk.jmh.annotations.Benchmark; @@ -69,6 +70,7 @@ import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; import static com.facebook.presto.type.TypeUtils.checkElementNotNull; @@ -116,6 +118,7 @@ public static class BenchmarkData public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); metadata.addFunctions(new FunctionListBuilder().scalar(BenchmarkOldArrayHash.class).getFunctions()); metadata.addFunctions(new FunctionListBuilder().scalar(BenchmarkAnotherArrayHash.class).getFunctions()); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); @@ -139,8 +142,8 @@ public void setup() throw new UnsupportedOperationException(); } ArrayType arrayType = new ArrayType(elementType); - Signature signature = new Signature(name, FunctionKind.SCALAR, BIGINT.getTypeSignature(), arrayType.getTypeSignature()); - projectionsBuilder.add(new CallExpression(signature, BIGINT, ImmutableList.of(field(0, arrayType)))); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(name), fromTypes(arrayType)); + projectionsBuilder.add(new CallExpression(functionHandle, BIGINT, ImmutableList.of(field(0, arrayType)))); blocks[0] = createChannel(POSITIONS, ARRAY_SIZE, arrayType); ImmutableList projections = projectionsBuilder.build(); @@ -211,7 +214,7 @@ private BenchmarkOldArrayHash() {} @TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long oldHash( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = "T") MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = "T") MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { @@ -233,7 +236,7 @@ private BenchmarkAnotherArrayHash() {} @TypeParameter("T") @SqlType(StandardTypes.BIGINT) public static long anotherHash( - @OperatorDependency(operator = HASH_CODE, returnType = StandardTypes.BIGINT, argumentTypes = "T") MethodHandle hashFunction, + @OperatorDependency(operator = HASH_CODE, argumentTypes = "T") MethodHandle hashFunction, @TypeParameter("T") Type type, @SqlType("array(T)") Block block) { diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayIntersect.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayIntersect.java index 44d93be7a3c24..d8892854afe51 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayIntersect.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayIntersect.java @@ -13,20 +13,21 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slices; import org.openjdk.jmh.annotations.Benchmark; @@ -53,10 +54,12 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -119,11 +122,12 @@ public void setup() } ArrayType arrayType = new ArrayType(elementType); - Signature signature = new Signature(name, FunctionKind.SCALAR, arrayType.getTypeSignature(), arrayType.getTypeSignature(), arrayType.getTypeSignature()); + MetadataManager metadata = createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of(name), fromTypes(arrayType, arrayType)); ImmutableList projections = ImmutableList.of( - new CallExpression(signature, arrayType, ImmutableList.of(field(0, arrayType), field(1, arrayType)))); + new CallExpression(functionHandle, arrayType, ImmutableList.of(field(0, arrayType), field(1, arrayType)))); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); pageProcessor = compiler.compilePageProcessor(Optional.empty(), projections).get(); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayJoin.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayJoin.java index 48b009ec47b1d..aba7c4bc1213a 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayJoin.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayJoin.java @@ -13,19 +13,20 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slices; import org.openjdk.jmh.annotations.Benchmark; @@ -49,8 +50,10 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -88,14 +91,15 @@ public static class BenchmarkData @Setup public void setup() { - Signature signature = new Signature("array_join", FunctionKind.SCALAR, VARCHAR.getTypeSignature(), new ArrayType(BIGINT).getTypeSignature(), VARCHAR.getTypeSignature()); + MetadataManager metadata = createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of("array_join"), fromTypes(new ArrayType(BIGINT), VARCHAR)); List projections = ImmutableList.of( - new CallExpression(signature, VARCHAR, ImmutableList.of( + new CallExpression(functionHandle, VARCHAR, ImmutableList.of( field(0, new ArrayType(BIGINT)), constant(Slices.wrappedBuffer(",".getBytes(UTF_8)), VARCHAR)))); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); pageProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)) .compilePageProcessor(Optional.empty(), projections) .get(); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySort.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySort.java index e7126282340d1..a1566ec24f01d 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySort.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySort.java @@ -19,9 +19,8 @@ import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.function.ScalarFunction; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.function.SqlType; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.Type; @@ -29,6 +28,7 @@ import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.base.Verify; import com.google.common.collect.ImmutableList; import com.google.common.primitives.Ints; @@ -58,6 +58,7 @@ import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; import static com.facebook.presto.metadata.FunctionExtractor.extractFunctions; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -112,8 +113,8 @@ public void setup() for (int i = 0; i < TYPES.size(); i++) { Type elementType = TYPES.get(i); ArrayType arrayType = new ArrayType(elementType); - Signature signature = new Signature(name, FunctionKind.SCALAR, arrayType.getTypeSignature(), arrayType.getTypeSignature()); - projectionsBuilder.add(new CallExpression(signature, arrayType, ImmutableList.of(field(i, arrayType)))); + FunctionHandle functionHandle = metadata.getFunctionManager().lookupFunction(QualifiedName.of(name), fromTypes(arrayType)); + projectionsBuilder.add(new CallExpression(functionHandle, arrayType, ImmutableList.of(field(i, arrayType)))); blocks[i] = createChannel(POSITIONS, ARRAY_SIZE, arrayType); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySubscript.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySubscript.java index 94201c5d0aa27..d6be09a2c19e3 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySubscript.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArraySubscript.java @@ -21,8 +21,7 @@ import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; import com.facebook.presto.spi.block.DictionaryBlock; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; @@ -61,6 +60,7 @@ import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.createUnboundedVarcharType; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -135,15 +135,10 @@ public void setup() ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); - Signature signature = new Signature( - "$operator$" + SUBSCRIPT.name(), - FunctionKind.SCALAR, - arrayType.getElementType().getTypeSignature(), - arrayType.getTypeSignature(), - BIGINT.getTypeSignature()); + FunctionHandle functionHandle = metadata.getFunctionManager().resolveOperator(SUBSCRIPT, fromTypes(arrayType, BIGINT)); for (int i = 0; i < arraySize; i++) { projectionsBuilder.add(new CallExpression( - signature, + functionHandle, arrayType.getElementType(), ImmutableList.of(field(0, arrayType), constant((long) i + 1, BIGINT)))); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayTransform.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayTransform.java index 7e707999ec674..8e7029aee69e9 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayTransform.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkArrayTransform.java @@ -13,6 +13,7 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; @@ -20,8 +21,7 @@ import com.facebook.presto.spi.PageBuilder; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; @@ -32,6 +32,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.base.Verify; import com.google.common.collect.ImmutableList; import org.openjdk.jmh.annotations.Benchmark; @@ -61,6 +62,8 @@ import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @SuppressWarnings("MethodMayBeStatic") @@ -105,6 +108,7 @@ public static class BenchmarkData public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); Block[] blocks = new Block[TYPES.size()]; @@ -112,9 +116,9 @@ public void setup() for (int i = 0; i < TYPES.size(); i++) { Type elementType = TYPES.get(i); ArrayType arrayType = new ArrayType(elementType); - Signature signature = new Signature("transform", FunctionKind.SCALAR, returnType.getTypeSignature(), arrayType.getTypeSignature(), parseTypeSignature("function(bigint,boolean)")); - Signature greaterThan = new Signature("$operator$" + GREATER_THAN.name(), FunctionKind.SCALAR, BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()); - projectionsBuilder.add(new CallExpression(signature, returnType, ImmutableList.of( + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of("transform"), fromTypeSignatures(arrayType.getTypeSignature(), parseTypeSignature("function(bigint,boolean)"))); + FunctionHandle greaterThan = functionManager.resolveOperator(GREATER_THAN, fromTypes(BIGINT, BIGINT)); + projectionsBuilder.add(new CallExpression(functionHandle, returnType, ImmutableList.of( new InputReferenceExpression(0, arrayType), new LambdaDefinitionExpression( ImmutableList.of(BIGINT), diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkEqualsOperator.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkEqualsOperator.java index 896e846fa20c3..f187858eef47f 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkEqualsOperator.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkEqualsOperator.java @@ -13,6 +13,7 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; @@ -20,7 +21,6 @@ import com.facebook.presto.spi.Page; import com.facebook.presto.spi.PageBuilder; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.OperatorType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; @@ -51,12 +51,14 @@ import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; +import static com.facebook.presto.spi.function.OperatorType.EQUAL; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.field; +import static com.facebook.presto.sql.relational.Expressions.specialForm; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.OR; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.collect.Iterables.cycle; import static com.google.common.collect.Iterables.limit; @@ -82,40 +84,37 @@ public class BenchmarkEqualsOperator public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); ExpressionCompiler expressionCompiler = new ExpressionCompiler( metadata, new PageFunctionCompiler(metadata, 0)); - RowExpression projection = generateComplexComparisonProjection(FIELDS_COUNT, COMPARISONS_COUNT); + RowExpression projection = generateComplexComparisonProjection(functionManager, FIELDS_COUNT, COMPARISONS_COUNT); compiledProcessor = expressionCompiler.compilePageProcessor(Optional.empty(), ImmutableList.of(projection)).get(); } - private static RowExpression generateComplexComparisonProjection(int fieldsCount, int comparisonsCount) + private static RowExpression generateComplexComparisonProjection(FunctionManager functionManager, int fieldsCount, int comparisonsCount) { checkArgument(fieldsCount > 0, "fieldsCount must be greater than zero"); checkArgument(comparisonsCount > 0, "comparisonsCount must be greater than zero"); if (comparisonsCount == 1) { - return createComparison(0, 0); + return createComparison(functionManager, 0, 0); } return createConjunction( - createComparison(0, comparisonsCount % fieldsCount), - generateComplexComparisonProjection(fieldsCount, comparisonsCount - 1)); + createComparison(functionManager, 0, comparisonsCount % fieldsCount), + generateComplexComparisonProjection(functionManager, fieldsCount, comparisonsCount - 1)); } private static RowExpression createConjunction(RowExpression left, RowExpression right) { - return call( - internalScalarFunction("OR", BOOLEAN.getTypeSignature(), BOOLEAN.getTypeSignature(), BOOLEAN.getTypeSignature()), - BOOLEAN, - left, - right); + return specialForm(OR, BOOLEAN, left, right); } - private static RowExpression createComparison(int leftField, int rightField) + private static RowExpression createComparison(FunctionManager functionManager, int leftField, int rightField) { return call( - internalOperator(OperatorType.EQUAL, BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()), + functionManager.resolveOperator(EQUAL, fromTypes(BIGINT, BIGINT)), BOOLEAN, field(leftField, BIGINT), field(rightField, BIGINT)); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToArrayCast.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToArrayCast.java index 6f2e766e563f7..3318f5f48866a 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToArrayCast.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToArrayCast.java @@ -13,14 +13,14 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; @@ -53,6 +53,8 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; @@ -110,12 +112,13 @@ public void setup() throw new UnsupportedOperationException(); } - Signature signature = new Signature("$operator$CAST", FunctionKind.SCALAR, new ArrayType(elementType).getTypeSignature(), JSON.getTypeSignature()); + MetadataManager metadata = createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); + FunctionHandle functionHandle = functionManager.lookupCast(CAST, JSON.getTypeSignature(), (new ArrayType(elementType)).getTypeSignature()); List projections = ImmutableList.of( - new CallExpression(signature, new ArrayType(elementType), ImmutableList.of(field(0, JSON)))); + new CallExpression(functionHandle, new ArrayType(elementType), ImmutableList.of(field(0, JSON)))); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); pageProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)) .compilePageProcessor(Optional.empty(), projections) .get(); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToMapCast.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToMapCast.java index e74b55e478d8d..84f301925a955 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToMapCast.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkJsonToMapCast.java @@ -13,14 +13,14 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; @@ -52,6 +52,8 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; @@ -95,7 +97,9 @@ public static class BenchmarkData @Setup public void setup() { - Signature signature = new Signature("$operator$CAST", FunctionKind.SCALAR, mapType(VARCHAR, BIGINT).getTypeSignature(), JSON.getTypeSignature()); + MetadataManager metadata = createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); + FunctionHandle functionHandle = functionManager.lookupCast(CAST, JSON.getTypeSignature(), mapType(VARCHAR, BIGINT).getTypeSignature()); Type valueType; switch (valueTypeName) { @@ -113,9 +117,8 @@ public void setup() } List projections = ImmutableList.of( - new CallExpression(signature, mapType(VARCHAR, valueType), ImmutableList.of(field(0, JSON)))); + new CallExpression(functionHandle, mapType(VARCHAR, valueType), ImmutableList.of(field(0, JSON)))); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); pageProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)) .compilePageProcessor(Optional.empty(), projections) .get(); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapConcat.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapConcat.java index 186f57adbf3e8..1f9e96bbae539 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapConcat.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapConcat.java @@ -20,13 +20,13 @@ import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; import com.facebook.presto.spi.block.DictionaryBlock; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.MapType; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slice; import org.openjdk.jmh.annotations.Benchmark; @@ -54,8 +54,10 @@ import static com.facebook.presto.block.BlockAssertions.createSlicesBlock; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.createUnboundedVarcharType; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; import static com.facebook.presto.util.StructuralTestUtil.mapType; @@ -99,7 +101,7 @@ public static class BenchmarkData @Setup public void setup() { - MetadataManager metadata = MetadataManager.createTestMetadataManager(); + MetadataManager metadata = createTestMetadataManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); List leftKeys; @@ -137,14 +139,9 @@ public void setup() ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); - Signature signature = new Signature( - name, - FunctionKind.SCALAR, - mapType.getTypeSignature(), - mapType.getTypeSignature(), - mapType.getTypeSignature()); + FunctionHandle functionHandle = metadata.getFunctionManager().lookupFunction(QualifiedName.of(name), fromTypes(mapType, mapType)); projectionsBuilder.add(new CallExpression( - signature, + functionHandle, mapType, ImmutableList.of(field(0, mapType), field(1, mapType)))); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapSubscript.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapSubscript.java index 064d6078ebe93..e5b63e9d2e3bb 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapSubscript.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapSubscript.java @@ -20,8 +20,7 @@ import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; import com.facebook.presto.spi.block.DictionaryBlock; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.MapType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; @@ -56,9 +55,11 @@ import static com.facebook.presto.block.BlockAssertions.createSlicesBlock; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.function.OperatorType.SUBSCRIPT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.VarcharType.createUnboundedVarcharType; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; @@ -105,7 +106,7 @@ public static class BenchmarkData @Setup public void setup() { - MetadataManager metadata = MetadataManager.createTestMetadataManager(); + MetadataManager metadata = createTestMetadataManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); List keys; @@ -146,15 +147,10 @@ public void setup() ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); - Signature signature = new Signature( - "$operator$" + SUBSCRIPT.name(), - FunctionKind.SCALAR, - mapType.getValueType().getTypeSignature(), - mapType.getTypeSignature(), - mapType.getKeyType().getTypeSignature()); + FunctionHandle functionHandle = metadata.getFunctionManager().resolveOperator(SUBSCRIPT, fromTypes(mapType, mapType.getKeyType())); for (int i = 0; i < mapSize; i++) { projectionsBuilder.add(new CallExpression( - signature, + functionHandle, mapType.getValueType(), ImmutableList.of(field(0, mapType), constant(utf8Slice(keys.get(i)), createUnboundedVarcharType())))); } diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapToMapCast.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapToMapCast.java index 225c6de08987b..c033f73d5c784 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapToMapCast.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkMapToMapCast.java @@ -19,8 +19,7 @@ import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.MapType; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; @@ -50,6 +49,8 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.sql.relational.Expressions.field; @@ -91,12 +92,12 @@ public static class BenchmarkData @Setup public void setup() { - Signature signature = new Signature("$operator$CAST", FunctionKind.SCALAR, mapType(BIGINT, DOUBLE).getTypeSignature(), mapType(DOUBLE, BIGINT).getTypeSignature()); + MetadataManager metadata = createTestMetadataManager(); + FunctionHandle functionHandle = metadata.getFunctionManager().lookupCast(CAST, mapType(DOUBLE, BIGINT).getTypeSignature(), mapType(BIGINT, DOUBLE).getTypeSignature()); List projections = ImmutableList.of( - new CallExpression(signature, mapType(BIGINT, DOUBLE), ImmutableList.of(field(0, mapType(DOUBLE, BIGINT))))); + new CallExpression(functionHandle, mapType(BIGINT, DOUBLE), ImmutableList.of(field(0, mapType(DOUBLE, BIGINT))))); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); pageProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)) .compilePageProcessor(Optional.empty(), projections) .get(); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkRowToRowCast.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkRowToRowCast.java index 1dc84ae803d5e..ff45a1eacad7a 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkRowToRowCast.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkRowToRowCast.java @@ -19,7 +19,7 @@ import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.RowType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.VarcharType; @@ -48,8 +48,9 @@ import java.util.concurrent.ThreadLocalRandom; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.block.RowBlock.fromFieldBlocks; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.VarcharType.createVarcharType; import static com.facebook.presto.sql.relational.Expressions.field; @@ -91,12 +92,12 @@ public static class BenchmarkData @Setup public void setup() { - Signature signature = new Signature("$operator$CAST", SCALAR, RowType.anonymous(fromFieldTypes).getTypeSignature(), RowType.anonymous(toFieldTypes).getTypeSignature()); + MetadataManager metadata = createTestMetadataManager(); + FunctionHandle functionHandle = metadata.getFunctionManager().lookupCast(CAST, RowType.anonymous(fromFieldTypes).getTypeSignature(), RowType.anonymous(toFieldTypes).getTypeSignature()); List projections = ImmutableList.of( - new CallExpression(signature, RowType.anonymous(fromFieldTypes), ImmutableList.of(field(0, RowType.anonymous(toFieldTypes))))); + new CallExpression(functionHandle, RowType.anonymous(fromFieldTypes), ImmutableList.of(field(0, RowType.anonymous(toFieldTypes))))); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); pageProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)) .compilePageProcessor(Optional.empty(), projections) .get(); diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformKey.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformKey.java index dceb23b03e6c3..7932d9ba1dd86 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformKey.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformKey.java @@ -14,14 +14,14 @@ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.MapType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; @@ -29,6 +29,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; @@ -59,6 +60,8 @@ import static com.facebook.presto.spi.type.DoubleType.DOUBLE; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.writeNativeValue; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -105,6 +108,7 @@ public static class BenchmarkData public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); Type elementType; @@ -122,14 +126,13 @@ public void setup() throw new UnsupportedOperationException(); } MapType mapType = mapType(elementType, elementType); - Signature signature = new Signature( - name, - FunctionKind.SCALAR, - mapType.getTypeSignature(), - mapType.getTypeSignature(), - parseTypeSignature(format("function(%s, %s, %s)", type, type, type))); - Signature add = new Signature("$operator$" + ADD.name(), FunctionKind.SCALAR, elementType.getTypeSignature(), elementType.getTypeSignature(), elementType.getTypeSignature()); - projectionsBuilder.add(call(signature, mapType, ImmutableList.of( + FunctionHandle functionHandle = functionManager.lookupFunction( + QualifiedName.of(name), + fromTypeSignatures( + mapType.getTypeSignature(), + parseTypeSignature(format("function(%s, %s, %s)", type, type, type)))); + FunctionHandle add = functionManager.resolveOperator(ADD, fromTypes(elementType, elementType)); + projectionsBuilder.add(call(functionHandle, mapType, ImmutableList.of( field(0, mapType), new LambdaDefinitionExpression( ImmutableList.of(elementType, elementType), diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformValue.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformValue.java index d77f8f3e5ddcd..0f1b93e818fe9 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformValue.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/BenchmarkTransformValue.java @@ -14,14 +14,14 @@ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; -import com.facebook.presto.spi.function.FunctionKind; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.MapType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.gen.ExpressionCompiler; @@ -29,6 +29,7 @@ import com.facebook.presto.sql.relational.LambdaDefinitionExpression; import com.facebook.presto.sql.relational.RowExpression; import com.facebook.presto.sql.relational.VariableReferenceExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slices; import org.openjdk.jmh.annotations.Benchmark; @@ -62,6 +63,8 @@ import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.TypeUtils.writeNativeValue; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypeSignatures; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -108,6 +111,7 @@ public static class BenchmarkData public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); Type elementType; @@ -130,19 +134,15 @@ public void setup() } MapType mapType = mapType(elementType, elementType); MapType returnType = mapType(elementType, BOOLEAN); - Signature signature = new Signature( - name, - FunctionKind.SCALAR, - returnType.getTypeSignature(), - mapType.getTypeSignature(), - parseTypeSignature(format("function(%s, %s, boolean)", type, type))); - Signature greaterThan = new Signature( - "$operator$" + GREATER_THAN.name(), - FunctionKind.SCALAR, - BOOLEAN.getTypeSignature(), - elementType.getTypeSignature(), - elementType.getTypeSignature()); - projectionsBuilder.add(call(signature, returnType, ImmutableList.of( + FunctionHandle functionHandle = functionManager.lookupFunction( + QualifiedName.of(name), + fromTypeSignatures( + mapType.getTypeSignature(), + parseTypeSignature(format("function(%s, %s, boolean)", type, type)))); + FunctionHandle greaterThan = metadata.getFunctionManager().resolveOperator( + GREATER_THAN, + fromTypes(elementType, elementType)); + projectionsBuilder.add(call(functionHandle, returnType, ImmutableList.of( field(0, mapType), new LambdaDefinitionExpression( ImmutableList.of(elementType, elementType), diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/FunctionAssertions.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/FunctionAssertions.java index e4da3bbc4ff0c..bd66e09b7c752 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/FunctionAssertions.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/FunctionAssertions.java @@ -113,7 +113,6 @@ import static com.facebook.presto.spi.StandardErrorCode.INVALID_CAST_ARGUMENT; import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT; import static com.facebook.presto.spi.StandardErrorCode.NUMERIC_VALUE_OUT_OF_RANGE; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DateTimeEncoding.packDateTimeWithZone; @@ -957,7 +956,7 @@ private static SourceOperatorFactory compileScanFilterProject(Optional, Type> expressionTypes) { - return translate(projection, SCALAR, expressionTypes, metadata.getFunctionManager(), metadata.getTypeManager(), session, false); + return translate(projection, expressionTypes, metadata.getFunctionManager(), metadata.getTypeManager(), session, false); } private static Page getAtMostOnePage(Operator operator, Page sourcePage) diff --git a/presto-main/src/test/java/com/facebook/presto/operator/scalar/TestPageProcessorCompiler.java b/presto-main/src/test/java/com/facebook/presto/operator/scalar/TestPageProcessorCompiler.java index 9ad7687260423..b3f84a5beb85c 100644 --- a/presto-main/src/test/java/com/facebook/presto/operator/scalar/TestPageProcessorCompiler.java +++ b/presto-main/src/test/java/com/facebook/presto/operator/scalar/TestPageProcessorCompiler.java @@ -13,21 +13,22 @@ */ package com.facebook.presto.operator.scalar; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.block.DictionaryBlock; import com.facebook.presto.spi.block.RunLengthEncodedBlock; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.sql.gen.ExpressionCompiler; import com.facebook.presto.sql.gen.PageFunctionCompiler; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.DeterminismEvaluator; import com.facebook.presto.sql.relational.InputReferenceExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import io.airlift.slice.DynamicSliceOutput; import io.airlift.slice.Slice; @@ -42,15 +43,13 @@ import static com.facebook.presto.block.BlockAssertions.createRLEBlock; import static com.facebook.presto.block.BlockAssertions.createSlicesBlock; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.project.PageProcessor.MAX_BATCH_SIZE; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.function.OperatorType.LESS_THAN; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; -import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; import static com.google.common.collect.Iterators.getOnlyElement; @@ -81,10 +80,11 @@ public void tearDown() @Test public void testNoCaching() { + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); ImmutableList.Builder projectionsBuilder = ImmutableList.builder(); ArrayType arrayType = new ArrayType(VARCHAR); - Signature signature = new Signature("concat", SCALAR, arrayType.getTypeSignature(), arrayType.getTypeSignature(), arrayType.getTypeSignature()); - projectionsBuilder.add(new CallExpression(signature, arrayType, ImmutableList.of(field(0, arrayType), field(1, arrayType)))); + FunctionHandle functionHandle = functionManager.lookupFunction(QualifiedName.of("concat"), fromTypes(arrayType, arrayType)); + projectionsBuilder.add(new CallExpression(functionHandle, arrayType, ImmutableList.of(field(0, arrayType), field(1, arrayType)))); ImmutableList projections = projectionsBuilder.build(); PageProcessor pageProcessor = compiler.compilePageProcessor(Optional.empty(), projections).get(); @@ -121,9 +121,10 @@ public void testSanityRLE() @Test public void testSanityFilterOnDictionary() { + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); CallExpression lengthVarchar = new CallExpression( - new Signature("length", SCALAR, parseTypeSignature(StandardTypes.BIGINT), parseTypeSignature(StandardTypes.VARCHAR)), BIGINT, ImmutableList.of(field(0, VARCHAR))); - Signature lessThan = internalOperator(LESS_THAN, BOOLEAN, ImmutableList.of(BIGINT, BIGINT)); + functionManager.lookupFunction(QualifiedName.of("length"), fromTypes(VARCHAR)), BIGINT, ImmutableList.of(field(0, VARCHAR))); + FunctionHandle lessThan = functionManager.resolveOperator(LESS_THAN, fromTypes(BIGINT, BIGINT)); CallExpression filter = new CallExpression(lessThan, BOOLEAN, ImmutableList.of(lengthVarchar, constant(10L, BIGINT))); PageProcessor processor = compiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field(0, VARCHAR)), MAX_BATCH_SIZE).get(); @@ -161,7 +162,8 @@ public void testSanityFilterOnDictionary() @Test public void testSanityFilterOnRLE() { - Signature lessThan = internalOperator(LESS_THAN, BOOLEAN, ImmutableList.of(BIGINT, BIGINT)); + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); + FunctionHandle lessThan = functionManager.resolveOperator(LESS_THAN, fromTypes(BIGINT, BIGINT)); CallExpression filter = new CallExpression(lessThan, BOOLEAN, ImmutableList.of(field(0, BIGINT), constant(10L, BIGINT))); PageProcessor processor = compiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field(0, BIGINT)), MAX_BATCH_SIZE).get(); @@ -206,9 +208,10 @@ public void testSanityColumnarDictionary() @Test public void testNonDeterministicProject() { - Signature lessThan = internalOperator(LESS_THAN, BOOLEAN, ImmutableList.of(BIGINT, BIGINT)); + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); + FunctionHandle lessThan = functionManager.resolveOperator(LESS_THAN, fromTypes(BIGINT, BIGINT)); CallExpression random = new CallExpression( - new Signature("random", SCALAR, parseTypeSignature(StandardTypes.BIGINT), parseTypeSignature(StandardTypes.BIGINT)), BIGINT, singletonList(constant(10L, BIGINT))); + functionManager.lookupFunction(QualifiedName.of("random"), fromTypes(BIGINT)), BIGINT, singletonList(constant(10L, BIGINT))); InputReferenceExpression col0 = field(0, BIGINT); CallExpression lessThanRandomExpression = new CallExpression(lessThan, BOOLEAN, ImmutableList.of(col0, random)); diff --git a/presto-main/src/test/java/com/facebook/presto/sql/TestExpressionOptimizer.java b/presto-main/src/test/java/com/facebook/presto/sql/TestExpressionOptimizer.java index a1b6b1231edc2..1c3a2198b867a 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/TestExpressionOptimizer.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/TestExpressionOptimizer.java @@ -16,16 +16,16 @@ import com.facebook.presto.block.BlockEncodingManager; import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.spi.block.IntArrayBlock; -import com.facebook.presto.spi.function.OperatorType; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.spi.function.FunctionHandle; import com.facebook.presto.spi.type.ArrayType; import com.facebook.presto.spi.type.RowType; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.sql.analyzer.FeaturesConfig; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.ConstantExpression; import com.facebook.presto.sql.relational.RowExpression; +import com.facebook.presto.sql.relational.SpecialFormExpression; import com.facebook.presto.sql.relational.optimizer.ExpressionOptimizer; +import com.facebook.presto.sql.tree.QualifiedName; import com.facebook.presto.type.TypeRegistry; import com.google.common.collect.ImmutableList; import org.testng.annotations.AfterClass; @@ -34,21 +34,22 @@ import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.block.BlockAssertions.toValues; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalScalarFunction; -import static com.facebook.presto.operator.scalar.JsonStringToArrayCast.JSON_STRING_TO_ARRAY_NAME; -import static com.facebook.presto.operator.scalar.JsonStringToMapCast.JSON_STRING_TO_MAP_NAME; -import static com.facebook.presto.operator.scalar.JsonStringToRowCast.JSON_STRING_TO_ROW_NAME; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.CastType.JSON_TO_ARRAY_CAST; +import static com.facebook.presto.metadata.CastType.JSON_TO_MAP_CAST; +import static com.facebook.presto.metadata.CastType.JSON_TO_ROW_CAST; +import static com.facebook.presto.spi.function.OperatorType.ADD; +import static com.facebook.presto.spi.function.OperatorType.EQUAL; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.IntegerType.INTEGER; import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; -import static com.facebook.presto.sql.relational.Signatures.CAST; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.IF; import static com.facebook.presto.type.JsonType.JSON; import static com.facebook.presto.util.StructuralTestUtil.mapType; import static io.airlift.slice.Slices.utf8Slice; @@ -58,13 +59,15 @@ public class TestExpressionOptimizer { private TypeRegistry typeManager; + private FunctionManager functionManager; private ExpressionOptimizer optimizer; @BeforeClass public void setUp() { typeManager = new TypeRegistry(); - optimizer = new ExpressionOptimizer(new FunctionManager(typeManager, new BlockEncodingManager(typeManager), new FeaturesConfig()), typeManager, TEST_SESSION); + functionManager = new FunctionManager(typeManager, new BlockEncodingManager(typeManager), new FeaturesConfig()); + optimizer = new ExpressionOptimizer(functionManager, typeManager, TEST_SESSION); } @AfterClass(alwaysRun = true) @@ -79,8 +82,8 @@ public void testPossibleExponentialOptimizationTime() { RowExpression expression = constant(1L, BIGINT); for (int i = 0; i < 100; i++) { - Signature signature = internalOperator(OperatorType.ADD.name(), parseTypeSignature(StandardTypes.BIGINT), parseTypeSignature(StandardTypes.BIGINT), parseTypeSignature(StandardTypes.BIGINT)); - expression = new CallExpression(signature, BIGINT, ImmutableList.of(expression, constant(1L, BIGINT))); + FunctionHandle functionHandle = functionManager.resolveOperator(ADD, fromTypes(BIGINT, BIGINT)); + expression = new CallExpression(functionHandle, BIGINT, ImmutableList.of(expression, constant(1L, BIGINT))); } optimizer.optimize(expression); } @@ -92,7 +95,7 @@ public void testIfConstantOptimization() assertEquals(optimizer.optimize(ifExpression(constant(false, BOOLEAN), 1L, 2L)), constant(2L, BIGINT)); assertEquals(optimizer.optimize(ifExpression(constant(null, BOOLEAN), 1L, 2L)), constant(2L, BIGINT)); - Signature bigintEquals = internalOperator(OperatorType.EQUAL.name(), BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()); + FunctionHandle bigintEquals = functionManager.resolveOperator(EQUAL, fromTypes(BIGINT, BIGINT)); RowExpression condition = new CallExpression(bigintEquals, BOOLEAN, ImmutableList.of(constant(3L, BIGINT), constant(3L, BIGINT))); assertEquals(optimizer.optimize(ifExpression(condition, 1L, 2L)), constant(1L, BIGINT)); } @@ -100,11 +103,11 @@ public void testIfConstantOptimization() @Test public void testCastWithJsonParseOptimization() { - Signature jsonParseSignature = new Signature("json_parse", SCALAR, JSON.getTypeSignature(), ImmutableList.of(VARCHAR.getTypeSignature())); + FunctionHandle jsonParseFunctionHandle = functionManager.lookupFunction(QualifiedName.of("json_parse"), fromTypes(VARCHAR)); // constant - Signature jsonCastSignature = new Signature(CAST, SCALAR, parseTypeSignature("array(integer)"), ImmutableList.of(JSON.getTypeSignature())); - RowExpression jsonCastExpression = new CallExpression(jsonCastSignature, new ArrayType(INTEGER), ImmutableList.of(call(jsonParseSignature, JSON, constant(utf8Slice("[1, 2]"), VARCHAR)))); + FunctionHandle jsonCastFunctionHandle = functionManager.lookupCast(CAST, JSON.getTypeSignature(), parseTypeSignature("array(integer)")); + RowExpression jsonCastExpression = new CallExpression(jsonCastFunctionHandle, new ArrayType(INTEGER), ImmutableList.of(call(jsonParseFunctionHandle, JSON, constant(utf8Slice("[1, 2]"), VARCHAR)))); RowExpression resultExpression = optimizer.optimize(jsonCastExpression); assertInstanceOf(resultExpression, ConstantExpression.class); Object resultValue = ((ConstantExpression) resultExpression).getValue(); @@ -112,33 +115,32 @@ public void testCastWithJsonParseOptimization() assertEquals(toValues(INTEGER, (IntArrayBlock) resultValue), ImmutableList.of(1, 2)); // varchar to array - jsonCastSignature = new Signature(CAST, SCALAR, parseTypeSignature("array(varchar)"), ImmutableList.of(JSON.getTypeSignature())); - jsonCastExpression = new CallExpression(jsonCastSignature, new ArrayType(VARCHAR), ImmutableList.of(call(jsonParseSignature, JSON, field(1, VARCHAR)))); + jsonCastFunctionHandle = functionManager.lookupCast(CAST, JSON.getTypeSignature(), parseTypeSignature("array(varchar)")); + jsonCastExpression = call(jsonCastFunctionHandle, new ArrayType(VARCHAR), ImmutableList.of(call(jsonParseFunctionHandle, JSON, field(1, VARCHAR)))); resultExpression = optimizer.optimize(jsonCastExpression); assertEquals( resultExpression, - call(internalScalarFunction(JSON_STRING_TO_ARRAY_NAME, parseTypeSignature("array(varchar)"), parseTypeSignature(StandardTypes.VARCHAR)), new ArrayType(VARCHAR), field(1, VARCHAR))); + call(functionManager.lookupCast(JSON_TO_ARRAY_CAST, VARCHAR.getTypeSignature(), parseTypeSignature("array(varchar)")), new ArrayType(VARCHAR), field(1, VARCHAR))); // varchar to map - jsonCastSignature = new Signature(CAST, SCALAR, parseTypeSignature("map(integer,varchar)"), ImmutableList.of(JSON.getTypeSignature())); - jsonCastExpression = new CallExpression(jsonCastSignature, mapType(INTEGER, VARCHAR), ImmutableList.of(call(jsonParseSignature, JSON, field(1, VARCHAR)))); + jsonCastFunctionHandle = functionManager.lookupCast(CAST, JSON.getTypeSignature(), parseTypeSignature("map(integer,varchar)")); + jsonCastExpression = call(jsonCastFunctionHandle, mapType(INTEGER, VARCHAR), ImmutableList.of(call(jsonParseFunctionHandle, JSON, field(1, VARCHAR)))); resultExpression = optimizer.optimize(jsonCastExpression); assertEquals( resultExpression, - call(internalScalarFunction(JSON_STRING_TO_MAP_NAME, parseTypeSignature("map(integer,varchar)"), parseTypeSignature(StandardTypes.VARCHAR)), mapType(INTEGER, VARCHAR), field(1, VARCHAR))); + call(functionManager.lookupCast(JSON_TO_MAP_CAST, VARCHAR.getTypeSignature(), parseTypeSignature("map(integer, varchar)")), mapType(INTEGER, VARCHAR), field(1, VARCHAR))); // varchar to row - jsonCastSignature = new Signature(CAST, SCALAR, parseTypeSignature("row(varchar,bigint)"), ImmutableList.of(JSON.getTypeSignature())); - jsonCastExpression = new CallExpression(jsonCastSignature, RowType.anonymous(ImmutableList.of(VARCHAR, BIGINT)), ImmutableList.of(call(jsonParseSignature, JSON, field(1, VARCHAR)))); + jsonCastFunctionHandle = functionManager.lookupCast(CAST, JSON.getTypeSignature(), parseTypeSignature("row(varchar,bigint)")); + jsonCastExpression = call(jsonCastFunctionHandle, RowType.anonymous(ImmutableList.of(VARCHAR, BIGINT)), ImmutableList.of(call(jsonParseFunctionHandle, JSON, field(1, VARCHAR)))); resultExpression = optimizer.optimize(jsonCastExpression); assertEquals( resultExpression, - call(internalScalarFunction(JSON_STRING_TO_ROW_NAME, parseTypeSignature("row(varchar,bigint)"), parseTypeSignature(StandardTypes.VARCHAR)), RowType.anonymous(ImmutableList.of(VARCHAR, BIGINT)), field(1, VARCHAR))); + call(functionManager.lookupCast(JSON_TO_ROW_CAST, VARCHAR.getTypeSignature(), parseTypeSignature("row(varchar,bigint)")), RowType.anonymous(ImmutableList.of(VARCHAR, BIGINT)), field(1, VARCHAR))); } private static RowExpression ifExpression(RowExpression condition, long trueValue, long falseValue) { - Signature signature = new Signature("IF", SCALAR, BIGINT.getTypeSignature(), BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()); - return new CallExpression(signature, BIGINT, ImmutableList.of(condition, constant(trueValue, BIGINT), constant(falseValue, BIGINT))); + return new SpecialFormExpression(IF, BIGINT, ImmutableList.of(condition, constant(trueValue, BIGINT), constant(falseValue, BIGINT))); } } diff --git a/presto-main/src/test/java/com/facebook/presto/sql/TestSqlToRowExpressionTranslator.java b/presto-main/src/test/java/com/facebook/presto/sql/TestSqlToRowExpressionTranslator.java index a76b4265043e6..16de6210513c6 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/TestSqlToRowExpressionTranslator.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/TestSqlToRowExpressionTranslator.java @@ -36,7 +36,6 @@ import java.util.Map; import static com.facebook.presto.SessionTestUtils.TEST_SESSION; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DecimalType.createDecimalType; import static com.facebook.presto.spi.type.Decimals.encodeScaledValue; @@ -92,7 +91,7 @@ private RowExpression translateAndOptimize(Expression expression) private RowExpression translateAndOptimize(Expression expression, Map, Type> types) { - return SqlToRowExpressionTranslator.translate(expression, SCALAR, types, metadata.getFunctionManager(), metadata.getTypeManager(), TEST_SESSION, true); + return SqlToRowExpressionTranslator.translate(expression, types, metadata.getFunctionManager(), metadata.getTypeManager(), TEST_SESSION, true); } private Expression simplifyExpression(Expression expression) diff --git a/presto-main/src/test/java/com/facebook/presto/sql/gen/BenchmarkPageProcessor.java b/presto-main/src/test/java/com/facebook/presto/sql/gen/BenchmarkPageProcessor.java index 2fd49950f47bf..e969088d79228 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/gen/BenchmarkPageProcessor.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/gen/BenchmarkPageProcessor.java @@ -13,15 +13,13 @@ */ package com.facebook.presto.sql.gen; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.MetadataManager; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.PageBuilder; import com.facebook.presto.spi.block.Block; -import com.facebook.presto.spi.function.OperatorType; -import com.facebook.presto.spi.function.Signature; -import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.sql.relational.RowExpression; import com.google.common.collect.ImmutableList; import io.airlift.slice.Slice; @@ -47,16 +45,21 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; +import static com.facebook.presto.spi.function.OperatorType.GREATER_THAN_OR_EQUAL; +import static com.facebook.presto.spi.function.OperatorType.LESS_THAN; +import static com.facebook.presto.spi.function.OperatorType.LESS_THAN_OR_EQUAL; +import static com.facebook.presto.spi.function.OperatorType.MULTIPLY; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DateType.DATE; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; -import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; +import static com.facebook.presto.sql.relational.Expressions.specialForm; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.AND; import static com.google.common.base.Preconditions.checkState; import static io.airlift.slice.Slices.utf8Slice; @@ -83,8 +86,11 @@ public void setup() { inputPage = createInputPage(); - MetadataManager metadata = MetadataManager.createTestMetadataManager(); - compiledProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)).compilePageProcessor(Optional.of(FILTER), ImmutableList.of(PROJECT)).get(); + MetadataManager metadata = createTestMetadataManager(); + FunctionManager functionManager = metadata.getFunctionManager(); + compiledProcessor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)) + .compilePageProcessor(Optional.of(createFilterExpression(functionManager)), ImmutableList.of(createProjectExpression(functionManager))) + .get(); } @Benchmark @@ -183,38 +189,48 @@ private static boolean filter(int position, Block discountBlock, Block shipDateB // and discount >= 0.05 // and discount <= 0.07 // and quantity < 24; - private static final RowExpression FILTER = call(new Signature("AND", SCALAR, parseTypeSignature(StandardTypes.BOOLEAN)), - BOOLEAN, - call(internalOperator(OperatorType.GREATER_THAN_OR_EQUAL, BOOLEAN.getTypeSignature(), VARCHAR.getTypeSignature(), VARCHAR.getTypeSignature()), - BOOLEAN, - field(SHIP_DATE, VARCHAR), - constant(MIN_SHIP_DATE, VARCHAR)), - call(new Signature("AND", SCALAR, parseTypeSignature(StandardTypes.BOOLEAN)), - BOOLEAN, - call(internalOperator(OperatorType.LESS_THAN, BOOLEAN.getTypeSignature(), VARCHAR.getTypeSignature(), VARCHAR.getTypeSignature()), - BOOLEAN, - field(SHIP_DATE, VARCHAR), - constant(MAX_SHIP_DATE, VARCHAR)), - call(new Signature("AND", SCALAR, parseTypeSignature(StandardTypes.BOOLEAN)), - BOOLEAN, - call(internalOperator(OperatorType.GREATER_THAN_OR_EQUAL, BOOLEAN.getTypeSignature(), DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature()), - BOOLEAN, - field(DISCOUNT, DOUBLE), - constant(0.05, DOUBLE)), - call(new Signature("AND", SCALAR, parseTypeSignature(StandardTypes.BOOLEAN)), - BOOLEAN, - call(internalOperator(OperatorType.LESS_THAN_OR_EQUAL, BOOLEAN.getTypeSignature(), DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature()), - BOOLEAN, - field(DISCOUNT, DOUBLE), - constant(0.07, DOUBLE)), - call(internalOperator(OperatorType.LESS_THAN, BOOLEAN.getTypeSignature(), DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature()), - BOOLEAN, - field(QUANTITY, DOUBLE), - constant(24.0, DOUBLE)))))); - - private static final RowExpression PROJECT = call( - internalOperator(OperatorType.MULTIPLY, DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature(), DOUBLE.getTypeSignature()), - DOUBLE, - field(EXTENDED_PRICE, DOUBLE), - field(DISCOUNT, DOUBLE)); + private static final RowExpression createFilterExpression(FunctionManager functionManager) + { + return specialForm( + AND, + BOOLEAN, + call(functionManager.resolveOperator(GREATER_THAN_OR_EQUAL, fromTypes(VARCHAR, VARCHAR)), + BOOLEAN, + field(SHIP_DATE, VARCHAR), + constant(MIN_SHIP_DATE, VARCHAR)), + specialForm( + AND, + BOOLEAN, + call(functionManager.resolveOperator(LESS_THAN, fromTypes(VARCHAR, VARCHAR)), + BOOLEAN, + field(SHIP_DATE, VARCHAR), + constant(MAX_SHIP_DATE, VARCHAR)), + specialForm( + AND, + BOOLEAN, + call(functionManager.resolveOperator(GREATER_THAN_OR_EQUAL, fromTypes(DOUBLE, DOUBLE)), + BOOLEAN, + field(DISCOUNT, DOUBLE), + constant(0.05, DOUBLE)), + specialForm( + AND, + BOOLEAN, + call(functionManager.resolveOperator(LESS_THAN_OR_EQUAL, fromTypes(DOUBLE, DOUBLE)), + BOOLEAN, + field(DISCOUNT, DOUBLE), + constant(0.07, DOUBLE)), + call(functionManager.resolveOperator(LESS_THAN, fromTypes(DOUBLE, DOUBLE)), + BOOLEAN, + field(QUANTITY, DOUBLE), + constant(24.0, DOUBLE)))))); + } + + private static final RowExpression createProjectExpression(FunctionManager functionManager) + { + return call( + functionManager.resolveOperator(MULTIPLY, fromTypes(DOUBLE, DOUBLE)), + DOUBLE, + field(EXTENDED_PRICE, DOUBLE), + field(DISCOUNT, DOUBLE)); + } } diff --git a/presto-main/src/test/java/com/facebook/presto/sql/gen/InCodeGeneratorBenchmark.java b/presto-main/src/test/java/com/facebook/presto/sql/gen/InCodeGeneratorBenchmark.java index 5869a227ff097..4dec40f7e6c89 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/gen/InCodeGeneratorBenchmark.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/gen/InCodeGeneratorBenchmark.java @@ -18,7 +18,6 @@ import com.facebook.presto.operator.project.PageProcessor; import com.facebook.presto.spi.Page; import com.facebook.presto.spi.PageBuilder; -import com.facebook.presto.spi.function.Signature; import com.facebook.presto.spi.type.StandardTypes; import com.facebook.presto.spi.type.Type; import com.facebook.presto.sql.relational.RowExpression; @@ -46,16 +45,14 @@ import java.util.concurrent.TimeUnit; import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; -import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; -import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; -import static com.facebook.presto.sql.relational.Signatures.IN; +import static com.facebook.presto.sql.relational.Expressions.specialForm; +import static com.facebook.presto.sql.relational.SpecialFormExpression.Form.IN; import static com.facebook.presto.testing.TestingConnectorSession.SESSION; import static org.openjdk.jmh.annotations.Mode.AverageTime; @@ -127,10 +124,7 @@ public void setup() } inputPage = pageBuilder.build(); - RowExpression filter = call( - new Signature(IN, SCALAR, parseTypeSignature(StandardTypes.BOOLEAN)), - BOOLEAN, - arguments); + RowExpression filter = specialForm(IN, BOOLEAN, arguments); MetadataManager metadata = MetadataManager.createTestMetadataManager(); processor = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)).compilePageProcessor(Optional.of(filter), ImmutableList.of(project)).get(); diff --git a/presto-main/src/test/java/com/facebook/presto/sql/gen/PageProcessorBenchmark.java b/presto-main/src/test/java/com/facebook/presto/sql/gen/PageProcessorBenchmark.java index bc1e3f03dae51..d0b7ba1e15178 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/gen/PageProcessorBenchmark.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/gen/PageProcessorBenchmark.java @@ -63,7 +63,6 @@ import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.scalar.FunctionAssertions.createExpression; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.sql.analyzer.ExpressionAnalyzer.getExpressionTypesFromInput; @@ -189,7 +188,7 @@ private RowExpression rowExpression(String expression, Type type) Map types = builder.build(); Map, Type> expressionTypes = getExpressionTypesFromInput(TEST_SESSION, METADATA, SQL_PARSER, types, inputReferenceExpression, emptyList(), WarningCollector.NOOP); - return SqlToRowExpressionTranslator.translate(inputReferenceExpression, SCALAR, expressionTypes, METADATA.getFunctionManager(), METADATA.getTypeManager(), TEST_SESSION, true); + return SqlToRowExpressionTranslator.translate(inputReferenceExpression, expressionTypes, METADATA.getFunctionManager(), METADATA.getTypeManager(), TEST_SESSION, true); } private static Page createPage(List types, boolean dictionary) diff --git a/presto-main/src/test/java/com/facebook/presto/sql/gen/TestInCodeGenerator.java b/presto-main/src/test/java/com/facebook/presto/sql/gen/TestInCodeGenerator.java index bce12d1b20dd3..b736383324da0 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/gen/TestInCodeGenerator.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/gen/TestInCodeGenerator.java @@ -13,7 +13,7 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.spi.function.Signature; +import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.sql.relational.CallExpression; import com.facebook.presto.sql.relational.RowExpression; import io.airlift.slice.Slices; @@ -23,7 +23,8 @@ import java.util.Collections; import java.util.List; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; +import static com.facebook.presto.metadata.CastType.CAST; +import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DateType.DATE; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -34,7 +35,6 @@ import static com.facebook.presto.sql.gen.InCodeGenerator.SwitchGenerationCase.SET_CONTAINS; import static com.facebook.presto.sql.gen.InCodeGenerator.checkSwitchGenerationCase; import static com.facebook.presto.sql.relational.Expressions.constant; -import static com.facebook.presto.sql.relational.Signatures.CAST; import static org.testng.Assert.assertEquals; public class TestInCodeGenerator @@ -42,6 +42,7 @@ public class TestInCodeGenerator @Test public void testInteger() { + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); List values = new ArrayList<>(); values.add(constant(Integer.MIN_VALUE, INTEGER)); values.add(constant(Integer.MAX_VALUE, INTEGER)); @@ -51,11 +52,7 @@ public void testInteger() values.add(constant(null, INTEGER)); assertEquals(checkSwitchGenerationCase(INTEGER, values), DIRECT_SWITCH); values.add(new CallExpression( - new Signature( - CAST, - SCALAR, - INTEGER.getTypeSignature(), - DOUBLE.getTypeSignature()), + functionManager.lookupCast(CAST, DOUBLE.getTypeSignature(), INTEGER.getTypeSignature()), INTEGER, Collections.singletonList(constant(12345678901234.0, DOUBLE)))); assertEquals(checkSwitchGenerationCase(INTEGER, values), DIRECT_SWITCH); @@ -72,6 +69,7 @@ public void testInteger() @Test public void testBigint() { + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); List values = new ArrayList<>(); values.add(constant(Integer.MAX_VALUE + 1L, BIGINT)); values.add(constant(Integer.MIN_VALUE - 1L, BIGINT)); @@ -81,11 +79,7 @@ public void testBigint() values.add(constant(null, BIGINT)); assertEquals(checkSwitchGenerationCase(BIGINT, values), HASH_SWITCH); values.add(new CallExpression( - new Signature( - CAST, - SCALAR, - BIGINT.getTypeSignature(), - DOUBLE.getTypeSignature()), + functionManager.lookupCast(CAST, DOUBLE.getTypeSignature(), BIGINT.getTypeSignature()), BIGINT, Collections.singletonList(constant(12345678901234.0, DOUBLE)))); assertEquals(checkSwitchGenerationCase(BIGINT, values), HASH_SWITCH); diff --git a/presto-main/src/test/java/com/facebook/presto/sql/gen/TestPageFunctionCompiler.java b/presto-main/src/test/java/com/facebook/presto/sql/gen/TestPageFunctionCompiler.java index daeb31f88904d..e64393399067e 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/gen/TestPageFunctionCompiler.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/gen/TestPageFunctionCompiler.java @@ -13,7 +13,6 @@ */ package com.facebook.presto.sql.gen; -import com.facebook.presto.metadata.InternalSignatureUtils; import com.facebook.presto.operator.DriverYieldSignal; import com.facebook.presto.operator.Work; import com.facebook.presto.operator.project.PageProjection; @@ -23,7 +22,6 @@ import com.facebook.presto.spi.block.Block; import com.facebook.presto.spi.block.BlockBuilder; import com.facebook.presto.sql.relational.CallExpression; -import com.google.common.collect.ImmutableList; import org.testng.annotations.Test; import java.util.Optional; @@ -33,6 +31,7 @@ import static com.facebook.presto.spi.StandardErrorCode.NUMERIC_VALUE_OUT_OF_RANGE; import static com.facebook.presto.spi.function.OperatorType.ADD; import static com.facebook.presto.spi.type.BigintType.BIGINT; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.call; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; @@ -46,7 +45,7 @@ public class TestPageFunctionCompiler { private static final CallExpression ADD_10_EXPRESSION = call( - InternalSignatureUtils.internalOperator(ADD, BIGINT.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), BIGINT.getTypeSignature())), + createTestMetadataManager().getFunctionManager().resolveOperator(ADD, fromTypes(BIGINT, BIGINT)), BIGINT, field(0, BIGINT), constant(10L, BIGINT)); diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/TestEffectivePredicateExtractor.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/TestEffectivePredicateExtractor.java index bfee356647d20..2b64428b472e3 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/TestEffectivePredicateExtractor.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/TestEffectivePredicateExtractor.java @@ -72,7 +72,6 @@ import java.util.Set; import java.util.UUID; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.sql.ExpressionUtils.and; import static com.facebook.presto.sql.ExpressionUtils.combineConjuncts; @@ -140,7 +139,7 @@ public void setUp() public void testAggregation() { FunctionCall functionCall = new FunctionCall(QualifiedName.of("count"), ImmutableList.of()); - FunctionHandle functionHandle = metadata.getFunctionManager().resolveFunction(TEST_SESSION, QualifiedName.of("count"), ImmutableList.of()); + FunctionHandle functionHandle = metadata.getFunctionManager().lookupFunction(QualifiedName.of("count"), ImmutableList.of()); PlanNode node = new AggregationNode(newId(), filter(baseTableScan, and( diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/TestTypeValidator.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/TestTypeValidator.java index 857f09031bd30..c85f5d5fef116 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/TestTypeValidator.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/TestTypeValidator.java @@ -147,7 +147,7 @@ public void testValidUnion() public void testValidWindow() { Symbol windowSymbol = symbolAllocator.newSymbol("sum", DOUBLE); - FunctionHandle functionHandle = FUNCTION_MANAGER.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(DOUBLE)); + FunctionHandle functionHandle = FUNCTION_MANAGER.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE)); FunctionCall functionCall = new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnC.toSymbolReference())); WindowNode.Frame frame = new WindowNode.Frame( @@ -185,7 +185,7 @@ public void testValidAggregation() baseTableScan, ImmutableMap.of(aggregationSymbol, new Aggregation( new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnC.toSymbolReference())), - FUNCTION_MANAGER.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(DOUBLE)), + FUNCTION_MANAGER.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE)), Optional.empty())), singleGroupingSet(ImmutableList.of(columnA, columnB)), ImmutableList.of(), @@ -236,7 +236,7 @@ public void testInvalidAggregationFunctionCall() baseTableScan, ImmutableMap.of(aggregationSymbol, new Aggregation( new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnA.toSymbolReference())), - FUNCTION_MANAGER.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(DOUBLE)), + FUNCTION_MANAGER.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE)), Optional.empty())), singleGroupingSet(ImmutableList.of(columnA, columnB)), ImmutableList.of(), @@ -257,7 +257,7 @@ public void testInvalidAggregationFunctionSignature() baseTableScan, ImmutableMap.of(aggregationSymbol, new Aggregation( new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnC.toSymbolReference())), - FUNCTION_MANAGER.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(BIGINT)), // should be DOUBLE + FUNCTION_MANAGER.lookupFunction(QualifiedName.of("sum"), fromTypes(BIGINT)), // should be DOUBLE Optional.empty())), singleGroupingSet(ImmutableList.of(columnA, columnB)), ImmutableList.of(), @@ -272,7 +272,7 @@ public void testInvalidAggregationFunctionSignature() public void testInvalidWindowFunctionCall() { Symbol windowSymbol = symbolAllocator.newSymbol("sum", DOUBLE); - FunctionHandle functionHandle = FUNCTION_MANAGER.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(DOUBLE)); + FunctionHandle functionHandle = FUNCTION_MANAGER.lookupFunction(QualifiedName.of("sum"), fromTypes(DOUBLE)); FunctionCall functionCall = new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnA.toSymbolReference())); // should be columnC WindowNode.Frame frame = new WindowNode.Frame( @@ -304,7 +304,7 @@ public void testInvalidWindowFunctionCall() public void testInvalidWindowFunctionSignature() { Symbol windowSymbol = symbolAllocator.newSymbol("sum", DOUBLE); - FunctionHandle functionHandle = FUNCTION_MANAGER.resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(BIGINT)); // should be DOUBLE + FunctionHandle functionHandle = FUNCTION_MANAGER.lookupFunction(QualifiedName.of("sum"), fromTypes(BIGINT)); // should be DOUBLE FunctionCall functionCall = new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnC.toSymbolReference())); WindowNode.Frame frame = new WindowNode.Frame( diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestMergeAdjacentWindows.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestMergeAdjacentWindows.java index 2542e9cb81e6c..cfbed42ff13fd 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestMergeAdjacentWindows.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestMergeAdjacentWindows.java @@ -33,7 +33,6 @@ import java.util.Optional; import java.util.stream.Collectors; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -59,7 +58,7 @@ public class TestMergeAdjacentWindows Optional.empty(), Optional.empty()); - private static final FunctionHandle FUNCTION_HANDLE = createTestMetadataManager().getFunctionManager().resolveFunction(TEST_SESSION, QualifiedName.of("avg"), fromTypes(DOUBLE)); + private static final FunctionHandle FUNCTION_HANDLE = createTestMetadataManager().getFunctionManager().lookupFunction(QualifiedName.of("avg"), fromTypes(DOUBLE)); private static final String columnAAlias = "ALIAS_A"; private static final ExpectedValueProvider specificationA = specification(ImmutableList.of(columnAAlias), ImmutableList.of(), ImmutableMap.of()); diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestSwapAdjacentWindowsBySpecifications.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestSwapAdjacentWindowsBySpecifications.java index 39c0fc8815777..fdd9f2686e007 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestSwapAdjacentWindowsBySpecifications.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestSwapAdjacentWindowsBySpecifications.java @@ -28,7 +28,6 @@ import java.util.Optional; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -57,7 +56,7 @@ public TestSwapAdjacentWindowsBySpecifications() Optional.empty(), Optional.empty()); - functionHandle = createTestMetadataManager().getFunctionManager().resolveFunction(TEST_SESSION, QualifiedName.of("avg"), fromTypes(BIGINT)); + functionHandle = createTestMetadataManager().getFunctionManager().lookupFunction(QualifiedName.of("avg"), fromTypes(BIGINT)); } @Test diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/plan/TestWindowNode.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/plan/TestWindowNode.java index c9987be386e71..7859d04881b2c 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/plan/TestWindowNode.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/plan/TestWindowNode.java @@ -41,7 +41,6 @@ import java.util.Set; import java.util.UUID; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; @@ -91,7 +90,7 @@ public void testSerializationRoundtrip() throws Exception { Symbol windowSymbol = symbolAllocator.newSymbol("sum", BIGINT); - FunctionHandle functionHandle = createTestMetadataManager().getFunctionManager().resolveFunction(TEST_SESSION, QualifiedName.of("sum"), fromTypes(BIGINT)); + FunctionHandle functionHandle = createTestMetadataManager().getFunctionManager().lookupFunction(QualifiedName.of("sum"), fromTypes(BIGINT)); FunctionCall functionCall = new FunctionCall(QualifiedName.of("sum"), ImmutableList.of(columnC.toSymbolReference())); WindowNode.Frame frame = new WindowNode.Frame( WindowFrame.Type.RANGE, diff --git a/presto-main/src/test/java/com/facebook/presto/sql/relational/TestDeterminismEvaluator.java b/presto-main/src/test/java/com/facebook/presto/sql/relational/TestDeterminismEvaluator.java index 6fe3798113a60..3f2d775db4f5b 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/relational/TestDeterminismEvaluator.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/relational/TestDeterminismEvaluator.java @@ -13,18 +13,17 @@ */ package com.facebook.presto.sql.relational; -import com.facebook.presto.spi.function.Signature; -import com.facebook.presto.spi.type.StandardTypes; +import com.facebook.presto.metadata.FunctionManager; +import com.facebook.presto.spi.function.FunctionHandle; +import com.facebook.presto.sql.tree.QualifiedName; import com.google.common.collect.ImmutableList; import org.testng.annotations.Test; -import static com.facebook.presto.metadata.InternalSignatureUtils.internalOperator; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.function.OperatorType.LESS_THAN; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; -import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.relational.Expressions.constant; import static com.facebook.presto.sql.relational.Expressions.field; import static java.util.Collections.singletonList; @@ -36,20 +35,17 @@ public class TestDeterminismEvaluator @Test public void testDeterminismEvaluator() { - DeterminismEvaluator determinismEvaluator = new DeterminismEvaluator(createTestMetadataManager().getFunctionManager()); + FunctionManager functionManager = createTestMetadataManager().getFunctionManager(); + DeterminismEvaluator determinismEvaluator = new DeterminismEvaluator(functionManager); CallExpression random = new CallExpression( - new Signature( - "random", - SCALAR, - parseTypeSignature(StandardTypes.BIGINT), - parseTypeSignature(StandardTypes.BIGINT)), + functionManager.lookupFunction(QualifiedName.of("random"), fromTypes(BIGINT)), BIGINT, singletonList(constant(10L, BIGINT))); assertFalse(determinismEvaluator.isDeterministic(random)); InputReferenceExpression col0 = field(0, BIGINT); - Signature lessThan = internalOperator(LESS_THAN, BOOLEAN, ImmutableList.of(BIGINT, BIGINT)); + FunctionHandle lessThan = functionManager.resolveOperator(LESS_THAN, fromTypes(BIGINT, BIGINT)); CallExpression lessThanExpression = new CallExpression(lessThan, BOOLEAN, ImmutableList.of(col0, constant(10L, BIGINT))); assertTrue(determinismEvaluator.isDeterministic(lessThanExpression)); diff --git a/presto-main/src/test/java/com/facebook/presto/type/BenchmarkDecimalOperators.java b/presto-main/src/test/java/com/facebook/presto/type/BenchmarkDecimalOperators.java index 23571df83fec9..e6bf6a7532616 100644 --- a/presto-main/src/test/java/com/facebook/presto/type/BenchmarkDecimalOperators.java +++ b/presto-main/src/test/java/com/facebook/presto/type/BenchmarkDecimalOperators.java @@ -66,7 +66,6 @@ import static com.facebook.presto.memory.context.AggregatedMemoryContext.newSimpleAggregatedMemoryContext; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.operator.scalar.FunctionAssertions.createExpression; -import static com.facebook.presto.spi.function.FunctionKind.SCALAR; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DecimalType.createDecimalType; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -619,7 +618,7 @@ private RowExpression rowExpression(String expression) .collect(toMap(Map.Entry::getValue, entry -> symbolTypes.get(entry.getKey()))); Map, Type> expressionTypes = getExpressionTypesFromInput(TEST_SESSION, metadata, SQL_PARSER, types, inputReferenceExpression, emptyList(), WarningCollector.NOOP); - return SqlToRowExpressionTranslator.translate(inputReferenceExpression, SCALAR, expressionTypes, metadata.getFunctionManager(), metadata.getTypeManager(), TEST_SESSION, true); + return SqlToRowExpressionTranslator.translate(inputReferenceExpression, expressionTypes, metadata.getFunctionManager(), metadata.getTypeManager(), TEST_SESSION, true); } private Object generateRandomValue(Type type) diff --git a/presto-main/src/test/java/com/facebook/presto/type/TestTypeRegistry.java b/presto-main/src/test/java/com/facebook/presto/type/TestTypeRegistry.java index 96f6dfed87c22..2bffac6be7862 100644 --- a/presto-main/src/test/java/com/facebook/presto/type/TestTypeRegistry.java +++ b/presto-main/src/test/java/com/facebook/presto/type/TestTypeRegistry.java @@ -14,14 +14,13 @@ package com.facebook.presto.type; import com.facebook.presto.block.BlockEncodingManager; +import com.facebook.presto.metadata.CastType; import com.facebook.presto.metadata.FunctionManager; import com.facebook.presto.metadata.OperatorNotFoundException; -import com.facebook.presto.spi.function.OperatorType; import com.facebook.presto.spi.type.Type; import com.facebook.presto.spi.type.TypeManager; import com.facebook.presto.spi.type.TypeSignature; import com.facebook.presto.sql.analyzer.FeaturesConfig; -import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import org.testng.annotations.Test; @@ -54,6 +53,7 @@ import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.spi.type.VarcharType.createUnboundedVarcharType; import static com.facebook.presto.spi.type.VarcharType.createVarcharType; +import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.type.JoniRegexpType.JONI_REGEXP; import static com.facebook.presto.type.JsonPathType.JSON_PATH; import static com.facebook.presto.type.LikePatternType.LIKE_PATTERN; @@ -253,7 +253,7 @@ public void testCastOperatorsExistForCoercions() for (Type resultType : types) { if (typeRegistry.canCoerce(sourceType, resultType) && sourceType != UNKNOWN && resultType != UNKNOWN) { try { - functionManager.lookupCast(OperatorType.CAST, sourceType.getTypeSignature(), resultType.getTypeSignature()); + functionManager.lookupCast(CastType.CAST, sourceType.getTypeSignature(), resultType.getTypeSignature()); } catch (OperatorNotFoundException e) { fail(format("'%s' -> '%s' coercion exists but there is no cast operator", sourceType, resultType)); @@ -268,16 +268,16 @@ public void testOperatorsImplemented() { for (Type type : typeRegistry.getTypes()) { if (type.isComparable()) { - functionManager.resolveOperator(EQUAL, ImmutableList.of(type, type)); - functionManager.resolveOperator(NOT_EQUAL, ImmutableList.of(type, type)); - functionManager.resolveOperator(IS_DISTINCT_FROM, ImmutableList.of(type, type)); - functionManager.resolveOperator(HASH_CODE, ImmutableList.of(type)); + functionManager.resolveOperator(EQUAL, fromTypes(type, type)); + functionManager.resolveOperator(NOT_EQUAL, fromTypes(type, type)); + functionManager.resolveOperator(IS_DISTINCT_FROM, fromTypes(type, type)); + functionManager.resolveOperator(HASH_CODE, fromTypes(type)); } if (type.isOrderable()) { - functionManager.resolveOperator(LESS_THAN, ImmutableList.of(type, type)); - functionManager.resolveOperator(LESS_THAN_OR_EQUAL, ImmutableList.of(type, type)); - functionManager.resolveOperator(GREATER_THAN_OR_EQUAL, ImmutableList.of(type, type)); - functionManager.resolveOperator(GREATER_THAN, ImmutableList.of(type, type)); + functionManager.resolveOperator(LESS_THAN, fromTypes(type, type)); + functionManager.resolveOperator(LESS_THAN_OR_EQUAL, fromTypes(type, type)); + functionManager.resolveOperator(GREATER_THAN_OR_EQUAL, fromTypes(type, type)); + functionManager.resolveOperator(GREATER_THAN, fromTypes(type, type)); } } } diff --git a/presto-ml/src/test/java/com/facebook/presto/ml/TestEvaluateClassifierPredictions.java b/presto-ml/src/test/java/com/facebook/presto/ml/TestEvaluateClassifierPredictions.java index 742083a63b139..dec4e14fdf769 100644 --- a/presto-ml/src/test/java/com/facebook/presto/ml/TestEvaluateClassifierPredictions.java +++ b/presto-ml/src/test/java/com/facebook/presto/ml/TestEvaluateClassifierPredictions.java @@ -29,7 +29,6 @@ import java.util.List; import java.util.Optional; -import static com.facebook.presto.SessionTestUtils.TEST_SESSION; import static com.facebook.presto.metadata.FunctionExtractor.extractFunctions; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; @@ -46,7 +45,7 @@ public void testEvaluateClassifierPredictions() { metadata.addFunctions(extractFunctions(new MLPlugin().getFunctions())); InternalAggregationFunction aggregation = functionManager.getAggregateFunctionImplementation( - functionManager.resolveFunction(TEST_SESSION, QualifiedName.of("evaluate_classifier_predictions"), fromTypes(BIGINT, BIGINT))); + functionManager.lookupFunction(QualifiedName.of("evaluate_classifier_predictions"), fromTypes(BIGINT, BIGINT))); Accumulator accumulator = aggregation.bind(ImmutableList.of(0, 1), Optional.empty()).createAccumulator(); accumulator.addInput(getPage()); BlockBuilder finalOut = accumulator.getFinalType().createBlockBuilder(null, 1); diff --git a/presto-spi/src/main/java/com/facebook/presto/spi/function/OperatorDependency.java b/presto-spi/src/main/java/com/facebook/presto/spi/function/OperatorDependency.java index b4172aad61b35..1d034a79211b5 100644 --- a/presto-spi/src/main/java/com/facebook/presto/spi/function/OperatorDependency.java +++ b/presto-spi/src/main/java/com/facebook/presto/spi/function/OperatorDependency.java @@ -26,8 +26,6 @@ { OperatorType operator(); - String returnType(); - String[] argumentTypes(); Convention convention() default @Convention($notSpecified = true, arguments = {}, result = FAIL_ON_NULL);