func (dm *domainMap) Get(store kv.Storage) (d *domain.Domain, err error) { key := store.UUID() dm.mu.Lock() defer dm.mu.Unlock() d = dm.domains[key] if d != nil { return } if SchemaLease <= minSchemaLease { SchemaLease = minSchemaLease } lease := SchemaLease // if storage is local storage, we may in test environment or // run server in single machine mode, so we don't need wait // 2 * lease time for DDL operation. if localstore.IsLocalStore(store) { lease = 0 } d, err = domain.NewDomain(store, lease) if err != nil { return nil, errors.Trace(err) } dm.domains[key] = d return }
func (dm *domainMap) Get(store kv.Storage) (d *domain.Domain, err error) { key := store.UUID() dm.mu.Lock() defer dm.mu.Unlock() d = dm.domains[key] if d != nil { return } d, err = domain.NewDomain(store) if err != nil { return nil, errors.Trace(err) } dm.domains[key] = d return }
func (s *testSuite) TestAdmin(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") tk.MustExec("drop table if exists admin_test") tk.MustExec("create table admin_test (c1 int, c2 int, c3 int default 1, index (c1))") tk.MustExec("insert admin_test (c1) values (1),(2),(NULL)") r, err := tk.Exec("admin show ddl") c.Assert(err, IsNil) row, err := r.Next() c.Assert(err, IsNil) c.Assert(row.Data, HasLen, 3) txn, err := s.store.Begin() c.Assert(err, IsNil) ddlInfo, err := inspectkv.GetDDLInfo(txn) c.Assert(err, IsNil) c.Assert(row.Data[0], Equals, ddlInfo.SchemaVer) c.Assert(row.Data[1], DeepEquals, ddlInfo.Owner.String()) c.Assert(row.Data[2], DeepEquals, "") row, err = r.Next() c.Assert(err, IsNil) c.Assert(row, IsNil) // check table test tk.MustExec("create table admin_test1 (c1 int, c2 int default 1, index (c1))") tk.MustExec("insert admin_test1 (c1) values (21),(22)") r, err = tk.Exec("admin check table admin_test, admin_test1") c.Assert(err, IsNil) c.Assert(r, IsNil) // error table name r, err = tk.Exec("admin check table admin_test_error") c.Assert(err, NotNil) // different index values domain, err := domain.NewDomain(s.store, 1*time.Second) c.Assert(err, IsNil) is := domain.InfoSchema() c.Assert(is, NotNil) tb, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("admin_test")) c.Assert(err, IsNil) c.Assert(tb.Indices(), HasLen, 1) err = tb.Indices()[0].X.Create(txn, []interface{}{int64(10)}, 1) c.Assert(err, IsNil) err = txn.Commit() c.Assert(err, IsNil) r, err = tk.Exec("admin check table admin_test") c.Assert(err, NotNil) }
func (dm *domainMap) Get(store kv.Storage) (d *domain.Domain, err error) { key := store.UUID() dm.mu.Lock() defer dm.mu.Unlock() d = dm.domains[key] if d != nil { return } lease := time.Duration(0) if !localstore.IsLocalStore(store) { lease = schemaLease } d, err = domain.NewDomain(store, lease) if err != nil { return nil, errors.Trace(err) } dm.domains[key] = d return }
func (dm *domainMap) Get(store kv.Storage) (d *domain.Domain, err error) { key := store.UUID() dm.mu.Lock() defer dm.mu.Unlock() d = dm.domains[key] if d != nil { return } lease := time.Duration(0) if !localstore.IsLocalStore(store) { lease = schemaLease } err = util.RunWithRetry(defaultMaxRetries, retryInterval, func() (retry bool, err1 error) { d, err1 = domain.NewDomain(store, lease) return true, errors.Trace(err1) }) if err != nil { return nil, errors.Trace(err) } dm.domains[key] = d return }