sqlexec

Documentation

Index

• Variables
• func DrainRecordSet(ctx context.Context, rs RecordSet, maxChunkSize int) ([]chunk.Row, error)
• func EscapeSQL(sql string, args ...interface{}) (string, error)
• func EscapeString(s string) string
• func FormatSQL(w io.Writer, sql string, args ...interface{}) error
• func MustEscapeSQL(sql string, args ...interface{}) string
• func MustFormatSQL(w *strings.Builder, sql string, args ...interface{})
• type ExecOption
  • func GetExecOption(opts []OptionFuncAlias) ExecOption
• type MultiQueryNoDelayResult
• type OptionFuncAlias
  • func ExecOptionWithSnapshot(snapshot uint64) OptionFuncAlias
  • func ExecOptionWithSysProcTrack(procID uint64, track func(id uint64, ctx sessionctx.Context) error, ...) OptionFuncAlias
  • func GetAnalyzeSnapshotOption(analyzeSnapshot bool) OptionFuncAlias
  • func GetPartitionPruneModeOption(pruneMode string) OptionFuncAlias
• type RecordSet
• type RestrictedSQLExecutor
• type SQLExecutor
• type SQLParser
• type SimpleRecordSet
  • func (r *SimpleRecordSet) Close() error
  • func (r *SimpleRecordSet) Fields() []*ast.ResultField
  • func (r *SimpleRecordSet) NewChunk(alloc chunk.Allocator) *chunk.Chunk
  • func (r *SimpleRecordSet) Next(_ context.Context, req *chunk.Chunk) error
• type Statement

Variables

var ExecOptionAnalyzeVer1 = func(option *ExecOption) {
	option.AnalyzeVer = 1
}

ExecOptionAnalyzeVer1 tells ExecRestrictedStmt/SQL to collect statistics with version1.

var ExecOptionAnalyzeVer2 = func(option *ExecOption) {
	option.AnalyzeVer = 2
}

ExecOptionAnalyzeVer2 tells ExecRestrictedStmt/SQL to collect statistics with version2.

var ExecOptionIgnoreWarning = func(option *ExecOption) {
	option.IgnoreWarning = true
}

ExecOptionIgnoreWarning tells ExecRestrictedStmt/SQL to ignore the warnings.

var ExecOptionUseCurSession = func(option *ExecOption) {
	option.UseCurSession = true
}

ExecOptionUseCurSession tells ExecRestrictedStmt/SQL to use current session.

var ExecOptionUseSessionPool = func(option *ExecOption) {
	option.UseCurSession = false
}

ExecOptionUseSessionPool tells ExecRestrictedStmt/SQL to use session pool. UseCurSession is false by default, sometimes we set it explicitly for readability

Functions

func DrainRecordSet

func DrainRecordSet(ctx context.Context, rs RecordSet, maxChunkSize int) ([]chunk.Row, error)

DrainRecordSet fetches the rows in the RecordSet.

func EscapeSQL

func EscapeSQL(sql string, args ...interface{}) (string, error)

EscapeSQL will escape input arguments into the sql string, doing necessary processing. It works like printf() in c, there are following format specifiers: 1. %?: automatic conversion by the type of arguments. E.g. []string -> ('s1','s2'..) 2. %%: output % 3. %n: for identifiers, for example ("use %n", db) But it does not prevent you from doing:

EscapeSQL("select '%?", ";SQL injection!;") => "select '';SQL injection!;'".

It is still your responsibility to write safe SQL.

func EscapeString

func EscapeString(s string) string

EscapeString is used by session/bootstrap.go, which has some dynamic query building cases not well handled by this package. For normal usage, please use EscapeSQL instead!

func FormatSQL

func FormatSQL(w io.Writer, sql string, args ...interface{}) error

FormatSQL is the io.Writer version of EscapeSQL. Please refer to EscapeSQL for details.

func MustEscapeSQL

func MustEscapeSQL(sql string, args ...interface{}) string

MustEscapeSQL is a helper around EscapeSQL. The error returned from escapeSQL can be avoided statically if you do not pass interface{}.

func MustFormatSQL

func MustFormatSQL(w *strings.Builder, sql string, args ...interface{})

MustFormatSQL is a helper around FormatSQL, like MustEscapeSQL. But it asks that the writer must be strings.Builder, which will not return error when w.Write(...).

Types

type ExecOption

type ExecOption struct {
	AnalyzeSnapshot    *bool
	TrackSysProc       func(id uint64, ctx sessionctx.Context) error
	UnTrackSysProc     func(id uint64)
	PartitionPruneMode string
	SnapshotTS         uint64
	AnalyzeVer         int
	TrackSysProcID     uint64
	IgnoreWarning      bool
	UseCurSession      bool
}

ExecOption is a struct defined for ExecRestrictedStmt/SQL option.

func GetExecOption

func GetExecOption(opts []OptionFuncAlias) ExecOption

GetExecOption applies OptionFuncs and return ExecOption

type MultiQueryNoDelayResult

type MultiQueryNoDelayResult interface {
	// AffectedRows return affected row for one statement in multi-queries.
	AffectedRows() uint64
	// LastMessage return last message for one statement in multi-queries.
	LastMessage() string
	// WarnCount return warn count for one statement in multi-queries.
	WarnCount() uint16
	// Status return status when executing one statement in multi-queries.
	Status() uint16
	// LastInsertID return last insert id for one statement in multi-queries.
	LastInsertID() uint64
}

MultiQueryNoDelayResult is an interface for one no-delay result for one statement in multi-queries.

type OptionFuncAlias

type OptionFuncAlias = func(option *ExecOption)

OptionFuncAlias is defined for the optional parameter of ExecRestrictedStmt/SQL.

func ExecOptionWithSnapshot

func ExecOptionWithSnapshot(snapshot uint64) OptionFuncAlias

ExecOptionWithSnapshot tells ExecRestrictedStmt/SQL to use a snapshot.

func ExecOptionWithSysProcTrack

func ExecOptionWithSysProcTrack(procID uint64, track func(id uint64, ctx sessionctx.Context) error, untrack func(id uint64)) OptionFuncAlias

ExecOptionWithSysProcTrack tells ExecRestrictedStmt/SQL to track sys process.

func GetAnalyzeSnapshotOption

func GetAnalyzeSnapshotOption(analyzeSnapshot bool) OptionFuncAlias

GetAnalyzeSnapshotOption returns a function which tells ExecRestrictedStmt/SQL to run with analyzeSnapshot.

func GetPartitionPruneModeOption

func GetPartitionPruneModeOption(pruneMode string) OptionFuncAlias

GetPartitionPruneModeOption returns a function which tells ExecRestrictedStmt/SQL to run with pruneMode.

type RecordSet

type RecordSet interface {
	// Fields gets result fields.
	Fields() []*ast.ResultField

	// Next reads records into chunk.
	Next(ctx context.Context, req *chunk.Chunk) error

	// NewChunk create a chunk, if allocator is nil, the default one is used.
	NewChunk(chunk.Allocator) *chunk.Chunk

	// Close closes the underlying iterator, call Next after Close will
	// restart the iteration.
	Close() error
}

RecordSet is an abstract result set interface to help get data from Plan.

type RestrictedSQLExecutor

type RestrictedSQLExecutor interface {
	// ParseWithParams is the parameterized version of Parse: it will try to prevent injection under utf8mb4.
	// It works like printf() in c, there are following format specifiers:
	// 1. %?: automatic conversion by the type of arguments. E.g. []string -> ('s1','s2'..)
	// 2. %%: output %
	// 3. %n: for identifiers, for example ("use %n", db)
	//
	// Attention: it does not prevent you from doing parse("select '%?", ";SQL injection!;") => "select ”;SQL injection!;'".
	// One argument should be a standalone entity. It should not "concat" with other placeholders and characters.
	// This function only saves you from processing potentially unsafe parameters.
	ParseWithParams(ctx context.Context, sql string, args ...interface{}) (ast.StmtNode, error)
	// ExecRestrictedStmt run sql statement in ctx with some restrictions.
	ExecRestrictedStmt(ctx context.Context, stmt ast.StmtNode, opts ...OptionFuncAlias) ([]chunk.Row, []*ast.ResultField, error)
	// ExecRestrictedSQL run sql string in ctx with internal session.
	ExecRestrictedSQL(ctx context.Context, opts []OptionFuncAlias, sql string, args ...interface{}) ([]chunk.Row, []*ast.ResultField, error)
}

RestrictedSQLExecutor is an interface provides executing restricted sql statement. Why we need this interface? When we execute some management statements, we need to operate system tables. For example when executing create user statement, we need to check if the user already exists in the mysql.User table and insert a new row if not exists. In this case, we need a convenience way to manipulate system tables. The most simple way is executing sql statement. In order to execute sql statement in stmts package, we add this interface to solve dependence problem. And in the same time, we do not want this interface becomes a general way to run sql statement. We hope this could be used with some restrictions such as only allowing system tables as target, do not allowing recursion call. This is implemented in session.go.

type SQLExecutor

type SQLExecutor interface {
	// Execute is only used by plugins. It can be removed soon.
	Execute(ctx context.Context, sql string) ([]RecordSet, error)
	// ExecuteInternal means execute sql as the internal sql.
	ExecuteInternal(ctx context.Context, sql string, args ...interface{}) (RecordSet, error)
	ExecuteStmt(ctx context.Context, stmtNode ast.StmtNode) (RecordSet, error)
	// allowed when tikv disk full happened.
	SetDiskFullOpt(level kvrpcpb.DiskFullOpt)
	// clear allowed flag
	ClearDiskFullOpt()
}

SQLExecutor is an interface provides executing normal sql statement. Why we need this interface? To break circle dependence of packages. For example, privilege/privileges package need execute SQL, if it use session.Session.Execute, then privilege/privileges and tidb would become a circle.

type SQLParser

type SQLParser interface {
	ParseSQL(ctx context.Context, sql string, params ...parser.ParseParam) ([]ast.StmtNode, []error, error)
}

SQLParser is an interface provides parsing sql statement. To parse a sql statement, we could run parser.New() to get a parser object, and then run Parse method on it. But a session already has a parser bind in it, so we define this interface and use session as its implementation, thus avoid allocating new parser. See session.SQLParser for more information.

type SimpleRecordSet

type SimpleRecordSet struct {
	ResultFields []*ast.ResultField
	Rows         [][]interface{}
	MaxChunkSize int
	// contains filtered or unexported fields
}

SimpleRecordSet is a simple implementation of RecordSet. All values are known when creating SimpleRecordSet.

func (*SimpleRecordSet) Close

func (r *SimpleRecordSet) Close() error

Close implements the sqlexec.RecordSet interface.

func (*SimpleRecordSet) Fields

func (r *SimpleRecordSet) Fields() []*ast.ResultField

Fields implements the sqlexec.RecordSet interface.

func (*SimpleRecordSet) NewChunk

func (r *SimpleRecordSet) NewChunk(alloc chunk.Allocator) *chunk.Chunk

NewChunk implements the sqlexec.RecordSet interface.

func (*SimpleRecordSet) Next

func (r *SimpleRecordSet) Next(_ context.Context, req *chunk.Chunk) error

Next implements the sqlexec.RecordSet interface.

type Statement

type Statement interface {
	// OriginText gets the origin SQL text.
	OriginText() string

	// GetTextToLog gets the desensitization SQL text for logging.
	GetTextToLog() string

	// Exec executes SQL and gets a Recordset.
	Exec(ctx context.Context) (RecordSet, error)

	// IsPrepared returns whether this statement is prepared statement.
	IsPrepared() bool

	// IsReadOnly returns if the statement is read only. For example: SelectStmt without lock.
	IsReadOnly(vars *variable.SessionVars) bool

	// RebuildPlan rebuilds the plan of the statement.
	RebuildPlan(ctx context.Context) (schemaVersion int64, err error)

	// GetStmtNode returns the stmtNode inside Statement
	GetStmtNode() ast.StmtNode
}

Statement is an interface for SQL execution. NOTE: all Statement implementations must be safe for concurrent using by multiple goroutines. If the Exec method requires any Execution domain local data, they must be held out of the implementing instance.