executor

package
v1.1.0-alpha.1 Latest Latest
Warning

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

 Go to latest Published: Jan 19, 2018 License: Apache-2.0 Imports: 54 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

View Source 
const (
	// FlagIgnoreTruncate indicates if truncate error should be ignored.
	// Read-only statements should ignore truncate error, write statements should not ignore truncate error.
	FlagIgnoreTruncate uint64 = 1
	// FlagTruncateAsWarning indicates if truncate error should be returned as warning.
	// This flag only matters if FlagIgnoreTruncate is not set, in strict sql mode, truncate error should
	// be returned as error, in non-strict sql mode, truncate error should be saved as warning.
	FlagTruncateAsWarning uint64 = 1 << 1

	// FlagPadCharToFullLength indicates if sql_mode 'PAD_CHAR_TO_FULL_LENGTH' is set.
	FlagPadCharToFullLength uint64 = 1 << 2
)

Flags are used by tipb.SelectRequest.Flags to handle execution mode, like how to handle truncate error.

View Source 
const (
	CodePasswordNoMatch terror.ErrCode = 1133 // MySQL error code
	CodeCannotUser      terror.ErrCode = 1396 // MySQL error code

)

Error codes.

View Source 
const (
	// IGNORE is a special label to identify the situations we want to ignore.
	IGNORE = "Ignore"
	// Select represents select statements.
	Select = "Select"
	// AlterTable represents alter table statements.
	AlterTable = "AlterTable"
	// AnalyzeTable represents analyze table statements.
	AnalyzeTable = "AnalyzeTable"
	// Begin represents begin statements.
	Begin = "Begin"
	// Commit represents commit statements.
	Commit = "Commit"
	// CreateDatabase represents create database statements.
	CreateDatabase = "CreateDatabase"
	// CreateIndex represents create index statements.
	CreateIndex = "CreateIndex"
	// CreateTable represents create table statements.
	CreateTable = "CreateTable"
	// CreateUser represents create user statements.
	CreateUser = "CreateUser"
	// Delete represents delete statements.
	Delete = "Delete"
	// DropDatabase represents drop database statements.
	DropDatabase = "DropDatabase"
	// DropIndex represents drop index statements.
	DropIndex = "DropIndex"
	// DropTable represents drop table statements.
	DropTable = "DropTable"
	// Explain represents explain statements.
	Explain = "Explain"
	// Replace represents replace statements.
	Replace = "Replace"
	// Insert represents insert statements.
	Insert = "Insert"
	// LoadDataStmt represents load data statements.
	LoadDataStmt = "LoadData"
	// RollBack represents roll back statements.
	RollBack = "RollBack"
	// Set represents set statements.
	Set = "Set"
	// Show represents show statements.
	Show = "Show"
	// TruncateTable represents truncate table statements.
	TruncateTable = "TruncateTable"
	// Update represents update statements.
	Update = "Update"
	// Grant represents grant statements.
	Grant = "Grant"
	// Revoke represents revoke statements.
	Revoke = "Revoke"
)
View Source 
const LoadDataVarKey loadDataVarKeyType = 0

LoadDataVarKey is a variable key for load data.

Variables ¶

View Source 
var (
	ErrUnknownPlan          = terror.ClassExecutor.New(codeUnknownPlan, "Unknown plan")
	ErrPrepareMulti         = terror.ClassExecutor.New(codePrepareMulti, "Can not prepare multiple statements")
	ErrPrepareDDL           = terror.ClassExecutor.New(codePrepareDDL, "Can not prepare DDL statements")
	ErrPasswordNoMatch      = terror.ClassExecutor.New(CodePasswordNoMatch, "Can't find any matching row in the user table")
	ErrResultIsEmpty        = terror.ClassExecutor.New(codeResultIsEmpty, "result is empty")
	ErrBuildExecutor        = terror.ClassExecutor.New(codeErrBuildExec, "Failed to build executor")
	ErrBatchInsertFail      = terror.ClassExecutor.New(codeBatchInsertFail, "Batch insert failed, please clean the table and try again.")
	ErrWrongValueCountOnRow = terror.ClassExecutor.New(codeWrongValueCountOnRow, "Column count doesn't match value count at row %d")
	ErrPasswordFormat       = terror.ClassExecutor.New(codePasswordFormat, "The password hash doesn't have the expected format. Check if the correct password algorithm is being used with the PASSWORD() function.")
	ErrMemExceedThreshold   = terror.ClassExecutor.New(codeMemExceedThreshold, mysql.MySQLErrName[mysql.ErrMemExceedThreshold])
)

Error instances.

View Source 
var LookupTableTaskChannelSize int32 = 50

LookupTableTaskChannelSize represents the channel size of the index double read taskChan.

Functions ¶

func CompileExecutePreparedStmt ¶ 

func CompileExecutePreparedStmt(ctx context.Context, ID uint32, args ...interface{}) (ast.Statement, error)

CompileExecutePreparedStmt compiles a session Execute command to a stmt.Statement.

func GetFieldsFromLine ¶ 

func GetFieldsFromLine(line []byte, fieldsInfo *ast.FieldsClause) ([]string, error)

GetFieldsFromLine splits line according to fieldsInfo, this function is exported for testing.

func GetInfoSchema ¶ 

func GetInfoSchema(ctx context.Context) infoschema.InfoSchema

GetInfoSchema gets TxnCtx InfoSchema if snapshot schema is not set, Otherwise, snapshot schema is returned.

func IsPointGetWithPKOrUniqueKeyByAutoCommit ¶ 

func IsPointGetWithPKOrUniqueKeyByAutoCommit(ctx context.Context, p plan.Plan) bool

IsPointGetWithPKOrUniqueKeyByAutoCommit returns true when meets following conditions:

  1. ctx is auto commit tagged
  2. txn is nil
  3. plan is point get by pk or unique key

func ResetStmtCtx ¶ 

func ResetStmtCtx(ctx context.Context, s ast.StmtNode)

ResetStmtCtx resets the StmtContext. Before every execution, we must clear statement context.

func StatementLabel ¶ 

func StatementLabel(node ast.StmtNode, p plan.Plan, isExpensive *bool) string

StatementLabel generates a label for a statement.

Types ¶

type AnalyzeColumnsExec ¶ 

type AnalyzeColumnsExec struct {
	// contains filtered or unexported fields
}

AnalyzeColumnsExec represents Analyze columns push down executor.

type AnalyzeExec ¶ 

type AnalyzeExec struct {
	// contains filtered or unexported fields
}

AnalyzeExec represents Analyze executor.

func (*AnalyzeExec) Close ¶ 

func (e *AnalyzeExec) Close() error

Close implements the Executor Close interface.

func (*AnalyzeExec) Next ¶ 

func (e *AnalyzeExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*AnalyzeExec) NextChunk ¶ 

func (e *AnalyzeExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*AnalyzeExec) Open ¶ 

func (e *AnalyzeExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*AnalyzeExec) Schema ¶ 

func (e *AnalyzeExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type AnalyzeIndexExec ¶ 

type AnalyzeIndexExec struct {
	// contains filtered or unexported fields
}

AnalyzeIndexExec represents analyze index push down executor.

type CancelDDLJobsExec ¶ added in v1.0.1 

type CancelDDLJobsExec struct {
	// contains filtered or unexported fields
}

CancelDDLJobsExec represents a cancel DDL jobs executor.

func (*CancelDDLJobsExec) Close ¶ added in v1.0.1 

func (e *CancelDDLJobsExec) Close() error

Close implements the Executor Close interface.

func (*CancelDDLJobsExec) Next ¶ added in v1.0.1 

func (e *CancelDDLJobsExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*CancelDDLJobsExec) NextChunk ¶ 

func (e *CancelDDLJobsExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*CancelDDLJobsExec) Open ¶ added in v1.0.1 

func (e *CancelDDLJobsExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*CancelDDLJobsExec) Schema ¶ added in v1.0.1 

func (e *CancelDDLJobsExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type CheckTableExec ¶ 

type CheckTableExec struct {
	// contains filtered or unexported fields
}

CheckTableExec represents a check table executor. It is built from the "admin check table" statement, and it checks if the index matches the records in the table.

func (*CheckTableExec) Close ¶ 

func (e *CheckTableExec) Close() error

Close implements the Executor Close interface.

func (*CheckTableExec) Next ¶ 

func (e *CheckTableExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*CheckTableExec) NextChunk ¶ 

func (e *CheckTableExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*CheckTableExec) Open ¶ 

func (e *CheckTableExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*CheckTableExec) Schema ¶ 

func (e *CheckTableExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type Closeable ¶ 

type Closeable interface {
	// Close closes the object.
	Close() error
}

Closeable is a interface for closeable structures.

type Compiler ¶ 

type Compiler struct {
	Ctx context.Context
}

Compiler compiles an ast.StmtNode to a physical plan.

func (*Compiler) Compile ¶ 

func (c *Compiler) Compile(goCtx goctx.Context, stmtNode ast.StmtNode) (*ExecStmt, error)

Compile compiles an ast.StmtNode to a physical plan.

type DDLExec ¶ 

type DDLExec struct {
	// contains filtered or unexported fields
}

DDLExec represents a DDL executor. It grabs a DDL instance from Domain, calling the DDL methods to do the work.

func (*DDLExec) Close ¶ 

func (e *DDLExec) Close() error

Close implements the Executor Close interface.

func (*DDLExec) Next ¶ 

func (e *DDLExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*DDLExec) NextChunk ¶ 

func (e *DDLExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*DDLExec) Open ¶ 

func (e *DDLExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*DDLExec) Schema ¶ 

func (e *DDLExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type DeallocateExec ¶ 

type DeallocateExec struct {
	Name string
	// contains filtered or unexported fields
}

DeallocateExec represent a DEALLOCATE executor.

func (*DeallocateExec) Close ¶ 

func (e *DeallocateExec) Close() error

Close implements the Executor Close interface.

func (*DeallocateExec) Next ¶ 

func (e *DeallocateExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*DeallocateExec) NextChunk ¶ 

func (e *DeallocateExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*DeallocateExec) Open ¶ 

func (e *DeallocateExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*DeallocateExec) Schema ¶ 

func (e *DeallocateExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type DeleteExec ¶ 

type DeleteExec struct {
	SelectExec Executor

	Tables       []*ast.TableName
	IsMultiTable bool
	// contains filtered or unexported fields
}

DeleteExec represents a delete executor. See https://dev.mysql.com/doc/refman/5.7/en/delete.html

func (*DeleteExec) Close ¶ 

func (e *DeleteExec) Close() error

Close implements the Executor Close interface.

func (*DeleteExec) Next ¶ 

func (e *DeleteExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*DeleteExec) NextChunk ¶ 

func (e *DeleteExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*DeleteExec) Open ¶ 

func (e *DeleteExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*DeleteExec) Schema ¶ 

func (e *DeleteExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ExecStmt ¶ 

type ExecStmt struct {
	// InfoSchema stores a reference to the schema information.
	InfoSchema infoschema.InfoSchema
	// Plan stores a reference to the final physical plan.
	Plan plan.Plan
	// Expensive represents whether this query is an expensive one.
	Expensive bool
	// Cacheable represents whether the physical plan can be cached.
	Cacheable bool
	// Text represents the origin query text.
	Text string

	StmtNode ast.StmtNode

	Ctx context.Context
	// contains filtered or unexported fields
}

ExecStmt implements the ast.Statement interface, it builds a plan.Plan to an ast.Statement.

func (*ExecStmt) Exec ¶ 

func (a *ExecStmt) Exec(goCtx goctx.Context) (ast.RecordSet, error)

Exec implements the ast.Statement Exec interface. This function builds an Executor from a plan. If the Executor doesn't return result, like the INSERT, UPDATE statements, it executes in this function, if the Executor returns result, execution is done after this function returns, in the returned ast.RecordSet Next method.

func (*ExecStmt) IsPrepared ¶ 

func (a *ExecStmt) IsPrepared() bool

IsPrepared implements ast.Statement interface.

func (*ExecStmt) IsReadOnly ¶ added in v1.0.3 

func (a *ExecStmt) IsReadOnly() bool

IsReadOnly implements ast.Statement interface.

func (*ExecStmt) OriginText ¶ 

func (a *ExecStmt) OriginText() string

OriginText implements ast.Statement interface.

func (*ExecStmt) RebuildPlan ¶ added in v1.0.3 

func (a *ExecStmt) RebuildPlan() error

RebuildPlan implements ast.Statement interface.

type ExecuteExec ¶ 

type ExecuteExec struct {
	// contains filtered or unexported fields
}

ExecuteExec represents an EXECUTE executor. It cannot be executed by itself, all it needs to do is to build another Executor from a prepared statement.

func (*ExecuteExec) Build ¶ 

func (e *ExecuteExec) Build() error

Build builds a prepared statement into an executor. After Build, e.StmtExec will be used to do the real execution.

func (*ExecuteExec) Close ¶ 

func (e *ExecuteExec) Close() error

Close implements the Executor Close interface.

func (*ExecuteExec) Next ¶ 

func (e *ExecuteExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface. It will never be called.

func (*ExecuteExec) NextChunk ¶ 

func (e *ExecuteExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ExecuteExec) Open ¶ 

func (e *ExecuteExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ExecuteExec) Schema ¶ 

func (e *ExecuteExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type Executor ¶ 

type Executor interface {
	Next(goctx.Context) (Row, error)
	Close() error
	Open(goctx.Context) error
	Schema() *expression.Schema

	NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error
	// contains filtered or unexported methods
}

Executor executes a query.

type ExistsExec ¶ 

type ExistsExec struct {
	// contains filtered or unexported fields
}

ExistsExec represents exists executor.

func (*ExistsExec) Close ¶ 

func (e *ExistsExec) Close() error

Close implements the Executor Close interface.

func (*ExistsExec) Next ¶ 

func (e *ExistsExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface. We always return one row with one column which has true or false value.

func (*ExistsExec) NextChunk ¶ 

func (e *ExistsExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ExistsExec) Open ¶ 

func (e *ExistsExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ExistsExec) Schema ¶ 

func (e *ExistsExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ExplainExec ¶ 

type ExplainExec struct {
	// contains filtered or unexported fields
}

ExplainExec represents an explain executor.

func (*ExplainExec) Close ¶ 

func (e *ExplainExec) Close() error

Close implements the Executor Close interface.

func (*ExplainExec) Next ¶ 

func (e *ExplainExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*ExplainExec) NextChunk ¶ 

func (e *ExplainExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ExplainExec) Open ¶ 

func (e *ExplainExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ExplainExec) Schema ¶ 

func (e *ExplainExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type GrantExec ¶ 

type GrantExec struct {
	Privs      []*ast.PrivElem
	ObjectType ast.ObjectTypeType
	Level      *ast.GrantLevel
	Users      []*ast.UserSpec
	WithGrant  bool
	// contains filtered or unexported fields
}

GrantExec executes GrantStmt.

func (*GrantExec) Close ¶ 

func (e *GrantExec) Close() error

Close implements the Executor Close interface.

func (*GrantExec) Next ¶ 

func (e *GrantExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*GrantExec) NextChunk ¶ 

func (e *GrantExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*GrantExec) Open ¶ 

func (e *GrantExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*GrantExec) Schema ¶ 

func (e *GrantExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type HashAggExec ¶ 

type HashAggExec struct {
	AggFuncs []aggregation.Aggregation

	GroupByItems []expression.Expression
	// contains filtered or unexported fields
}

HashAggExec deals with all the aggregate functions. It is built from the Aggregate Plan. When Next() is called, it reads all the data from Src and updates all the items in AggFuncs.

func (*HashAggExec) Close ¶ 

func (e *HashAggExec) Close() error

Close implements the Executor Close interface.

func (*HashAggExec) Next ¶ 

func (e *HashAggExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*HashAggExec) NextChunk ¶ 

func (e *HashAggExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*HashAggExec) Open ¶ 

func (e *HashAggExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*HashAggExec) Schema ¶ 

func (e *HashAggExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type HashJoinExec ¶ 

type HashJoinExec struct {
	// contains filtered or unexported fields
}

HashJoinExec implements the hash join algorithm.

func (*HashJoinExec) Close ¶ 

func (e *HashJoinExec) Close() error

Close implements the Executor Close interface.

func (*HashJoinExec) Next ¶ 

func (e *HashJoinExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*HashJoinExec) NextChunk ¶ 

func (e *HashJoinExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) (err error)

NextChunk implements the Executor NextChunk interface. hash join constructs the result following these steps: step 1. fetch data from inner child and build a hash table; step 2. fetch data from outer child in a background goroutine and probe the hash table in multiple join workers.

func (*HashJoinExec) Open ¶ 

func (e *HashJoinExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*HashJoinExec) Schema ¶ 

func (e *HashJoinExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type IndexLookUpExecutor ¶ 

type IndexLookUpExecutor struct {
	// contains filtered or unexported fields
}

IndexLookUpExecutor implements double read for index scan.

func (*IndexLookUpExecutor) Close ¶ 

func (e *IndexLookUpExecutor) Close() error

Close implements Exec Close interface.

func (*IndexLookUpExecutor) Next ¶ 

func (e *IndexLookUpExecutor) Next(goCtx goctx.Context) (Row, error)

Next implements Exec Next interface.

func (*IndexLookUpExecutor) NextChunk ¶ 

func (e *IndexLookUpExecutor) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements Exec NextChunk interface.

func (*IndexLookUpExecutor) Open ¶ 

func (e *IndexLookUpExecutor) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*IndexLookUpExecutor) Schema ¶ 

func (e *IndexLookUpExecutor) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type IndexLookUpJoin ¶ 

type IndexLookUpJoin struct {
	// contains filtered or unexported fields
}

IndexLookUpJoin employs one outer worker and N innerWorkers to execute concurrently. It preserves the order of the outer table and support batch lookup.

The execution flow is very similar to IndexLookUpReader: 1. outerWorker read N outer rows, build a task and send it to result channel and inner worker channel. 2. The innerWorker receives the task, builds key ranges from outer rows and fetch inner rows, builds inner row hash map. 3. main thread receives the task, waits for inner worker finish handling the task. 4. main thread join each outer row by look up the inner rows hash map in the task.

func (*IndexLookUpJoin) Close ¶ 

func (e *IndexLookUpJoin) Close() error

Close implements the Executor interface.

func (*IndexLookUpJoin) Next ¶ 

func (e *IndexLookUpJoin) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor interface. Even though we only support read children in chunk mode, but we are not sure if our parents support chunk, so we have to implement Next.

func (*IndexLookUpJoin) NextChunk ¶ 

func (e *IndexLookUpJoin) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor interface.

func (*IndexLookUpJoin) Open ¶ 

func (e *IndexLookUpJoin) Open(goCtx goctx.Context) error

Open implements the Executor interface.

func (*IndexLookUpJoin) Schema ¶ 

func (e *IndexLookUpJoin) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type IndexReaderExecutor ¶ 

type IndexReaderExecutor struct {
	// contains filtered or unexported fields
}

IndexReaderExecutor sends dag request and reads index data from kv layer.

func (*IndexReaderExecutor) Close ¶ 

func (e *IndexReaderExecutor) Close() error

Close implements the Executor Close interface.

func (*IndexReaderExecutor) Next ¶ 

func (e *IndexReaderExecutor) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*IndexReaderExecutor) NextChunk ¶ 

func (e *IndexReaderExecutor) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*IndexReaderExecutor) Open ¶ 

func (e *IndexReaderExecutor) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*IndexReaderExecutor) Schema ¶ 

func (e *IndexReaderExecutor) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type InsertExec ¶ 

type InsertExec struct {
	*InsertValues

	OnDuplicate []*expression.Assignment

	Priority  mysql.PriorityEnum
	IgnoreErr bool
	// contains filtered or unexported fields
}

InsertExec represents an insert executor.

func (*InsertExec) Close ¶ 

func (e *InsertExec) Close() error

Close implements the Executor Close interface.

func (*InsertExec) Next ¶ 

func (e *InsertExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*InsertExec) NextChunk ¶ 

func (e *InsertExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements Exec NextChunk interface.

func (*InsertExec) Open ¶ 

func (e *InsertExec) Open(goCtx goctx.Context) error

Open implements the Executor Close interface.

func (InsertExec) Schema ¶ 

func (e InsertExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type InsertValues ¶ 

type InsertValues struct {
	SelectExec Executor

	Table     table.Table
	Columns   []*ast.ColumnName
	Lists     [][]expression.Expression
	Setlist   []*expression.Assignment
	IsPrepare bool

	GenColumns []*ast.ColumnName
	GenExprs   []expression.Expression
	// contains filtered or unexported fields
}

InsertValues is the data to insert.

func (*InsertValues) Close ¶ 

func (e *InsertValues) Close() error

Close implements the Executor Close interface.

func (*InsertValues) NextChunk ¶ 

func (e *InsertValues) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

func (*InsertValues) Open ¶ 

func (e *InsertValues) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*InsertValues) Schema ¶ 

func (e *InsertValues) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type LimitExec ¶ 

type LimitExec struct {
	// contains filtered or unexported fields
}

LimitExec represents limit executor It ignores 'Offset' rows from src, then returns 'Count' rows at maximum.

func (*LimitExec) Close ¶ 

func (e *LimitExec) Close() error

Close implements the Executor Close interface.

func (*LimitExec) Next ¶ 

func (e *LimitExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*LimitExec) NextChunk ¶ 

func (e *LimitExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*LimitExec) Open ¶ 

func (e *LimitExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*LimitExec) Schema ¶ 

func (e *LimitExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type LoadData ¶ 

type LoadData struct {
	IsLocal bool
	// contains filtered or unexported fields
}

LoadData represents a load data executor.

func (*LoadData) Close ¶ 

func (e *LoadData) Close() error

Close implements the Executor Close interface.

func (*LoadData) Next ¶ 

func (e *LoadData) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*LoadData) NextChunk ¶ 

func (e *LoadData) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*LoadData) Open ¶ 

func (e *LoadData) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*LoadData) Schema ¶ 

func (e *LoadData) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type LoadDataInfo ¶ 

type LoadDataInfo struct {
	Path       string
	Table      table.Table
	FieldsInfo *ast.FieldsClause
	LinesInfo  *ast.LinesClause
	Ctx        context.Context
	// contains filtered or unexported fields
}

LoadDataInfo saves the information of loading data operation.

func NewLoadDataInfo ¶ 

func NewLoadDataInfo(row []types.Datum, ctx context.Context, tbl table.Table, cols []*table.Column) *LoadDataInfo

NewLoadDataInfo returns a LoadDataInfo structure, and it's only used for tests now.

func (*LoadDataInfo) InsertData ¶ 

func (e *LoadDataInfo) InsertData(prevData, curData []byte) ([]byte, bool, error)

InsertData inserts data into specified table according to the specified format. If it has the rest of data isn't completed the processing, then is returns without completed data. If the number of inserted rows reaches the batchRows, then the second return value is true. If prevData isn't nil and curData is nil, there are no other data to deal with and the isEOF is true.

func (*LoadDataInfo) SetMaxRowsInBatch ¶ 

func (e *LoadDataInfo) SetMaxRowsInBatch(limit uint64)

SetMaxRowsInBatch sets the max number of rows to insert in a batch.

type MaxOneRowExec ¶ 

type MaxOneRowExec struct {
	// contains filtered or unexported fields
}

MaxOneRowExec checks if the number of rows that a query returns is at maximum one. It's built from subquery expression.

func (*MaxOneRowExec) Close ¶ 

func (e *MaxOneRowExec) Close() error

Close implements the Executor Close interface.

func (*MaxOneRowExec) Next ¶ 

func (e *MaxOneRowExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*MaxOneRowExec) NextChunk ¶ 

func (e *MaxOneRowExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*MaxOneRowExec) Open ¶ 

func (e *MaxOneRowExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*MaxOneRowExec) Schema ¶ 

func (e *MaxOneRowExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type MergeJoinExec ¶ 

type MergeJoinExec struct {
	// contains filtered or unexported fields
}

MergeJoinExec implements the merge join algorithm. This operator assumes that two iterators of both sides will provide required order on join condition: 1. For equal-join, one of the join key from each side matches the order given. 2. For other cases its preferred not to use SMJ and operator will throw error.

func (*MergeJoinExec) Close ¶ 

func (e *MergeJoinExec) Close() error

Close implements the Executor Close interface.

func (*MergeJoinExec) Next ¶ 

func (e *MergeJoinExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*MergeJoinExec) NextChunk ¶ 

func (e *MergeJoinExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*MergeJoinExec) Open ¶ 

func (e *MergeJoinExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*MergeJoinExec) Schema ¶ 

func (e *MergeJoinExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type NestedLoopApplyExec ¶ 

type NestedLoopApplyExec struct {
	// contains filtered or unexported fields
}

NestedLoopApplyExec is the executor for apply.

func (*NestedLoopApplyExec) Close ¶ 

func (e *NestedLoopApplyExec) Close() error

Close implements the Executor interface.

func (*NestedLoopApplyExec) Next ¶ 

func (e *NestedLoopApplyExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor interface.

func (*NestedLoopApplyExec) NextChunk ¶ 

func (e *NestedLoopApplyExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor interface.

func (*NestedLoopApplyExec) Open ¶ 

func (e *NestedLoopApplyExec) Open(goCtx goctx.Context) error

Open implements the Executor interface.

func (*NestedLoopApplyExec) Schema ¶ 

func (e *NestedLoopApplyExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type PrepareExec ¶ 

type PrepareExec struct {
	ID         uint32
	ParamCount int
	Fields     []*ast.ResultField
	// contains filtered or unexported fields
}

PrepareExec represents a PREPARE executor.

func NewPrepareExec ¶ 

func NewPrepareExec(ctx context.Context, is infoschema.InfoSchema, sqlTxt string) *PrepareExec

NewPrepareExec creates a new PrepareExec.

func (*PrepareExec) Close ¶ 

func (e *PrepareExec) Close() error

Close implements the Executor Close interface.

func (*PrepareExec) DoPrepare ¶ 

func (e *PrepareExec) DoPrepare() error

DoPrepare prepares the statement, it can be called multiple times without side effect.

func (*PrepareExec) Next ¶ 

func (e *PrepareExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*PrepareExec) NextChunk ¶ 

func (e *PrepareExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*PrepareExec) Open ¶ 

func (e *PrepareExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*PrepareExec) Schema ¶ 

func (e *PrepareExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ProjectionExec ¶ 

type ProjectionExec struct {
	// contains filtered or unexported fields
}

ProjectionExec represents a select fields executor.

func (*ProjectionExec) Close ¶ 

func (e *ProjectionExec) Close() error

Close implements the Executor Close interface.

func (*ProjectionExec) Next ¶ 

func (e *ProjectionExec) Next(goCtx goctx.Context) (retRow Row, err error)

Next implements the Executor Next interface.

func (*ProjectionExec) NextChunk ¶ 

func (e *ProjectionExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ProjectionExec) Open ¶ 

func (e *ProjectionExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ProjectionExec) Schema ¶ 

func (e *ProjectionExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ReplaceExec ¶ 

type ReplaceExec struct {
	*InsertValues
	Priority int
	// contains filtered or unexported fields
}

ReplaceExec represents a replace executor.

func (*ReplaceExec) Close ¶ 

func (e *ReplaceExec) Close() error

Close implements the Executor Close interface.

func (*ReplaceExec) Next ¶ 

func (e *ReplaceExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*ReplaceExec) NextChunk ¶ 

func (e *ReplaceExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ReplaceExec) Open ¶ 

func (e *ReplaceExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (ReplaceExec) Schema ¶ 

func (e ReplaceExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type RevokeExec ¶ 

type RevokeExec struct {
	Privs      []*ast.PrivElem
	ObjectType ast.ObjectTypeType
	Level      *ast.GrantLevel
	Users      []*ast.UserSpec
	// contains filtered or unexported fields
}

RevokeExec executes RevokeStmt.

func (*RevokeExec) Close ¶ 

func (e *RevokeExec) Close() error

Close implements the Executor Close interface.

func (*RevokeExec) Next ¶ 

func (e *RevokeExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*RevokeExec) NextChunk ¶ 

func (e *RevokeExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*RevokeExec) Open ¶ 

func (e *RevokeExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*RevokeExec) Schema ¶ 

func (e *RevokeExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type Row ¶ 

type Row = types.DatumRow

Row represents a result set row, it may be returned from a table, a join, or a projection.

The following cases will need store the handle information:

If the top plan is update or delete, then every executor will need the handle. If there is an union scan, then the below scan plan must store the handle. If there is sort need in the double read, then the table scan of the double read must store the handle. If there is a select for update. then we need to store the handle until the lock plan. But if there is aggregation, the handle info can be removed. Otherwise the executor's returned rows don't need to store the handle information.

type SelectLockExec ¶ 

type SelectLockExec struct {
	Lock ast.SelectLockType
	// contains filtered or unexported fields
}

SelectLockExec represents a select lock executor. It is built from the "SELECT .. FOR UPDATE" or the "SELECT .. LOCK IN SHARE MODE" statement. For "SELECT .. FOR UPDATE" statement, it locks every row key from source Executor. After the execution, the keys are buffered in transaction, and will be sent to KV when doing commit. If there is any key already locked by another transaction, the transaction will rollback and retry.

func (*SelectLockExec) Close ¶ 

func (e *SelectLockExec) Close() error

Close implements the Executor Close interface.

func (*SelectLockExec) Next ¶ 

func (e *SelectLockExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*SelectLockExec) NextChunk ¶ 

func (e *SelectLockExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*SelectLockExec) Open ¶ 

func (e *SelectLockExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*SelectLockExec) Schema ¶ 

func (e *SelectLockExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type SelectionExec ¶ 

type SelectionExec struct {
	// contains filtered or unexported fields
}

SelectionExec represents a filter executor.

func (*SelectionExec) Close ¶ 

func (e *SelectionExec) Close() error

Close implements plan.Plan Close interface.

func (*SelectionExec) Next ¶ 

func (e *SelectionExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*SelectionExec) NextChunk ¶ 

func (e *SelectionExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*SelectionExec) Open ¶ 

func (e *SelectionExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*SelectionExec) Schema ¶ 

func (e *SelectionExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type SetExecutor ¶ 

type SetExecutor struct {
	// contains filtered or unexported fields
}

SetExecutor executes set statement.

func (*SetExecutor) Close ¶ 

func (e *SetExecutor) Close() error

Close implements the Executor Close interface.

func (*SetExecutor) Next ¶ 

func (e *SetExecutor) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*SetExecutor) NextChunk ¶ 

func (e *SetExecutor) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*SetExecutor) Open ¶ 

func (e *SetExecutor) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*SetExecutor) Schema ¶ 

func (e *SetExecutor) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ShowDDLExec ¶ 

type ShowDDLExec struct {
	// contains filtered or unexported fields
}

ShowDDLExec represents a show DDL executor.

func (*ShowDDLExec) Close ¶ 

func (e *ShowDDLExec) Close() error

Close implements the Executor Close interface.

func (*ShowDDLExec) Next ¶ 

func (e *ShowDDLExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*ShowDDLExec) NextChunk ¶ 

func (e *ShowDDLExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ShowDDLExec) Open ¶ 

func (e *ShowDDLExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ShowDDLExec) Schema ¶ 

func (e *ShowDDLExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ShowDDLJobsExec ¶ 

type ShowDDLJobsExec struct {
	// contains filtered or unexported fields
}

ShowDDLJobsExec represent a show DDL jobs executor.

func (*ShowDDLJobsExec) Close ¶ 

func (e *ShowDDLJobsExec) Close() error

Close implements the Executor Close interface.

func (*ShowDDLJobsExec) Next ¶ 

func (e *ShowDDLJobsExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*ShowDDLJobsExec) NextChunk ¶ 

func (e *ShowDDLJobsExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ShowDDLJobsExec) Open ¶ 

func (e *ShowDDLJobsExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ShowDDLJobsExec) Schema ¶ 

func (e *ShowDDLJobsExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type ShowExec ¶ 

type ShowExec struct {
	Tp     ast.ShowStmtType // Databases/Tables/Columns/....
	DBName model.CIStr
	Table  *ast.TableName  // Used for showing columns.
	Column *ast.ColumnName // Used for `desc table column`.
	Flag   int             // Some flag parsed from sql, such as FULL.
	Full   bool
	User   *auth.UserIdentity // Used for show grants.

	// GlobalScope is used by show variables
	GlobalScope bool
	// contains filtered or unexported fields
}

ShowExec represents a show executor.

func (*ShowExec) Close ¶ 

func (e *ShowExec) Close() error

Close implements the Executor Close interface.

func (*ShowExec) Next ¶ 

func (e *ShowExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*ShowExec) NextChunk ¶ 

func (e *ShowExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*ShowExec) Open ¶ 

func (e *ShowExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*ShowExec) Schema ¶ 

func (e *ShowExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type SimpleExec ¶ 

type SimpleExec struct {
	Statement ast.StmtNode
	// contains filtered or unexported fields
}

SimpleExec represents simple statement executor. For statements do simple execution. includes `UseStmt`, 'SetStmt`, `DoStmt`, `BeginStmt`, `CommitStmt`, `RollbackStmt`. TODO: list all simple statements.

func (*SimpleExec) Close ¶ 

func (e *SimpleExec) Close() error

Close implements the Executor Close interface.

func (*SimpleExec) Next ¶ 

func (e *SimpleExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*SimpleExec) NextChunk ¶ 

func (e *SimpleExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*SimpleExec) Open ¶ 

func (e *SimpleExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*SimpleExec) Schema ¶ 

func (e *SimpleExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type SortExec ¶ 

type SortExec struct {
	ByItems []*plan.ByItems
	Rows    []*orderByRow
	Idx     int
	// contains filtered or unexported fields
}

SortExec represents sorting executor.

func (*SortExec) Close ¶ 

func (e *SortExec) Close() error

Close implements the Executor Close interface.

func (*SortExec) Len ¶ 

func (e *SortExec) Len() int

Len returns the number of rows.

func (*SortExec) Less ¶ 

func (e *SortExec) Less(i, j int) bool

Less implements sort.Interface Less interface.

func (*SortExec) Next ¶ 

func (e *SortExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*SortExec) NextChunk ¶ 

func (e *SortExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*SortExec) Open ¶ 

func (e *SortExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*SortExec) Schema ¶ 

func (e *SortExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

func (*SortExec) Swap ¶ 

func (e *SortExec) Swap(i, j int)

Swap implements sort.Interface Swap interface.

type StreamAggExec ¶ 

type StreamAggExec struct {
	StmtCtx  *stmtctx.StatementContext
	AggFuncs []aggregation.Aggregation

	GroupByItems []expression.Expression
	// contains filtered or unexported fields
}

StreamAggExec deals with all the aggregate functions. It assumes all the input data is sorted by group by key. When Next() is called, it will return a result for the same group.

func (*StreamAggExec) Close ¶ 

func (e *StreamAggExec) Close() error

Close implements the Executor Close interface.

func (*StreamAggExec) Next ¶ 

func (e *StreamAggExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*StreamAggExec) NextChunk ¶ 

func (e *StreamAggExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*StreamAggExec) Open ¶ 

func (e *StreamAggExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*StreamAggExec) Schema ¶ 

func (e *StreamAggExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type TableDualExec ¶ 

type TableDualExec struct {
	// contains filtered or unexported fields
}

TableDualExec represents a dual table executor.

func (*TableDualExec) Close ¶ 

func (e *TableDualExec) Close() error

Close implements the Executor Close interface.

func (*TableDualExec) Next ¶ 

func (e *TableDualExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*TableDualExec) NextChunk ¶ 

func (e *TableDualExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*TableDualExec) Open ¶ 

func (e *TableDualExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*TableDualExec) Schema ¶ 

func (e *TableDualExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type TableReaderExecutor ¶ 

type TableReaderExecutor struct {
	// contains filtered or unexported fields
}

TableReaderExecutor sends dag request and reads table data from kv layer.

func (*TableReaderExecutor) Close ¶ 

func (e *TableReaderExecutor) Close() error

Close implements the Executor Close interface.

func (*TableReaderExecutor) Next ¶ 

func (e *TableReaderExecutor) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*TableReaderExecutor) NextChunk ¶ 

func (e *TableReaderExecutor) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*TableReaderExecutor) Open ¶ 

func (e *TableReaderExecutor) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*TableReaderExecutor) Schema ¶ 

func (e *TableReaderExecutor) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type TableScanExec ¶ 

type TableScanExec struct {
	// contains filtered or unexported fields
}

TableScanExec is a table scan executor without result fields.

func (*TableScanExec) Close ¶ 

func (e *TableScanExec) Close() error

Close implements the Executor Close interface.

func (*TableScanExec) Next ¶ 

func (e *TableScanExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor interface.

func (*TableScanExec) NextChunk ¶ 

func (e *TableScanExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*TableScanExec) Open ¶ 

func (e *TableScanExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*TableScanExec) Schema ¶ 

func (e *TableScanExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type TopNExec ¶ 

type TopNExec struct {
	SortExec
	// contains filtered or unexported fields
}

TopNExec implements a Top-N algorithm and it is built from a SELECT statement with ORDER BY and LIMIT. Instead of sorting all the rows fetched from the table, it keeps the Top-N elements only in a heap to reduce memory usage.

func (*TopNExec) Len ¶ 

func (e *TopNExec) Len() int

Len implements heap.Interface Len interface.

func (*TopNExec) Less ¶ 

func (e *TopNExec) Less(i, j int) bool

Less implements heap.Interface Less interface.

func (*TopNExec) Next ¶ 

func (e *TopNExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*TopNExec) NextChunk ¶ 

func (e *TopNExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*TopNExec) Pop ¶ 

func (e *TopNExec) Pop() interface{}

Pop implements heap.Interface Pop interface.

func (*TopNExec) Push ¶ 

func (e *TopNExec) Push(x interface{})

Push implements heap.Interface Push interface.

func (*TopNExec) Schema ¶ 

func (e *TopNExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type UnionExec ¶ 

type UnionExec struct {
	// contains filtered or unexported fields
}

UnionExec pulls all it's childrens result and returns to its parent directly. A "resultPuller" is started for every child to pull result from that child and push it to the "resultPool", the used "Chunk" is obtained from the corresponding "resourcePool". All resultPullers are running concurrently. 

                          +----------------+
+---> resourcePool 1 ---> | resultPuller 1 |-----+
|                         +----------------+     |
|                                                |
|                         +----------------+     v
+---> resourcePool 2 ---> | resultPuller 2 |-----> resultPool ---+
|                         +----------------+     ^               |
|                               ......           |               |
|                         +----------------+     |               |
+---> resourcePool n ---> | resultPuller n |-----+               |
|                         +----------------+                     |
|                                                                |
|                          +-------------+                       |
|--------------------------| main thread | <---------------------+
                           +-------------+

func (*UnionExec) Close ¶ 

func (e *UnionExec) Close() error

Close implements the Executor Close interface.

func (*UnionExec) Next ¶ 

func (e *UnionExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*UnionExec) NextChunk ¶ 

func (e *UnionExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*UnionExec) Open ¶ 

func (e *UnionExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*UnionExec) Schema ¶ 

func (e *UnionExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

type UnionScanExec ¶ 

type UnionScanExec struct {
	// contains filtered or unexported fields
}

UnionScanExec merges the rows from dirty table and the rows from XAPI request.

func (*UnionScanExec) Close ¶ 

func (e *UnionScanExec) Close() error

Close implements the Executor Close interface.

func (*UnionScanExec) Len ¶ 

func (us *UnionScanExec) Len() int

Len implements sort.Interface interface.

func (*UnionScanExec) Less ¶ 

func (us *UnionScanExec) Less(i, j int) bool

Less implements sort.Interface interface.

func (*UnionScanExec) Next ¶ 

func (us *UnionScanExec) Next(goCtx goctx.Context) (Row, error)

Next implements Execution Next interface.

func (*UnionScanExec) NextChunk ¶ 

func (us *UnionScanExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*UnionScanExec) Open ¶ 

func (e *UnionScanExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*UnionScanExec) Schema ¶ 

func (e *UnionScanExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

func (*UnionScanExec) Swap ¶ 

func (us *UnionScanExec) Swap(i, j int)

Swap implements sort.Interface interface.

type UpdateExec ¶ 

type UpdateExec struct {
	SelectExec  Executor
	OrderedList []*expression.Assignment
	IgnoreErr   bool
	// contains filtered or unexported fields
}

UpdateExec represents a new update executor.

func (*UpdateExec) Close ¶ 

func (e *UpdateExec) Close() error

Close implements the Executor Close interface.

func (*UpdateExec) Next ¶ 

func (e *UpdateExec) Next(goCtx goctx.Context) (Row, error)

Next implements the Executor Next interface.

func (*UpdateExec) NextChunk ¶ 

func (e *UpdateExec) NextChunk(goCtx goctx.Context, chk *chunk.Chunk) error

NextChunk implements the Executor NextChunk interface.

func (*UpdateExec) Open ¶ 

func (e *UpdateExec) Open(goCtx goctx.Context) error

Open implements the Executor Open interface.

func (*UpdateExec) Schema ¶ 

func (e *UpdateExec) Schema() *expression.Schema

Schema implements the Executor Schema interface.

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.