// ExecRestrictedSQL implements SQLHelper interface.
// This is used for executing some restricted sql statements.
func (s *session) ExecRestrictedSQL(ctx context.Context, sql string) (rset.Recordset, error) {
if ctx.Value(&sqlexec.RestrictedSQLExecutorKeyType{}) != nil {
// We do not support run this function concurrently.
// TODO: Maybe we should remove this restriction latter.
return nil, errors.New("Should not call ExecRestrictedSQL concurrently.")
}
statements, err := Compile(ctx, sql)
if err != nil {
log.Errorf("Compile %s with error: %v", sql, err)
return nil, errors.Trace(err)
}
if len(statements) != 1 {
log.Errorf("ExecRestrictedSQL only executes one statement. Too many/few statement in %s", sql)
return nil, errors.New("Wrong number of statement.")
}
st := statements[0]
// Check statement for some restriction
// For example only support DML on system meta table.
// TODO: Add more restrictions.
log.Debugf("Executing %s [%s]", st.OriginText(), sql)
ctx.SetValue(&sqlexec.RestrictedSQLExecutorKeyType{}, true)
defer ctx.ClearValue(&sqlexec.RestrictedSQLExecutorKeyType{})
rs, err := st.Exec(ctx)
return rs, errors.Trace(err)
}
func popRowStack(ctx context.Context) error {
s := getRowStack(ctx)
if s == nil || len(s.items) == 0 {
return errors.Errorf("pop empty row stack")
}
n := len(s.items) - 1
s.items[n] = nil
s.items = s.items[0:n]
if len(s.items) == 0 {
ctx.ClearValue(rowStackKey)
return nil
}
ctx.SetValue(rowStackKey, s)
return nil
}
func (sq *SubQuery) pop(ctx context.Context) error {
v := ctx.Value(subQueryStackKey)
if v == nil {
return errors.Errorf("pop empty sub query stack")
}
st := v.([]*SubQuery)
// can not empty
n := len(st) - 1
if st[n] != sq {
return errors.Errorf("pop invalid top sub query in stack, want %v, but top is %v", sq, st[n])
}
st[n] = nil
st = st[0:n]
if len(st) == 0 {
ctx.ClearValue(subQueryStackKey)
return nil
}
ctx.SetValue(subQueryStackKey, st)
return nil
}
// ClearExecArgs clears executive args from context.
func ClearExecArgs(ctx context.Context) {
ctx.ClearValue(execArgsKey)
}
// ClearBinlog clears binlog in the Context.
func ClearBinlog(ctx context.Context) {
ctx.ClearValue(binlogKey)
}
