ast

type AliasRef struct {
	// MUST have, It is used for evaluation
	Expression Expr

	// optional, lazy set when calculating isAggregate
	IsAggregate *bool
	// contains filtered or unexported fields
}

type ArrayType struct {
	Type DataType
	FieldType
}

type ArrowExpr struct {
	Expr Expr
}

type BasicType struct {
	Type DataType
	FieldType
}

type BetweenExpr struct {
	Lower  Expr
	Higher Expr
}

type BinaryExpr struct {
	OP  Token
	LHS Expr
	RHS Expr
}

type BooleanLiteral struct {
	Val bool
}

type BracketExpr struct {
	Expr Expr
}

type Call struct {
	Name     string
	FuncId   int
	FuncType FuncType
	Args     []Expr
	// This is used for analytic functions.
	// In planner, all analytic functions are planned to calculate in analytic_op which produce a new field.
	// This cachedField cached the new field name and when evaluating, just returned the field access evaluated value.
	CachedField string
	Cached      bool
	Partition   *PartitionExpr
	WhenExpr    Expr
}

type CaseExpr struct {
	// The compare value Expression. It can be a value Expression or nil.
	// When it is nil, the WhenClause Expr must be a logical(comparison) Expression
	Value       Expr
	WhenClauses []*WhenClause
	ElseClause  Expr
}

type ColFuncField struct {
	Name string
	Expr Expr
}

type ColonExpr struct {
	Start Expr
	End   Expr
}

type DataType int

type DescribeStreamStatement struct {
	Name string

	Statement
}

type DescribeTableStatement struct {
	Name string

	Statement
}

type Dimension struct {
	Expr Expr

	Node
}

type Dimensions []Dimension

type DropStreamStatement struct {
	Name string

	Statement
}

type DropTableStatement struct {
	Name string

	Statement
}

type ExplainStreamStatement struct {
	Name string

	Statement
}

type ExplainTableStatement struct {
	Name string

	Statement
}

type Expr interface {
	Node

	// String function for the explain grammar, convert Expr to String
	String() string
	// contains filtered or unexported methods
}

type Field struct {
	Name  string
	AName string
	Expr  Expr

	Node
}

type FieldRef struct {
	// optional, bind in analyzer, empty means alias, default means not set
	// MUST have after binding for SQL fields. For 1.2,1.3 and 1.4, use special constant as stream name
	StreamName StreamName
	// optional, set only once. For selections, empty name will be assigned a default name
	// MUST have after binding, assign a name for 1.4
	Name string
	// Only for alias
	*AliasRef
}

type FieldType interface {
	// contains filtered or unexported methods
}

type Fields []Field

type FuncType int

type IndexExpr struct {
	Index Expr
}

type IntegerLiteral struct {
	Val int64
}

type Join struct {
	Name     string
	Alias    string
	JoinType JoinType
	Expr     Expr

	Node
}

type JoinType int

type Joins []Join

type JsonFieldRef struct {
	Name string
}

type JsonStreamField struct {
	Type       string                      `json:"type"`
	Items      *JsonStreamField            `json:"items,omitempty"`
	Properties map[string]*JsonStreamField `json:"properties,omitempty"`

	Selected bool
}

type LikePattern struct {
	Expr    Expr
	Pattern *regexp.Regexp
}

type LimitExpr struct {
	LimitCount *IntegerLiteral
}

type Literal interface {
	Expr
	// contains filtered or unexported methods
}

type MetaRef struct {
	StreamName StreamName
	Name       string
}

type NameNode interface {
	Node
	GetName() string
}

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

type NumberLiteral struct {
	Val float64
}

type Options struct {
	DATASOURCE        string `json:"datasource,omitempty"`
	KEY               string `json:"key,omitempty"`
	FORMAT            string `json:"format,omitempty"`
	CONF_KEY          string `json:"confKey,omitempty"`
	TYPE              string `json:"type,omitempty"`
	STRICT_VALIDATION bool   `json:"strictValidation,omitempty"`
	TIMESTAMP         string `json:"timestamp,omitempty"`
	TIMESTAMP_FORMAT  string `json:"timestampFormat,omitempty"`
	SHARED            bool   `json:"shared,omitempty"`
	SCHEMAID          string `json:"schemaid,omitempty"`
	// for scan table only
	RETAIN_SIZE int `json:"retainSize,omitempty"`
	// for table only, to distinguish lookup & scan
	KIND string `json:"kind,omitempty"`
	// for delimited format only
	DELIMITER string `json:"delimiter,omitempty"`

	RuleID       string                      `json:"-"`
	Schema       map[string]*JsonStreamField `json:"-"`
	IsWildCard   bool                        `json:"-"`
	IsSchemaLess bool                        `json:"-"`
	StreamName   string                      `json:"-"`
}

type ParenExpr struct {
	Expr Expr
}

type PartitionExpr struct {
	Exprs []Expr
}

type RecType struct {
	StreamFields StreamFields
	FieldType
}

type SelectStatement struct {
	Fields     Fields
	Sources    Sources
	Joins      Joins
	Condition  Expr
	Limit      Expr
	Dimensions Dimensions
	Having     Expr
	SortFields SortFields

	Statement
}

type ShowStreamsStatement struct {
	Statement
}

type ShowTablesStatement struct {
	Statement
}

type SortField struct {
	Name       string
	StreamName StreamName
	Uname      string // unique name of a field
	Ascending  bool
	FieldExpr  Expr

	Expr
}

type SortFields []SortField

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

type Sources []Source

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

type StreamField struct {
	Name string
	FieldType
}

type StreamFields []StreamField

type StreamName string

type StreamStmt struct {
	Name         StreamName
	StreamFields StreamFields
	Options      *Options
	StreamType   StreamType // default to TypeStream

	Statement
}

type StreamType int

type StringLiteral struct {
	Val string
}

type Table struct {
	Name  string
	Alias string
	Source
}

type TimeLiteral struct {
	Val Token
}

type Token int

type ValidateAbleExpr interface {
	ValidateExpr() error
}

type ValueSetExpr struct {
	LiteralExprs []Expr // ("A", "B", "C") or (1, 2, 3)
	ArrayExpr    Expr
}

type Visitor interface {
	Visit(Node) bool
}

type WhenClause struct {
	// The condition Expression
	Expr   Expr
	Result Expr
}

type Wildcard struct {
	Token   Token
	Replace []Field
	Except  []string
}

type Window struct {
	TriggerCondition Expr
	WindowType       WindowType
	Delay            *IntegerLiteral
	Length           *IntegerLiteral
	Interval         *IntegerLiteral
	TimeUnit         *TimeLiteral
	Filter           Expr
	Expr
}

type WindowType int