parser

type AlterDatabaseStatement struct {
	Alter    Pos    // position of ALTER keyword
	Database Pos    // position of DATABASE keyword
	Name     *Ident // database name

	With Pos // position of WITH keyword

	Option DatabaseOption
}

type AlterTableStatement struct {
	Alter Pos    // position of ALTER keyword
	Table Pos    // position of TABLE keyword
	Name  *Ident // table name

	Rename Pos // position of RENAME keyword

	RenameColumn  Pos    // position of COLUMN keyword after RENAME
	OldColumnName *Ident // old column name
	To            Pos    // position of TO keyword
	NewColumnName *Ident // new column name

	Add       Pos               // position of ADD keyword
	AddColumn Pos               // position of COLUMN keyword after ADD
	ColumnDef *ColumnDefinition // new column definition

	Drop           Pos    // position of ADD keyword
	DropColumn     Pos    // position of COLUMN keyword after ADD
	DropColumnName *Ident // drop column name
}

type AlterViewStatement struct {
	Alter Pos    // position of CREATE keyword
	View  Pos    // position of VIEW keyword
	Name  *Ident // view name

	// TODO(pok) - we'll do this later - see note in parseCompileView()
	// Lparen  Pos              // position of column list left paren
	// Columns []*Ident         // column list
	// Rparen  Pos              // position of column list right paren
	As     Pos              // position of AS keyword
	Select *SelectStatement // source statement
}

type AnalyzeStatement struct {
	Analyze Pos    // position of ANALYZE keyword
	Name    *Ident // table name
}

type Assignment struct {
	Lparen  Pos      // position of column list left paren
	Columns []*Ident // column list
	Rparen  Pos      // position of column list right paren
	Eq      Pos      // position of =
	Expr    Expr     // assigned expression
}

type BeginStatement struct {
	Begin       Pos // position of BEGIN
	Deferred    Pos // position of DEFERRED keyword
	Immediate   Pos // position of IMMEDIATE keyword
	Exclusive   Pos // position of EXCLUSIVE keyword
	Transaction Pos // position of TRANSACTION keyword  (optional)
}

type BinaryExpr struct {
	X     Expr  // lhs
	OpPos Pos   // position of Op
	Op    Token // operator
	Y     Expr  // rhs

	ResultDataType ExprDataType
}

type BoolLit struct {
	ValuePos Pos  // literal position
	Value    bool // literal value
}

type BulkInsertMapDefinition struct {
	Name    *Ident // map name
	Type    *Type  // data type
	MapExpr Expr
}

type BulkInsertStatement struct {
	Bulk    Pos // position of BULK keyword
	Insert  Pos // position of INSERT keyword
	Replace Pos // position of REPLACE keyword
	Into    Pos // position of INTO keyword

	Table *Ident // table name

	ColumnsLparen Pos      // position of column list left paren
	Columns       []*Ident // optional column list
	ColumnsRparen Pos      // position of column list right paren

	Map       Pos                        // position of MAP keyword
	MapLparen Pos                        // position of column list left paren
	MapList   []*BulkInsertMapDefinition // source to column map
	MapRparen Pos                        // position of column list right paren

	Transform       Pos    // position of MAP keyword
	TransformLparen Pos    // position of column list left paren
	TransformList   []Expr // source to column map
	TransformRparen Pos    // position of column list right paren

	From               Pos  // position of FROM keyword
	DataSource         Expr // data source
	With               Pos  // position of WITH keyword
	BatchSize          Expr
	RowsLimit          Expr
	Format             Expr
	Input              Expr
	HeaderRow          Expr // has header row (that needs to be skipped)
	AllowMissingValues Expr // allows missing values
}

type CTE struct {
	TableName     *Ident           // table name
	ColumnsLparen Pos              // position of column list left paren
	Columns       []*Ident         // optional column list
	ColumnsRparen Pos              // position of column list right paren
	As            Pos              // position of AS keyword
	SelectLparen  Pos              // position of select left paren
	Select        *SelectStatement // select statement
	SelectRparen  Pos              // position of select right paren
}

type CacheTypeConstraint struct {
	CacheType      Pos // position of CACHETYPE keyword
	CacheTypeValue string
	Size           Pos  // position of SIZE keyword
	SizeExpr       Expr // check expression
}

type Call struct {
	Name     *Ident        // function name
	Lparen   Pos           // position of left paren
	Star     Pos           // position of *
	Distinct Pos           // position of DISTINCT keyword
	Args     []Expr        // argument list
	Rparen   Pos           // position of right paren
	Filter   *FilterClause // filter clause
	Over     *OverClause   // over clause

	ResultDataType ExprDataType
}

type CaseBlock struct {
	When      Pos  // position of WHEN keyword
	Condition Expr // block condition
	Then      Pos  // position of THEN keyword
	Body      Expr // result expression
}

type CaseExpr struct {
	Case     Pos          // position of CASE keyword
	Operand  Expr         // optional condition after the CASE keyword
	Blocks   []*CaseBlock // list of WHEN/THEN pairs
	Else     Pos          // position of ELSE keyword
	ElseExpr Expr         // expression used by default case
	End      Pos          // position of END keyword

	ResultDataType ExprDataType
}

type CastExpr struct {
	Cast   Pos   // position of CAST keyword
	Lparen Pos   // position of left paren
	X      Expr  // target expression
	As     Pos   // position of AS keyword
	Type   *Type // cast type
	Rparen Pos   // position of right paren

	ResultDataType ExprDataType
}

type CheckConstraint struct {
	Constraint Pos    // position of CONSTRAINT keyword
	Name       *Ident // constraint name
	Check      Pos    // position of UNIQUE keyword
	Lparen     Pos    // position of left paren
	Expr       Expr   // check expression
	Rparen     Pos    // position of right paren
}

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

type ColumnDefinition struct {
	Name        *Ident       // column name
	Type        *Type        // data type
	Constraints []Constraint // column constraints
}

type CommentOption struct {
	Comment Pos  // position of COMMENT keyword
	Expr    Expr // expression
}

type CommitStatement struct {
	Commit      Pos // position of COMMIT keyword
	End         Pos // position of END keyword
	Transaction Pos // position of TRANSACTION keyword  (optional)
}

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

type CreateDatabaseStatement struct {
	Create      Pos    // position of CREATE keyword
	Database    Pos    // position of DATABASE keyword
	If          Pos    // position of IF keyword (optional)
	IfNot       Pos    // position of NOT keyword (optional)
	IfNotExists Pos    // position of EXISTS keyword (optional)
	Name        *Ident // database name

	With Pos // position of WITH keyword

	Options []DatabaseOption // database options
}

type CreateFunctionStatement struct {
	Create      Pos    // position of CREATE keyword
	Function    Pos    // position of FUNCTION keyword
	If          Pos    // position of IF keyword
	IfNot       Pos    // position of NOT keyword after IF
	IfNotExists Pos    // position of EXISTS keyword after IF NOT
	Name        *Ident // index name

	Lparen     Pos                    // position of parameter LParen
	Parameters []*ParameterDefinition // parameters
	Rparen     Pos                    // position of parameter RParen

	Returns   Pos                  // position of RETURNS keyword
	ReturnDef *ParameterDefinition // return def

	As Pos // position of AS keyword

	Begin Pos         // position of BEGIN keyword
	Body  []Statement // function body
	End   Pos         // position of END keyword
}

type CreateIndexStatement struct {
	Create      Pos              // position of CREATE keyword
	Unique      Pos              // position of optional UNIQUE keyword
	Index       Pos              // position of INDEX keyword
	If          Pos              // position of IF keyword
	IfNot       Pos              // position of NOT keyword after IF
	IfNotExists Pos              // position of EXISTS keyword after IF NOT
	Name        *Ident           // index name
	On          Pos              // position of ON keyword
	Table       *Ident           // index name
	Lparen      Pos              // position of column list left paren
	Columns     []*IndexedColumn // column list
	Rparen      Pos              // position of column list right paren
	Where       Pos              // position of WHERE keyword
	WhereExpr   Expr             // conditional expression
}

type CreateTableStatement struct {
	Create      Pos    // position of CREATE keyword
	Table       Pos    // position of TABLE keyword
	If          Pos    // position of IF keyword (optional)
	IfNot       Pos    // position of NOT keyword (optional)
	IfNotExists Pos    // position of EXISTS keyword (optional)
	Name        *Ident // table name

	Lparen      Pos                 // position of left paren of column list
	Columns     []*ColumnDefinition // column definitions
	Constraints []Constraint        // table constraints
	Rparen      Pos                 // position of right paren of column list

	As      Pos              // position of AS keyword (optional)
	Select  *SelectStatement // select stmt to build from
	Options []TableOption    // table options
}

type CreateViewStatement struct {
	Create      Pos    // position of CREATE keyword
	View        Pos    // position of VIEW keyword
	If          Pos    // position of IF keyword
	IfNot       Pos    // position of NOT keyword after IF
	IfNotExists Pos    // position of EXISTS keyword after IF NOT
	Name        *Ident // view name
	// TODO(pok) - we'll do this later - see note in parseCompileView()
	// Lparen      Pos              // position of column list left paren
	// Columns     []*Ident         // column list
	// Rparen      Pos              // position of column list right paren
	As     Pos              // position of AS keyword
	Select *SelectStatement // source statement
}

type DataTypeBool struct {
}

type DataTypeDecimal struct {
	Scale int64
}

type DataTypeID struct {
}

type DataTypeIDSet struct {
}

type DataTypeIDSetQuantum struct {
}

type DataTypeInt struct {
}

type DataTypeRange struct {
	SubscriptType ExprDataType
}

type DataTypeString struct {
}

type DataTypeStringSet struct {
}

type DataTypeStringSetQuantum struct {
}

type DataTypeSubtable struct {
	Columns []*SubtableColumn
}

type DataTypeTimestamp struct {
}

type DataTypeTuple struct {
	Members []ExprDataType
}

type DataTypeVoid struct {
}

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

type DateLit struct {
	ValuePos Pos       // literal position
	Value    time.Time // literal value
}

type DefaultConstraint struct {
	Constraint Pos    // position of CONSTRAINT keyword
	Name       *Ident // constraint name
	Default    Pos    // position of DEFAULT keyword
	Lparen     Pos    // position of left paren
	Expr       Expr   // default expression
	Rparen     Pos    // position of right paren
}

type DeleteStatement struct {
	//	WithClause *WithClause    // clause containing CTEs
	Delete    Pos                 // position of UPDATE keyword
	From      Pos                 // position of FROM keyword
	TableName *QualifiedTableName // the name of the table we are deleting from
	Source    Source              // source for the delete

	Where     Pos  // position of WHERE keyword
	WhereExpr Expr // conditional expression
}

type DropDatabaseStatement struct {
	Drop     Pos    // position of DROP keyword
	Database Pos    // position of DATABASE keyword
	If       Pos    // position of IF keyword
	IfExists Pos    // position of EXISTS keyword after IF
	Name     *Ident // database name
}

type DropFunctionStatement struct {
	Drop     Pos    // position of DROP keyword
	Function Pos    // position of FUNCTION keyword
	If       Pos    // position of IF keyword
	IfExists Pos    // position of EXISTS keyword after IF
	Name     *Ident // trigger name
}

type DropIndexStatement struct {
	Drop     Pos    // position of DROP keyword
	Index    Pos    // position of INDEX keyword
	If       Pos    // position of IF keyword
	IfExists Pos    // position of EXISTS keyword after IF
	Name     *Ident // index name
}

type DropTableStatement struct {
	Drop     Pos    // position of DROP keyword
	Table    Pos    // position of TABLE keyword
	If       Pos    // position of IF keyword
	IfExists Pos    // position of EXISTS keyword after IF
	Name     *Ident // table name
}

type DropViewStatement struct {
	Drop     Pos    // position of DROP keyword
	View     Pos    // position of VIEW keyword
	If       Pos    // position of IF keyword
	IfExists Pos    // position of EXISTS keyword after IF
	Name     *Ident // view name
}

type Error struct {
	Pos Pos
	Msg string
}

type Exists struct {
	Not    Pos              // position of optional NOT keyword
	Exists Pos              // position of EXISTS keyword
	Lparen Pos              // position of left paren
	Select *SelectStatement // select statement
	Rparen Pos              // position of right paren
}

type ExplainStatement struct {
	Explain   Pos       // position of EXPLAIN
	Query     Pos       // position of QUERY (optional)
	QueryPlan Pos       // position of PLAN after QUERY (optional)
	Stmt      Statement // target statement
}

type Expr interface {
	Node

	IsLiteral() bool
	DataType() ExprDataType
	Pos() Pos
	// contains filtered or unexported methods
}

type ExprDataType interface {

	// the base type name e.g. int or decimal
	BaseTypeName() string
	// additional type information - intended to be used outside the language
	// layer (marshalled over json, or otherwise serialized so that consumers
	// have access to complete type information)
	// TypeInfo is not used inside the language layer itself, as the concrete
	// types (e.g. DataTypeString) are used
	TypeInfo() map[string]interface{}
	// the full type specification as a string - intended to be human readable
	TypeDescription() string
	// contains filtered or unexported methods
}

type ExprList struct {
	Lparen Pos    // position of left paren
	Exprs  []Expr // list of expressions
	Rparen Pos    // position of right paren
}

type FilterClause struct {
	Filter Pos  // position of FILTER keyword
	Lparen Pos  // position of left paren
	Where  Pos  // position of WHERE keyword
	X      Expr // filter expression
	Rparen Pos  // position of right paren
}

type FloatLit struct {
	ValuePos Pos    // literal position
	Value    string // literal value
}

type ForeignKeyArg struct {
	On         Pos // position of ON keyword
	OnUpdate   Pos // position of the UPDATE keyword
	OnDelete   Pos // position of the DELETE keyword
	Set        Pos // position of the SET keyword
	SetNull    Pos // position of the NULL keyword after SET
	SetDefault Pos // position of the DEFAULT keyword after SET
	Cascade    Pos // position of the CASCADE keyword
	Restrict   Pos // position of the RESTRICT keyword
	No         Pos // position of the NO keyword
	NoAction   Pos // position of the ACTION keyword after NO
}

type ForeignKeyConstraint struct {
	Constraint Pos    // position of CONSTRAINT keyword
	Name       *Ident // constraint name

	Foreign    Pos      // position of FOREIGN keyword (table only)
	ForeignKey Pos      // position of KEY keyword after FOREIGN (table only)
	Lparen     Pos      // position of left paren (table only)
	Columns    []*Ident // indexed columns (table only)
	Rparen     Pos      // position of right paren (table only)

	References         Pos              // position of REFERENCES keyword
	ForeignTable       *Ident           // foreign table name
	ForeignLparen      Pos              // position of left paren
	ForeignColumns     []*Ident         // column list
	ForeignRparen      Pos              // position of right paren
	Args               []*ForeignKeyArg // arguments
	Deferrable         Pos              // position of DEFERRABLE keyword
	Not                Pos              // position of NOT keyword
	NotDeferrable      Pos              // position of DEFERRABLE keyword after NOT
	Initially          Pos              // position of INITIALLY keyword
	InitiallyDeferred  Pos              // position of DEFERRED keyword after INITIALLY
	InitiallyImmediate Pos              // position of IMMEDIATE keyword after INITIALLY
}

type FrameSpec struct {
	Range  Pos // position of RANGE keyword
	Rows   Pos // position of ROWS keyword
	Groups Pos // position of GROUPS keyword

	Between Pos // position of BETWEEN keyword

	X           Expr // lhs expression
	UnboundedX  Pos  // position of lhs UNBOUNDED keyword
	PrecedingX  Pos  // position of lhs PRECEDING keyword
	CurrentX    Pos  // position of lhs CURRENT keyword
	CurrentRowX Pos  // position of lhs ROW keyword
	FollowingX  Pos  // position of lhs FOLLOWING keyword

	And Pos // position of AND keyword

	Y           Expr // lhs expression
	UnboundedY  Pos  // position of rhs UNBOUNDED keyword
	FollowingY  Pos  // position of rhs FOLLOWING keyword
	CurrentY    Pos  // position of rhs CURRENT keyword
	CurrentRowY Pos  // position of rhs ROW keyword
	PrecedingY  Pos  // position of rhs PRECEDING keyword

	Exclude           Pos // position of EXCLUDE keyword
	ExcludeNo         Pos // position of NO keyword after EXCLUDE
	ExcludeNoOthers   Pos // position of OTHERS keyword after EXCLUDE NO
	ExcludeCurrent    Pos // position of CURRENT keyword after EXCLUDE
	ExcludeCurrentRow Pos // position of ROW keyword after EXCLUDE CURRENT
	ExcludeGroup      Pos // position of GROUP keyword after EXCLUDE
	ExcludeTies       Pos // position of TIES keyword after EXCLUDE
}

type Ident struct {
	NamePos Pos    // identifier position
	Name    string // identifier name
	Quoted  bool   // true if double quoted
}

type IndexedColumn struct {
	X    Expr // column expression
	Asc  Pos  // position of optional ASC keyword
	Desc Pos  // position of optional DESC keyword
}

type InsertStatement struct {
	Insert          Pos // position of INSERT keyword
	Replace         Pos // position of REPLACE keyword
	InsertOr        Pos // position of OR keyword after INSERT
	InsertOrReplace Pos // position of REPLACE keyword after INSERT OR
	//	InsertOrRollback Pos // position of ROLLBACK keyword after INSERT OR
	//	InsertOrAbort    Pos // position of ABORT keyword after INSERT OR
	//	InsertOrFail     Pos // position of FAIL keyword after INSERT OR
	//	InsertOrIgnore   Pos // position of IGNORE keyword after INSERT OR
	Into Pos // position of INTO keyword

	Table *Ident // table name
	As    Pos    // position of AS keyword
	Alias *Ident // optional alias

	ColumnsLparen Pos      // position of column list left paren
	Columns       []*Ident // optional column list
	ColumnsRparen Pos      // position of column list right paren

	Values    Pos         // position of VALUES keyword
	TupleList []*ExprList // multiple tuples

}

type IntegerLit struct {
	ValuePos Pos    // literal position
	Value    string // literal value
}

type JoinClause struct {
	X          Source         // lhs source
	Operator   *JoinOperator  // join operator
	Y          Source         // rhs source
	Constraint JoinConstraint // join constraint
}

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

type JoinOperator struct {
	Comma Pos // position of comma
	Left  Pos // position of LEFT keyword
	Right Pos // position of RIGHT keyword
	Full  Pos // position of FULL keyword
	Outer Pos // position of OUTER keyword
	Inner Pos // position of INNER keyword
	//	Cross   Pos // position of CROSS keyword // TODO(pok) - add cross back when we do it
	Join Pos // position of JOIN keyword
}

type KeyPartitionsOption struct {
	KeyPartitions Pos  // position of KEYPARTITIONS keyword
	Expr          Expr // expression
}

type MaxConstraint struct {
	Max  Pos  // position of MAX keyword
	Expr Expr // check expression
}

type MinConstraint struct {
	Min  Pos  // position of MIN keyword
	Expr Expr // min expression
}

type Node interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

type NotNullConstraint struct {
	Constraint Pos    // position of CONSTRAINT keyword
	Name       *Ident // constraint name
	Not        Pos    // position of NOT keyword
	Null       Pos    // position of NULL keyword
}

type NullLit struct {
	ValuePos Pos
}

type OnConstraint struct {
	On Pos  // position of ON keyword
	X  Expr // constraint expression
}

type OrderingTerm struct {
	X Expr // ordering expression

	Asc  Pos // position of ASC keyword
	Desc Pos // position of DESC keyword

	Nulls      Pos // position of NULLS keyword
	NullsFirst Pos // position of FIRST keyword
	NullsLast  Pos // position of LAST keyword
}

type OverClause struct {
	Over       Pos               // position of OVER keyword
	Name       *Ident            // window name
	Definition *WindowDefinition // window definition
}

type ParameterDefinition struct {
	Name *Variable // parameter name
	Type *Type     // data type
}

type ParenExpr struct {
	Lparen Pos  // position of left paren
	X      Expr // parenthesized expression
	Rparen Pos  // position of right paren
}

type ParenSource struct {
	Lparen Pos    // position of left paren
	X      Source // nested source
	Rparen Pos    // position of right paren
	As     Pos    // position of AS keyword (select source only)
	Alias  *Ident // optional table alias (select source only)
}

type Parser struct {
	// contains filtered or unexported fields
}

type Pos struct {
	Offset int // offset, starting at 0
	Line   int // line number, starting at 1
	Column int // column number, starting at 1 (byte count)
}

type PrimaryKeyConstraint struct {
	Constraint Pos    // position of CONSTRAINT keyword
	Name       *Ident // constraint name
	Primary    Pos    // position of PRIMARY keyword
	Key        Pos    // position of KEY keyword

	Lparen  Pos      // position of left paren (table only)
	Columns []*Ident // indexed columns (table only)
	Rparen  Pos      // position of right paren (table only)

	Autoincrement Pos // position of AUTOINCREMENT keyword (column only)
}

type QualifiedRef struct {
	Table       *Ident // table name
	Dot         Pos    // position of dot
	Star        Pos    // position of * (result column only)
	Column      *Ident // column name
	ColumnIndex int

	// Set by the planner; not at parse-time
	RefDataType ExprDataType
}

type QualifiedTableName struct {
	Name          *Ident                // table name
	As            Pos                   // position of AS keyword
	Alias         *Ident                // optional table alias
	Indexed       Pos                   // position of INDEXED keyword
	IndexedBy     Pos                   // position of BY keyword after INDEXED
	Not           Pos                   // position of NOT keyword before INDEXED
	NotIndexed    Pos                   // position of NOT keyword before INDEXED
	Index         *Ident                // name of index
	OutputColumns []*SourceOutputColumn // output columns - populated during analysis
}

type Range struct {
	X   Expr // lhs expression
	And Pos  // position of AND keyword
	Y   Expr // rhs expression

	ResultDataType ExprDataType
}

type ReleaseStatement struct {
	Release   Pos    // position of RELEASE keyword
	Savepoint Pos    // position of SAVEPOINT keyword (optional)
	Name      *Ident // name of savepoint
}

type ResultColumn struct {
	Star  Pos    // position of *
	Expr  Expr   // column expression (may be "tbl.*")
	As    Pos    // position of AS keyword
	Alias *Ident // alias name
}

type RollbackStatement struct {
	Rollback      Pos    // position of ROLLBACK keyword
	Transaction   Pos    // position of TRANSACTION keyword  (optional)
	To            Pos    // position of TO keyword  (optional)
	Savepoint     Pos    // position of SAVEPOINT keyword  (optional)
	SavepointName *Ident // name of savepoint
}

type SavepointStatement struct {
	Savepoint Pos    // position of SAVEPOINT keyword
	Name      *Ident // name of savepoint
}

type Scanner struct {
	// contains filtered or unexported fields
}

type SelectStatement struct {
	WithClause *WithClause // clause containing CTEs

	Select   Pos // position of SELECT keyword
	Distinct Pos // position of DISTINCT keyword
	//	All      Pos             // position of ALL keyword
	Columns []*ResultColumn // list of result columns in the SELECT clause

	Top     Pos  // position of TOP keyword
	TopN    Pos  // position of TOPN keyword
	TopExpr Expr // TOP expr

	From   Pos    // position of FROM keyword
	Source Source // chain of tables & subqueries in FROM clause

	Where     Pos  // position of WHERE keyword
	WhereExpr Expr // condition for WHERE clause

	Group        Pos    // position of GROUP keyword
	GroupBy      Pos    // position of BY keyword after GROUP
	GroupByExprs []Expr // group by expression list
	Having       Pos    // position of HAVING keyword
	HavingExpr   Expr   // HAVING expression

	Window  Pos       // position of WINDOW keyword
	Windows []*Window // window list

	Union     Pos              // position of UNION keyword
	UnionAll  Pos              // position of ALL keyword after UNION
	Intersect Pos              // position of INTERSECT keyword
	Except    Pos              // position of EXCEPT keyword
	Compound  *SelectStatement // compounded SELECT statement

	Order         Pos             // position of ORDER keyword
	OrderBy       Pos             // position of BY keyword after ORDER
	OrderingTerms []*OrderingTerm // terms of ORDER BY clause

}

type SetLiteralExpr struct {
	Lbracket Pos    // position of left bracket
	Members  []Expr // bracketed expression
	Rbracket Pos    // position of right bracket

	ResultDataType ExprDataType
}

type ShowColumnsStatement struct {
	Show      Pos    // position of SHOW
	Columns   Pos    // position of COLUMNS
	From      Pos    // position of FROM
	TableName *Ident // name of table
}

type ShowCreateTableStatement struct {
	Show      Pos    // position of SHOW
	Create    Pos    // position of CREATE
	Table     Pos    // position of CREATE
	TableName *Ident // name of table
}

type ShowDatabasesStatement struct {
	Show      Pos // position of SHOW
	Databases Pos // position of DATABASES
}

type ShowTablesStatement struct {
	Show   Pos // position of SHOW
	Tables Pos // position of TABLES
}

type Source interface {
	Node

	SourceFromAlias(alias string) Source

	// get the possible output columns from the source
	PossibleOutputColumns() []*SourceOutputColumn

	// find output columns by name
	OutputColumnNamed(name string) (*SourceOutputColumn, error)
	OutputColumnQualifierNamed(qualifier string, name string) (*SourceOutputColumn, error)
	// contains filtered or unexported methods
}

type SourceOutputColumn struct {
	TableName   string
	ColumnName  string
	ColumnIndex int
	Datatype    ExprDataType
}

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

type StringLit struct {
	ValuePos Pos    // literal position
	Value    string // literal value (without quotes)
	IsBlob   bool   // are we a blob?
}

type SubtableColumn struct {
	Name     string
	DataType ExprDataType
}

type SysVariable struct {
	NamePos Pos   // variable position in sql
	Token   Token // parser token mapped to the variable's name/keyword
}

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

type TableValuedFunction struct {
	Name          *Ident                // table name
	As            Pos                   // position of AS keyword
	Alias         *Ident                // optional table alias
	Call          *Call                 // call
	OutputColumns []*SourceOutputColumn // output columns - populated during analysis
}

type TimeQuantumConstraint struct {
	TimeQuantum Pos  // position of TIMEQUANTUM keyword
	Expr        Expr // expression
	Ttl         Pos
	TtlExpr     Expr
}

type TimeUnitConstraint struct {
	TimeUnit  Pos  // position of TIMEUNIT keyword
	Expr      Expr // expression
	Epoch     Pos  // position of TIMEUNIT keyword
	EpochExpr Expr // expression
}

type Token int

type TupleLiteralExpr struct {
	Lbrace  Pos    // position of left brace
	Members []Expr // bracketed expression
	Rbrace  Pos    // position of right brace

	ResultDataType ExprDataType
}

type Type struct {
	Name      *Ident      // type name
	Lparen    Pos         // position of left paren (optional)
	Precision *IntegerLit // precision (optional)
	Scale     *IntegerLit // scale (optional)
	Rparen    Pos         // position of right paren (optional)
}

type UnaryExpr struct {
	OpPos Pos   // operation position
	Op    Token // operation
	X     Expr  // target expression

	ResultDataType ExprDataType
}

type UniqueConstraint struct {
	Constraint Pos    // position of CONSTRAINT keyword
	Name       *Ident // constraint name
	Unique     Pos    // position of UNIQUE keyword

	Lparen  Pos      // position of left paren (table only)
	Columns []*Ident // indexed columns (table only)
	Rparen  Pos      // position of right paren (table only)
}

type UnitsOption struct {
	Units Pos  // position of UNITS keyword
	Expr  Expr // expression
}

type UpdateStatement struct {
	WithClause *WithClause // clause containing CTEs

	Update           Pos // position of UPDATE keyword
	UpdateOr         Pos // position of OR keyword after UPDATE
	UpdateOrReplace  Pos // position of REPLACE keyword after UPDATE OR
	UpdateOrRollback Pos // position of ROLLBACK keyword after UPDATE OR
	UpdateOrAbort    Pos // position of ABORT keyword after UPDATE OR
	UpdateOrFail     Pos // position of FAIL keyword after UPDATE OR
	UpdateOrIgnore   Pos // position of IGNORE keyword after UPDATE OR

	Table *QualifiedTableName // table name

	Set         Pos           // position of SET keyword
	Assignments []*Assignment // list of column assignments
	Where       Pos           // position of WHERE keyword
	WhereExpr   Expr          // conditional expression
}

type UpsertClause struct {
	On         Pos // position of ON keyword
	OnConflict Pos // position of CONFLICT keyword after ON

	Lparen    Pos              // position of column list left paren
	Columns   []*IndexedColumn // optional indexed column list
	Rparen    Pos              // position of column list right paren
	Where     Pos              // position of WHERE keyword
	WhereExpr Expr             // optional conditional expression

	Do              Pos           // position of DO keyword
	DoNothing       Pos           // position of NOTHING keyword after DO
	DoUpdate        Pos           // position of UPDATE keyword after DO
	DoUpdateSet     Pos           // position of SET keyword after DO UPDATE
	Assignments     []*Assignment // list of column assignments
	UpdateWhere     Pos           // position of WHERE keyword for DO UPDATE SET
	UpdateWhereExpr Expr          // optional conditional expression for DO UPDATE SET
}

type UsingConstraint struct {
	Using   Pos      // position of USING keyword
	Lparen  Pos      // position of left paren
	Columns []*Ident // column list
	Rparen  Pos      // position of right paren
}

type Variable struct {
	NamePos       Pos    // variable position
	Name          string // variable name
	VariableIndex int
	VarDataType   ExprDataType
}

type VisitEndFunc func(Node) (Node, error)