Example 1 with TypeCoercion
use of io.trino.type.TypeCoercion in project trino by trinodb.
the class ExpressionInterpreter method evaluateConstantExpression.
public static Object evaluateConstantExpression(Expression expression, Type expectedType, PlannerContext plannerContext, Session session, AccessControl accessControl, Map<NodeRef<Parameter>, Expression> parameters) {
ExpressionAnalyzer analyzer = createConstantAnalyzer(plannerContext, accessControl, session, parameters, WarningCollector.NOOP);
analyzer.analyze(expression, Scope.create());
Type actualType = analyzer.getExpressionTypes().get(NodeRef.of(expression));
if (!new TypeCoercion(plannerContext.getTypeManager()::getType).canCoerce(actualType, expectedType)) {
throw semanticException(TYPE_MISMATCH, expression, "Cannot cast type %s to %s", actualType.getDisplayName(), expectedType.getDisplayName());
}
Map<NodeRef<Expression>, Type> coercions = ImmutableMap.<NodeRef<Expression>, Type>builder().putAll(analyzer.getExpressionCoercions()).put(NodeRef.of(expression), expectedType).buildOrThrow();
return evaluateConstantExpression(expression, coercions, analyzer.getTypeOnlyCoercions(), plannerContext, session, accessControl, ImmutableSet.of(), parameters);
}
Also used :
NodeRef(io.trino.sql.tree.NodeRef)
FunctionType(io.trino.type.FunctionType)
OperatorType(io.trino.spi.function.OperatorType)
CharType(io.trino.spi.type.CharType)
VarcharType.createVarcharType(io.trino.spi.type.VarcharType.createVarcharType)
RowType(io.trino.spi.type.RowType)
TypeSignatureTranslator.toSqlType(io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType)
ArrayType(io.trino.spi.type.ArrayType)
Type(io.trino.spi.type.Type)
VarcharType(io.trino.spi.type.VarcharType)
NullIfExpression(io.trino.sql.tree.NullIfExpression)
ArithmeticUnaryExpression(io.trino.sql.tree.ArithmeticUnaryExpression)
DereferenceExpression(io.trino.sql.tree.DereferenceExpression)
InListExpression(io.trino.sql.tree.InListExpression)
NotExpression(io.trino.sql.tree.NotExpression)
ArithmeticBinaryExpression(io.trino.sql.tree.ArithmeticBinaryExpression)
LogicalExpression(io.trino.sql.tree.LogicalExpression)
SearchedCaseExpression(io.trino.sql.tree.SearchedCaseExpression)
BindExpression(io.trino.sql.tree.BindExpression)
ComparisonExpression(io.trino.sql.tree.ComparisonExpression)
CoalesceExpression(io.trino.sql.tree.CoalesceExpression)
IfExpression(io.trino.sql.tree.IfExpression)
QuantifiedComparisonExpression(io.trino.sql.tree.QuantifiedComparisonExpression)
Expression(io.trino.sql.tree.Expression)
SimpleCaseExpression(io.trino.sql.tree.SimpleCaseExpression)
SubqueryExpression(io.trino.sql.tree.SubqueryExpression)
LambdaExpression(io.trino.sql.tree.LambdaExpression)
SubscriptExpression(io.trino.sql.tree.SubscriptExpression)
CanonicalizeExpressionRewriter.canonicalizeExpression(io.trino.sql.planner.iterative.rule.CanonicalizeExpressionRewriter.canonicalizeExpression)
ExpressionAnalyzer(io.trino.sql.analyzer.ExpressionAnalyzer)
TypeCoercion(io.trino.type.TypeCoercion)
Example 2 with TypeCoercion
use of io.trino.type.TypeCoercion in project trino by trinodb.
the class QueryPlanner method plan.
public UpdateNode plan(Update node) {
Table table = node.getTable();
TableHandle handle = analysis.getTableHandle(table);
TableSchema tableSchema = plannerContext.getMetadata().getTableSchema(session, handle);
Map<String, ColumnHandle> columnMap = plannerContext.getMetadata().getColumnHandles(session, handle);
List<ColumnSchema> columnsSchemas = tableSchema.getColumns();
List<String> targetColumnNames = node.getAssignments().stream().map(assignment -> assignment.getName().getValue()).collect(toImmutableList());
// Create lists of columnnames and SET expressions, in table column order
ImmutableList.Builder<String> updatedColumnNamesBuilder = ImmutableList.builder();
ImmutableList.Builder<ColumnHandle> updatedColumnHandlesBuilder = ImmutableList.builder();
ImmutableList.Builder<Expression> orderedColumnValuesBuilder = ImmutableList.builder();
for (ColumnSchema columnSchema : columnsSchemas) {
String name = columnSchema.getName();
int index = targetColumnNames.indexOf(name);
if (index >= 0) {
updatedColumnNamesBuilder.add(name);
updatedColumnHandlesBuilder.add(requireNonNull(columnMap.get(name), "columnMap didn't contain name"));
orderedColumnValuesBuilder.add(node.getAssignments().get(index).getValue());
}
}
List<String> updatedColumnNames = updatedColumnNamesBuilder.build();
List<ColumnHandle> updatedColumnHandles = updatedColumnHandlesBuilder.build();
List<Expression> orderedColumnValues = orderedColumnValuesBuilder.build();
// create table scan
RelationPlan relationPlan = new RelationPlanner(analysis, symbolAllocator, idAllocator, lambdaDeclarationToSymbolMap, plannerContext, outerContext, session, recursiveSubqueries).process(table, null);
PlanBuilder builder = newPlanBuilder(relationPlan, analysis, lambdaDeclarationToSymbolMap);
if (node.getWhere().isPresent()) {
builder = filter(builder, node.getWhere().get(), node);
}
builder = subqueryPlanner.handleSubqueries(builder, orderedColumnValues, analysis.getSubqueries(node));
builder = builder.appendProjections(orderedColumnValues, symbolAllocator, idAllocator);
PlanAndMappings planAndMappings = coerce(builder, orderedColumnValues, analysis, idAllocator, symbolAllocator, typeCoercion);
builder = planAndMappings.getSubPlan();
ImmutableList.Builder<Symbol> updatedColumnValuesBuilder = ImmutableList.builder();
orderedColumnValues.forEach(columnValue -> updatedColumnValuesBuilder.add(planAndMappings.get(columnValue)));
Symbol rowId = builder.translate(analysis.getRowIdField(table));
updatedColumnValuesBuilder.add(rowId);
List<Symbol> outputs = ImmutableList.of(symbolAllocator.newSymbol("partialrows", BIGINT), symbolAllocator.newSymbol("fragment", VARBINARY));
Optional<PlanNodeId> tableScanId = getIdForLeftTableScan(relationPlan.getRoot());
checkArgument(tableScanId.isPresent(), "tableScanId not present");
// create update node
return new UpdateNode(idAllocator.getNextId(), builder.getRoot(), new UpdateTarget(Optional.empty(), plannerContext.getMetadata().getTableMetadata(session, handle).getTable(), updatedColumnNames, updatedColumnHandles), rowId, updatedColumnValuesBuilder.build(), outputs);
}
Also used :
PatternRecognitionComponents(io.trino.sql.planner.RelationPlanner.PatternRecognitionComponents)
Arrays(java.util.Arrays)
TypeSignatureProvider.fromTypes(io.trino.sql.analyzer.TypeSignatureProvider.fromTypes)
Delete(io.trino.sql.tree.Delete)
PlanNode(io.trino.sql.planner.plan.PlanNode)
Node(io.trino.sql.tree.Node)
Offset(io.trino.sql.tree.Offset)
PlanNodeId(io.trino.sql.planner.plan.PlanNodeId)
LongLiteral(io.trino.sql.tree.LongLiteral)
Map(java.util.Map)
Union(io.trino.sql.tree.Union)
FetchFirst(io.trino.sql.tree.FetchFirst)
TableScanNode(io.trino.sql.planner.plan.TableScanNode)
ImmutableList.toImmutableList(com.google.common.collect.ImmutableList.toImmutableList)
Assignments(io.trino.sql.planner.plan.Assignments)
Set(java.util.Set)
TableSchema(io.trino.metadata.TableSchema)
SortItem(io.trino.sql.tree.SortItem)
NodeUtils.getSortItemsFromOrderBy(io.trino.sql.NodeUtils.getSortItemsFromOrderBy)
DEFAULT_FRAME(io.trino.sql.planner.plan.WindowNode.Frame.DEFAULT_FRAME)
RelationType(io.trino.sql.analyzer.RelationType)
ImmutableMap.toImmutableMap(com.google.common.collect.ImmutableMap.toImmutableMap)
AggregationNode.groupingSets(io.trino.sql.planner.plan.AggregationNode.groupingSets)
DeleteTarget(io.trino.sql.planner.plan.TableWriterNode.DeleteTarget)
PlanBuilder.newPlanBuilder(io.trino.sql.planner.PlanBuilder.newPlanBuilder)
ImmutableListMultimap(com.google.common.collect.ImmutableListMultimap)
DecimalLiteral(io.trino.sql.tree.DecimalLiteral)
ValuesNode(io.trino.sql.planner.plan.ValuesNode)
ExpressionAnalyzer.isNumericType(io.trino.sql.analyzer.ExpressionAnalyzer.isNumericType)
Session(io.trino.Session)
Iterables(com.google.common.collect.Iterables)
LimitNode(io.trino.sql.planner.plan.LimitNode)
TypeCoercion(io.trino.type.TypeCoercion)
BOOLEAN(io.trino.spi.type.BooleanType.BOOLEAN)
ArrayList(java.util.ArrayList)
LinkedHashMap(java.util.LinkedHashMap)
UpdateTarget(io.trino.sql.planner.plan.TableWriterNode.UpdateTarget)
ScopeAware.scopeAwareKey(io.trino.sql.planner.ScopeAware.scopeAwareKey)
VARCHAR(io.trino.spi.type.VarcharType.VARCHAR)
NodeRef(io.trino.sql.tree.NodeRef)
ColumnHandle(io.trino.spi.connector.ColumnHandle)
AggregationNode(io.trino.sql.planner.plan.AggregationNode)
ImmutableSet.toImmutableSet(com.google.common.collect.ImmutableSet.toImmutableSet)
VARBINARY(io.trino.spi.type.VarbinaryType.VARBINARY)
GroupingOperationRewriter.rewriteGroupingOperation(io.trino.sql.planner.GroupingOperationRewriter.rewriteGroupingOperation)
NodeUtils(io.trino.sql.NodeUtils)
INTERVAL_DAY_TIME(io.trino.type.IntervalDayTimeType.INTERVAL_DAY_TIME)
Query(io.trino.sql.tree.Query)
StringLiteral(io.trino.sql.tree.StringLiteral)
Relation(io.trino.sql.tree.Relation)
GroupingSetAnalysis(io.trino.sql.analyzer.Analysis.GroupingSetAnalysis)
Iterables.getOnlyElement(com.google.common.collect.Iterables.getOnlyElement)
SortOrder(io.trino.spi.connector.SortOrder)
AggregationNode.singleGroupingSet(io.trino.sql.planner.plan.AggregationNode.singleGroupingSet)
TableHandle(io.trino.metadata.TableHandle)
Table(io.trino.sql.tree.Table)
GroupIdNode(io.trino.sql.planner.plan.GroupIdNode)
YEAR(io.trino.sql.tree.IntervalLiteral.IntervalField.YEAR)
OffsetNode(io.trino.sql.planner.plan.OffsetNode)
ROWS(io.trino.sql.tree.WindowFrame.Type.ROWS)
NullTreatment(io.trino.sql.tree.FunctionCall.NullTreatment)
DAY(io.trino.sql.tree.IntervalLiteral.IntervalField.DAY)
MeasureDefinition(io.trino.sql.tree.MeasureDefinition)
INTERVAL_YEAR_MONTH(io.trino.type.IntervalYearMonthType.INTERVAL_YEAR_MONTH)
Aggregation(io.trino.sql.planner.plan.AggregationNode.Aggregation)
FilterNode(io.trino.sql.planner.plan.FilterNode)
LambdaArgumentDeclaration(io.trino.sql.tree.LambdaArgumentDeclaration)
Preconditions.checkArgument(com.google.common.base.Preconditions.checkArgument)
OrderingScheme.sortItemToSortOrder(io.trino.sql.planner.OrderingScheme.sortItemToSortOrder)
SelectExpression(io.trino.sql.analyzer.Analysis.SelectExpression)
GROUPS(io.trino.sql.tree.WindowFrame.Type.GROUPS)
DeleteNode(io.trino.sql.planner.plan.DeleteNode)
Update(io.trino.sql.tree.Update)
FunctionCall(io.trino.sql.tree.FunctionCall)
QuerySpecification(io.trino.sql.tree.QuerySpecification)
ImmutableSet(com.google.common.collect.ImmutableSet)
ImmutableMap(com.google.common.collect.ImmutableMap)
ResolvedFunction(io.trino.metadata.ResolvedFunction)
TypeSignatureTranslator.toSqlType(io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType)
IntervalLiteral(io.trino.sql.tree.IntervalLiteral)
RANGE(io.trino.sql.tree.WindowFrame.Type.RANGE)
VariableDefinition(io.trino.sql.tree.VariableDefinition)
PatternRecognitionNode(io.trino.sql.planner.plan.PatternRecognitionNode)
Collectors(java.util.stream.Collectors)
Sets(com.google.common.collect.Sets)
ComparisonExpression(io.trino.sql.tree.ComparisonExpression)
String.format(java.lang.String.format)
Preconditions.checkState(com.google.common.base.Preconditions.checkState)
LESS_THAN_OR_EQUAL(io.trino.sql.tree.ComparisonExpression.Operator.LESS_THAN_OR_EQUAL)
GenericLiteral(io.trino.sql.tree.GenericLiteral)
SimplePlanRewriter(io.trino.sql.planner.plan.SimplePlanRewriter)
List(java.util.List)
POSITIVE(io.trino.sql.tree.IntervalLiteral.Sign.POSITIVE)
IfExpression(io.trino.sql.tree.IfExpression)
ColumnSchema(io.trino.spi.connector.ColumnSchema)
BIGINT(io.trino.spi.type.BigintType.BIGINT)
WindowFrame(io.trino.sql.tree.WindowFrame)
Optional(java.util.Optional)
Expression(io.trino.sql.tree.Expression)
WindowNode(io.trino.sql.planner.plan.WindowNode)
DecimalType(io.trino.spi.type.DecimalType)
OrderBy(io.trino.sql.tree.OrderBy)
PlannerContext(io.trino.sql.PlannerContext)
Analysis(io.trino.sql.analyzer.Analysis)
IntStream(java.util.stream.IntStream)
FieldId(io.trino.sql.analyzer.FieldId)
UnionNode(io.trino.sql.planner.plan.UnionNode)
WindowOperation(io.trino.sql.tree.WindowOperation)
Type(io.trino.spi.type.Type)
LambdaExpression(io.trino.sql.tree.LambdaExpression)
HashMap(java.util.HashMap)
SystemSessionProperties.getMaxRecursionDepth(io.trino.SystemSessionProperties.getMaxRecursionDepth)
SortNode(io.trino.sql.planner.plan.SortNode)
Function(java.util.function.Function)
Cast(io.trino.sql.tree.Cast)
HashSet(java.util.HashSet)
ImmutableList(com.google.common.collect.ImmutableList)
Objects.requireNonNull(java.util.Objects.requireNonNull)
GREATER_THAN_OR_EQUAL(io.trino.sql.tree.ComparisonExpression.Operator.GREATER_THAN_OR_EQUAL)
ProjectNode(io.trino.sql.planner.plan.ProjectNode)
ResolvedWindow(io.trino.sql.analyzer.Analysis.ResolvedWindow)
RowsPerMatch(io.trino.sql.tree.PatternRecognitionRelation.RowsPerMatch)
Iterator(java.util.Iterator)
TRUE_LITERAL(io.trino.sql.tree.BooleanLiteral.TRUE_LITERAL)
UpdateNode(io.trino.sql.planner.plan.UpdateNode)
QualifiedName(io.trino.sql.tree.QualifiedName)
SystemSessionProperties.isSkipRedundantSort(io.trino.SystemSessionProperties.isSkipRedundantSort)
FrameBound(io.trino.sql.tree.FrameBound)
TableSchema(io.trino.metadata.TableSchema)
ImmutableList.toImmutableList(com.google.common.collect.ImmutableList.toImmutableList)
ImmutableList(com.google.common.collect.ImmutableList)
ColumnSchema(io.trino.spi.connector.ColumnSchema)
PlanBuilder.newPlanBuilder(io.trino.sql.planner.PlanBuilder.newPlanBuilder)
PlanNodeId(io.trino.sql.planner.plan.PlanNodeId)
UpdateNode(io.trino.sql.planner.plan.UpdateNode)
ColumnHandle(io.trino.spi.connector.ColumnHandle)
Table(io.trino.sql.tree.Table)
UpdateTarget(io.trino.sql.planner.plan.TableWriterNode.UpdateTarget)
SelectExpression(io.trino.sql.analyzer.Analysis.SelectExpression)
ComparisonExpression(io.trino.sql.tree.ComparisonExpression)
IfExpression(io.trino.sql.tree.IfExpression)
Expression(io.trino.sql.tree.Expression)
LambdaExpression(io.trino.sql.tree.LambdaExpression)
TableHandle(io.trino.metadata.TableHandle)
Example 3 with TypeCoercion
use of io.trino.type.TypeCoercion in project trino by trinodb.
the class TestDomainTranslator method testNumericTypeTranslation.
private void testNumericTypeTranslation(NumericValues<?> columnValues, NumericValues<?> literalValues) {
Type columnType = columnValues.getType();
Type literalType = literalValues.getType();
Type superType = new TypeCoercion(functionResolution.getPlannerContext().getTypeManager()::getType).getCommonSuperType(columnType, literalType).orElseThrow(() -> new IllegalArgumentException("incompatible types in test (" + columnType + ", " + literalType + ")"));
Expression max = toExpression(literalValues.getMax(), literalType);
Expression min = toExpression(literalValues.getMin(), literalType);
Expression integerPositive = toExpression(literalValues.getIntegerPositive(), literalType);
Expression integerNegative = toExpression(literalValues.getIntegerNegative(), literalType);
Expression fractionalPositive = toExpression(literalValues.getFractionalPositive(), literalType);
Expression fractionalNegative = toExpression(literalValues.getFractionalNegative(), literalType);
if (!literalType.equals(superType)) {
max = cast(max, superType);
min = cast(min, superType);
integerPositive = cast(integerPositive, superType);
integerNegative = cast(integerNegative, superType);
fractionalPositive = cast(fractionalPositive, superType);
fractionalNegative = cast(fractionalNegative, superType);
}
Symbol columnSymbol = columnValues.getColumn();
Expression columnExpression = columnSymbol.toSymbolReference();
if (!columnType.equals(superType)) {
columnExpression = cast(columnExpression, superType);
}
// greater than or equal
testSimpleComparison(greaterThanOrEqual(columnExpression, integerPositive), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(greaterThanOrEqual(columnExpression, integerNegative), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(greaterThanOrEqual(columnExpression, max), columnSymbol, Range.greaterThan(columnType, columnValues.getMax()));
testSimpleComparison(greaterThanOrEqual(columnExpression, min), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(greaterThanOrEqual(columnExpression, fractionalPositive), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(greaterThanOrEqual(columnExpression, fractionalNegative), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalNegative()));
}
// greater than or equal negated
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(not(greaterThanOrEqual(columnExpression, integerPositive)));
assertNoFullPushdown(not(greaterThanOrEqual(columnExpression, integerNegative)));
assertNoFullPushdown(not(greaterThanOrEqual(columnExpression, max)));
assertNoFullPushdown(not(greaterThanOrEqual(columnExpression, min)));
assertNoFullPushdown(not(greaterThanOrEqual(columnExpression, fractionalPositive)));
assertNoFullPushdown(not(greaterThanOrEqual(columnExpression, fractionalNegative)));
} else {
testSimpleComparison(not(greaterThanOrEqual(columnExpression, integerPositive)), columnSymbol, Range.lessThan(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(greaterThanOrEqual(columnExpression, integerNegative)), columnSymbol, Range.lessThan(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(not(greaterThanOrEqual(columnExpression, max)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getMax()));
testSimpleComparison(not(greaterThanOrEqual(columnExpression, min)), columnSymbol, Range.lessThan(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(not(greaterThanOrEqual(columnExpression, fractionalPositive)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(not(greaterThanOrEqual(columnExpression, fractionalNegative)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalNegative()));
}
}
// greater than
testSimpleComparison(greaterThan(columnExpression, integerPositive), columnSymbol, Range.greaterThan(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(greaterThan(columnExpression, integerNegative), columnSymbol, Range.greaterThan(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(greaterThan(columnExpression, max), columnSymbol, Range.greaterThan(columnType, columnValues.getMax()));
testSimpleComparison(greaterThan(columnExpression, min), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(greaterThan(columnExpression, fractionalPositive), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(greaterThan(columnExpression, fractionalNegative), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalNegative()));
}
// greater than negated
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(not(greaterThan(columnExpression, integerPositive)));
assertNoFullPushdown(not(greaterThan(columnExpression, integerNegative)));
assertNoFullPushdown(not(greaterThan(columnExpression, max)));
assertNoFullPushdown(not(greaterThan(columnExpression, min)));
assertNoFullPushdown(not(greaterThan(columnExpression, fractionalPositive)));
assertNoFullPushdown(not(greaterThan(columnExpression, fractionalNegative)));
} else {
testSimpleComparison(not(greaterThan(columnExpression, integerPositive)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(greaterThan(columnExpression, integerNegative)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(not(greaterThan(columnExpression, max)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getMax()));
testSimpleComparison(not(greaterThan(columnExpression, min)), columnSymbol, Range.lessThan(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(not(greaterThan(columnExpression, fractionalPositive)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(not(greaterThan(columnExpression, fractionalNegative)), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalNegative()));
}
}
// less than or equal
testSimpleComparison(lessThanOrEqual(columnExpression, integerPositive), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(lessThanOrEqual(columnExpression, integerNegative), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(lessThanOrEqual(columnExpression, max), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getMax()));
testSimpleComparison(lessThanOrEqual(columnExpression, min), columnSymbol, Range.lessThan(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(lessThanOrEqual(columnExpression, fractionalPositive), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(lessThanOrEqual(columnExpression, fractionalNegative), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalNegative()));
}
// less than or equal negated
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(not(lessThanOrEqual(columnExpression, integerPositive)));
assertNoFullPushdown(not(lessThanOrEqual(columnExpression, integerNegative)));
assertNoFullPushdown(not(lessThanOrEqual(columnExpression, max)));
assertNoFullPushdown(not(lessThanOrEqual(columnExpression, min)));
assertNoFullPushdown(not(lessThanOrEqual(columnExpression, fractionalPositive)));
assertNoFullPushdown(not(lessThanOrEqual(columnExpression, fractionalNegative)));
} else {
testSimpleComparison(not(lessThanOrEqual(columnExpression, integerPositive)), columnSymbol, Range.greaterThan(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(lessThanOrEqual(columnExpression, integerNegative)), columnSymbol, Range.greaterThan(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(not(lessThanOrEqual(columnExpression, max)), columnSymbol, Range.greaterThan(columnType, columnValues.getMax()));
testSimpleComparison(not(lessThanOrEqual(columnExpression, min)), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(not(lessThanOrEqual(columnExpression, fractionalPositive)), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(not(lessThanOrEqual(columnExpression, fractionalNegative)), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalNegative()));
}
}
// less than
testSimpleComparison(lessThan(columnExpression, integerPositive), columnSymbol, Range.lessThan(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(lessThan(columnExpression, integerNegative), columnSymbol, Range.lessThan(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(lessThan(columnExpression, max), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getMax()));
testSimpleComparison(lessThan(columnExpression, min), columnSymbol, Range.lessThan(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(lessThan(columnExpression, fractionalPositive), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(lessThan(columnExpression, fractionalNegative), columnSymbol, Range.lessThanOrEqual(columnType, columnValues.getFractionalNegative()));
}
// less than negated
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(not(lessThan(columnExpression, integerPositive)));
assertNoFullPushdown(not(lessThan(columnExpression, integerNegative)));
assertNoFullPushdown(not(lessThan(columnExpression, max)));
assertNoFullPushdown(not(lessThan(columnExpression, min)));
assertNoFullPushdown(not(lessThan(columnExpression, fractionalPositive)));
assertNoFullPushdown(not(lessThan(columnExpression, fractionalNegative)));
} else {
testSimpleComparison(not(lessThan(columnExpression, integerPositive)), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(lessThan(columnExpression, integerNegative)), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(not(lessThan(columnExpression, max)), columnSymbol, Range.greaterThan(columnType, columnValues.getMax()));
testSimpleComparison(not(lessThan(columnExpression, min)), columnSymbol, Range.greaterThanOrEqual(columnType, columnValues.getMin()));
if (literalValues.isFractional()) {
testSimpleComparison(not(lessThan(columnExpression, fractionalPositive)), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalPositive()));
testSimpleComparison(not(lessThan(columnExpression, fractionalNegative)), columnSymbol, Range.greaterThan(columnType, columnValues.getFractionalNegative()));
}
}
// equal
testSimpleComparison(equal(columnExpression, integerPositive), columnSymbol, Range.equal(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(equal(columnExpression, integerNegative), columnSymbol, Range.equal(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(equal(columnExpression, max), columnSymbol, Domain.none(columnType));
testSimpleComparison(equal(columnExpression, min), columnSymbol, Domain.none(columnType));
if (literalValues.isFractional()) {
testSimpleComparison(equal(columnExpression, fractionalPositive), columnSymbol, Domain.none(columnType));
testSimpleComparison(equal(columnExpression, fractionalNegative), columnSymbol, Domain.none(columnType));
}
// equal negated
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(not(equal(columnExpression, integerPositive)));
assertNoFullPushdown(not(equal(columnExpression, integerNegative)));
assertNoFullPushdown(not(equal(columnExpression, max)));
assertNoFullPushdown(not(equal(columnExpression, min)));
assertNoFullPushdown(not(equal(columnExpression, fractionalPositive)));
assertNoFullPushdown(not(equal(columnExpression, fractionalNegative)));
} else {
testSimpleComparison(not(equal(columnExpression, integerPositive)), columnSymbol, Domain.create(ValueSet.ofRanges(Range.lessThan(columnType, columnValues.getIntegerPositive()), Range.greaterThan(columnType, columnValues.getIntegerPositive())), false));
testSimpleComparison(not(equal(columnExpression, integerNegative)), columnSymbol, Domain.create(ValueSet.ofRanges(Range.lessThan(columnType, columnValues.getIntegerNegative()), Range.greaterThan(columnType, columnValues.getIntegerNegative())), false));
testSimpleComparison(not(equal(columnExpression, max)), columnSymbol, Domain.notNull(columnType));
testSimpleComparison(not(equal(columnExpression, min)), columnSymbol, Domain.notNull(columnType));
if (literalValues.isFractional()) {
testSimpleComparison(not(equal(columnExpression, fractionalPositive)), columnSymbol, Domain.notNull(columnType));
testSimpleComparison(not(equal(columnExpression, fractionalNegative)), columnSymbol, Domain.notNull(columnType));
}
}
// not equal
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(notEqual(columnExpression, integerPositive));
assertNoFullPushdown(notEqual(columnExpression, integerNegative));
assertNoFullPushdown(notEqual(columnExpression, max));
assertNoFullPushdown(notEqual(columnExpression, min));
assertNoFullPushdown(notEqual(columnExpression, fractionalPositive));
assertNoFullPushdown(notEqual(columnExpression, integerNegative));
} else {
testSimpleComparison(notEqual(columnExpression, integerPositive), columnSymbol, Domain.create(ValueSet.ofRanges(Range.lessThan(columnType, columnValues.getIntegerPositive()), Range.greaterThan(columnType, columnValues.getIntegerPositive())), false));
testSimpleComparison(notEqual(columnExpression, integerNegative), columnSymbol, Domain.create(ValueSet.ofRanges(Range.lessThan(columnType, columnValues.getIntegerNegative()), Range.greaterThan(columnType, columnValues.getIntegerNegative())), false));
testSimpleComparison(notEqual(columnExpression, max), columnSymbol, Domain.notNull(columnType));
testSimpleComparison(notEqual(columnExpression, min), columnSymbol, Domain.notNull(columnType));
if (literalValues.isFractional()) {
testSimpleComparison(notEqual(columnExpression, fractionalPositive), columnSymbol, Domain.notNull(columnType));
testSimpleComparison(notEqual(columnExpression, fractionalNegative), columnSymbol, Domain.notNull(columnType));
}
}
// not equal negated
if (literalValues.isTypeWithNaN()) {
testSimpleComparison(not(notEqual(columnExpression, integerPositive)), columnSymbol, Range.equal(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(notEqual(columnExpression, integerNegative)), columnSymbol, Range.equal(columnType, columnValues.getIntegerNegative()));
assertNoFullPushdown(not(notEqual(columnExpression, max)));
assertNoFullPushdown(not(notEqual(columnExpression, min)));
assertNoFullPushdown(not(notEqual(columnExpression, fractionalPositive)));
assertNoFullPushdown(not(notEqual(columnExpression, fractionalNegative)));
} else {
testSimpleComparison(not(notEqual(columnExpression, integerPositive)), columnSymbol, Range.equal(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(notEqual(columnExpression, integerNegative)), columnSymbol, Range.equal(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(not(notEqual(columnExpression, max)), columnSymbol, Domain.none(columnType));
testSimpleComparison(not(notEqual(columnExpression, min)), columnSymbol, Domain.none(columnType));
if (literalValues.isFractional()) {
testSimpleComparison(not(notEqual(columnExpression, fractionalPositive)), columnSymbol, Domain.none(columnType));
testSimpleComparison(not(notEqual(columnExpression, fractionalNegative)), columnSymbol, Domain.none(columnType));
}
}
// is distinct from
if (literalValues.isTypeWithNaN()) {
assertNoFullPushdown(isDistinctFrom(columnExpression, integerPositive));
assertNoFullPushdown(isDistinctFrom(columnExpression, integerNegative));
testSimpleComparison(isDistinctFrom(columnExpression, max), columnSymbol, Domain.all(columnType));
testSimpleComparison(isDistinctFrom(columnExpression, min), columnSymbol, Domain.all(columnType));
testSimpleComparison(isDistinctFrom(columnExpression, fractionalPositive), columnSymbol, Domain.all(columnType));
testSimpleComparison(isDistinctFrom(columnExpression, fractionalNegative), columnSymbol, Domain.all(columnType));
} else {
testSimpleComparison(isDistinctFrom(columnExpression, integerPositive), columnSymbol, Domain.create(ValueSet.ofRanges(Range.lessThan(columnType, columnValues.getIntegerPositive()), Range.greaterThan(columnType, columnValues.getIntegerPositive())), true));
testSimpleComparison(isDistinctFrom(columnExpression, integerNegative), columnSymbol, Domain.create(ValueSet.ofRanges(Range.lessThan(columnType, columnValues.getIntegerNegative()), Range.greaterThan(columnType, columnValues.getIntegerNegative())), true));
testSimpleComparison(isDistinctFrom(columnExpression, max), columnSymbol, Domain.all(columnType));
testSimpleComparison(isDistinctFrom(columnExpression, min), columnSymbol, Domain.all(columnType));
if (literalValues.isFractional()) {
testSimpleComparison(isDistinctFrom(columnExpression, fractionalPositive), columnSymbol, Domain.all(columnType));
testSimpleComparison(isDistinctFrom(columnExpression, fractionalNegative), columnSymbol, Domain.all(columnType));
}
}
// is distinct from negated
testSimpleComparison(not(isDistinctFrom(columnExpression, integerPositive)), columnSymbol, Range.equal(columnType, columnValues.getIntegerPositive()));
testSimpleComparison(not(isDistinctFrom(columnExpression, integerNegative)), columnSymbol, Range.equal(columnType, columnValues.getIntegerNegative()));
testSimpleComparison(not(isDistinctFrom(columnExpression, max)), columnSymbol, Domain.none(columnType));
testSimpleComparison(not(isDistinctFrom(columnExpression, min)), columnSymbol, Domain.none(columnType));
if (literalValues.isFractional()) {
testSimpleComparison(not(isDistinctFrom(columnExpression, fractionalPositive)), columnSymbol, Domain.none(columnType));
testSimpleComparison(not(isDistinctFrom(columnExpression, fractionalNegative)), columnSymbol, Domain.none(columnType));
}
}
Also used :
CharType.createCharType(io.trino.spi.type.CharType.createCharType)
TypeSignatureTranslator.toSqlType(io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType)
DecimalType(io.trino.spi.type.DecimalType)
DoubleType(io.trino.spi.type.DoubleType)
Type(io.trino.spi.type.Type)
VarcharType.createUnboundedVarcharType(io.trino.spi.type.VarcharType.createUnboundedVarcharType)
DecimalType.createDecimalType(io.trino.spi.type.DecimalType.createDecimalType)
RealType(io.trino.spi.type.RealType)
ComparisonExpression(io.trino.sql.tree.ComparisonExpression)
Expression(io.trino.sql.tree.Expression)
InListExpression(io.trino.sql.tree.InListExpression)
NotExpression(io.trino.sql.tree.NotExpression)
TypeCoercion(io.trino.type.TypeCoercion)
Example 4 with TypeCoercion
use of io.trino.type.TypeCoercion in project trino by trinodb.
the class QueryPlanner method aggregate.
private PlanBuilder aggregate(PlanBuilder subPlan, QuerySpecification node) {
if (!analysis.isAggregation(node)) {
return subPlan;
}
ImmutableList.Builder<Expression> inputBuilder = ImmutableList.builder();
analysis.getAggregates(node).stream().map(FunctionCall::getArguments).flatMap(List::stream).filter(// lambda expression is generated at execution time
expression -> !(expression instanceof LambdaExpression)).forEach(inputBuilder::add);
analysis.getAggregates(node).stream().map(FunctionCall::getOrderBy).map(NodeUtils::getSortItemsFromOrderBy).flatMap(List::stream).map(SortItem::getSortKey).forEach(inputBuilder::add);
// filter expressions need to be projected first
analysis.getAggregates(node).stream().map(FunctionCall::getFilter).filter(Optional::isPresent).map(Optional::get).forEach(inputBuilder::add);
GroupingSetAnalysis groupingSetAnalysis = analysis.getGroupingSets(node);
inputBuilder.addAll(groupingSetAnalysis.getComplexExpressions());
List<Expression> inputs = inputBuilder.build();
subPlan = subqueryPlanner.handleSubqueries(subPlan, inputs, analysis.getSubqueries(node));
subPlan = subPlan.appendProjections(inputs, symbolAllocator, idAllocator);
// Add projection to coerce inputs to their site-specific types.
// This is important because the same lexical expression may need to be coerced
// in different ways if it's referenced by multiple arguments to the window function.
// For example, given v::integer,
// avg(v)
// Needs to be rewritten as
// avg(CAST(v AS double))
PlanAndMappings coercions = coerce(subPlan, inputs, analysis, idAllocator, symbolAllocator, typeCoercion);
subPlan = coercions.getSubPlan();
GroupingSetsPlan groupingSets = planGroupingSets(subPlan, node, groupingSetAnalysis);
subPlan = planAggregation(groupingSets.getSubPlan(), groupingSets.getGroupingSets(), groupingSets.getGroupIdSymbol(), analysis.getAggregates(node), coercions::get);
return planGroupingOperations(subPlan, node, groupingSets.getGroupIdSymbol(), groupingSets.getColumnOnlyGroupingSets());
}
Also used :
PatternRecognitionComponents(io.trino.sql.planner.RelationPlanner.PatternRecognitionComponents)
Arrays(java.util.Arrays)
TypeSignatureProvider.fromTypes(io.trino.sql.analyzer.TypeSignatureProvider.fromTypes)
Delete(io.trino.sql.tree.Delete)
PlanNode(io.trino.sql.planner.plan.PlanNode)
Node(io.trino.sql.tree.Node)
Offset(io.trino.sql.tree.Offset)
PlanNodeId(io.trino.sql.planner.plan.PlanNodeId)
LongLiteral(io.trino.sql.tree.LongLiteral)
Map(java.util.Map)
Union(io.trino.sql.tree.Union)
FetchFirst(io.trino.sql.tree.FetchFirst)
TableScanNode(io.trino.sql.planner.plan.TableScanNode)
ImmutableList.toImmutableList(com.google.common.collect.ImmutableList.toImmutableList)
Assignments(io.trino.sql.planner.plan.Assignments)
Set(java.util.Set)
TableSchema(io.trino.metadata.TableSchema)
SortItem(io.trino.sql.tree.SortItem)
NodeUtils.getSortItemsFromOrderBy(io.trino.sql.NodeUtils.getSortItemsFromOrderBy)
DEFAULT_FRAME(io.trino.sql.planner.plan.WindowNode.Frame.DEFAULT_FRAME)
RelationType(io.trino.sql.analyzer.RelationType)
ImmutableMap.toImmutableMap(com.google.common.collect.ImmutableMap.toImmutableMap)
AggregationNode.groupingSets(io.trino.sql.planner.plan.AggregationNode.groupingSets)
DeleteTarget(io.trino.sql.planner.plan.TableWriterNode.DeleteTarget)
PlanBuilder.newPlanBuilder(io.trino.sql.planner.PlanBuilder.newPlanBuilder)
ImmutableListMultimap(com.google.common.collect.ImmutableListMultimap)
DecimalLiteral(io.trino.sql.tree.DecimalLiteral)
ValuesNode(io.trino.sql.planner.plan.ValuesNode)
ExpressionAnalyzer.isNumericType(io.trino.sql.analyzer.ExpressionAnalyzer.isNumericType)
Session(io.trino.Session)
Iterables(com.google.common.collect.Iterables)
LimitNode(io.trino.sql.planner.plan.LimitNode)
TypeCoercion(io.trino.type.TypeCoercion)
BOOLEAN(io.trino.spi.type.BooleanType.BOOLEAN)
ArrayList(java.util.ArrayList)
LinkedHashMap(java.util.LinkedHashMap)
UpdateTarget(io.trino.sql.planner.plan.TableWriterNode.UpdateTarget)
ScopeAware.scopeAwareKey(io.trino.sql.planner.ScopeAware.scopeAwareKey)
VARCHAR(io.trino.spi.type.VarcharType.VARCHAR)
NodeRef(io.trino.sql.tree.NodeRef)
ColumnHandle(io.trino.spi.connector.ColumnHandle)
AggregationNode(io.trino.sql.planner.plan.AggregationNode)
ImmutableSet.toImmutableSet(com.google.common.collect.ImmutableSet.toImmutableSet)
VARBINARY(io.trino.spi.type.VarbinaryType.VARBINARY)
GroupingOperationRewriter.rewriteGroupingOperation(io.trino.sql.planner.GroupingOperationRewriter.rewriteGroupingOperation)
NodeUtils(io.trino.sql.NodeUtils)
INTERVAL_DAY_TIME(io.trino.type.IntervalDayTimeType.INTERVAL_DAY_TIME)
Query(io.trino.sql.tree.Query)
StringLiteral(io.trino.sql.tree.StringLiteral)
Relation(io.trino.sql.tree.Relation)
GroupingSetAnalysis(io.trino.sql.analyzer.Analysis.GroupingSetAnalysis)
Iterables.getOnlyElement(com.google.common.collect.Iterables.getOnlyElement)
SortOrder(io.trino.spi.connector.SortOrder)
AggregationNode.singleGroupingSet(io.trino.sql.planner.plan.AggregationNode.singleGroupingSet)
TableHandle(io.trino.metadata.TableHandle)
Table(io.trino.sql.tree.Table)
GroupIdNode(io.trino.sql.planner.plan.GroupIdNode)
YEAR(io.trino.sql.tree.IntervalLiteral.IntervalField.YEAR)
OffsetNode(io.trino.sql.planner.plan.OffsetNode)
ROWS(io.trino.sql.tree.WindowFrame.Type.ROWS)
NullTreatment(io.trino.sql.tree.FunctionCall.NullTreatment)
DAY(io.trino.sql.tree.IntervalLiteral.IntervalField.DAY)
MeasureDefinition(io.trino.sql.tree.MeasureDefinition)
INTERVAL_YEAR_MONTH(io.trino.type.IntervalYearMonthType.INTERVAL_YEAR_MONTH)
Aggregation(io.trino.sql.planner.plan.AggregationNode.Aggregation)
FilterNode(io.trino.sql.planner.plan.FilterNode)
LambdaArgumentDeclaration(io.trino.sql.tree.LambdaArgumentDeclaration)
Preconditions.checkArgument(com.google.common.base.Preconditions.checkArgument)
OrderingScheme.sortItemToSortOrder(io.trino.sql.planner.OrderingScheme.sortItemToSortOrder)
SelectExpression(io.trino.sql.analyzer.Analysis.SelectExpression)
GROUPS(io.trino.sql.tree.WindowFrame.Type.GROUPS)
DeleteNode(io.trino.sql.planner.plan.DeleteNode)
Update(io.trino.sql.tree.Update)
FunctionCall(io.trino.sql.tree.FunctionCall)
QuerySpecification(io.trino.sql.tree.QuerySpecification)
ImmutableSet(com.google.common.collect.ImmutableSet)
ImmutableMap(com.google.common.collect.ImmutableMap)
ResolvedFunction(io.trino.metadata.ResolvedFunction)
TypeSignatureTranslator.toSqlType(io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType)
IntervalLiteral(io.trino.sql.tree.IntervalLiteral)
RANGE(io.trino.sql.tree.WindowFrame.Type.RANGE)
VariableDefinition(io.trino.sql.tree.VariableDefinition)
PatternRecognitionNode(io.trino.sql.planner.plan.PatternRecognitionNode)
Collectors(java.util.stream.Collectors)
Sets(com.google.common.collect.Sets)
ComparisonExpression(io.trino.sql.tree.ComparisonExpression)
String.format(java.lang.String.format)
Preconditions.checkState(com.google.common.base.Preconditions.checkState)
LESS_THAN_OR_EQUAL(io.trino.sql.tree.ComparisonExpression.Operator.LESS_THAN_OR_EQUAL)
GenericLiteral(io.trino.sql.tree.GenericLiteral)
SimplePlanRewriter(io.trino.sql.planner.plan.SimplePlanRewriter)
List(java.util.List)
POSITIVE(io.trino.sql.tree.IntervalLiteral.Sign.POSITIVE)
IfExpression(io.trino.sql.tree.IfExpression)
ColumnSchema(io.trino.spi.connector.ColumnSchema)
BIGINT(io.trino.spi.type.BigintType.BIGINT)
WindowFrame(io.trino.sql.tree.WindowFrame)
Optional(java.util.Optional)
Expression(io.trino.sql.tree.Expression)
WindowNode(io.trino.sql.planner.plan.WindowNode)
DecimalType(io.trino.spi.type.DecimalType)
OrderBy(io.trino.sql.tree.OrderBy)
PlannerContext(io.trino.sql.PlannerContext)
Analysis(io.trino.sql.analyzer.Analysis)
IntStream(java.util.stream.IntStream)
FieldId(io.trino.sql.analyzer.FieldId)
UnionNode(io.trino.sql.planner.plan.UnionNode)
WindowOperation(io.trino.sql.tree.WindowOperation)
Type(io.trino.spi.type.Type)
LambdaExpression(io.trino.sql.tree.LambdaExpression)
HashMap(java.util.HashMap)
SystemSessionProperties.getMaxRecursionDepth(io.trino.SystemSessionProperties.getMaxRecursionDepth)
SortNode(io.trino.sql.planner.plan.SortNode)
Function(java.util.function.Function)
Cast(io.trino.sql.tree.Cast)
HashSet(java.util.HashSet)
ImmutableList(com.google.common.collect.ImmutableList)
Objects.requireNonNull(java.util.Objects.requireNonNull)
GREATER_THAN_OR_EQUAL(io.trino.sql.tree.ComparisonExpression.Operator.GREATER_THAN_OR_EQUAL)
ProjectNode(io.trino.sql.planner.plan.ProjectNode)
ResolvedWindow(io.trino.sql.analyzer.Analysis.ResolvedWindow)
RowsPerMatch(io.trino.sql.tree.PatternRecognitionRelation.RowsPerMatch)
Iterator(java.util.Iterator)
TRUE_LITERAL(io.trino.sql.tree.BooleanLiteral.TRUE_LITERAL)
UpdateNode(io.trino.sql.planner.plan.UpdateNode)
QualifiedName(io.trino.sql.tree.QualifiedName)
SystemSessionProperties.isSkipRedundantSort(io.trino.SystemSessionProperties.isSkipRedundantSort)
FrameBound(io.trino.sql.tree.FrameBound)
Optional(java.util.Optional)
ImmutableList.toImmutableList(com.google.common.collect.ImmutableList.toImmutableList)
ImmutableList(com.google.common.collect.ImmutableList)
GroupingSetAnalysis(io.trino.sql.analyzer.Analysis.GroupingSetAnalysis)
SelectExpression(io.trino.sql.analyzer.Analysis.SelectExpression)
ComparisonExpression(io.trino.sql.tree.ComparisonExpression)
IfExpression(io.trino.sql.tree.IfExpression)
Expression(io.trino.sql.tree.Expression)
LambdaExpression(io.trino.sql.tree.LambdaExpression)
ImmutableList.toImmutableList(com.google.common.collect.ImmutableList.toImmutableList)
ArrayList(java.util.ArrayList)
List(java.util.List)
ImmutableList(com.google.common.collect.ImmutableList)
FunctionCall(io.trino.sql.tree.FunctionCall)
LambdaExpression(io.trino.sql.tree.LambdaExpression)
Aggregations
Type (io.trino.spi.type.Type)4
TypeSignatureTranslator.toSqlType (io.trino.sql.analyzer.TypeSignatureTranslator.toSqlType)4
DecimalType (io.trino.spi.type.DecimalType)3
ComparisonExpression (io.trino.sql.tree.ComparisonExpression)3
Expression (io.trino.sql.tree.Expression)3
TypeCoercion (io.trino.type.TypeCoercion)3
Preconditions.checkArgument (com.google.common.base.Preconditions.checkArgument)2
Preconditions.checkState (com.google.common.base.Preconditions.checkState)2
ImmutableList (com.google.common.collect.ImmutableList)2
ImmutableList.toImmutableList (com.google.common.collect.ImmutableList.toImmutableList)2
ImmutableListMultimap (com.google.common.collect.ImmutableListMultimap)2
ImmutableMap (com.google.common.collect.ImmutableMap)2
ImmutableMap.toImmutableMap (com.google.common.collect.ImmutableMap.toImmutableMap)2
ImmutableSet (com.google.common.collect.ImmutableSet)2
ImmutableSet.toImmutableSet (com.google.common.collect.ImmutableSet.toImmutableSet)2
Iterables (com.google.common.collect.Iterables)2
Iterables.getOnlyElement (com.google.common.collect.Iterables.getOnlyElement)2
Sets (com.google.common.collect.Sets)2
Session (io.trino.Session)2
SystemSessionProperties.getMaxRecursionDepth (io.trino.SystemSessionProperties.getMaxRecursionDepth)2
