Require session for operator resolution

core/trino-main/src/main/java/io/trino/metadata/Metadata.java

@@ -613,7 +613,7 @@ default Type getParameterizedType(String baseTypeName, List<TypeSignatureParamet
 
     ResolvedFunction resolveFunction(Session session, QualifiedName name, List<TypeSignatureProvider> parameterTypes);
 
-    ResolvedFunction resolveOperator(OperatorType operatorType, List<? extends Type> argumentTypes)
+    ResolvedFunction resolveOperator(Session session, OperatorType operatorType, List<? extends Type> argumentTypes)
             throws OperatorNotFoundException;
 
     default ResolvedFunction getCoercion(Type fromType, Type toType)

core/trino-main/src/main/java/io/trino/metadata/MetadataManager.java

@@ -2258,7 +2258,7 @@ public ResolvedFunction resolveFunction(Session session, QualifiedName name, Lis
     }
 
     @Override
-    public ResolvedFunction resolveOperator(OperatorType operatorType, List<? extends Type> argumentTypes)
+    public ResolvedFunction resolveOperator(Session session, OperatorType operatorType, List<? extends Type> argumentTypes)
             throws OperatorNotFoundException
     {
         try {

core/trino-main/src/main/java/io/trino/sql/analyzer/ExpressionAnalyzer.java

@@ -1422,7 +1422,7 @@ private void analyzeFrameRangeOffset(Expression offsetValue, FrameBound.Type bou
                 operatorType = ADD;
             }
             try {
-                function = metadata.resolveOperator(operatorType, ImmutableList.of(sortKeyType, offsetValueType));
+                function = metadata.resolveOperator(session, operatorType, ImmutableList.of(sortKeyType, offsetValueType));
             }
             catch (TrinoException e) {
                 ErrorCode errorCode = e.getErrorCode();
@@ -2282,7 +2282,7 @@ private Type getOperator(StackableAstVisitorContext<Context> context, Expression
 
             BoundSignature operatorSignature;
             try {
-                operatorSignature = metadata.resolveOperator(operatorType, argumentTypes.build()).getSignature();
+                operatorSignature = metadata.resolveOperator(session, operatorType, argumentTypes.build()).getSignature();
             }
             catch (OperatorNotFoundException e) {
                 throw semanticException(TYPE_MISMATCH, node, e, "%s", e.getMessage());

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

@@ -2366,7 +2366,7 @@ private Scope analyzeJoinUsing(Join node, List<Identifier> columns, Optional<Sco
 
                 // ensure a comparison operator exists for the given types (applying coercions if necessary)
                 try {
-                    metadata.resolveOperator(OperatorType.EQUAL, ImmutableList.of(
+                    metadata.resolveOperator(session, OperatorType.EQUAL, ImmutableList.of(
                             leftField.get().getType(), rightField.get().getType()));
                 }
                 catch (OperatorNotFoundException e) {

core/trino-main/src/main/java/io/trino/sql/planner/ExpressionInterpreter.java

@@ -604,8 +604,8 @@ protected Object visitInPredicate(InPredicate node, Object context)
                     set = FastutilSetHelper.toFastutilHashSet(
                             objectSet,
                             type,
-                            metadata.getScalarFunctionInvoker(metadata.resolveOperator(HASH_CODE, ImmutableList.of(type)), simpleConvention(FAIL_ON_NULL, NEVER_NULL)).getMethodHandle(),
-                            metadata.getScalarFunctionInvoker(metadata.resolveOperator(EQUAL, ImmutableList.of(type, type)), simpleConvention(NULLABLE_RETURN, NEVER_NULL, NEVER_NULL)).getMethodHandle());
+                            metadata.getScalarFunctionInvoker(metadata.resolveOperator(session, HASH_CODE, ImmutableList.of(type)), simpleConvention(FAIL_ON_NULL, NEVER_NULL)).getMethodHandle(),
+                            metadata.getScalarFunctionInvoker(metadata.resolveOperator(session, EQUAL, ImmutableList.of(type, type)), simpleConvention(NULLABLE_RETURN, NEVER_NULL, NEVER_NULL)).getMethodHandle());
                 }
                 inListCache.put(valueList, set);
             }
@@ -620,7 +620,7 @@ protected Object visitInPredicate(InPredicate node, Object context)
             List<Object> values = new ArrayList<>(valueList.getValues().size());
             List<Type> types = new ArrayList<>(valueList.getValues().size());
 
-            ResolvedFunction equalsOperator = metadata.resolveOperator(OperatorType.EQUAL, types(node.getValue(), valueList));
+            ResolvedFunction equalsOperator = metadata.resolveOperator(session, OperatorType.EQUAL, types(node.getValue(), valueList));
             for (Expression expression : valueList.getValues()) {
                 // Use process() instead of processWithExceptionHandling() for processing in-list items.
                 // Do not handle exceptions thrown while processing a single in-list expression,
@@ -720,7 +720,7 @@ protected Object visitArithmeticUnary(ArithmeticUnaryExpression node, Object con
                 case PLUS:
                     return value;
                 case MINUS:
-                    ResolvedFunction resolvedOperator = metadata.resolveOperator(OperatorType.NEGATION, types(node.getValue()));
+                    ResolvedFunction resolvedOperator = metadata.resolveOperator(session, OperatorType.NEGATION, types(node.getValue()));
                     InvocationConvention invocationConvention = new InvocationConvention(ImmutableList.of(NEVER_NULL), FAIL_ON_NULL, true, false);
                     MethodHandle handle = metadata.getScalarFunctionInvoker(resolvedOperator, invocationConvention).getMethodHandle();
 
@@ -1402,7 +1402,7 @@ private boolean hasUnresolvedValue(List<Object> values)
 
         private Object invokeOperator(OperatorType operatorType, List<? extends Type> argumentTypes, List<Object> argumentValues)
         {
-            ResolvedFunction operator = metadata.resolveOperator(operatorType, argumentTypes);
+            ResolvedFunction operator = metadata.resolveOperator(session, operatorType, argumentTypes);
             return functionInvoker.invoke(operator, connectorSession, argumentValues);
         }
 

core/trino-main/src/main/java/io/trino/sql/planner/optimizations/ExpressionEquivalence.java

@@ -104,10 +104,6 @@ private RowExpression toRowExpression(Session session, Expression expression, Ma
     private static class CanonicalizationVisitor
             implements RowExpressionVisitor<RowExpression, Void>
     {
-        public CanonicalizationVisitor()
-        {
-        }
-
         @Override
         public RowExpression visitCall(CallExpression call, Void context)
         {

core/trino-main/src/main/java/io/trino/sql/relational/SqlToRowExpressionTranslator.java

@@ -169,7 +169,7 @@ private Visitor(
             this.types = ImmutableMap.copyOf(requireNonNull(types, "types is null"));
             this.layout = layout;
             this.session = session;
-            standardFunctionResolution = new StandardFunctionResolution(metadata);
+            standardFunctionResolution = new StandardFunctionResolution(session, metadata);
         }
 
         private Type getType(Expression node)
@@ -409,7 +409,7 @@ protected RowExpression visitArithmeticUnary(ArithmeticUnaryExpression node, Voi
                     return expression;
                 case MINUS:
                     return call(
-                            metadata.resolveOperator(NEGATION, ImmutableList.of(expression.getType())),
+                            metadata.resolveOperator(session, NEGATION, ImmutableList.of(expression.getType())),
                             expression);
             }
 
@@ -535,7 +535,7 @@ protected RowExpression visitSimpleCaseExpression(SimpleCaseExpression node, Voi
                 RowExpression operand = process(clause.getOperand(), context);
                 RowExpression result = process(clause.getResult(), context);
 
-                functionDependencies.add(metadata.resolveOperator(EQUAL, ImmutableList.of(value.getType(), operand.getType())));
+                functionDependencies.add(metadata.resolveOperator(session, EQUAL, ImmutableList.of(value.getType(), operand.getType())));
 
                 arguments.add(new SpecialForm(
                         WHEN,
@@ -622,9 +622,9 @@ protected RowExpression visitInPredicate(InPredicate node, Void context)
             }
 
             List<ResolvedFunction> functionDependencies = ImmutableList.<ResolvedFunction>builder()
-                    .add(metadata.resolveOperator(EQUAL, ImmutableList.of(value.getType(), value.getType())))
-                    .add(metadata.resolveOperator(HASH_CODE, ImmutableList.of(value.getType())))
-                    .add(metadata.resolveOperator(INDETERMINATE, ImmutableList.of(value.getType())))
+                    .add(metadata.resolveOperator(session, EQUAL, ImmutableList.of(value.getType(), value.getType())))
+                    .add(metadata.resolveOperator(session, HASH_CODE, ImmutableList.of(value.getType())))
+                    .add(metadata.resolveOperator(session, INDETERMINATE, ImmutableList.of(value.getType())))
                     .build();
 
             return new SpecialForm(IN, BOOLEAN, arguments.build(), functionDependencies);
@@ -665,7 +665,7 @@ protected RowExpression visitNullIfExpression(NullIfExpression node, Void contex
             RowExpression first = process(node.getFirst(), context);
             RowExpression second = process(node.getSecond(), context);
 
-            ResolvedFunction resolvedFunction = metadata.resolveOperator(EQUAL, ImmutableList.of(first.getType(), second.getType()));
+            ResolvedFunction resolvedFunction = metadata.resolveOperator(session, EQUAL, ImmutableList.of(first.getType(), second.getType()));
             List<ResolvedFunction> functionDependencies = ImmutableList.<ResolvedFunction>builder()
                     .add(resolvedFunction)
                     .add(metadata.getCoercion(first.getType(), resolvedFunction.getSignature().getArgumentTypes().get(0)))
@@ -687,7 +687,7 @@ protected RowExpression visitBetweenPredicate(BetweenPredicate node, Void contex
             RowExpression max = process(node.getMax(), context);
 
             List<ResolvedFunction> functionDependencies = ImmutableList.<ResolvedFunction>builder()
-                    .add(metadata.resolveOperator(LESS_THAN_OR_EQUAL, ImmutableList.of(value.getType(), max.getType())))
+                    .add(metadata.resolveOperator(session, LESS_THAN_OR_EQUAL, ImmutableList.of(value.getType(), max.getType())))
                     .build();
 
             return new SpecialForm(
@@ -709,7 +709,7 @@ protected RowExpression visitSubscriptExpression(SubscriptExpression node, Void
             }
 
             return call(
-                    metadata.resolveOperator(SUBSCRIPT, ImmutableList.of(base.getType(), index.getType())),
+                    metadata.resolveOperator(session, SUBSCRIPT, ImmutableList.of(base.getType(), index.getType())),
                     base,
                     index);
         }

core/trino-main/src/main/java/io/trino/sql/relational/StandardFunctionResolution.java

@@ -14,11 +14,12 @@
 package io.trino.sql.relational;
 
 import com.google.common.collect.ImmutableList;
+import io.trino.Session;
 import io.trino.metadata.Metadata;
 import io.trino.metadata.ResolvedFunction;
 import io.trino.spi.function.OperatorType;
 import io.trino.spi.type.Type;
-import io.trino.sql.tree.ArithmeticBinaryExpression;
+import io.trino.sql.tree.ArithmeticBinaryExpression.Operator;
 import io.trino.sql.tree.ComparisonExpression;
 
 import static io.trino.spi.function.OperatorType.ADD;
@@ -34,14 +35,16 @@
 
 public final class StandardFunctionResolution
 {
+    private final Session session;
     private final Metadata metadata;
 
-    public StandardFunctionResolution(Metadata metadata)
+    public StandardFunctionResolution(Session session, Metadata metadata)
     {
+        this.session = requireNonNull(session, "session is null");
         this.metadata = requireNonNull(metadata, "metadata is null");
     }
 
-    public ResolvedFunction arithmeticFunction(ArithmeticBinaryExpression.Operator operator, Type leftType, Type rightType)
+    public ResolvedFunction arithmeticFunction(Operator operator, Type leftType, Type rightType)
     {
         OperatorType operatorType;
         switch (operator) {
@@ -63,7 +66,7 @@ public ResolvedFunction arithmeticFunction(ArithmeticBinaryExpression.Operator o
             default:
                 throw new IllegalStateException("Unknown arithmetic operator: " + operator);
         }
-        return metadata.resolveOperator(operatorType, ImmutableList.of(leftType, rightType));
+        return metadata.resolveOperator(session, operatorType, ImmutableList.of(leftType, rightType));
     }
 
     public ResolvedFunction comparisonFunction(ComparisonExpression.Operator operator, Type leftType, Type rightType)
@@ -86,6 +89,6 @@ public ResolvedFunction comparisonFunction(ComparisonExpression.Operator operato
                 throw new IllegalStateException("Unsupported comparison operator type: " + operator);
         }
 
-        return metadata.resolveOperator(operatorType, ImmutableList.of(leftType, rightType));
+        return metadata.resolveOperator(session, operatorType, ImmutableList.of(leftType, rightType));
     }
 }

core/trino-main/src/test/java/io/trino/metadata/AbstractMockMetadata.java

@@ -752,7 +752,7 @@ public ResolvedFunction resolveFunction(Session session, QualifiedName name, Lis
     }
 
     @Override
-    public ResolvedFunction resolveOperator(OperatorType operatorType, List<? extends Type> argumentTypes)
+    public ResolvedFunction resolveOperator(Session session, OperatorType operatorType, List<? extends Type> argumentTypes)
             throws OperatorNotFoundException
     {
         throw new UnsupportedOperationException();

core/trino-main/src/test/java/io/trino/metadata/TestFunctionRegistry.java

@@ -67,7 +67,8 @@ public void testIdentityCast()
     @Test
     public void testExactMatchBeforeCoercion()
     {
-        Metadata metadata = createTestMetadataManager();
+        TestingFunctionResolution functionResolution = new TestingFunctionResolution();
+        Metadata metadata = functionResolution.getMetadata();
         boolean foundOperator = false;
         for (FunctionMetadata function : listOperators(metadata)) {
             OperatorType operatorType = unmangleOperator(function.getSignature().getName());
@@ -83,7 +84,7 @@ public void testExactMatchBeforeCoercion()
             List<Type> argumentTypes = function.getSignature().getArgumentTypes().stream()
                     .map(metadata::getType)
                     .collect(toImmutableList());
-            BoundSignature exactOperator = metadata.resolveOperator(operatorType, argumentTypes).getSignature();
+            BoundSignature exactOperator = functionResolution.resolveOperator(operatorType, argumentTypes).getSignature();
             assertEquals(exactOperator.toSignature(), function.getSignature());
             foundOperator = true;
         }

core/trino-main/src/test/java/io/trino/metadata/TestingFunctionResolution.java

@@ -98,7 +98,7 @@ public PageFunctionCompiler getPageFunctionCompiler(int expressionCacheSize)
     public ResolvedFunction resolveOperator(OperatorType operatorType, List<? extends Type> argumentTypes)
             throws OperatorNotFoundException
     {
-        return inTransaction(session -> metadata.resolveOperator(operatorType, argumentTypes));
+        return inTransaction(session -> metadata.resolveOperator(session, operatorType, argumentTypes));
     }
 
     public ResolvedFunction getCoercion(Type fromType, Type toType)

core/trino-main/src/test/java/io/trino/operator/TestFilterAndProjectOperator.java

@@ -15,11 +15,10 @@
 
 import com.google.common.collect.ImmutableList;
 import io.airlift.units.DataSize;
-import io.trino.metadata.Metadata;
+import io.trino.metadata.TestingFunctionResolution;
 import io.trino.operator.project.PageProcessor;
 import io.trino.spi.Page;
 import io.trino.sql.gen.ExpressionCompiler;
-import io.trino.sql.gen.PageFunctionCompiler;
 import io.trino.sql.planner.plan.PlanNodeId;
 import io.trino.sql.relational.RowExpression;
 import io.trino.testing.MaterializedResult;
@@ -37,7 +36,6 @@
 import static io.airlift.units.DataSize.Unit.KILOBYTE;
 import static io.trino.RowPagesBuilder.rowPagesBuilder;
 import static io.trino.SessionTestUtils.TEST_SESSION;
-import static io.trino.metadata.MetadataManager.createTestMetadataManager;
 import static io.trino.operator.OperatorAssertion.assertOperatorEquals;
 import static io.trino.spi.function.OperatorType.ADD;
 import static io.trino.spi.function.OperatorType.EQUAL;
@@ -83,19 +81,19 @@ public void test()
                 .addSequencePage(100, 0, 0)
                 .build();
 
-        Metadata metadata = createTestMetadataManager();
+        TestingFunctionResolution functionResolution = new TestingFunctionResolution();
         RowExpression filter = call(
-                metadata.resolveOperator(LESS_THAN_OR_EQUAL, ImmutableList.of(BIGINT, BIGINT)),
+                functionResolution.resolveOperator(LESS_THAN_OR_EQUAL, ImmutableList.of(BIGINT, BIGINT)),
                 field(1, BIGINT),
                 constant(9L, BIGINT));
 
         RowExpression field0 = field(0, VARCHAR);
         RowExpression add5 = call(
-                metadata.resolveOperator(ADD, ImmutableList.of(BIGINT, BIGINT)),
+                functionResolution.resolveOperator(ADD, ImmutableList.of(BIGINT, BIGINT)),
                 field(1, BIGINT),
                 constant(5L, BIGINT));
 
-        ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0));
+        ExpressionCompiler compiler = functionResolution.getExpressionCompiler();
         Supplier<PageProcessor> processor = compiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field0, add5));
 
         OperatorFactory operatorFactory = FilterAndProjectOperator.createOperatorFactory(
@@ -133,13 +131,13 @@ public void testMergeOutput()
                 .addSequencePage(100, 0, 0)
                 .build();
 
-        Metadata metadata = createTestMetadataManager();
+        TestingFunctionResolution functionResolution = new TestingFunctionResolution();
         RowExpression filter = call(
-                metadata.resolveOperator(EQUAL, ImmutableList.of(BIGINT, BIGINT)),
+                functionResolution.resolveOperator(EQUAL, ImmutableList.of(BIGINT, BIGINT)),
                 field(1, BIGINT),
                 constant(10L, BIGINT));
 
-        ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0));
+        ExpressionCompiler compiler = functionResolution.getExpressionCompiler();
         Supplier<PageProcessor> processor = compiler.compilePageProcessor(Optional.of(filter), ImmutableList.of(field(1, BIGINT)));
 
         OperatorFactory operatorFactory = FilterAndProjectOperator.createOperatorFactory(

core/trino-main/src/test/java/io/trino/operator/TestScanFilterAndProjectOperator.java

@@ -22,6 +22,7 @@
 import io.trino.metadata.Metadata;
 import io.trino.metadata.Split;
 import io.trino.metadata.SqlScalarFunction;
+import io.trino.metadata.TestingFunctionResolution;
 import io.trino.operator.index.PageRecordSet;
 import io.trino.operator.project.CursorProcessor;
 import io.trino.operator.project.PageProcessor;
@@ -56,7 +57,6 @@
 import static io.trino.RowPagesBuilder.rowPagesBuilder;
 import static io.trino.SessionTestUtils.TEST_SESSION;
 import static io.trino.block.BlockAssertions.toValues;
-import static io.trino.metadata.MetadataManager.createTestMetadataManager;
 import static io.trino.operator.OperatorAssertion.toMaterializedResult;
 import static io.trino.operator.PageAssertions.assertPageEquals;
 import static io.trino.operator.project.PageProcessor.MAX_BATCH_SIZE;
@@ -80,8 +80,8 @@
 public class TestScanFilterAndProjectOperator
         extends AbstractTestFunctions
 {
-    private final Metadata metadata = createTestMetadataManager();
-    private final ExpressionCompiler expressionCompiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0));
+    private final TestingFunctionResolution functionResolution = new TestingFunctionResolution();
+    private final ExpressionCompiler expressionCompiler = functionResolution.getExpressionCompiler();
     private ExecutorService executor = newCachedThreadPool(daemonThreadsNamed(getClass().getSimpleName() + "-%s"));
     private ScheduledExecutorService scheduledExecutor = newScheduledThreadPool(2, daemonThreadsNamed(getClass().getSimpleName() + "-scheduledExecutor-%s"));
 
@@ -140,7 +140,7 @@ public void testPageSourceMergeOutput()
                 .build();
 
         RowExpression filter = call(
-                metadata.resolveOperator(EQUAL, ImmutableList.of(BIGINT, BIGINT)),
+                functionResolution.resolveOperator(EQUAL, ImmutableList.of(BIGINT, BIGINT)),
                 field(0, BIGINT),
                 constant(10L, BIGINT));
         List<RowExpression> projections = ImmutableList.of(field(0, BIGINT));