variable

package
v0.0.0-...-74d5ce4 Latest Latest
Warning

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

 Go to latest Published: Sep 15, 2017 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

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 (
	// 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_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_cbo uses new planner with cost based optimizer.
	TiDBCBO = "tidb_cbo"
)

TiDB system variable names.

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

Default TiDB system variable values.

Variables

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 SetNamesVariables = []string{
	"character_set_client",
	"character_set_connection",
	"character_set_results",
}

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

View Source 
var SysVars map[string]*SysVar

SysVars is global sys vars map.

Functions

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.

Types

type GlobalVarAccessor 

type GlobalVarAccessor interface {
	// 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 http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
	CurrInsertValues interface{}

	// Per-connection time zones. Each client that connects has its own time zone setting, given by the session time_zone variable.
	// See https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html
	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

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

	// CBO indicates if we use new planner with cbo.
	CBO bool
	// 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 https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html

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
	TruncateAsWarning    bool
	OverflowAsWarning    bool
	InShowWarning        bool

	// Copied from SessionVars.TimeZone.
	TimeZone *time.Location
	Priority mysql.PriorityEnum
	// 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
	TableDeltaMap map[int64]TableDelta
}

TransactionContext is used to store variables that has transaction scope.

func (*TransactionContext) UpdateDeltaForTable 

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

UpdateDeltaForTable updates the delta info for some table.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.