java.lang.Object
- io.prestosql.sql.analyzer.Analysis

```
public class Analysis
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`Analysis.AccessControlInfo`
`static class`	`Analysis.Create`
`static class`	`Analysis.GroupingSetAnalysis`
`static class`	`Analysis.Insert`
`static class`	`Analysis.JoinUsingAnalysis`
`static class`	`Analysis.RefreshMaterializedViewAnalysis`
`static class`	`Analysis.SelectExpression`
`static class`	`Analysis.UnnestAnalysis`

Constructor Summary

Constructors
Constructor Description

Analysis(Statement root, Map<NodeRef<Parameter>,Expression> parameters, boolean isDescribe)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addCoercion(Expression expression, Type type, boolean isTypeOnlyCoercion)`
`void`	`addCoercions(Map<NodeRef<Expression>,Type> coercions, Set<NodeRef<Expression>> typeOnlyCoercions)`
`void`	`addColumnMask(Table table, String column, Expression mask)`
`void`	`addColumnReferences(Map<NodeRef<Expression>,ResolvedField> columnReferences)`
`void`	`addEmptyColumnReferencesForTable(AccessControl accessControl, Identity identity, QualifiedObjectName table)`
`void`	`addLambdaArgumentReferences(Map<NodeRef<Identifier>,LambdaArgumentDeclaration> lambdaArgumentReferences)`
`void`	`addReferencedFields(com.google.common.collect.Multimap<NodeRef<Node>,Field> references)`
`void`	`addRelationCoercion(Relation relation, Type[] types)`
`void`	`addResolvedFunction(FunctionCall node, ResolvedFunction function, String authorization)`
`void`	`addRowFilter(Table table, Expression filter)`
`void`	`addTableColumnReferences(AccessControl accessControl, Identity identity, com.google.common.collect.Multimap<QualifiedObjectName,String> tableColumnMap)`
`void`	`addTypes(Map<NodeRef<Expression>,Type> types)`
`Scope`	`getAccessControlScope(Table node)`
`List<FunctionCall>`	`getAggregates(QuerySpecification query)`
`Optional<TableHandle>`	`getAnalyzeTarget()`
`Type`	`getCoercion(Expression expression)`
`Map<NodeRef<Expression>,Type>`	`getCoercions()`
`ColumnHandle`	`getColumn(Field field)`
`Map<String,List<Expression>>`	`getColumnMasks(Table table)`
`Map<NodeRef<Expression>,ResolvedField>`	`getColumnReferenceFields()`
`Set<NodeRef<Expression>>`	`getColumnReferences()`
`Optional<Analysis.Create>`	`getCreate()`
`List<ExistsPredicate>`	`getExistsSubqueries(Node node)`
`Optional<Scope>`	`getExpandableBaseScope(Node node)`
`List<GroupingOperation>`	`getGroupingOperations(QuerySpecification querySpecification)`
`Analysis.GroupingSetAnalysis`	`getGroupingSets(QuerySpecification node)`
`Expression`	`getHaving(QuerySpecification query)`
`Scope`	`getImplicitFromScope(QuerySpecification node)`
`List<InPredicate>`	`getInPredicateSubqueries(Node node)`
`Optional<Analysis.Insert>`	`getInsert()`
`Expression`	`getJoinCriteria(Join join)`
`Analysis.JoinUsingAnalysis`	`getJoinUsing(Join node)`
`LambdaArgumentDeclaration`	`getLambdaArgumentReference(Identifier identifier)`
`Map<NodeRef<Identifier>,LambdaArgumentDeclaration>`	`getLambdaArgumentReferences()`
`OptionalLong`	`getLimit(Node node)`
`Query`	`getNamedQuery(Table table)`
`long`	`getOffset(Offset node)`
`List<Expression>`	`getOrderByAggregates(OrderBy node)`
`List<Expression>`	`getOrderByExpressions(Node node)`
`List<FunctionCall>`	`getOrderByWindowFunctions(OrderBy query)`
`RelationType`	`getOutputDescriptor()`
`RelationType`	`getOutputDescriptor(Node node)`
`Map<NodeRef<Parameter>,Expression>`	`getParameters()`
`List<QuantifiedComparisonExpression>`	`getQuantifiedComparisonSubqueries(Node node)`
`Node`	`getRecursiveReference(Query query)`
`List<TableInfo>`	`getReferencedTables()`
`Optional<Analysis.RefreshMaterializedViewAnalysis>`	`getRefreshMaterializedView()`
`List<Type>`	`getRelationCoercion(Relation relation)`
`ResolvedField`	`getResolvedField(Expression expression)`
`ResolvedFunction`	`getResolvedFunction(FunctionCall function)`
`Scope`	`getRootScope()`
`List<RoutineInfo>`	`getRoutines()`
`List<Expression>`	`getRowFilters(Table node)`
`FieldReference`	`getRowIdField(Table table)`
`double`	`getSampleRatio(SampledRelation relation)`
`List<SubqueryExpression>`	`getScalarSubqueries(Node node)`
`Scope`	`getScope(Node node)`
`List<Field>`	`getSelectAllResultFields(AllColumns node)`
`List<Analysis.SelectExpression>`	`getSelectExpressions(Node node)`
`Statement`	`getStatement()`
`Map<Analysis.AccessControlInfo,Map<QualifiedObjectName,Set<String>>>`	`getTableColumnReferences()`
`TableHandle`	`getTableHandle(Table table)`
`Collection<TableHandle>`	`getTables()`
`Optional<Output>`	`getTarget()`
`Type`	`getType(Expression expression)`
`Set<NodeRef<Expression>>`	`getTypeOnlyCoercions()`
`Map<NodeRef<Expression>,Type>`	`getTypes()`
`Analysis.UnnestAnalysis`	`getUnnest(Unnest node)`
`String`	`getUpdateType()`
`Expression`	`getWhere(QuerySpecification node)`
`List<FunctionCall>`	`getWindowFunctions(QuerySpecification query)`
`boolean`	`hasColumnMask(QualifiedObjectName table, String column, String identity)`
`boolean`	`hasRowFilter(QualifiedObjectName table, String identity)`
`boolean`	`hasTableInView(Table tableReference)`
`boolean`	`isAggregation(QuerySpecification node)`
`boolean`	`isColumnReference(Expression expression)`
`boolean`	`isDescribe()`
`boolean`	`isExpandableQuery(Query query)`
`boolean`	`isOrderByRedundant(OrderBy orderBy)`
`boolean`	`isSkipMaterializedViewRefresh()`
`boolean`	`isTypeOnlyCoercion(Expression expression)`
`void`	`markRedundantOrderBy(OrderBy orderBy)`
`void`	`recordSubqueries(Node node, ExpressionAnalysis expressionAnalysis)`
`void`	`registerExpandableQuery(Query query, Node recursiveReference)`
`void`	`registerNamedQuery(Table tableReference, Query query)`
`void`	`registerTable(Table table, Optional<TableHandle> handle, QualifiedObjectName name, List<ViewExpression> filters, Map<Field,List<ViewExpression>> columnMasks, String authorization, Scope accessControlScope)`
`void`	`registerTableForColumnMasking(QualifiedObjectName table, String column, String identity)`
`void`	`registerTableForRowFiltering(QualifiedObjectName table, String identity)`
`void`	`registerTableForView(Table tableReference)`
`void`	`resetUpdateType()`
`void`	`setAggregates(QuerySpecification node, List<FunctionCall> aggregates)`
`void`	`setAnalyzeTarget(TableHandle analyzeTarget)`
`void`	`setColumn(Field field, ColumnHandle handle)`
`void`	`setCreate(Analysis.Create create)`
`void`	`setExpandableBaseScope(Node node, Scope scope)`
`void`	`setGroupingOperations(QuerySpecification querySpecification, List<GroupingOperation> groupingOperations)`
`void`	`setGroupingSets(QuerySpecification node, Analysis.GroupingSetAnalysis groupingSets)`
`void`	`setHaving(QuerySpecification node, Expression expression)`
`void`	`setImplicitFromScope(QuerySpecification node, Scope scope)`
`void`	`setInsert(Analysis.Insert insert)`
`void`	`setJoinCriteria(Join node, Expression criteria)`
`void`	`setJoinUsing(Join node, Analysis.JoinUsingAnalysis analysis)`
`void`	`setLimit(Node node, long rowCount)`
`void`	`setLimit(Node node, OptionalLong rowCount)`
`void`	`setOffset(Offset node, long rowCount)`
`void`	`setOrderByAggregates(OrderBy node, List<Expression> aggregates)`
`void`	`setOrderByExpressions(Node node, List<Expression> items)`
`void`	`setOrderByWindowFunctions(OrderBy node, List<FunctionCall> functions)`
`void`	`setRefreshMaterializedView(Analysis.RefreshMaterializedViewAnalysis refreshMaterializedView)`
`void`	`setRowIdField(Table table, FieldReference field)`
`void`	`setSampleRatio(SampledRelation relation, double ratio)`
`void`	`setScope(Node node, Scope scope)`
`void`	`setSelectAllResultFields(AllColumns node, List<Field> expressions)`
`void`	`setSelectExpressions(Node node, List<Analysis.SelectExpression> expressions)`
`void`	`setSkipMaterializedViewRefresh(boolean skipMaterializedViewRefresh)`
`void`	`setUnnest(Unnest node, Analysis.UnnestAnalysis analysis)`
`void`	`setUpdateType(String updateType, QualifiedObjectName target)`
`void`	`setWhere(Node node, Expression expression)`
`void`	`setWindowFunctions(QuerySpecification node, List<FunctionCall> functions)`
`Optional<Scope>`	`tryGetScope(Node node)`
`void`	`unregisterTableForColumnMasking(QualifiedObjectName table, String column, String identity)`
`void`	`unregisterTableForRowFiltering(QualifiedObjectName table, String identity)`
`void`	`unregisterTableForView()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Analysis

public Analysis(@Nullable
                Statement root,
                Map<NodeRef<Parameter>,Expression> parameters,
                boolean isDescribe)

Method Detail

getStatement
```
public Statement getStatement()
```

getUpdateType
```
public String getUpdateType()
```

getTarget
```
public Optional<Output> getTarget()
```

setUpdateType

public void setUpdateType(String updateType,
                          QualifiedObjectName target)

resetUpdateType
```
public void resetUpdateType()
```

isSkipMaterializedViewRefresh

public boolean isSkipMaterializedViewRefresh()

setSkipMaterializedViewRefresh

public void setSkipMaterializedViewRefresh(boolean skipMaterializedViewRefresh)

setAggregates

public void setAggregates(QuerySpecification node,
                          List<FunctionCall> aggregates)

getAggregates

public List<FunctionCall> getAggregates(QuerySpecification query)

setOrderByAggregates

public void setOrderByAggregates(OrderBy node,
                                 List<Expression> aggregates)

getOrderByAggregates

public List<Expression> getOrderByAggregates(OrderBy node)

getTypes

public Map<NodeRef<Expression>,Type> getTypes()

getType

public Type getType(Expression expression)

getRelationCoercion

public List<Type> getRelationCoercion(Relation relation)

addRelationCoercion

public void addRelationCoercion(Relation relation,
                                Type[] types)

getCoercions

public Map<NodeRef<Expression>,Type> getCoercions()

getTypeOnlyCoercions

public Set<NodeRef<Expression>> getTypeOnlyCoercions()

getCoercion

public Type getCoercion(Expression expression)

addLambdaArgumentReferences

public void addLambdaArgumentReferences(Map<NodeRef<Identifier>,LambdaArgumentDeclaration> lambdaArgumentReferences)

getLambdaArgumentReference

public LambdaArgumentDeclaration getLambdaArgumentReference(Identifier identifier)

getLambdaArgumentReferences

public Map<NodeRef<Identifier>,LambdaArgumentDeclaration> getLambdaArgumentReferences()

setGroupingSets

public void setGroupingSets(QuerySpecification node,
                            Analysis.GroupingSetAnalysis groupingSets)

isAggregation

public boolean isAggregation(QuerySpecification node)

isTypeOnlyCoercion

public boolean isTypeOnlyCoercion(Expression expression)

getGroupingSets

public Analysis.GroupingSetAnalysis getGroupingSets(QuerySpecification node)

setWhere

public void setWhere(Node node,
                     Expression expression)

getWhere

public Expression getWhere(QuerySpecification node)

setOrderByExpressions

public void setOrderByExpressions(Node node,
                                  List<Expression> items)

getOrderByExpressions

public List<Expression> getOrderByExpressions(Node node)

setOffset

public void setOffset(Offset node,
                      long rowCount)

getOffset

public long getOffset(Offset node)

setLimit

public void setLimit(Node node,
                     OptionalLong rowCount)

setLimit

public void setLimit(Node node,
                     long rowCount)

getLimit

public OptionalLong getLimit(Node node)

setSelectAllResultFields

public void setSelectAllResultFields(AllColumns node,
                                     List<Field> expressions)

getSelectAllResultFields

public List<Field> getSelectAllResultFields(AllColumns node)

setSelectExpressions

public void setSelectExpressions(Node node,
                                 List<Analysis.SelectExpression> expressions)

getSelectExpressions

public List<Analysis.SelectExpression> getSelectExpressions(Node node)

setHaving

public void setHaving(QuerySpecification node,
                      Expression expression)

setJoinCriteria

public void setJoinCriteria(Join node,
                            Expression criteria)

getJoinCriteria

public Expression getJoinCriteria(Join join)

recordSubqueries

public void recordSubqueries(Node node,
                             ExpressionAnalysis expressionAnalysis)

getInPredicateSubqueries

public List<InPredicate> getInPredicateSubqueries(Node node)

getScalarSubqueries

public List<SubqueryExpression> getScalarSubqueries(Node node)

getExistsSubqueries

public List<ExistsPredicate> getExistsSubqueries(Node node)

getQuantifiedComparisonSubqueries

public List<QuantifiedComparisonExpression> getQuantifiedComparisonSubqueries(Node node)

setWindowFunctions

public void setWindowFunctions(QuerySpecification node,
                               List<FunctionCall> functions)

getWindowFunctions

public List<FunctionCall> getWindowFunctions(QuerySpecification query)

setOrderByWindowFunctions

public void setOrderByWindowFunctions(OrderBy node,
                                      List<FunctionCall> functions)

getOrderByWindowFunctions

public List<FunctionCall> getOrderByWindowFunctions(OrderBy query)

addColumnReferences

public void addColumnReferences(Map<NodeRef<Expression>,ResolvedField> columnReferences)

getScope
```
public Scope getScope(Node node)
```

tryGetScope

public Optional<Scope> tryGetScope(Node node)

getRootScope
```
public Scope getRootScope()
```

setScope

public void setScope(Node node,
                     Scope scope)

getOutputDescriptor

public RelationType getOutputDescriptor()

getOutputDescriptor

public RelationType getOutputDescriptor(Node node)

getTableHandle

public TableHandle getTableHandle(Table table)

getTables

public Collection<TableHandle> getTables()

registerTable

public void registerTable(Table table,
                          Optional<TableHandle> handle,
                          QualifiedObjectName name,
                          List<ViewExpression> filters,
                          Map<Field,List<ViewExpression>> columnMasks,
                          String authorization,
                          Scope accessControlScope)

getResolvedFunction

public ResolvedFunction getResolvedFunction(FunctionCall function)

addResolvedFunction

public void addResolvedFunction(FunctionCall node,
                                ResolvedFunction function,
                                String authorization)

getColumnReferences

public Set<NodeRef<Expression>> getColumnReferences()

getColumnReferenceFields

public Map<NodeRef<Expression>,ResolvedField> getColumnReferenceFields()

getResolvedField

public ResolvedField getResolvedField(Expression expression)

isColumnReference

public boolean isColumnReference(Expression expression)

addTypes

public void addTypes(Map<NodeRef<Expression>,Type> types)

addCoercion

public void addCoercion(Expression expression,
                        Type type,
                        boolean isTypeOnlyCoercion)

addCoercions

public void addCoercions(Map<NodeRef<Expression>,Type> coercions,
                         Set<NodeRef<Expression>> typeOnlyCoercions)

getHaving

public Expression getHaving(QuerySpecification query)

setColumn

public void setColumn(Field field,
                      ColumnHandle handle)

getColumn

public ColumnHandle getColumn(Field field)

getAnalyzeTarget

public Optional<TableHandle> getAnalyzeTarget()

setAnalyzeTarget

public void setAnalyzeTarget(TableHandle analyzeTarget)

setCreate

public void setCreate(Analysis.Create create)

getCreate

public Optional<Analysis.Create> getCreate()

setInsert

public void setInsert(Analysis.Insert insert)

getInsert

public Optional<Analysis.Insert> getInsert()

setRefreshMaterializedView

public void setRefreshMaterializedView(Analysis.RefreshMaterializedViewAnalysis refreshMaterializedView)

getRefreshMaterializedView

public Optional<Analysis.RefreshMaterializedViewAnalysis> getRefreshMaterializedView()

getNamedQuery

public Query getNamedQuery(Table table)

registerNamedQuery

public void registerNamedQuery(Table tableReference,
                               Query query)

registerExpandableQuery

public void registerExpandableQuery(Query query,
                                    Node recursiveReference)

isExpandableQuery

public boolean isExpandableQuery(Query query)

getRecursiveReference

public Node getRecursiveReference(Query query)

setExpandableBaseScope

public void setExpandableBaseScope(Node node,
                                   Scope scope)

getExpandableBaseScope

public Optional<Scope> getExpandableBaseScope(Node node)

registerTableForView

public void registerTableForView(Table tableReference)

unregisterTableForView
```
public void unregisterTableForView()
```

hasTableInView

public boolean hasTableInView(Table tableReference)

setSampleRatio

public void setSampleRatio(SampledRelation relation,
                           double ratio)

getSampleRatio

public double getSampleRatio(SampledRelation relation)

setGroupingOperations

public void setGroupingOperations(QuerySpecification querySpecification,
                                  List<GroupingOperation> groupingOperations)

getGroupingOperations

public List<GroupingOperation> getGroupingOperations(QuerySpecification querySpecification)

getParameters

public Map<NodeRef<Parameter>,Expression> getParameters()

isDescribe
```
public boolean isDescribe()
```

setJoinUsing

public void setJoinUsing(Join node,
                         Analysis.JoinUsingAnalysis analysis)

getJoinUsing

public Analysis.JoinUsingAnalysis getJoinUsing(Join node)

setUnnest

public void setUnnest(Unnest node,
                      Analysis.UnnestAnalysis analysis)

getUnnest

public Analysis.UnnestAnalysis getUnnest(Unnest node)

addTableColumnReferences

public void addTableColumnReferences(AccessControl accessControl,
                                     Identity identity,
                                     com.google.common.collect.Multimap<QualifiedObjectName,String> tableColumnMap)

addEmptyColumnReferencesForTable

public void addEmptyColumnReferencesForTable(AccessControl accessControl,
                                             Identity identity,
                                             QualifiedObjectName table)

addReferencedFields

public void addReferencedFields(com.google.common.collect.Multimap<NodeRef<Node>,Field> references)

getTableColumnReferences

public Map<Analysis.AccessControlInfo,Map<QualifiedObjectName,Set<String>>> getTableColumnReferences()

markRedundantOrderBy

public void markRedundantOrderBy(OrderBy orderBy)

isOrderByRedundant

public boolean isOrderByRedundant(OrderBy orderBy)

hasRowFilter

public boolean hasRowFilter(QualifiedObjectName table,
                            String identity)

registerTableForRowFiltering

public void registerTableForRowFiltering(QualifiedObjectName table,
                                         String identity)

unregisterTableForRowFiltering

public void unregisterTableForRowFiltering(QualifiedObjectName table,
                                           String identity)

addRowFilter

public void addRowFilter(Table table,
                         Expression filter)

getRowFilters

public List<Expression> getRowFilters(Table node)

hasColumnMask

public boolean hasColumnMask(QualifiedObjectName table,
                             String column,
                             String identity)

registerTableForColumnMasking

public void registerTableForColumnMasking(QualifiedObjectName table,
                                          String column,
                                          String identity)

unregisterTableForColumnMasking

public void unregisterTableForColumnMasking(QualifiedObjectName table,
                                            String column,
                                            String identity)

addColumnMask

public void addColumnMask(Table table,
                          String column,
                          Expression mask)

getColumnMasks

public Map<String,List<Expression>> getColumnMasks(Table table)

getReferencedTables

public List<TableInfo> getReferencedTables()

getRoutines

public List<RoutineInfo> getRoutines()

setRowIdField

public void setRowIdField(Table table,
                          FieldReference field)

getRowIdField

public FieldReference getRowIdField(Table table)

getAccessControlScope

public Scope getAccessControlScope(Table node)

setImplicitFromScope

public void setImplicitFromScope(QuerySpecification node,
                                 Scope scope)

getImplicitFromScope

public Scope getImplicitFromScope(QuerySpecification node)

Class Analysis

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Analysis

Method Detail

getStatement

getUpdateType

getTarget

setUpdateType

resetUpdateType

isSkipMaterializedViewRefresh

setSkipMaterializedViewRefresh

setAggregates

getAggregates

setOrderByAggregates

getOrderByAggregates

getTypes

getType

getRelationCoercion

addRelationCoercion

getCoercions

getTypeOnlyCoercions

getCoercion

addLambdaArgumentReferences

getLambdaArgumentReference

getLambdaArgumentReferences

setGroupingSets

isAggregation

isTypeOnlyCoercion

getGroupingSets

setWhere

getWhere

setOrderByExpressions

getOrderByExpressions

setOffset

getOffset

setLimit

setLimit

getLimit

setSelectAllResultFields

getSelectAllResultFields

setSelectExpressions

getSelectExpressions

setHaving

setJoinCriteria

getJoinCriteria

recordSubqueries

getInPredicateSubqueries

getScalarSubqueries

getExistsSubqueries

getQuantifiedComparisonSubqueries

setWindowFunctions

getWindowFunctions

setOrderByWindowFunctions

getOrderByWindowFunctions

addColumnReferences

getScope

tryGetScope

getRootScope

setScope

getOutputDescriptor

getOutputDescriptor

getTableHandle

getTables

registerTable

getResolvedFunction

addResolvedFunction

getColumnReferences

getColumnReferenceFields

getResolvedField

isColumnReference

addTypes

addCoercion

addCoercions

getHaving

setColumn

getColumn