// LoadCommonGlobalVariableIfNeeded loads and applies commonly used global variables for the session
// right before creating a transaction for the first time.
func (s *session) loadCommonGlobalVariablesIfNeeded() error {
vars := s.sessionVars
if vars.CommonGlobalLoaded {
return nil
}
if s.Value(context.Initing) != nil {
// When running bootstrap or upgrade, we should not access global storage.
return nil
}
// Set the variable to true to prevent cyclic recursive call.
vars.CommonGlobalLoaded = true
rs, err := s.ExecRestrictedSQL(s, loadCommonGlobalVarsSQL)
if err != nil {
vars.CommonGlobalLoaded = false
log.Errorf("Failed to load common global variables.")
return errors.Trace(err)
}
for {
row, err1 := rs.Next()
if err1 != nil {
vars.CommonGlobalLoaded = false
log.Errorf("Failed to load common global variables.")
return errors.Trace(err1)
}
if row == nil {
break
}
varName := row.Data[0].GetString()
if d := varsutil.GetSystemVar(vars, varName); d.IsNull() {
varsutil.SetSystemVar(s.sessionVars, varName, row.Data[1])
}
}
vars.CommonGlobalLoaded = true
return nil
}
func (e *ShowExec) fetchShowVariables() error {
sessionVars := e.ctx.GetSessionVars()
globalVars := sessionVars.GlobalVarsAccessor
for _, v := range variable.SysVars {
var err error
var value string
if !e.GlobalScope {
// Try to get Session Scope variable value first.
sv := varsutil.GetSystemVar(sessionVars, v.Name)
if sv.IsNull() {
value, err = globalVars.GetGlobalSysVar(v.Name)
if err != nil {
return errors.Trace(err)
}
sv.SetString(value)
err = varsutil.SetSystemVar(sessionVars, v.Name, sv)
if err != nil {
return errors.Trace(err)
}
}
value = sv.GetString()
} else {
value, err = globalVars.GetGlobalSysVar(v.Name)
if err != nil {
return errors.Trace(err)
}
}
row := &Row{Data: types.MakeDatums(v.Name, value)}
e.rows = append(e.rows, row)
}
return nil
}
func (s *testSuite) TestSetCharset(c *C) {
defer testleak.AfterTest(c)()
tk := testkit.NewTestKit(c, s.store)
tk.MustExec(`SET NAMES latin1`)
ctx := tk.Se.(context.Context)
sessionVars := ctx.GetSessionVars()
for _, v := range variable.SetNamesVariables {
sVar := varsutil.GetSystemVar(sessionVars, v)
c.Assert(sVar.GetString() != "utf8", IsTrue)
}
tk.MustExec(`SET NAMES utf8`)
for _, v := range variable.SetNamesVariables {
sVar := varsutil.GetSystemVar(sessionVars, v)
c.Assert(sVar.GetString(), Equals, "utf8")
}
sVar := varsutil.GetSystemVar(sessionVars, variable.CollationConnection)
c.Assert(sVar.GetString(), Equals, "utf8_general_ci")
// Issue 1523
tk.MustExec(`SET NAMES binary`)
}
func getSystemTimestamp(ctx context.Context) (time.Time, error) {
value := time.Now()
if ctx == nil {
return value, nil
}
// check whether use timestamp varibale
sessionVars := ctx.GetSessionVars()
ts := varsutil.GetSystemVar(sessionVars, "timestamp")
if !ts.IsNull() && ts.GetString() != "" {
timestamp, err := ts.ToInt64(ctx.GetSessionVars().StmtCtx)
if err != nil {
return time.Time{}, errors.Trace(err)
}
if timestamp <= 0 {
return value, nil
}
return time.Unix(timestamp, 0), nil
}
return value, nil
}
func dataForSessionVar(ctx context.Context) (records [][]types.Datum, err error) {
sessionVars := ctx.GetSessionVars()
globalVars := sessionVars.GlobalVarsAccessor
for _, v := range variable.SysVars {
var value string
sv := varsutil.GetSystemVar(sessionVars, v.Name)
if sv.IsNull() {
value, err = globalVars.GetGlobalSysVar(v.Name)
if err != nil {
return nil, errors.Trace(err)
}
sv.SetString(value)
err = varsutil.SetSystemVar(sessionVars, v.Name, sv)
if err != nil {
return nil, errors.Trace(err)
}
}
value = sv.GetString()
row := types.MakeDatums(v.Name, value)
records = append(records, row)
}
return
}
func (e *Evaluator) variable(v *ast.VariableExpr) bool {
name := strings.ToLower(v.Name)
sessionVars := e.ctx.GetSessionVars()
globalVars := sessionVars.GlobalVarsAccessor
if !v.IsSystem {
if v.Value != nil && !v.Value.GetDatum().IsNull() {
strVal, err := v.Value.GetDatum().ToString()
if err != nil {
e.err = errors.Trace(err)
return false
}
sessionVars.Users[name] = strings.ToLower(strVal)
v.SetString(strVal)
return true
}
// user vars
if value, ok := sessionVars.Users[name]; ok {
v.SetString(value)
return true
}
// select null user vars is permitted.
v.SetNull()
return true
}
sysVar, ok := variable.SysVars[name]
if !ok {
// select null sys vars is not permitted
e.err = variable.UnknownSystemVar.GenByArgs(name)
return false
}
if sysVar.Scope == variable.ScopeNone {
v.SetString(sysVar.Value)
return true
}
if !v.IsGlobal {
d := varsutil.GetSystemVar(sessionVars, name)
if d.IsNull() {
if sysVar.Scope&variable.ScopeGlobal == 0 {
d.SetString(sysVar.Value)
} else {
// Get global system variable and fill it in session.
globalVal, err := globalVars.GetGlobalSysVar(name)
if err != nil {
e.err = errors.Trace(err)
return false
}
d.SetString(globalVal)
err = varsutil.SetSystemVar(sessionVars, name, d)
if err != nil {
e.err = errors.Trace(err)
return false
}
}
}
v.SetDatum(d)
return true
}
value, err := globalVars.GetGlobalSysVar(name)
if err != nil {
e.err = errors.Trace(err)
return false
}
v.SetString(value)
return true
}
func (er *expressionRewriter) rewriteVariable(v *ast.VariableExpr) {
stkLen := len(er.ctxStack)
name := strings.ToLower(v.Name)
sessionVars := er.b.ctx.GetSessionVars()
globalVars := sessionVars.GlobalVarsAccessor
if !v.IsSystem {
if v.Value != nil {
er.ctxStack[stkLen-1], er.err = expression.NewFunction(ast.SetVar,
er.ctxStack[stkLen-1].GetType(),
datumToConstant(types.NewDatum(name), mysql.TypeString),
er.ctxStack[stkLen-1])
return
}
if _, ok := sessionVars.Users[name]; ok {
f, err := expression.NewFunction(ast.GetVar,
// TODO: Here is wrong, the sessionVars should store a name -> Datum map. Will fix it later.
types.NewFieldType(mysql.TypeString),
datumToConstant(types.NewStringDatum(name), mysql.TypeString))
if err != nil {
er.err = errors.Trace(err)
return
}
er.ctxStack = append(er.ctxStack, f)
} else {
// select null user vars is permitted.
er.ctxStack = append(er.ctxStack, &expression.Constant{RetType: types.NewFieldType(mysql.TypeNull)})
}
return
}
sysVar, ok := variable.SysVars[name]
if !ok {
// select null sys vars is not permitted
er.err = variable.UnknownSystemVar.GenByArgs(name)
return
}
if sysVar.Scope == variable.ScopeNone {
er.ctxStack = append(er.ctxStack, datumToConstant(types.NewDatum(sysVar.Value), mysql.TypeString))
return
}
if v.IsGlobal {
value, err := globalVars.GetGlobalSysVar(name)
if err != nil {
er.err = errors.Trace(err)
return
}
er.ctxStack = append(er.ctxStack, datumToConstant(types.NewDatum(value), mysql.TypeString))
return
}
d := varsutil.GetSystemVar(sessionVars, name)
if d.IsNull() {
if sysVar.Scope&variable.ScopeGlobal == 0 {
d.SetString(sysVar.Value)
} else {
// Get global system variable and fill it in session.
globalVal, err := globalVars.GetGlobalSysVar(name)
if err != nil {
er.err = errors.Trace(err)
return
}
d.SetString(globalVal)
err = varsutil.SetSystemVar(sessionVars, name, d)
if err != nil {
er.err = errors.Trace(err)
return
}
}
}
er.ctxStack = append(er.ctxStack, datumToConstant(d, mysql.TypeString))
return
}