// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
if err != nil {
return nil, err
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatusFlag(mysql.ServerStatusAutocommit, true)
// session implements variable.GlobalVarAccessor. Bind it to ctx.
variable.BindGlobalVarAccessor(s, s)
// session implements autocommit.Checker. Bind it to ctx
autocommit.BindAutocommitChecker(s, s)
sessionMu.Lock()
defer sessionMu.Unlock()
_, ok := storeBootstrapped[store.UUID()]
if !ok {
s.initing = true
bootstrap(s)
s.initing = false
storeBootstrapped[store.UUID()] = true
}
// TODO: Add auth here
privChecker := &privileges.UserPrivileges{}
privilege.BindPrivilegeChecker(s, privChecker)
return s, nil
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
if err != nil {
return nil, err
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatusFlag(mysql.ServerStatusAutocommit, true)
sessionMu.Lock()
defer sessionMu.Unlock()
_, ok := storeBootstrapped[store.UUID()]
if !ok {
bootstrap(s)
storeBootstrapped[store.UUID()] = true
}
// Add auth here
return s, nil
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
debugInfos: make(map[string]interface{}),
maxRetryCnt: 10,
parser: parser.New(),
}
domain, err := domap.Get(store)
if err != nil {
return nil, errors.Trace(err)
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatusFlag(mysql.ServerStatusAutocommit, true)
// session implements variable.GlobalVarAccessor. Bind it to ctx.
variable.BindGlobalVarAccessor(s, s)
// session implements autocommit.Checker. Bind it to ctx
autocommit.BindAutocommitChecker(s, s)
sessionMu.Lock()
defer sessionMu.Unlock()
ver := getStoreBootstrapVersion(store)
if ver == notBootstrapped {
// if no bootstrap and storage is remote, we must use a little lease time to
// bootstrap quickly, after bootstrapped, we will reset the lease time.
// TODO: Using a bootstap tool for doing this may be better later.
if !localstore.IsLocalStore(store) {
sessionctx.GetDomain(s).SetLease(chooseMinLease(100*time.Millisecond, schemaLease))
}
s.SetValue(context.Initing, true)
bootstrap(s)
s.ClearValue(context.Initing)
if !localstore.IsLocalStore(store) {
sessionctx.GetDomain(s).SetLease(schemaLease)
}
finishBootstrap(store)
} else if ver < currentBootstrapVersion {
s.SetValue(context.Initing, true)
upgrade(s)
s.ClearValue(context.Initing)
}
// TODO: Add auth here
privChecker := &privileges.UserPrivileges{}
privilege.BindPrivilegeChecker(s, privChecker)
return s, nil
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
if err != nil {
return nil, err
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatus(mysql.ServerStatusAutocommit)
return s, nil
}
// Create a new session on store but only do ddl works.
func (s *testSessionSuite) bootstrapWithOnlyDDLWork(store kv.Storage, c *C) {
ss := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
parser: parser.New(),
sessionVars: variable.NewSessionVars(),
}
ss.SetValue(context.Initing, true)
domain, err := domap.Get(store)
c.Assert(err, IsNil)
sessionctx.BindDomain(ss, domain)
sessionMu.Lock()
defer sessionMu.Unlock()
b, err := checkBootstrapped(ss)
c.Assert(b, IsFalse)
c.Assert(err, IsNil)
doDDLWorks(ss)
// Leave dml unfinished.
}
// Create a new session on store but only do ddl works.
func (s *testSessionSuite) bootstrapWithError(store kv.Storage, c *C) {
ss := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
c.Assert(err, IsNil)
sessionctx.BindDomain(ss, domain)
variable.BindSessionVars(ss)
variable.GetSessionVars(ss).SetStatusFlag(mysql.ServerStatusAutocommit, true)
// session implements autocommit.Checker. Bind it to ctx
autocommit.BindAutocommitChecker(ss, ss)
sessionMu.Lock()
defer sessionMu.Unlock()
b, err := checkBootstrapped(ss)
c.Assert(b, IsFalse)
c.Assert(err, IsNil)
doDDLWorks(ss)
// Leave dml unfinished.
}
func createSession(store kv.Storage) (*session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
maxRetryCnt: 10,
parser: parser.New(),
sessionVars: variable.NewSessionVars(),
}
domain, err := domap.Get(store)
if err != nil {
return nil, errors.Trace(err)
}
sessionctx.BindDomain(s, domain)
// session implements variable.GlobalVarAccessor. Bind it to ctx.
s.sessionVars.GlobalVarsAccessor = s
// TODO: Add auth here
privChecker := &privileges.UserPrivileges{}
privilege.BindPrivilegeChecker(s, privChecker)
return s, nil
}