Package io.trino.sql.analyzer

Class Analysis

java.lang.Object

io.trino.sql.analyzer.Analysis

public class Analysis
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static final class	Analysis.AccessControlInfo
static final class	Analysis.Create
static class	Analysis.GroupingSetAnalysis
static final class	Analysis.Insert
static final class	Analysis.JoinUsingAnalysis
static final record	Analysis.JsonTableAnalysis
static class	Analysis.MergeAnalysis
static class	Analysis.PredicateCoercions	Analysis for predicates such as x IN (subquery) or x = SOME (subquery)
static class	Analysis.Range
static final class	Analysis.RefreshMaterializedViewAnalysis
static class	Analysis.ResolvedWindow
static final class	Analysis.SelectExpression
static class	Analysis.SourceColumn
static class	Analysis.SubqueryAnalysis
static class	Analysis.TableArgumentAnalysis
static class	Analysis.TableFunctionInvocationAnalysis
static class	Analysis.UnnestAnalysis

Constructor Summary

Constructors

Constructor	Description
Analysis(Statement root, Map<NodeRef<Parameter>,Expression> parameters, QueryType queryType)

Method Summary

Modifier and Type	Method	Description
void	addAliased(Relation relation)
void	addCheckConstraints(Table table, Expression constraint)
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	addJsonTableAnalysis(JsonTable jsonTable, Analysis.JsonTableAnalysis analysis)
void	addLabelDereferences(Map<NodeRef<DereferenceExpression>,ExpressionAnalyzer.LabelPrefixedReference> dereferences)
void	addLambdaArgumentReferences(Map<NodeRef<Identifier>,LambdaArgumentDeclaration> lambdaArgumentReferences)
void	addPatternRecognitionFunctions(Set<NodeRef<FunctionCall>> functions)
void	addPolymorphicTableFunction(TableFunctionInvocation invocation)
void	addPredicateCoercions(Map<NodeRef<Expression>,Analysis.PredicateCoercions> coercions)
void	addRelationCoercion(Relation relation, Type[] types)
void	addResolvedFunction(Node 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	addType(Expression expression, Type type)
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<AnalyzeMetadata>	getAnalyzeMetadata()
List<Expression>	getCheckConstraints(Table node)
Type	getCoercion(Expression expression)
Map<NodeRef<Expression>,Type>	getCoercions()
ColumnHandle	getColumn(Field field)
Map<String,Expression>	getColumnMasks(Table table)
Map<NodeRef<Expression>,ResolvedField>	getColumnReferenceFields()
Set<NodeRef<Expression>>	getColumnReferences()
Optional<Analysis.Create>	getCreate()
Optional<QualifiedObjectName>	getDelegatedRefreshMaterializedView()
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)
ResolvedFunction	getJsonInputFunction(Expression expression)
ResolvedFunction	getJsonOutputFunction(Node node)
JsonPathAnalyzer.JsonPathAnalysis	getJsonPathAnalysis(Node node)
Analysis.JsonTableAnalysis	getJsonTableAnalysis(JsonTable jsonTable)
ExpressionAnalyzer.LabelPrefixedReference	getLabelDereference(DereferenceExpression expression)
LambdaArgumentDeclaration	getLambdaArgumentReference(Identifier identifier)
Map<NodeRef<Identifier>,LambdaArgumentDeclaration>	getLambdaArgumentReferences()
OptionalLong	getLimit(Node node)
MeasureDefinition	getMeasureDefinition(WindowOperation measure)
Optional<Analysis.MergeAnalysis>	getMergeAnalysis()
Query	getNamedQuery(Table table)
long	getOffset(Offset node)
List<Expression>	getOrderByAggregates(OrderBy node)
List<Expression>	getOrderByExpressions(Node node)
List<FunctionCall>	getOrderByWindowFunctions(OrderBy query)
List<WindowOperation>	getOrderByWindowMeasures(OrderBy node)
RelationType	getOutputDescriptor()
RelationType	getOutputDescriptor(Node node)
Map<NodeRef<Parameter>,Expression>	getParameters()
Analysis.PredicateCoercions	getPredicateCoercions(Expression expression)
QueryType	getQueryType()
Analysis.Range	getRange(RangeQuantifier quantifier)
Node	getRecursiveReference(Query query)
List<TableInfo>	getReferencedTables()
Optional<Analysis.RefreshMaterializedViewAnalysis>	getRefreshMaterializedView()
List<Type>	getRelationCoercion(Relation relation)
QualifiedName	getRelationName(Relation relation)
ResolvedField	getResolvedField(Expression expression)
ResolvedFunction	getResolvedFunction(Node node)
Set<ResolvedFunction>	getResolvedFunctions()
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()
Optional<TableExecuteHandle>	getTableExecuteHandle()
Analysis.TableFunctionInvocationAnalysis	getTableFunctionAnalysis(TableFunctionInvocation node)
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(RowPattern pattern)
Analysis.UnnestAnalysis	getUnnest(Unnest node)
Optional<List<ColumnSchema>>	getUpdatedColumns()
String	getUpdateType()
Expression	getWhere(QuerySpecification node)
Analysis.ResolvedWindow	getWindow(Node node)
Analysis.ResolvedWindow	getWindowDefinition(QuerySpecification query, CanonicalizationAware<Identifier> name)
List<FunctionCall>	getWindowFunctions(QuerySpecification query)
List<WindowOperation>	getWindowMeasures(QuerySpecification node)
boolean	hasColumnMask(QualifiedObjectName table, String column, String identity)
boolean	hasRowFilter(QualifiedObjectName table, String identity)
boolean	hasTableInView(Table tableReference)
boolean	isAggregation(QuerySpecification node)
boolean	isAliased(Relation relation)
boolean	isColumnReference(Expression expression)
boolean	isDescribe()
boolean	isExpandableQuery(Query query)
boolean	isOrderByRedundant(OrderBy orderBy)
boolean	isPatternAggregation(FunctionCall function)
boolean	isPatternRecognitionFunction(FunctionCall functionCall)
boolean	isPolymorphicTableFunction(TableFunctionInvocation invocation)
boolean	isSkipMaterializedViewRefresh()
boolean	isTableExecuteReadsData()
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, String authorization, Scope accessControlScope)
void	registerTableForColumnMasking(QualifiedObjectName table, String column, String identity)
void	registerTableForRowFiltering(QualifiedObjectName table, String identity)
void	registerTableForView(Table tableReference)
void	setAggregates(QuerySpecification node, List<FunctionCall> aggregates)
void	setAnalyzeMetadata(AnalyzeMetadata analyzeMetadata)
void	setColumn(Field field, ColumnHandle handle)
void	setCreate(Analysis.Create create)
void	setDelegatedRefreshMaterializedView(QualifiedObjectName viewName)
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	setJsonInputFunctions(Map<NodeRef<Expression>,ResolvedFunction> functions)
void	setJsonOutputFunctions(Map<NodeRef<Node>,ResolvedFunction> functions)
void	setJsonPathAnalyses(Map<NodeRef<Node>,JsonPathAnalyzer.JsonPathAnalysis> pathAnalyses)
void	setJsonPathAnalysis(Node node, JsonPathAnalyzer.JsonPathAnalysis pathAnalysis)
void	setLimit(Node node, long rowCount)
void	setLimit(Node node, OptionalLong rowCount)
void	setMeasureDefinitions(Map<NodeRef<WindowOperation>,MeasureDefinition> definitions)
void	setMergeAnalysis(Analysis.MergeAnalysis mergeAnalysis)
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	setOrderByWindowMeasures(OrderBy node, List<WindowOperation> measures)
void	setPatternAggregations(Set<NodeRef<FunctionCall>> aggregations)
void	setRanges(Map<NodeRef<RangeQuantifier>,Analysis.Range> quantifierRanges)
void	setRefreshMaterializedView(Analysis.RefreshMaterializedViewAnalysis refreshMaterializedView)
void	setRelationName(Relation relation, QualifiedName name)
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	setTableExecuteHandle(TableExecuteHandle tableExecuteHandle)
void	setTableExecuteReadsData(boolean readsData)
void	setTableFunctionAnalysis(TableFunctionInvocation node, Analysis.TableFunctionInvocationAnalysis analysis)
void	setUndefinedLabels(RowPattern pattern, Set<String> labels)
void	setUndefinedLabels(Map<NodeRef<RowPattern>,Set<String>> labels)
void	setUnnest(Unnest node, Analysis.UnnestAnalysis analysis)
void	setUpdatedColumns(List<ColumnSchema> updatedColumns)
void	setUpdateTarget(CatalogHandle.CatalogVersion catalogVersion, QualifiedObjectName targetName, Optional<Table> targetTable, Optional<List<OutputColumn>> targetColumns)
void	setUpdateType(String updateType)
void	setWhere(Node node, Expression expression)
void	setWindow(Node node, Analysis.ResolvedWindow window)
void	setWindowFunctions(QuerySpecification node, List<FunctionCall> functions)
void	setWindowMeasures(QuerySpecification node, List<WindowOperation> measures)
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 Details

Analysis

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

Method Details

getStatement

public Statement getStatement()

getUpdateType

public String getUpdateType()

getTarget

public Optional<Output> getTarget()

setUpdateType

public void setUpdateType(String updateType)

setUpdateTarget

public void setUpdateTarget(CatalogHandle.CatalogVersion catalogVersion,
 QualifiedObjectName targetName,
 Optional<Table> targetTable,
 Optional<List<OutputColumn>> targetColumns)

isUpdateTarget

public boolean isUpdateTarget(Table table)

isSkipMaterializedViewRefresh

public boolean isSkipMaterializedViewRefresh()

setSkipMaterializedViewRefresh

public void setSkipMaterializedViewRefresh(boolean skipMaterializedViewRefresh)

isTableExecuteReadsData

public boolean isTableExecuteReadsData()

setTableExecuteReadsData

public void setTableExecuteReadsData(boolean readsData)

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(Node node,
 Analysis.ResolvedWindow window)

getWindow

public Analysis.ResolvedWindow getWindow(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)

setWindowMeasures

public void setWindowMeasures(QuerySpecification node,
 List<WindowOperation> measures)

getWindowMeasures

public List<WindowOperation> getWindowMeasures(QuerySpecification node)

setOrderByWindowMeasures

public void setOrderByWindowMeasures(OrderBy node,
 List<WindowOperation> measures)

getOrderByWindowMeasures

public List<WindowOperation> getOrderByWindowMeasures(OrderBy node)

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,
 String authorization,
 Scope accessControlScope)

getResolvedFunctions

public Set<ResolvedFunction> getResolvedFunctions()

getResolvedFunction

public ResolvedFunction getResolvedFunction(Node node)

addResolvedFunction

public void addResolvedFunction(Node 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)

addType

public void addType(Expression expression,
 Type type)

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)

getAnalyzeMetadata

public Optional<AnalyzeMetadata> getAnalyzeMetadata()

setAnalyzeMetadata

public void setAnalyzeMetadata(AnalyzeMetadata analyzeMetadata)

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<ColumnSchema> updatedColumns)

getUpdatedColumns

public Optional<List<ColumnSchema>> getUpdatedColumns()

getMergeAnalysis

public Optional<Analysis.MergeAnalysis> getMergeAnalysis()

setMergeAnalysis

public void setMergeAnalysis(Analysis.MergeAnalysis mergeAnalysis)

setRefreshMaterializedView

public void setRefreshMaterializedView(Analysis.RefreshMaterializedViewAnalysis refreshMaterializedView)

getRefreshMaterializedView

public Optional<Analysis.RefreshMaterializedViewAnalysis> getRefreshMaterializedView()

setDelegatedRefreshMaterializedView

public void setDelegatedRefreshMaterializedView(QualifiedObjectName viewName)

getDelegatedRefreshMaterializedView

public Optional<QualifiedObjectName> getDelegatedRefreshMaterializedView()

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

getQueryType

public QueryType getQueryType()

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)

setRanges

public void setRanges(Map<NodeRef<RangeQuantifier>,Analysis.Range> quantifierRanges)

getRange

public Analysis.Range getRange(RangeQuantifier quantifier)

setUndefinedLabels

public void setUndefinedLabels(RowPattern pattern,
 Set<String> labels)

setUndefinedLabels

public void setUndefinedLabels(Map<NodeRef<RowPattern>,Set<String>> labels)

getUndefinedLabels

public Set<String> getUndefinedLabels(RowPattern pattern)

setMeasureDefinitions

public void setMeasureDefinitions(Map<NodeRef<WindowOperation>,MeasureDefinition> definitions)

getMeasureDefinition

public MeasureDefinition getMeasureDefinition(WindowOperation measure)

setPatternAggregations

public void setPatternAggregations(Set<NodeRef<FunctionCall>> aggregations)

isPatternAggregation

public boolean isPatternAggregation(FunctionCall function)

setJsonPathAnalyses

public void setJsonPathAnalyses(Map<NodeRef<Node>,JsonPathAnalyzer.JsonPathAnalysis> pathAnalyses)

setJsonPathAnalysis

public void setJsonPathAnalysis(Node node,
 JsonPathAnalyzer.JsonPathAnalysis pathAnalysis)

getJsonPathAnalysis

public JsonPathAnalyzer.JsonPathAnalysis getJsonPathAnalysis(Node node)

setJsonInputFunctions

public void setJsonInputFunctions(Map<NodeRef<Expression>,ResolvedFunction> functions)

getJsonInputFunction

public ResolvedFunction getJsonInputFunction(Expression expression)

setJsonOutputFunctions

public void setJsonOutputFunctions(Map<NodeRef<Node>,ResolvedFunction> functions)

getJsonOutputFunction

public ResolvedFunction getJsonOutputFunction(Node node)

addJsonTableAnalysis

public void addJsonTableAnalysis(JsonTable jsonTable,
 Analysis.JsonTableAnalysis analysis)

getJsonTableAnalysis

public Analysis.JsonTableAnalysis getJsonTableAnalysis(JsonTable jsonTable)

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)

addCheckConstraints

public void addCheckConstraints(Table table,
 Expression constraint)

getRowFilters

public List<Expression> getRowFilters(Table node)

getCheckConstraints

public List<Expression> getCheckConstraints(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,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)

setTableExecuteHandle

public void setTableExecuteHandle(TableExecuteHandle tableExecuteHandle)

getTableExecuteHandle

public Optional<TableExecuteHandle> getTableExecuteHandle()

setTableFunctionAnalysis

public void setTableFunctionAnalysis(TableFunctionInvocation node,
 Analysis.TableFunctionInvocationAnalysis analysis)

getTableFunctionAnalysis

public Analysis.TableFunctionInvocationAnalysis getTableFunctionAnalysis(TableFunctionInvocation node)

setRelationName

public void setRelationName(Relation relation,
 QualifiedName name)

getRelationName

public QualifiedName getRelationName(Relation relation)

addAliased

public void addAliased(Relation relation)

isAliased

public boolean isAliased(Relation relation)

addPolymorphicTableFunction

public void addPolymorphicTableFunction(TableFunctionInvocation invocation)

isPolymorphicTableFunction

public boolean isPolymorphicTableFunction(TableFunctionInvocation invocation)