plan

type Alter struct {
	*PlanBase
	Ctx  *Context
	Stmt *rel.SqlAlter
}

type Command struct {
	*PlanBase
	Ctx  *Context
	Stmt *rel.SqlCommand
}

type Context struct {

	// Stateful Fields that are transported to participate across network/nodes
	context.Context        // go context for cancelation in plan
	SchemaName      string // schema name to load schema with

	Raw        string           // Raw sql statement
	Stmt       rel.SqlStatement // Original Statement
	Projection *Projection      // Projection for this context optional

	// Local in-memory helpers not transported across network
	Session expr.ContextReadWriter // Session for this connection
	Schema  *schema.Schema         // this schema for this connection
	Funcs   expr.FuncResolver      // Local/Dialect specific functions

	// From configuration
	DisableRecover bool

	// Local State
	Errors []error
	// contains filtered or unexported fields
}

type ContextPb struct {
	Schema           string `protobuf:"bytes,1,req,name=schema" json:"schema"`
	Id               uint64 `protobuf:"varint,2,req,name=id" json:"id"`
	Fingerprint      uint64 `protobuf:"varint,3,req,name=fingerprint" json:"fingerprint"`
	XXX_unrecognized []byte `json:"-"`
}

type Create struct {
	*PlanBase
	Ctx  *Context
	Stmt *rel.SqlCreate
}

type Delete struct {
	*PlanBase
	Stmt   *rel.SqlDelete
	Source schema.ConnDeletion
}

type Drop struct {
	*PlanBase
	Ctx  *Context
	Stmt *rel.SqlDrop
}

type GroupBy struct {
	*PlanBase
	Stmt    *rel.SqlSelect
	Partial bool
}

type GroupByPb struct {
	Select           *rel.SqlSelectPb `protobuf:"bytes,1,opt,name=select" json:"select,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

type Having struct {
	*PlanBase
	Stmt *rel.SqlSelect
}

type HavingPb struct {
	Select           *rel.SqlSelectPb `protobuf:"bytes,1,opt,name=select" json:"select,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

type Insert struct {
	*PlanBase
	Stmt   *rel.SqlInsert
	Source schema.ConnUpsert
}

type Into struct {
	*PlanBase
	Stmt *rel.SqlInto
}

type JoinKey struct {
	*PlanBase
	Source *Source
}

type JoinKeyPb struct {
	Having           *expr.NodePb `protobuf:"bytes,1,opt,name=having" json:"having,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

type JoinMerge struct {
	*PlanBase
	Left      Task
	Right     Task
	LeftFrom  *rel.SqlSource
	RightFrom *rel.SqlSource
	ColIndex  map[string]int
}

type JoinMergePb struct {
	Having           *expr.NodePb `protobuf:"bytes,1,opt,name=having" json:"having,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

type NextIdFunc func() uint64

type Order struct {
	*PlanBase
	Stmt *rel.SqlSelect
}

type OrderPb struct {
	Select           *rel.SqlSelectPb `protobuf:"bytes,1,opt,name=select" json:"select,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

type PlanBase struct {
	RootTask Task // Root task
	// contains filtered or unexported fields
}

type PlanPb struct {
	Parallel         bool              `protobuf:"varint,1,req,name=parallel" json:"parallel"`
	Select           *SelectPb         `protobuf:"bytes,3,opt,name=select" json:"select,omitempty"`
	Source           *SourcePb         `protobuf:"bytes,4,opt,name=source" json:"source,omitempty"`
	Where            *WherePb          `protobuf:"bytes,5,opt,name=where" json:"where,omitempty"`
	Having           *HavingPb         `protobuf:"bytes,6,opt,name=having" json:"having,omitempty"`
	GroupBy          *GroupByPb        `protobuf:"bytes,7,opt,name=groupBy" json:"groupBy,omitempty"`
	Order            *OrderPb          `protobuf:"bytes,8,opt,name=order" json:"order,omitempty"`
	JoinMerge        *JoinMergePb      `protobuf:"bytes,9,opt,name=joinMerge" json:"joinMerge,omitempty"`
	JoinKey          *JoinKeyPb        `protobuf:"bytes,10,opt,name=joinKey" json:"joinKey,omitempty"`
	Projection       *rel.ProjectionPb `protobuf:"bytes,11,opt,name=projection" json:"projection,omitempty"`
	Children         []*PlanPb         `protobuf:"bytes,12,rep,name=children" json:"children,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

type Planner interface {
	// DML Statements
	WalkSelect(p *Select) error
	WalkInsert(p *Insert) error
	WalkUpsert(p *Upsert) error
	WalkUpdate(p *Update) error
	WalkDelete(p *Delete) error
	WalkInto(p *Into) error
	WalkSourceSelect(p *Source) error
	WalkProjectionSource(p *Source) error
	WalkProjectionFinal(p *Select) error

	// Other Statements
	WalkPreparedStatement(p *PreparedStatement) error
	WalkCommand(p *Command) error

	// DDL operations
	WalkCreate(p *Create) error
	WalkDrop(p *Drop) error
	WalkAlter(p *Alter) error
}

type PlannerDefault struct {
	Planner Planner
	Ctx     *Context
	// contains filtered or unexported fields
}

type PreparedStatement struct {
	*PlanBase
	Stmt *rel.PreparedStatement
}

type Projection struct {
	*PlanBase
	Final bool // Is this final projection or not?
	P     *Select
	Stmt  *rel.SqlSelect
	Proj  *rel.Projection
}

type Proto interface {
	proto.Marshaler
	proto.Unmarshaler
}

type SchemaLoader func(name string) (*schema.Schema, error)

type Select struct {
	*PlanBase
	Ctx      *Context
	From     []*Source
	Stmt     *rel.SqlSelect
	ChildDag bool
	// contains filtered or unexported fields
}

type SelectPb struct {
	Select           *rel.SqlSelectPb `protobuf:"bytes,1,req,name=select" json:"select,omitempty"`
	Context          *ContextPb       `protobuf:"bytes,2,opt,name=context" json:"context,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

type SelectTask interface {
	Equal(Task) bool
}

type Source struct {
	*PlanBase

	// Request Information, if cross-node distributed query must be serialized
	*SourcePb
	Stmt     *rel.SqlSource  // The sub-query statement (may have been rewritten)
	Proj     *rel.Projection // projection for this sub-query
	ExecPlan Proto           // If SourceExec has a plan?
	Custom   u.JsonHelper    // Source specific context info

	DataSource schema.Source  // The data source for this From
	Conn       schema.Conn    // Connection for this source, only for this source/task
	Schema     *schema.Schema // Schema for this source/from
	Tbl        *schema.Table  // Table schema for this From
	Static     []driver.Value // this is static data source
	Cols       []string
	// contains filtered or unexported fields
}

type SourcePb struct {
	// do we need group-by, join, partition key for routing purposes?
	NeedsHashableKey bool `protobuf:"varint,2,req,name=needsHashableKey" json:"needsHashableKey"`
	// Is this final projection or not?  non finals are partial-sub-query types
	Final bool `protobuf:"varint,3,req,name=final" json:"final"`
	// Is this plan complete as is?  skip remaining plan walk steps
	Complete         bool              `protobuf:"varint,4,req,name=complete" json:"complete"`
	Join             bool              `protobuf:"varint,5,req,name=join" json:"join"`
	SourceExec       bool              `protobuf:"varint,6,req,name=sourceExec" json:"sourceExec"`
	Custom           []byte            `protobuf:"bytes,7,opt,name=custom" json:"custom,omitempty"`
	SqlSource        *rel.SqlSourcePb  `protobuf:"bytes,8,opt,name=sqlSource" json:"sqlSource,omitempty"`
	Projection       *rel.ProjectionPb `protobuf:"bytes,9,opt,name=projection" json:"projection,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

type SourcePlanner interface {
	// given our request statement, turn that into a plan.Task.
	WalkSourceSelect(pl Planner, s *Source) (Task, error)
}

type Task interface {
	// Walk, give a planner to this task to allow
	// Task to call appropriate parts of planner.
	Walk(p Planner) error

	// Children tasks of this, this task may be participating
	// in parents.
	Children() []Task
	// Add a child to this dag
	Add(Task) error
	IsSequential() bool
	SetSequential()
	IsParallel() bool
	SetParallel()
	Equal(Task) bool
	ToPb() (*PlanPb, error)
}

type Update struct {
	*PlanBase
	Stmt   *rel.SqlUpdate
	Source schema.ConnUpsert
}

type Upsert struct {
	*PlanBase
	Stmt   *rel.SqlUpsert
	Source schema.ConnUpsert
}

type Where struct {
	*PlanBase
	Final bool
	Stmt  *rel.SqlSelect
}

type WherePb struct {
	Select           *rel.SqlSelectPb `protobuf:"bytes,1,opt,name=select" json:"select,omitempty"`
	Final            bool             `protobuf:"varint,2,req,name=final" json:"final"`
	XXX_unrecognized []byte           `json:"-"`
}