tidb variable 代码
文件路径：/sessionctx/variable/variable.go
/ Copyright 2021 PingCAP, Inc.
/
/ Licensed under the Apache License, Version 2.0 (the "License");
/ you may not use this file except in compliance with the License.
/ You may obtain a copy of the License at
/
/ http://www.apache.org/licenses/LICENSE-2.0
/
/ Unless required by applicable law or agreed to in writing, software
/ distributed under the License is distributed on an "AS IS" BASIS,
/ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/ See the License for the specific language governing permissions and
/ limitations under the License.
package variable
import (
"strconv"
"strings"
"sync"
"time"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/parser/mysql"
"github.com/pingcap/tidb/types"
)
/ ScopeFlag is for system variable whether can be changed in global/session dynamically or not.
type ScopeFlag uint8
/ TypeFlag is the SysVar type, which doesn't exactly match MySQL types.
type TypeFlag byte
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
/ ScopeInstance means it is similar to global but doesn't propagate to other TiDB servers.
ScopeInstance ScopeFlag = 1 << 2
/ TypeStr is the default
TypeStr TypeFlag = 0
/ TypeBool for boolean
TypeBool TypeFlag = 1
/ TypeInt for integer
TypeInt TypeFlag = 2
/ TypeEnum for Enum
TypeEnum TypeFlag = 3
/ TypeFloat for Double
TypeFloat TypeFlag = 4
/ TypeUnsigned for Unsigned integer
TypeUnsigned TypeFlag = 5
/ TypeTime for time of day (a TiDB extension)
TypeTime TypeFlag = 6
/ TypeDuration for a golang duration (a TiDB extension)
TypeDuration TypeFlag = 7
/ On is the canonical string for ON
On = "ON"
/ Off is the canonical string for OFF
Off = "OFF"
/ Warn means return warnings
Warn = "WARN"
/ IntOnly means enable for int type
IntOnly = "INT_ONLY"
/ AssertionStrictStr is a choice of variable TiDBTxnAssertionLevel that means full assertions should be performed,
/ even if the performance might be slowed down.
AssertionStrictStr = "STRICT"
/ AssertionFastStr is a choice of variable TiDBTxnAssertionLevel that means assertions that doesn't affect
/ performance should be performed.
AssertionFastStr = "FAST"
/ AssertionOffStr is a choice of variable TiDBTxnAssertionLevel that means no assertion should be performed.
AssertionOffStr = "OFF"
/ OOMActionCancel constants represents the valid action configurations for OOMAction "CANCEL".
OOMActionCancel = "CANCEL"
/ OOMActionLog constants represents the valid action configurations for OOMAction "LOG".
OOMActionLog = "LOG"
)
/ Global config name list.
const (
GlobalConfigEnableTopSQL = "enable_resource_metering"
)
/ SysVar is for system variable.
/ All the fields of SysVar should be READ ONLY after created.
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
/ Type is the MySQL type (optional)
Type TypeFlag
/ MinValue will automatically be validated when specified (optional)
MinValue int64
/ MaxValue will automatically be validated when specified (optional)
MaxValue uint64
/ AutoConvertNegativeBool applies to boolean types (optional)
AutoConvertNegativeBool bool
/ ReadOnly applies to all types
ReadOnly bool
/ PossibleValues applies to ENUM type
PossibleValues []string
/ AllowEmpty is a special TiDB behavior which means "read value from config" (do not use)
AllowEmpty bool
/ AllowEmptyAll is a special behavior that only applies to TiDBCapturePlanBaseline, TiDBTxnMode (do not use)
AllowEmptyAll bool
/ AllowAutoValue means that the special value "-1" is permitted, even when outside of range.
AllowAutoValue bool
/ Validation is a callback after the type validation has been performed, but before the Set function
Validation func(*SessionVars, string, string, ScopeFlag) (string, error)
/ SetSession is called after validation but before updating systems[]. It also doubles as an Init function
/ and will be called on all variables in builtinGlobalVariable, regardless of their scope.
SetSession func(*SessionVars, string) error
/ SetGlobal is called after validation
SetGlobal func(*SessionVars, string) error
/ IsHintUpdatable indicate whether it's updatable via SET_VAR() hint (optional)
IsHintUpdatable bool
/ Deprecated: Hidden previously meant that the variable still responds to SET but doesn't show up in SHOW VARIABLES
/ However, this feature is no longer used. All variables are visble.
Hidden bool
/ Aliases is a list of sysvars that should also be updated when this sysvar is updated.
/ Updating aliases calls the SET function of the aliases, but does not update their aliases (preventing SET recursion)
Aliases []string
/ GetSession is a getter function for session scope.
/ It can be used by instance-scoped variables to overwrite the previously expected value.
GetSession func(*SessionVars) (string, error)
/ GetGlobal is a getter function for global scope.
GetGlobal func(*SessionVars) (string, error)
/ GetStateValue gets the value for session states, which is used for migrating sessions.
/ We need a function to override GetSession sometimes, because GetSession may not return the real value.
GetStateValue func(*SessionVars) (string, bool, error)
/ skipInit defines if the sysvar should be loaded into the session on init.
/ This is only important to set for sysvars that include session scope,
/ since global scoped sysvars are not-applicable.
skipInit bool
/ IsNoop defines if the sysvar is a noop included for MySQL compatibility
IsNoop bool
/ GlobalConfigName is the global config name of this global variable.
/ If the global variable has the global config name,
/ it should store the global config into PD(etcd) too when set global variable.
GlobalConfigName string
}
/ GetGlobalFromHook calls the GetSession func if it exists.
func (sv *SysVar) GetGlobalFromHook(s *SessionVars) (string, error) {
/ Call the Getter if there is one defined.
if sv.GetGlobal != nil {
val, err := sv.GetGlobal(s)
if err != nil {
return val, err
}
/ Ensure that the results from the getter are validated
/ Since some are read directly from tables.
return sv.ValidateWithRelaxedValidation(s, val, ScopeGlobal), nil
}
if sv.HasNoneScope() {
return sv.Value, nil
}
return s.GlobalVarsAccessor.GetGlobalSysVar(sv.Name)
}
/ GetSessionFromHook calls the GetSession func if it exists.
func (sv *SysVar) GetSessionFromHook(s *SessionVars) (string, error) {
if sv.HasNoneScope() {
return sv.Value, nil
}
/ Call the Getter if there is one defined.
if sv.GetSession != nil {
val, err := sv.GetSession(s)
if err != nil {
return val, err
}
/ Ensure that the results from the getter are validated
/ Since some are read directly from tables.
return sv.ValidateWithRelaxedValidation(s, val, ScopeSession), nil
}
var (
ok bool
val string
)
if val, ok = s.stmtVars[sv.Name]; ok {
return val, nil
}
if val, ok = s.systems[sv.Name]; !ok {
return val, errors.New("sysvar has not yet loaded")
}
return val, nil
}
/ SetSessionFromHook calls the SetSession func if it exists.
func (sv *SysVar) SetSessionFromHook(s *SessionVars, val string) error {
if sv.SetSession != nil {
if err := sv.SetSession(s, val); err != nil {
return err
}
}
s.systems[sv.Name] = val
/ Call the Set function on all the aliases for this sysVar
/ Skipping the validation function, and not calling aliases of
/ aliases. By skipping the validation function it means that things
/ like duplicate warnings should not appear.
if sv.Aliases != nil {
for _, aliasName := range sv.Aliases {
aliasSv := GetSysVar(aliasName)
if aliasSv.SetSession != nil {
if err := aliasSv.SetSession(s, val); err != nil {
return err
}
}
s.systems[aliasSv.Name] = val
}
}
return nil
}
/ SetGlobalFromHook calls the SetGlobal func if it exists.
func (sv *SysVar) SetGlobalFromHook(s *SessionVars, val string, skipAliases bool) error {
if sv.SetGlobal != nil {
return sv.SetGlobal(s, val)
}
/ Call the SetGlobalSysVarOnly function on all the aliases for this sysVar
/ which skips the validation function and when SetGlobalFromHook is called again
/ it will be with skipAliases=true. This helps break recursion because
/ most aliases are reciprocal.
if !skipAliases && sv.Aliases != nil {
for _, aliasName := range sv.Aliases {
if err := s.GlobalVarsAccessor.SetGlobalSysVarOnly(aliasName, val); err != nil {
return err
}
}
}
return nil
}
/ HasNoneScope returns true if the scope for the sysVar is None.
func (sv *SysVar) HasNoneScope() bool {
return sv.Scope == ScopeNone
}
/ HasSessionScope returns true if the scope for the sysVar includes session.
func (sv *SysVar) HasSessionScope() bool {
return sv.Scope&ScopeSession != 0
}
/ HasGlobalScope returns true if the scope for the sysVar includes global.
func (sv *SysVar) HasGlobalScope() bool {
return sv.Scope&ScopeGlobal != 0
}
/ HasInstanceScope returns true if the scope for the sysVar includes instance
func (sv *SysVar) HasInstanceScope() bool {
return sv.Scope&ScopeInstance != 0
}
/ Validate checks if system variable satisfies specific restriction.
func (sv *SysVar) Validate(vars *SessionVars, value string, scope ScopeFlag) (string, error) {
/ Check that the scope is correct first.
if err := sv.validateScope(scope); err != nil {
return value, err
}
/ Normalize the value and apply validation based on type.
/ i.e. TypeBool converts 1/on/ON to ON.
normalizedValue, err := sv.ValidateFromType(vars, value, scope)
if err != nil {
return normalizedValue, err
}
/ If type validation was successful, call the (optional) validation function
if sv.Validation != nil {
return sv.Validation(vars, normalizedValue, value, scope)
}
return normalizedValue, nil
}
/ ValidateFromType provides automatic validation based on the SysVar's type
func (sv *SysVar) ValidateFromType(vars *SessionVars, value string, scope ScopeFlag) (string, error) {
/ Some sysvars in TiDB have a special behavior where the empty string means
/ "use the config file value". This needs to be cleaned up once the behavior
/ for instance variables is determined.
if value == "" && ((sv.AllowEmpty && scope == ScopeSession) || sv.AllowEmptyAll) {
return value, nil
}
/ Provide validation using the SysVar struct
switch sv.Type {
case TypeUnsigned:
return sv.checkUInt64SystemVar(value, vars)
case TypeInt:
return sv.checkInt64SystemVar(value, vars)
case TypeBool:
return sv.checkBoolSystemVar(value, vars)
case TypeFloat:
return sv.checkFloatSystemVar(value, vars)
case TypeEnum:
return sv.checkEnumSystemVar(value, vars)
case TypeTime:
return sv.checkTimeSystemVar(value, vars)
case TypeDuration:
return sv.checkDurationSystemVar(value, vars)
}
return value, nil / typeString
}
func (sv *SysVar) validateScope(scope ScopeFlag) error {
if sv.ReadOnly || sv.Scope == ScopeNone {
return ErrIncorrectScope.FastGenByArgs(sv.Name, "read only")
}
if scope == ScopeGlobal && !(sv.HasGlobalScope() || sv.HasInstanceScope()) {
return errLocalVariable.FastGenByArgs(sv.Name)
}
if scope == ScopeSession && !sv.HasSessionScope() {
return errGlobalVariable.FastGenByArgs(sv.Name)
}
return nil
}
/ ValidateWithRelaxedValidation normalizes values but can not return errors.
/ Normalization+validation needs to be applied when reading values because older versions of TiDB
/ may be less sophisticated in normalizing values. But errors should be caught and handled,
/ because otherwise there will be upgrade issues.
func (sv *SysVar) ValidateWithRelaxedValidation(vars *SessionVars, value string, scope ScopeFlag) string {
warns := vars.StmtCtx.GetWarnings()
defer func() {
vars.StmtCtx.SetWarnings(warns) / RelaxedValidation = trim warnings too.
}()
normalizedValue, err := sv.ValidateFromType(vars, value, scope)
if err != nil {
return normalizedValue
}
if sv.Validation != nil {
normalizedValue, err = sv.Validation(vars, normalizedValue, value, scope)
if err != nil {
return normalizedValue
}
}
return normalizedValue
}
const (
localDayTimeFormat = "15:04"
/ FullDayTimeFormat is the full format of analyze start time and end time.
FullDayTimeFormat = "15:04 -0700"
)
func (sv *SysVar) checkTimeSystemVar(value string, vars *SessionVars) (string, error) {
var t time.Time
var err error
if len(value) <= len(localDayTimeFormat) {
t, err = time.ParseInLocation(localDayTimeFormat, value, vars.Location())
} else {
t, err = time.ParseInLocation(FullDayTimeFormat, value, vars.Location())
}
if err != nil {
return "", err
}
return t.Format(FullDayTimeFormat), nil
}
func (sv *SysVar) checkDurationSystemVar(value string, vars *SessionVars) (string, error) {
d, err := time.ParseDuration(value)
if err != nil {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
/ Check for min/max violations
if int64(d) < sv.MinValue {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return time.Duration(sv.MinValue).String(), nil
}
if uint64(d) > sv.MaxValue {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return time.Duration(sv.MaxValue).String(), nil
}
/ return a string representation of the duration
return d.String(), nil
}
func (sv *SysVar) checkUInt64SystemVar(value string, vars *SessionVars) (string, error) {
if sv.AllowAutoValue && value == "-1" {
return value, nil
}
if len(value) == 0 {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
if value[0] == '-' {
_, err := strconv.ParseInt(value, 10, 64)
if err != nil {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatInt(sv.MinValue, 10), nil
}
val, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
if val < uint64(sv.MinValue) {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatInt(sv.MinValue, 10), nil
}
if val > sv.MaxValue {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatUint(sv.MaxValue, 10), nil
}
return value, nil
}
func (sv *SysVar) checkInt64SystemVar(value string, vars *SessionVars) (string, error) {
if sv.AllowAutoValue && value == "-1" {
return value, nil
}
val, err := strconv.ParseInt(value, 10, 64)
if err != nil {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
if val < sv.MinValue {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatInt(sv.MinValue, 10), nil
}
if val > int64(sv.MaxValue) {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatUint(sv.MaxValue, 10), nil
}
return value, nil
}
func (sv *SysVar) checkEnumSystemVar(value string, vars *SessionVars) (string, error) {
/ The value could be either a string or the ordinal position in the PossibleValues.
/ This allows for the behavior 0 = OFF, 1 = ON, 2 = DEMAND etc.
var iStr string
for i, v := range sv.PossibleValues {
iStr = strconv.Itoa(i)
if strings.EqualFold(value, v) || strings.EqualFold(value, iStr) {
return v, nil
}
}
return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
}
func (sv *SysVar) checkFloatSystemVar(value string, vars *SessionVars) (string, error) {
if len(value) == 0 {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
val, err := strconv.ParseFloat(value, 64)
if err != nil {
return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
}
if val < float64(sv.MinValue) {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatInt(sv.MinValue, 10), nil
}
if val > float64(sv.MaxValue) {
vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
return strconv.FormatUint(sv.MaxValue, 10), nil
}
return value, nil
}
func (sv *SysVar) checkBoolSystemVar(value string, vars *SessionVars) (string, error) {
if strings.EqualFold(value, "ON") {
return On, nil
} else if strings.EqualFold(value, "OFF") {
return Off, nil
}
val, err := strconv.ParseInt(value, 10, 64)
if err == nil {
/ There are two types of conversion rules for integer values.
/ The default only allows 0 || 1, but a subset of values convert any
/ negative integer to 1.
if !sv.AutoConvertNegativeBool {
if val == 0 {
return Off, nil
} else if val == 1 {
return On, nil
}
} else {
if val == 1 || val < 0 {
return On, nil
} else if val == 0 {
return Off, nil
}
}
}
return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
}
/ GetNativeValType attempts to convert the val to the approx MySQL non-string type
func (sv *SysVar) GetNativeValType(val string) (types.Datum, byte, uint) {
switch sv.Type {
case TypeUnsigned:
u, err := strconv.ParseUint(val, 10, 64)
if err != nil {
u = 0
}
return types.NewUintDatum(u), mysql.TypeLonglong, mysql.UnsignedFlag
case TypeBool:
optVal := int64(0) / OFF
if TiDBOptOn(val) {
optVal = 1
}
return types.NewIntDatum(optVal), mysql.TypeLong, 0
}
return types.NewStringDatum(val), mysql.TypeVarString, 0
}
/ SkipInit returns true if when a new session is created we should "skip" copying
/ an initial value to it (and call the SetSession func if it exists)
func (sv *SysVar) SkipInit() bool {
if sv.skipInit || sv.IsNoop {
return true
}
return !sv.HasSessionScope()
}
/ SkipSysvarCache returns true if the sysvar should not re-execute on peers
/ This doesn't make sense for the GC variables because they are based in tikv
/ tables. We'd effectively be reading and writing to the same table, which
/ could be in an unsafe manner. In future these variables might be converted
/ to not use a different table internally, but to do that we need to first
/ fix upgrade/downgrade so we know that older servers won't be in the cluster
/ which update only these values.
func (sv *SysVar) SkipSysvarCache() bool {
switch sv.Name {
case TiDBGCEnable, TiDBGCRunInterval, TiDBGCLifetime,
TiDBGCConcurrency, TiDBGCScanLockMode:
return true
}
return false
}
var sysVars map[string]*SysVar
var sysVarsLock sync.RWMutex
/ RegisterSysVar adds a sysvar to the SysVars list
func RegisterSysVar(sv *SysVar) {
name := strings.ToLower(sv.Name)
sysVarsLock.Lock()
sysVars[name] = sv
sysVarsLock.Unlock()
}
/ UnregisterSysVar removes a sysvar from the SysVars list
/ currently only used in tests.
func UnregisterSysVar(name string) {
name = strings.ToLower(name)
sysVarsLock.Lock()
delete(sysVars, name)
sysVarsLock.Unlock()
}
/ GetSysVar returns sys var info for name as key.
func GetSysVar(name string) *SysVar {
name = strings.ToLower(name)
sysVarsLock.RLock()
defer sysVarsLock.RUnlock()
return sysVars[name]
}
/ SetSysVar sets a sysvar. In fact, SysVar is immutable.
/ SetSysVar is implemented by register a new SysVar with the same name again.
/ This will not propagate to the cluster, so it should only be
/ used for instance scoped AUTO variables such as system_time_zone.
func SetSysVar(name string, value string) {
old := GetSysVar(name)
tmp := *old
tmp.Value = value
RegisterSysVar(&tmp)
}
/ GetSysVars deep copies the sysVars list under a RWLock
func GetSysVars() map[string]*SysVar {
sysVarsLock.RLock()
defer sysVarsLock.RUnlock()
m := make(map[string]*SysVar, len(sysVars))
for name, sv := range sysVars {
tmp := *sv
m[name] = &tmp
}
return m
}
func init() {
sysVars = make(map[string]*SysVar)
for _, v := range defaultSysVars {
RegisterSysVar(v)
}
for _, v := range noopSysVars {
v.IsNoop = true
RegisterSysVar(v)
}
}
/ GlobalVarAccessor is the interface for accessing global scope system and status variables.
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
/ SetGlobalSysVarOnly sets the global system variable without calling the validation function or updating aliases.
SetGlobalSysVarOnly(name string, value string) error
/ GetTiDBTableValue gets a value from mysql.tidb for the key 'name'
GetTiDBTableValue(name string) (string, error)
/ SetTiDBTableValue sets a value+comment for the mysql.tidb key 'name'
SetTiDBTableValue(name, value, comment string) error
}