From bee57894759f03f39e46b27cdd53caede5ed63a9 Mon Sep 17 00:00:00 2001 From: Martin Traverso Date: Fri, 2 Feb 2024 08:30:38 -0800 Subject: [PATCH] Split IR type analyzer --- .../io/trino/cost/FilterStatsCalculator.java | 6 +- .../io/trino/cost/ScalarStatsCalculator.java | 6 +- .../io/trino/execution/SqlQueryExecution.java | 10 +- .../io/trino/server/ServerMainModule.java | 4 +- .../java/io/trino/sql/ExpressionUtils.java | 4 +- .../io/trino/sql/analyzer/QueryExplainer.java | 7 +- .../sql/analyzer/QueryExplainerFactory.java | 4 - .../{planner => analyzer}/TypeAnalyzer.java | 4 +- .../ConnectorExpressionTranslator.java | 4 +- .../trino/sql/planner/DomainTranslator.java | 30 +- .../planner/EffectivePredicateExtractor.java | 6 +- .../sql/planner/IrExpressionInterpreter.java | 4 +- .../io/trino/sql/planner/IrTypeAnalyzer.java | 641 ++++++++++++++++++ .../planner/LayoutConstraintEvaluator.java | 2 +- .../sql/planner/LocalExecutionPlanner.java | 4 +- .../io/trino/sql/planner/LogicalPlanner.java | 6 +- .../trino/sql/planner/PartialTranslator.java | 2 +- .../io/trino/sql/planner/PlanOptimizers.java | 4 +- .../trino/sql/planner/SplitSourceFactory.java | 4 +- ...wPartialAggregationOverGroupIdRuleSet.java | 6 +- .../rule/CanonicalizeExpressionRewriter.java | 4 +- .../rule/CanonicalizeExpressions.java | 4 +- .../iterative/rule/DereferencePushdown.java | 10 +- .../iterative/rule/EliminateCrossJoins.java | 6 +- ...xtractDereferencesFromFilterAboveScan.java | 6 +- .../iterative/rule/ExtractSpatialJoins.java | 18 +- .../iterative/rule/InlineProjections.java | 10 +- .../rule/PreAggregateCaseAggregations.java | 6 +- .../rule/PushAggregationIntoTableScan.java | 8 +- .../rule/PushDistinctLimitIntoTableScan.java | 6 +- .../PushDownDereferenceThroughFilter.java | 6 +- .../rule/PushDownDereferenceThroughJoin.java | 6 +- .../PushDownDereferenceThroughProject.java | 6 +- .../PushDownDereferenceThroughSemiJoin.java | 6 +- .../PushDownDereferenceThroughUnnest.java | 6 +- ...DownDereferencesThroughAssignUniqueId.java | 6 +- .../PushDownDereferencesThroughLimit.java | 6 +- ...shDownDereferencesThroughMarkDistinct.java | 6 +- .../PushDownDereferencesThroughRowNumber.java | 6 +- .../rule/PushDownDereferencesThroughSort.java | 6 +- .../rule/PushDownDereferencesThroughTopN.java | 6 +- ...ushDownDereferencesThroughTopNRanking.java | 6 +- .../PushDownDereferencesThroughWindow.java | 6 +- ...alityFilterExpressionBelowJoinRuleSet.java | 6 +- .../iterative/rule/PushJoinIntoTableScan.java | 6 +- .../rule/PushLimitThroughProject.java | 6 +- .../PushMergeWriterUpdateIntoConnector.java | 6 +- .../rule/PushPredicateIntoTableScan.java | 10 +- .../rule/PushProjectionIntoTableScan.java | 6 +- .../rule/PushProjectionThroughJoin.java | 6 +- .../rule/PushTopNThroughProject.java | 6 +- .../rule/RemoveRedundantDateTrunc.java | 6 +- ...emoveRedundantPredicateAboveTableScan.java | 6 +- .../rule/RemoveUnsupportedDynamicFilters.java | 30 +- .../planner/iterative/rule/ReorderJoins.java | 14 +- .../rule/SimplifyCountOverConstant.java | 6 +- .../iterative/rule/SimplifyExpressions.java | 8 +- .../rule/UnwrapCastInComparison.java | 12 +- .../rule/UnwrapDateTruncInComparison.java | 12 +- .../rule/UnwrapSingleColumnRowInApply.java | 6 +- .../rule/UnwrapYearInComparison.java | 12 +- .../planner/optimizations/AddExchanges.java | 6 +- .../optimizations/AddLocalExchanges.java | 6 +- .../optimizations/ExpressionEquivalence.java | 6 +- .../optimizations/PredicatePushDown.java | 10 +- .../optimizations/PropertyDerivations.java | 12 +- .../StreamPropertyDerivations.java | 8 +- .../optimizations/joins/JoinGraph.java | 8 +- .../trino/sql/planner/plan/Assignments.java | 4 +- .../planner/sanity/AllFunctionsResolved.java | 4 +- .../planner/sanity/DynamicFiltersChecker.java | 4 +- .../sanity/NoDuplicatePlanNodeIdsChecker.java | 4 +- .../sanity/NoIdentifierLeftChecker.java | 4 +- .../NoSubqueryExpressionLeftChecker.java | 4 +- .../sql/planner/sanity/PlanSanityChecker.java | 10 +- .../sql/planner/sanity/SugarFreeChecker.java | 4 +- .../TableExecuteStructureValidator.java | 4 +- .../planner/sanity/TableScanValidator.java | 4 +- .../sql/planner/sanity/TypeValidator.java | 8 +- ...ValidateAggregationsWithDefaultValues.java | 8 +- .../sanity/ValidateDependenciesChecker.java | 4 +- .../sanity/ValidateScaledWritersUsage.java | 4 +- .../sanity/ValidateStreamingAggregations.java | 8 +- .../sanity/VerifyNoFilteredAggregations.java | 4 +- .../sanity/VerifyOnlyOneOutputNode.java | 4 +- ...VerifyUseConnectorNodePartitioningSet.java | 4 +- .../java/io/trino/testing/PlanTester.java | 13 +- .../cost/TestComparisonStatsCalculator.java | 4 +- .../trino/cost/TestFilterStatsCalculator.java | 4 +- .../java/io/trino/cost/TestJoinStatsRule.java | 4 +- .../trino/cost/TestScalarStatsCalculator.java | 4 +- .../io/trino/execution/TaskTestUtils.java | 4 +- ...stPageFieldsToInputParametersRewriter.java | 5 +- .../io/trino/sql/ExpressionTestUtils.java | 6 +- .../trino/sql/TestExpressionInterpreter.java | 4 +- .../sql/TestSqlToRowExpressionTranslator.java | 4 +- .../sql/gen/BenchmarkPageProcessor2.java | 5 +- .../TestConnectorExpressionTranslator.java | 3 +- .../TestEffectivePredicateExtractor.java | 3 +- .../trino/sql/planner/TestLiteralEncoder.java | 2 +- .../sql/planner/TestPartialTranslator.java | 3 +- .../trino/sql/planner/TestTypeValidator.java | 3 +- .../TestCanonicalizeExpressionRewriter.java | 5 +- .../rule/TestEliminateCrossJoins.java | 14 +- .../iterative/rule/TestJoinNodeFlattener.java | 18 +- ...estPushMergeWriterUpdateIntoConnector.java | 4 +- .../rule/TestPushPredicateIntoTableScan.java | 4 +- .../rule/TestPushProjectionIntoTableScan.java | 7 +- .../rule/TestPushProjectionThroughJoin.java | 11 +- .../iterative/rule/TestReorderJoins.java | 4 +- .../rule/TestSimplifyExpressions.java | 6 +- .../TestUnwrapSingleColumnRowInApply.java | 8 +- .../iterative/rule/test/RuleTester.java | 9 +- .../optimizations/TestEliminateSorts.java | 5 +- .../TestExpressionEquivalence.java | 4 +- .../TestRemoveUnsupportedDynamicFilters.java | 4 +- .../optimizations/TestReorderWindows.java | 6 +- .../sanity/TestDynamicFiltersChecker.java | 4 +- ...ValidateAggregationsWithDefaultValues.java | 4 +- .../TestValidateScaledWritersUsage.java | 4 +- .../TestValidateStreamingAggregations.java | 7 +- .../trino/type/BenchmarkDecimalOperators.java | 5 +- .../trino/plugin/ignite/TestIgniteClient.java | 4 +- .../postgresql/TestPostgreSqlClient.java | 4 +- 124 files changed, 1005 insertions(+), 431 deletions(-) rename core/trino-main/src/main/java/io/trino/sql/{planner => analyzer}/TypeAnalyzer.java (97%) create mode 100644 core/trino-main/src/main/java/io/trino/sql/planner/IrTypeAnalyzer.java diff --git a/core/trino-main/src/main/java/io/trino/cost/FilterStatsCalculator.java b/core/trino-main/src/main/java/io/trino/cost/FilterStatsCalculator.java index cd5ecd3a6a01..c3c4da2352d5 100644 --- a/core/trino-main/src/main/java/io/trino/cost/FilterStatsCalculator.java +++ b/core/trino-main/src/main/java/io/trino/cost/FilterStatsCalculator.java @@ -28,10 +28,10 @@ import io.trino.sql.analyzer.ExpressionAnalyzer; import io.trino.sql.analyzer.Scope; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.AstVisitor; import io.trino.sql.tree.BetweenPredicate; @@ -93,10 +93,10 @@ public class FilterStatsCalculator private final PlannerContext plannerContext; private final ScalarStatsCalculator scalarStatsCalculator; private final StatsNormalizer normalizer; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; @Inject - public FilterStatsCalculator(PlannerContext plannerContext, ScalarStatsCalculator scalarStatsCalculator, StatsNormalizer normalizer, TypeAnalyzer typeAnalyzer) + public FilterStatsCalculator(PlannerContext plannerContext, ScalarStatsCalculator scalarStatsCalculator, StatsNormalizer normalizer, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.scalarStatsCalculator = requireNonNull(scalarStatsCalculator, "scalarStatsCalculator is null"); diff --git a/core/trino-main/src/main/java/io/trino/cost/ScalarStatsCalculator.java b/core/trino-main/src/main/java/io/trino/cost/ScalarStatsCalculator.java index 7bec9feb641e..579723d1d4e7 100644 --- a/core/trino-main/src/main/java/io/trino/cost/ScalarStatsCalculator.java +++ b/core/trino-main/src/main/java/io/trino/cost/ScalarStatsCalculator.java @@ -28,10 +28,10 @@ import io.trino.sql.analyzer.ExpressionAnalyzer; import io.trino.sql.analyzer.Scope; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralInterpreter; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.ArithmeticBinaryExpression; import io.trino.sql.tree.ArithmeticUnaryExpression; @@ -63,10 +63,10 @@ public class ScalarStatsCalculator { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; @Inject - public ScalarStatsCalculator(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public ScalarStatsCalculator(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext cannot be null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/execution/SqlQueryExecution.java b/core/trino-main/src/main/java/io/trino/execution/SqlQueryExecution.java index 5aa422cd9c19..d7b7ee488a0a 100644 --- a/core/trino-main/src/main/java/io/trino/execution/SqlQueryExecution.java +++ b/core/trino-main/src/main/java/io/trino/execution/SqlQueryExecution.java @@ -57,6 +57,7 @@ import io.trino.sql.analyzer.Analyzer; import io.trino.sql.analyzer.AnalyzerFactory; import io.trino.sql.planner.InputExtractor; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LogicalPlanner; import io.trino.sql.planner.NodePartitioningManager; import io.trino.sql.planner.Plan; @@ -66,7 +67,6 @@ import io.trino.sql.planner.PlanOptimizersFactory; import io.trino.sql.planner.SplitSourceFactory; import io.trino.sql.planner.SubPlan; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.optimizations.PlanOptimizer; import io.trino.sql.planner.plan.OutputNode; import io.trino.sql.tree.ExplainAnalyze; @@ -133,7 +133,7 @@ public class SqlQueryExecution private final CostCalculator costCalculator; private final DynamicFilterService dynamicFilterService; private final TableExecuteContextManager tableExecuteContextManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final SqlTaskManager coordinatorTaskManager; private final ExchangeManagerRegistry exchangeManagerRegistry; private final EventDrivenTaskSourceFactory eventDrivenTaskSourceFactory; @@ -170,7 +170,7 @@ private SqlQueryExecution( WarningCollector warningCollector, PlanOptimizersStatsCollector planOptimizersStatsCollector, TableExecuteContextManager tableExecuteContextManager, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, SqlTaskManager coordinatorTaskManager, ExchangeManagerRegistry exchangeManagerRegistry, EventDrivenTaskSourceFactory eventDrivenTaskSourceFactory, @@ -766,7 +766,7 @@ public static class SqlQueryExecutionFactory private final CostCalculator costCalculator; private final DynamicFilterService dynamicFilterService; private final TableExecuteContextManager tableExecuteContextManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final SqlTaskManager coordinatorTaskManager; private final ExchangeManagerRegistry exchangeManagerRegistry; private final EventDrivenTaskSourceFactory eventDrivenTaskSourceFactory; @@ -798,7 +798,7 @@ public static class SqlQueryExecutionFactory CostCalculator costCalculator, DynamicFilterService dynamicFilterService, TableExecuteContextManager tableExecuteContextManager, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, SqlTaskManager coordinatorTaskManager, ExchangeManagerRegistry exchangeManagerRegistry, EventDrivenTaskSourceFactory eventDrivenTaskSourceFactory, diff --git a/core/trino-main/src/main/java/io/trino/server/ServerMainModule.java b/core/trino-main/src/main/java/io/trino/server/ServerMainModule.java index 96c8f407d58a..831fd2432b9e 100644 --- a/core/trino-main/src/main/java/io/trino/server/ServerMainModule.java +++ b/core/trino-main/src/main/java/io/trino/server/ServerMainModule.java @@ -138,11 +138,11 @@ import io.trino.sql.gen.PageFunctionCompiler; import io.trino.sql.parser.SqlParser; import io.trino.sql.planner.CompilerConfig; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LocalExecutionPlanner; import io.trino.sql.planner.NodePartitioningManager; import io.trino.sql.planner.OptimizerConfig; import io.trino.sql.planner.RuleStatsRecorder; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.tree.Expression; import io.trino.tracing.ForTracing; import io.trino.tracing.TracingMetadata; @@ -408,7 +408,7 @@ protected void setup(Binder binder) binder.bind(RegisterFunctionBundles.class).asEagerSingleton(); // type - binder.bind(TypeAnalyzer.class).in(Scopes.SINGLETON); + binder.bind(IrTypeAnalyzer.class).in(Scopes.SINGLETON); jsonBinder(binder).addDeserializerBinding(Type.class).to(TypeDeserializer.class); jsonBinder(binder).addDeserializerBinding(TypeSignature.class).to(TypeSignatureDeserializer.class); jsonBinder(binder).addKeyDeserializerBinding(TypeSignature.class).to(TypeSignatureKeyDeserializer.class); diff --git a/core/trino-main/src/main/java/io/trino/sql/ExpressionUtils.java b/core/trino-main/src/main/java/io/trino/sql/ExpressionUtils.java index dc275893ff6c..ae7ad91ebdf2 100644 --- a/core/trino-main/src/main/java/io/trino/sql/ExpressionUtils.java +++ b/core/trino-main/src/main/java/io/trino/sql/ExpressionUtils.java @@ -21,11 +21,11 @@ import io.trino.spi.type.Type; import io.trino.sql.planner.DeterminismEvaluator; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolsExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Cast; import io.trino.sql.tree.Expression; @@ -298,7 +298,7 @@ public static boolean isEffectivelyLiteral(PlannerContext plannerContext, Sessio private static boolean constantExpressionEvaluatesSuccessfully(PlannerContext plannerContext, Session session, Expression constantExpression) { - Map, Type> types = TypeAnalyzer.createTestingTypeAnalyzer(plannerContext).getTypes(session, TypeProvider.empty(), constantExpression); + Map, Type> types = new IrTypeAnalyzer(plannerContext).getTypes(session, TypeProvider.empty(), constantExpression); IrExpressionInterpreter interpreter = new IrExpressionInterpreter(constantExpression, plannerContext, session, types); Object literalValue = interpreter.optimize(NoOpSymbolResolver.INSTANCE); return !(literalValue instanceof Expression); diff --git a/core/trino-main/src/main/java/io/trino/sql/analyzer/QueryExplainer.java b/core/trino-main/src/main/java/io/trino/sql/analyzer/QueryExplainer.java index aa8e99d8e695..bcdc3d52c4e6 100644 --- a/core/trino-main/src/main/java/io/trino/sql/analyzer/QueryExplainer.java +++ b/core/trino-main/src/main/java/io/trino/sql/analyzer/QueryExplainer.java @@ -22,13 +22,13 @@ import io.trino.spi.TrinoException; import io.trino.sql.PlannerContext; import io.trino.sql.SqlFormatter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LogicalPlanner; import io.trino.sql.planner.Plan; import io.trino.sql.planner.PlanFragmenter; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.PlanOptimizersFactory; import io.trino.sql.planner.SubPlan; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.optimizations.PlanOptimizer; import io.trino.sql.planner.planprinter.PlanPrinter; import io.trino.sql.tree.CreateCatalog; @@ -63,7 +63,6 @@ public class QueryExplainer private final PlanFragmenter planFragmenter; private final PlannerContext plannerContext; private final AnalyzerFactory analyzerFactory; - private final StatementAnalyzerFactory statementAnalyzerFactory; private final StatsCalculator statsCalculator; private final CostCalculator costCalculator; private final NodeVersion version; @@ -73,7 +72,6 @@ public class QueryExplainer PlanFragmenter planFragmenter, PlannerContext plannerContext, AnalyzerFactory analyzerFactory, - StatementAnalyzerFactory statementAnalyzerFactory, StatsCalculator statsCalculator, CostCalculator costCalculator, NodeVersion version) @@ -82,7 +80,6 @@ public class QueryExplainer this.planFragmenter = requireNonNull(planFragmenter, "planFragmenter is null"); this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.analyzerFactory = requireNonNull(analyzerFactory, "analyzerFactory is null"); - this.statementAnalyzerFactory = requireNonNull(statementAnalyzerFactory, "statementAnalyzerFactory is null"); this.statsCalculator = requireNonNull(statsCalculator, "statsCalculator is null"); this.costCalculator = requireNonNull(costCalculator, "costCalculator is null"); this.version = requireNonNull(version, "version is null"); @@ -171,7 +168,7 @@ public Plan getLogicalPlan(Session session, Statement statement, List new UnsupportedOperationException("Expression is not supported: " + expression.toString())); } - public static Optional translate(Session session, Expression expression, TypeProvider types, PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public static Optional translate(Session session, Expression expression, TypeProvider types, PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { return new SqlToConnectorExpressionTranslator(session, typeAnalyzer.getTypes(session, types, expression), plannerContext) .process(expression); @@ -142,7 +142,7 @@ public static ConnectorExpressionTranslation translateConjuncts( Expression expression, TypeProvider types, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { Map, Type> remainingExpressionTypes = typeAnalyzer.getTypes(session, types, expression); ConnectorExpressionTranslator.SqlToConnectorExpressionTranslator translator = new ConnectorExpressionTranslator.SqlToConnectorExpressionTranslator( diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/DomainTranslator.java b/core/trino-main/src/main/java/io/trino/sql/planner/DomainTranslator.java index a6a835f48a02..86ac6cc91b50 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/DomainTranslator.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/DomainTranslator.java @@ -16,19 +16,12 @@ import com.google.common.base.Throwables; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; import com.google.common.collect.PeekingIterator; import io.airlift.slice.Slice; import io.airlift.slice.Slices; import io.trino.Session; -import io.trino.connector.CatalogServiceProvider; -import io.trino.metadata.AnalyzePropertyManager; import io.trino.metadata.OperatorNotFoundException; import io.trino.metadata.ResolvedFunction; -import io.trino.metadata.TableFunctionRegistry; -import io.trino.metadata.TableProceduresPropertyManager; -import io.trino.metadata.TableProceduresRegistry; -import io.trino.metadata.TablePropertyManager; import io.trino.security.AllowAllAccessControl; import io.trino.spi.ErrorCode; import io.trino.spi.TrinoException; @@ -47,9 +40,6 @@ import io.trino.spi.type.VarcharType; import io.trino.sql.InterpretedFunctionInvoker; import io.trino.sql.PlannerContext; -import io.trino.sql.analyzer.SessionTimeProvider; -import io.trino.sql.analyzer.StatementAnalyzerFactory; -import io.trino.sql.parser.SqlParser; import io.trino.sql.tree.AstVisitor; import io.trino.sql.tree.BetweenPredicate; import io.trino.sql.tree.BooleanLiteral; @@ -67,7 +57,6 @@ import io.trino.sql.tree.NullLiteral; import io.trino.sql.tree.StringLiteral; import io.trino.sql.tree.SymbolReference; -import io.trino.transaction.NoOpTransactionManager; import io.trino.type.LikeFunctions; import io.trino.type.LikePattern; import io.trino.type.LikePatternType; @@ -318,20 +307,7 @@ private static boolean isBetween(Range range) public static ExtractionResult getExtractionResult(PlannerContext plannerContext, Session session, Expression predicate, TypeProvider types) { // This is a limited type analyzer for the simple expressions used in this method - TypeAnalyzer typeAnalyzer = new TypeAnalyzer( - plannerContext, - new StatementAnalyzerFactory( - plannerContext, - new SqlParser(), - SessionTimeProvider.DEFAULT, - new AllowAllAccessControl(), - new NoOpTransactionManager(), - user -> ImmutableSet.of(), - new TableProceduresRegistry(CatalogServiceProvider.fail("procedures are not supported in domain translator")), - new TableFunctionRegistry(CatalogServiceProvider.fail("table functions are not supported in domain translator")), - new TablePropertyManager(CatalogServiceProvider.fail("table properties not supported in domain translator")), - new AnalyzePropertyManager(CatalogServiceProvider.fail("analyze properties not supported in domain translator")), - new TableProceduresPropertyManager(CatalogServiceProvider.fail("procedures are not supported in domain translator")))); + IrTypeAnalyzer typeAnalyzer = new IrTypeAnalyzer(plannerContext); return new Visitor(plannerContext, session, types, typeAnalyzer).process(predicate, false); } @@ -343,10 +319,10 @@ private static class Visitor private final Session session; private final TypeProvider types; private final InterpretedFunctionInvoker functionInvoker; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final TypeCoercion typeCoercion; - private Visitor(PlannerContext plannerContext, Session session, TypeProvider types, TypeAnalyzer typeAnalyzer) + private Visitor(PlannerContext plannerContext, Session session, TypeProvider types, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.literalEncoder = new LiteralEncoder(plannerContext); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/EffectivePredicateExtractor.java b/core/trino-main/src/main/java/io/trino/sql/planner/EffectivePredicateExtractor.java index 260864c9444b..f0b4f41d6861 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/EffectivePredicateExtractor.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/EffectivePredicateExtractor.java @@ -109,7 +109,7 @@ public EffectivePredicateExtractor(DomainTranslator domainTranslator, PlannerCon this.useTableProperties = useTableProperties; } - public Expression extract(Session session, PlanNode node, TypeProvider types, TypeAnalyzer typeAnalyzer) + public Expression extract(Session session, PlanNode node, TypeProvider types, IrTypeAnalyzer typeAnalyzer) { return node.accept(new Visitor(domainTranslator, plannerContext, session, types, typeAnalyzer, useTableProperties), null); } @@ -122,10 +122,10 @@ private static class Visitor private final Metadata metadata; private final Session session; private final TypeProvider types; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final boolean useTableProperties; - public Visitor(DomainTranslator domainTranslator, PlannerContext plannerContext, Session session, TypeProvider types, TypeAnalyzer typeAnalyzer, boolean useTableProperties) + public Visitor(DomainTranslator domainTranslator, PlannerContext plannerContext, Session session, TypeProvider types, IrTypeAnalyzer typeAnalyzer, boolean useTableProperties) { this.domainTranslator = requireNonNull(domainTranslator, "domainTranslator is null"); this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/IrExpressionInterpreter.java b/core/trino-main/src/main/java/io/trino/sql/planner/IrExpressionInterpreter.java index 8e90b89553cd..7cdbed7f3538 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/IrExpressionInterpreter.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/IrExpressionInterpreter.java @@ -500,7 +500,9 @@ private boolean isEqual(Object operand1, Type type1, Object operand2, Type type2 private Type type(Expression expression) { - return expressionTypes.get(NodeRef.of(expression)); + Type type = expressionTypes.get(NodeRef.of(expression)); + checkState(type != null, "Type not found for expression: %s", expression); + return type; } @Override diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/IrTypeAnalyzer.java b/core/trino-main/src/main/java/io/trino/sql/planner/IrTypeAnalyzer.java new file mode 100644 index 000000000000..14cafd70f5c4 --- /dev/null +++ b/core/trino-main/src/main/java/io/trino/sql/planner/IrTypeAnalyzer.java @@ -0,0 +1,641 @@ +/* + * 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 io.trino.sql.planner; + +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.inject.Inject; +import io.trino.Session; +import io.trino.execution.warnings.WarningCollector; +import io.trino.metadata.FunctionResolver; +import io.trino.metadata.ResolvedFunction; +import io.trino.security.AccessControl; +import io.trino.security.AllowAllAccessControl; +import io.trino.spi.TrinoException; +import io.trino.spi.function.BoundSignature; +import io.trino.spi.function.OperatorType; +import io.trino.spi.type.ArrayType; +import io.trino.spi.type.CharType; +import io.trino.spi.type.Decimals; +import io.trino.spi.type.MapType; +import io.trino.spi.type.RowType; +import io.trino.spi.type.Type; +import io.trino.spi.type.TypeSignatureParameter; +import io.trino.spi.type.VarcharType; +import io.trino.sql.PlannerContext; +import io.trino.sql.tree.ArithmeticBinaryExpression; +import io.trino.sql.tree.ArithmeticUnaryExpression; +import io.trino.sql.tree.Array; +import io.trino.sql.tree.AstVisitor; +import io.trino.sql.tree.BetweenPredicate; +import io.trino.sql.tree.BinaryLiteral; +import io.trino.sql.tree.BindExpression; +import io.trino.sql.tree.BooleanLiteral; +import io.trino.sql.tree.Cast; +import io.trino.sql.tree.CharLiteral; +import io.trino.sql.tree.CoalesceExpression; +import io.trino.sql.tree.ComparisonExpression; +import io.trino.sql.tree.DecimalLiteral; +import io.trino.sql.tree.DoubleLiteral; +import io.trino.sql.tree.Expression; +import io.trino.sql.tree.FunctionCall; +import io.trino.sql.tree.GenericLiteral; +import io.trino.sql.tree.IfExpression; +import io.trino.sql.tree.InListExpression; +import io.trino.sql.tree.InPredicate; +import io.trino.sql.tree.IntervalLiteral; +import io.trino.sql.tree.IsNotNullPredicate; +import io.trino.sql.tree.IsNullPredicate; +import io.trino.sql.tree.LambdaExpression; +import io.trino.sql.tree.LogicalExpression; +import io.trino.sql.tree.LongLiteral; +import io.trino.sql.tree.Node; +import io.trino.sql.tree.NodeRef; +import io.trino.sql.tree.NotExpression; +import io.trino.sql.tree.NullIfExpression; +import io.trino.sql.tree.NullLiteral; +import io.trino.sql.tree.Row; +import io.trino.sql.tree.SearchedCaseExpression; +import io.trino.sql.tree.SimpleCaseExpression; +import io.trino.sql.tree.StringLiteral; +import io.trino.sql.tree.SubscriptExpression; +import io.trino.sql.tree.SymbolReference; +import io.trino.sql.tree.TimeLiteral; +import io.trino.sql.tree.TimestampLiteral; +import io.trino.sql.tree.TryExpression; +import io.trino.type.FunctionType; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.collect.ImmutableList.toImmutableList; +import static io.trino.cache.CacheUtils.uncheckedCacheGet; +import static io.trino.cache.SafeCaches.buildNonEvictableCache; +import static io.trino.spi.StandardErrorCode.INVALID_LITERAL; +import static io.trino.spi.type.BigintType.BIGINT; +import static io.trino.spi.type.BooleanType.BOOLEAN; +import static io.trino.spi.type.DoubleType.DOUBLE; +import static io.trino.spi.type.IntegerType.INTEGER; +import static io.trino.spi.type.TimeType.createTimeType; +import static io.trino.spi.type.TimeWithTimeZoneType.createTimeWithTimeZoneType; +import static io.trino.spi.type.TimestampType.createTimestampType; +import static io.trino.spi.type.TimestampWithTimeZoneType.createTimestampWithTimeZoneType; +import static io.trino.spi.type.VarbinaryType.VARBINARY; +import static io.trino.sql.analyzer.ExpressionTreeUtils.extractLocation; +import static io.trino.sql.analyzer.SemanticExceptions.semanticException; +import static io.trino.sql.analyzer.TypeSignatureTranslator.toTypeSignature; +import static io.trino.type.ArrayParametricType.ARRAY; +import static io.trino.type.DateTimes.extractTimePrecision; +import static io.trino.type.DateTimes.extractTimestampPrecision; +import static io.trino.type.DateTimes.parseTime; +import static io.trino.type.DateTimes.parseTimeWithTimeZone; +import static io.trino.type.DateTimes.parseTimestamp; +import static io.trino.type.DateTimes.parseTimestampWithTimeZone; +import static io.trino.type.DateTimes.timeHasTimeZone; +import static io.trino.type.DateTimes.timestampHasTimeZone; +import static io.trino.type.IntervalDayTimeType.INTERVAL_DAY_TIME; +import static io.trino.type.IntervalYearMonthType.INTERVAL_YEAR_MONTH; +import static io.trino.type.UnknownType.UNKNOWN; +import static java.lang.Math.toIntExact; +import static java.util.Objects.requireNonNull; + +/** + * This class is to facilitate obtaining the type of an expression and its subexpressions + * during planning (i.e., when interacting with IR expression). It will eventually get + * removed when we split the AST from the IR and we encode the type directly into IR expressions. + */ +public class IrTypeAnalyzer +{ + private final PlannerContext plannerContext; + + @Inject + public IrTypeAnalyzer(PlannerContext plannerContext) + { + this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); + } + + public Map, Type> getTypes(Session session, TypeProvider inputTypes, Iterable expressions) + { + Visitor visitor = new Visitor(plannerContext, session, inputTypes); + + for (Expression expression : expressions) { + visitor.process(expression, new Context(ImmutableMap.of())); + } + + return visitor.getTypes(); + } + + public Map, Type> getTypes(Session session, TypeProvider inputTypes, Expression expression) + { + return getTypes(session, inputTypes, ImmutableList.of(expression)); + } + + public Type getType(Session session, TypeProvider inputTypes, Expression expression) + { + return getTypes(session, inputTypes, expression).get(NodeRef.of(expression)); + } + + private static class Visitor + extends AstVisitor + { + private static final AccessControl ALLOW_ALL_ACCESS_CONTROL = new AllowAllAccessControl(); + + private final PlannerContext plannerContext; + private final Session session; + private final TypeProvider symbolTypes; + private final FunctionResolver functionResolver; + + // Cache from SQL type name to Type; every Type in the cache has a CAST defined from VARCHAR + private final Cache varcharCastableTypeCache = buildNonEvictableCache(CacheBuilder.newBuilder().maximumSize(1000)); + + private final Map, Type> expressionTypes = new LinkedHashMap<>(); + + public Visitor(PlannerContext plannerContext, Session session, TypeProvider symbolTypes) + { + this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); + this.session = requireNonNull(session, "session is null"); + this.symbolTypes = requireNonNull(symbolTypes, "symbolTypes is null"); + this.functionResolver = plannerContext.getFunctionResolver(WarningCollector.NOOP); + } + + public Map, Type> getTypes() + { + return expressionTypes; + } + + private Type setExpressionType(Expression expression, Type type) + { + requireNonNull(expression, "expression cannot be null"); + requireNonNull(type, "type cannot be null"); + + expressionTypes.put(NodeRef.of(expression), type); + return type; + } + + @Override + public Type process(Node node, Context context) + { + if (node instanceof Expression) { + // don't double process a node + Type type = expressionTypes.get(NodeRef.of(((Expression) node))); + if (type != null) { + return type; + } + } + return super.process(node, context); + } + + @Override + protected Type visitRow(Row node, Context context) + { + List types = node.getItems().stream() + .map(child -> process(child, context)) + .collect(toImmutableList()); + + return setExpressionType(node, RowType.anonymous(types)); + } + + @Override + protected Type visitSymbolReference(SymbolReference node, Context context) + { + Symbol symbol = Symbol.from(node); + Type type = context.argumentTypes().get(symbol); + if (type == null) { + type = symbolTypes.get(symbol); + } + checkArgument(type != null, "No type for: %s", node.getName()); + return setExpressionType(node, type); + } + + @Override + protected Type visitNotExpression(NotExpression node, Context context) + { + process(node.getValue(), context); + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitLogicalExpression(LogicalExpression node, Context context) + { + node.getTerms().forEach(term -> process(term, context)); + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitComparisonExpression(ComparisonExpression node, Context context) + { + process(node.getLeft(), context); + process(node.getRight(), context); + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitIsNullPredicate(IsNullPredicate node, Context context) + { + process(node.getValue(), context); + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitIsNotNullPredicate(IsNotNullPredicate node, Context context) + { + process(node.getValue(), context); + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitNullIfExpression(NullIfExpression node, Context context) + { + Type firstType = process(node.getFirst(), context); + Type ignored = process(node.getSecond(), context); + + // TODO: + // NULLIF(v1, v2) = IF(v1 = v2, v1) + // In order to compare v1 and v2, they need to have the same (coerced) type, but + // the result of NULLIF should be the same as v1. It's currently not possible + // to represent this in the IR, so we allow the types to be different for now and + // rely on the execution layer to insert the necessary casts. + + return setExpressionType(node, firstType); + } + + @Override + protected Type visitIfExpression(IfExpression node, Context context) + { + Type conditionType = process(node.getCondition(), context); + checkArgument(conditionType.equals(BOOLEAN), "Condition must be boolean: %s", conditionType); + + Type trueType = process(node.getTrueValue(), context); + if (node.getFalseValue().isPresent()) { + Type falseType = process(node.getFalseValue().get(), context); + checkArgument(trueType.equals(falseType), "Types must be equal: %s vs %s", trueType, falseType); + } + + return setExpressionType(node, trueType); + } + + @Override + protected Type visitSearchedCaseExpression(SearchedCaseExpression node, Context context) + { + Set resultTypes = node.getWhenClauses().stream() + .map(clause -> { + Type operandType = process(clause.getOperand(), context); + checkArgument(operandType.equals(BOOLEAN), "When clause operand must be boolean: %s", operandType); + return setExpressionType(clause, process(clause.getResult(), context)); + }) + .collect(Collectors.toSet()); + + checkArgument(resultTypes.size() == 1, "All result types must be the same: %s", resultTypes); + Type resultType = resultTypes.iterator().next(); + node.getDefaultValue().ifPresent(defaultValue -> { + Type defaultType = process(defaultValue, context); + checkArgument(defaultType.equals(resultType), "Default result type must be the same as WHEN result types: %s vs %s", defaultType, resultType); + }); + + return setExpressionType(node, resultType); + } + + @Override + protected Type visitSimpleCaseExpression(SimpleCaseExpression node, Context context) + { + Type operandType = process(node.getOperand(), context); + + Set resultTypes = node.getWhenClauses().stream() + .map(clause -> { + Type clauseOperandType = process(clause.getOperand(), context); + checkArgument(clauseOperandType.equals(operandType), "WHEN clause operand type must match CASE operand type: %s vs %s", clauseOperandType, operandType); + return setExpressionType(clause, process(clause.getResult(), context)); + }) + .collect(Collectors.toSet()); + + checkArgument(resultTypes.size() == 1, "All result types must be the same: %s", resultTypes); + Type resultType = resultTypes.iterator().next(); + node.getDefaultValue().ifPresent(defaultValue -> { + Type defaultType = process(defaultValue, context); + checkArgument(defaultType.equals(resultType), "Default result type must be the same as WHEN result types: %s vs %s", defaultType, resultType); + }); + + return setExpressionType(node, resultType); + } + + @Override + protected Type visitCoalesceExpression(CoalesceExpression node, Context context) + { + Set types = node.getOperands().stream() + .map(operand -> process(operand, context)) + .collect(Collectors.toSet()); + + checkArgument(types.size() == 1, "All operands must have the same type: %s", types); + return setExpressionType(node, types.iterator().next()); + } + + @Override + protected Type visitArithmeticUnary(ArithmeticUnaryExpression node, Context context) + { + return setExpressionType(node, process(node.getValue(), context)); + } + + @Override + protected Type visitArithmeticBinary(ArithmeticBinaryExpression node, Context context) + { + ImmutableList.Builder argumentTypes = ImmutableList.builder(); + argumentTypes.add(process(node.getLeft(), context)); + argumentTypes.add(process(node.getRight(), context)); + + BoundSignature operatorSignature = plannerContext.getMetadata() + .resolveOperator(OperatorType.valueOf(node.getOperator().name()), argumentTypes.build()) + .getSignature(); + + return setExpressionType(node, operatorSignature.getReturnType()); + } + + @Override + protected Type visitSubscriptExpression(SubscriptExpression node, Context context) + { + Type baseType = process(node.getBase(), context); + process(node.getIndex(), context); + return setExpressionType( + node, + switch (baseType) { + case RowType rowType -> rowType.getFields().get(toIntExact(((LongLiteral) node.getIndex()).getParsedValue()) - 1).getType(); + case ArrayType arrayType -> arrayType.getElementType(); + case MapType mapType -> mapType.getValueType(); + default -> throw new IllegalStateException("Unexpected type: " + baseType); + }); + } + + @Override + protected Type visitArray(Array node, Context context) + { + Type type = null; + for (Expression item : node.getValues()) { + Type itemType = process(item, context); + + if (type == null) { + type = itemType; + } + + checkArgument(itemType.equals(type), "Types must be equal: %s vs %s", itemType, type); + } + + if (type == null) { + type = UNKNOWN; + } + + Type arrayType = plannerContext.getTypeManager().getParameterizedType(ARRAY.getName(), ImmutableList.of(TypeSignatureParameter.typeParameter(type.getTypeSignature()))); + return setExpressionType(node, arrayType); + } + + @Override + protected Type visitStringLiteral(StringLiteral node, Context context) + { + return setExpressionType(node, VarcharType.createVarcharType(node.length())); + } + + @Override + protected Type visitCharLiteral(CharLiteral node, Context context) + { + return setExpressionType(node, CharType.createCharType(node.length())); + } + + @Override + protected Type visitBinaryLiteral(BinaryLiteral node, Context context) + { + return setExpressionType(node, VARBINARY); + } + + @Override + protected Type visitLongLiteral(LongLiteral node, Context context) + { + if (node.getParsedValue() >= Integer.MIN_VALUE && node.getParsedValue() <= Integer.MAX_VALUE) { + return setExpressionType(node, INTEGER); + } + + return setExpressionType(node, BIGINT); + } + + @Override + protected Type visitDoubleLiteral(DoubleLiteral node, Context context) + { + return setExpressionType(node, DOUBLE); + } + + @Override + protected Type visitDecimalLiteral(DecimalLiteral node, Context context) + { + return setExpressionType(node, Decimals.parse(node.getValue()).getType()); + } + + @Override + protected Type visitBooleanLiteral(BooleanLiteral node, Context context) + { + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitGenericLiteral(GenericLiteral node, Context context) + { + Type type = uncheckedCacheGet(varcharCastableTypeCache, node.getType(), () -> plannerContext.getTypeManager().fromSqlType(node.getType())); + return setExpressionType(node, type); + } + + @Override + protected Type visitTimeLiteral(TimeLiteral node, Context context) + { + Type type; + try { + int precision = extractTimePrecision(node.getValue()); + + if (timeHasTimeZone(node.getValue())) { + type = createTimeWithTimeZoneType(precision); + parseTimeWithTimeZone(precision, node.getValue()); + } + else { + type = createTimeType(precision); + parseTime(node.getValue()); + } + } + catch (TrinoException e) { + throw new TrinoException(e::getErrorCode, extractLocation(node), e.getMessage(), e); + } + catch (IllegalArgumentException e) { + throw semanticException(INVALID_LITERAL, node, "'%s' is not a valid TIME literal", node.getValue()); + } + + return setExpressionType(node, type); + } + + @Override + protected Type visitTimestampLiteral(TimestampLiteral node, Context context) + { + Type type; + try { + if (timestampHasTimeZone(node.getValue())) { + int precision = extractTimestampPrecision(node.getValue()); + type = createTimestampWithTimeZoneType(precision); + parseTimestampWithTimeZone(precision, node.getValue()); + } + else { + int precision = extractTimestampPrecision(node.getValue()); + type = createTimestampType(precision); + parseTimestamp(precision, node.getValue()); + } + } + catch (TrinoException e) { + throw new TrinoException(e::getErrorCode, extractLocation(node), e.getMessage(), e); + } + catch (Exception e) { + throw semanticException(INVALID_LITERAL, node, e, "'%s' is not a valid TIMESTAMP literal", node.getValue()); + } + + return setExpressionType(node, type); + } + + @Override + protected Type visitIntervalLiteral(IntervalLiteral node, Context context) + { + Type type; + if (node.isYearToMonth()) { + type = INTERVAL_YEAR_MONTH; + } + else { + type = INTERVAL_DAY_TIME; + } + return setExpressionType(node, type); + } + + @Override + protected Type visitNullLiteral(NullLiteral node, Context context) + { + return setExpressionType(node, UNKNOWN); + } + + @Override + protected Type visitFunctionCall(FunctionCall node, Context context) + { + // Function should already be resolved in IR + ResolvedFunction function = functionResolver.resolveFunction(session, node.getName(), null, ALLOW_ALL_ACCESS_CONTROL); + + BoundSignature signature = function.getSignature(); + for (int i = 0; i < node.getArguments().size(); i++) { + Expression argument = node.getArguments().get(i); + Type formalType = signature.getArgumentTypes().get(i); + + Type unused = switch (argument) { + case LambdaExpression lambda -> processLambdaExpression(lambda, ((FunctionType) formalType).getArgumentTypes()); + case BindExpression bind -> processBindExpression(bind, (FunctionType) formalType, context); + default -> process(argument, context); + }; + + // TODO + // checkArgument(actualType.equals(formalType), "Actual and formal argument types do not match: %s vs %s", actualType, formalType); + } + + return setExpressionType(node, signature.getReturnType()); + } + + private Type processBindExpression(BindExpression bind, FunctionType formalType, Context context) + { + List argumentTypes = new ArrayList<>(); + + argumentTypes.addAll(bind.getValues().stream() + .map(value -> process(value, context)) + .collect(toImmutableList())); + + argumentTypes.addAll(formalType.getArgumentTypes()); + + if (bind.getFunction() instanceof LambdaExpression) { + Type unused = processLambdaExpression((LambdaExpression) bind.getFunction(), argumentTypes); + // TODO: validate actual type and expected type are the same + return setExpressionType(bind, formalType); + } + + throw new UnsupportedOperationException("not yet implemented"); + } + + private Type processLambdaExpression(LambdaExpression lambda, List argumentTypes) + { + ImmutableMap.Builder typeBindings = ImmutableMap.builder(); + for (int i = 0; i < argumentTypes.size(); i++) { + typeBindings.put( + new Symbol(lambda.getArguments().get(i).getName().getValue()), + argumentTypes.get(i)); + } + + Type returnType = process(lambda.getBody(), new Context(typeBindings.buildOrThrow())); + return setExpressionType(lambda, new FunctionType(argumentTypes, returnType)); + } + + @Override + protected Type visitBetweenPredicate(BetweenPredicate node, Context context) + { + process(node.getValue(), context); + process(node.getMin(), context); + process(node.getMax(), context); + + return setExpressionType(node, BOOLEAN); + } + + @Override + public Type visitTryExpression(TryExpression node, Context context) + { + return setExpressionType(node, process(node.getInnerExpression(), context)); + } + + @Override + public Type visitCast(Cast node, Context context) + { + process(node.getExpression(), context); + return setExpressionType(node, plannerContext.getTypeManager().getType(toTypeSignature(node.getType()))); + } + + @Override + protected Type visitInPredicate(InPredicate node, Context context) + { + Expression value = node.getValue(); + InListExpression valueList = (InListExpression) node.getValueList(); + + Type type = process(value, context); + for (Expression item : valueList.getValues()) { + Type itemType = process(item, context); + checkArgument(itemType.equals(type), "Types must be equal: %s vs %s", itemType, type); + } + + setExpressionType(valueList, type); + + return setExpressionType(node, BOOLEAN); + } + + @Override + protected Type visitExpression(Expression node, Context context) + { + throw new UnsupportedOperationException("Not a valid IR expression: " + node.getClass().getName()); + } + + @Override + protected Type visitNode(Node node, Context context) + { + throw new UnsupportedOperationException("Not a valid IR expression: " + node.getClass().getName()); + } + } + + private record Context(Map argumentTypes) {} +} diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/LayoutConstraintEvaluator.java b/core/trino-main/src/main/java/io/trino/sql/planner/LayoutConstraintEvaluator.java index d99d8e25f702..b54882451af2 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/LayoutConstraintEvaluator.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/LayoutConstraintEvaluator.java @@ -35,7 +35,7 @@ public class LayoutConstraintEvaluator private final IrExpressionInterpreter evaluator; private final Set arguments; - public LayoutConstraintEvaluator(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, Session session, TypeProvider types, Map assignments, Expression expression) + public LayoutConstraintEvaluator(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, Session session, TypeProvider types, Map assignments, Expression expression) { this.assignments = ImmutableMap.copyOf(requireNonNull(assignments, "assignments is null")); evaluator = new IrExpressionInterpreter(expression, plannerContext, session, typeAnalyzer.getTypes(session, types, expression)); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/LocalExecutionPlanner.java b/core/trino-main/src/main/java/io/trino/sql/planner/LocalExecutionPlanner.java index ea92d1c5c405..dabadb610003 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/LocalExecutionPlanner.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/LocalExecutionPlanner.java @@ -395,7 +395,7 @@ public class LocalExecutionPlanner private final PlannerContext plannerContext; private final Metadata metadata; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final Optional explainAnalyzeContext; private final PageSourceProvider pageSourceProvider; private final IndexManager indexManager; @@ -450,7 +450,7 @@ public class LocalExecutionPlanner @Inject public LocalExecutionPlanner( PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, Optional explainAnalyzeContext, PageSourceProvider pageSourceProvider, IndexManager indexManager, diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java b/core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java index d0c89b4d27bb..2f046cb5214a 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java @@ -181,7 +181,7 @@ public enum Stage private final Metadata metadata; private final PlannerContext plannerContext; private final TypeCoercion typeCoercion; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final StatisticsAggregationPlanner statisticsAggregationPlanner; private final StatsCalculator statsCalculator; private final CostCalculator costCalculator; @@ -193,7 +193,7 @@ public LogicalPlanner( List planOptimizers, PlanNodeIdAllocator idAllocator, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, StatsCalculator statsCalculator, CostCalculator costCalculator, WarningCollector warningCollector, @@ -208,7 +208,7 @@ public LogicalPlanner( PlanSanityChecker planSanityChecker, PlanNodeIdAllocator idAllocator, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, StatsCalculator statsCalculator, CostCalculator costCalculator, WarningCollector warningCollector, diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/PartialTranslator.java b/core/trino-main/src/main/java/io/trino/sql/planner/PartialTranslator.java index 803f47967185..71353e6c87ac 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/PartialTranslator.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/PartialTranslator.java @@ -40,7 +40,7 @@ private PartialTranslator() {} public static Map, ConnectorExpression> extractPartialTranslations( Expression inputExpression, Session session, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider typeProvider, PlannerContext plannerContext) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/PlanOptimizers.java b/core/trino-main/src/main/java/io/trino/sql/planner/PlanOptimizers.java index 95d127b0c591..db9c357f2615 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/PlanOptimizers.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/PlanOptimizers.java @@ -272,7 +272,7 @@ public class PlanOptimizers @Inject public PlanOptimizers( PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TaskManagerConfig taskManagerConfig, SplitManager splitManager, PageSourceManager pageSourceManager, @@ -303,7 +303,7 @@ public PlanOptimizers( public PlanOptimizers( PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TaskManagerConfig taskManagerConfig, boolean forceSingleNode, SplitManager splitManager, diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/SplitSourceFactory.java b/core/trino-main/src/main/java/io/trino/sql/planner/SplitSourceFactory.java index 37ce4def5c12..8976a50037ae 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/SplitSourceFactory.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/SplitSourceFactory.java @@ -92,10 +92,10 @@ public class SplitSourceFactory private final SplitManager splitManager; private final PlannerContext plannerContext; private final DynamicFilterService dynamicFilterService; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; @Inject - public SplitSourceFactory(SplitManager splitManager, PlannerContext plannerContext, DynamicFilterService dynamicFilterService, TypeAnalyzer typeAnalyzer) + public SplitSourceFactory(SplitManager splitManager, PlannerContext plannerContext, DynamicFilterService dynamicFilterService, IrTypeAnalyzer typeAnalyzer) { this.splitManager = requireNonNull(splitManager, "splitManager is null"); this.plannerContext = requireNonNull(plannerContext, "metadata is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/AddExchangesBelowPartialAggregationOverGroupIdRuleSet.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/AddExchangesBelowPartialAggregationOverGroupIdRuleSet.java index f0bbd4088452..7ee9072becd0 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/AddExchangesBelowPartialAggregationOverGroupIdRuleSet.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/AddExchangesBelowPartialAggregationOverGroupIdRuleSet.java @@ -26,10 +26,10 @@ import io.trino.matching.Captures; import io.trino.matching.Pattern; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Partitioning; import io.trino.sql.planner.PartitioningScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.optimizations.StreamPreferredProperties; import io.trino.sql.planner.optimizations.StreamPropertyDerivations.StreamProperties; @@ -129,13 +129,13 @@ public class AddExchangesBelowPartialAggregationOverGroupIdRuleSet private static final double ANTI_SKEWNESS_MARGIN = 3; private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final TaskCountEstimator taskCountEstimator; private final DataSize maxPartialAggregationMemoryUsage; public AddExchangesBelowPartialAggregationOverGroupIdRuleSet( PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TaskCountEstimator taskCountEstimator, TaskManagerConfig taskManagerConfig) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/CanonicalizeExpressionRewriter.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/CanonicalizeExpressionRewriter.java index 5fc78d75cb95..d0f651fafbb5 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/CanonicalizeExpressionRewriter.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/CanonicalizeExpressionRewriter.java @@ -22,7 +22,7 @@ import io.trino.spi.type.Type; import io.trino.spi.type.VarcharType; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.ArithmeticBinaryExpression; import io.trino.sql.tree.Cast; @@ -60,7 +60,7 @@ public static Expression canonicalizeExpression(Expression expression, Map rewrite(expression, context.getSession(), plannerContext, typeAnalyzer, context.getSymbolAllocator().getTypes())); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/DereferencePushdown.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/DereferencePushdown.java index 97b034d0efc9..94c13bda0089 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/DereferencePushdown.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/DereferencePushdown.java @@ -16,8 +16,8 @@ import com.google.common.collect.ImmutableList; import io.trino.Session; import io.trino.spi.type.RowType; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.DefaultExpressionTraversalVisitor; import io.trino.sql.tree.Expression; @@ -41,7 +41,7 @@ class DereferencePushdown { private DereferencePushdown() {} - public static Set extractRowSubscripts(Collection expressions, boolean allowOverlap, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + public static Set extractRowSubscripts(Collection expressions, boolean allowOverlap, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { Set symbolReferencesAndRowSubscripts = expressions.stream() .flatMap(expression -> getSymbolReferencesAndRowSubscripts(expression, session, typeAnalyzer, types).stream()) @@ -62,7 +62,7 @@ public static Set extractRowSubscripts(Collection projections, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + public static boolean exclusiveDereferences(Set projections, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { return projections.stream() .allMatch(expression -> expression instanceof SymbolReference || @@ -80,7 +80,7 @@ public static Symbol getBase(SubscriptExpression expression) * Extract the sub-expressions of type {@link SubscriptExpression} or {@link SymbolReference} from the expression * in a top-down manner. The expressions within the base of a valid {@link SubscriptExpression} sequence are not extracted. */ - private static List getSymbolReferencesAndRowSubscripts(Expression expression, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + private static List getSymbolReferencesAndRowSubscripts(Expression expression, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { ImmutableList.Builder builder = ImmutableList.builder(); @@ -112,7 +112,7 @@ protected Void visitLambdaExpression(LambdaExpression node, ImmutableList.Builde return builder.build(); } - private static boolean isRowSubscriptChain(SubscriptExpression expression, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + private static boolean isRowSubscriptChain(SubscriptExpression expression, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { if (!(typeAnalyzer.getType(session, types, expression.getBase()) instanceof RowType)) { return false; diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/EliminateCrossJoins.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/EliminateCrossJoins.java index 8ae612a270a7..85d2f2616c27 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/EliminateCrossJoins.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/EliminateCrossJoins.java @@ -20,10 +20,10 @@ import io.trino.matching.Captures; import io.trino.matching.Pattern; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OptimizerConfig.JoinReorderingStrategy; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.optimizations.joins.JoinGraph; import io.trino.sql.planner.plan.FilterNode; @@ -57,9 +57,9 @@ public class EliminateCrossJoins { private static final Pattern PATTERN = join(); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public EliminateCrossJoins(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public EliminateCrossJoins(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractDereferencesFromFilterAboveScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractDereferencesFromFilterAboveScan.java index 7ca5a08a24bc..d2d749694ef3 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractDereferencesFromFilterAboveScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractDereferencesFromFilterAboveScan.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.FilterNode; @@ -69,9 +69,9 @@ public class ExtractDereferencesFromFilterAboveScan implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public ExtractDereferencesFromFilterAboveScan(TypeAnalyzer typeAnalyzer) + public ExtractDereferencesFromFilterAboveScan(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractSpatialJoins.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractSpatialJoins.java index 28d0950e927b..5f21d857fac4 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractSpatialJoins.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ExtractSpatialJoins.java @@ -46,9 +46,9 @@ import io.trino.split.SplitSource.SplitBatch; import io.trino.sql.PlannerContext; import io.trino.sql.planner.BuiltinFunctionCallBuilder; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.ResolvedFunctionCallBuilder; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.iterative.Rule.Context; import io.trino.sql.planner.iterative.Rule.Result; @@ -158,9 +158,9 @@ public class ExtractSpatialJoins private final PlannerContext plannerContext; private final SplitManager splitManager; private final PageSourceManager pageSourceManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public ExtractSpatialJoins(PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, TypeAnalyzer typeAnalyzer) + public ExtractSpatialJoins(PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.splitManager = requireNonNull(splitManager, "splitManager is null"); @@ -186,9 +186,9 @@ public static final class ExtractSpatialInnerJoin private final PlannerContext plannerContext; private final SplitManager splitManager; private final PageSourceManager pageSourceManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public ExtractSpatialInnerJoin(PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, TypeAnalyzer typeAnalyzer) + public ExtractSpatialInnerJoin(PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.splitManager = requireNonNull(splitManager, "splitManager is null"); @@ -242,9 +242,9 @@ public static final class ExtractSpatialLeftJoin private final PlannerContext plannerContext; private final SplitManager splitManager; private final PageSourceManager pageSourceManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public ExtractSpatialLeftJoin(PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, TypeAnalyzer typeAnalyzer) + public ExtractSpatialLeftJoin(PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.splitManager = requireNonNull(splitManager, "splitManager is null"); @@ -298,7 +298,7 @@ private static Result tryCreateSpatialJoin( PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { PlanNode leftNode = joinNode.getLeft(); PlanNode rightNode = joinNode.getRight(); @@ -368,7 +368,7 @@ private static Result tryCreateSpatialJoin( PlannerContext plannerContext, SplitManager splitManager, PageSourceManager pageSourceManager, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { // TODO Add support for distributed left spatial joins Optional spatialPartitioningTableName = joinNode.getType() == INNER ? getSpatialPartitioningTableName(context.getSession()) : Optional.empty(); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/InlineProjections.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/InlineProjections.java index 890a56533620..3af745235e53 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/InlineProjections.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/InlineProjections.java @@ -22,9 +22,9 @@ import io.trino.matching.Pattern; import io.trino.spi.type.RowType; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolsExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; @@ -65,9 +65,9 @@ public class InlineProjections .with(source().matching(project().capturedAs(CHILD))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public InlineProjections(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public InlineProjections(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -89,7 +89,7 @@ public Result apply(ProjectNode parent, Captures captures, Context context) .orElse(Result.empty()); } - static Optional inlineProjections(PlannerContext plannerContext, ProjectNode parent, ProjectNode child, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + static Optional inlineProjections(PlannerContext plannerContext, ProjectNode parent, ProjectNode child, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { // squash identity projections if (parent.isIdentity() && child.isIdentity()) { @@ -165,7 +165,7 @@ private static Expression inlineReferences(Expression expression, Assignments as return inlineSymbols(mapping, expression); } - private static Set extractInliningTargets(PlannerContext plannerContext, ProjectNode parent, ProjectNode child, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + private static Set extractInliningTargets(PlannerContext plannerContext, ProjectNode parent, ProjectNode child, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { // candidates for inlining are // 1. references to simple constants or symbol references diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PreAggregateCaseAggregations.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PreAggregateCaseAggregations.java index 6a58bf147463..1ba86d3bebc9 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PreAggregateCaseAggregations.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PreAggregateCaseAggregations.java @@ -29,9 +29,9 @@ import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolsExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.AggregationNode.Aggregation; @@ -119,9 +119,9 @@ public class PreAggregateCaseAggregations .with(source().matching(not(AggregationNode.class::isInstance))))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PreAggregateCaseAggregations(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public PreAggregateCaseAggregations(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushAggregationIntoTableScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushAggregationIntoTableScan.java index 6f836483af85..18049e35ef0e 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushAggregationIntoTableScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushAggregationIntoTableScan.java @@ -33,11 +33,11 @@ import io.trino.sql.PlannerContext; import io.trino.sql.planner.ConnectorExpressionTranslator; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.OrderingScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.Assignments; @@ -82,9 +82,9 @@ public class PushAggregationIntoTableScan .with(source().matching(tableScan().capturedAs(TABLE_SCAN))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushAggregationIntoTableScan(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public PushAggregationIntoTableScan(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -127,7 +127,7 @@ public Result apply(AggregationNode node, Captures captures, Context context) public static Optional pushAggregationIntoTableScan( PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, Context context, PlanNode aggregationNode, TableScanNode tableScan, diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDistinctLimitIntoTableScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDistinctLimitIntoTableScan.java index 1d9eb418752a..470d477ce6de 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDistinctLimitIntoTableScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDistinctLimitIntoTableScan.java @@ -19,7 +19,7 @@ import io.trino.matching.Captures; import io.trino.matching.Pattern; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.DistinctLimitNode; import io.trino.sql.planner.plan.LimitNode; @@ -48,9 +48,9 @@ public class PushDistinctLimitIntoTableScan .with(source().matching(tableScan().capturedAs(TABLE_SCAN))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDistinctLimitIntoTableScan(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public PushDistinctLimitIntoTableScan(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughFilter.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughFilter.java index be69244c43c6..a3a4fe896155 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughFilter.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughFilter.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.FilterNode; @@ -62,9 +62,9 @@ public class PushDownDereferenceThroughFilter implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferenceThroughFilter(TypeAnalyzer typeAnalyzer) + public PushDownDereferenceThroughFilter(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughJoin.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughJoin.java index 1753653bfd27..2c0e7f86c07a 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughJoin.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughJoin.java @@ -19,9 +19,9 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.JoinNode; @@ -77,9 +77,9 @@ public class PushDownDereferenceThroughJoin implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferenceThroughJoin(TypeAnalyzer typeAnalyzer) + public PushDownDereferenceThroughJoin(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughProject.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughProject.java index 772e8558234f..dbe69b1b5c8d 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughProject.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughProject.java @@ -17,7 +17,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.ProjectNode; @@ -54,9 +54,9 @@ public class PushDownDereferenceThroughProject implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferenceThroughProject(TypeAnalyzer typeAnalyzer) + public PushDownDereferenceThroughProject(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughSemiJoin.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughSemiJoin.java index b357c54ea6d0..f56a99b6e3c3 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughSemiJoin.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughSemiJoin.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.PlanNode; @@ -66,9 +66,9 @@ public class PushDownDereferenceThroughSemiJoin implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferenceThroughSemiJoin(TypeAnalyzer typeAnalyzer) + public PushDownDereferenceThroughSemiJoin(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughUnnest.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughUnnest.java index 8e10890f5982..8afba6237e3f 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughUnnest.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferenceThroughUnnest.java @@ -18,8 +18,8 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.ProjectNode; @@ -63,9 +63,9 @@ public class PushDownDereferenceThroughUnnest implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferenceThroughUnnest(TypeAnalyzer typeAnalyzer) + public PushDownDereferenceThroughUnnest(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughAssignUniqueId.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughAssignUniqueId.java index 979ab5d804d2..58c904df3778 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughAssignUniqueId.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughAssignUniqueId.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.AssignUniqueId; import io.trino.sql.planner.plan.Assignments; @@ -58,9 +58,9 @@ public class PushDownDereferencesThroughAssignUniqueId implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughAssignUniqueId(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughAssignUniqueId(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughLimit.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughLimit.java index 0fec0133ac46..036b64cf8289 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughLimit.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughLimit.java @@ -19,9 +19,9 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OrderingScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.LimitNode; @@ -63,9 +63,9 @@ public class PushDownDereferencesThroughLimit implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughLimit(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughLimit(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughMarkDistinct.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughMarkDistinct.java index a8cadd6a92a4..6a84ea97b5f0 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughMarkDistinct.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughMarkDistinct.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.MarkDistinctNode; @@ -63,9 +63,9 @@ public class PushDownDereferencesThroughMarkDistinct implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughMarkDistinct(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughMarkDistinct(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughRowNumber.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughRowNumber.java index 983e85799a6c..09159a9875da 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughRowNumber.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughRowNumber.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.ProjectNode; @@ -63,9 +63,9 @@ public class PushDownDereferencesThroughRowNumber implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughRowNumber(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughRowNumber(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughSort.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughSort.java index 528f3b2dc812..33414fac1720 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughSort.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughSort.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.ProjectNode; @@ -63,9 +63,9 @@ public class PushDownDereferencesThroughSort implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughSort(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughSort(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopN.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopN.java index 478bd3ad406a..e2b9eb5bf814 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopN.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopN.java @@ -18,7 +18,7 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.ProjectNode; @@ -63,9 +63,9 @@ public class PushDownDereferencesThroughTopN implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughTopN(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughTopN(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopNRanking.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopNRanking.java index e0bcb2dec420..bb6d3fda00f6 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopNRanking.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughTopNRanking.java @@ -18,9 +18,9 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OrderingScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.DataOrganizationSpecification; @@ -66,9 +66,9 @@ public class PushDownDereferencesThroughTopNRanking implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughTopNRanking(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughTopNRanking(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughWindow.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughWindow.java index fbf6a829a28f..ab6ede870c48 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughWindow.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushDownDereferencesThroughWindow.java @@ -18,9 +18,9 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OrderingScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.DataOrganizationSpecification; @@ -67,9 +67,9 @@ public class PushDownDereferencesThroughWindow implements Rule { private static final Capture CHILD = newCapture(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushDownDereferencesThroughWindow(TypeAnalyzer typeAnalyzer) + public PushDownDereferencesThroughWindow(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushInequalityFilterExpressionBelowJoinRuleSet.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushInequalityFilterExpressionBelowJoinRuleSet.java index 73956965beef..271d8228294a 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushInequalityFilterExpressionBelowJoinRuleSet.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushInequalityFilterExpressionBelowJoinRuleSet.java @@ -20,8 +20,8 @@ import io.trino.matching.Captures; import io.trino.matching.Pattern; import io.trino.metadata.Metadata; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.FilterNode; @@ -91,9 +91,9 @@ public class PushInequalityFilterExpressionBelowJoinRuleSet join().capturedAs(JOIN_CAPTURE))); private final Metadata metadata; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushInequalityFilterExpressionBelowJoinRuleSet(Metadata metadata, TypeAnalyzer typeAnalyzer) + public PushInequalityFilterExpressionBelowJoinRuleSet(Metadata metadata, IrTypeAnalyzer typeAnalyzer) { this.metadata = requireNonNull(metadata, "metadata is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushJoinIntoTableScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushJoinIntoTableScan.java index b249aed8577e..680925e9a3bb 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushJoinIntoTableScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushJoinIntoTableScan.java @@ -31,8 +31,8 @@ import io.trino.sql.PlannerContext; import io.trino.sql.planner.ConnectorExpressionTranslator; import io.trino.sql.planner.ConnectorExpressionTranslator.ConnectorExpressionTranslation; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; @@ -77,9 +77,9 @@ public class PushJoinIntoTableScan .with(right().matching(tableScan().capturedAs(RIGHT_TABLE_SCAN))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushJoinIntoTableScan(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public PushJoinIntoTableScan(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushLimitThroughProject.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushLimitThroughProject.java index 4973af72860e..4bafaeca0956 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushLimitThroughProject.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushLimitThroughProject.java @@ -18,9 +18,9 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OrderingScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.optimizations.SymbolMapper; import io.trino.sql.planner.plan.LimitNode; @@ -51,9 +51,9 @@ public class PushLimitThroughProject .matching(projectNode -> !projectNode.isIdentity()) .capturedAs(CHILD))); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushLimitThroughProject(TypeAnalyzer typeAnalyzer) + public PushLimitThroughProject(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushMergeWriterUpdateIntoConnector.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushMergeWriterUpdateIntoConnector.java index 0e991a450fe1..51064bacc4a1 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushMergeWriterUpdateIntoConnector.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushMergeWriterUpdateIntoConnector.java @@ -23,7 +23,7 @@ import io.trino.spi.expression.Constant; import io.trino.sql.PlannerContext; import io.trino.sql.planner.ConnectorExpressionTranslator; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.MergeProcessorNode; import io.trino.sql.planner.plan.MergeWriterNode; @@ -68,7 +68,7 @@ public class PushMergeWriterUpdateIntoConnector project().capturedAs(PROJECT_NODE_CAPTURE).with(source().matching( tableScan().capturedAs(TABLE_SCAN))))))))); - public PushMergeWriterUpdateIntoConnector(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, Metadata metadata) + public PushMergeWriterUpdateIntoConnector(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, Metadata metadata) { this.metadata = requireNonNull(metadata, "metadata is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -77,7 +77,7 @@ public PushMergeWriterUpdateIntoConnector(PlannerContext plannerContext, TypeAna private final Metadata metadata; private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; @Override public Pattern getPattern() diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushPredicateIntoTableScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushPredicateIntoTableScan.java index 155121aa191f..2e3a6700aef3 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushPredicateIntoTableScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushPredicateIntoTableScan.java @@ -37,12 +37,12 @@ import io.trino.sql.planner.ConnectorExpressionTranslator.ConnectorExpressionTranslation; import io.trino.sql.planner.DomainTranslator; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LayoutConstraintEvaluator; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolAllocator; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.FilterNode; import io.trino.sql.planner.plan.PlanNode; @@ -89,11 +89,11 @@ public class PushPredicateIntoTableScan tableScan().capturedAs(TABLE_SCAN))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final boolean pruneWithPredicateExpression; - public PushPredicateIntoTableScan(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, boolean pruneWithPredicateExpression) + public PushPredicateIntoTableScan(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, boolean pruneWithPredicateExpression) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -160,7 +160,7 @@ public static Optional pushFilterIntoTableScan( Session session, SymbolAllocator symbolAllocator, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, StatsProvider statsProvider, DomainTranslator domainTranslator) { @@ -361,7 +361,7 @@ static Expression createResultingPredicate( PlannerContext plannerContext, Session session, SymbolAllocator symbolAllocator, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, Expression dynamicFilter, Expression unenforcedConstraints, Expression nonDeterministicPredicate, diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionIntoTableScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionIntoTableScan.java index 6c51f5e4d813..58a11840bd8e 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionIntoTableScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionIntoTableScan.java @@ -35,10 +35,10 @@ import io.trino.sql.PlannerContext; import io.trino.sql.planner.ConnectorExpressionTranslator; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.ProjectNode; @@ -75,11 +75,11 @@ public class PushProjectionIntoTableScan tableScan().capturedAs(TABLE_SCAN))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final LiteralEncoder literalEncoder; private final ScalarStatsCalculator scalarStatsCalculator; - public PushProjectionIntoTableScan(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, ScalarStatsCalculator scalarStatsCalculator) + public PushProjectionIntoTableScan(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, ScalarStatsCalculator scalarStatsCalculator) { this.plannerContext = plannerContext; this.typeAnalyzer = typeAnalyzer; diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionThroughJoin.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionThroughJoin.java index 755a0dcfa6e7..45d059a7cb48 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionThroughJoin.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushProjectionThroughJoin.java @@ -17,10 +17,10 @@ import com.google.common.collect.Streams; import io.trino.Session; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolsExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.Lookup; import io.trino.sql.planner.plan.Assignments; @@ -53,7 +53,7 @@ public static Optional pushProjectionThroughJoin( Lookup lookup, PlanNodeIdAllocator planNodeIdAllocator, Session session, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types) { if (!projectNode.getAssignments().getExpressions().stream().allMatch(expression -> isDeterministic(expression, plannerContext.getMetadata()))) { @@ -147,7 +147,7 @@ private static PlanNode inlineProjections( ProjectNode parentProjection, Lookup lookup, Session session, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types) { PlanNode child = lookup.resolve(parentProjection.getSource()); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushTopNThroughProject.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushTopNThroughProject.java index da85df626f56..ca4fbcae0447 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushTopNThroughProject.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/PushTopNThroughProject.java @@ -18,8 +18,8 @@ import io.trino.matching.Capture; import io.trino.matching.Captures; import io.trino.matching.Pattern; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.optimizations.SymbolMapper; import io.trino.sql.planner.plan.Assignments; @@ -71,9 +71,9 @@ public final class PushTopNThroughProject .capturedAs(PROJECT_CHILD) // do not push topN between projection and table scan so that they can be merged into a PageProcessor .with(source().matching(node -> !(node instanceof TableScanNode))))); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public PushTopNThroughProject(TypeAnalyzer typeAnalyzer) + public PushTopNThroughProject(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantDateTrunc.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantDateTrunc.java index 3e61147938e1..5b8bd9b2d2f8 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantDateTrunc.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantDateTrunc.java @@ -20,8 +20,8 @@ import io.trino.spi.type.VarcharType; import io.trino.sql.PlannerContext; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.NoOpSymbolResolver; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Expression; import io.trino.sql.tree.ExpressionTreeRewriter; @@ -42,12 +42,12 @@ public class RemoveRedundantDateTrunc extends ExpressionRewriteRuleSet { - public RemoveRedundantDateTrunc(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public RemoveRedundantDateTrunc(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { super((expression, context) -> rewrite(expression, context.getSession(), plannerContext, typeAnalyzer, context.getSymbolAllocator().getTypes())); } - private static Expression rewrite(Expression expression, Session session, PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, TypeProvider types) + private static Expression rewrite(Expression expression, Session session, PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { requireNonNull(plannerContext, "plannerContext is null"); requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantPredicateAboveTableScan.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantPredicateAboveTableScan.java index a6c3f1341bb7..3b87045f7ede 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantPredicateAboveTableScan.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveRedundantPredicateAboveTableScan.java @@ -26,8 +26,8 @@ import io.trino.sql.PlannerContext; import io.trino.sql.planner.DomainTranslator; import io.trino.sql.planner.DomainTranslator.ExtractionResult; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.FilterNode; @@ -69,9 +69,9 @@ public class RemoveRedundantPredicateAboveTableScan .matching(node -> !node.getEnforcedConstraint().isAll()))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public RemoveRedundantPredicateAboveTableScan(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public RemoveRedundantPredicateAboveTableScan(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveUnsupportedDynamicFilters.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveUnsupportedDynamicFilters.java index 95d0929da0c6..935ab898e69e 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveUnsupportedDynamicFilters.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/RemoveUnsupportedDynamicFilters.java @@ -17,22 +17,12 @@ import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import io.trino.Session; -import io.trino.connector.CatalogServiceProvider; -import io.trino.metadata.AnalyzePropertyManager; import io.trino.metadata.OperatorNotFoundException; -import io.trino.metadata.TableFunctionRegistry; -import io.trino.metadata.TableProceduresPropertyManager; -import io.trino.metadata.TableProceduresRegistry; -import io.trino.metadata.TablePropertyManager; -import io.trino.security.AllowAllAccessControl; import io.trino.spi.type.Type; import io.trino.sql.DynamicFilters; import io.trino.sql.PlannerContext; -import io.trino.sql.analyzer.SessionTimeProvider; -import io.trino.sql.analyzer.StatementAnalyzerFactory; -import io.trino.sql.parser.SqlParser; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.optimizations.PlanOptimizer; import io.trino.sql.planner.plan.DynamicFilterId; @@ -50,7 +40,6 @@ import io.trino.sql.tree.LogicalExpression; import io.trino.sql.tree.NodeRef; import io.trino.sql.tree.SymbolReference; -import io.trino.transaction.NoOpTransactionManager; import io.trino.type.TypeCoercion; import java.util.HashSet; @@ -86,26 +75,13 @@ public class RemoveUnsupportedDynamicFilters implements PlanOptimizer { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; public RemoveUnsupportedDynamicFilters(PlannerContext plannerContext) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); // This is a limited type analyzer for the simple expressions used in dynamic filters - this.typeAnalyzer = new TypeAnalyzer( - plannerContext, - new StatementAnalyzerFactory( - plannerContext, - new SqlParser(), - SessionTimeProvider.DEFAULT, - new AllowAllAccessControl(), - new NoOpTransactionManager(), - user -> ImmutableSet.of(), - new TableProceduresRegistry(CatalogServiceProvider.fail("procedures are not supported in testing analyzer")), - new TableFunctionRegistry(CatalogServiceProvider.fail("table functions are not supported in testing analyzer")), - new TablePropertyManager(CatalogServiceProvider.fail("table properties not supported in testing analyzer")), - new AnalyzePropertyManager(CatalogServiceProvider.fail("analyze properties not supported in testing analyzer")), - new TableProceduresPropertyManager(CatalogServiceProvider.fail("procedures are not supported in testing analyzer")))); + this.typeAnalyzer = new IrTypeAnalyzer(plannerContext); } @Override diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ReorderJoins.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ReorderJoins.java index 0ea1cb44feae..48acca45a493 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ReorderJoins.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/ReorderJoins.java @@ -34,11 +34,11 @@ import io.trino.metadata.Metadata; import io.trino.sql.PlannerContext; import io.trino.sql.planner.EqualityInference; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OptimizerConfig.JoinDistributionType; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolsExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.Lookup; import io.trino.sql.planner.iterative.Rule; @@ -102,12 +102,12 @@ public class ReorderJoins // We check that join distribution type is absent because we only want // to do this transformation once (reordered joins will have distribution type already set). private final Pattern pattern; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final PlannerContext plannerContext; private final CostComparator costComparator; - public ReorderJoins(PlannerContext plannerContext, CostComparator costComparator, TypeAnalyzer typeAnalyzer) + public ReorderJoins(PlannerContext plannerContext, CostComparator costComparator, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.costComparator = requireNonNull(costComparator, "costComparator is null"); @@ -546,7 +546,7 @@ public boolean equals(Object obj) && this.pushedProjectionThroughJoin == other.pushedProjectionThroughJoin; } - static MultiJoinNode toMultiJoinNode(PlannerContext plannerContext, JoinNode joinNode, Context context, boolean pushProjectionsThroughJoin, TypeAnalyzer typeAnalyzer) + static MultiJoinNode toMultiJoinNode(PlannerContext plannerContext, JoinNode joinNode, Context context, boolean pushProjectionsThroughJoin, IrTypeAnalyzer typeAnalyzer) { return toMultiJoinNode( plannerContext, @@ -568,7 +568,7 @@ static MultiJoinNode toMultiJoinNode( int joinLimit, boolean pushProjectionsThroughJoin, Session session, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types) { // the number of sources is the number of joins + 1 @@ -580,7 +580,7 @@ private static class JoinNodeFlattener { private final PlannerContext plannerContext; private final Session session; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final TypeProvider types; private final Lookup lookup; private final PlanNodeIdAllocator planNodeIdAllocator; @@ -601,7 +601,7 @@ private static class JoinNodeFlattener int sourceLimit, boolean pushProjectionsThroughJoin, Session session, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyCountOverConstant.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyCountOverConstant.java index d60b5560030a..761fd0f7d03f 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyCountOverConstant.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyCountOverConstant.java @@ -24,8 +24,8 @@ import io.trino.spi.function.CatalogSchemaFunctionName; import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.Assignments; @@ -58,9 +58,9 @@ public class SimplifyCountOverConstant .with(source().matching(project().capturedAs(CHILD))); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public SimplifyCountOverConstant(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public SimplifyCountOverConstant(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyExpressions.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyExpressions.java index 66023b705dc2..a5432fd3d5da 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyExpressions.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/SimplifyExpressions.java @@ -18,10 +18,10 @@ import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.SymbolAllocator; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.tree.Expression; import io.trino.sql.tree.NodeRef; @@ -38,7 +38,7 @@ public class SimplifyExpressions extends ExpressionRewriteRuleSet { - public static Expression rewrite(Expression expression, Session session, SymbolAllocator symbolAllocator, PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public static Expression rewrite(Expression expression, Session session, SymbolAllocator symbolAllocator, PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { requireNonNull(plannerContext, "plannerContext is null"); requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -55,7 +55,7 @@ public static Expression rewrite(Expression expression, Session session, SymbolA return new LiteralEncoder(plannerContext).toExpression(optimized, expressionTypes.get(NodeRef.of(expression))); } - public SimplifyExpressions(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public SimplifyExpressions(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { super(createRewrite(plannerContext, typeAnalyzer)); } @@ -71,7 +71,7 @@ public Set> rules() patternRecognitionExpressionRewrite()); // ApplyNode and AggregationNode are not supported, because ExpressionInterpreter doesn't support them } - private static ExpressionRewriter createRewrite(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + private static ExpressionRewriter createRewrite(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { requireNonNull(plannerContext, "plannerContext is null"); requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapCastInComparison.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapCastInComparison.java index a981f60ac61d..b78688c7509a 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapCastInComparison.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapCastInComparison.java @@ -36,9 +36,9 @@ import io.trino.sql.InterpretedFunctionInvoker; import io.trino.sql.PlannerContext; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Cast; import io.trino.sql.tree.ComparisonExpression; @@ -123,12 +123,12 @@ public class UnwrapCastInComparison extends ExpressionRewriteRuleSet { - public UnwrapCastInComparison(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public UnwrapCastInComparison(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { super(createRewrite(plannerContext, typeAnalyzer)); } - private static ExpressionRewriter createRewrite(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + private static ExpressionRewriter createRewrite(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { requireNonNull(plannerContext, "plannerContext is null"); requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -138,7 +138,7 @@ private static ExpressionRewriter createRewrite(PlannerContext plannerContext, T public static Expression unwrapCasts(Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, Expression expression) { @@ -149,13 +149,13 @@ private static class Visitor extends io.trino.sql.tree.ExpressionRewriter { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final Session session; private final TypeProvider types; private final InterpretedFunctionInvoker functionInvoker; private final LiteralEncoder literalEncoder; - public Visitor(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, Session session, TypeProvider types) + public Visitor(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, Session session, TypeProvider types) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapDateTruncInComparison.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapDateTruncInComparison.java index 20c5b45adb0d..a0c733eddc00 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapDateTruncInComparison.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapDateTruncInComparison.java @@ -29,9 +29,9 @@ import io.trino.sql.InterpretedFunctionInvoker; import io.trino.sql.PlannerContext; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.BetweenPredicate; import io.trino.sql.tree.Cast; @@ -101,12 +101,12 @@ public class UnwrapDateTruncInComparison extends ExpressionRewriteRuleSet { - public UnwrapDateTruncInComparison(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public UnwrapDateTruncInComparison(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { super(createRewrite(plannerContext, typeAnalyzer)); } - private static ExpressionRewriter createRewrite(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + private static ExpressionRewriter createRewrite(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { requireNonNull(plannerContext, "plannerContext is null"); requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -116,7 +116,7 @@ private static ExpressionRewriter createRewrite(PlannerContext plannerContext, T private static Expression unwrapDateTrunc(Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, Expression expression) { @@ -127,13 +127,13 @@ private static class Visitor extends io.trino.sql.tree.ExpressionRewriter { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final Session session; private final TypeProvider types; private final InterpretedFunctionInvoker functionInvoker; private final LiteralEncoder literalEncoder; - public Visitor(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, Session session, TypeProvider types) + public Visitor(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, Session session, TypeProvider types) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapSingleColumnRowInApply.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapSingleColumnRowInApply.java index 8e6b2c3859af..9c8c9639e468 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapSingleColumnRowInApply.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapSingleColumnRowInApply.java @@ -17,8 +17,8 @@ import io.trino.matching.Pattern; import io.trino.spi.type.RowType; import io.trino.spi.type.Type; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.sql.planner.plan.ApplyNode; import io.trino.sql.planner.plan.Assignments; @@ -72,9 +72,9 @@ public class UnwrapSingleColumnRowInApply { private static final Pattern PATTERN = applyNode(); - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public UnwrapSingleColumnRowInApply(TypeAnalyzer typeAnalyzer) + public UnwrapSingleColumnRowInApply(IrTypeAnalyzer typeAnalyzer) { this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapYearInComparison.java b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapYearInComparison.java index afa07383e42d..87b48edb3728 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapYearInComparison.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/iterative/rule/UnwrapYearInComparison.java @@ -22,9 +22,9 @@ import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.BetweenPredicate; import io.trino.sql.tree.Cast; @@ -82,12 +82,12 @@ public class UnwrapYearInComparison extends ExpressionRewriteRuleSet { - public UnwrapYearInComparison(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public UnwrapYearInComparison(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { super(createRewrite(plannerContext, typeAnalyzer)); } - private static ExpressionRewriter createRewrite(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + private static ExpressionRewriter createRewrite(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { requireNonNull(plannerContext, "plannerContext is null"); requireNonNull(typeAnalyzer, "typeAnalyzer is null"); @@ -97,7 +97,7 @@ private static ExpressionRewriter createRewrite(PlannerContext plannerContext, T private static Expression unwrapYear(Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, Expression expression) { @@ -108,12 +108,12 @@ private static class Visitor extends io.trino.sql.tree.ExpressionRewriter { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final Session session; private final TypeProvider types; private final LiteralEncoder literalEncoder; - public Visitor(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, Session session, TypeProvider types) + public Visitor(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, Session session, TypeProvider types) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddExchanges.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddExchanges.java index 9d4c629fb432..1185504f168a 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddExchanges.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddExchanges.java @@ -34,6 +34,7 @@ import io.trino.spi.connector.WriterScalingOptions; import io.trino.sql.PlannerContext; import io.trino.sql.planner.DomainTranslator; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Partitioning; import io.trino.sql.planner.PartitioningHandle; import io.trino.sql.planner.PartitioningScheme; @@ -41,7 +42,6 @@ import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolAllocator; import io.trino.sql.planner.SystemPartitioningHandle; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.rule.PushPredicateIntoTableScan; import io.trino.sql.planner.plan.AggregationNode; @@ -141,11 +141,11 @@ public class AddExchanges implements PlanOptimizer { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final StatsCalculator statsCalculator; private final TaskCountEstimator taskCountEstimator; - public AddExchanges(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, StatsCalculator statsCalculator, TaskCountEstimator taskCountEstimator) + public AddExchanges(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, StatsCalculator statsCalculator, TaskCountEstimator taskCountEstimator) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddLocalExchanges.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddLocalExchanges.java index c9e9e6f0c855..8a109cc0dd5e 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddLocalExchanges.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/AddLocalExchanges.java @@ -22,6 +22,7 @@ import io.trino.spi.connector.LocalProperty; import io.trino.spi.connector.WriterScalingOptions; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Partitioning; import io.trino.sql.planner.PartitioningHandle; import io.trino.sql.planner.PartitioningScheme; @@ -29,7 +30,6 @@ import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolAllocator; import io.trino.sql.planner.SystemPartitioningHandle; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.optimizations.StreamPropertyDerivations.StreamProperties; import io.trino.sql.planner.plan.AggregationNode; @@ -115,9 +115,9 @@ public class AddLocalExchanges implements PlanOptimizer { private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public AddLocalExchanges(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + public AddLocalExchanges(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.typeAnalyzer = requireNonNull(typeAnalyzer, "typeAnalyzer is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/ExpressionEquivalence.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/ExpressionEquivalence.java index 5d6039405e47..ea6253680d89 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/ExpressionEquivalence.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/ExpressionEquivalence.java @@ -23,8 +23,8 @@ import io.trino.metadata.Metadata; import io.trino.spi.function.CatalogSchemaFunctionName; import io.trino.spi.type.Type; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.relational.CallExpression; import io.trino.sql.relational.ConstantExpression; @@ -61,10 +61,10 @@ public class ExpressionEquivalence private static final Ordering ROW_EXPRESSION_ORDERING = Ordering.from(new RowExpressionComparator()); private final Metadata metadata; private final FunctionManager functionManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final CanonicalizationVisitor canonicalizationVisitor; - public ExpressionEquivalence(Metadata metadata, FunctionManager functionManager, TypeAnalyzer typeAnalyzer) + public ExpressionEquivalence(Metadata metadata, FunctionManager functionManager, IrTypeAnalyzer typeAnalyzer) { this.metadata = requireNonNull(metadata, "metadata is null"); this.functionManager = requireNonNull(functionManager, "functionManager is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PredicatePushDown.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PredicatePushDown.java index 09ddc8edd378..00081b271c44 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PredicatePushDown.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PredicatePushDown.java @@ -27,13 +27,13 @@ import io.trino.sql.planner.EffectivePredicateExtractor; import io.trino.sql.planner.EqualityInference; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolAllocator; import io.trino.sql.planner.SymbolsExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.AssignUniqueId; @@ -125,13 +125,13 @@ public class PredicatePushDown LESS_THAN_OR_EQUAL); private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final boolean useTableProperties; private final boolean dynamicFiltering; public PredicatePushDown( PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, boolean useTableProperties, boolean dynamicFiltering) { @@ -159,7 +159,7 @@ private static class Rewriter private final PlanNodeIdAllocator idAllocator; private final PlannerContext plannerContext; private final Metadata metadata; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final Session session; private final TypeProvider types; private final ExpressionEquivalence expressionEquivalence; @@ -171,7 +171,7 @@ private Rewriter( SymbolAllocator symbolAllocator, PlanNodeIdAllocator idAllocator, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, Session session, TypeProvider types, boolean useTableProperties, diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PropertyDerivations.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PropertyDerivations.java index accf65e2c89e..48378bc62c1c 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PropertyDerivations.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/PropertyDerivations.java @@ -32,10 +32,10 @@ import io.trino.sql.PlannerContext; import io.trino.sql.planner.DomainTranslator; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.NoOpSymbolResolver; import io.trino.sql.planner.OrderingScheme; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.optimizations.ActualProperties.Global; import io.trino.sql.planner.plan.AggregationNode; @@ -126,7 +126,7 @@ public static ActualProperties derivePropertiesRecursively( PlannerContext plannerContext, Session session, TypeProvider types, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { List inputProperties = node.getSources().stream() .map(source -> derivePropertiesRecursively(source, plannerContext, session, types, typeAnalyzer)) @@ -140,7 +140,7 @@ public static ActualProperties deriveProperties( PlannerContext plannerContext, Session session, TypeProvider types, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { ActualProperties output = node.accept(new Visitor(plannerContext, session, types, typeAnalyzer), inputProperties); @@ -163,7 +163,7 @@ public static ActualProperties streamBackdoorDeriveProperties( PlannerContext plannerContext, Session session, TypeProvider types, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { return node.accept(new Visitor(plannerContext, session, types, typeAnalyzer), inputProperties); } @@ -174,9 +174,9 @@ private static class Visitor private final PlannerContext plannerContext; private final Session session; private final TypeProvider types; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; - public Visitor(PlannerContext plannerContext, Session session, TypeProvider types, TypeAnalyzer typeAnalyzer) + public Visitor(PlannerContext plannerContext, Session session, TypeProvider types, IrTypeAnalyzer typeAnalyzer) { this.plannerContext = plannerContext; this.session = session; diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/StreamPropertyDerivations.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/StreamPropertyDerivations.java index 84991b329ba6..19cb26cf1a20 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/StreamPropertyDerivations.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/StreamPropertyDerivations.java @@ -26,9 +26,9 @@ import io.trino.spi.connector.ColumnHandle; import io.trino.spi.connector.LocalProperty; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Partitioning.ArgumentBinding; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.ApplyNode; @@ -115,7 +115,7 @@ public static StreamProperties derivePropertiesRecursively( PlannerContext plannerContext, Session session, TypeProvider types, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { List inputProperties = node.getSources().stream() .map(source -> derivePropertiesRecursively(source, plannerContext, session, types, typeAnalyzer)) @@ -129,7 +129,7 @@ public static StreamProperties deriveProperties( PlannerContext plannerContext, Session session, TypeProvider types, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { return deriveProperties(node, ImmutableList.of(inputProperties), plannerContext, session, types, typeAnalyzer); } @@ -140,7 +140,7 @@ public static StreamProperties deriveProperties( PlannerContext plannerContext, Session session, TypeProvider types, - TypeAnalyzer typeAnalyzer) + IrTypeAnalyzer typeAnalyzer) { requireNonNull(node, "node is null"); requireNonNull(inputProperties, "inputProperties is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/joins/JoinGraph.java b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/joins/JoinGraph.java index 58a2a62cc1e5..fc05cffd1640 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/joins/JoinGraph.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/optimizations/joins/JoinGraph.java @@ -18,9 +18,9 @@ import com.google.common.collect.Multimap; import io.trino.Session; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.GroupReference; import io.trino.sql.planner.iterative.Lookup; @@ -67,7 +67,7 @@ public static JoinGraph buildFrom( Lookup lookup, PlanNodeIdAllocator planNodeIdAllocator, Session session, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types) { return plan.accept(new Builder(plannerContext, lookup, planNodeIdAllocator, session, typeAnalyzer, types), new Context()); @@ -206,10 +206,10 @@ private static class Builder private final Lookup lookup; private final PlanNodeIdAllocator planNodeIdAllocator; private final Session session; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final TypeProvider types; - private Builder(PlannerContext plannerContext, Lookup lookup, PlanNodeIdAllocator planNodeIdAllocator, Session session, TypeAnalyzer typeAnalyzer, TypeProvider types) + private Builder(PlannerContext plannerContext, Lookup lookup, PlanNodeIdAllocator planNodeIdAllocator, Session session, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); this.lookup = requireNonNull(lookup, "lookup cannot be null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/plan/Assignments.java b/core/trino-main/src/main/java/io/trino/sql/planner/plan/Assignments.java index e088a91b8fd7..f28eaae01cee 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/plan/Assignments.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/plan/Assignments.java @@ -20,9 +20,9 @@ import com.google.common.collect.Maps; import io.trino.Session; import io.trino.spi.type.Type; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolAllocator; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.tree.Expression; import io.trino.sql.tree.SymbolReference; @@ -80,7 +80,7 @@ public static Assignments of(Symbol symbol1, Expression expression1, Symbol symb return builder().put(symbol1, expression1).put(symbol2, expression2).build(); } - public static Assignments of(Collection expressions, Session session, SymbolAllocator symbolAllocator, TypeAnalyzer typeAnalyzer) + public static Assignments of(Collection expressions, Session session, SymbolAllocator symbolAllocator, IrTypeAnalyzer typeAnalyzer) { Assignments.Builder assignments = Assignments.builder(); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/AllFunctionsResolved.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/AllFunctionsResolved.java index b71328a03b1a..73d6f5baf8e7 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/AllFunctionsResolved.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/AllFunctionsResolved.java @@ -19,8 +19,8 @@ import io.trino.metadata.ResolvedFunction; import io.trino.sql.PlannerContext; import io.trino.sql.planner.ExpressionExtractor; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.tree.DefaultExpressionTraversalVisitor; @@ -39,7 +39,7 @@ public void validate( PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/DynamicFiltersChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/DynamicFiltersChecker.java index d47665dae44e..67640d76143f 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/DynamicFiltersChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/DynamicFiltersChecker.java @@ -20,8 +20,8 @@ import io.trino.operator.RetryPolicy; import io.trino.sql.DynamicFilters; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.SubExpressionExtractor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.DynamicFilterId; import io.trino.sql.planner.plan.DynamicFilterSourceNode; @@ -60,7 +60,7 @@ public void validate( PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoDuplicatePlanNodeIdsChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoDuplicatePlanNodeIdsChecker.java index a2cc5ba28a35..f7bc32cdbc94 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoDuplicatePlanNodeIdsChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoDuplicatePlanNodeIdsChecker.java @@ -16,7 +16,7 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.planner.plan.PlanNodeId; @@ -37,7 +37,7 @@ public void validate( PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoIdentifierLeftChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoIdentifierLeftChecker.java index e30270e2efcc..216b9eee007b 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoIdentifierLeftChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoIdentifierLeftChecker.java @@ -18,7 +18,7 @@ import io.trino.sql.PlannerContext; import io.trino.sql.analyzer.ExpressionTreeUtils; import io.trino.sql.planner.ExpressionExtractor; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.tree.Identifier; @@ -33,7 +33,7 @@ public void validate( PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoSubqueryExpressionLeftChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoSubqueryExpressionLeftChecker.java index 205deabade79..5acafc977e94 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoSubqueryExpressionLeftChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/NoSubqueryExpressionLeftChecker.java @@ -17,7 +17,7 @@ import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; import io.trino.sql.planner.ExpressionExtractor; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.tree.DefaultTraversalVisitor; @@ -34,7 +34,7 @@ public void validate( PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/PlanSanityChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/PlanSanityChecker.java index a531d873234b..9815a29c5b55 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/PlanSanityChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/PlanSanityChecker.java @@ -19,7 +19,7 @@ import io.trino.cost.StatsAndCosts; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; @@ -39,11 +39,11 @@ public PlanSanityChecker(boolean forceSingleNode) checkers = ImmutableListMultimap.builder() .putAll( Stage.INTERMEDIATE, + new NoSubqueryExpressionLeftChecker(), new ValidateDependenciesChecker(), new NoDuplicatePlanNodeIdsChecker(), new AllFunctionsResolved(), new TypeValidator(), - new NoSubqueryExpressionLeftChecker(), new NoIdentifierLeftChecker(), new VerifyOnlyOneOutputNode()) .putAll( @@ -71,7 +71,7 @@ public void validateFinalPlan( PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { @@ -103,7 +103,7 @@ public void validateIntermediatePlan( PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { @@ -137,7 +137,7 @@ void validate( PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector); } diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/SugarFreeChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/SugarFreeChecker.java index f39495c6b0d4..9f16749bf542 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/SugarFreeChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/SugarFreeChecker.java @@ -18,8 +18,8 @@ import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; import io.trino.sql.planner.ExpressionExtractor; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.tree.Array; @@ -50,7 +50,7 @@ public final class SugarFreeChecker public void validate(PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableExecuteStructureValidator.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableExecuteStructureValidator.java index 1ec837259b3b..0e78266e5501 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableExecuteStructureValidator.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableExecuteStructureValidator.java @@ -16,7 +16,7 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.ExchangeNode; import io.trino.sql.planner.plan.OutputNode; @@ -37,7 +37,7 @@ public class TableExecuteStructureValidator public void validate(PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableScanValidator.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableScanValidator.java index 8506b4bb3f26..54cec5212fdb 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableScanValidator.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TableScanValidator.java @@ -16,8 +16,8 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.SimplePlanVisitor; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.planner.plan.TableScanNode; @@ -29,7 +29,7 @@ public class TableScanValidator public void validate(PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TypeValidator.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TypeValidator.java index a9ade2a4ee2b..d75e4fd647c3 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TypeValidator.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/TypeValidator.java @@ -20,9 +20,9 @@ import io.trino.spi.type.Type; import io.trino.spi.type.TypeManager; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.SimplePlanVisitor; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.AggregationNode.Aggregation; @@ -52,7 +52,7 @@ public final class TypeValidator public void validate(PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { @@ -64,10 +64,10 @@ private static class Visitor { private final Session session; private final TypeCoercion typeCoercion; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final TypeProvider types; - public Visitor(Session session, TypeManager typeManager, TypeAnalyzer typeAnalyzer, TypeProvider types) + public Visitor(Session session, TypeManager typeManager, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { this.session = requireNonNull(session, "session is null"); this.typeCoercion = new TypeCoercion(typeManager::getType); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateAggregationsWithDefaultValues.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateAggregationsWithDefaultValues.java index 263b0e3a4934..30e89938cfb9 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateAggregationsWithDefaultValues.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateAggregationsWithDefaultValues.java @@ -16,7 +16,7 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.optimizations.ActualProperties; import io.trino.sql.planner.optimizations.PropertyDerivations; @@ -63,7 +63,7 @@ public ValidateAggregationsWithDefaultValues(boolean forceSingleNode) public void validate(PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { @@ -75,10 +75,10 @@ private class Visitor { final Session session; final PlannerContext plannerContext; - final TypeAnalyzer typeAnalyzer; + final IrTypeAnalyzer typeAnalyzer; final TypeProvider types; - Visitor(Session session, PlannerContext plannerContext, TypeAnalyzer typeAnalyzer, TypeProvider types) + Visitor(Session session, PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer, TypeProvider types) { this.session = requireNonNull(session, "session is null"); this.plannerContext = requireNonNull(plannerContext, "plannerContext is null"); diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateDependenciesChecker.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateDependenciesChecker.java index bdb5f3d2115d..ac5d5bd82dd4 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateDependenciesChecker.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateDependenciesChecker.java @@ -19,8 +19,8 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.AggregationNode.Aggregation; @@ -104,7 +104,7 @@ public final class ValidateDependenciesChecker public void validate(PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateScaledWritersUsage.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateScaledWritersUsage.java index 5bd5938b50b9..43328c3458e7 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateScaledWritersUsage.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateScaledWritersUsage.java @@ -18,8 +18,8 @@ import io.trino.execution.warnings.WarningCollector; import io.trino.spi.connector.WriterScalingOptions; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PartitioningHandle; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.ExchangeNode; import io.trino.sql.planner.plan.PlanNode; @@ -48,7 +48,7 @@ public void validate( PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateStreamingAggregations.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateStreamingAggregations.java index 555bd27278f8..d3ca6ab28040 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateStreamingAggregations.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/ValidateStreamingAggregations.java @@ -20,8 +20,8 @@ import io.trino.spi.connector.GroupingProperty; import io.trino.spi.connector.LocalProperty; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.optimizations.LocalProperties; import io.trino.sql.planner.optimizations.StreamPropertyDerivations.StreamProperties; @@ -47,7 +47,7 @@ public class ValidateStreamingAggregations public void validate(PlanNode planNode, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { @@ -59,12 +59,12 @@ private static final class Visitor { private final Session session; private final PlannerContext plannerContext; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final TypeProvider types; private Visitor(Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types) { this.session = session; diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyNoFilteredAggregations.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyNoFilteredAggregations.java index 80c26f18c0a1..2b5808418437 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyNoFilteredAggregations.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyNoFilteredAggregations.java @@ -16,7 +16,7 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.AggregationNode; import io.trino.sql.planner.plan.PlanNode; @@ -30,7 +30,7 @@ public final class VerifyNoFilteredAggregations public void validate(PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyOnlyOneOutputNode.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyOnlyOneOutputNode.java index cad94f097e49..49159c38516d 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyOnlyOneOutputNode.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyOnlyOneOutputNode.java @@ -16,7 +16,7 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.OutputNode; import io.trino.sql.planner.plan.PlanNode; @@ -31,7 +31,7 @@ public final class VerifyOnlyOneOutputNode public void validate(PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyUseConnectorNodePartitioningSet.java b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyUseConnectorNodePartitioningSet.java index 63d636dcbf3a..e92021c5bdf6 100644 --- a/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyUseConnectorNodePartitioningSet.java +++ b/core/trino-main/src/main/java/io/trino/sql/planner/sanity/VerifyUseConnectorNodePartitioningSet.java @@ -16,7 +16,7 @@ import io.trino.Session; import io.trino.execution.warnings.WarningCollector; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.planner.plan.TableScanNode; @@ -31,7 +31,7 @@ public final class VerifyUseConnectorNodePartitioningSet public void validate(PlanNode plan, Session session, PlannerContext plannerContext, - TypeAnalyzer typeAnalyzer, + IrTypeAnalyzer typeAnalyzer, TypeProvider types, WarningCollector warningCollector) { diff --git a/core/trino-main/src/main/java/io/trino/testing/PlanTester.java b/core/trino-main/src/main/java/io/trino/testing/PlanTester.java index 061b064cdfc1..5446bd972d03 100644 --- a/core/trino-main/src/main/java/io/trino/testing/PlanTester.java +++ b/core/trino-main/src/main/java/io/trino/testing/PlanTester.java @@ -154,6 +154,7 @@ import io.trino.sql.gen.PageFunctionCompiler; import io.trino.sql.parser.SqlParser; import io.trino.sql.planner.CompilerConfig; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LocalExecutionPlanner; import io.trino.sql.planner.LocalExecutionPlanner.LocalExecutionPlan; import io.trino.sql.planner.LogicalPlanner; @@ -165,7 +166,6 @@ import io.trino.sql.planner.PlanOptimizers; import io.trino.sql.planner.RuleStatsRecorder; import io.trino.sql.planner.SubPlan; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.optimizations.PlanOptimizer; import io.trino.sql.planner.plan.PlanNode; import io.trino.sql.planner.plan.PlanNodeId; @@ -405,7 +405,7 @@ private PlanTester(Session defaultSession, int nodeCountForStats) tablePropertyManager, analyzePropertyManager, tableProceduresPropertyManager); - TypeAnalyzer typeAnalyzer = new TypeAnalyzer(plannerContext, statementAnalyzerFactory); + IrTypeAnalyzer typeAnalyzer = new IrTypeAnalyzer(plannerContext); this.statsCalculator = createNewStatsCalculator(plannerContext, typeAnalyzer); this.scalarStatsCalculator = new ScalarStatsCalculator(plannerContext, typeAnalyzer); this.taskCountEstimator = new TaskCountEstimator(() -> nodeCountForStats); @@ -496,7 +496,7 @@ private static SessionPropertyManager createSessionPropertyManager( return CatalogServiceProviderModule.createSessionPropertyManager(ImmutableSet.of(sessionProperties), connectorServicesProvider); } - private static StatsCalculator createNewStatsCalculator(PlannerContext plannerContext, TypeAnalyzer typeAnalyzer) + private static StatsCalculator createNewStatsCalculator(PlannerContext plannerContext, IrTypeAnalyzer typeAnalyzer) { StatsNormalizer normalizer = new StatsNormalizer(); ScalarStatsCalculator scalarStatsCalculator = new ScalarStatsCalculator(plannerContext, typeAnalyzer); @@ -702,7 +702,7 @@ private List createDrivers(Session session, @Language("SQL") String sql) tableExecuteContextManager.registerTableExecuteContextForQuery(taskContext.getQueryContext().getQueryId()); LocalExecutionPlanner executionPlanner = new LocalExecutionPlanner( plannerContext, - new TypeAnalyzer(plannerContext, statementAnalyzerFactory), + new IrTypeAnalyzer(plannerContext), Optional.empty(), pageSourceManager, indexManager, @@ -806,7 +806,7 @@ public List getPlanOptimizers(boolean forceSingleNode) { return new PlanOptimizers( plannerContext, - new TypeAnalyzer(plannerContext, statementAnalyzerFactory), + new IrTypeAnalyzer(plannerContext), taskManagerConfig, forceSingleNode, splitManager, @@ -846,7 +846,7 @@ public Plan createPlan(Session session, @Language("SQL") String sql, List op () -> optimizers, planFragmenter, plannerContext, - statementAnalyzerFactory, statsCalculator, costCalculator, new NodeVersion("test")); diff --git a/core/trino-main/src/test/java/io/trino/cost/TestComparisonStatsCalculator.java b/core/trino-main/src/test/java/io/trino/cost/TestComparisonStatsCalculator.java index 926b8892306a..592c52f6f233 100644 --- a/core/trino-main/src/test/java/io/trino/cost/TestComparisonStatsCalculator.java +++ b/core/trino-main/src/test/java/io/trino/cost/TestComparisonStatsCalculator.java @@ -18,6 +18,7 @@ import io.trino.spi.type.DoubleType; import io.trino.spi.type.Type; import io.trino.spi.type.VarcharType; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Cast; @@ -40,7 +41,6 @@ import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.tree.ComparisonExpression.Operator.EQUAL; import static io.trino.sql.tree.ComparisonExpression.Operator.GREATER_THAN; import static io.trino.sql.tree.ComparisonExpression.Operator.GREATER_THAN_OR_EQUAL; @@ -58,7 +58,7 @@ public class TestComparisonStatsCalculator { - private final FilterStatsCalculator filterStatsCalculator = new FilterStatsCalculator(PLANNER_CONTEXT, new ScalarStatsCalculator(PLANNER_CONTEXT, createTestingTypeAnalyzer(PLANNER_CONTEXT)), new StatsNormalizer(), createTestingTypeAnalyzer(PLANNER_CONTEXT)); + private final FilterStatsCalculator filterStatsCalculator = new FilterStatsCalculator(PLANNER_CONTEXT, new ScalarStatsCalculator(PLANNER_CONTEXT, new IrTypeAnalyzer(PLANNER_CONTEXT)), new StatsNormalizer(), new IrTypeAnalyzer(PLANNER_CONTEXT)); private final Session session = testSessionBuilder().build(); private final TypeProvider types = TypeProvider.copyOf(ImmutableMap.builder() .put(new Symbol("u"), DoubleType.DOUBLE) diff --git a/core/trino-main/src/test/java/io/trino/cost/TestFilterStatsCalculator.java b/core/trino-main/src/test/java/io/trino/cost/TestFilterStatsCalculator.java index 78784e688199..adca6b3414f8 100644 --- a/core/trino-main/src/test/java/io/trino/cost/TestFilterStatsCalculator.java +++ b/core/trino-main/src/test/java/io/trino/cost/TestFilterStatsCalculator.java @@ -23,6 +23,7 @@ import io.trino.spi.type.Type; import io.trino.spi.type.VarcharType; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Expression; @@ -35,7 +36,6 @@ import static io.trino.SystemSessionProperties.FILTER_CONJUNCTION_INDEPENDENCE_FACTOR; import static io.trino.sql.ExpressionTestUtils.planExpression; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.iterative.rule.test.PlanBuilder.expression; import static io.trino.testing.TestingSession.testSessionBuilder; import static io.trino.testing.TransactionBuilder.transaction; @@ -108,7 +108,7 @@ public class TestFilterStatsCalculator .setHighValue(POSITIVE_INFINITY) .setNullsFraction(0.34) .build(); - private final FilterStatsCalculator statsCalculator = new FilterStatsCalculator(PLANNER_CONTEXT, new ScalarStatsCalculator(PLANNER_CONTEXT, createTestingTypeAnalyzer(PLANNER_CONTEXT)), new StatsNormalizer(), createTestingTypeAnalyzer(PLANNER_CONTEXT)); + private final FilterStatsCalculator statsCalculator = new FilterStatsCalculator(PLANNER_CONTEXT, new ScalarStatsCalculator(PLANNER_CONTEXT, new IrTypeAnalyzer(PLANNER_CONTEXT)), new StatsNormalizer(), new IrTypeAnalyzer(PLANNER_CONTEXT)); private final PlanNodeStatsEstimate standardInputStatistics = PlanNodeStatsEstimate.builder() .addSymbolStatistics(new Symbol("x"), xStats) .addSymbolStatistics(new Symbol("y"), yStats) diff --git a/core/trino-main/src/test/java/io/trino/cost/TestJoinStatsRule.java b/core/trino-main/src/test/java/io/trino/cost/TestJoinStatsRule.java index 264a58054293..ac1f1809e4ff 100644 --- a/core/trino-main/src/test/java/io/trino/cost/TestJoinStatsRule.java +++ b/core/trino-main/src/test/java/io/trino/cost/TestJoinStatsRule.java @@ -16,6 +16,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import io.trino.spi.type.Type; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.iterative.rule.test.PlanBuilder; @@ -36,7 +37,6 @@ import static io.trino.spi.type.BigintType.BIGINT; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.plan.JoinType.FULL; import static io.trino.sql.planner.plan.JoinType.INNER; import static io.trino.sql.planner.plan.JoinType.LEFT; @@ -91,7 +91,7 @@ public class TestJoinStatsRule private static final StatsNormalizer NORMALIZER = new StatsNormalizer(); private static final JoinStatsRule JOIN_STATS_RULE = new JoinStatsRule( - new FilterStatsCalculator(PLANNER_CONTEXT, new ScalarStatsCalculator(PLANNER_CONTEXT, createTestingTypeAnalyzer(PLANNER_CONTEXT)), NORMALIZER, createTestingTypeAnalyzer(PLANNER_CONTEXT)), + new FilterStatsCalculator(PLANNER_CONTEXT, new ScalarStatsCalculator(PLANNER_CONTEXT, new IrTypeAnalyzer(PLANNER_CONTEXT)), NORMALIZER, new IrTypeAnalyzer(PLANNER_CONTEXT)), NORMALIZER, 1.0); private static final TypeProvider TYPES = TypeProvider.copyOf(ImmutableMap.builder() diff --git a/core/trino-main/src/test/java/io/trino/cost/TestScalarStatsCalculator.java b/core/trino-main/src/test/java/io/trino/cost/TestScalarStatsCalculator.java index 4a12f759ac59..1a2cea2cf587 100644 --- a/core/trino-main/src/test/java/io/trino/cost/TestScalarStatsCalculator.java +++ b/core/trino-main/src/test/java/io/trino/cost/TestScalarStatsCalculator.java @@ -21,6 +21,7 @@ import io.trino.metadata.TestingFunctionResolution; import io.trino.security.AllowAllAccessControl; import io.trino.sql.parser.SqlParser; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; @@ -42,7 +43,6 @@ import static io.trino.spi.type.VarcharType.createVarcharType; import static io.trino.sql.ExpressionUtils.rewriteIdentifiersToSymbolReferences; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TestingSession.testSessionBuilder; import static io.trino.testing.TransactionBuilder.transaction; import static java.lang.Double.NEGATIVE_INFINITY; @@ -51,7 +51,7 @@ public class TestScalarStatsCalculator { private final TestingFunctionResolution functionResolution = new TestingFunctionResolution(); - private final ScalarStatsCalculator calculator = new ScalarStatsCalculator(functionResolution.getPlannerContext(), createTestingTypeAnalyzer(functionResolution.getPlannerContext())); + private final ScalarStatsCalculator calculator = new ScalarStatsCalculator(functionResolution.getPlannerContext(), new IrTypeAnalyzer(functionResolution.getPlannerContext())); private final Session session = testSessionBuilder().build(); private final SqlParser sqlParser = new SqlParser(); diff --git a/core/trino-main/src/test/java/io/trino/execution/TaskTestUtils.java b/core/trino-main/src/test/java/io/trino/execution/TaskTestUtils.java index 6126813c9809..6bbf58dfabc1 100644 --- a/core/trino-main/src/test/java/io/trino/execution/TaskTestUtils.java +++ b/core/trino-main/src/test/java/io/trino/execution/TaskTestUtils.java @@ -46,6 +46,7 @@ import io.trino.sql.gen.OrderingCompiler; import io.trino.sql.gen.PageFunctionCompiler; import io.trino.sql.planner.CompilerConfig; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LocalExecutionPlanner; import io.trino.sql.planner.NodePartitioningManager; import io.trino.sql.planner.Partitioning; @@ -71,7 +72,6 @@ import static io.trino.sql.planner.SystemPartitioningHandle.SINGLE_DISTRIBUTION; import static io.trino.sql.planner.SystemPartitioningHandle.SOURCE_DISTRIBUTION; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TestingHandles.TEST_TABLE_HANDLE; public final class TaskTestUtils @@ -153,7 +153,7 @@ public static LocalExecutionPlanner createTestingPlanner() PageFunctionCompiler pageFunctionCompiler = new PageFunctionCompiler(PLANNER_CONTEXT.getFunctionManager(), 0); return new LocalExecutionPlanner( PLANNER_CONTEXT, - createTestingTypeAnalyzer(PLANNER_CONTEXT), + new IrTypeAnalyzer(PLANNER_CONTEXT), Optional.empty(), pageSourceManager, new IndexManager(CatalogServiceProvider.fail()), diff --git a/core/trino-main/src/test/java/io/trino/operator/project/TestPageFieldsToInputParametersRewriter.java b/core/trino-main/src/test/java/io/trino/operator/project/TestPageFieldsToInputParametersRewriter.java index 553f30dcf9c0..3e28a8480f57 100644 --- a/core/trino-main/src/test/java/io/trino/operator/project/TestPageFieldsToInputParametersRewriter.java +++ b/core/trino-main/src/test/java/io/trino/operator/project/TestPageFieldsToInputParametersRewriter.java @@ -20,8 +20,8 @@ import io.trino.spi.type.ArrayType; import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.relational.RowExpression; import io.trino.sql.relational.SqlToRowExpressionTranslator; @@ -44,7 +44,6 @@ import static io.trino.spi.type.BigintType.BIGINT; import static io.trino.sql.ExpressionTestUtils.createExpression; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static org.assertj.core.api.Assertions.assertThat; public class TestPageFieldsToInputParametersRewriter @@ -53,7 +52,7 @@ public class TestPageFieldsToInputParametersRewriter private static final PlannerContext PLANNER_CONTEXT = plannerContextBuilder() .withTransactionManager(TRANSACTION_MANAGER) .build(); - private static final TypeAnalyzer TYPE_ANALYZER = createTestingTypeAnalyzer(PLANNER_CONTEXT); + private static final IrTypeAnalyzer TYPE_ANALYZER = new IrTypeAnalyzer(PLANNER_CONTEXT); @Test public void testEagerLoading() diff --git a/core/trino-main/src/test/java/io/trino/sql/ExpressionTestUtils.java b/core/trino-main/src/test/java/io/trino/sql/ExpressionTestUtils.java index 5be0d4ab4667..86d9fa9586bf 100644 --- a/core/trino-main/src/test/java/io/trino/sql/ExpressionTestUtils.java +++ b/core/trino-main/src/test/java/io/trino/sql/ExpressionTestUtils.java @@ -22,6 +22,7 @@ import io.trino.sql.analyzer.ExpressionAnalyzer; import io.trino.sql.analyzer.Scope; import io.trino.sql.parser.SqlParser; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.assertions.ExpressionVerifier; import io.trino.sql.planner.assertions.SymbolAliases; @@ -42,7 +43,6 @@ import static io.trino.sql.ExpressionUtils.rewriteIdentifiersToSymbolReferences; import static io.trino.sql.analyzer.SemanticExceptions.semanticException; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TransactionBuilder.transaction; public final class ExpressionTestUtils @@ -169,12 +169,12 @@ private Expression coerceIfNecessary(Expression originalExpression, Expression r public static Map, Type> getTypes(Session session, PlannerContext plannerContext, TypeProvider typeProvider, Expression expression) { if (session.getTransactionId().isPresent()) { - return createTestingTypeAnalyzer(plannerContext).getTypes(session, typeProvider, expression); + return new IrTypeAnalyzer(plannerContext).getTypes(session, typeProvider, expression); } return transaction(new TestingTransactionManager(), plannerContext.getMetadata(), new AllowAllAccessControl()) .singleStatement() .execute(session, transactionSession -> { - return createTestingTypeAnalyzer(plannerContext).getTypes(transactionSession, typeProvider, expression); + return new IrTypeAnalyzer(plannerContext).getTypes(transactionSession, typeProvider, expression); }); } } diff --git a/core/trino-main/src/test/java/io/trino/sql/TestExpressionInterpreter.java b/core/trino-main/src/test/java/io/trino/sql/TestExpressionInterpreter.java index 8772d66be346..78b11160c088 100644 --- a/core/trino-main/src/test/java/io/trino/sql/TestExpressionInterpreter.java +++ b/core/trino-main/src/test/java/io/trino/sql/TestExpressionInterpreter.java @@ -24,6 +24,7 @@ import io.trino.spi.type.VarbinaryType; import io.trino.sql.parser.SqlParser; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolResolver; import io.trino.sql.planner.TypeProvider; @@ -69,7 +70,6 @@ import static io.trino.sql.ExpressionTestUtils.resolveFunctionCalls; import static io.trino.sql.ExpressionUtils.rewriteIdentifiersToSymbolReferences; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TransactionBuilder.transaction; import static io.trino.testing.assertions.TrinoExceptionAssert.assertTrinoExceptionThrownBy; import static io.trino.type.DateTimes.scaleEpochMillisToMicros; @@ -1700,7 +1700,7 @@ static Expression planExpression(@Language("SQL") String expression) parsedExpression, transactionSession, PLANNER_CONTEXT, - createTestingTypeAnalyzer(PLANNER_CONTEXT), + new IrTypeAnalyzer(PLANNER_CONTEXT), SYMBOL_TYPES); return parsedExpression; }); diff --git a/core/trino-main/src/test/java/io/trino/sql/TestSqlToRowExpressionTranslator.java b/core/trino-main/src/test/java/io/trino/sql/TestSqlToRowExpressionTranslator.java index 18e6092f4fe7..cf503f15a039 100644 --- a/core/trino-main/src/test/java/io/trino/sql/TestSqlToRowExpressionTranslator.java +++ b/core/trino-main/src/test/java/io/trino/sql/TestSqlToRowExpressionTranslator.java @@ -17,9 +17,9 @@ import io.trino.spi.type.Decimals; import io.trino.spi.type.Type; import io.trino.sql.planner.IrExpressionInterpreter; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.NoOpSymbolResolver; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.relational.RowExpression; import io.trino.sql.relational.SqlToRowExpressionTranslator; @@ -104,6 +104,6 @@ private Expression simplifyExpression(Expression expression) private Map, Type> getExpressionTypes(Expression expression) { - return TypeAnalyzer.createTestingTypeAnalyzer(PLANNER_CONTEXT).getTypes(TEST_SESSION, TypeProvider.empty(), expression); + return new IrTypeAnalyzer(PLANNER_CONTEXT).getTypes(TEST_SESSION, TypeProvider.empty(), expression); } } diff --git a/core/trino-main/src/test/java/io/trino/sql/gen/BenchmarkPageProcessor2.java b/core/trino-main/src/test/java/io/trino/sql/gen/BenchmarkPageProcessor2.java index 1cd8a58b420a..dbea4c09eb02 100644 --- a/core/trino-main/src/test/java/io/trino/sql/gen/BenchmarkPageProcessor2.java +++ b/core/trino-main/src/test/java/io/trino/sql/gen/BenchmarkPageProcessor2.java @@ -27,8 +27,8 @@ import io.trino.spi.connector.RecordSet; import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.relational.RowExpression; import io.trino.sql.relational.SqlToRowExpressionTranslator; @@ -62,7 +62,6 @@ import static io.trino.spi.type.VarcharType.VARCHAR; import static io.trino.sql.ExpressionTestUtils.createExpression; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static java.util.Locale.ENGLISH; import static java.util.stream.Collectors.toList; @@ -81,7 +80,7 @@ public class BenchmarkPageProcessor2 .build(); private static final Map TYPE_MAP = ImmutableMap.of("bigint", BIGINT, "varchar", VARCHAR); - private static final TypeAnalyzer TYPE_ANALYZER = createTestingTypeAnalyzer(PLANNER_CONTEXT); + private static final IrTypeAnalyzer TYPE_ANALYZER = new IrTypeAnalyzer(PLANNER_CONTEXT); private static final Session TEST_SESSION = TestingSession.testSessionBuilder().build(); private static final int POSITIONS = 1024; diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/TestConnectorExpressionTranslator.java b/core/trino-main/src/test/java/io/trino/sql/planner/TestConnectorExpressionTranslator.java index 4124ef909910..2fde7c22119f 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/TestConnectorExpressionTranslator.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/TestConnectorExpressionTranslator.java @@ -86,7 +86,6 @@ import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; import static io.trino.sql.planner.ConnectorExpressionTranslator.translate; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TransactionBuilder.transaction; import static io.trino.type.JoniRegexpType.JONI_REGEXP; import static io.trino.type.JsonPathType.JSON_PATH; @@ -98,7 +97,7 @@ public class TestConnectorExpressionTranslator { private static final Session TEST_SESSION = TestingSession.testSessionBuilder().build(); - private static final TypeAnalyzer TYPE_ANALYZER = createTestingTypeAnalyzer(PLANNER_CONTEXT); + private static final IrTypeAnalyzer TYPE_ANALYZER = new IrTypeAnalyzer(PLANNER_CONTEXT); private static final Type ROW_TYPE = rowType(field("int_symbol_1", INTEGER), field("varchar_symbol_1", createVarcharType(5))); private static final VarcharType VARCHAR_TYPE = createUnboundedVarcharType(); private static final ArrayType VARCHAR_ARRAY_TYPE = new ArrayType(VARCHAR_TYPE); diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/TestEffectivePredicateExtractor.java b/core/trino-main/src/test/java/io/trino/sql/planner/TestEffectivePredicateExtractor.java index d5d8e60d4816..fb9f74bfe2d7 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/TestEffectivePredicateExtractor.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/TestEffectivePredicateExtractor.java @@ -106,7 +106,6 @@ import static io.trino.sql.ExpressionUtils.or; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.plan.AggregationNode.globalAggregation; import static io.trino.sql.planner.plan.AggregationNode.singleAggregation; import static io.trino.sql.planner.plan.AggregationNode.singleGroupingSet; @@ -174,7 +173,7 @@ public TableProperties getTableProperties(Session session, TableHandle handle) }; private final PlannerContext plannerContext = plannerContextBuilder().withMetadata(metadata).build(); - private final TypeAnalyzer typeAnalyzer = createTestingTypeAnalyzer(plannerContext); + private final IrTypeAnalyzer typeAnalyzer = new IrTypeAnalyzer(plannerContext); private final EffectivePredicateExtractor effectivePredicateExtractor = new EffectivePredicateExtractor(new DomainTranslator(plannerContext), plannerContext, true); private final EffectivePredicateExtractor effectivePredicateExtractorWithoutTableProperties = new EffectivePredicateExtractor(new DomainTranslator(plannerContext), plannerContext, false); diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/TestLiteralEncoder.java b/core/trino-main/src/test/java/io/trino/sql/planner/TestLiteralEncoder.java index a8f886f87494..ed0b8e0ea175 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/TestLiteralEncoder.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/TestLiteralEncoder.java @@ -334,7 +334,7 @@ private Map, Type> getExpressionTypes(Expression expression) return transaction(transactionManager, metadata, new AllowAllAccessControl()) .singleStatement() .execute(TEST_SESSION, transactionSession -> { - return TypeAnalyzer.createTestingTypeAnalyzer(PLANNER_CONTEXT).getTypes(transactionSession, TypeProvider.empty(), expression); + return new IrTypeAnalyzer(PLANNER_CONTEXT).getTypes(transactionSession, TypeProvider.empty(), expression); }); } diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/TestPartialTranslator.java b/core/trino-main/src/test/java/io/trino/sql/planner/TestPartialTranslator.java index 8572080c25f1..73692114253d 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/TestPartialTranslator.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/TestPartialTranslator.java @@ -46,7 +46,6 @@ import static io.trino.sql.planner.ConnectorExpressionTranslator.translate; import static io.trino.sql.planner.PartialTranslator.extractPartialTranslations; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.tree.ArithmeticBinaryExpression.Operator.ADD; import static io.trino.testing.TestingSession.testSessionBuilder; import static org.assertj.core.api.Assertions.assertThat; @@ -56,7 +55,7 @@ public class TestPartialTranslator private static final Session TEST_SESSION = testSessionBuilder() .setTransactionId(TransactionId.create()) .build(); - private static final TypeAnalyzer TYPE_ANALYZER = createTestingTypeAnalyzer(PLANNER_CONTEXT); + private static final IrTypeAnalyzer TYPE_ANALYZER = new IrTypeAnalyzer(PLANNER_CONTEXT); private static final TypeProvider TYPE_PROVIDER = TypeProvider.copyOf(ImmutableMap.builder() .put(new Symbol("double_symbol_1"), DOUBLE) .put(new Symbol("double_symbol_2"), DOUBLE) diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/TestTypeValidator.java b/core/trino-main/src/test/java/io/trino/sql/planner/TestTypeValidator.java index 0f5d15626570..e87e0171f852 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/TestTypeValidator.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/TestTypeValidator.java @@ -52,7 +52,6 @@ import static io.trino.sql.analyzer.TypeSignatureProvider.fromTypes; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.plan.AggregationNode.singleAggregation; import static io.trino.sql.planner.plan.AggregationNode.singleGroupingSet; import static io.trino.sql.planner.plan.FrameBoundType.UNBOUNDED_FOLLOWING; @@ -352,7 +351,7 @@ public void testInvalidUnion() private void assertTypesValid(PlanNode node) { - TYPE_VALIDATOR.validate(node, TEST_SESSION, PLANNER_CONTEXT, createTestingTypeAnalyzer(PLANNER_CONTEXT), symbolAllocator.getTypes(), WarningCollector.NOOP); + TYPE_VALIDATOR.validate(node, TEST_SESSION, PLANNER_CONTEXT, new IrTypeAnalyzer(PLANNER_CONTEXT), symbolAllocator.getTypes(), WarningCollector.NOOP); } private static PlanNodeId newId() diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestCanonicalizeExpressionRewriter.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestCanonicalizeExpressionRewriter.java index 9680dec3d94a..6ed6f498f9be 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestCanonicalizeExpressionRewriter.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestCanonicalizeExpressionRewriter.java @@ -18,8 +18,8 @@ import io.trino.security.AllowAllAccessControl; import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.assertions.SymbolAliases; import io.trino.sql.planner.iterative.rule.test.PlanBuilder; @@ -37,7 +37,6 @@ import static io.trino.sql.ExpressionTestUtils.assertExpressionEquals; import static io.trino.sql.analyzer.TypeSignatureProvider.fromTypes; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.iterative.rule.CanonicalizeExpressionRewriter.rewrite; import static io.trino.testing.TransactionBuilder.transaction; import static io.trino.transaction.InMemoryTransactionManager.createTestTransactionManager; @@ -48,7 +47,7 @@ public class TestCanonicalizeExpressionRewriter private static final PlannerContext PLANNER_CONTEXT = plannerContextBuilder() .withTransactionManager(TRANSACTION_MANAGER) .build(); - private static final TypeAnalyzer TYPE_ANALYZER = createTestingTypeAnalyzer(PLANNER_CONTEXT); + private static final IrTypeAnalyzer TYPE_ANALYZER = new IrTypeAnalyzer(PLANNER_CONTEXT); private static final AllowAllAccessControl ACCESS_CONTROL = new AllowAllAccessControl(); @Test diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestEliminateCrossJoins.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestEliminateCrossJoins.java index c244b57de589..64e1c5e5b065 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestEliminateCrossJoins.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestEliminateCrossJoins.java @@ -16,6 +16,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import io.trino.Session; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; @@ -44,7 +45,6 @@ import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.collect.ImmutableList.toImmutableList; import static io.trino.SystemSessionProperties.JOIN_REORDERING_STRATEGY; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.any; import static io.trino.sql.planner.assertions.PlanMatchPattern.expression; import static io.trino.sql.planner.assertions.PlanMatchPattern.join; @@ -125,7 +125,7 @@ public void testJoinOrder() "a", "c", "b", "c"); - JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, createTestingTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); + JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, new IrTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); assertThat(getJoinOrder(joinGraph)).isEqualTo(ImmutableList.of(0, 2, 1)); } @@ -155,7 +155,7 @@ public void testJoinOrderWithRealCrossJoin() PlanNode plan = joinNode(leftPlan, rightPlan); - JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, createTestingTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); + JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, new IrTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); assertThat(getJoinOrder(joinGraph)).isEqualTo(ImmutableList.of(0, 2, 1, 3, 5, 4)); } @@ -175,7 +175,7 @@ public void testJoinOrderWithMultipleEdgesBetweenNodes() "b1", "c1", "b2", "c2"); - JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, createTestingTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); + JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, new IrTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); assertThat(getJoinOrder(joinGraph)).isEqualTo(ImmutableList.of(0, 2, 1)); } @@ -194,7 +194,7 @@ public void testDoesNotChangeOrderWithoutCrossJoin() values("c"), "b", "c"); - JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, createTestingTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); + JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, new IrTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); assertThat(getJoinOrder(joinGraph)).isEqualTo(ImmutableList.of(0, 1, 2)); } @@ -212,7 +212,7 @@ public void testDoNotReorderCrossJoins() values("c"), "b", "c"); - JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, createTestingTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); + JoinGraph joinGraph = JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, new IrTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()); assertThat(getJoinOrder(joinGraph)).isEqualTo(ImmutableList.of(0, 1, 2)); } @@ -299,7 +299,7 @@ public void testGiveUpOnComplexProjections() "a2", "c", "b", "c"); - assertThat(JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, createTestingTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()).size()).isEqualTo(2); + assertThat(JoinGraph.buildFrom(tester().getPlannerContext(), plan, noLookup(), new PlanNodeIdAllocator(), session, new IrTypeAnalyzer(tester().getPlannerContext()), TypeProvider.empty()).size()).isEqualTo(2); } private Function crossJoinAndJoin(JoinType secondJoinType) diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestJoinNodeFlattener.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestJoinNodeFlattener.java index 4a50aa4b415d..41c8bab2b1af 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestJoinNodeFlattener.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestJoinNodeFlattener.java @@ -15,6 +15,7 @@ package io.trino.sql.planner.iterative.rule; import com.google.common.collect.ImmutableList; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Plan; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; @@ -51,7 +52,6 @@ import static io.trino.cost.StatsAndCosts.empty; import static io.trino.metadata.AbstractMockMetadata.dummyMetadata; import static io.trino.sql.ExpressionUtils.and; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.node; import static io.trino.sql.planner.assertions.PlanMatchPattern.values; import static io.trino.sql.planner.iterative.Lookup.noLookup; @@ -108,7 +108,7 @@ public void testDoesNotAllowOuterJoin() ImmutableList.of(a1), ImmutableList.of(b1), Optional.empty()); - assertThatThrownBy(() -> toMultiJoinNode(queryRunner.getPlannerContext(), outerJoin, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())) + assertThatThrownBy(() -> toMultiJoinNode(queryRunner.getPlannerContext(), outerJoin, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())) .isInstanceOf(IllegalStateException.class) .hasMessageMatching("join type must be.*"); } @@ -143,7 +143,7 @@ public void testDoesNotConvertNestedOuterJoins() .setSources(leftJoin, valuesC).setFilter(createEqualsExpression(a1, c1)) .setOutputSymbols(a1, b1, c1) .build(); - assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); + assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); } @Test @@ -169,7 +169,7 @@ public void testPushesProjectionsThroughJoin() equiJoinClause(a, b))), valuesC, equiJoinClause(d, c)); - MultiJoinNode actual = toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, true, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes()); + MultiJoinNode actual = toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, true, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes()); assertThat(actual.getOutputSymbols()).isEqualTo(ImmutableList.of(d, c)); assertThat(actual.getFilter()).isEqualTo(and(createEqualsExpression(a, b), createEqualsExpression(d, c))); assertThat(actual.isPushedProjectionThroughJoin()).isTrue(); @@ -215,7 +215,7 @@ public void testDoesNotPushStraddlingProjection() equiJoinClause(a, b))), valuesC, equiJoinClause(d, c)); - MultiJoinNode actual = toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, true, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes()); + MultiJoinNode actual = toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, true, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes()); assertThat(actual.getOutputSymbols()).isEqualTo(ImmutableList.of(d, c)); assertThat(actual.getFilter()).isEqualTo(createEqualsExpression(d, c)); assertThat(actual.isPushedProjectionThroughJoin()).isFalse(); @@ -266,7 +266,7 @@ public void testRetainsOutputSymbols() .setFilter(and(createEqualsExpression(b1, c1), createEqualsExpression(a1, b1))) .setOutputSymbols(a1, b1) .build(); - assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); + assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); } @Test @@ -310,7 +310,7 @@ public void testCombinesCriteriaAndFilters() and(new ComparisonExpression(EQUAL, b1.toSymbolReference(), c1.toSymbolReference()), new ComparisonExpression(EQUAL, a1.toSymbolReference(), b1.toSymbolReference()), bcFilter, abcFilter), ImmutableList.of(a1, b1, b2, c1, c2), false); - assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); + assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, DEFAULT_JOIN_LIMIT, false, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); } @Test @@ -366,7 +366,7 @@ public void testConvertsBushyTrees() .setFilter(and(createEqualsExpression(a1, b1), createEqualsExpression(a1, c1), createEqualsExpression(d1, e1), createEqualsExpression(d2, e2), createEqualsExpression(b1, e1))) .setOutputSymbols(a1, b1, c1, d1, d2, e1, e2) .build(); - assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, 5, false, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); + assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, 5, false, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); } @Test @@ -424,7 +424,7 @@ public void testMoreThanJoinLimit() .setFilter(and(createEqualsExpression(a1, c1), createEqualsExpression(b1, e1))) .setOutputSymbols(a1, b1, c1, d1, d2, e1, e2) .build(); - assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, 2, false, testSessionBuilder().build(), createTestingTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); + assertThat(toMultiJoinNode(queryRunner.getPlannerContext(), joinNode, noLookup(), planNodeIdAllocator, 2, false, testSessionBuilder().build(), new IrTypeAnalyzer(queryRunner.getPlannerContext()), p.getTypes())).isEqualTo(expected); } private ComparisonExpression createEqualsExpression(Symbol left, Symbol right) diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushMergeWriterUpdateIntoConnector.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushMergeWriterUpdateIntoConnector.java index df5c42e99000..9cd57a5bdff7 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushMergeWriterUpdateIntoConnector.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushMergeWriterUpdateIntoConnector.java @@ -24,8 +24,8 @@ import io.trino.spi.connector.TestingColumnHandle; import io.trino.spi.expression.Constant; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.rule.test.RuleTester; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.planner.plan.TableUpdateNode; @@ -175,7 +175,7 @@ public void testPushUpdateIntoConnectorUpdateAll() private static PushMergeWriterUpdateIntoConnector createRule(RuleTester tester) { PlannerContext plannerContext = tester.getPlannerContext(); - TypeAnalyzer typeAnalyzer = tester.getTypeAnalyzer(); + IrTypeAnalyzer typeAnalyzer = tester.getTypeAnalyzer(); return new PushMergeWriterUpdateIntoConnector( plannerContext, typeAnalyzer, diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushPredicateIntoTableScan.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushPredicateIntoTableScan.java index 9faa43fd163f..c32f6a73f466 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushPredicateIntoTableScan.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushPredicateIntoTableScan.java @@ -37,6 +37,7 @@ import io.trino.spi.predicate.NullableValue; import io.trino.spi.predicate.TupleDomain; import io.trino.spi.type.Type; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.rule.test.BaseRuleTest; import io.trino.sql.tree.ArithmeticBinaryExpression; import io.trino.sql.tree.Cast; @@ -62,7 +63,6 @@ import static io.trino.spi.type.VarcharType.VARCHAR; import static io.trino.spi.type.VarcharType.createVarcharType; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.anyTree; import static io.trino.sql.planner.assertions.PlanMatchPattern.constrainedTableScanWithTableLayout; import static io.trino.sql.planner.assertions.PlanMatchPattern.filter; @@ -96,7 +96,7 @@ public class TestPushPredicateIntoTableScan @BeforeAll public void setUpBeforeClass() { - pushPredicateIntoTableScan = new PushPredicateIntoTableScan(tester().getPlannerContext(), createTestingTypeAnalyzer(tester().getPlannerContext()), false); + pushPredicateIntoTableScan = new PushPredicateIntoTableScan(tester().getPlannerContext(), new IrTypeAnalyzer(tester().getPlannerContext()), false); CatalogHandle catalogHandle = tester().getCurrentCatalogHandle(); tester().getPlanTester().createCatalog(MOCK_CATALOG, createMockFactory(), ImmutableMap.of()); diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionIntoTableScan.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionIntoTableScan.java index 0f3c837f30e2..d25f74445348 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionIntoTableScan.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionIntoTableScan.java @@ -41,8 +41,8 @@ import io.trino.spi.type.RowType; import io.trino.spi.type.Type; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.iterative.rule.test.RuleTester; import io.trino.sql.planner.plan.Assignments; import io.trino.sql.tree.Expression; @@ -68,7 +68,6 @@ import static io.trino.spi.type.VarcharType.VARCHAR; import static io.trino.sql.analyzer.TypeSignatureProvider.fromTypes; import static io.trino.sql.planner.ConnectorExpressionTranslator.translate; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.TypeProvider.viewOf; import static io.trino.sql.planner.assertions.PlanMatchPattern.anyTree; import static io.trino.sql.planner.assertions.PlanMatchPattern.expression; @@ -129,7 +128,7 @@ public void testPushProjection() // Create catalog with applyProjection enabled MockConnectorFactory factory = createMockFactory(ImmutableMap.of(columnName, columnHandle), Optional.of(this::mockApplyProjection)); try (RuleTester ruleTester = RuleTester.builder().withDefaultCatalogConnectorFactory(factory).build()) { - TypeAnalyzer typeAnalyzer = createTestingTypeAnalyzer(ruleTester.getPlannerContext()); + IrTypeAnalyzer typeAnalyzer = new IrTypeAnalyzer(ruleTester.getPlannerContext()); // Prepare project node symbols and types Symbol identity = new Symbol("symbol_identity"); @@ -330,7 +329,7 @@ else if (projection instanceof Constant) { private static PushProjectionIntoTableScan createRule(RuleTester tester) { PlannerContext plannerContext = tester.getPlannerContext(); - TypeAnalyzer typeAnalyzer = tester.getTypeAnalyzer(); + IrTypeAnalyzer typeAnalyzer = tester.getTypeAnalyzer(); return new PushProjectionIntoTableScan( plannerContext, typeAnalyzer, diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionThroughJoin.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionThroughJoin.java index 40d8c69394af..84c12820b849 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionThroughJoin.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestPushProjectionThroughJoin.java @@ -16,6 +16,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import io.trino.Session; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Plan; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; @@ -37,7 +38,6 @@ import static io.trino.metadata.AbstractMockMetadata.dummyMetadata; import static io.trino.metadata.FunctionManager.createTestingFunctionManager; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanAssert.assertPlan; import static io.trino.sql.planner.assertions.PlanMatchPattern.expression; import static io.trino.sql.planner.assertions.PlanMatchPattern.join; @@ -88,8 +88,7 @@ a2, new ArithmeticUnaryExpression(PLUS, a0.toSymbolReference()), new JoinNode.EquiJoinClause(a1, b1))); Session session = testSessionBuilder().build(); - Optional rewritten = pushProjectionThroughJoin(PLANNER_CONTEXT, planNode, noLookup(), idAllocator, session, createTestingTypeAnalyzer( - PLANNER_CONTEXT), p.getTypes()); + Optional rewritten = pushProjectionThroughJoin(PLANNER_CONTEXT, planNode, noLookup(), idAllocator, session, new IrTypeAnalyzer(PLANNER_CONTEXT), p.getTypes()); assertThat(rewritten.isPresent()).isTrue(); assertPlan( session, @@ -130,8 +129,7 @@ c, new ArithmeticBinaryExpression(ADD, a.toSymbolReference(), b.toSymbolReferenc INNER, p.values(a), p.values(b))); - Optional rewritten = pushProjectionThroughJoin(PLANNER_CONTEXT, planNode, noLookup(), new PlanNodeIdAllocator(), testSessionBuilder().build(), createTestingTypeAnalyzer( - PLANNER_CONTEXT), p.getTypes()); + Optional rewritten = pushProjectionThroughJoin(PLANNER_CONTEXT, planNode, noLookup(), new PlanNodeIdAllocator(), testSessionBuilder().build(), new IrTypeAnalyzer(PLANNER_CONTEXT), p.getTypes()); assertThat(rewritten).isEmpty(); } @@ -150,8 +148,7 @@ c, new ArithmeticUnaryExpression(MINUS, a.toSymbolReference())), LEFT, p.values(a), p.values(b))); - Optional rewritten = pushProjectionThroughJoin(PLANNER_CONTEXT, planNode, noLookup(), new PlanNodeIdAllocator(), testSessionBuilder().build(), createTestingTypeAnalyzer( - PLANNER_CONTEXT), p.getTypes()); + Optional rewritten = pushProjectionThroughJoin(PLANNER_CONTEXT, planNode, noLookup(), new PlanNodeIdAllocator(), testSessionBuilder().build(), new IrTypeAnalyzer(PLANNER_CONTEXT), p.getTypes()); assertThat(rewritten).isEmpty(); } } diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestReorderJoins.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestReorderJoins.java index afd99b7cac52..3de2d34e4510 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestReorderJoins.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestReorderJoins.java @@ -20,6 +20,7 @@ import io.trino.cost.SymbolStatsEstimate; import io.trino.metadata.TestingFunctionResolution; import io.trino.spi.type.Type; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.OptimizerConfig.JoinDistributionType; import io.trino.sql.planner.OptimizerConfig.JoinReorderingStrategy; import io.trino.sql.planner.Symbol; @@ -47,7 +48,6 @@ import static io.trino.sql.planner.OptimizerConfig.JoinDistributionType.AUTOMATIC; import static io.trino.sql.planner.OptimizerConfig.JoinDistributionType.BROADCAST; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.expression; import static io.trino.sql.planner.assertions.PlanMatchPattern.join; import static io.trino.sql.planner.assertions.PlanMatchPattern.strictProject; @@ -669,6 +669,6 @@ public void testReorderAndReplicate() private RuleBuilder assertReorderJoins() { - return tester.assertThat(new ReorderJoins(PLANNER_CONTEXT, new CostComparator(1, 1, 1), createTestingTypeAnalyzer(PLANNER_CONTEXT))); + return tester.assertThat(new ReorderJoins(PLANNER_CONTEXT, new CostComparator(1, 1, 1), new IrTypeAnalyzer(PLANNER_CONTEXT))); } } diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestSimplifyExpressions.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestSimplifyExpressions.java index 8e68641b9c36..080fe91e858c 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestSimplifyExpressions.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestSimplifyExpressions.java @@ -16,6 +16,7 @@ import com.google.common.collect.ImmutableMap; import io.trino.spi.type.Type; import io.trino.sql.parser.SqlParser; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.SymbolAllocator; import io.trino.sql.planner.SymbolsExtractor; @@ -46,7 +47,6 @@ import static io.trino.sql.ExpressionUtils.logicalExpression; import static io.trino.sql.ExpressionUtils.rewriteIdentifiersToSymbolReferences; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.iterative.rule.SimplifyExpressions.rewrite; import static java.util.stream.Collectors.toList; import static org.assertj.core.api.Assertions.assertThat; @@ -281,7 +281,7 @@ private static Expression simplify(@Language("SQL") String expression, Map symbols = symbolTypes.entrySet().stream().collect(toImmutableMap(symbolTypeEntry -> new Symbol(symbolTypeEntry.getKey()), Map.Entry::getValue)); Expression actualExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expression)); - return normalize(rewrite(actualExpression, TEST_SESSION, new SymbolAllocator(symbols), PLANNER_CONTEXT, createTestingTypeAnalyzer(PLANNER_CONTEXT))); + return normalize(rewrite(actualExpression, TEST_SESSION, new SymbolAllocator(symbols), PLANNER_CONTEXT, new IrTypeAnalyzer(PLANNER_CONTEXT))); } @Test @@ -340,7 +340,7 @@ private static void assertSimplifiesNumericTypes(String expression, String expec { Expression actualExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expression)); Expression expectedExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expected)); - Expression rewritten = rewrite(actualExpression, TEST_SESSION, new SymbolAllocator(numericAndBooleanSymbolTypeMapFor(actualExpression)), PLANNER_CONTEXT, createTestingTypeAnalyzer(PLANNER_CONTEXT)); + Expression rewritten = rewrite(actualExpression, TEST_SESSION, new SymbolAllocator(numericAndBooleanSymbolTypeMapFor(actualExpression)), PLANNER_CONTEXT, new IrTypeAnalyzer(PLANNER_CONTEXT)); assertThat(normalize(rewritten)).isEqualTo(normalize(expectedExpression)); } diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestUnwrapSingleColumnRowInApply.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestUnwrapSingleColumnRowInApply.java index 65b71023b56f..569383fb6da7 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestUnwrapSingleColumnRowInApply.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/TestUnwrapSingleColumnRowInApply.java @@ -15,6 +15,7 @@ import com.google.common.collect.ImmutableMap; import io.trino.spi.type.RowType; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.assertions.ExpressionMatcher; import io.trino.sql.planner.iterative.rule.test.BaseRuleTest; import io.trino.sql.planner.plan.Assignments; @@ -27,7 +28,6 @@ import static io.trino.spi.type.BooleanType.BOOLEAN; import static io.trino.spi.type.IntegerType.INTEGER; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.apply; import static io.trino.sql.planner.assertions.PlanMatchPattern.expression; import static io.trino.sql.planner.assertions.PlanMatchPattern.project; @@ -42,7 +42,7 @@ public class TestUnwrapSingleColumnRowInApply @Test public void testDoesNotFireOnNoSingleColumnRow() { - tester().assertThat(new UnwrapSingleColumnRowInApply(createTestingTypeAnalyzer(tester().getPlannerContext()))) + tester().assertThat(new UnwrapSingleColumnRowInApply(new IrTypeAnalyzer(tester().getPlannerContext()))) .on(p -> p.apply( Assignments.builder() .put(p.symbol("output1", BOOLEAN), new InPredicate(new SymbolReference("value"), new SymbolReference("element"))) @@ -57,7 +57,7 @@ public void testDoesNotFireOnNoSingleColumnRow() @Test public void testUnwrapInPredicate() { - tester().assertThat(new UnwrapSingleColumnRowInApply(createTestingTypeAnalyzer(tester().getPlannerContext()))) + tester().assertThat(new UnwrapSingleColumnRowInApply(new IrTypeAnalyzer(tester().getPlannerContext()))) .on(p -> p.apply( Assignments.builder() .put(p.symbol("unwrapped", BOOLEAN), new InPredicate(new SymbolReference("rowValue"), new SymbolReference("rowElement"))) @@ -95,7 +95,7 @@ public void testUnwrapInPredicate() @Test public void testUnwrapQuantifiedComparison() { - tester().assertThat(new UnwrapSingleColumnRowInApply(createTestingTypeAnalyzer(tester().getPlannerContext()))) + tester().assertThat(new UnwrapSingleColumnRowInApply(new IrTypeAnalyzer(tester().getPlannerContext()))) .on(p -> p.apply( Assignments.builder() .put(p.symbol("unwrapped", BOOLEAN), new QuantifiedComparisonExpression(EQUAL, ALL, new SymbolReference("rowValue"), new SymbolReference("rowElement"))) diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/test/RuleTester.java b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/test/RuleTester.java index 2257208ae2a0..eaf1a188cd9e 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/test/RuleTester.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/iterative/rule/test/RuleTester.java @@ -25,7 +25,7 @@ import io.trino.split.PageSourceManager; import io.trino.split.SplitManager; import io.trino.sql.PlannerContext; -import io.trino.sql.planner.TypeAnalyzer; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.iterative.Rule; import io.trino.testing.PlanTester; @@ -36,7 +36,6 @@ import java.util.Map; import java.util.Optional; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TestingHandles.TEST_CATALOG_NAME; import static io.trino.testing.TestingSession.testSessionBuilder; import static java.util.Objects.requireNonNull; @@ -49,7 +48,7 @@ public class RuleTester private final PlanTester planTester; private final SplitManager splitManager; private final PageSourceManager pageSourceManager; - private final TypeAnalyzer typeAnalyzer; + private final IrTypeAnalyzer typeAnalyzer; private final FunctionManager functionManager; public static RuleTester defaultRuleTester() @@ -65,7 +64,7 @@ public RuleTester(PlanTester planTester) this.functionManager = planTester.getPlannerContext().getFunctionManager(); this.splitManager = planTester.getSplitManager(); this.pageSourceManager = planTester.getPageSourceManager(); - this.typeAnalyzer = createTestingTypeAnalyzer(planTester.getPlannerContext()); + this.typeAnalyzer = new IrTypeAnalyzer(planTester.getPlannerContext()); } public RuleBuilder assertThat(Rule rule) @@ -109,7 +108,7 @@ public PageSourceManager getPageSourceManager() return pageSourceManager; } - public TypeAnalyzer getTypeAnalyzer() + public IrTypeAnalyzer getTypeAnalyzer() { return typeAnalyzer; } diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestEliminateSorts.java b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestEliminateSorts.java index b2dc61f376c2..809225ed2025 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestEliminateSorts.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestEliminateSorts.java @@ -18,8 +18,8 @@ import com.google.common.collect.ImmutableSet; import io.trino.cost.TaskCountEstimator; import io.trino.spi.connector.SortOrder; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.RuleStatsRecorder; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.assertions.BasePlanTest; import io.trino.sql.planner.assertions.ExpectedValueProvider; import io.trino.sql.planner.assertions.PlanMatchPattern; @@ -33,7 +33,6 @@ import java.util.List; import java.util.Optional; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.anyTree; import static io.trino.sql.planner.assertions.PlanMatchPattern.filter; import static io.trino.sql.planner.assertions.PlanMatchPattern.functionCall; @@ -100,7 +99,7 @@ SELECT quantity, row_number() OVER (ORDER BY quantity) private void assertUnitPlan(@Language("SQL") String sql, PlanMatchPattern pattern) { - TypeAnalyzer typeAnalyzer = createTestingTypeAnalyzer(getPlanTester().getPlannerContext()); + IrTypeAnalyzer typeAnalyzer = new IrTypeAnalyzer(getPlanTester().getPlannerContext()); List optimizers = ImmutableList.of( new IterativeOptimizer( getPlanTester().getPlannerContext(), diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestExpressionEquivalence.java b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestExpressionEquivalence.java index 076705032a2e..0a589678beaa 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestExpressionEquivalence.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestExpressionEquivalence.java @@ -23,6 +23,7 @@ import io.trino.spi.type.TypeSignature; import io.trino.sql.PlannerContext; import io.trino.sql.parser.SqlParser; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Expression; @@ -40,7 +41,6 @@ import static io.trino.sql.ExpressionTestUtils.planExpression; import static io.trino.sql.planner.SymbolsExtractor.extractUnique; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TransactionBuilder.transaction; import static java.lang.String.format; import static java.util.function.Function.identity; @@ -57,7 +57,7 @@ public class TestExpressionEquivalence private static final ExpressionEquivalence EQUIVALENCE = new ExpressionEquivalence( PLANNER_CONTEXT.getMetadata(), PLANNER_CONTEXT.getFunctionManager(), - createTestingTypeAnalyzer(PLANNER_CONTEXT)); + new IrTypeAnalyzer(PLANNER_CONTEXT)); private static final TypeProvider TYPE_PROVIDER = TypeProvider.copyOf(ImmutableMap.builder() .put(new Symbol("a_boolean"), BOOLEAN) .put(new Symbol("b_boolean"), BOOLEAN) diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestRemoveUnsupportedDynamicFilters.java b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestRemoveUnsupportedDynamicFilters.java index 21c07d0d0def..7e72a6d413ff 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestRemoveUnsupportedDynamicFilters.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestRemoveUnsupportedDynamicFilters.java @@ -24,6 +24,7 @@ import io.trino.plugin.tpch.TpchTableHandle; import io.trino.spi.connector.CatalogHandle; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Plan; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; @@ -55,7 +56,6 @@ import static io.trino.sql.DynamicFilters.createDynamicFilterExpression; import static io.trino.sql.ExpressionUtils.combineConjuncts; import static io.trino.sql.ExpressionUtils.combineDisjuncts; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.join; import static io.trino.sql.planner.assertions.PlanMatchPattern.output; import static io.trino.sql.planner.assertions.PlanMatchPattern.semiJoin; @@ -493,7 +493,7 @@ private PlanNode removeUnsupportedDynamicFilters(PlanNode root) new CachingTableStatsProvider(metadata, session))); new DynamicFiltersChecker().validate(rewrittenPlan, session, - plannerContext, createTestingTypeAnalyzer(plannerContext), + plannerContext, new IrTypeAnalyzer(plannerContext), builder.getTypes(), WarningCollector.NOOP); return rewrittenPlan; diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestReorderWindows.java b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestReorderWindows.java index 2e4fe02b3872..852eb23ec3d7 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestReorderWindows.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/optimizations/TestReorderWindows.java @@ -17,6 +17,8 @@ import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import io.trino.spi.connector.SortOrder; +import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.RuleStatsRecorder; import io.trino.sql.planner.assertions.BasePlanTest; import io.trino.sql.planner.assertions.ExpectedValueProvider; @@ -34,7 +36,6 @@ import java.util.Optional; import static io.trino.sql.planner.PlanOptimizers.columnPruningRules; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.assertions.PlanMatchPattern.anyTree; import static io.trino.sql.planner.assertions.PlanMatchPattern.expression; import static io.trino.sql.planner.assertions.PlanMatchPattern.filter; @@ -332,11 +333,12 @@ public void testReorderBDAC() private void assertUnitPlan(@Language("SQL") String sql, PlanMatchPattern pattern) { + PlannerContext plannerContext = getPlanTester().getPlannerContext(); List optimizers = ImmutableList.of( new UnaliasSymbolReferences(getPlanTester().getPlannerContext().getMetadata()), new PredicatePushDown( getPlanTester().getPlannerContext(), - createTestingTypeAnalyzer(getPlanTester().getPlannerContext()), + new IrTypeAnalyzer(plannerContext), false, false), new IterativeOptimizer( diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestDynamicFiltersChecker.java b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestDynamicFiltersChecker.java index 33dbb8bf5b3a..595868ed04a9 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestDynamicFiltersChecker.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestDynamicFiltersChecker.java @@ -23,6 +23,7 @@ import io.trino.plugin.tpch.TpchTableHandle; import io.trino.spi.connector.CatalogHandle; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; @@ -43,7 +44,6 @@ import static io.trino.sql.DynamicFilters.createDynamicFilterExpression; import static io.trino.sql.ExpressionUtils.combineConjuncts; import static io.trino.sql.ExpressionUtils.combineDisjuncts; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.iterative.rule.test.PlanBuilder.expression; import static io.trino.sql.planner.plan.JoinType.INNER; import static org.assertj.core.api.Assertions.assertThatThrownBy; @@ -352,7 +352,7 @@ private void validatePlan(PlanNode root) getPlanTester().inTransaction(session -> { // metadata.getCatalogHandle() registers the catalog for the transaction session.getCatalog().ifPresent(catalog -> metadata.getCatalogHandle(session, catalog)); - new DynamicFiltersChecker().validate(root, session, plannerContext, createTestingTypeAnalyzer(plannerContext), TypeProvider.empty(), WarningCollector.NOOP); + new DynamicFiltersChecker().validate(root, session, plannerContext, new IrTypeAnalyzer(plannerContext), TypeProvider.empty(), WarningCollector.NOOP); return null; }); } diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateAggregationsWithDefaultValues.java b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateAggregationsWithDefaultValues.java index 266d85206cba..b1df0c34704b 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateAggregationsWithDefaultValues.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateAggregationsWithDefaultValues.java @@ -22,6 +22,7 @@ import io.trino.plugin.tpch.TpchTableHandle; import io.trino.spi.connector.CatalogHandle; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; @@ -35,7 +36,6 @@ import static io.trino.SessionTestUtils.TEST_SESSION; import static io.trino.spi.type.BigintType.BIGINT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.plan.AggregationNode.Step.FINAL; import static io.trino.sql.planner.plan.AggregationNode.Step.PARTIAL; import static io.trino.sql.planner.plan.AggregationNode.groupingSets; @@ -199,7 +199,7 @@ private void validatePlan(PlanNode root, boolean forceSingleNode) root, session, plannerContext, - createTestingTypeAnalyzer(plannerContext), + new IrTypeAnalyzer(plannerContext), TypeProvider.empty(), WarningCollector.NOOP); return null; diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateScaledWritersUsage.java b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateScaledWritersUsage.java index c165ab7d16f1..28b326ae4681 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateScaledWritersUsage.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateScaledWritersUsage.java @@ -26,6 +26,7 @@ import io.trino.spi.connector.SchemaTableName; import io.trino.spi.connector.WriterScalingOptions; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Partitioning; import io.trino.sql.planner.PartitioningHandle; import io.trino.sql.planner.PartitioningScheme; @@ -52,7 +53,6 @@ import static io.trino.sql.planner.SystemPartitioningHandle.SCALED_WRITER_HASH_DISTRIBUTION; import static io.trino.sql.planner.SystemPartitioningHandle.SCALED_WRITER_ROUND_ROBIN_DISTRIBUTION; import static io.trino.sql.planner.SystemPartitioningHandle.SINGLE_DISTRIBUTION; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TestingHandles.TEST_CATALOG_HANDLE; import static io.trino.testing.TestingHandles.createTestCatalogHandle; import static org.assertj.core.api.Assertions.assertThatThrownBy; @@ -292,7 +292,7 @@ private void validatePlan(PlanNode root) root, session, plannerContext, - createTestingTypeAnalyzer(plannerContext), + new IrTypeAnalyzer(plannerContext), TypeProvider.empty(), WarningCollector.NOOP); return null; diff --git a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateStreamingAggregations.java b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateStreamingAggregations.java index 3f20e95b2d31..6e56054f7003 100644 --- a/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateStreamingAggregations.java +++ b/core/trino-main/src/test/java/io/trino/sql/planner/sanity/TestValidateStreamingAggregations.java @@ -22,8 +22,8 @@ import io.trino.plugin.tpch.TpchTransactionHandle; import io.trino.spi.connector.CatalogHandle; import io.trino.sql.PlannerContext; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.PlanNodeIdAllocator; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.planner.assertions.BasePlanTest; import io.trino.sql.planner.iterative.rule.test.PlanBuilder; @@ -34,7 +34,6 @@ import java.util.function.Function; import static io.trino.spi.type.BigintType.BIGINT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.sql.planner.plan.AggregationNode.Step.SINGLE; import static org.assertj.core.api.Assertions.assertThatThrownBy; @@ -42,7 +41,7 @@ public class TestValidateStreamingAggregations extends BasePlanTest { private PlannerContext plannerContext; - private TypeAnalyzer typeAnalyzer; + private IrTypeAnalyzer typeAnalyzer; private PlanNodeIdAllocator idAllocator = new PlanNodeIdAllocator(); private TableHandle nationTableHandle; @@ -50,7 +49,7 @@ public class TestValidateStreamingAggregations public void setup() { plannerContext = getPlanTester().getPlannerContext(); - typeAnalyzer = createTestingTypeAnalyzer(plannerContext); + typeAnalyzer = new IrTypeAnalyzer(plannerContext); CatalogHandle catalogHandle = getCurrentCatalogHandle(); nationTableHandle = new TableHandle( diff --git a/core/trino-main/src/test/java/io/trino/type/BenchmarkDecimalOperators.java b/core/trino-main/src/test/java/io/trino/type/BenchmarkDecimalOperators.java index dd1d5fc4f418..ce04e140775f 100644 --- a/core/trino-main/src/test/java/io/trino/type/BenchmarkDecimalOperators.java +++ b/core/trino-main/src/test/java/io/trino/type/BenchmarkDecimalOperators.java @@ -26,8 +26,8 @@ import io.trino.sql.PlannerContext; import io.trino.sql.gen.ExpressionCompiler; import io.trino.sql.gen.PageFunctionCompiler; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; -import io.trino.sql.planner.TypeAnalyzer; import io.trino.sql.planner.TypeProvider; import io.trino.sql.relational.RowExpression; import io.trino.sql.relational.SqlToRowExpressionTranslator; @@ -64,7 +64,6 @@ import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.sql.ExpressionTestUtils.createExpression; import static io.trino.sql.planner.TestingPlannerContext.plannerContextBuilder; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TestingConnectorSession.SESSION; import static java.lang.String.format; import static java.math.BigInteger.ONE; @@ -555,7 +554,7 @@ private Object execute(BaseState state) private static class BaseState { - private final TypeAnalyzer typeAnalyzer = createTestingTypeAnalyzer(PLANNER_CONTEXT); + private final IrTypeAnalyzer typeAnalyzer = new IrTypeAnalyzer(PLANNER_CONTEXT); private final Random random = new Random(); protected final Map symbols = new HashMap<>(); diff --git a/plugin/trino-ignite/src/test/java/io/trino/plugin/ignite/TestIgniteClient.java b/plugin/trino-ignite/src/test/java/io/trino/plugin/ignite/TestIgniteClient.java index 955d0519177d..30eb60207b6b 100644 --- a/plugin/trino-ignite/src/test/java/io/trino/plugin/ignite/TestIgniteClient.java +++ b/plugin/trino-ignite/src/test/java/io/trino/plugin/ignite/TestIgniteClient.java @@ -29,6 +29,7 @@ import io.trino.spi.expression.Variable; import io.trino.spi.type.Type; import io.trino.sql.planner.ConnectorExpressionTranslator; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; import io.trino.sql.tree.Expression; @@ -50,7 +51,6 @@ import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.VarcharType.createVarcharType; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.testing.TestingConnectorSession.SESSION; import static org.assertj.core.api.Assertions.assertThat; @@ -220,7 +220,7 @@ private ConnectorExpression translateToConnectorExpression(Expression expression TypeProvider.viewOf(symbolTypes.entrySet().stream() .collect(toImmutableMap(entry -> new Symbol(entry.getKey()), Map.Entry::getValue))), PLANNER_CONTEXT, - createTestingTypeAnalyzer(PLANNER_CONTEXT)) + new IrTypeAnalyzer(PLANNER_CONTEXT)) .orElseThrow(); } diff --git a/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlClient.java b/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlClient.java index 4250ed8d70ae..c9adf414199b 100644 --- a/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlClient.java +++ b/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlClient.java @@ -37,6 +37,7 @@ import io.trino.spi.session.PropertyMetadata; import io.trino.spi.type.Type; import io.trino.sql.planner.ConnectorExpressionTranslator; +import io.trino.sql.planner.IrTypeAnalyzer; import io.trino.sql.planner.LiteralEncoder; import io.trino.sql.planner.Symbol; import io.trino.sql.planner.TypeProvider; @@ -72,7 +73,6 @@ import static io.trino.spi.type.VarcharType.createVarcharType; import static io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType; import static io.trino.sql.planner.TestingPlannerContext.PLANNER_CONTEXT; -import static io.trino.sql.planner.TypeAnalyzer.createTestingTypeAnalyzer; import static io.trino.type.InternalTypeManager.TESTING_TYPE_MANAGER; import static java.lang.String.format; import static org.assertj.core.api.Assertions.assertThat; @@ -457,7 +457,7 @@ private ConnectorExpression translateToConnectorExpression(Expression expression TypeProvider.viewOf(symbolTypes.entrySet().stream() .collect(toImmutableMap(entry -> new Symbol(entry.getKey()), Entry::getValue))), PLANNER_CONTEXT, - createTestingTypeAnalyzer(PLANNER_CONTEXT)) + new IrTypeAnalyzer(PLANNER_CONTEXT)) .orElseThrow(); } }