From 60b79a4ca5dbb4fd83e84b4026164f26626df5e5 Mon Sep 17 00:00:00 2001 From: Pratik Joseph Dabre Date: Fri, 26 Sep 2025 10:10:57 -0700 Subject: [PATCH] Fix constant folding for SpecialFormExpression and LambdaDefinitionExpression in sidecar enabled clusters Co-authored-by: aditi-pandit --- .../presto/sql/planner/QueryPlanner.java | 6 +- .../sql/planner/RowExpressionInterpreter.java | 2 +- .../sql/relational/FunctionResolution.java | 7 +- .../relational/RowExpressionOptimizer.java | 68 ++----- .../TestRowExpressionOptimizer.java | 185 +++++++++++++----- .../sidecar/TestNativeSidecarPlugin.java | 2 +- 6 files changed, 163 insertions(+), 107 deletions(-) diff --git a/presto-main-base/src/main/java/com/facebook/presto/sql/planner/QueryPlanner.java b/presto-main-base/src/main/java/com/facebook/presto/sql/planner/QueryPlanner.java index 7199daeb239f1..10ad2b1f68e7d 100644 --- a/presto-main-base/src/main/java/com/facebook/presto/sql/planner/QueryPlanner.java +++ b/presto-main-base/src/main/java/com/facebook/presto/sql/planner/QueryPlanner.java @@ -14,6 +14,7 @@ package com.facebook.presto.sql.planner; import com.facebook.presto.Session; +import com.facebook.presto.common.CatalogSchemaName; import com.facebook.presto.common.QualifiedObjectName; import com.facebook.presto.common.block.SortOrder; import com.facebook.presto.common.predicate.TupleDomain; @@ -114,7 +115,6 @@ import static com.facebook.presto.sql.NodeUtils.getSortItemsFromOrderBy; import static com.facebook.presto.sql.analyzer.ExpressionAnalyzer.isNumericType; import static com.facebook.presto.sql.analyzer.ExpressionTreeUtils.getSourceLocation; -import static com.facebook.presto.sql.analyzer.TypeSignatureProvider.fromTypes; import static com.facebook.presto.sql.planner.PlannerUtils.newVariable; import static com.facebook.presto.sql.planner.PlannerUtils.toOrderingScheme; import static com.facebook.presto.sql.planner.PlannerUtils.toSortOrder; @@ -1112,7 +1112,7 @@ private FrameBoundPlanAndSymbols planFrameBound(PlanBuilder subPlan, PlanAndMapp // First, append filter to validate offset values. They mustn't be negative or null. VariableReferenceExpression offsetSymbol = coercions.get(frameOffset.get()); Expression zeroOffset = zeroOfType(TypeProvider.viewOf(variableAllocator.getVariables()).get(offsetSymbol)); - FunctionHandle fail = metadata.getFunctionAndTypeManager().resolveFunction(Optional.empty(), Optional.empty(), QualifiedObjectName.valueOf("presto.default.fail"), fromTypes(VARCHAR)); + CatalogSchemaName defaultNamespace = metadata.getFunctionAndTypeManager().getDefaultNamespace(); Expression predicate = new IfExpression( new ComparisonExpression( GREATER_THAN_OR_EQUAL, @@ -1121,7 +1121,7 @@ private FrameBoundPlanAndSymbols planFrameBound(PlanBuilder subPlan, PlanAndMapp TRUE_LITERAL, new Cast( new FunctionCall( - QualifiedName.of("presto", "default", "fail"), + QualifiedName.of(defaultNamespace.getCatalogName(), defaultNamespace.getSchemaName(), "fail"), ImmutableList.of(new Cast(new StringLiteral("Window frame offset value must not be negative or null"), VARCHAR.getTypeSignature().toString()))), BOOLEAN.getTypeSignature().toString())); subPlan = subPlan.withNewRoot(new FilterNode( diff --git a/presto-main-base/src/main/java/com/facebook/presto/sql/planner/RowExpressionInterpreter.java b/presto-main-base/src/main/java/com/facebook/presto/sql/planner/RowExpressionInterpreter.java index 8c89750b6d78a..3b24606a808ef 100644 --- a/presto-main-base/src/main/java/com/facebook/presto/sql/planner/RowExpressionInterpreter.java +++ b/presto-main-base/src/main/java/com/facebook/presto/sql/planner/RowExpressionInterpreter.java @@ -264,7 +264,7 @@ public Object visitCall(CallExpression node, Object context) (!functionMetadata.isDeterministic() || hasUnresolvedValue(argumentValues) || isDynamicFilter(node) || - resolution.isFailFunction(functionHandle))) { + resolution.isJavaBuiltInFailFunction(functionHandle))) { return call(node.getDisplayName(), functionHandle, node.getType(), toRowExpressions(argumentValues, node.getArguments())); } diff --git a/presto-main-base/src/main/java/com/facebook/presto/sql/relational/FunctionResolution.java b/presto-main-base/src/main/java/com/facebook/presto/sql/relational/FunctionResolution.java index 337582257bad4..3aa2a3b544ca7 100644 --- a/presto-main-base/src/main/java/com/facebook/presto/sql/relational/FunctionResolution.java +++ b/presto-main-base/src/main/java/com/facebook/presto/sql/relational/FunctionResolution.java @@ -300,9 +300,12 @@ public boolean isTryFunction(FunctionHandle functionHandle) return functionAndTypeResolver.getFunctionMetadata(functionHandle).getName().getObjectName().equals("$internal$try"); } - public boolean isFailFunction(FunctionHandle functionHandle) + public boolean isJavaBuiltInFailFunction(FunctionHandle functionHandle) { - return functionAndTypeResolver.getFunctionMetadata(functionHandle).getName().equals(functionAndTypeResolver.qualifyObjectName(QualifiedName.of("fail"))); + // todo: Revert this hack once constant folding support lands in C++. + // For now, we always use the presto.default.fail function even when the default namespace is switched. + // This is done for consistency since the BuiltInNamespaceRewriter rewrites the functionHandles to presto.default functionHandles. + return functionAndTypeResolver.getFunctionMetadata(functionHandle).getName().equals(QualifiedObjectName.valueOf(JAVA_BUILTIN_NAMESPACE, "fail")); } @Override diff --git a/presto-main-base/src/main/java/com/facebook/presto/sql/relational/RowExpressionOptimizer.java b/presto-main-base/src/main/java/com/facebook/presto/sql/relational/RowExpressionOptimizer.java index fac9ef76fb3d7..caf443379fb4c 100644 --- a/presto-main-base/src/main/java/com/facebook/presto/sql/relational/RowExpressionOptimizer.java +++ b/presto-main-base/src/main/java/com/facebook/presto/sql/relational/RowExpressionOptimizer.java @@ -15,6 +15,8 @@ import com.facebook.presto.common.CatalogSchemaName; import com.facebook.presto.common.QualifiedObjectName; +import com.facebook.presto.expressions.RowExpressionRewriter; +import com.facebook.presto.expressions.RowExpressionTreeRewriter; import com.facebook.presto.metadata.FunctionAndTypeManager; import com.facebook.presto.metadata.Metadata; import com.facebook.presto.spi.ConnectorSession; @@ -24,7 +26,6 @@ import com.facebook.presto.spi.relation.CallExpression; import com.facebook.presto.spi.relation.ExpressionOptimizer; import com.facebook.presto.spi.relation.RowExpression; -import com.facebook.presto.spi.relation.RowExpressionVisitor; import com.facebook.presto.spi.relation.VariableReferenceExpression; import com.facebook.presto.sql.analyzer.TypeSignatureProvider; import com.facebook.presto.sql.planner.RowExpressionInterpreter; @@ -106,7 +107,7 @@ public RowExpression convertToInterpreterNamespace(RowExpression expression) // No need to replace built-in namespaces if the default namespace is already the Java built-in namespace return expression; } - return expression.accept(new ReplaceBuiltInNamespaces(), null); + return RowExpressionTreeRewriter.rewriteWith(new ReplaceBuiltInNamespaces(), expression, null); } public RowExpression restoreOriginalNamespaces(RowExpression expression) @@ -114,25 +115,15 @@ public RowExpression restoreOriginalNamespaces(RowExpression expression) if (defaultToOriginalFunctionHandles.isEmpty()) { return expression; } - return expression.accept(new ReplaceOriginalNamespaces(), null); + return RowExpressionTreeRewriter.rewriteWith(new ReplaceOriginalNamespaces(), expression, null); } private class ReplaceBuiltInNamespaces - implements RowExpressionVisitor + extends RowExpressionRewriter { @Override - public RowExpression visitExpression(RowExpression expression, Void context) + public RowExpression rewriteCall(CallExpression call, Void context, RowExpressionTreeRewriter treeRewriter) { - return expression; - } - - @Override - public RowExpression visitCall(CallExpression call, Void context) - { - ImmutableList rewrittenArgs = call.getArguments().stream() - .map(arg -> arg.accept(this, context)) - .collect(toImmutableList()); - FunctionHandle functionHandle = call.getFunctionHandle(); FunctionMetadata functionMetadata = functionAndTypeManager.getFunctionMetadata(functionHandle); if (!functionMetadata.getImplementationType().canBeEvaluatedInCoordinator()) { @@ -148,13 +139,8 @@ public RowExpression visitCall(CallExpression call, Void context) } catch (PrestoException e) { if (e.getErrorCode().equals(FUNCTION_NOT_FOUND.toErrorCode())) { - // If the function is not found in the Java built-in namespace, return with rewritten children. - return new CallExpression( - call.getSourceLocation(), - call.getDisplayName(), - call.getFunctionHandle(), - call.getType(), - rewrittenArgs); + // If the function is not found in the Java built-in namespace, let default rewriter handle it + return null; } throw e; // Rethrow other exceptions } @@ -163,6 +149,9 @@ public RowExpression visitCall(CallExpression call, Void context) format("FunctionHandle %s in the Java built-in namespace (%s) is not eligible to be evaluated in the coordinator", javaNamespaceFunctionHandle, JAVA_BUILTIN_NAMESPACE)); defaultToOriginalFunctionHandles.put(javaNamespaceFunctionHandle, functionHandle); + ImmutableList rewrittenArgs = call.getArguments().stream() + .map(arg -> treeRewriter.rewrite(arg, context)) + .collect(toImmutableList()); return new CallExpression( call.getSourceLocation(), call.getDisplayName(), @@ -171,34 +160,22 @@ public RowExpression visitCall(CallExpression call, Void context) rewrittenArgs); } - // If no rewrite needed, still return with rewritten children - return new CallExpression( - call.getSourceLocation(), - call.getDisplayName(), - functionHandle, - call.getType(), - rewrittenArgs); + // Return null to let the default rewriter handle it (which will rewrite children automatically) + return null; } } private class ReplaceOriginalNamespaces - implements RowExpressionVisitor + extends RowExpressionRewriter { @Override - public RowExpression visitExpression(RowExpression expression, Void context) + public RowExpression rewriteCall(CallExpression call, Void context, RowExpressionTreeRewriter treeRewriter) { - return expression; - } - - @Override - public RowExpression visitCall(CallExpression call, Void context) - { - ImmutableList rewrittenArgs = call.getArguments().stream() - .map(arg -> arg.accept(this, context)) - .collect(toImmutableList()); - if (defaultToOriginalFunctionHandles.containsKey(call.getFunctionHandle())) { FunctionHandle originalFunctionHandle = defaultToOriginalFunctionHandles.get(call.getFunctionHandle()); + ImmutableList rewrittenArgs = call.getArguments().stream() + .map(arg -> treeRewriter.rewrite(arg, context)) + .collect(toImmutableList()); return new CallExpression( call.getSourceLocation(), call.getDisplayName(), @@ -206,13 +183,8 @@ public RowExpression visitCall(CallExpression call, Void context) call.getType(), rewrittenArgs); } - // Nothing to restore, just rebuild with rewritten children - return new CallExpression( - call.getSourceLocation(), - call.getDisplayName(), - call.getFunctionHandle(), - call.getType(), - rewrittenArgs); + // Return null to let the default rewriter handle it (which will rewrite children automatically) + return null; } } } diff --git a/presto-main-base/src/test/java/com/facebook/presto/sql/relational/TestRowExpressionOptimizer.java b/presto-main-base/src/test/java/com/facebook/presto/sql/relational/TestRowExpressionOptimizer.java index 4167c0fb5e594..0a100ac9f8757 100644 --- a/presto-main-base/src/test/java/com/facebook/presto/sql/relational/TestRowExpressionOptimizer.java +++ b/presto-main-base/src/test/java/com/facebook/presto/sql/relational/TestRowExpressionOptimizer.java @@ -15,9 +15,11 @@ import com.facebook.presto.common.QualifiedObjectName; import com.facebook.presto.common.block.IntArrayBlock; +import com.facebook.presto.common.function.OperatorType; import com.facebook.presto.common.type.ArrayType; import com.facebook.presto.common.type.RowType; import com.facebook.presto.common.type.StandardTypes; +import com.facebook.presto.common.type.Type; import com.facebook.presto.functionNamespace.SqlInvokedFunctionNamespaceManagerConfig; import com.facebook.presto.functionNamespace.execution.NoopSqlFunctionExecutor; import com.facebook.presto.functionNamespace.execution.SqlFunctionExecutors; @@ -33,6 +35,7 @@ import com.facebook.presto.spi.function.SqlInvokedFunction; import com.facebook.presto.spi.relation.CallExpression; import com.facebook.presto.spi.relation.ConstantExpression; +import com.facebook.presto.spi.relation.LambdaDefinitionExpression; import com.facebook.presto.spi.relation.RowExpression; import com.facebook.presto.spi.relation.SpecialFormExpression; import com.facebook.presto.sql.analyzer.FunctionsConfig; @@ -42,10 +45,15 @@ import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; +import java.util.List; +import java.util.Optional; + import static com.facebook.airlift.testing.Assertions.assertInstanceOf; import static com.facebook.presto.block.BlockAssertions.toValues; import static com.facebook.presto.common.function.OperatorType.ADD; import static com.facebook.presto.common.function.OperatorType.EQUAL; +import static com.facebook.presto.common.function.OperatorType.GREATER_THAN; +import static com.facebook.presto.common.function.OperatorType.LESS_THAN; import static com.facebook.presto.common.type.BigintType.BIGINT; import static com.facebook.presto.common.type.BooleanType.BOOLEAN; import static com.facebook.presto.common.type.DoubleType.DOUBLE; @@ -94,7 +102,7 @@ public class TestRowExpressionOptimizer RoutineCharacteristics.builder().setLanguage(CPP).setDeterminism(DETERMINISTIC).setNullCallClause(RETURNS_NULL_ON_NULL_INPUT).build(), "", notVersioned()); - public static final SqlInvokedFunction CPP_CUSTOM_FUNCTION = new SqlInvokedFunction( + private static final SqlInvokedFunction CPP_CUSTOM_FUNCTION = new SqlInvokedFunction( new QualifiedObjectName("native", "default", "cpp_custom_func"), ImmutableList.of(new Parameter("x", parseTypeSignature(StandardTypes.BIGINT))), parseTypeSignature(StandardTypes.BIGINT), @@ -104,6 +112,28 @@ public class TestRowExpressionOptimizer notVersioned()); private static final String nativePrefix = "native.default"; + private static final RowExpression CUBE_ROOT_EXP = call( + "cbrt", + new SqlFunctionHandle( + new SqlFunctionId( + QualifiedObjectName.valueOf(format("%s.cbrt", nativePrefix)), + ImmutableList.of(BIGINT.getTypeSignature())), + "1"), + DOUBLE, + ImmutableList.of( + constant(27L, BIGINT))); + + private static final RowExpression SQUARE_ROOT_EXP = call( + "sqrt", + new SqlFunctionHandle( + new SqlFunctionId( + QualifiedObjectName.valueOf(format("%s.sqrt", nativePrefix)), + ImmutableList.of(BIGINT.getTypeSignature())), + "1"), + DOUBLE, + ImmutableList.of( + constant(64L, BIGINT))); + private FunctionAndTypeManager functionAndTypeManager; private RowExpressionOptimizer optimizer; @@ -186,42 +216,11 @@ public void testCastWithJsonParseOptimization() public void testDefaultExpressionOptimizerUsesJavaNamespaceForBuiltInFunctions() { RowExpressionOptimizer nativeOptimizer = getNativeOptimizer(); - RowExpression simpleAddition = call( - "sqrt", - new SqlFunctionHandle( - new SqlFunctionId( - QualifiedObjectName.valueOf(format("%s.sqrt", nativePrefix)), - ImmutableList.of(BIGINT.getTypeSignature())), - "1"), - DOUBLE, - ImmutableList.of( - constant(4L, BIGINT))); - assertEquals(nativeOptimizer.optimize(simpleAddition, OPTIMIZED, SESSION), constant(2.0, DOUBLE)); - assertThrows(IllegalArgumentException.class, () -> optimizer.optimize(simpleAddition, OPTIMIZED, SESSION)); - - RowExpression sqrt = call( - "sqrt", - new SqlFunctionHandle( - new SqlFunctionId( - QualifiedObjectName.valueOf(format("%s.sqrt", nativePrefix)), - ImmutableList.of(BIGINT.getTypeSignature())), - "1"), - DOUBLE, - ImmutableList.of( - constant(64L, BIGINT))); + assertEquals(nativeOptimizer.optimize(SQUARE_ROOT_EXP, OPTIMIZED, SESSION), constant(8.0, DOUBLE)); + assertThrows(IllegalArgumentException.class, () -> optimizer.optimize(SQUARE_ROOT_EXP, OPTIMIZED, SESSION)); - RowExpression cbrt = call( - "cbrt", - new SqlFunctionHandle( - new SqlFunctionId( - QualifiedObjectName.valueOf(format("%s.cbrt", nativePrefix)), - ImmutableList.of(BIGINT.getTypeSignature())), - "1"), - DOUBLE, - ImmutableList.of(sqrt)); - - assertEquals(nativeOptimizer.optimize(cbrt, OPTIMIZED, SESSION), constant(2.0, DOUBLE)); - assertThrows(IllegalArgumentException.class, () -> optimizer.optimize(cbrt, OPTIMIZED, SESSION)); + assertEquals(nativeOptimizer.optimize(CUBE_ROOT_EXP, OPTIMIZED, SESSION), constant(3.0, DOUBLE)); + assertThrows(IllegalArgumentException.class, () -> optimizer.optimize(CUBE_ROOT_EXP, OPTIMIZED, SESSION)); } @Test @@ -229,17 +228,6 @@ public void testFunctionNotInPrestoDefaultNamespaceIsNotEvaluated() { RowExpressionOptimizer nativeOptimizer = getNativeOptimizer(); - RowExpression sqrt = call( - "sqrt", - new SqlFunctionHandle( - new SqlFunctionId( - QualifiedObjectName.valueOf(format("%s.sqrt", nativePrefix)), - ImmutableList.of(BIGINT.getTypeSignature())), - "1"), - DOUBLE, - ImmutableList.of( - constant(64L, BIGINT))); - // Create a call expression to the custom native function RowExpression customFunctionCall = call( "cpp_custom_func", @@ -270,7 +258,7 @@ public void testFunctionNotInPrestoDefaultNamespaceIsNotEvaluated() ImmutableList.of(BIGINT.getTypeSignature())), "1"), BIGINT, - ImmutableList.of(sqrt)); + ImmutableList.of(SQUARE_ROOT_EXP)); // The inner CallExpression should be optimized, but the outer shouldn't since the function doesn't exist in presto.default namespace optimized = nativeOptimizer.optimize(customFunctionWithCallExpressionCall, OPTIMIZED, SESSION); @@ -292,14 +280,96 @@ public void testFunctionNotInPrestoDefaultNamespaceIsNotEvaluated() assertEquals(optimizedCall.getChildren().get(0), constant(8.0, DOUBLE)); } - private static RowExpression ifExpression(RowExpression condition, long trueValue, long falseValue) + @Test + public void testSpecialFormExpressionsWhenDefaultNamespaceIsSwitched() { - return new SpecialFormExpression(IF, BIGINT, ImmutableList.of(condition, constant(trueValue, BIGINT), constant(falseValue, BIGINT))); + RowExpressionOptimizer nativeOptimizer = getNativeOptimizer(); + + RowExpression leftCondition = callOperator( + GREATER_THAN, + SQUARE_ROOT_EXP, + constant(5.0, DOUBLE)); + + RowExpression rightCondition = callOperator( + LESS_THAN, + CUBE_ROOT_EXP, + constant(10.0, DOUBLE)); + + RowExpression andExpr = new SpecialFormExpression( + SpecialFormExpression.Form.AND, + BOOLEAN, + ImmutableList.of(leftCondition, rightCondition)); + + RowExpression optimized = nativeOptimizer.optimize(andExpr, OPTIMIZED, SESSION); + assertEquals(optimized, constant(true, BOOLEAN)); + + // Lambda expressions inside Special form expressions + List lambdaTypes = ImmutableList.of(DOUBLE, DOUBLE); + LambdaDefinitionExpression lambda = + new LambdaDefinitionExpression( + Optional.empty(), + lambdaTypes, + ImmutableList.of("s", "x"), + callOperator(ADD, SQUARE_ROOT_EXP, CUBE_ROOT_EXP)); + + andExpr = new SpecialFormExpression( + SpecialFormExpression.Form.AND, + BOOLEAN, + ImmutableList.of(lambda, rightCondition)); + + // rightCondition is always true, hence the expression should be reduced to "(s, x) -> 11.0". + optimized = nativeOptimizer.optimize(andExpr, OPTIMIZED, SESSION); + + assertInstanceOf(optimized, LambdaDefinitionExpression.class); + LambdaDefinitionExpression lambdaExpression = (LambdaDefinitionExpression) optimized; + assertEquals(lambdaExpression.getArgumentTypes(), lambdaTypes); + assertEquals(lambdaExpression.getBody(), constant(11.0, DOUBLE)); } - private RowExpression optimize(RowExpression expression) + @Test + public void testLambdaExpressionsWhenDefaultNamespaceIsSwitched() { - return optimizer.optimize(expression, OPTIMIZED, SESSION); + RowExpressionOptimizer nativeOptimizer = getNativeOptimizer(); + + List lambdaTypes = ImmutableList.of(DOUBLE, DOUBLE); + + LambdaDefinitionExpression lambda = + new LambdaDefinitionExpression( + Optional.empty(), + lambdaTypes, + ImmutableList.of("s", "x"), + callOperator(ADD, SQUARE_ROOT_EXP, CUBE_ROOT_EXP)); + + LambdaDefinitionExpression nestedLambda = + new LambdaDefinitionExpression( + Optional.empty(), + ImmutableList.of(DOUBLE), + ImmutableList.of("y"), + lambda); + + RowExpression optimized = nativeOptimizer.optimize(lambda, OPTIMIZED, SESSION); + + assertInstanceOf(optimized, LambdaDefinitionExpression.class); + LambdaDefinitionExpression lambdaExpression = (LambdaDefinitionExpression) optimized; + assertEquals(lambdaExpression.getArgumentTypes(), lambdaTypes); + assertEquals(lambdaExpression.getBody(), constant(11.0, DOUBLE)); + + // Nested lambda + RowExpression optimizedOuterLambda = nativeOptimizer.optimize(nestedLambda, OPTIMIZED, SESSION); + + assertInstanceOf(optimizedOuterLambda, LambdaDefinitionExpression.class); + LambdaDefinitionExpression outerLambdaExpression = (LambdaDefinitionExpression) optimizedOuterLambda; + assertEquals(outerLambdaExpression.getArgumentTypes(), ImmutableList.of(DOUBLE)); + assertInstanceOf(outerLambdaExpression.getBody(), LambdaDefinitionExpression.class); + + LambdaDefinitionExpression innerLambdaExpression = (LambdaDefinitionExpression) outerLambdaExpression.getBody(); + assertEquals(innerLambdaExpression.getArgumentTypes(), lambdaTypes); + assertEquals(innerLambdaExpression.getBody(), constant(11.0, DOUBLE)); + } + + private static RowExpression ifExpression(RowExpression condition, long trueValue, long falseValue) + { + return new SpecialFormExpression(IF, BIGINT, ImmutableList.of(condition, constant(trueValue, BIGINT), constant(falseValue, BIGINT))); } private static RowExpressionOptimizer getNativeOptimizer() @@ -323,4 +393,15 @@ private static RowExpressionOptimizer getNativeOptimizer() metadata.getFunctionAndTypeManager().createFunction(CPP_CUSTOM_FUNCTION, true); return new RowExpressionOptimizer(metadata); } + + private RowExpression callOperator(OperatorType operator, RowExpression left, RowExpression right) + { + FunctionHandle functionHandle = functionAndTypeManager.resolveOperator(operator, fromTypes(left.getType(), right.getType())); + return Expressions.call(operator.getOperator(), functionHandle, left.getType(), left, right); + } + + private RowExpression optimize(RowExpression expression) + { + return optimizer.optimize(expression, OPTIMIZED, SESSION); + } } diff --git a/presto-native-sidecar-plugin/src/test/java/com/facebook/presto/sidecar/TestNativeSidecarPlugin.java b/presto-native-sidecar-plugin/src/test/java/com/facebook/presto/sidecar/TestNativeSidecarPlugin.java index 00f62c5877554..4dc3b460bf13a 100644 --- a/presto-native-sidecar-plugin/src/test/java/com/facebook/presto/sidecar/TestNativeSidecarPlugin.java +++ b/presto-native-sidecar-plugin/src/test/java/com/facebook/presto/sidecar/TestNativeSidecarPlugin.java @@ -219,7 +219,7 @@ public void testGeneralQueries() "date_trunc('hour', from_unixtime(orderkey, '-09:30')), date_trunc('minute', from_unixtime(orderkey, '+05:30')), " + "date_trunc('second', from_unixtime(orderkey, '+00:00')) FROM orders"); assertQuery("SELECT mod(orderkey, linenumber) FROM lineitem"); - assertQueryFails("SELECT IF(true, 0/0, 1)", "/ by zero"); + assertQueryFails("SELECT IF(true, 0/0, 1)", "/ by zero", true); assertQuery("select CASE WHEN true THEN 'Yes' ELSE 'No' END"); }