executor

package
v2.1.0-rc.5+incompatible Latest Latest
Warning

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

 Go to latest Published: Nov 12, 2018 License: Apache-2.0 Imports: 64 Imported by: 410

Documentation

Index

Constants

View Source 
const LoadDataVarKey loadDataVarKeyType = 0

LoadDataVarKey is a variable key for load data.

View Source 
const LoadStatsVarKey loadStatsVarKeyType = 0

LoadStatsVarKey is a variable key for load statistic.

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")
	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.")

	ErrPasswordNoMatch             = terror.ClassExecutor.New(mysql.ErrPasswordNoMatch, mysql.MySQLErrName[mysql.ErrPasswordNoMatch])
	ErrCannotUser                  = terror.ClassExecutor.New(mysql.ErrCannotUser, mysql.MySQLErrName[mysql.ErrCannotUser])
	ErrPasswordFormat              = terror.ClassExecutor.New(mysql.ErrPasswordFormat, mysql.MySQLErrName[mysql.ErrPasswordFormat])
	ErrCantChangeTxCharacteristics = terror.ClassExecutor.New(mysql.ErrCantChangeTxCharacteristics, mysql.MySQLErrName[mysql.ErrCantChangeTxCharacteristics])
	ErrPsManyParam                 = terror.ClassExecutor.New(mysql.ErrPsManyParam, mysql.MySQLErrName[mysql.ErrPsManyParam])
	ErrAdminCheckTable             = terror.ClassExecutor.New(mysql.ErrAdminCheckTable, mysql.MySQLErrName[mysql.ErrAdminCheckTable])
)

Error instances.

View Source 
var LookupTableTaskChannelSize int32 = 50

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

View Source 
var QueryReplacer = strings.NewReplacer("\r", " ", "\n", " ", "\t", " ")

QueryReplacer replaces new line and tab for grep result including query string.

Functions

func CompileExecutePreparedStmt 

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

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

func CountStmtNode 

func CountStmtNode(stmtNode ast.StmtNode, inRestrictedSQL bool)

CountStmtNode records the number of statements with the same type.

func GetInfoSchema 

func GetInfoSchema(ctx sessionctx.Context) infoschema.InfoSchema

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

func GetLackHandles 

func GetLackHandles(expectedHandles []int64, obtainedHandlesMap map[int64]struct{}) []int64

GetLackHandles gets the handles in expectedHandles but not in obtainedHandlesMap.

func GetStmtLabel 

func GetStmtLabel(stmtNode ast.StmtNode) string

GetStmtLabel generates a label for a statement.

func IsPointGetWithPKOrUniqueKeyByAutoCommit 

func IsPointGetWithPKOrUniqueKeyByAutoCommit(ctx sessionctx.Context, p plannercore.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 ResetContextOfStmt 

func ResetContextOfStmt(ctx sessionctx.Context, s ast.StmtNode) (err error)

ResetContextOfStmt resets the StmtContext and session variables. Before every execution, we must clear statement context.

Types

type AfFinalResult 

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

AfFinalResult indicates aggregation functions final result.

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 closes all executors and release all resources.

func (*AnalyzeExec) Next 

func (e *AnalyzeExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*AnalyzeExec) Open 

func (e *AnalyzeExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*AnalyzeExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*CancelDDLJobsExec) Next added in v1.0.1 

func (e *CancelDDLJobsExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*CancelDDLJobsExec) Open added in v1.0.1 

func (e *CancelDDLJobsExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*CancelDDLJobsExec) Schema added in v1.0.1 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type CheckIndexExec 

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

CheckIndexExec represents the executor of checking an index. It is built from the "admin check index" statement, and it checks the consistency of the index data with the records of the table.

func (*CheckIndexExec) Close 

func (e *CheckIndexExec) Close() error

Close implements the Executor Close interface.

func (*CheckIndexExec) Next 

func (e *CheckIndexExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*CheckIndexExec) Open 

func (e *CheckIndexExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*CheckIndexExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type CheckIndexRangeExec 

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

CheckIndexRangeExec outputs the index values which has handle between begin and end.

func (*CheckIndexRangeExec) Close 

func (e *CheckIndexRangeExec) Close() error

Close implements the Executor Close interface.

func (*CheckIndexRangeExec) Next 

func (e *CheckIndexRangeExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*CheckIndexRangeExec) Open 

func (e *CheckIndexRangeExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*CheckIndexRangeExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*CheckTableExec) Next 

func (e *CheckTableExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*CheckTableExec) Open 

func (e *CheckTableExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*CheckTableExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type ChecksumTableExec 

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

ChecksumTableExec represents ChecksumTable executor.

func (*ChecksumTableExec) Close 

func (e *ChecksumTableExec) Close() error

Close closes all executors and release all resources.

func (*ChecksumTableExec) Next 

func (e *ChecksumTableExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ChecksumTableExec) Open 

func (e *ChecksumTableExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*ChecksumTableExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type CleanupIndexExec 

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

CleanupIndexExec represents a cleanup index executor. It is built from "admin cleanup index" statement, is used to delete dangling index data.

func (*CleanupIndexExec) Close 

func (e *CleanupIndexExec) Close() error

Close implements the Executor Close interface.

func (*CleanupIndexExec) Next 

func (e *CleanupIndexExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*CleanupIndexExec) Open 

func (e *CleanupIndexExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*CleanupIndexExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type Closeable 

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

Closeable is a interface for closeable structures.

type Compiler 

type Compiler struct {
	Ctx sessionctx.Context
}

Compiler compiles an ast.StmtNode to a physical plan.

func (*Compiler) Compile 

func (c *Compiler) Compile(ctx context.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 closes all executors and release all resources.

func (*DDLExec) Next 

func (e *DDLExec) Next(ctx context.Context, chk *chunk.Chunk) (err error)

Next implements the Executor Next interface.

func (*DDLExec) Open 

func (e *DDLExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*DDLExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*DeallocateExec) Next 

func (e *DeallocateExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*DeallocateExec) Open 

func (e *DeallocateExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*DeallocateExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*DeleteExec) Open 

func (e *DeleteExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*DeleteExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type DirtyDB 

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

DirtyDB stores uncommitted write operations for a transaction. It is stored and retrieved by context.Value and context.SetValue method.

func GetDirtyDB 

func GetDirtyDB(ctx sessionctx.Context) *DirtyDB

GetDirtyDB returns the DirtyDB bind to the context.

func (*DirtyDB) AddRow 

func (udb *DirtyDB) AddRow(tid, handle int64, row []types.Datum)

AddRow adds a row to the DirtyDB.

func (*DirtyDB) DeleteRow 

func (udb *DirtyDB) DeleteRow(tid int64, handle int64)

DeleteRow deletes a row from the DirtyDB.

func (*DirtyDB) GetDirtyTable 

func (udb *DirtyDB) GetDirtyTable(tid int64) *DirtyTable

GetDirtyTable gets the DirtyTable by id from the DirtyDB.

func (*DirtyDB) TruncateTable 

func (udb *DirtyDB) TruncateTable(tid int64)

TruncateTable truncates a table.

type DirtyTable 

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

DirtyTable stores uncommitted write operation for a transaction.

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 plannercore.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 sessionctx.Context
	// StartTime stands for the starting time when executing the statement.
	StartTime time.Time
	// contains filtered or unexported fields
}

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

func (*ExecStmt) Exec 

func (a *ExecStmt) Exec(ctx context.Context) (ast.RecordSet, error)

Exec 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 returns true if stmt is a prepare statement.

func (*ExecStmt) IsReadOnly added in v1.0.3 

func (a *ExecStmt) IsReadOnly() bool

IsReadOnly returns true if a statement is read only. It will update readOnlyCheckStmt if current ExecStmt can be conveted to a plannercore.Execute. Last step is using ast.IsReadOnly function to determine a statement is read only or not.

func (*ExecStmt) LogSlowQuery 

func (a *ExecStmt) LogSlowQuery(txnTS uint64, succ bool)

LogSlowQuery is used to print the slow query in the log files.

func (*ExecStmt) OriginText 

func (a *ExecStmt) OriginText() string

OriginText returns original statement as a string.

func (*ExecStmt) RebuildPlan added in v1.0.3 

func (a *ExecStmt) RebuildPlan() (int64, error)

RebuildPlan rebuilds current execute statement plan. It returns the current information schema version that 'a' is using.

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 closes all executors and release all resources.

func (*ExecuteExec) Next 

func (e *ExecuteExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ExecuteExec) Open 

func (e *ExecuteExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*ExecuteExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type Executor 

type Executor interface {
	Open(context.Context) error
	Next(ctx context.Context, chk *chunk.Chunk) error
	Close() error
	Schema() *expression.Schema
	// contains filtered or unexported methods
}

Executor is the physical implementation of a algebra operator.

In TiDB, all algebra operators are implemented as iterators, i.e., they support a simple Open-Next-Close protocol. See this paper for more details:

"Volcano-An Extensible and Parallel Query Evaluation System"

Different from Volcano's execution model, a "Next" function call in TiDB will return a batch of rows, other than a single row in Volcano. NOTE: Executors must call "chk.Reset()" before appending their results to it.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ExplainExec) Open 

func (e *ExplainExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*ExplainExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*GrantExec) Next 

func (e *GrantExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*GrantExec) Open 

func (e *GrantExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*GrantExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type HashAggExec 

type HashAggExec struct {
	PartialAggFuncs []aggfuncs.AggFunc
	FinalAggFuncs   []aggfuncs.AggFunc

	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 PartialAggFuncs. The parallel execution flow is as the following graph shows: 

                  +-------------+
                  | Main Thread |
                  +------+------+
                         ^
                         |
                         +
                    +-+-            +-+
                    | |    ......   | |  finalOutputCh
                    +++-            +-+
                     ^
                     |
                     +---------------+
                     |               |
       +--------------+             +--------------+
       | final worker |     ......  | final worker |
       +------------+-+             +-+------------+
                    ^                 ^
                    |                 |
                   +-+  +-+  ......  +-+
                   | |  | |          | |
                   ...  ...          ...    partialOutputChs
                   | |  | |          | |
                   +++  +++          +++
                    ^    ^            ^
+-+                 |    |            |
| |        +--------o----+            |

inputCh +-+ | +-----------------+---+ 

    | |        |                              |
    ...    +---+------------+            +----+-----------+
    | |    | partial worker |   ......   | partial worker |
    +++    +--------------+-+            +-+--------------+
     |                     ^                ^
     |                     |                |
+----v---------+          +++ +-+          +++
| data fetcher | +------> | | | |  ......  | |   partialInputChs
+--------------+          +-+ +-+          +-+

func (*HashAggExec) Close 

func (e *HashAggExec) Close() error

Close implements the Executor Close interface.

func (*HashAggExec) Next 

func (e *HashAggExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*HashAggExec) Open 

func (e *HashAggExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*HashAggExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type HashAggFinalWorker 

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

HashAggFinalWorker indicates the final workers of parallel hash agg execution, the number of the worker can be set by `tidb_hashagg_final_concurrency`.

type HashAggInput 

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

HashAggInput indicates the input of hash agg exec.

type HashAggIntermData 

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

HashAggIntermData indicates the intermediate data of aggregation execution.

type HashAggPartialWorker 

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

HashAggPartialWorker indicates the partial workers of parallel hash agg execution, the number of the worker can be set by `tidb_hashagg_partial_concurrency`.

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(ctx context.Context, chk *chunk.Chunk) (err error)

Next implements the Executor Next 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(ctx context.Context) error

Open implements the Executor Open interface.

func (*HashJoinExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements Exec Next interface.

func (*IndexLookUpExecutor) Open 

func (e *IndexLookUpExecutor) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*IndexLookUpExecutor) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor interface.

func (*IndexLookUpJoin) Open 

func (e *IndexLookUpJoin) Open(ctx context.Context) error

Open implements the Executor interface.

func (*IndexLookUpJoin) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 clears all resources hold by current object.

func (*IndexReaderExecutor) Next 

func (e *IndexReaderExecutor) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*IndexReaderExecutor) Open 

func (e *IndexReaderExecutor) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*IndexReaderExecutor) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type InsertExec 

type InsertExec struct {
	*InsertValues
	OnDuplicate []*expression.Assignment
	Priority    mysql.PriorityEnum
}

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(ctx context.Context, chk *chunk.Chunk) error

Next implements Exec Next interface.

func (*InsertExec) Open 

func (e *InsertExec) Open(ctx context.Context) error

Open implements the Executor Close interface.

func (InsertExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type InsertValues 

type InsertValues struct {
	SelectExec Executor

	Table   table.Table
	Columns []*ast.ColumnName
	Lists   [][]expression.Expression
	SetList []*expression.Assignment

	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 closes all executors and release all resources.

func (*InsertValues) Next 

func (e *InsertValues) Next(ctx context.Context, chk *chunk.Chunk) error

Next fills mutiple rows into a chunk.

func (*InsertValues) Open 

func (e *InsertValues) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*InsertValues) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*LimitExec) Open 

func (e *LimitExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*LimitExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type LoadDataExec 

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

LoadDataExec represents a load data executor.

func (*LoadDataExec) Close 

func (e *LoadDataExec) Close() error

Close implements the Executor Close interface.

func (*LoadDataExec) Next 

func (e *LoadDataExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*LoadDataExec) Open 

func (e *LoadDataExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*LoadDataExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type LoadDataInfo 

type LoadDataInfo struct {
	*InsertValues

	Path        string
	Table       table.Table
	FieldsInfo  *ast.FieldsClause
	LinesInfo   *ast.LinesClause
	IgnoreLines uint64
	Ctx         sessionctx.Context
	// contains filtered or unexported fields
}

LoadDataInfo saves the information of loading data operation.

func NewLoadDataInfo 

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

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

func (LoadDataInfo) Close 

func (e LoadDataInfo) Close() error

Close closes all executors and release all resources.

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

func (e LoadDataInfo) Next(ctx context.Context, chk *chunk.Chunk) error

Next fills mutiple rows into a chunk.

func (LoadDataInfo) Open 

func (e LoadDataInfo) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (LoadDataInfo) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

func (*LoadDataInfo) SetMaxRowsInBatch 

func (e *LoadDataInfo) SetMaxRowsInBatch(limit uint64)

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

type LoadStatsExec 

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

LoadStatsExec represents a load statistic executor.

func (*LoadStatsExec) Close 

func (e *LoadStatsExec) Close() error

Close implements the Executor Close interface.

func (*LoadStatsExec) Next 

func (e *LoadStatsExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*LoadStatsExec) Open 

func (e *LoadStatsExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*LoadStatsExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type LoadStatsInfo 

type LoadStatsInfo struct {
	Path string
	Ctx  sessionctx.Context
}

LoadStatsInfo saves the information of loading statistic operation.

func (*LoadStatsInfo) Update 

func (e *LoadStatsInfo) Update(data []byte) error

Update updates the stats of the corresponding table according to the data.

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 closes all executors and release all resources.

func (*MaxOneRowExec) Next 

func (e *MaxOneRowExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*MaxOneRowExec) Open 

func (e *MaxOneRowExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*MaxOneRowExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*MergeJoinExec) Open 

func (e *MergeJoinExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*MergeJoinExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) (err error)

Next implements the Executor interface.

func (*NestedLoopApplyExec) Open 

func (e *NestedLoopApplyExec) Open(ctx context.Context) error

Open implements the Executor interface.

func (*NestedLoopApplyExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type PointGetExecutor 

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

PointGetExecutor executes point select query.

func (*PointGetExecutor) Close 

func (e *PointGetExecutor) Close() error

Close implements the Executor interface.

func (*PointGetExecutor) Next 

func (e *PointGetExecutor) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor interface.

func (*PointGetExecutor) Open 

func (e *PointGetExecutor) Open(context.Context) error

Open implements the Executor interface.

func (*PointGetExecutor) Schema 

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

Schema implements the Executor 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 sessionctx.Context, is infoschema.InfoSchema, sqlTxt string) *PrepareExec

NewPrepareExec creates a new PrepareExec.

func (*PrepareExec) Close 

func (e *PrepareExec) Close() error

Close closes all executors and release all resources.

func (*PrepareExec) Next 

func (e *PrepareExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*PrepareExec) Open 

func (e *PrepareExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*PrepareExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type ProjectionExec 

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

ProjectionExec implements the physical Projection Operator: https://en.wikipedia.org/wiki/Projection_(relational_algebra)

func (*ProjectionExec) Close 

func (e *ProjectionExec) Close() error

Close implements the Executor Close interface.

func (*ProjectionExec) Next 

func (e *ProjectionExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

Here we explain the execution flow of the parallel projection implementation. There are 3 main components:

  1. "projectionInputFetcher": Fetch input "Chunk" from child.
  2. "projectionWorker": Do the projection work.
  3. "ProjectionExec.Next": Return result to parent.

1. "projectionInputFetcher" gets its input and output resources from its "inputCh" and "outputCh" channel, once the input and output resources are abtained, it fetches child's result into "input.chk" and: 

a. Dispatches this input to the worker specified in "input.targetWorker"
b. Dispatches this output to the main thread: "ProjectionExec.Next"
c. Dispatches this output to the worker specified in "input.targetWorker"

It is finished and exited once: 

a. There is no more input from child.
b. "ProjectionExec" close the "globalFinishCh"

2. "projectionWorker" gets its input and output resources from its "inputCh" and "outputCh" channel, once the input and output resources are abtained, it calculates the projection result use "input.chk" as the input and "output.chk" as the output, once the calculation is done, it: 

a. Sends "nil" or error to "output.done" to mark this input is finished.
b. Returns the "input" resource to "projectionInputFetcher.inputCh"

They are finished and exited once: 

a. "ProjectionExec" closes the "globalFinishCh"

3. "ProjectionExec.Next" gets its output resources from its "outputCh" channel. After receiving an output from "outputCh", it should wait to receive a "nil" or error from "output.done" channel. Once a "nil" or error is received: 

 a. Returns this output to its parent
 b. Returns the "output" resource to "projectionInputFetcher.outputCh"

+-----------+----------------------+--------------------------+
|           |                      |                          |
|  +--------+---------+   +--------+---------+       +--------+---------+
|  | projectionWorker |   + projectionWorker |  ...  + projectionWorker |
|  +------------------+   +------------------+       +------------------+
|       ^       ^              ^       ^                  ^       ^
|       |       |              |       |                  |       |
|    inputCh outputCh       inputCh outputCh           inputCh outputCh
|       ^       ^              ^       ^                  ^       ^
|       |       |              |       |                  |       |
|                              |       |
|                              |       +----------------->outputCh
|                              |       |                      |
|                              |       |                      v
|                      +-------+-------+--------+   +---------------------+
|                      | projectionInputFetcher |   | ProjectionExec.Next |
|                      +------------------------+   +---------+-----------+
|                              ^       ^                      |
|                              |       |                      |
|                           inputCh outputCh                  |
|                              ^       ^                      |
|                              |       |                      |
+------------------------------+       +----------------------+

func (*ProjectionExec) Open 

func (e *ProjectionExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*ProjectionExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type RecoverIndexExec 

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

RecoverIndexExec represents a recover index executor. It is built from "admin recover index" statement, is used to backfill corrupted index.

func (*RecoverIndexExec) Close 

func (e *RecoverIndexExec) Close() error

Close closes all executors and release all resources.

func (*RecoverIndexExec) Next 

func (e *RecoverIndexExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*RecoverIndexExec) Open 

func (e *RecoverIndexExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*RecoverIndexExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type ReplaceExec 

type ReplaceExec struct {
	*InsertValues
	Priority int
}

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ReplaceExec) Open 

func (e *ReplaceExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (ReplaceExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*RevokeExec) Next 

func (e *RevokeExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*RevokeExec) Open 

func (e *RevokeExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*RevokeExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*SelectLockExec) Next 

func (e *SelectLockExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*SelectLockExec) Open 

func (e *SelectLockExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*SelectLockExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 plannercore.Plan Close interface.

func (*SelectionExec) Next 

func (e *SelectionExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*SelectionExec) Open 

func (e *SelectionExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*SelectionExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type SetExecutor 

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

SetExecutor executes set statement.

func (*SetExecutor) Close 

func (e *SetExecutor) Close() error

Close closes all executors and release all resources.

func (*SetExecutor) Next 

func (e *SetExecutor) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*SetExecutor) Open 

func (e *SetExecutor) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*SetExecutor) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*ShowDDLExec) Next 

func (e *ShowDDLExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ShowDDLExec) Open 

func (e *ShowDDLExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*ShowDDLExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type ShowDDLJobQueriesExec 

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

ShowDDLJobQueriesExec represents a show DDL job queries executor. The jobs id that is given by 'admin show ddl job queries' statement, only be searched in the latest 10 history jobs

func (*ShowDDLJobQueriesExec) Close 

func (e *ShowDDLJobQueriesExec) Close() error

Close closes all executors and release all resources.

func (*ShowDDLJobQueriesExec) Next 

func (e *ShowDDLJobQueriesExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ShowDDLJobQueriesExec) Open 

func (e *ShowDDLJobQueriesExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*ShowDDLJobQueriesExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*ShowDDLJobsExec) Next 

func (e *ShowDDLJobsExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ShowDDLJobsExec) Open 

func (e *ShowDDLJobsExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*ShowDDLJobsExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*ShowExec) Next 

func (e *ShowExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ShowExec) Open 

func (e *ShowExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*ShowExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type ShowNextRowIDExec 

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

ShowNextRowIDExec represents a show the next row ID executor.

func (*ShowNextRowIDExec) Close 

func (e *ShowNextRowIDExec) Close() error

Close closes all executors and release all resources.

func (*ShowNextRowIDExec) Next 

func (e *ShowNextRowIDExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ShowNextRowIDExec) Open 

func (e *ShowNextRowIDExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*ShowNextRowIDExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type ShowSlowExec 

type ShowSlowExec struct {
	ShowSlow *ast.ShowSlow
	// contains filtered or unexported fields
}

ShowSlowExec represents the executor of showing the slow queries. It is build from the "admin show slow" statement: 

admin show slow top [internal | all] N
admin show slow recent N

func (*ShowSlowExec) Close 

func (e *ShowSlowExec) Close() error

Close closes all executors and release all resources.

func (*ShowSlowExec) Next 

func (e *ShowSlowExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*ShowSlowExec) Open 

func (e *ShowSlowExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*ShowSlowExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*SimpleExec) Next 

func (e *SimpleExec) Next(ctx context.Context, chk *chunk.Chunk) (err error)

Next implements the Executor Next interface.

func (*SimpleExec) Open 

func (e *SimpleExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*SimpleExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type SortExec 

type SortExec struct {
	ByItems []*plannercore.ByItems
	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) Next 

func (e *SortExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*SortExec) Open 

func (e *SortExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*SortExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type StreamAggExec 

type StreamAggExec struct {
	StmtCtx      *stmtctx.StatementContext
	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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*StreamAggExec) Open 

func (e *StreamAggExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*StreamAggExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*TableDualExec) Next 

func (e *TableDualExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*TableDualExec) Open 

func (e *TableDualExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*TableDualExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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(ctx context.Context, chk *chunk.Chunk) error

Next fills data into the chunk passed by its caller. The task was actually done by tableReaderHandler.

func (*TableReaderExecutor) Open 

func (e *TableReaderExecutor) Open(ctx context.Context) error

Open initialzes necessary variables for using this executor.

func (*TableReaderExecutor) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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 closes all executors and release all resources.

func (*TableScanExec) Next 

func (e *TableScanExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*TableScanExec) Open 

func (e *TableScanExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*TableScanExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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

func (e *TopNExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*TopNExec) Open 

func (e *TopNExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*TopNExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type TraceExec 

type TraceExec struct {

	// CollectedSpans collects all span during execution. Span is appended via
	// callback method which passes into tracer implementation.
	CollectedSpans []basictracer.RawSpan
	// contains filtered or unexported fields
}

TraceExec represents a root executor of trace query.

func (*TraceExec) Close 

func (e *TraceExec) Close() error

Close closes all executors and release all resources.

func (*TraceExec) Next 

func (e *TraceExec) Next(ctx context.Context, chk *chunk.Chunk) error

Next executes real query and collects span later.

func (*TraceExec) Open 

func (e *TraceExec) Open(ctx context.Context) error

Open initializes children recursively and "childrenResults" according to children's schemas.

func (*TraceExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type UnionExec 

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

UnionExec pulls all it's children's 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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*UnionExec) Open 

func (e *UnionExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*UnionExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

type UnionScanExec 

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

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

func (*UnionScanExec) Close 

func (e *UnionScanExec) Close() error

Close closes all executors and release all resources.

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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*UnionScanExec) Open 

func (us *UnionScanExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*UnionScanExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

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
	// 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(ctx context.Context, chk *chunk.Chunk) error

Next implements the Executor Next interface.

func (*UpdateExec) Open 

func (e *UpdateExec) Open(ctx context.Context) error

Open implements the Executor Open interface.

func (*UpdateExec) Schema 

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

Schema returns the current baseExecutor's schema. If it is nil, then create and return a new one.

Source Files

View all Source files

Directories

Path Synopsis

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.