// GetGlobalSysVar implements GlobalVarAccessor GetGlobalSysVar interface.
func (c *Context) GetGlobalSysVar(ctx context.Context, name string) (string, error) {
v := variable.GetSysVar(name)
if v == nil {
return "", terror.UnknownSystemVar.Gen("unknown sys variable: %s", name)
}
return v.Value, nil
}
// SetGlobalSysVar implements GlobalVarAccessor SetGlobalSysVar interface.
func (c *Context) SetGlobalSysVar(ctx context.Context, name string, value string) error {
v := variable.GetSysVar(name)
if v == nil {
return terror.UnknownSystemVar.Gen("unknown sys variable: %s", name)
}
v.Value = value
return nil
}
func (e *SimpleExec) executeSet(s *ast.SetStmt) error {
sessionVars := variable.GetSessionVars(e.ctx)
globalVars := variable.GetGlobalVarAccessor(e.ctx)
for _, v := range s.Variables {
// Variable is case insensitive, we use lower case.
if v.Name == ast.SetNames {
// This is set charset stmt.
cs := v.Value.GetValue().(string)
var co string
if v.ExtendValue != nil {
co = v.ExtendValue.GetValue().(string)
}
err := e.setCharset(cs, co)
if err != nil {
return errors.Trace(err)
}
continue
}
name := strings.ToLower(v.Name)
if !v.IsSystem {
// Set user variable.
value, err := evaluator.Eval(e.ctx, v.Value)
if err != nil {
return errors.Trace(err)
}
if value.IsNull() {
delete(sessionVars.Users, name)
} else {
svalue, err1 := value.ToString()
if err1 != nil {
return errors.Trace(err1)
}
sessionVars.Users[name] = fmt.Sprintf("%v", svalue)
}
continue
}
// Set system variable
sysVar := variable.GetSysVar(name)
if sysVar == nil {
return variable.UnknownSystemVar.Gen("Unknown system variable '%s'", name)
}
if sysVar.Scope == variable.ScopeNone {
return errors.Errorf("Variable '%s' is a read only variable", name)
}
if v.IsGlobal {
// Set global scope system variable.
if sysVar.Scope&variable.ScopeGlobal == 0 {
return errors.Errorf("Variable '%s' is a SESSION variable and can't be used with SET GLOBAL", name)
}
value, err := evaluator.Eval(e.ctx, v.Value)
if err != nil {
return errors.Trace(err)
}
if value.IsNull() {
value.SetString("")
}
svalue, err := value.ToString()
if err != nil {
return errors.Trace(err)
}
err = globalVars.SetGlobalSysVar(e.ctx, name, svalue)
if err != nil {
return errors.Trace(err)
}
} else {
// Set session scope system variable.
if sysVar.Scope&variable.ScopeSession == 0 {
return errors.Errorf("Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL", name)
}
value, err := evaluator.Eval(e.ctx, v.Value)
if err != nil {
return errors.Trace(err)
}
err = sessionVars.SetSystemVar(name, value)
if err != nil {
return errors.Trace(err)
}
}
}
return nil
}
// Exec implements the stmt.Statement Exec interface.
func (s *SetStmt) Exec(ctx context.Context) (_ rset.Recordset, err error) {
log.Debug("Set sys/user variables")
sessionVars := variable.GetSessionVars(ctx)
globalVars := variable.GetGlobalVarAccessor(ctx)
for _, v := range s.Variables {
// Variable is case insensitive, we use lower case.
name := strings.ToLower(v.Name)
if !v.IsSystem {
// User variable.
value, err := v.getValue(ctx)
if err != nil {
return nil, errors.Trace(err)
}
if value == nil {
delete(sessionVars.Users, name)
} else {
sessionVars.Users[name] = fmt.Sprintf("%v", value)
}
return nil, nil
}
sysVar := variable.GetSysVar(name)
if sysVar == nil {
return nil, variable.UnknownSystemVar.Gen("Unknown system variable '%s'", name)
}
if sysVar.Scope == variable.ScopeNone {
return nil, errors.Errorf("Variable '%s' is a read only variable", name)
}
if v.IsGlobal {
if sysVar.Scope&variable.ScopeGlobal > 0 {
value, err := v.getValue(ctx)
if err != nil {
return nil, errors.Trace(err)
}
if value == nil {
value = ""
}
svalue, err := types.ToString(value)
if err != nil {
return nil, errors.Trace(err)
}
err = globalVars.SetGlobalSysVar(ctx, name, svalue)
return nil, errors.Trace(err)
}
return nil, errors.Errorf("Variable '%s' is a SESSION variable and can't be used with SET GLOBAL", name)
}
if sysVar.Scope&variable.ScopeSession > 0 {
if value, err := v.getValue(ctx); err != nil {
return nil, errors.Trace(err)
} else if value == nil {
sessionVars.Systems[name] = ""
} else {
sessionVars.Systems[name] = fmt.Sprintf("%v", value)
}
return nil, nil
}
return nil, errors.Errorf("Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL", name)
}
return nil, nil
}
func (e *SetExecutor) executeSet() error {
sessionVars := e.ctx.GetSessionVars()
for _, v := range e.vars {
// Variable is case insensitive, we use lower case.
if v.Name == ast.SetNames {
// This is set charset stmt.
cs := v.Expr.(*expression.Constant).Value.GetString()
var co string
if v.ExtendValue != nil {
co = v.ExtendValue.Value.GetString()
}
err := e.setCharset(cs, co)
if err != nil {
return errors.Trace(err)
}
continue
}
name := strings.ToLower(v.Name)
if !v.IsSystem {
// Set user variable.
value, err := v.Expr.Eval(nil, e.ctx)
if err != nil {
return errors.Trace(err)
}
if value.IsNull() {
delete(sessionVars.Users, name)
} else {
svalue, err1 := value.ToString()
if err1 != nil {
return errors.Trace(err1)
}
sessionVars.Users[name] = fmt.Sprintf("%v", svalue)
}
continue
}
// Set system variable
sysVar := variable.GetSysVar(name)
if sysVar == nil {
return variable.UnknownSystemVar.GenByArgs(name)
}
if sysVar.Scope == variable.ScopeNone {
return errors.Errorf("Variable '%s' is a read only variable", name)
}
if v.IsGlobal {
// Set global scope system variable.
if sysVar.Scope&variable.ScopeGlobal == 0 {
return errors.Errorf("Variable '%s' is a SESSION variable and can't be used with SET GLOBAL", name)
}
value, err := e.getVarValue(v, sysVar)
if err != nil {
return errors.Trace(err)
}
if value.IsNull() {
value.SetString("")
}
svalue, err := value.ToString()
if err != nil {
return errors.Trace(err)
}
err = sessionVars.GlobalVarsAccessor.SetGlobalSysVar(name, svalue)
if err != nil {
return errors.Trace(err)
}
} else {
// Set session scope system variable.
if sysVar.Scope&variable.ScopeSession == 0 {
return errors.Errorf("Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL", name)
}
value, err := e.getVarValue(v, nil)
if err != nil {
return errors.Trace(err)
}
err = varsutil.SetSystemVar(sessionVars, name, value)
if err != nil {
return errors.Trace(err)
}
e.loadSnapshotInfoSchemaIfNeeded(name)
log.Infof("[%d] set system variable %s = %s", sessionVars.ConnectionID, name, value.GetString())
}
}
return nil
}
// Exec implements the stmt.Statement Exec interface.
func (s *SetStmt) Exec(ctx context.Context) (_ rset.Recordset, err error) {
log.Debug("Set sys/user variables")
sessionVars := variable.GetSessionVars(ctx)
for _, v := range s.Variables {
// Variable is case insensitive, we use lower case.
name := strings.ToLower(v.Name)
if !v.IsSystem {
// User variable.
value, err := v.getValue(ctx)
if err != nil {
return nil, errors.Trace(err)
}
if value == nil {
delete(sessionVars.Users, name)
} else {
sessionVars.Users[name] = fmt.Sprintf("%v", value)
}
return nil, nil
}
// TODO: should get global sys var from db.
sysVar := variable.GetSysVar(name)
if sysVar == nil {
return nil, errors.Errorf("Unknown system variable '%s'", name)
}
if sysVar.Scope == variable.ScopeNone {
return nil, errors.Errorf("Variable '%s' is a read only variable", name)
}
if v.IsGlobal {
if sysVar.Scope&variable.ScopeGlobal > 0 {
value, err := v.getValue(ctx)
if err != nil {
return nil, errors.Trace(err)
}
if value == nil {
sysVar.Value = ""
} else {
// TODO: set global variables in db, now we only change memory global sys var map.
// TODO: check sys variable type if possible.
sysVar.Value = fmt.Sprintf("%v", value)
}
return nil, nil
}
return nil, errors.Errorf("Variable '%s' is a SESSION variable and can't be used with SET GLOBAL", name)
}
if sysVar.Scope&variable.ScopeSession > 0 {
if value, err := v.getValue(ctx); err != nil {
return nil, errors.Trace(err)
} else if value == nil {
sysVar.Value = ""
} else {
// TODO: check sys variable type if possible.
sessionVars.Systems[name] = fmt.Sprintf("%v", value)
}
return nil, nil
}
return nil, errors.Errorf("Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL", name)
}
return nil, nil
}
func (e *SimpleExec) executeSet(s *ast.SetStmt) error {
sessionVars := variable.GetSessionVars(e.ctx)
globalVars := variable.GetGlobalVarAccessor(e.ctx)
for _, v := range s.Variables {
// Variable is case insensitive, we use lower case.
name := strings.ToLower(v.Name)
if !v.IsSystem {
// Set user variable.
value, err := evaluator.Eval(e.ctx, v.Value)
if err != nil {
return errors.Trace(err)
}
if value == nil {
delete(sessionVars.Users, name)
} else {
sessionVars.Users[name] = fmt.Sprintf("%v", value)
}
continue
}
// Set system variable
sysVar := variable.GetSysVar(name)
if sysVar == nil {
return variable.UnknownSystemVar.Gen("Unknown system variable '%s'", name)
}
if sysVar.Scope == variable.ScopeNone {
return errors.Errorf("Variable '%s' is a read only variable", name)
}
if v.IsGlobal {
// Set global scope system variable.
if sysVar.Scope&variable.ScopeGlobal == 0 {
return errors.Errorf("Variable '%s' is a SESSION variable and can't be used with SET GLOBAL", name)
}
value, err := evaluator.Eval(e.ctx, v.Value)
if err != nil {
return errors.Trace(err)
}
if value == nil {
value = ""
}
svalue, err := types.ToString(value)
if err != nil {
return errors.Trace(err)
}
err = globalVars.SetGlobalSysVar(e.ctx, name, svalue)
if err != nil {
return errors.Trace(err)
}
} else {
// Set session scope system variable.
if sysVar.Scope&variable.ScopeSession == 0 {
return errors.Errorf("Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL", name)
}
if value, err := evaluator.Eval(e.ctx, v.Value); err != nil {
return errors.Trace(err)
} else if value == nil {
sessionVars.Systems[name] = ""
} else {
sessionVars.Systems[name] = fmt.Sprintf("%v", value)
}
}
}
return nil
}