parse

type ActionReturn struct {
	Position
	// IsTable is true if the return type is a table.
	IsTable bool
	// Fields are the fields of the return type.
	Fields []*engine.NamedType
}

type ActionStmt interface {
	Node
	// contains filtered or unexported methods
}

type ActionStmtAssign struct {

	// Variable is the variable that is being assigned.
	Variable Assignable
	// Type is the type of the variable.
	// It can be nil if the variable is not being assigned,
	// or if the type should be inferred.
	Type *types.DataType
	// Value is the value that is being assigned.
	Value Expression
	// contains filtered or unexported fields
}

type ActionStmtCall struct {

	// Receivers are the variables being assigned. If nil, then the
	// receiver can be ignored.
	Receivers []*ExpressionVariable
	Call      *ExpressionFunctionCall
	// contains filtered or unexported fields
}

type ActionStmtDeclaration struct {

	// Variable is the variable that is being declared.
	Variable *ExpressionVariable
	Type     *types.DataType
	// contains filtered or unexported fields
}

type ActionStmtForLoop struct {

	// Receiver is the variable that is assigned on each iteration.
	Receiver *ExpressionVariable
	// LoopTerm is what the loop is looping through.
	LoopTerm LoopTerm
	// Body is the body of the loop.
	Body []ActionStmt
	// contains filtered or unexported fields
}

type ActionStmtIf struct {

	// IfThens are the if statements.
	// They are evaluated in order, as
	// IF ... THEN ... ELSEIF ... THEN ...
	IfThens []*IfThen
	// Else is the else statement.
	// It is evaluated if no other if statement
	// is true.
	Else []ActionStmt
	// contains filtered or unexported fields
}

type ActionStmtLoopControl struct {
	Type LoopControlType
	// contains filtered or unexported fields
}

type ActionStmtReturn struct {

	// Values are the values to return.
	// Either values is set or SQL is set, but not both.
	Values []Expression
	// SQL is the SQL statement to return.
	// Either values is set or SQL is set, but not both.
	SQL *SQLStatement
	// contains filtered or unexported fields
}

type ActionStmtReturnNext struct {

	// Values are the values to return.
	Values []Expression
	// contains filtered or unexported fields
}

type ActionStmtSQL struct {
	SQL *SQLStatement
	// contains filtered or unexported fields
}

type ActionVisitor interface {
	SQLVisitor
	VisitActionStmtDeclaration(*ActionStmtDeclaration) any
	VisitActionStmtAssignment(*ActionStmtAssign) any
	VisitActionStmtCall(*ActionStmtCall) any
	VisitActionStmtForLoop(*ActionStmtForLoop) any
	VisitLoopTermRange(*LoopTermRange) any
	VisitLoopTermSQL(*LoopTermSQL) any
	VisitLoopTermExpression(*LoopTermExpression) any
	VisitActionStmtIf(*ActionStmtIf) any
	VisitIfThen(*IfThen) any
	VisitActionStmtSQL(*ActionStmtSQL) any
	VisitActionStmtLoopControl(*ActionStmtLoopControl) any
	VisitActionStmtReturn(*ActionStmtReturn) any
	VisitActionStmtReturnNext(*ActionStmtReturnNext) any
}

type AddColumn struct {
	Position
	Name        string
	Type        *types.DataType
	IfNotExists bool
}

type AddTableConstraint struct {
	Position
	Constraint *OutOfLineConstraint
}

type AlterColumnDrop struct {
	Position
	Column string
	Type   SingleColumnConstraintType
}

type AlterColumnSet struct {
	Position
	// Column is the column that is being altered.
	Column string
	// Type is the type of constraint that is being set.
	Type SingleColumnConstraintType
	// Value is the value of the constraint.
	// It is only set if the type is DEFAULT.
	Value Expression
}

type AlterTableAction interface {
	Node
	// contains filtered or unexported methods
}

type AlterTableStatement struct {
	Position
	Namespacing
	Table   string
	Actions []AlterTableAction
}

type ArithmeticOperator string

type Assignable interface {
	Expression
	// contains filtered or unexported methods
}

type CheckConstraint struct {
	Position
	Expression Expression
}

type Column struct {
	Position

	Name        string
	Type        *types.DataType
	Constraints []InlineConstraint
}

type CommonTableExpression struct {
	Position
	// Name is the name of the CTE.
	Name string
	// Columns are the columns of the CTE.
	Columns []string
	// Query is the query of the CTE.
	Query *SelectStatement
}

type ComparisonOperator string

type CompoundOperator string

type ConstraintType interface {
	String() string
	// contains filtered or unexported methods
}

type CreateActionStatement struct {
	Position
	Namespacing
	// Either IfNotExists or OrReplace can be true, but not both.
	// Both can be false.
	IfNotExists bool
	OrReplace   bool

	// Name is the name of the action.
	Name string

	// Parameters are the parameters of the action.
	Parameters []*engine.NamedType

	// Modifiers are things like VIEW, OWNER, etc.
	Modifiers []string
	// Returns specifies the return type of the action.
	// It can be nil if the action does not return anything.
	Returns *ActionReturn
	// Statements are the statements in the action.
	Statements []ActionStmt
	// Raw is the raw CREATE ACTION statement.
	Raw string
}

type CreateIndexStatement struct {
	Position
	Namespacing
	IfNotExists bool
	Name        string
	On          string
	Columns     []string
	Type        IndexType
}

type CreateNamespaceStatement struct {
	Position
	// IfNotExists is true if the IF NOT EXISTS clause is present.
	IfNotExists bool
	// Namespace is the namespace that is being created.
	Namespace string
}

type CreateRoleStatement struct {
	Position
	// IfNotExists is true if the IF NOT EXISTS clause is present.
	IfNotExists bool
	// Role is the role that is being created or dropped.
	Role string
}

type CreateTableStatement struct {
	Position
	Namespacing
	IfNotExists bool
	Name        string
	Columns     []*Column
	// Constraints contains the non-inline constraints
	Constraints []*OutOfLineConstraint
}

type DDLVisitor interface {
	// DDL
	VisitCreateTableStatement(*CreateTableStatement) any
	VisitAlterTableStatement(*AlterTableStatement) any
	VisitDropTableStatement(*DropTableStatement) any
	VisitCreateIndexStatement(*CreateIndexStatement) any
	VisitDropIndexStatement(*DropIndexStatement) any
	VisitGrantOrRevokeStatement(*GrantOrRevokeStatement) any
	VisitTransferOwnershipStatement(*TransferOwnershipStatement) any
	VisitAlterColumnSet(*AlterColumnSet) any
	VisitAlterColumnDrop(*AlterColumnDrop) any
	VisitAddColumn(*AddColumn) any
	VisitDropColumn(*DropColumn) any
	VisitRenameColumn(*RenameColumn) any
	VisitRenameTable(*RenameTable) any
	VisitAddTableConstraint(*AddTableConstraint) any
	VisitDropTableConstraint(*DropTableConstraint) any
	VisitColumn(*Column) any
	VisitCreateRoleStatement(*CreateRoleStatement) any
	VisitDropRoleStatement(*DropRoleStatement) any
	VisitUseExtensionStatement(*UseExtensionStatement) any
	VisitUnuseExtensionStatement(*UnuseExtensionStatement) any
	VisitCreateNamespaceStatement(*CreateNamespaceStatement) any
	VisitDropNamespaceStatement(*DropNamespaceStatement) any
	VisitSetCurrentNamespaceStatement(*SetCurrentNamespaceStatement) any
	VisitCreateActionStatement(*CreateActionStatement) any
	VisitDropActionStatement(*DropActionStatement) any
	// Constraints
	VisitPrimaryKeyInlineConstraint(*PrimaryKeyInlineConstraint) any
	VisitPrimaryKeyOutOfLineConstraint(*PrimaryKeyOutOfLineConstraint) any
	VisitUniqueInlineConstraint(*UniqueInlineConstraint) any
	VisitUniqueOutOfLineConstraint(*UniqueOutOfLineConstraint) any
	VisitDefaultConstraint(*DefaultConstraint) any
	VisitNotNullConstraint(*NotNullConstraint) any
	VisitCheckConstraint(*CheckConstraint) any
	VisitForeignKeyReferences(*ForeignKeyReferences) any
	VisitForeignKeyOutOfLineConstraint(*ForeignKeyOutOfLineConstraint) any
}

type DefaultConstraint struct {
	Position
	Value Expression
}

type DeleteStatement struct {
	Position

	Table string
	Alias string     // can be empty
	From  Table      // can be nil
	Joins []*Join    // can be nil
	Where Expression // can be nil
}

type DropActionStatement struct {
	Position
	Namespacing
	// IfExists is true if the IF EXISTS clause is present.
	IfExists bool
	// Name is the name of the action.
	Name string
}

type DropBehavior string

type DropColumn struct {
	Position
	Name     string
	IfExists bool
}

type DropIndexStatement struct {
	Position
	Namespacing
	Name       string
	CheckExist bool
}

type DropNamespaceStatement struct {
	Position
	// IfExists is true if the IF EXISTS clause is present.
	IfExists bool
	// Namespace is the namespace that is being dropped.
	Namespace string
}

type DropRoleStatement struct {
	Position
	// IfExists is true if the IF EXISTS clause is present.
	IfExists bool
	// Role is the role that is being created or dropped.
	Role string
}

type DropTableConstraint struct {
	Position
	Name     string
	IfExists bool
}

type DropTableStatement struct {
	Position
	Namespacing
	Tables   []string
	IfExists bool
	Behavior DropBehavior
}

type Expression interface {
	Node
}

type ExpressionArithmetic struct {
	Position
	// Left is the left side of the arithmetic expression.
	Left Expression
	// Right is the right side of the arithmetic expression.
	Right Expression
	// Operator is the operator of the arithmetic expression.
	Operator ArithmeticOperator
}

type ExpressionArrayAccess struct {
	Position
	Typecastable
	// Array is the array that is being accessed.
	Array Expression
	// Index is the index that is being accessed.
	// Either Index or FromTo is set, but not both.
	Index Expression
	// FromTo is the range that is being accessed.
	// Either Index or FromTo is set, but not both.
	// If FromTo is set, then it is a range access.
	// If both values are set, then it is arr[FROM:TO].
	// If only From is set, then it is arr[FROM:].
	// If only To is set, then it is arr[:TO].
	// If neither are set and index is not set, then it is arr[:].
	FromTo *[2]Expression
}

type ExpressionBetween struct {
	Position
	// Expression is the expression that is being compared.
	Expression Expression
	// Lower is the left side of the BETWEEN expression.
	Lower Expression
	// Upper is the right side of the BETWEEN expression.
	Upper Expression
	// Not is true if the BETWEEN expression is a NOT BETWEEN expression.
	Not bool
}

type ExpressionCase struct {
	Position
	Case     Expression
	WhenThen [][2]Expression
	Else     Expression
}

type ExpressionCollate struct {
	Position
	// Expression is the expression that is being collated.
	Expression Expression
	// Collation is the collation that is being used.
	Collation string
}

type ExpressionColumn struct {
	Position
	Typecastable
	// Table is the table that the column is in.
	Table string // can be empty
	// Column is the name of the column.
	Column string
}

type ExpressionComparison struct {
	Position
	// Left is the left side of the comparison.
	Left Expression
	// Right is the right side of the comparison.
	Right Expression
	// Operator is the operator of the comparison.
	Operator ComparisonOperator
}

type ExpressionFieldAccess struct {
	Position
	Typecastable
	// Record is the record that is being accessed.
	Record Expression
	// Field is the field that is being accessed.
	Field string
}

type ExpressionFunctionCall struct {
	Position
	Typecastable
	// Namespace is the namespace/schema that the function is in.
	// It can be empty if the function is in the default namespace.
	Namespace string
	// Name is the name of the function.
	Name string
	// Args are the arguments to the function call.
	// They are passed using ()
	Args []Expression
	// Distinct is true if the function call is a DISTINCT function call.
	Distinct bool
	// Star is true if the function call is a * function call.
	// If it is set, then Args must be empty.
	Star bool
}

type ExpressionIn struct {
	Position
	// Expression is the expression that is being compared.
	Expression Expression
	// List is the list of expressions that the expression is being compared to.
	// Either List or Subquery is set, but not both.
	List []Expression
	// Subquery is the subquery that the expression is being compared to.
	// Either List or Subquery is set, but not both.
	Subquery *SelectStatement
	// Not is true if the IN expression is a NOT IN expression.
	Not bool
}

type ExpressionIs struct {
	Position
	// Left is the left side of the IS expression.
	Left Expression
	// Right is the right side of the IS expression.
	Right Expression
	// Not is true if the IS expression is a NOT IS expression.
	Not bool
	// Distinct is true if the IS expression is a DISTINCT IS expression.
	Distinct bool
}

type ExpressionLiteral struct {
	Position
	Typecastable
	Type *types.DataType
	// Value is the value of the literal.
	// It must be of type string, int64, bool, *decimal.Decimal,
	// or nil
	Value any
}

type ExpressionLogical struct {
	Position
	// Left is the left side of the logical expression.
	Left Expression
	// Right is the right side of the logical expression.
	Right Expression
	// Operator is the operator of the logical expression.
	Operator LogicalOperator
}

type ExpressionMakeArray struct {
	Position
	Typecastable
	Values []Expression
}

type ExpressionParenthesized struct {
	Position
	Typecastable
	// Inner is the inner expression.
	Inner Expression
}

type ExpressionStringComparison struct {
	Position
	// Left is the left side of the comparison.
	Left Expression
	// Right is the right side of the comparison.
	Right Expression
	Not   bool
	// Operator is the operator of the comparison.
	Operator StringComparisonOperator
}

type ExpressionSubquery struct {
	Position
	Typecastable
	Not      bool
	Exists   bool
	Subquery *SelectStatement
}

type ExpressionUnary struct {
	Position
	// Expression is the expression that is being operated on.
	Expression Expression
	// Operator is the operator of the unary expression.
	Operator UnaryOperator
}

type ExpressionVariable struct {
	Position
	Typecastable
	// Name is the naem of the variable,
	// without the $ or @.
	Name string
	// Prefix is the $ or @ prefix.
	Prefix VariablePrefix
}

type ExpressionWindowFunctionCall struct {
	Position
	FunctionCall *ExpressionFunctionCall
	// Filter is the filter clause.
	// If nil, then there is no filter clause.
	Filter Expression
	// Window is the window function that is being called.
	Window Window
}

type ForeignKey struct {
	// ChildKeys are the columns that are referencing another.
	// For example, in FOREIGN KEY (a) REFERENCES tbl2(b), "a" is the child key
	ChildKeys []string `json:"child_keys"`

	// ParentKeys are the columns that are being referred to.
	// For example, in FOREIGN KEY (a) REFERENCES tbl2(b), "b" is the parent key
	ParentKeys []string `json:"parent_keys"`

	// ParentTable is the table that holds the parent columns.
	// For example, in FOREIGN KEY (a) REFERENCES tbl2(b), "tbl2" is the parent table
	ParentTable string `json:"parent_table"`

	// Action refers to what the foreign key should do when the parent is altered.
	// This is NOT the same as a database action.
	// For example, ON DELETE CASCADE is a foreign key action
	Actions []*ForeignKeyAction `json:"actions"`
}

type ForeignKeyAction struct {
	// On can be either "UPDATE" or "DELETE"
	On ForeignKeyActionOn `json:"on"`

	// Do specifies what a foreign key action should do
	Do ForeignKeyActionDo `json:"do"`
}

type ForeignKeyActionDo string

type ForeignKeyActionOn string

type ForeignKeyOutOfLineConstraint struct {
	Position
	Columns    []string
	References *ForeignKeyReferences
}

type ForeignKeyReferences struct {
	Position

	// RefTableNamespace is the qualifier of the referenced table.
	// It can be empty if the table is in the same schema.
	RefTableNamespace string
	RefTable          string
	RefColumns        []string
	Actions           []*ForeignKeyAction
}

type GetPositioner interface {
	GetPosition() *Position
	Clear()
}

type GrantOrRevokeStatement struct {
	Position
	// If is true if either IF GRANTED or IF NOT GRANTED is present,
	// depending on the statement.
	If bool
	// IsGrant is true if the statement is a GRANT statement.
	// If it is false, then it is a REVOKE statement.
	IsGrant bool
	// Privileges are the privileges that are being granted.
	// Either Privileges or Role must be set, but not both.
	Privileges []string
	// Namespace is the namespace that the privileges are being granted on.
	// It can be nil if they are global.
	Namespace *string
	// OnNam
	// Role is the role being granted
	// Either Privileges or Role must be set, but not both.
	GrantRole string
	// ToRole is the role being granted to.
	// Only one of ToUser, ToRole, or ToVariable must be set.
	ToRole string
	// ToUser is the user being granted to.
	// Only one of ToUser, ToRole, or ToVariable must be set.
	ToUser string
	// ToVariable is the variable being granted to.
	// Only one of ToUser, ToRole, or ToVariable must be set.
	ToVariable Expression
}

type IfThen struct {
	Position
	If   Expression
	Then []ActionStmt
}

type IndexType string

type InlineConstraint interface {
	Node
	// contains filtered or unexported methods
}

type InsertStatement struct {
	Position
	Table   string
	Alias   string   // can be empty
	Columns []string // can be empty
	// Either Values or Select is set, but not both.
	Values     [][]Expression   // can be empty
	Select     *SelectStatement // can be nil
	OnConflict *OnConflict      // can be nil
}

type Join struct {
	Position
	Type     JoinType
	Relation Table
	On       Expression
}

type JoinType string

type LogicalOperator string

type LoopControlType string

type LoopTerm interface {
	Node
	// contains filtered or unexported methods
}

type LoopTermExpression struct {

	// If Array is true, then the ARRAY keyword was used, specifying that
	// the function is expected to return a single array, and we should loop
	// through each element in the array.
	Array bool
	// Expression is the expression to loop through.
	Expression Expression
	// contains filtered or unexported fields
}

type LoopTermRange struct {

	// Start is the start of the range.
	Start Expression
	// End is the end of the range.
	End Expression
	// contains filtered or unexported fields
}

type LoopTermSQL struct {

	// Statement is the Statement statement to execute.
	Statement *SQLStatement
	// contains filtered or unexported fields
}

type MultiColumnConstraintType string

type Namespaceable interface {
	TopLevelStatement
	SetNamespacePrefix(string)
	GetNamespacePrefix() string
}

type Namespacing struct {
	NamespacePrefix string
}

type Node interface {
	Positionable
	Accept(Visitor) any
}

type NotNullConstraint struct {
	Position
}

type NullOrder string

type OnConflict struct {
	Position
	ConflictColumns []string           // can be empty
	ConflictWhere   Expression         // can be nil
	DoUpdate        []*UpdateSetClause // if nil, then do nothing
	UpdateWhere     Expression         // can be nil
}

type OrderType string

type OrderingTerm struct {
	Position
	Expression Expression
	Order      OrderType
	Nulls      NullOrder
}

type OutOfLineConstraint struct {
	Position
	Name       string // can be empty if the name should be auto-generated
	Constraint OutOfLineConstraintClause
}

type OutOfLineConstraintClause interface {
	Node

	// LocalColumns returns the local columns that the constraint is applied to.
	LocalColumns() []string
	// contains filtered or unexported methods
}

type ParseError struct {
	ParserName string    `json:"parser_name,omitempty"`
	Err        error     `json:"error"`
	Message    string    `json:"message,omitempty"`
	Position   *Position `json:"position,omitempty"`
}

type ParseErrs interface {
	Err() error
	Errors() []*ParseError
	Add(...*ParseError)
	MarshalJSON() ([]byte, error)
}

type ParseResult struct {
	// Statements are the individual statements, in the order they were encountered.
	Statements []TopLevelStatement `json:"statements,omitempty"`
	// ParseErrs is the error listener that contains all the errors that occurred during parsing.
	ParseErrs ParseErrs `json:"parse_errs,omitempty"`
}

type Position struct {
	StartLine *int `json:"start_line,omitempty"`
	StartCol  *int `json:"start_col,omitempty"`
	EndLine   *int `json:"end_line,omitempty"`
	EndCol    *int `json:"end_col,omitempty"`
	// contains filtered or unexported fields
}

type Positionable interface {
	GetPositioner
	Set(r antlr.ParserRuleContext)
	SetToken(t antlr.Token)
}

type PrimaryKeyInlineConstraint struct {
	Position
}

type PrimaryKeyOutOfLineConstraint struct {
	Position
	Columns []string
}

type RelationSubquery struct {
	Position
	Subquery *SelectStatement
	// Alias cannot be empty, as our syntax
	// forces it for subqueries.
	Alias string
}

type RelationTable struct {
	Position
	// Namespace is the namespace of the table.
	// If it is empty, then the table is in the current namespace.
	Namespace string
	// Table is the name of the table.
	Table string
	Alias string // can be empty
}

type RenameColumn struct {
	Position
	OldName string
	NewName string
}

type RenameTable struct {
	Position
	Name string
}

type ResultColumn interface {
	Node
	ResultColumnType() ResultColumnType
}

type ResultColumnExpression struct {
	Position

	Expression Expression
	Alias      string // can be empty
}

type ResultColumnType string

type ResultColumnWildcard struct {
	Position
	Table string // can be empty
}

type SQLCore interface {
	Node
	// contains filtered or unexported methods
}

type SQLStatement struct {
	Position
	Namespacing
	CTEs []*CommonTableExpression
	// Recursive is true if the RECURSIVE keyword is present.
	Recursive bool
	// SQL can be an insert, update, delete, or select statement.
	SQL SQLCore
	// contains filtered or unexported fields
}

type SQLVisitor interface {
	VisitExpressionLiteral(*ExpressionLiteral) any
	VisitExpressionFunctionCall(*ExpressionFunctionCall) any
	VisitExpressionWindowFunctionCall(*ExpressionWindowFunctionCall) any
	VisitWindowImpl(*WindowImpl) any
	VisitWindowReference(*WindowReference) any
	VisitExpressionVariable(*ExpressionVariable) any
	VisitExpressionArrayAccess(*ExpressionArrayAccess) any
	VisitExpressionMakeArray(*ExpressionMakeArray) any
	VisitExpressionFieldAccess(*ExpressionFieldAccess) any
	VisitExpressionParenthesized(*ExpressionParenthesized) any
	VisitExpressionComparison(*ExpressionComparison) any
	VisitExpressionLogical(*ExpressionLogical) any
	VisitExpressionArithmetic(*ExpressionArithmetic) any
	VisitExpressionUnary(*ExpressionUnary) any
	VisitExpressionColumn(*ExpressionColumn) any
	VisitExpressionCollate(*ExpressionCollate) any
	VisitExpressionStringComparison(*ExpressionStringComparison) any
	VisitExpressionIs(*ExpressionIs) any
	VisitExpressionIn(*ExpressionIn) any
	VisitExpressionBetween(*ExpressionBetween) any
	VisitExpressionSubquery(*ExpressionSubquery) any
	VisitExpressionCase(*ExpressionCase) any
	VisitCommonTableExpression(*CommonTableExpression) any
	VisitSQLStatement(*SQLStatement) any
	VisitSelectStatement(*SelectStatement) any
	VisitSelectCore(*SelectCore) any
	VisitResultColumnExpression(*ResultColumnExpression) any
	VisitResultColumnWildcard(*ResultColumnWildcard) any
	VisitRelationTable(*RelationTable) any
	VisitRelationSubquery(*RelationSubquery) any
	VisitJoin(*Join) any
	VisitUpdateStatement(*UpdateStatement) any
	VisitUpdateSetClause(*UpdateSetClause) any
	VisitDeleteStatement(*DeleteStatement) any
	VisitInsertStatement(*InsertStatement) any
	VisitUpsertClause(*OnConflict) any
	VisitOrderingTerm(*OrderingTerm) any
}

type SelectCore struct {
	Position
	// Distinct is true if the SELECT statement is a DISTINCT SELECT statement.
	Distinct bool
	Columns  []ResultColumn
	From     Table        // can be nil
	Joins    []*Join      // can be nil
	Where    Expression   // can be nil
	GroupBy  []Expression // can be nil
	Having   Expression   // can be nil
	Windows  []*struct {
		Name   string
		Window *WindowImpl
	} // can be nil
}

type SelectStatement struct {
	Position
	SelectCores       []*SelectCore
	CompoundOperators []CompoundOperator
	Ordering          []*OrderingTerm
	Limit             Expression
	Offset            Expression
}

type SetCurrentNamespaceStatement struct {
	Position
	Namespace string
}

type SingleColumnConstraintType string

type StringComparisonOperator string

type Table interface {
	Node
	// contains filtered or unexported methods
}

type TopLevelStatement interface {
	Node
	// contains filtered or unexported methods
}

type TransferOwnershipStatement struct {
	Position
	// ToUser is the user that the ownership is being transferred to.
	ToUser string
	// ToVariable is the variable that the ownership is being transferred to.
	ToVariable Expression
}

type Typecastable struct {
	TypeCast *types.DataType
}

type Typecasted interface {
	GetTypeCast() *types.DataType
}

type UnaryOperator string

type UnimplementedActionVisitor struct{}

type UnimplementedDDLVisitor struct{}

type UniqueInlineConstraint struct {
	Position
}

type UniqueOutOfLineConstraint struct {
	Position
	Columns []string
}

type UnuseExtensionStatement struct {
	Position
	IfExists bool
	Alias    string
}

type UpdateSetClause struct {
	Position
	Column string
	Value  Expression
}

type UpdateStatement struct {
	Position
	Table     string
	Alias     string // can be empty
	SetClause []*UpdateSetClause
	From      Table      // can be nil
	Joins     []*Join    // can be nil
	Where     Expression // can be nil
}

type UseExtensionStatement struct {
	Position
	IfNotExists bool
	ExtName     string
	Config      []*struct {
		Key   string
		Value Expression
	}
	Alias string
}

type VariablePrefix string

type Visitor interface {
	ActionVisitor
	DDLVisitor
}

type Window interface {
	Node
	// contains filtered or unexported methods
}

type WindowImpl struct {
	Position
	// PartitionBy is the partition by clause.
	PartitionBy []Expression
	// OrderBy is the order by clause.
	OrderBy []*OrderingTerm
}

type WindowReference struct {
	Position
	// Name is the name of the window.
	Name string
}