lineage

type Action int8

type AstWalker struct {
	NodeCount    []int
	UnknownNodes []interface{}
	NodeStack    *utils.Stack
	Ctx          interface{}
	// Fn the function to be called when the walk.
	//when newNode is not nil and action is Continue, AstWalker.Walk will stop walk deeper and return which will cause
	//the AST node replaced by the newNode.
	Fn func(ctx interface{}, node interface{}) (newNode interface{}, action Action)
}

type Col struct {
	// Name is the column name
	Name string
	// Type is the column schema type
	Type string
}

type ColExpr struct {
	Name     string
	SrcTable []string // length == 1 means source table is deterministic, else all elements are possible.
	Scope    *utils.Stack
	// ColType is the type of column
	// Physical column is a column in input physical table, otherwise it can be
	// *tree.FuncExpr, *tree.CoalesceExpr, *tree.CaseExpr
	ColType ExprType
}

type ColExprs []ColExpr

type ColumnName string

type ColumnStmt struct {
	Name  string
	Alias string
	Typ   string
}

type DataSource interface{}

type ExprType int8

type GetProvidedCtx struct {
	Err error
}

type NormalizeCtx struct {
	UserCtx *UserCtx
	Walker  *AstWalker
	Err     error
	// contains filtered or unexported fields
}

type QueryCtx struct {
	Contexts []SubqueryCtx
	Err      error
	// contains filtered or unexported fields
}

type ReferredCols map[string]int

type Schema struct {
	Name   string
	Engine string
	Query  string
	//Physical table columns referred in Query
	ReferredColumns map[string]map[string]bool // map[table][column]bool
	Tables          Tables
	TableMap        map[string]*Table `yaml:"-"` // tableName:table
}

type SubqueryCtx struct {
	//Node tree.
	// Projections are the query output schema
	Projections []tree.SelectExpr
	// From contains the input table schema and subquery schema
	// we call these two types View
	From []View
	// Alias is the subquery alias name
	Alias string
}

type Table struct {
	Name string
	// Pk is the primary key name.
	Pk string
	// Cols are the columns in the Table
	Cols []Col
	// Index is the column names array to build an index
	Index []string
}

type TableExpr struct {
	Name        string
	AliasTo     string
	AliasClause *tree.AliasClause
	TableType   ExprType
}

type TableExprs []TableExpr

type TableStmt struct {
	Name    tree.NameParts
	Columns map[string]ColumnStmt // map[ColumnName or AliasName]ColumnStmt
	Alias   string
}

type Tables []Table

type UserCtx struct {
	//TableAliasList is `[]*tree.AliasClause`, for removing table alias after normalization.
	TableAliasList *utils.Stack
	TableCols      ColExprs     // table.column referenced in SQL statement
	DeferredFuncs  *utils.Stack // stack of `func() error`
}

type View struct {
	TableView    *TableStmt
	SubqueryView *SubqueryCtx
	NodeRef      interface{} // Node pointer to AST tree node
}