tree

type AliasedRelation struct {
	IRelation
	Relation    IRelation
	Alias       *Identifier
	ColumnNames []*Identifier
}

type AllColumns struct {
	// SelectItem is ISelectItem
	ISelectItem
	// Prefix is QualifiedName
	Prefix *QualifiedName
}

type AstVisitor interface {

	// VisitAliasedRelation visits the node
	VisitAliasedRelation(aliasedRelation *AliasedRelation, ctx interface{}) interface{}

	// VisitAllColumns visits the node
	VisitAllColumns(allColumns *AllColumns, ctx interface{}) interface{}

	// VisitExpression visits the node
	VisitExpression(exp IExpression, ctx interface{}) interface{}

	// VisitGroupBy visits the node
	VisitGroupBy(groupby *GroupBy, ctx interface{}) interface{}

	// VisitExpression visits the node
	VisitGroupingElement(groupElement IGroupingElement, ctx interface{}) interface{}

	// VisitIdentifier visits the node
	VisitIdentifier(identifier *Identifier, ctx interface{}) interface{}

	// VisitJoin visits the node
	VisitJoin(join *Join, ctx interface{}) interface{}

	// VisitLogicalBinaryExpression visits the node
	VisitLogicalBinaryExpression(logicalBinaryExpr *LogicalBinaryExpression, ctx interface{}) interface{}

	// VisitOrderBy visits the node
	VisitOrderBy(orderBy *OrderBy, ctx interface{}) interface{}

	// VisitQuery visits the node
	VisitQuery(query *Query, ctx interface{}) interface{}

	// VisitQueryBody visits the node
	VisitQueryBody(queryBody IQueryBody, ctx interface{}) interface{}

	// VisitQuerySpecification visits the node
	VisitQuerySpecification(querySpec *QuerySpecification, ctx interface{}) interface{}

	// VisitRelation visits the node
	VisitRelation(relation IRelation, ctx interface{}) interface{}

	// VisitSelect visits the node
	VisitSelect(sel *Select, ctx interface{}) interface{}

	// VisitSelectItem visits the node
	VisitSelectItem(selectItem ISelectItem, ctx interface{}) interface{}

	// VisitSimpleGroupBy visits the node
	VisitSimpleGroupBy(simpleGroupBy *SimpleGroupBy, ctx interface{}) interface{}

	// VisitSingleColumn visits the node
	VisitSingleColumn(singleColumn *SingleColumn, ctx interface{}) interface{}

	// VisitSortItem visits the node
	VisitSortItem(sortItem *SortItem, ctx interface{}) interface{}

	// VisitStatement visits the node
	VisitStatement(statement IStatement, ctx interface{}) interface{}

	// VisitTable visits the node
	VisitTable(table *Table, ctx interface{}) interface{}

	// VisitTableSubquery visits the node
	VisitTableSubquery(tableSubquery *TableSubquery, ctx interface{}) interface{}

	// VisitWith visits the node
	VisitWith(with *With, ctx interface{}) interface{}

	// VisitWithQuery visits the node
	VisitWithQuery(with *WithQuery, ctx interface{}) interface{}
	// contains filtered or unexported methods
}

type Expression struct {
	// Node is an INode
	*Node
}

type GroupBy struct {
	// Node is INode
	INode
	IsDistinct       bool
	GroupingElements []IGroupingElement
}

type GroupingElement struct {
	// Node is INode
	INode
}

type IExpression interface {
	// INode is interface
	INode
}

type IGroupingElement interface {
	// INode is interface
	INode
}

type IJoinCriteria interface {
	// GetNodes returns the list of nodes
	GetNodes() []INode
}

type INode interface {
	SetValue(value string)
	GetValue() string
	Accept(visitor AstVisitor, ctx interface{}) interface{}
}

type IQueryBody interface {
	// IRelation is interface
	IRelation
}

type IRelation interface {
	// INode is interface
	INode
}

type ISelectItem interface {
	// INode is interface
	INode
}

type IStatement interface {
	// INode is interface
	INode
}

type Identifier struct {
	// Expression is IExpression
	IExpression
	// Value is Identifier text
	Value string
	// Delimited is flag
	Delimited bool
}

type Join struct {
	// IRelation is interface
	IRelation
	// Type is join type
	Type JoinType
	// Left is IRelation
	Left IRelation
	// Right is IRelation
	Right IRelation
	// Criteria is on condition
	Criteria IJoinCriteria
}

type JoinOn struct {
	// IJoinCriteria is interface
	IJoinCriteria
	Expr IExpression
}

type JoinType int

type JoinUsing struct {
	// IJoinCriteria is interface
	IJoinCriteria
	Columns []*Identifier
}

type LogicalBinaryExpType int

type LogicalBinaryExpression struct {
	IExpression
	LogicType LogicalBinaryExpType
	Left      IExpression
	Right     IExpression
}

type NaturalJoin struct {
	// IJoinCriteria is interface
	IJoinCriteria
}

type Node struct {
	// Location is node location
	Location *NodeLocation
	// contains filtered or unexported fields
}

type NodeLocation struct {
	// Line is #line
	Line int
	// CharPosition is #col
	CharPosition int
}

type OrderBy struct {
	// Node is INode
	INode
	// SortItems is list of SortItems
	SortItems []*SortItem
}

type OrderType int

type QualifiedName struct {
	// Parts is list of string
	Parts []string
	// OriginalParts is list of string
	OriginalParts []string
}

type Query struct {
	// Statement is IStatement
	IStatement
	// QueryBody is IQueryBody
	QueryBody IQueryBody
	// With is with
	With *With
	// OrderBy is orderby
	OrderBy *OrderBy
	// Limit is limit
	Limit string
}

type QueryBody struct {
	IRelation
}

type QuerySpecification struct {
	// QueryBody is IQueryBody
	IQueryBody
	// Select is Select
	Select *Select
	// From is IRelation
	From IRelation
	// Where is IExpression
	Where IExpression
	// GroupBy is GroupBy
	GroupBy *GroupBy
	// Having is IExpression
	Having IExpression
	// OrderBy is OrderBy
	OrderBy *OrderBy
	// Limit is limit
	Limit string
}

type Relation struct {
	INode
}

type Select struct {
	// Node is INode
	INode
	// Distinct is distinct
	Distinct bool
	// SelectItems is list of ISelectItems
	SelectItems []ISelectItem
}

type SelectItem struct {
	// Node is INode
	INode
}

type SimpleGroupBy struct {
	IGroupingElement
	// Columns is group by columns
	Columns []IExpression
}

type SingleColumn struct {
	// SelectItem is interface
	ISelectItem
	// Alias is column alias
	Alias *Identifier
	// Expression is IExpression
	Expression IExpression
}

type SortItem struct {
	// Node is INode
	INode
	Expr  IExpression
	Order OrderType
}

type Statement struct {
	// Node is INode
	INode
}

type Table struct {
	IQueryBody
	// Name is table name
	Name *QualifiedName
}

type TableSubquery struct {
	IQueryBody
	// Query is subquery
	Query *Query
}

type With struct {
	// Node is INode
	INode
	// Recursive is with Recursive
	Recursive bool
	// Queries is WithQuery
	Queries []*WithQuery
}

type WithQuery struct {
	// Node is INode
	INode
	// Name is name
	Name *Identifier
	// Query is query
	Query *Query
	// ColumnAliases is ColumnAliases
	ColumnAliases []*Identifier
}