engine

package
v2.2.0-rc.1+incompatible Latest Latest
Warning

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

Go to latest
Published: May 18, 2018 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source
const (
	// DeleteUnsharded is for routing a delete statement
	// to an unsharded keyspace.
	DeleteUnsharded = DeleteOpcode(iota)
	// DeleteEqual is for routing a delete statement
	// to a single shard. Requires: A Vindex, a single
	// Value, and an OwnedVindexQuery, which will be used to
	// determine if lookup rows need to be deleted.
	DeleteEqual
	// DeleteScatter is for routing a scattered
	// delete statement.
	DeleteScatter
	// DeleteByDestination is to route explicitly to a given
	// target destination. Is used when the query explicitly sets a target destination:
	// in the from clause:
	// e.g: DELETE FROM `keyspace[-]`.x1 LIMIT 100
	DeleteByDestination
)

This is the list of DeleteOpcode values.

View Source
const (
	// InsertUnsharded is for routing an insert statement
	// to an unsharded keyspace.
	InsertUnsharded = InsertOpcode(iota)
	// InsertSharded is for routing an insert statement
	// to individual shards. Requires: A list of Values, one
	// for each ColVindex. If the table has an Autoinc column,
	// A Generate subplan must be created.
	InsertSharded
	// InsertShardedIgnore is for INSERT IGNORE and
	// INSERT...ON DUPLICATE KEY constructs.
	InsertShardedIgnore
)
View Source
const (
	NormalJoin = JoinOpcode(iota)
	LeftJoin
)

This is the list of JoinOpcode values.

View Source
const (
	AggregateCount = AggregateOpcode(iota)
	AggregateSum
	AggregateMin
	AggregateMax
)

These constants list the possible aggregate opcodes.

View Source
const (
	// SelectUnsharded is the opcode for routing a
	// select statement to an unsharded database.
	SelectUnsharded = RouteOpcode(iota)
	// SelectEqualUnique is for routing a query to
	// a single shard. Requires: A Unique Vindex, and
	// a single Value.
	SelectEqualUnique
	// SelectEqual is for routing a query using a
	// non-unique vindex. Requires: A Vindex, and
	// a single Value.
	SelectEqual
	// SelectIN is for routing a query that has an IN
	// clause using a Vindex. Requires: A Vindex,
	// and a Values list.
	SelectIN
	// SelectScatter is for routing a scatter query
	// to all shards of a keyspace.
	SelectScatter
	// SelectNext is for fetching from a sequence.
	SelectNext
	// SelectDBA is for executing a DBA statement.
	SelectDBA
)

This is the list of RouteOpcode values.

View Source
const (
	// UpdateUnsharded is for routing an update statement
	// to an unsharded keyspace.
	UpdateUnsharded = UpdateOpcode(iota)
	// UpdateEqual is for routing an update statement
	// to a single shard: Requires: A Vindex, and
	// a single Value.
	UpdateEqual
	// UpdateScatter is for routing a scattered
	// update statement.
	UpdateScatter
)

This is the list of UpdateOpcode values.

View Source
const (
	VindexNone = VindexOpcode(iota)
	VindexMap
	NumVindexCodes
)

These are opcode values for VindexFunc.

View Source
const ListVarName = "__vals"

ListVarName is a reserved bind var name for list vars. This is used for sending different IN clause values to different shards.

View Source
const SeqVarName = "__seq"

SeqVarName is a reserved bind var name for sequence values.

Variables

View Source
var SupportedAggregates = map[string]AggregateOpcode{
	"count": AggregateCount,
	"sum":   AggregateSum,
	"min":   AggregateMin,
	"max":   AggregateMax,
}

SupportedAggregates maps the list of supported aggregate functions to their opcodes.

Functions

This section is empty.

Types

type AggregateOpcode

type AggregateOpcode int

AggregateOpcode is the aggregation Opcode.

func (AggregateOpcode) MarshalJSON

func (code AggregateOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the AggregateOpcode as a JSON string. It's used for testing and diagnostics.

func (AggregateOpcode) String

func (code AggregateOpcode) String() string

type AggregateParams

type AggregateParams struct {
	Opcode AggregateOpcode
	Col    int
}

AggregateParams specify the parameters for each aggregation. It contains the opcode and input column number.

type Delete

type Delete struct {
	// Opcode is the execution opcode.
	Opcode DeleteOpcode

	// Keyspace specifies the keyspace to send the query to.
	Keyspace *vindexes.Keyspace

	// TargetDestination specifies the destination to send the query to.
	TargetDestination key.Destination

	// Query specifies the query to be executed.
	Query string

	// Vindex specifies the vindex to be used.
	Vindex vindexes.Vindex
	// Values specifies the vindex values to use for routing.
	// For now, only one value is specified.
	Values []sqltypes.PlanValue

	// Table specifies the table for the delete.
	Table *vindexes.Table

	// OwnedVindexQuery is used for deleting lookup vindex entries.
	OwnedVindexQuery string

	// Option to override the standard behavior and allow a multi-shard delete
	// to use single round trip autocommit.
	MultiShardAutocommit bool
}

Delete represents the instructions to perform a delete.

func (*Delete) Execute

func (del *Delete) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*Delete) GetFields

func (del *Delete) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*Delete) MarshalJSON

func (del *Delete) MarshalJSON() ([]byte, error)

MarshalJSON serializes the Delete into a JSON representation. It's used for testing and diagnostics.

func (*Delete) StreamExecute

func (del *Delete) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type DeleteOpcode

type DeleteOpcode int

DeleteOpcode is a number representing the opcode for the Delete primitve.

func (DeleteOpcode) MarshalJSON

func (code DeleteOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the DeleteOpcode as a JSON string. It's used for testing and diagnostics.

type Generate

type Generate struct {
	Keyspace *vindexes.Keyspace
	Query    string
	// Values are the supplied values for the column, which
	// will be stored as a list within the PlanValue. New
	// values will be generated based on how many were not
	// supplied (NULL).
	Values sqltypes.PlanValue
}

Generate represents the instruction to generate a value from a sequence.

type Insert

type Insert struct {
	// Opcode is the execution opcode.
	Opcode InsertOpcode

	// Keyspace specifies the keyspace to send the query to.
	Keyspace *vindexes.Keyspace

	// Query specifies the query to be executed.
	// For InsertSharded plans, this value is unused,
	// and Prefix, Mid and Suffix are used instead.
	Query string

	// VindexValues specifies values for all the vindex columns.
	// This is a three-dimensonal data structure:
	// Insert.Values[i] represents the values to be inserted for the i'th colvindex (i < len(Insert.Table.ColumnVindexes))
	// Insert.Values[i].Values[j] represents values for the j'th column of the given colVindex (j < len(colVindex[i].Columns)
	// Insert.Values[i].Values[j].Values[k] represents the value pulled from row k for that column: (k < len(ins.rows))
	VindexValues []sqltypes.PlanValue

	// Table sepcifies the table for the insert.
	Table *vindexes.Table

	// Generate is only set for inserts where a sequence must be generated.
	Generate *Generate

	// Prefix, Mid and Suffix are for sharded insert plans.
	Prefix string
	Mid    []string
	Suffix string

	// Option to override the standard behavior and allow a multi-shard insert
	// to use single round trip autocommit.
	//
	// This is a clear violation of the SQL semantics since it means the statement
	// is not atomic in the presence of PK conflicts on one shard and not another.
	// However some application use cases would prefer that the statement partially
	// succeed in order to get the performance benefits of autocommit.
	MultiShardAutocommit bool
}

Insert represents the instructions to perform an insert operation.

func (*Insert) Execute

func (ins *Insert) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*Insert) GetFields

func (ins *Insert) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*Insert) MarshalJSON

func (ins *Insert) MarshalJSON() ([]byte, error)

MarshalJSON serializes the Insert into a JSON representation. It's used for testing and diagnostics.

func (*Insert) StreamExecute

func (ins *Insert) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type InsertOpcode

type InsertOpcode int

InsertOpcode is a number representing the opcode for the Insert primitve.

func (InsertOpcode) MarshalJSON

func (code InsertOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the InsertOpcode as a JSON string. It's used for testing and diagnostics.

type Join

type Join struct {
	Opcode JoinOpcode
	// Left and Right are the LHS and RHS primitives
	// of the Join. They can be any primitive.
	Left, Right Primitive `json:",omitempty"`

	// Cols defines which columns from the left
	// or right results should be used to build the
	// return result. For results coming from the
	// left query, the index values go as -1, -2, etc.
	// For the right query, they're 1, 2, etc.
	// If Cols is {-1, -2, 1, 2}, it means that
	// the returned result will be {Left0, Left1, Right0, Right1}.
	Cols []int `json:",omitempty"`

	// Vars defines the list of joinVars that need to
	// be built from the LHS result before invoking
	// the RHS subqquery.
	Vars map[string]int `json:",omitempty"`
}

Join specifies the parameters for a join primitive.

func (*Join) Execute

func (jn *Join) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*Join) GetFields

func (jn *Join) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*Join) StreamExecute

func (jn *Join) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type JoinOpcode

type JoinOpcode int

JoinOpcode is a number representing the opcode for the Join primitive.

func (JoinOpcode) MarshalJSON

func (code JoinOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the JoinOpcode as a JSON string. It's used for testing and diagnostics.

func (JoinOpcode) String

func (code JoinOpcode) String() string

type Limit

type Limit struct {
	Count  sqltypes.PlanValue
	Offset sqltypes.PlanValue
	Input  Primitive
}

Limit is a primitive that performs the LIMIT operation.

func (*Limit) Execute

func (l *Limit) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute satisfies the Primtive interface.

func (*Limit) GetFields

func (l *Limit) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields satisfies the Primtive interface.

func (*Limit) MarshalJSON

func (l *Limit) MarshalJSON() ([]byte, error)

MarshalJSON serializes the Limit into a JSON representation. It's used for testing and diagnostics.

func (*Limit) StreamExecute

func (l *Limit) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute satisfies the Primtive interface.

type OrderbyParams

type OrderbyParams struct {
	Col  int
	Desc bool
}

OrderbyParams specifies the parameters for ordering. This is used for merge-sorting scatter queries.

type OrderedAggregate

type OrderedAggregate struct {
	// Aggregates specifies the aggregation parameters for each
	// aggregation function: function opcode and input column number.
	Aggregates []AggregateParams

	// Keys specifies the input values that must be used for
	// the aggregation key.
	Keys []int

	// TruncateColumnCount specifies the number of columns to return
	// in the final result. Rest of the columns are truncated
	// from the result received. If 0, no truncation happens.
	TruncateColumnCount int `json:",omitempty"`

	// Input is the primitive that will feed into this Primitive.
	Input Primitive
}

OrderedAggregate is a primitive that expects the underlying primitive to feed results in an order sorted by the Keys. Rows with duplicate keys are aggregated using the Aggregate functions. The assumption is that the underlying primitive is a scatter select with pre-sorted rows.

func (*OrderedAggregate) Execute

func (oa *OrderedAggregate) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute is a Primitive function.

func (*OrderedAggregate) GetFields

func (oa *OrderedAggregate) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields is a Primitive function.

func (*OrderedAggregate) StreamExecute

func (oa *OrderedAggregate) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute is a Primitive function.

type Plan

type Plan struct {
	// Original is the original query.
	Original string `json:",omitempty"`
	// Instructions contains the instructions needed to
	// fulfil the query.
	Instructions Primitive `json:",omitempty"`

	// Count of times this plan was executed
	ExecCount uint64
	// Total execution time
	ExecTime time.Duration
	// Total number of shard queries
	ShardQueries uint64
	// Total number of rows
	Rows uint64
	// Total number of errors
	Errors uint64
	// contains filtered or unexported fields
}

Plan represents the execution strategy for a given query. For now it's a simple wrapper around the real instructions. An instruction (aka Primitive) is typically a tree where each node does its part by combining the results of the sub-nodes.

func (*Plan) AddStats

func (p *Plan) AddStats(execCount uint64, execTime time.Duration, shardQueries, rows, errors uint64)

AddStats updates the plan execution statistics

func (*Plan) Size

func (p *Plan) Size() int

Size is defined so that Plan can be given to a cache.LRUCache. VTGate needs to maintain a cache of plans. It uses LRUCache, which in turn requires its objects to define a Size function.

func (*Plan) Stats

func (p *Plan) Stats() (execCount uint64, execTime time.Duration, shardQueries, rows, errors uint64)

Stats returns a copy of the plan execution statistics

type Primitive

type Primitive interface {
	Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)
	StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantields bool, callback func(*sqltypes.Result) error) error
	GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)
}

Primitive is the interface that needs to be satisfied by all primitives of a plan.

type Route

type Route struct {
	// the fields are described in the RouteOpcode values comments.
	// Opcode is the execution opcode.
	Opcode RouteOpcode

	// Keyspace specifies the keyspace to send the query to.
	Keyspace *vindexes.Keyspace

	// TargetDestination specifies an explicit target destination to send the query to.
	// This bypases the core of the v3 engine.
	TargetDestination key.Destination

	// Query specifies the query to be executed.
	Query string

	// FieldQuery specifies the query to be executed for a GetFieldInfo request.
	FieldQuery string

	// Vindex specifies the vindex to be used.
	Vindex vindexes.Vindex
	// Values specifies the vindex values to use for routing.
	Values []sqltypes.PlanValue

	// OrderBy specifies the key order for merge sorting. This will be
	// set only for scatter queries that need the results to be
	// merge-sorted.
	OrderBy []OrderbyParams

	// TruncateColumnCount specifies the number of columns to return
	// in the final result. Rest of the columns are truncated
	// from the result received. If 0, no truncation happens.
	TruncateColumnCount int
}

Route represents the instructions to route a read query to one or many vttablets.

func (*Route) Execute

func (route *Route) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*Route) GetFields

func (route *Route) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*Route) MarshalJSON

func (route *Route) MarshalJSON() ([]byte, error)

MarshalJSON serializes the Route into a JSON representation. It's used for testing and diagnostics.

func (*Route) StreamExecute

func (route *Route) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type RouteOpcode

type RouteOpcode int

RouteOpcode is a number representing the opcode for the Route primitve. Adding new opcodes here will require review of the join code in planbuilder.

func (RouteOpcode) MarshalJSON

func (code RouteOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the RouteOpcode as a JSON string. It's used for testing and diagnostics.

type Subquery

type Subquery struct {
	// Cols defines the column numbers from the underlying primitive
	// to be returned.
	Cols     []int
	Subquery Primitive
}

Subquery specifies the parameters for a subquery primitive.

func (*Subquery) Execute

func (sq *Subquery) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*Subquery) GetFields

func (sq *Subquery) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*Subquery) StreamExecute

func (sq *Subquery) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type Update

type Update struct {
	// Opcode is the execution opcode.
	Opcode UpdateOpcode

	// Keyspace specifies the keyspace to send the query to.
	Keyspace *vindexes.Keyspace

	// Query specifies the query to be executed.
	Query string

	// Vindex specifies the vindex to be used.
	Vindex vindexes.Vindex
	// Values specifies the vindex values to use for routing.
	// For now, only one value is specified.
	Values []sqltypes.PlanValue

	// ChangedVindexValues contains values for updated Vindexes during an update statement.
	ChangedVindexValues map[string][]sqltypes.PlanValue

	// Table sepcifies the table for the update.
	Table *vindexes.Table

	// OwnedVindexQuery is used for updating changes in lookup vindexes.
	OwnedVindexQuery string

	// Option to override the standard behavior and allow a multi-shard update
	// to use single round trip autocommit.
	MultiShardAutocommit bool
}

Update represents the instructions to perform an update.

func (*Update) Execute

func (upd *Update) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*Update) GetFields

func (upd *Update) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*Update) MarshalJSON

func (upd *Update) MarshalJSON() ([]byte, error)

MarshalJSON serializes the Update into a JSON representation. It's used for testing and diagnostics.

func (*Update) StreamExecute

func (upd *Update) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type UpdateOpcode

type UpdateOpcode int

UpdateOpcode is a number representing the opcode for the Update primitve.

func (UpdateOpcode) MarshalJSON

func (code UpdateOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the UpdateOpcode as a JSON string. It's used for testing and diagnostics.

type VCursor

type VCursor interface {
	// Context returns the context of the current request.
	Context() context.Context

	// V3 functions.
	Execute(method string, query string, bindvars map[string]*querypb.BindVariable, isDML bool) (*sqltypes.Result, error)
	ExecuteAutocommit(method string, query string, bindvars map[string]*querypb.BindVariable, isDML bool) (*sqltypes.Result, error)
	AutocommitApproval() bool

	// Shard-level functions.
	ExecuteMultiShard(rss []*srvtopo.ResolvedShard, queries []*querypb.BoundQuery, isDML, canAutocommit bool) (*sqltypes.Result, error)
	ExecuteStandalone(query string, bindvars map[string]*querypb.BindVariable, rs *srvtopo.ResolvedShard) (*sqltypes.Result, error)
	StreamExecuteMulti(query string, rss []*srvtopo.ResolvedShard, bindVars []map[string]*querypb.BindVariable, callback func(reply *sqltypes.Result) error) error

	// Resolver methods, from key.Destination to srvtopo.ResolvedShard.
	// Will replace all of the Topo functions.
	ResolveDestinations(keyspace string, ids []*querypb.Value, destinations []key.Destination) ([]*srvtopo.ResolvedShard, [][]*querypb.Value, error)
}

VCursor defines the interface the engine will use to execute routes.

type VindexFunc

type VindexFunc struct {
	Opcode VindexOpcode
	// Fields is the field info for the result.
	Fields []*querypb.Field
	// Cols contains source column numbers: 0 for id, 1 for keyspace_id.
	Cols   []int
	Vindex vindexes.Vindex
	Value  sqltypes.PlanValue
}

VindexFunc is a primitive that performs vindex functions.

func (*VindexFunc) Execute

func (vf *VindexFunc) Execute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error)

Execute performs a non-streaming exec.

func (*VindexFunc) GetFields

func (vf *VindexFunc) GetFields(vcursor VCursor, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error)

GetFields fetches the field info.

func (*VindexFunc) MarshalJSON

func (vf *VindexFunc) MarshalJSON() ([]byte, error)

MarshalJSON serializes the VindexFunc into a JSON representation. It's used for testing and diagnostics.

func (*VindexFunc) StreamExecute

func (vf *VindexFunc) StreamExecute(vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error

StreamExecute performs a streaming exec.

type VindexOpcode

type VindexOpcode int

VindexOpcode is the opcode for a VindexFunc.

func (VindexOpcode) MarshalJSON

func (code VindexOpcode) MarshalJSON() ([]byte, error)

MarshalJSON serializes the VindexOpcode into a JSON representation. It's used for testing and diagnostics.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL