io.prestosql.sql.analyzer

Class Analysis

java.lang.Object

io.prestosql.sql.analyzer.Analysis

public class Analysis
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Analysis.AccessControlInfo
static class	Analysis.GroupingSetAnalysis
static class	Analysis.Insert
static class	Analysis.JoinUsingAnalysis

Constructor Summary

Constructors

Constructor and Description
Analysis(Statement root, List<Expression> parameters, boolean isDescribe)

Method Summary

Modifier and Type	Method and Description
void	addCoercion(Expression expression, Type type, boolean isTypeOnlyCoercion)
void	addCoercions(Map<NodeRef<Expression>,Type> coercions, Set<NodeRef<Expression>> typeOnlyCoercions)
void	addColumnReferences(Map<NodeRef<Expression>,FieldId> columnReferences)
void	addEmptyColumnReferencesForTable(AccessControl accessControl, Identity identity, QualifiedObjectName table)
void	addFunctionSignatures(Map<NodeRef<FunctionCall>,Signature> infos)
void	addLambdaArgumentReferences(Map<NodeRef<Identifier>,LambdaArgumentDeclaration> lambdaArgumentReferences)
void	addRelationCoercion(Relation relation, Type[] types)
void	addTableColumnReferences(AccessControl accessControl, Identity identity, com.google.common.collect.Multimap<QualifiedObjectName,String> tableColumnMap)
void	addTypes(Map<NodeRef<Expression>,Type> types)
List<FunctionCall>	getAggregates(QuerySpecification query)
Optional<TableHandle>	getAnalyzeTarget()
Type	getCoercion(Expression expression)
Map<NodeRef<Expression>,Type>	getCoercions()
ColumnHandle	getColumn(Field field)
Optional<List<Identifier>>	getColumnAliases()
Map<NodeRef<Expression>,FieldId>	getColumnReferenceFields()
Set<NodeRef<Expression>>	getColumnReferences()
Optional<String>	getCreateTableComment()
Optional<QualifiedObjectName>	getCreateTableDestination()
Map<String,Expression>	getCreateTableProperties()
List<ExistsPredicate>	getExistsSubqueries(Node node)
Signature	getFunctionSignature(FunctionCall function)
List<Expression>	getGroupByExpressions(QuerySpecification node)
List<GroupingOperation>	getGroupingOperations(QuerySpecification querySpecification)
Analysis.GroupingSetAnalysis	getGroupingSets(QuerySpecification node)
Expression	getHaving(QuerySpecification query)
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)
List<Expression>	getOutputExpressions(Node node)
List<Expression>	getParameters()
List<QuantifiedComparisonExpression>	getQuantifiedComparisonSubqueries(Node node)
Type[]	getRelationCoercion(Relation relation)
Scope	getRootScope()
double	getSampleRatio(SampledRelation relation)
List<SubqueryExpression>	getScalarSubqueries(Node node)
Scope	getScope(Node node)
Statement	getStatement()
Map<Analysis.AccessControlInfo,Map<QualifiedObjectName,Set<String>>>	getTableColumnReferences()
TableHandle	getTableHandle(Table table)
Collection<TableHandle>	getTables()
Type	getType(Expression expression)
Set<NodeRef<Expression>>	getTypeOnlyCoercions()
Map<NodeRef<Expression>,Type>	getTypes()
Type	getTypeWithCoercions(Expression expression)
String	getUpdateType()
Expression	getWhere(QuerySpecification node)
List<FunctionCall>	getWindowFunctions(QuerySpecification query)
boolean	hasTableInView(Table tableReference)
boolean	isAggregation(QuerySpecification node)
boolean	isColumnReference(Expression expression)
boolean	isCreateTableAsSelectNoOp()
boolean	isCreateTableAsSelectWithData()
boolean	isDescribe()
boolean	isOrderByRedundant(OrderBy orderBy)
boolean	isTypeOnlyCoercion(Expression expression)
void	markRedundantOrderBy(OrderBy orderBy)
void	recordSubqueries(Node node, ExpressionAnalysis expressionAnalysis)
void	registerNamedQuery(Table tableReference, Query query)
void	registerTable(Table table, TableHandle handle)
void	registerTableForView(Table tableReference)
void	setAggregates(QuerySpecification node, List<FunctionCall> aggregates)
void	setAnalyzeTarget(TableHandle analyzeTarget)
void	setColumn(Field field, ColumnHandle handle)
void	setCreateTableAsSelectNoOp(boolean createTableAsSelectNoOp)
void	setCreateTableAsSelectWithData(boolean createTableAsSelectWithData)
void	setCreateTableColumnAliases(List<Identifier> createTableColumnAliases)
void	setCreateTableComment(Optional<String> createTableComment)
void	setCreateTableDestination(QualifiedObjectName destination)
void	setCreateTableProperties(Map<String,Expression> createTableProperties)
void	setGroupByExpressions(QuerySpecification node, List<Expression> expressions)
void	setGroupingOperations(QuerySpecification querySpecification, List<GroupingOperation> groupingOperations)
void	setGroupingSets(QuerySpecification node, Analysis.GroupingSetAnalysis groupingSets)
void	setHaving(QuerySpecification node, Expression expression)
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	setOutputExpressions(Node node, List<Expression> expressions)
void	setSampleRatio(SampledRelation relation, double ratio)
void	setScope(Node node, Scope scope)
void	setUpdateType(String updateType)
void	setWhere(Node node, Expression expression)
void	setWindowFunctions(QuerySpecification node, List<FunctionCall> functions)
Optional<Scope>	tryGetScope(Node node)
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,
                List<Expression> parameters,
                boolean isDescribe)

Method Detail

getStatement

public Statement getStatement()

getUpdateType

public String getUpdateType()

setUpdateType

public void setUpdateType(String updateType)

isCreateTableAsSelectWithData

public boolean isCreateTableAsSelectWithData()

setCreateTableAsSelectWithData

public void setCreateTableAsSelectWithData(boolean createTableAsSelectWithData)

isCreateTableAsSelectNoOp

public boolean isCreateTableAsSelectNoOp()

setCreateTableAsSelectNoOp

public void setCreateTableAsSelectNoOp(boolean createTableAsSelectNoOp)

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)

getTypeWithCoercions

public Type getTypeWithCoercions(Expression expression)

getRelationCoercion

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

setGroupByExpressions

public void setGroupByExpressions(QuerySpecification node,
                                  List<Expression> expressions)

isAggregation

public boolean isAggregation(QuerySpecification node)

isTypeOnlyCoercion

public boolean isTypeOnlyCoercion(Expression expression)

getGroupingSets

public Analysis.GroupingSetAnalysis getGroupingSets(QuerySpecification node)

getGroupByExpressions

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

setOutputExpressions

public void setOutputExpressions(Node node,
                                 List<Expression> expressions)

getOutputExpressions

public List<Expression> getOutputExpressions(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>,FieldId> 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,
                          TableHandle handle)

getFunctionSignature

public Signature getFunctionSignature(FunctionCall function)

addFunctionSignatures

public void addFunctionSignatures(Map<NodeRef<FunctionCall>,Signature> infos)

getColumnReferences

public Set<NodeRef<Expression>> getColumnReferences()

getColumnReferenceFields

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

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)

setCreateTableDestination

public void setCreateTableDestination(QualifiedObjectName destination)

getCreateTableDestination

public Optional<QualifiedObjectName> getCreateTableDestination()

getAnalyzeTarget

public Optional<TableHandle> getAnalyzeTarget()

setAnalyzeTarget

public void setAnalyzeTarget(TableHandle analyzeTarget)

setCreateTableProperties

public void setCreateTableProperties(Map<String,Expression> createTableProperties)

getCreateTableProperties

public Map<String,Expression> getCreateTableProperties()

getColumnAliases

public Optional<List<Identifier>> getColumnAliases()

setCreateTableColumnAliases

public void setCreateTableColumnAliases(List<Identifier> createTableColumnAliases)

setCreateTableComment

public void setCreateTableComment(Optional<String> createTableComment)

getCreateTableComment

public Optional<String> getCreateTableComment()

setInsert

public void setInsert(Analysis.Insert insert)

getInsert

public Optional<Analysis.Insert> getInsert()

getNamedQuery

public Query getNamedQuery(Table table)

registerNamedQuery

public void registerNamedQuery(Table tableReference,
                               Query query)

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 List<Expression> getParameters()

isDescribe

public boolean isDescribe()

setJoinUsing

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

getJoinUsing

public Analysis.JoinUsingAnalysis getJoinUsing(Join 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)

getTableColumnReferences

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

markRedundantOrderBy

public void markRedundantOrderBy(OrderBy orderBy)

isOrderByRedundant

public boolean isOrderByRedundant(OrderBy orderBy)