plan

package
v0.0.0-...-fc2d520 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 26, 2018 License: MIT Imports: 17 Imported by: 0

Documentation

Overview

Plan package converts the AST (expr package) into a plan, which is a DAG of tasks that comprise that plan, the planner is pluggable. The plan tasks are converted to executeable plan in exec. 

Package plan is a generated protocol buffer package.

It is generated from these files:
	plan.proto

It has these top-level messages:
	PlanPb
	SelectPb
	ContextPb
	SourcePb
	WherePb
	GroupByPb
	HavingPb
	OrderPb
	JoinMergePb
	JoinKeyPb

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrNotImplemented is plan specific error for not implemented
	ErrNotImplemented = fmt.Errorf("QLBridge.plan: not implemented")
	// ErrNoDataSource no datasource/type found
	ErrNoDataSource = fmt.Errorf("QLBridge.plan: No datasource found")
	// ErrNoPlan no plan
	ErrNoPlan = fmt.Errorf("No Plan")
)
View Source 
var (
	ErrInvalidLengthPlan = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPlan   = fmt.Errorf("proto: integer overflow")
)

Functions

func RewriteDescribeAsSelect 

func RewriteDescribeAsSelect(stmt *rel.SqlDescribe, ctx *Context) (*rel.SqlSelect, error)

func RewriteShowAsSelect 

func RewriteShowAsSelect(stmt *rel.SqlShow, ctx *Context) (*rel.SqlSelect, error)

RewriteShowAsSelect Rewrite Schema SHOW Statements AS SELECT statements so we only need a Select Planner, not separate planner for show statements

Types

type Alter 

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

Alter plan for ALTER {TABLE|COLUMN}

func NewAlter 

func NewAlter(ctx *Context, stmt *rel.SqlAlter) *Alter

NewAlter create Alter plan task.

func (*Alter) Walk 

func (m *Alter) Walk(p Planner) error

type Command 

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

Command for sql commands like SET.

func (*Command) Walk 

func (m *Command) Walk(p Planner) error

type Context 

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
}

Context for plan of a Relational task has info about the query projection, schema, function resolvers necessary to plan this statement. - may be transported across network boundaries to particpate in dag of tasks - holds references to in-mem data structures for schema - holds references to original statement - holds task specific state for errors, ids, etc (net.context) - manages Recover() - to persist/transport state

func NewContext 

func NewContext(query string) *Context

NewContext plan context

func NewContextFromPb 

func NewContextFromPb(pb *ContextPb) *Context

func (*Context) Equal 

func (m *Context) Equal(c *Context) bool

func (*Context) Recover 

func (m *Context) Recover()

called by go routines/tasks to ensure any recovery panics are captured

func (*Context) ToPB 

func (m *Context) ToPB() *ContextPb

called by go routines/tasks to ensure any recovery panics are captured

type ContextPb 

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:"-"`
}

Context

func (*ContextPb) Descriptor 

func (*ContextPb) Descriptor() ([]byte, []int)

func (*ContextPb) Marshal 

func (m *ContextPb) Marshal() (data []byte, err error)

func (*ContextPb) MarshalTo 

func (m *ContextPb) MarshalTo(data []byte) (int, error)

func (*ContextPb) ProtoMessage 

func (*ContextPb) ProtoMessage()

func (*ContextPb) Reset 

func (m *ContextPb) Reset()

func (*ContextPb) Size 

func (m *ContextPb) Size() (n int)

func (*ContextPb) String 

func (m *ContextPb) String() string

func (*ContextPb) Unmarshal 

func (m *ContextPb) Unmarshal(data []byte) error

type Create 

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

Create plan for CREATE {SCHEMA|SOURCE|DATABASE}

func NewCreate 

func NewCreate(ctx *Context, stmt *rel.SqlCreate) *Create

NewCreate creates a new Create Task plan.

func (*Create) Walk 

func (m *Create) Walk(p Planner) error

type Delete 

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

Delete plan for sql DELETE where

func (*Delete) Walk 

func (m *Delete) Walk(p Planner) error

type Drop 

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

Drop plan for DROP {SCHEMA|SOURCE|DATABASE}

func NewDrop 

func NewDrop(ctx *Context, stmt *rel.SqlDrop) *Drop

NewDrop create Drop plan task.

func (*Drop) Walk 

func (m *Drop) Walk(p Planner) error

type GroupBy 

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

GroupBy clause plan

func GroupByFromPB 

func GroupByFromPB(pb *PlanPb) *GroupBy

func NewGroupBy 

func NewGroupBy(stmt *rel.SqlSelect) *GroupBy

NewGroupBy from SqlSelect statement.

func (*GroupBy) Equal 

func (m *GroupBy) Equal(t Task) bool

func (*GroupBy) ToPb 

func (m *GroupBy) ToPb() (*PlanPb, error)

type GroupByPb 

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

Group By Plan

func (*GroupByPb) Descriptor 

func (*GroupByPb) Descriptor() ([]byte, []int)

func (*GroupByPb) Marshal 

func (m *GroupByPb) Marshal() (data []byte, err error)

func (*GroupByPb) MarshalTo 

func (m *GroupByPb) MarshalTo(data []byte) (int, error)

func (*GroupByPb) ProtoMessage 

func (*GroupByPb) ProtoMessage()

func (*GroupByPb) Reset 

func (m *GroupByPb) Reset()

func (*GroupByPb) Size 

func (m *GroupByPb) Size() (n int)

func (*GroupByPb) String 

func (m *GroupByPb) String() string

func (*GroupByPb) Unmarshal 

func (m *GroupByPb) Unmarshal(data []byte) error

type Having 

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

Having post-aggregation filter plan.

func HavingFromPB 

func HavingFromPB(pb *PlanPb) *Having

func NewHaving 

func NewHaving(stmt *rel.SqlSelect) *Having

NewHaving from SqlSelect statement.

func (*Having) Equal 

func (m *Having) Equal(t Task) bool

func (*Having) ToPb 

func (m *Having) ToPb() (*PlanPb, error)

type HavingPb 

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

func (*HavingPb) Descriptor 

func (*HavingPb) Descriptor() ([]byte, []int)

func (*HavingPb) Marshal 

func (m *HavingPb) Marshal() (data []byte, err error)

func (*HavingPb) MarshalTo 

func (m *HavingPb) MarshalTo(data []byte) (int, error)

func (*HavingPb) ProtoMessage 

func (*HavingPb) ProtoMessage()

func (*HavingPb) Reset 

func (m *HavingPb) Reset()

func (*HavingPb) Size 

func (m *HavingPb) Size() (n int)

func (*HavingPb) String 

func (m *HavingPb) String() string

func (*HavingPb) Unmarshal 

func (m *HavingPb) Unmarshal(data []byte) error

type Insert 

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

Insert plan

func (*Insert) Walk 

func (m *Insert) Walk(p Planner) error

type Into 

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

Into Select INTO table

func (*Into) Equal 

func (m *Into) Equal(t Task) bool

Equal compares equality of two tasks.

type JoinKey 

type JoinKey struct {
	*PlanBase
	Source *Source
}

JoinKey plan

func NewJoinKey 

func NewJoinKey(s *Source) *JoinKey

NewJoinKey creates JoinKey from Source.

func (*JoinKey) Equal 

func (m *JoinKey) Equal(t Task) bool

type JoinKeyPb 

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

func (*JoinKeyPb) Descriptor 

func (*JoinKeyPb) Descriptor() ([]byte, []int)

func (*JoinKeyPb) Marshal 

func (m *JoinKeyPb) Marshal() (data []byte, err error)

func (*JoinKeyPb) MarshalTo 

func (m *JoinKeyPb) MarshalTo(data []byte) (int, error)

func (*JoinKeyPb) ProtoMessage 

func (*JoinKeyPb) ProtoMessage()

func (*JoinKeyPb) Reset 

func (m *JoinKeyPb) Reset()

func (*JoinKeyPb) Size 

func (m *JoinKeyPb) Size() (n int)

func (*JoinKeyPb) String 

func (m *JoinKeyPb) String() string

func (*JoinKeyPb) Unmarshal 

func (m *JoinKeyPb) Unmarshal(data []byte) error

type JoinMerge 

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

JoinMerge 2 source/input tasks for join

func NewJoinMerge 

func NewJoinMerge(l, r Task, lf, rf *rel.SqlSource) *JoinMerge

NewJoinMerge A parallel join merge, uses Key() as value to merge two different input task/channels. 

left source  ->
               \
                 --  join  -->
               /
right source ->

func (*JoinMerge) Equal 

func (m *JoinMerge) Equal(t Task) bool

type JoinMergePb 

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

func (*JoinMergePb) Descriptor 

func (*JoinMergePb) Descriptor() ([]byte, []int)

func (*JoinMergePb) Marshal 

func (m *JoinMergePb) Marshal() (data []byte, err error)

func (*JoinMergePb) MarshalTo 

func (m *JoinMergePb) MarshalTo(data []byte) (int, error)

func (*JoinMergePb) ProtoMessage 

func (*JoinMergePb) ProtoMessage()

func (*JoinMergePb) Reset 

func (m *JoinMergePb) Reset()

func (*JoinMergePb) Size 

func (m *JoinMergePb) Size() (n int)

func (*JoinMergePb) String 

func (m *JoinMergePb) String() string

func (*JoinMergePb) Unmarshal 

func (m *JoinMergePb) Unmarshal(data []byte) error

type NextIdFunc 

type NextIdFunc func() uint64

NextIdFunc is the id generation function to give statements their own id 

var NextId NextIdFunc

NextId is the global next id generation function

type Order 

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

Order By clause

func NewOrder 

func NewOrder(stmt *rel.SqlSelect) *Order

NewOrder from SqlSelect statement.

func OrderFromPB 

func OrderFromPB(pb *PlanPb) *Order

func (*Order) Equal 

func (m *Order) Equal(t Task) bool

func (*Order) ToPb 

func (m *Order) ToPb() (*PlanPb, error)

type OrderPb 

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

func (*OrderPb) Descriptor 

func (*OrderPb) Descriptor() ([]byte, []int)

func (*OrderPb) Marshal 

func (m *OrderPb) Marshal() (data []byte, err error)

func (*OrderPb) MarshalTo 

func (m *OrderPb) MarshalTo(data []byte) (int, error)

func (*OrderPb) ProtoMessage 

func (*OrderPb) ProtoMessage()

func (*OrderPb) Reset 

func (m *OrderPb) Reset()

func (*OrderPb) Size 

func (m *OrderPb) Size() (n int)

func (*OrderPb) String 

func (m *OrderPb) String() string

func (*OrderPb) Unmarshal 

func (m *OrderPb) Unmarshal(data []byte) error

type PlanBase 

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

PlanBase holds dag of child tasks

func NewPlanBase 

func NewPlanBase(isParallel bool) *PlanBase

func (*PlanBase) Add 

func (m *PlanBase) Add(task Task) error

func (*PlanBase) Children 

func (m *PlanBase) Children() []Task

func (*PlanBase) Close 

func (m *PlanBase) Close() error

func (*PlanBase) Equal 

func (m *PlanBase) Equal(t Task) bool

func (*PlanBase) EqualBase 

func (m *PlanBase) EqualBase(p *PlanBase) bool

func (*PlanBase) IsParallel 

func (m *PlanBase) IsParallel() bool

func (*PlanBase) IsSequential 

func (m *PlanBase) IsSequential() bool

func (*PlanBase) Run 

func (m *PlanBase) Run() error

func (*PlanBase) SetParallel 

func (m *PlanBase) SetParallel()

func (*PlanBase) SetSequential 

func (m *PlanBase) SetSequential()

func (*PlanBase) ToPb 

func (m *PlanBase) ToPb() (*PlanPb, error)

func (*PlanBase) Walk 

func (m *PlanBase) Walk(p Planner) error

type PlanPb 

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:"-"`
}

The generic Node, must be exactly one of these types

func (*PlanPb) Descriptor 

func (*PlanPb) Descriptor() ([]byte, []int)

func (*PlanPb) Marshal 

func (m *PlanPb) Marshal() (data []byte, err error)

func (*PlanPb) MarshalTo 

func (m *PlanPb) MarshalTo(data []byte) (int, error)

func (*PlanPb) ProtoMessage 

func (*PlanPb) ProtoMessage()

func (*PlanPb) Reset 

func (m *PlanPb) Reset()

func (*PlanPb) Size 

func (m *PlanPb) Size() (n int)

func (*PlanPb) String 

func (m *PlanPb) String() string

func (*PlanPb) Unmarshal 

func (m *PlanPb) Unmarshal(data []byte) error

type Planner 

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
}

Planner interface for planners. Planners take a statement and walk the statement to create a DAG of tasks representing necessary sub-tasks to fulfil statement. implementations of planners: - qlbridge/exec package implements a non-distributed query-planner - dataux/planner implements a distributed query-planner

type PlannerDefault 

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

PlannerDefault is implementation of Planner that creates a dag of plan.Tasks that will be turned into execution plan by executor. This is a simple planner but can be over-ridden by providing a Planner that will supercede any single or more visit methods. - stateful, specific to a single request

func NewPlanner 

func NewPlanner(ctx *Context) *PlannerDefault

NewPlanner creates a new default planner with context.

func (*PlannerDefault) WalkAlter 

func (m *PlannerDefault) WalkAlter(p *Alter) error

WalkAlter walk a ALTER Plan to create the dag of tasks forAlter.

func (*PlannerDefault) WalkCommand 

func (m *PlannerDefault) WalkCommand(p *Command) error

WalkCommand walks the command statement

func (*PlannerDefault) WalkCreate 

func (m *PlannerDefault) WalkCreate(p *Create) error

WalkCreate walk a Create Plan to create the dag of tasks for Create.

func (*PlannerDefault) WalkDelete 

func (m *PlannerDefault) WalkDelete(p *Delete) error

func (*PlannerDefault) WalkDrop 

func (m *PlannerDefault) WalkDrop(p *Drop) error

WalkDrop walks the draop statement

func (*PlannerDefault) WalkInsert 

func (m *PlannerDefault) WalkInsert(p *Insert) error

func (*PlannerDefault) WalkInto 

func (m *PlannerDefault) WalkInto(p *Into) error

func (*PlannerDefault) WalkLiteralQuery 

func (m *PlannerDefault) WalkLiteralQuery(p *Select) error

WalkLiteralQuery Handle Literal queries such as "SELECT 1, @var;"

func (*PlannerDefault) WalkPreparedStatement 

func (m *PlannerDefault) WalkPreparedStatement(p *PreparedStatement) error

WalkPreparedStatement not implemented

func (*PlannerDefault) WalkProjectionFinal 

func (m *PlannerDefault) WalkProjectionFinal(p *Select) error

WalkProjectionFinal walk the select plan to create final projection.

func (*PlannerDefault) WalkProjectionSource 

func (m *PlannerDefault) WalkProjectionSource(p *Source) error

WalkProjectionSource non final projection (ie, per from).

func (*PlannerDefault) WalkSelect 

func (m *PlannerDefault) WalkSelect(p *Select) error

WalkSelect walk a select statement filling out plan.

func (*PlannerDefault) WalkSourceSelect 

func (m *PlannerDefault) WalkSourceSelect(p *Source) error

WalkSourceSelect is a single source select

func (*PlannerDefault) WalkUpdate 

func (m *PlannerDefault) WalkUpdate(p *Update) error

func (*PlannerDefault) WalkUpsert 

func (m *PlannerDefault) WalkUpsert(p *Upsert) error

type PreparedStatement 

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

PreparedStatement plan

func (*PreparedStatement) Walk 

func (m *PreparedStatement) Walk(p Planner) error

type Projection 

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

Projection holds original query for column info and schema/field types

func NewProjectionFinal 

func NewProjectionFinal(ctx *Context, p *Select) (*Projection, error)

Final Projections project final select columns for result-writing

func NewProjectionInProcess 

func NewProjectionInProcess(stmt *rel.SqlSelect) *Projection

func NewProjectionStatic 

func NewProjectionStatic(proj *rel.Projection) *Projection

A static projection has already had its column/types defined 

and doesn't need to use internal schema to find it, often internal SHOW/DESCRIBE

func ProjectionFromPB 

func ProjectionFromPB(pb *PlanPb, sel *rel.SqlSelect) *Projection

ProjectionFromPB create Projection from Protobuf.

func (*Projection) Equal 

func (m *Projection) Equal(t Task) bool

Equal checks if two tasks are equal.

func (*Projection) ToPb 

func (m *Projection) ToPb() (*PlanPb, error)

ToPb to protobuf.

type Proto 

type Proto interface {
	proto.Marshaler
	proto.Unmarshaler
}

Proto interface to ensure implements protobuf marshalling.

type SchemaLoader 

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

SchemaLoader func interface for loading schema.

type Select 

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

Select plan

func SelectFromPB 

func SelectFromPB(pb *PlanPb, loader SchemaLoader) (*Select, error)

func SelectPlanFromPbBytes 

func SelectPlanFromPbBytes(pb []byte, loader SchemaLoader) (*Select, error)

SelectPlanFromPbBytes Create a sql plan from pb.

func (*Select) Equal 

func (m *Select) Equal(t Task) bool

func (*Select) IsSchemaQuery 

func (m *Select) IsSchemaQuery() bool

func (*Select) Marshal 

func (m *Select) Marshal() ([]byte, error)

func (*Select) MarshalTo 

func (m *Select) MarshalTo(data []byte) (int, error)

func (*Select) NeedsFinalProjection 

func (m *Select) NeedsFinalProjection() bool

func (*Select) Size 

func (m *Select) Size() (n int)

func (*Select) Unmarshal 

func (m *Select) Unmarshal(data []byte) error

func (*Select) Walk 

func (m *Select) Walk(p Planner) error

type SelectPb 

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:"-"`
}

Select Plan

func (*SelectPb) Descriptor 

func (*SelectPb) Descriptor() ([]byte, []int)

func (*SelectPb) Marshal 

func (m *SelectPb) Marshal() (data []byte, err error)

func (*SelectPb) MarshalTo 

func (m *SelectPb) MarshalTo(data []byte) (int, error)

func (*SelectPb) ProtoMessage 

func (*SelectPb) ProtoMessage()

func (*SelectPb) Reset 

func (m *SelectPb) Reset()

func (*SelectPb) Size 

func (m *SelectPb) Size() (n int)

func (*SelectPb) String 

func (m *SelectPb) String() string

func (*SelectPb) Unmarshal 

func (m *SelectPb) Unmarshal(data []byte) error

type SelectTask 

type SelectTask interface {
	Equal(Task) bool
}

SelectTask interface to check equality

type Source 

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
}

Source defines a source Within a Select query, it optionally has multiple sources such as sub-select, join, etc this is the plan for a each source

func NewSource 

func NewSource(ctx *Context, stmt *rel.SqlSource, isFinal bool) (*Source, error)

NewSource create a new plan Task for data source

func NewSourceStaticPlan 

func NewSourceStaticPlan(ctx *Context) *Source

func SourceFromPB 

func SourceFromPB(pb *PlanPb, ctx *Context) (*Source, error)

func (*Source) Context 

func (m *Source) Context() *Context

func (*Source) Equal 

func (m *Source) Equal(t Task) bool

func (*Source) IsSchemaQuery 

func (m *Source) IsSchemaQuery() bool

func (*Source) LoadConn 

func (m *Source) LoadConn() error

func (*Source) Marshal 

func (m *Source) Marshal() ([]byte, error)

func (*Source) MarshalTo 

func (m *Source) MarshalTo(data []byte) (n int, err error)

func (*Source) Size 

func (m *Source) Size() (n int)

func (*Source) ToPb 

func (m *Source) ToPb() (*PlanPb, error)

func (*Source) Unmarshal 

func (m *Source) Unmarshal(data []byte) error

func (*Source) Walk 

func (m *Source) Walk(p Planner) error

type SourcePb 

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:"-"`
}

Source Plan is a plan for single source of select query, of which many may exist (joins, sub-querys etc)

func (*SourcePb) Descriptor 

func (*SourcePb) Descriptor() ([]byte, []int)

func (*SourcePb) Marshal 

func (m *SourcePb) Marshal() (data []byte, err error)

func (*SourcePb) MarshalTo 

func (m *SourcePb) MarshalTo(data []byte) (int, error)

func (*SourcePb) ProtoMessage 

func (*SourcePb) ProtoMessage()

func (*SourcePb) Reset 

func (m *SourcePb) Reset()

func (*SourcePb) Size 

func (m *SourcePb) Size() (n int)

func (*SourcePb) String 

func (m *SourcePb) String() string

func (*SourcePb) Unmarshal 

func (m *SourcePb) Unmarshal(data []byte) error

type SourcePlanner 

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

SourcePlanner Sources can often do their own planning for sub-select statements ie mysql can do its own (select, projection) mongo, es can as well - provide interface to allow passing down select planning to source

type Task 

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)
}

Task interface allows different portions of distributed plans (where, group-by, source-scan, project) to have its own planner. Output is a DAG of tasks to be given to executor. - may be parallel or sequential - must be serializeable to participate in cross network tasks

func SelectTaskFromTaskPb 

func SelectTaskFromTaskPb(pb *PlanPb, ctx *Context, sel *rel.SqlSelect) (Task, error)

SelectTaskFromTaskPb create plan task for SqlSelect from pb.

func WalkStmt 

func WalkStmt(ctx *Context, stmt rel.SqlStatement, planner Planner) (Task, error)

WalkStmt Walk given statement for given Planner to produce a query plan which is a plan.Task and children, ie a DAG of tasks

type Update 

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

Update plan for sql Update statements.

func (*Update) Walk 

func (m *Update) Walk(p Planner) error

type Upsert 

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

Upsert task (not official sql) for sql Upsert.

func (*Upsert) Walk 

func (m *Upsert) Walk(p Planner) error

type Where 

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

Where pre-aggregation filter

func NewWhere 

func NewWhere(stmt *rel.SqlSelect) *Where

NewWhere new Where Task from SqlSelect statement.

func NewWhereFinal 

func NewWhereFinal(stmt *rel.SqlSelect) *Where

NewWhereFinal from SqlSelect statement.

func WhereFromPB 

func WhereFromPB(pb *PlanPb) *Where

func (*Where) Equal 

func (m *Where) Equal(t Task) bool

func (*Where) ToPb 

func (m *Where) ToPb() (*PlanPb, error)

type WherePb 

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:"-"`
}

Where Plan

func (*WherePb) Descriptor 

func (*WherePb) Descriptor() ([]byte, []int)

func (*WherePb) Marshal 

func (m *WherePb) Marshal() (data []byte, err error)

func (*WherePb) MarshalTo 

func (m *WherePb) MarshalTo(data []byte) (int, error)

func (*WherePb) ProtoMessage 

func (*WherePb) ProtoMessage()

func (*WherePb) Reset 

func (m *WherePb) Reset()

func (*WherePb) Size 

func (m *WherePb) Size() (n int)

func (*WherePb) String 

func (m *WherePb) String() string

func (*WherePb) Unmarshal 

func (m *WherePb) Unmarshal(data []byte) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.