v1.0.9 Latest Latest

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

Go to latest
Published: Apr 20, 2018 License: Apache-2.0 Imports: 11 Imported by: 0




View Source
const (
	SQLModeVar          = "sql_mode"
	AutocommitVar       = "autocommit"
	CharacterSetResults = "character_set_results"
	MaxAllowedPacket    = "max_allowed_packet"
	TimeZone            = "time_zone"
	TxnIsolation        = "tx_isolation"

special session variables.

View Source
const (
	CodeUnknownStatusVar terror.ErrCode = 1
	CodeUnknownSystemVar terror.ErrCode = 1193
	CodeIncorrectScope   terror.ErrCode = 1238
	CodeUnknownTimeZone  terror.ErrCode = 1298
	CodeReadOnly         terror.ErrCode = 1621

Variable error codes.

View Source
const (
	// CharacterSetConnection is the name for character_set_connection system variable.
	CharacterSetConnection = "character_set_connection"
	// CollationConnection is the name for collation_connection system variable.
	CollationConnection = "collation_connection"
	// CharsetDatabase is the name for character_set_database system variable.
	CharsetDatabase = "character_set_database"
	// CollationDatabase is the name for collation_database system variable.
	CollationDatabase = "collation_database"
View Source
const (

	// tidb_snapshot is used for reading history data, the default value is empty string.
	// When the value is set to a datetime string like '2017-11-11 20:20:20', the session reads history data of that time.
	TiDBSnapshot = "tidb_snapshot"

	// tidb_skip_constraint_check is used for loading data from a dump file, to speed up the loading process.
	// When the value is set to true, unique index constraint is not checked.
	TiDBSkipConstraintCheck = "tidb_skip_constraint_check"

	// tidb_opt_agg_push_down is used to endable/disable the optimizer rule of aggregation push down.
	TiDBOptAggPushDown = "tidb_opt_agg_push_down"

	// tidb_opt_insubquery_unfold is used to enable/disable the optimizer rule of in subquery unfold.
	TiDBOptInSubqUnFolding = "tidb_opt_insubquery_unfold"

	// tidb_build_stats_concurrency is used to speed up the ANALYZE statement, when a table has multiple indices,
	// those indices can be scanned concurrently, with the cost of higher system performance impact.
	TiDBBuildStatsConcurrency = "tidb_build_stats_concurrency"

	// TiDBCurrentTS is used to get the current transaction timestamp.
	// It is read-only.
	TiDBCurrentTS = "tidb_current_ts"

	// tidb_distsql_scan_concurrency is used to set the concurrency of a distsql scan task.
	// A distsql scan task can be a table scan or a index scan, which may be distributed to many TiKV nodes.
	// Higher concurrency may reduce latency, but with the cost of higher memory usage and system performance impact.
	// If the query has a LIMIT clause, high concurrency makes the system do much more work than needed.
	TiDBDistSQLScanConcurrency = "tidb_distsql_scan_concurrency"

	// tidb_index_join_batch_size is used to set the batch size of a index lookup join.
	// The index lookup join fetches batches of data from outer executor and constructs ranges for inner executor.
	// This value controls how much of data in a batch to do the index join.
	// Large value may reduce the latency but consumes more system resource.
	TiDBIndexJoinBatchSize = "tidb_index_join_batch_size"

	// tidb_index_lookup_size is used for index lookup executor.
	// The index lookup executor first scan a batch of handles from a index, then use those handles to lookup the table
	// rows, this value controls how much of handles in a batch to do a lookup task.
	// Small value sends more RPCs to TiKV, consume more system resource.
	// Large value may do more work than needed if the query has a limit.
	TiDBIndexLookupSize = "tidb_index_lookup_size"

	// tidb_index_lookup_concurrency is used for index lookup executor.
	// A lookup task may have 'tidb_index_lookup_size' of handles at maximun, the handles may be distributed
	// in many TiKV nodes, we executes multiple concurrent index lookup tasks concurrently to reduce the time
	// waiting for a task to finish.
	// Set this value higher may reduce the latency but consumes more system resource.
	TiDBIndexLookupConcurrency = "tidb_index_lookup_concurrency"

	// tidb_index_serial_scan_concurrency is used for controlling the concurrency of index scan operation
	// when we need to keep the data output order the same as the order of index data.
	TiDBIndexSerialScanConcurrency = "tidb_index_serial_scan_concurrency"

	// tidb_skip_utf8_check skips the UTF8 validate process, validate UTF8 has performance cost, if we can make sure
	// the input string values are valid, we can skip the check.
	TiDBSkipUTF8Check = "tidb_skip_utf8_check"

	// tidb_batch_insert is used to enable/disable auto-split insert data. If set this option on, insert executor will automatically
	// insert data into multiple batches and use a single txn for each batch. This will be helpful when inserting large data.
	TiDBBatchInsert = "tidb_batch_insert"

	// tidb_batch_delete is used to enable/disable auto-split delete data. If set this option on, delete executor will automatically
	// split data into multiple batches and use a single txn for each batch. This will be helpful when deleting large data.
	TiDBBatchDelete = "tidb_batch_delete"

	// tidb_dml_batch_size is used to split the insert/delete data into small batches.
	// It only takes effort when tidb_batch_insert/tidb_batch_delete is on.
	// Its default value is 20000. When the row size is large, 20k rows could be larger than 100MB.
	// User could change it to a smaller one to avoid breaking the transaction size limitation.
	TiDBDMLBatchSize = "tidb_dml_batch_size"

	// tidb_max_row_count_for_inlj is used when do index nested loop join.
	// It controls the max row count of outer table when do index nested loop join without hint.
	// After the row count of the inner table is accurate, this variable will be removed.
	TiDBMaxRowCountForINLJ = "tidb_max_row_count_for_inlj"

	// tidb_general_log is used to log every query in the server in info level.
	TiDBGeneralLog = "tidb_general_log"

TiDB system variable names.

View Source
const (
	DefIndexLookupConcurrency     = 4
	DefIndexSerialScanConcurrency = 1
	DefIndexJoinBatchSize         = 25000
	DefIndexLookupSize            = 20000
	DefDistSQLScanConcurrency     = 10
	DefBuildStatsConcurrency      = 4
	DefMaxRowCountForINLJ         = 128
	DefSkipUTF8Check              = false
	DefOptAggPushDown             = false
	DefOptInSubqUnfolding         = false
	DefBatchInsert                = false
	DefBatchDelete                = false
	DefCurretTS                   = 0
	DefDMLBatchSize               = 20000
	DefTiDBGeneralLog             = 0

Default TiDB system variable values.


View Source
var (
	ErrCantSetToNull  = terror.ClassVariable.New(codeCantSetToNull, "cannot set variable to null")
	ErrSnapshotTooOld = terror.ClassVariable.New(codeSnapshotTooOld, "snapshot is older than GC safe point %s")

Error instances.

View Source
var (
	UnknownStatusVar   = terror.ClassVariable.New(CodeUnknownStatusVar, "unknown status variable")
	UnknownSystemVar   = terror.ClassVariable.New(CodeUnknownSystemVar, "unknown system variable '%s'")
	ErrIncorrectScope  = terror.ClassVariable.New(CodeIncorrectScope, "Incorrect variable scope")
	ErrUnknownTimeZone = terror.ClassVariable.New(CodeUnknownTimeZone, "unknown or incorrect time zone: %s")
	ErrReadOnly        = terror.ClassVariable.New(CodeReadOnly, "variable is read only")

Variable errors

View Source
var DefaultStatusVarScopeFlag = ScopeGlobal | ScopeSession

DefaultStatusVarScopeFlag is the default scope of status variables.

View Source
var (
	ProcessGeneralLog uint32

Process global variables.

View Source
var SetNamesVariables = []string{

SetNamesVariables is the system variable names related to set names statements.

View Source
var SysVars map[string]*SysVar

SysVars is global sys vars map.


func GetStatusVars

func GetStatusVars(vars *SessionVars) (map[string]*StatusVal, error)

GetStatusVars gets registered statistics status variables. TODO: Refactor this function to avoid repeated memory allocation / dealloc

func RegisterStatistics

func RegisterStatistics(s Statistics)

RegisterStatistics registers statistics.


type GlobalVarAccessor

type GlobalVarAccessor interface {
	// GetAllSysVars gets all the global system variable values.
	GetAllSysVars() (map[string]string, error)
	// GetGlobalSysVar gets the global system variable value for name.
	GetGlobalSysVar(name string) (string, error)
	// SetGlobalSysVar sets the global system variable name to value.
	SetGlobalSysVar(name string, value string) error

GlobalVarAccessor is the interface for accessing global scope system and status variables.

type RetryInfo

type RetryInfo struct {
	Retrying               bool
	DroppedPreparedStmtIDs []uint32
	// contains filtered or unexported fields

RetryInfo saves retry information.

func (*RetryInfo) AddAutoIncrementID

func (r *RetryInfo) AddAutoIncrementID(id int64)

AddAutoIncrementID adds id to AutoIncrementIDs.

func (*RetryInfo) Clean

func (r *RetryInfo) Clean()

Clean does some clean work.

func (*RetryInfo) GetCurrAutoIncrementID

func (r *RetryInfo) GetCurrAutoIncrementID() (int64, error)

GetCurrAutoIncrementID gets current AutoIncrementID.

func (*RetryInfo) ResetOffset

func (r *RetryInfo) ResetOffset()

ResetOffset resets the current retry offset.

type ScopeFlag

type ScopeFlag uint8

ScopeFlag is for system variable whether can be changed in global/session dynamically or not.

const (
	// ScopeNone means the system variable can not be changed dynamically.
	ScopeNone ScopeFlag = 0
	// ScopeGlobal means the system variable can be changed globally.
	ScopeGlobal ScopeFlag = 1 << 0
	// ScopeSession means the system variable can only be changed in current session.
	ScopeSession ScopeFlag = 1 << 1

type SessionVars

type SessionVars struct {
	// UsersLock is a lock for user defined variables.
	UsersLock sync.RWMutex
	// Users are user defined variables.
	Users map[string]string
	// Systems are system variables.
	Systems map[string]string
	// PreparedStmts stores prepared statement.
	PreparedStmts        map[uint32]interface{}
	PreparedStmtNameToID map[string]uint32

	// retry information
	RetryInfo *RetryInfo
	// Should be reset on transaction finished.
	TxnCtx *TransactionContext

	Status           uint16
	PrevLastInsertID uint64 // PrevLastInsertID is the last insert ID of previous statement.
	LastInsertID     uint64 // LastInsertID is the auto-generated ID in the current statement.
	InsertID         uint64 // InsertID is the given insert ID of an auto_increment column.

	// ClientCapability is client's capability.
	ClientCapability uint32

	// TLSConnectionState is the TLS connection state (nil if not using TLS).
	TLSConnectionState *tls.ConnectionState

	// ConnectionID is the connection id of the current session.
	ConnectionID uint64

	// User is the user identity with which the session login.
	User *auth.UserIdentity

	// CurrentDB is the default database of this session.
	CurrentDB string

	// StrictSQLMode indicates if the session is in strict mode.
	StrictSQLMode bool

	// CommonGlobalLoaded indicates if common global variable has been loaded for this session.
	CommonGlobalLoaded bool

	// InRestrictedSQL indicates if the session is handling restricted SQL execution.
	InRestrictedSQL bool

	// SnapshotTS is used for reading history data. For simplicity, SnapshotTS only supports distsql request.
	SnapshotTS uint64

	// SnapshotInfoschema is used with SnapshotTS, when the schema version at snapshotTS less than current schema
	// version, we load an old version schema for query.
	SnapshotInfoschema interface{}

	// BinlogClient is used to write binlog.
	BinlogClient interface{}

	// GlobalVarsAccessor is used to set and get global variables.
	GlobalVarsAccessor GlobalVarAccessor

	// LastFoundRows is the number of found rows of last query statement
	LastFoundRows uint64

	// StmtCtx holds variables for current executing statement.
	StmtCtx *StatementContext

	// AllowAggPushDown can be set to false to forbid aggregation push down.
	AllowAggPushDown bool

	// AllowInSubqueryUnFolding can be set to true to fold in subquery
	AllowInSubqueryUnFolding bool

	// CurrInsertValues is used to record current ValuesExpr's values.
	// See
	CurrInsertValues interface{}

	// Per-connection time zones. Each client that connects has its own time zone setting, given by the session time_zone variable.
	// See
	TimeZone *time.Location

	SQLMode mysql.SQLMode

	// SkipConstraintCheck is true when importing data.
	SkipConstraintCheck bool

	// SkipUTF8Check check on input value.
	SkipUTF8Check bool

	// BuildStatsConcurrencyVar is used to control statistics building concurrency.
	BuildStatsConcurrencyVar int

	// IndexJoinBatchSize is the batch size of a index lookup join.
	IndexJoinBatchSize int

	// IndexLookupSize is the number of handles for an index lookup task in index double read executor.
	IndexLookupSize int

	// IndexLookupConcurrency is the number of concurrent index lookup worker.
	IndexLookupConcurrency int

	// DistSQLScanConcurrency is the number of concurrent dist SQL scan worker.
	DistSQLScanConcurrency int

	// IndexSerialScanConcurrency is the number of concurrent index serial scan worker.
	IndexSerialScanConcurrency int

	// BatchInsert indicates if we should split insert data into multiple batches.
	BatchInsert bool

	// BatchDelete indicates if we should split delete data into multiple batches.
	BatchDelete bool

	// DMLBatchSize indicates the size of batches for DML.
	// It will be used when BatchInsert or BatchDelete is on.
	DMLBatchSize int

	// MaxRowCountForINLJ defines max row count that the outer table of index nested loop join could be without force hint.
	MaxRowCountForINLJ int
	// contains filtered or unexported fields

SessionVars is to handle user-defined or global variables in the current session.

func NewSessionVars

func NewSessionVars() *SessionVars

NewSessionVars creates a session vars object.

func (*SessionVars) GetCharsetInfo

func (s *SessionVars) GetCharsetInfo() (charset, collation string)

GetCharsetInfo gets charset and collation for current context. What character set should the server translate a statement to after receiving it? For this, the server uses the character_set_connection and collation_connection system variables. It converts statements sent by the client from character_set_client to character_set_connection (except for string literals that have an introducer such as _latin1 or _utf8). collation_connection is important for comparisons of literal strings. For comparisons of strings with column values, collation_connection does not matter because columns have their own collation, which has a higher collation precedence. See

func (*SessionVars) GetNextPreparedStmtID

func (s *SessionVars) GetNextPreparedStmtID() uint32

GetNextPreparedStmtID generates and returns the next session scope prepared statement id.

func (*SessionVars) GetStatusFlag

func (s *SessionVars) GetStatusFlag(flag uint16) bool

GetStatusFlag gets the session server status variable, returns true if it is on.

func (*SessionVars) GetTimeZone

func (s *SessionVars) GetTimeZone() *time.Location

GetTimeZone returns the value of time_zone session variable.

func (*SessionVars) InTxn

func (s *SessionVars) InTxn() bool

InTxn returns if the session is in transaction.

func (*SessionVars) IsAutocommit

func (s *SessionVars) IsAutocommit() bool

IsAutocommit returns if the session is set to autocommit.

func (*SessionVars) SetLastInsertID

func (s *SessionVars) SetLastInsertID(insertID uint64)

SetLastInsertID saves the last insert id to the session context. TODO: we may store the result for last_insert_id sys var later.

func (*SessionVars) SetStatusFlag

func (s *SessionVars) SetStatusFlag(flag uint16, on bool)

SetStatusFlag sets the session server status variable. If on is ture sets the flag in session status, otherwise removes the flag.

type StatementContext

type StatementContext struct {
	InInsertStmt           bool
	InUpdateOrDeleteStmt   bool
	InSelectStmt           bool
	IgnoreTruncate         bool
	IgnoreZeroInDate       bool
	DividedByZeroAsWarning bool
	TruncateAsWarning      bool
	OverflowAsWarning      bool
	InShowWarning          bool

	// Copied from SessionVars.TimeZone.
	TimeZone     *time.Location
	Priority     mysql.PriorityEnum
	NotFillCache bool
	BatchCheck   bool
	// contains filtered or unexported fields

StatementContext contains variables for a statement. It should be reset before executing a statement.

func MostRestrictStateContext

func MostRestrictStateContext() *StatementContext

MostRestrictStateContext gets a most restrict StatementContext.

func (*StatementContext) AddAffectedRows

func (sc *StatementContext) AddAffectedRows(rows uint64)

AddAffectedRows adds affected rows.

func (*StatementContext) AddFoundRows

func (sc *StatementContext) AddFoundRows(rows uint64)

AddFoundRows adds found rows.

func (*StatementContext) AffectedRows

func (sc *StatementContext) AffectedRows() uint64

AffectedRows gets affected rows.

func (*StatementContext) AppendWarning

func (sc *StatementContext) AppendWarning(warn error)

AppendWarning appends a warning.

func (*StatementContext) FoundRows

func (sc *StatementContext) FoundRows() uint64

FoundRows gets found rows.

func (*StatementContext) GetWarnings

func (sc *StatementContext) GetWarnings() []error

GetWarnings gets warnings.

func (*StatementContext) HandleOverflow

func (sc *StatementContext) HandleOverflow(err error, warnErr error) error

HandleOverflow treats ErrOverflow as warnings or returns the error based on the StmtCtx.OverflowAsWarning state.

func (*StatementContext) HandleTruncate

func (sc *StatementContext) HandleTruncate(err error) error

HandleTruncate ignores or returns the error based on the StatementContext state.

func (*StatementContext) ResetForRetry

func (sc *StatementContext) ResetForRetry()

ResetForRetry resets the changed states during execution.

func (*StatementContext) SetWarnings

func (sc *StatementContext) SetWarnings(warns []error)

SetWarnings sets warnings.

func (*StatementContext) WarningCount

func (sc *StatementContext) WarningCount() uint16

WarningCount gets warning count.

type Statistics

type Statistics interface {
	// GetScope gets the status variables scope.
	GetScope(status string) ScopeFlag
	// Stats returns the statistics status variables.
	Stats(*SessionVars) (map[string]interface{}, error)

Statistics is the interface of statistics.

type StatusVal

type StatusVal struct {
	Scope ScopeFlag
	Value interface{}

StatusVal is the value of the corresponding status variable.

type SysVar

type SysVar struct {
	// Scope is for whether can be changed or not
	Scope ScopeFlag

	// Name is the variable name.
	Name string

	// Value is the variable value.
	Value string

SysVar is for system variable.

func GetSysVar

func GetSysVar(name string) *SysVar

GetSysVar returns sys var info for name as key.

type TableDelta

type TableDelta struct {
	Delta int64
	Count int64

TableDelta stands for the changed count for one table.

type TransactionContext

type TransactionContext struct {
	ForUpdate     bool
	DirtyDB       interface{}
	Binlog        interface{}
	InfoSchema    interface{}
	Histroy       interface{}
	SchemaVersion int64
	StartTS       uint64
	Shard         *int64
	TableDeltaMap map[int64]TableDelta

TransactionContext is used to store variables that has transaction scope.

func (*TransactionContext) ClearDelta added in v1.0.5

func (tc *TransactionContext) ClearDelta()

ClearDelta clears the delta map.

func (*TransactionContext) UpdateDeltaForTable

func (tc *TransactionContext) UpdateDeltaForTable(tableID int64, delta int64, count int64)

UpdateDeltaForTable updates the delta info for some table.

Jump to

Keyboard shortcuts

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