java.lang.Object
- io.trino.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.PredicateCoercions`	Analysis for predicates such as `x IN (subquery)` or `x = SOME (subquery)`
`static class`	`Analysis.Range`
`static class`	`Analysis.RefreshMaterializedViewAnalysis`
`static class`	`Analysis.ResolvedWindow`
`static class`	`Analysis.SelectExpression`
`static class`	`Analysis.SourceColumn`
`static class`	`Analysis.SubqueryAnalysis`
`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, Map<NodeRef<Expression>,Type> sortKeyCoercionsForFrameBoundCalculation, Map<NodeRef<Expression>,Type> sortKeyCoercionsForFrameBoundComparison)`
`void`	`addColumnMask(Table table, String column, Expression mask)`
`void`	`addColumnReferences(Map<NodeRef<Expression>,ResolvedField> columnReferences)`
`void`	`addEmptyColumnReferencesForTable(AccessControl accessControl, Identity identity, QualifiedObjectName table)`
`void`	`addExpressionFields(Expression expression, Collection<Field> fields)`
`void`	`addFrameBoundCalculations(Map<NodeRef<Expression>,ResolvedFunction> frameBoundCalculations)`
`void`	`addLabelDereferences(Map<NodeRef<DereferenceExpression>,ExpressionAnalyzer.LabelPrefixedReference> dereferences)`
`void`	`addLambdaArgumentReferences(Map<NodeRef<Identifier>,LambdaArgumentDeclaration> lambdaArgumentReferences)`
`void`	`addPatternRecognitionFunctions(Set<NodeRef<FunctionCall>> functions)`
`void`	`addPredicateCoercions(Map<NodeRef<Expression>,Analysis.PredicateCoercions> coercions)`
`void`	`addRelationCoercion(Relation relation, Type[] types)`
`void`	`addResolvedFunction(FunctionCall node, ResolvedFunction function, String authorization)`
`void`	`addRowFilter(Table table, Expression filter)`
`void`	`addSourceColumns(Field field, Set<Analysis.SourceColumn> sourceColumn)`
`void`	`addTableColumnReferences(AccessControl accessControl, Identity identity, com.google.common.collect.Multimap<QualifiedObjectName,String> tableColumnMap)`
`void`	`addTypes(Map<NodeRef<Expression>,Type> types)`
`void`	`addWindowDefinition(QuerySpecification query, CanonicalizationAware<Identifier> name, Analysis.ResolvedWindow window)`
`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()`
`Optional<Scope>`	`getExpandableBaseScope(Node node)`
`Set<Analysis.SourceColumn>`	`getExpressionSourceColumns(Expression expression)`
`ResolvedFunction`	`getFrameBoundCalculation(Expression frameOffset)`
`List<GroupingOperation>`	`getGroupingOperations(QuerySpecification querySpecification)`
`Analysis.GroupingSetAnalysis`	`getGroupingSets(QuerySpecification node)`
`Expression`	`getHaving(QuerySpecification query)`
`Scope`	`getImplicitFromScope(QuerySpecification node)`
`Optional<Analysis.Insert>`	`getInsert()`
`Expression`	`getJoinCriteria(Join join)`
`Analysis.JoinUsingAnalysis`	`getJoinUsing(Join node)`
`ExpressionAnalyzer.LabelPrefixedReference`	`getLabelDereference(DereferenceExpression expression)`
`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()`
`Analysis.PredicateCoercions`	`getPredicateCoercions(Expression expression)`
`Analysis.Range`	`getRange(RangeQuantifier quantifier)`
`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)`
`Scope`	`getScope(Node node)`
`List<Field>`	`getSelectAllResultFields(AllColumns node)`
`List<Analysis.SelectExpression>`	`getSelectExpressions(Node node)`
`Type`	`getSortKeyCoercionForFrameBoundCalculation(Expression frameOffset)`
`Type`	`getSortKeyCoercionForFrameBoundComparison(Expression frameOffset)`
`Set<Analysis.SourceColumn>`	`getSourceColumns(Field field)`
`Statement`	`getStatement()`
`Analysis.SubqueryAnalysis`	`getSubqueries(Node node)`
`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()`
`Set<String>`	`getUndefinedLabels(PatternRecognitionRelation relation)`
`Analysis.UnnestAnalysis`	`getUnnest(Unnest node)`
`Optional<List<ColumnMetadata>>`	`getUpdatedColumns()`
`String`	`getUpdateType()`
`Expression`	`getWhere(QuerySpecification node)`
`Analysis.ResolvedWindow`	`getWindow(FunctionCall functionCall)`
`Analysis.ResolvedWindow`	`getWindowDefinition(QuerySpecification query, CanonicalizationAware<Identifier> name)`
`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`	`isPatternRecognitionFunction(FunctionCall functionCall)`
`boolean`	`isSkipMaterializedViewRefresh()`
`boolean`	`isTypeOnlyCoercion(Expression expression)`
`boolean`	`isUpdateTarget(Table table)`
`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`	`setRange(RangeQuantifier quantifier, Analysis.Range range)`
`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`	`setUndefinedLabels(PatternRecognitionRelation relation, Set<String> labels)`
`void`	`setUnnest(Unnest node, Analysis.UnnestAnalysis analysis)`
`void`	`setUpdatedColumns(List<ColumnMetadata> updatedColumns)`
`void`	`setUpdateType(String updateType, QualifiedObjectName targetName, Optional<Table> targetTable, Optional<List<OutputColumn>> targetColumns)`
`void`	`setWhere(Node node, Expression expression)`
`void`	`setWindow(FunctionCall functionCall, Analysis.ResolvedWindow window)`
`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 targetName,
                          Optional<Table> targetTable,
                          Optional<List<OutputColumn>> targetColumns)

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

isUpdateTarget

public boolean isUpdateTarget(Table table)

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)

getSubqueries

public Analysis.SubqueryAnalysis getSubqueries(Node node)

addWindowDefinition

public void addWindowDefinition(QuerySpecification query,
                                CanonicalizationAware<Identifier> name,
                                Analysis.ResolvedWindow window)

getWindowDefinition

public Analysis.ResolvedWindow getWindowDefinition(QuerySpecification query,
                                                   CanonicalizationAware<Identifier> name)

setWindow

public void setWindow(FunctionCall functionCall,
                      Analysis.ResolvedWindow window)

getWindow

public Analysis.ResolvedWindow getWindow(FunctionCall functionCall)

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,
                         Map<NodeRef<Expression>,Type> sortKeyCoercionsForFrameBoundCalculation,
                         Map<NodeRef<Expression>,Type> sortKeyCoercionsForFrameBoundComparison)

getSortKeyCoercionForFrameBoundCalculation

public Type getSortKeyCoercionForFrameBoundCalculation(Expression frameOffset)

getSortKeyCoercionForFrameBoundComparison

public Type getSortKeyCoercionForFrameBoundComparison(Expression frameOffset)

addFrameBoundCalculations

public void addFrameBoundCalculations(Map<NodeRef<Expression>,ResolvedFunction> frameBoundCalculations)

getFrameBoundCalculation

public ResolvedFunction getFrameBoundCalculation(Expression frameOffset)

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()

setUpdatedColumns

public void setUpdatedColumns(List<ColumnMetadata> updatedColumns)

getUpdatedColumns

public Optional<List<ColumnMetadata>> getUpdatedColumns()

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)

addLabelDereferences

public void addLabelDereferences(Map<NodeRef<DereferenceExpression>,ExpressionAnalyzer.LabelPrefixedReference> dereferences)

getLabelDereference

public ExpressionAnalyzer.LabelPrefixedReference getLabelDereference(DereferenceExpression expression)

addPatternRecognitionFunctions

public void addPatternRecognitionFunctions(Set<NodeRef<FunctionCall>> functions)

isPatternRecognitionFunction

public boolean isPatternRecognitionFunction(FunctionCall functionCall)

setRange

public void setRange(RangeQuantifier quantifier,
                     Analysis.Range range)

getRange

public Analysis.Range getRange(RangeQuantifier quantifier)

setUndefinedLabels

public void setUndefinedLabels(PatternRecognitionRelation relation,
                               Set<String> labels)

getUndefinedLabels

public Set<String> getUndefinedLabels(PatternRecognitionRelation relation)

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()

addSourceColumns

public void addSourceColumns(Field field,
                             Set<Analysis.SourceColumn> sourceColumn)

getSourceColumns

public Set<Analysis.SourceColumn> getSourceColumns(Field field)

addExpressionFields

public void addExpressionFields(Expression expression,
                                Collection<Field> fields)

getExpressionSourceColumns

public Set<Analysis.SourceColumn> getExpressionSourceColumns(Expression expression)

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)

addPredicateCoercions

public void addPredicateCoercions(Map<NodeRef<Expression>,Analysis.PredicateCoercions> coercions)

getPredicateCoercions

public Analysis.PredicateCoercions getPredicateCoercions(Expression expression)

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

isUpdateTarget

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

getSubqueries

addWindowDefinition

getWindowDefinition

setWindow

getWindow

setWindowFunctions

getWindowFunctions

setOrderByWindowFunctions

getOrderByWindowFunctions

addColumnReferences

getScope

tryGetScope

getRootScope

setScope

getOutputDescriptor

getOutputDescriptor

getTableHandle

getTables

registerTable

getResolvedFunction

addResolvedFunction

getColumnReferences

getColumnReferenceFields

getResolvedField

isColumnReference

addTypes

addCoercion

addCoercions

getSortKeyCoercionForFrameBoundCalculation