// Make sure it is safe to concurrently create handle on multiple stores.
func (testSuite) TestConcurrent(c *C) {
defer testleak.AfterTest(c)()
storeCount := 5
stores := make([]kv.Storage, storeCount)
for i := 0; i < storeCount; i++ {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open(fmt.Sprintf("memory_path_%d", i))
c.Assert(err, IsNil)
stores[i] = store
}
defer func() {
for _, store := range stores {
store.Close()
}
}()
var wg sync.WaitGroup
wg.Add(storeCount)
for _, store := range stores {
go func(s kv.Storage) {
defer wg.Done()
_, err := infoschema.NewHandle(s)
c.Assert(err, IsNil)
}(store)
}
wg.Wait()
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
// For GenID
txn, err := store.Begin()
c.Assert(err, IsNil)
key := []byte(meta.AutoIDKey(1))
id, err := meta.GenID(txn, key, 1)
c.Assert(id, Equals, int64(1))
id, err = meta.GenID(txn, key, 2)
c.Assert(id, Equals, int64(3))
id, err = meta.GenID(txn, []byte{}, 1)
c.Assert(err, NotNil)
// For DBMetaKey
mkey := meta.DBMetaKey(1)
c.Assert(mkey, Equals, "mDB::1")
//For AutoIDKey
mkey = meta.AutoIDKey(1)
c.Assert(mkey, Equals, "mTable::1_autoID")
mkey = meta.AutoIDKey(0)
c.Assert(mkey, Equals, "mTable::0_autoID")
// For GenGlobalID
id, err = meta.GenGlobalID(store)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(1))
id, err = meta.GenGlobalID(store)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(2))
}
// Make sure that all tables of infomation_schema could be found in infoschema handle.
func (*testSuite) TestInfoTables(c *C) {
defer testleak.AfterTest(c)()
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
handle, err := infoschema.NewHandle(store)
c.Assert(err, IsNil)
builder, err := infoschema.NewBuilder(handle).InitWithDBInfos(nil, 0)
c.Assert(err, IsNil)
err = builder.Build()
c.Assert(err, IsNil)
is := handle.Get()
c.Assert(is, NotNil)
info_tables := []string{
"SCHEMATA",
"TABLES",
"COLUMNS",
"STATISTICS",
"CHARACTER_SETS",
"COLLATIONS",
"FILES",
"PROFILING",
"PARTITIONS",
"KEY_COLUMN_USAGE",
"REFERENTIAL_CONSTRAINTS",
}
for _, t := range info_tables {
tb, err1 := is.TableByName(model.NewCIStr(infoschema.Name), model.NewCIStr(t))
c.Assert(err1, IsNil)
c.Assert(tb, NotNil)
}
}
func (s *testIndexSuite) SetUpSuite(c *C) {
path := "memory:"
d := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := d.Open(path)
c.Assert(err, IsNil)
s.s = store
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
m := meta.NewMeta(store)
err = m.RunInNewTxn(false, func(m *meta.TMeta) error {
err = m.CreateDatabase(&model.DBInfo{ID: 1, Name: model.NewCIStr("a")})
c.Assert(err, IsNil)
err = m.CreateTable(1, &model.TableInfo{ID: 1, Name: model.NewCIStr("t")})
c.Assert(err, IsNil)
return nil
})
c.Assert(err, IsNil)
alloc := autoid.NewAllocator(m, 1)
c.Assert(alloc, NotNil)
id, err := alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(1))
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(2))
id, err = alloc.Alloc(0)
c.Assert(err, NotNil)
}
func (s *testSuite) TestSnapshot(c *C) {
defer testleak.AfterTest(c)()
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
txn, _ := store.Begin()
m := meta.NewMeta(txn)
m.GenGlobalID()
n, _ := m.GetGlobalID()
c.Assert(n, Equals, int64(1))
txn.Commit()
ver1, _ := store.CurrentVersion()
time.Sleep(time.Millisecond)
txn, _ = store.Begin()
m = meta.NewMeta(txn)
m.GenGlobalID()
n, _ = m.GetGlobalID()
c.Assert(n, Equals, int64(2))
txn.Commit()
snapshot, _ := store.GetSnapshot(ver1)
snapMeta := meta.NewSnapshotMeta(snapshot)
n, _ = snapMeta.GetGlobalID()
c.Assert(n, Equals, int64(1))
_, err = snapMeta.GenGlobalID()
c.Assert(err, NotNil)
}
func (s *testKVSuite) TestBoltDBDeadlock(c *C) {
d := localstore.Driver{
Driver: boltdb.Driver{},
}
path := "boltdb_test"
defer os.Remove(path)
store, err := d.Open(path)
c.Assert(err, IsNil)
defer store.Close()
kv.RunInNewTxn(store, false, func(txn kv.Transaction) error {
txn.Set([]byte("a"), []byte("0"))
kv.IncInt64(txn, []byte("a"), 1)
kv.RunInNewTxn(store, false, func(txn kv.Transaction) error {
txn.Set([]byte("b"), []byte("0"))
kv.IncInt64(txn, []byte("b"), 1)
return nil
})
return nil
})
kv.RunInNewTxn(store, false, func(txn kv.Transaction) error {
n, err := kv.GetInt64(txn, []byte("a"))
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = kv.GetInt64(txn, []byte("b"))
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
return nil
})
}
func (ts *testMemoryTableSuite) SetUpSuite(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Check(err, IsNil)
ts.store = store
ts.se, err = tidb.CreateSession(ts.store)
c.Assert(err, IsNil)
// create table
tp1 := types.NewFieldType(mysql.TypeLong)
col1 := &model.ColumnInfo{
ID: 1,
Name: model.NewCIStr("a"),
Offset: 0,
FieldType: *tp1,
}
tp2 := types.NewFieldType(mysql.TypeVarchar)
tp2.Flen = 255
col2 := &model.ColumnInfo{
ID: 2,
Name: model.NewCIStr("b"),
Offset: 1,
FieldType: *tp2,
}
tblInfo := &model.TableInfo{
ID: 100,
Name: model.NewCIStr("t"),
Columns: []*model.ColumnInfo{col1, col2},
}
alloc := autoid.NewMemoryAllocator(int64(10))
ts.tbl, _ = tables.MemoryTableFromMeta(alloc, tblInfo)
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
ctx := mock.NewContext()
dom, err := NewDomain(store, 0)
c.Assert(err, IsNil)
store = dom.Store()
dd := dom.DDL()
c.Assert(dd, NotNil)
err = dd.CreateSchema(ctx, model.NewCIStr("aaa"))
c.Assert(err, IsNil)
is := dom.InfoSchema()
c.Assert(is, NotNil)
dom, err = NewDomain(store, 0)
c.Assert(err, IsNil)
dom.SetLease(10 * time.Second)
m, err := dom.Stats()
c.Assert(err, IsNil)
c.Assert(m[ddlLastReloadSchemaTS], GreaterEqual, int64(0))
dom.SetLease(50 * time.Millisecond)
store.Close()
time.Sleep(1 * time.Second)
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer testleak.AfterTest(c)()
ctx := mock.NewContext()
dom, err := NewDomain(store, 0)
c.Assert(err, IsNil)
store = dom.Store()
dd := dom.DDL()
c.Assert(dd, NotNil)
cs := &ast.CharsetOpt{
Chs: "utf8",
Col: "utf8_bin",
}
err = dd.CreateSchema(ctx, model.NewCIStr("aaa"), cs)
c.Assert(err, IsNil)
is := dom.InfoSchema()
c.Assert(is, NotNil)
dom, err = NewDomain(store, 0)
c.Assert(err, IsNil)
dom.SetLease(10 * time.Second)
m, err := dom.Stats()
c.Assert(err, IsNil)
c.Assert(m[ddlLastReloadSchemaTS], GreaterEqual, int64(0))
c.Assert(dom.GetScope("dummy_status"), Equals, variable.DefaultScopeFlag)
dom.SetLease(10 * time.Millisecond)
time.Sleep(20 * time.Millisecond)
atomic.StoreInt64(&dom.lastLeaseTS, 0)
dom.tryReload()
time.Sleep(1 * time.Second)
// for schemaValidity
err = dom.SchemaValidity.Check(0)
c.Assert(err, IsNil)
dom.SchemaValidity.MockReloadFailed = true
err = dom.MustReload()
c.Assert(err, NotNil)
err = dom.SchemaValidity.Check(0)
c.Assert(err, NotNil)
dom.SchemaValidity.MockReloadFailed = false
err = dom.MustReload()
c.Assert(err, IsNil)
err = dom.SchemaValidity.Check(0)
c.Assert(err, IsNil)
// for goroutine exit in Reload
defaultMinReloadTimeout = 1 * time.Second
err = store.Close()
c.Assert(err, IsNil)
err = dom.Reload()
c.Assert(err, NotNil)
}
func (ts *testSuite) SetUpSuite(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Check(err, IsNil)
ts.store = store
ts.se, err = tidb.CreateSession(ts.store)
c.Assert(err, IsNil)
}
func (s *tesTxStructureSuite) SetUpSuite(c *C) {
path := "memory:"
d := localstore.Driver{
Driver: goleveldb.MemoryDriver{},
}
store, err := d.Open(path)
c.Assert(err, IsNil)
s.s = NewStore(store, []byte{0x00})
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer testleak.AfterTest(c)()
ctx := mock.NewContext()
dom, err := NewDomain(store, 80*time.Millisecond)
c.Assert(err, IsNil)
store = dom.Store()
dd := dom.DDL()
c.Assert(dd, NotNil)
c.Assert(dd.GetLease(), Equals, 80*time.Millisecond)
cs := &ast.CharsetOpt{
Chs: "utf8",
Col: "utf8_bin",
}
err = dd.CreateSchema(ctx, model.NewCIStr("aaa"), cs)
c.Assert(err, IsNil)
is := dom.InfoSchema()
c.Assert(is, NotNil)
m, err := dom.Stats()
c.Assert(err, IsNil)
c.Assert(m[ddlLastReloadSchemaTS], GreaterEqual, int64(0))
c.Assert(dom.GetScope("dummy_status"), Equals, variable.DefaultScopeFlag)
// for setting lease
lease := 100 * time.Millisecond
// for schemaValidity
schemaVer, err := dom.SchemaValidity.Check(0, 0)
c.Assert(err, IsNil)
dom.SchemaValidity.MockReloadFailed.SetValue(true)
err = dom.Reload()
c.Assert(err, NotNil)
time.Sleep(lease)
_, err = dom.SchemaValidity.Check(0, 0)
c.Assert(err, NotNil)
_, err = dom.SchemaValidity.Check(0, schemaVer)
c.Assert(err, NotNil)
dom.SchemaValidity.MockReloadFailed.SetValue(false)
dom.SchemaValidity.SetExpireInfo(false, 0)
_, err = dom.SchemaValidity.Check(1, 0)
c.Assert(err, NotNil)
schemaVer1, err := dom.SchemaValidity.Check(0, schemaVer)
c.Assert(err, IsNil)
err = dom.Reload()
c.Assert(err, IsNil)
time.Sleep(lease)
schemaVer2, err := dom.SchemaValidity.Check(0, 0)
c.Assert(err, IsNil)
c.Assert(schemaVer1, Equals, schemaVer2)
err = store.Close()
c.Assert(err, IsNil)
}
func (ts *testSuite) SetUpSuite(c *C) {
table.TableFromMeta = tables.TableFromMeta
driver := localstore.Driver{goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Check(err, IsNil)
ts.store = store
ts.se, err = tidb.CreateSession(ts.store)
c.Assert(err, IsNil)
_, err = ts.se.Execute("CREATE DATABASE test")
c.Assert(err, IsNil)
}
func (s *testSuite) TestDDL(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
m := meta.NewMeta(store)
t, err := m.Begin()
c.Assert(err, IsNil)
defer t.Rollback()
owner := &model.Owner{OwnerID: "1"}
err = t.SetDDLOwner(owner)
c.Assert(err, IsNil)
ov, err := t.GetDDLOwner()
c.Assert(err, IsNil)
c.Assert(owner, DeepEquals, ov)
job := &model.Job{ID: 1}
err = t.EnQueueDDLJob(job)
c.Assert(err, IsNil)
n, err := t.DDLJobLength()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
v, err := t.GetDDLJob(0)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, job)
v, err = t.GetDDLJob(1)
c.Assert(err, IsNil)
c.Assert(v, IsNil)
job.ID = 2
err = t.UpdateDDLJob(0, job)
c.Assert(err, IsNil)
v, err = t.DeQueueDDLJob()
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, job)
err = t.AddHistoryDDLJob(job)
c.Assert(err, IsNil)
v, err = t.GetHistoryDDLJob(2)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, job)
err = t.Commit()
c.Assert(err, IsNil)
}
func (s *testPrefixSuite) SetUpSuite(c *C) {
path := "memory:"
d := localstore.Driver{
Driver: goleveldb.MemoryDriver{},
}
store, err := d.Open(path)
c.Assert(err, IsNil)
s.s = store
// must in cache
cacheS, _ := d.Open(path)
c.Assert(cacheS, Equals, store)
}
func (s *testKVSuite) TestDBClose(c *C) {
defer testleak.AfterTest(c)()
path := "memory:test"
d := localstore.Driver{
Driver: goleveldb.MemoryDriver{},
}
store, err := d.Open(path)
c.Assert(err, IsNil)
txn, err := store.Begin()
c.Assert(err, IsNil)
err = txn.Set([]byte("a"), []byte("b"))
c.Assert(err, IsNil)
err = txn.Commit()
c.Assert(err, IsNil)
ver, err := store.CurrentVersion()
c.Assert(err, IsNil)
c.Assert(kv.MaxVersion.Cmp(ver), Equals, 1)
snap, err := store.GetSnapshot(kv.MaxVersion)
c.Assert(err, IsNil)
_, err = snap.Get([]byte("a"))
c.Assert(err, IsNil)
txn, err = store.Begin()
c.Assert(err, IsNil)
err = store.Close()
c.Assert(err, IsNil)
_, err = store.Begin()
c.Assert(err, NotNil)
_, err = store.GetSnapshot(kv.MaxVersion)
c.Assert(err, NotNil)
err = txn.Set([]byte("a"), []byte("b"))
c.Assert(err, IsNil)
err = txn.Commit()
c.Assert(err, NotNil)
snap.Release()
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
dom, err := NewDomain(store)
c.Assert(err, IsNil)
store = dom.Store()
dd := dom.DDL()
c.Assert(dd, NotNil)
err = dd.CreateSchema(nil, model.NewCIStr("aaa"))
c.Assert(err, IsNil)
is := dom.InfoSchema()
c.Assert(is, NotNil)
dom, err = NewDomain(store)
c.Assert(err, IsNil)
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
alloc := autoid.NewAllocator(store)
c.Assert(alloc, NotNil)
id, err := alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(1))
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(2))
id, err = alloc.Alloc(0)
c.Assert(err, NotNil)
}
func (*testSuite) TestT(c *C) {
var ident = ast.Ident{
Name: model.NewCIStr("t"),
}
c.Assert(ident.String(), Not(Equals), "")
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
se, err := tidb.CreateSession(store)
c.Assert(err, IsNil)
ctx := se.(context.Context)
db.BindCurrentSchema(ctx, "test")
fullIdent := ident.Full(ctx)
c.Assert(fullIdent.Schema.L, Equals, "test")
c.Assert(fullIdent.Name.L, Equals, "t")
c.Assert(fullIdent.String(), Not(Equals), "")
fullIdent2 := fullIdent.Full(ctx)
c.Assert(fullIdent2.Schema.L, Equals, fullIdent.Schema.L)
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
ctx := mock.NewContext()
dom, err := NewDomain(store, 0)
c.Assert(err, IsNil)
store = dom.Store()
dd := dom.DDL()
c.Assert(dd, NotNil)
cs := &coldef.CharsetOpt{
Chs: "utf8",
Col: "utf8_bin",
}
err = dd.CreateSchema(ctx, model.NewCIStr("aaa"), cs)
c.Assert(err, IsNil)
is := dom.InfoSchema()
c.Assert(is, NotNil)
dom, err = NewDomain(store, 0)
c.Assert(err, IsNil)
dom.SetLease(10 * time.Second)
m, err := dom.Stats()
c.Assert(err, IsNil)
c.Assert(m[ddlLastReloadSchemaTS], GreaterEqual, int64(0))
c.Assert(dom.GetScope("dummy_status"), Equals, variable.DefaultScopeFlag)
dom.SetLease(10 * time.Millisecond)
time.Sleep(20 * time.Millisecond)
atomic.StoreInt64(&dom.lastLeaseTS, 0)
dom.tryReload()
store.Close()
time.Sleep(1 * time.Second)
}
func (s *testSuite) SetUpSuite(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
var err error
s.store, err = driver.Open("memory:test_inspect")
c.Assert(err, IsNil)
s.ctx = mock.NewContext()
s.ctx.Store = s.store
variable.BindSessionVars(s.ctx)
txn, err := s.store.Begin()
c.Assert(err, IsNil)
t := meta.NewMeta(txn)
s.dbInfo = &model.DBInfo{
ID: 1,
Name: model.NewCIStr("a"),
}
err = t.CreateDatabase(s.dbInfo)
c.Assert(err, IsNil)
col := &model.ColumnInfo{
Name: model.NewCIStr("c"),
ID: 0,
Offset: 0,
DefaultValue: 1,
State: model.StatePublic,
FieldType: *types.NewFieldType(mysql.TypeLong),
}
col1 := &model.ColumnInfo{
Name: model.NewCIStr("c1"),
ID: 1,
Offset: 1,
DefaultValue: 1,
State: model.StatePublic,
FieldType: *types.NewFieldType(mysql.TypeLong),
}
idx := &model.IndexInfo{
Name: model.NewCIStr("c"),
ID: 1,
Unique: true,
Columns: []*model.IndexColumn{{
Name: model.NewCIStr("c"),
Offset: 0,
Length: 255,
}},
State: model.StatePublic,
}
s.tbInfo = &model.TableInfo{
ID: 1,
Name: model.NewCIStr("t"),
State: model.StatePublic,
Columns: []*model.ColumnInfo{col, col1},
Indices: []*model.IndexInfo{idx},
}
err = t.CreateTable(s.dbInfo.ID, s.tbInfo)
c.Assert(err, IsNil)
err = txn.Commit()
c.Assert(err, IsNil)
}
func testCreateStore(c *C, name string) kv.Storage {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open(fmt.Sprintf("memory:%s", name))
c.Assert(err, IsNil)
return store
}
func (*testSuite) TestT(c *C) {
table.TableFromMeta = tables.TableFromMeta
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
handle := infoschema.NewHandle(store)
dbName := model.NewCIStr("Test")
tbName := model.NewCIStr("T")
colName := model.NewCIStr("A")
idxName := model.NewCIStr("idx")
noexist := model.NewCIStr("noexist")
colInfo := &model.ColumnInfo{
ID: 3,
Name: colName,
Offset: 0,
FieldType: *types.NewFieldType(mysqldef.TypeLonglong),
}
idxInfo := &model.IndexInfo{
Name: idxName,
Table: tbName,
Columns: []*model.IndexColumn{
&model.IndexColumn{
Name: colName,
Offset: 0,
Length: 10,
},
},
Unique: true,
Primary: true,
}
tblInfo := &model.TableInfo{
ID: 2,
Name: tbName,
Columns: []*model.ColumnInfo{colInfo},
Indices: []*model.IndexInfo{idxInfo},
}
dbInfo := &model.DBInfo{
ID: 1,
Name: dbName,
Tables: []*model.TableInfo{tblInfo},
}
dbInfos := []*model.DBInfo{dbInfo}
handle.Set(dbInfos)
is := handle.Get()
schemaNames := is.AllSchemaNames()
c.Assert(len(schemaNames), Equals, 1)
c.Assert(schemaNames[0], Equals, "Test")
schemas := is.AllSchemas()
c.Assert(len(schemas), Equals, 1)
schemas = is.Clone()
c.Assert(len(schemas), Equals, 1)
c.Assert(is.SchemaExists(dbName), IsTrue)
c.Assert(is.SchemaExists(noexist), IsFalse)
schema, ok := is.SchemaByID(1)
c.Assert(ok, IsTrue)
c.Assert(schema, NotNil)
schema, ok = is.SchemaByID(2)
c.Assert(ok, IsFalse)
c.Assert(schema, IsNil)
schema, ok = is.SchemaByName(dbName)
c.Assert(ok, IsTrue)
c.Assert(schema, NotNil)
schema, ok = is.SchemaByName(noexist)
c.Assert(ok, IsFalse)
c.Assert(schema, IsNil)
c.Assert(is.TableExists(dbName, tbName), IsTrue)
c.Assert(is.TableExists(dbName, noexist), IsFalse)
tb, ok := is.TableByID(2)
c.Assert(ok, IsTrue)
c.Assert(tb, NotNil)
tb, ok = is.TableByID(3)
c.Assert(ok, IsFalse)
c.Assert(tb, IsNil)
tb, err = is.TableByName(dbName, tbName)
c.Assert(err, IsNil)
c.Assert(tb, NotNil)
tb, err = is.TableByName(dbName, noexist)
c.Assert(err, NotNil)
c.Assert(is.ColumnExists(dbName, tbName, colName), IsTrue)
c.Assert(is.ColumnExists(dbName, tbName, noexist), IsFalse)
col, ok := is.ColumnByID(3)
c.Assert(ok, IsTrue)
c.Assert(col, NotNil)
col, ok = is.ColumnByID(5)
c.Assert(ok, IsFalse)
c.Assert(col, IsNil)
col, ok = is.ColumnByName(dbName, tbName, colName)
c.Assert(ok, IsTrue)
c.Assert(col, NotNil)
col, ok = is.ColumnByName(dbName, tbName, noexist)
c.Assert(ok, IsFalse)
c.Assert(col, IsNil)
indices := is.ColumnIndices(3)
c.Assert(len(indices), Equals, 1)
tbs := is.SchemaTables(dbName)
c.Assert(len(tbs), Equals, 1)
tbs = is.SchemaTables(noexist)
c.Assert(len(tbs), Equals, 0)
idx, ok := is.IndexByName(dbName, tbName, idxName)
c.Assert(ok, IsTrue)
c.Assert(idx, NotNil)
}
func (s *testSuite) TestMeta(c *C) {
defer testleak.AfterTest(c)()
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
txn, err := store.Begin()
c.Assert(err, IsNil)
defer txn.Rollback()
t := meta.NewMeta(txn)
n, err := t.GenGlobalID()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetGlobalID()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(0))
n, err = t.GenSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
dbInfo := &model.DBInfo{
ID: 1,
Name: model.NewCIStr("a"),
}
err = t.CreateDatabase(dbInfo)
c.Assert(err, IsNil)
err = t.CreateDatabase(dbInfo)
c.Assert(err, NotNil)
v, err := t.GetDatabase(1)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, dbInfo)
dbInfo.Name = model.NewCIStr("aa")
err = t.UpdateDatabase(dbInfo)
c.Assert(err, IsNil)
v, err = t.GetDatabase(1)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, dbInfo)
dbs, err := t.ListDatabases()
c.Assert(err, IsNil)
c.Assert(dbs, DeepEquals, []*model.DBInfo{dbInfo})
tbInfo := &model.TableInfo{
ID: 1,
Name: model.NewCIStr("t"),
}
err = t.CreateTable(1, tbInfo)
c.Assert(err, IsNil)
n, err = t.GenAutoTableID(1, 1, 10)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(10))
n, err = t.GetAutoTableID(1, 1)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(10))
err = t.CreateTable(1, tbInfo)
c.Assert(err, NotNil)
tbInfo.Name = model.NewCIStr("tt")
err = t.UpdateTable(1, tbInfo)
c.Assert(err, IsNil)
table, err := t.GetTable(1, 1)
c.Assert(err, IsNil)
c.Assert(table, DeepEquals, tbInfo)
table, err = t.GetTable(1, 2)
c.Assert(err, IsNil)
c.Assert(table, IsNil)
tbInfo2 := &model.TableInfo{
ID: 2,
Name: model.NewCIStr("bb"),
}
err = t.CreateTable(1, tbInfo2)
c.Assert(err, IsNil)
tables, err := t.ListTables(1)
c.Assert(err, IsNil)
c.Assert(tables, DeepEquals, []*model.TableInfo{tbInfo, tbInfo2})
err = t.DropTable(1, 2)
c.Assert(err, IsNil)
tables, err = t.ListTables(1)
c.Assert(err, IsNil)
c.Assert(tables, DeepEquals, []*model.TableInfo{tbInfo})
err = t.DropDatabase(1)
c.Assert(err, IsNil)
dbs, err = t.ListDatabases()
c.Assert(err, IsNil)
c.Assert(dbs, HasLen, 0)
bootstrapVer, err := t.GetBootstrapVersion()
c.Assert(err, IsNil)
c.Assert(bootstrapVer, Equals, int64(0))
err = t.FinishBootstrap(int64(1))
c.Assert(err, IsNil)
bootstrapVer, err = t.GetBootstrapVersion()
c.Assert(err, IsNil)
c.Assert(bootstrapVer, Equals, int64(1))
// Test case for meta.FinishBootstrap with a version.
err = t.FinishBootstrap(int64(10))
c.Assert(err, IsNil)
bootstrapVer, err = t.GetBootstrapVersion()
c.Assert(err, IsNil)
c.Assert(bootstrapVer, Equals, int64(10))
// Test case for SchemaDiff.
schemaDiff := &model.SchemaDiff{
Version: 100,
SchemaID: 1,
Type: model.ActionTruncateTable,
TableID: 2,
OldTableID: 3,
}
err = t.SetSchemaDiff(schemaDiff.Version, schemaDiff)
c.Assert(err, IsNil)
readDiff, err := t.GetSchemaDiff(schemaDiff.Version)
c.Assert(readDiff, DeepEquals, schemaDiff)
err = txn.Commit()
c.Assert(err, IsNil)
}
func (*testSuite) TestT(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
err = kv.RunInNewTxn(store, false, func(txn kv.Transaction) error {
m := meta.NewMeta(txn)
err = m.CreateDatabase(&model.DBInfo{ID: 1, Name: model.NewCIStr("a")})
c.Assert(err, IsNil)
err = m.CreateTable(1, &model.TableInfo{ID: 1, Name: model.NewCIStr("t")})
c.Assert(err, IsNil)
err = m.CreateTable(1, &model.TableInfo{ID: 2, Name: model.NewCIStr("t1")})
c.Assert(err, IsNil)
err = m.CreateTable(1, &model.TableInfo{ID: 3, Name: model.NewCIStr("t1")})
c.Assert(err, IsNil)
return nil
})
c.Assert(err, IsNil)
alloc := autoid.NewAllocator(store, 1)
c.Assert(alloc, NotNil)
id, err := alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(1))
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(2))
id, err = alloc.Alloc(0)
c.Assert(err, NotNil)
// rebase
err = alloc.Rebase(1, int64(1), true)
c.Assert(err, IsNil)
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(3))
err = alloc.Rebase(1, int64(3), true)
c.Assert(err, IsNil)
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(4))
err = alloc.Rebase(1, int64(10), true)
c.Assert(err, IsNil)
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(11))
err = alloc.Rebase(1, int64(3010), true)
c.Assert(err, IsNil)
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(3011))
alloc = autoid.NewAllocator(store, 1)
c.Assert(alloc, NotNil)
id, err = alloc.Alloc(1)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(autoid.GetStep()+1))
alloc = autoid.NewAllocator(store, 1)
c.Assert(alloc, NotNil)
err = alloc.Rebase(2, int64(1), false)
c.Assert(err, IsNil)
id, err = alloc.Alloc(2)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(2))
alloc = autoid.NewAllocator(store, 1)
c.Assert(alloc, NotNil)
err = alloc.Rebase(3, int64(3210), false)
c.Assert(err, IsNil)
alloc = autoid.NewAllocator(store, 1)
c.Assert(alloc, NotNil)
err = alloc.Rebase(3, int64(3000), false)
c.Assert(err, IsNil)
id, err = alloc.Alloc(3)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(3211))
err = alloc.Rebase(3, int64(6543), false)
c.Assert(err, IsNil)
id, err = alloc.Alloc(3)
c.Assert(err, IsNil)
c.Assert(id, Equals, int64(6544))
}
func (*testSuite) TestT(c *C) {
defer testleak.AfterTest(c)()
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
handle, err := infoschema.NewHandle(store)
c.Assert(err, IsNil)
dbName := model.NewCIStr("Test")
tbName := model.NewCIStr("T")
colName := model.NewCIStr("A")
idxName := model.NewCIStr("idx")
noexist := model.NewCIStr("noexist")
colID, err := genGlobalID(store)
c.Assert(err, IsNil)
colInfo := &model.ColumnInfo{
ID: colID,
Name: colName,
Offset: 0,
FieldType: *types.NewFieldType(mysql.TypeLonglong),
State: model.StatePublic,
}
idxInfo := &model.IndexInfo{
Name: idxName,
Table: tbName,
Columns: []*model.IndexColumn{
{
Name: colName,
Offset: 0,
Length: 10,
},
},
Unique: true,
Primary: true,
State: model.StatePublic,
}
tbID, err := genGlobalID(store)
c.Assert(err, IsNil)
tblInfo := &model.TableInfo{
ID: tbID,
Name: tbName,
Columns: []*model.ColumnInfo{colInfo},
Indices: []*model.IndexInfo{idxInfo},
State: model.StatePublic,
}
dbID, err := genGlobalID(store)
c.Assert(err, IsNil)
dbInfo := &model.DBInfo{
ID: dbID,
Name: dbName,
Tables: []*model.TableInfo{tblInfo},
State: model.StatePublic,
}
dbInfos := []*model.DBInfo{dbInfo}
err = kv.RunInNewTxn(store, true, func(txn kv.Transaction) error {
meta.NewMeta(txn).CreateDatabase(dbInfo)
return errors.Trace(err)
})
c.Assert(err, IsNil)
builder, err := infoschema.NewBuilder(handle).InitWithDBInfos(dbInfos, 1)
c.Assert(err, IsNil)
txn, err := store.Begin()
c.Assert(err, IsNil)
checkApplyCreateNonExistsSchemaDoesNotPanic(c, txn, builder)
checkApplyCreateNonExistsTableDoesNotPanic(c, txn, builder, dbID)
txn.Rollback()
err = builder.Build()
c.Assert(err, IsNil)
is := handle.Get()
schemaNames := is.AllSchemaNames()
c.Assert(schemaNames, HasLen, 3)
c.Assert(testutil.CompareUnorderedStringSlice(schemaNames, []string{infoschema.Name, perfschema.Name, "Test"}), IsTrue)
schemas := is.AllSchemas()
c.Assert(schemas, HasLen, 3)
schemas = is.Clone()
c.Assert(schemas, HasLen, 3)
c.Assert(is.SchemaExists(dbName), IsTrue)
c.Assert(is.SchemaExists(noexist), IsFalse)
schema, ok := is.SchemaByID(dbID)
c.Assert(ok, IsTrue)
c.Assert(schema, NotNil)
schema, ok = is.SchemaByID(tbID)
c.Assert(ok, IsFalse)
c.Assert(schema, IsNil)
schema, ok = is.SchemaByName(dbName)
c.Assert(ok, IsTrue)
c.Assert(schema, NotNil)
schema, ok = is.SchemaByName(noexist)
c.Assert(ok, IsFalse)
c.Assert(schema, IsNil)
c.Assert(is.TableExists(dbName, tbName), IsTrue)
c.Assert(is.TableExists(dbName, noexist), IsFalse)
tb, ok := is.TableByID(tbID)
c.Assert(ok, IsTrue)
c.Assert(tb, NotNil)
tb, ok = is.TableByID(dbID)
c.Assert(ok, IsFalse)
c.Assert(tb, IsNil)
alloc, ok := is.AllocByID(tbID)
c.Assert(ok, IsTrue)
c.Assert(alloc, NotNil)
tb, err = is.TableByName(dbName, tbName)
c.Assert(err, IsNil)
c.Assert(tb, NotNil)
tb, err = is.TableByName(dbName, noexist)
c.Assert(err, NotNil)
tbs := is.SchemaTables(dbName)
c.Assert(tbs, HasLen, 1)
tbs = is.SchemaTables(noexist)
c.Assert(tbs, HasLen, 0)
// Make sure partitions table exists
tb, err = is.TableByName(model.NewCIStr("information_schema"), model.NewCIStr("partitions"))
c.Assert(err, IsNil)
c.Assert(tb, NotNil)
}
func (s *testSuite) TestMeta(c *C) {
defer testleak.AfterTest(c)()
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
txn, err := store.Begin()
c.Assert(err, IsNil)
defer txn.Rollback()
t := meta.NewMeta(txn)
n, err := t.GenGlobalID()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetGlobalID()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(0))
n, err = t.GenSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
dbInfo := &model.DBInfo{
ID: 1,
Name: model.NewCIStr("a"),
}
err = t.CreateDatabase(dbInfo)
c.Assert(err, IsNil)
err = t.CreateDatabase(dbInfo)
c.Assert(err, NotNil)
v, err := t.GetDatabase(1)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, dbInfo)
dbInfo.Name = model.NewCIStr("aa")
err = t.UpdateDatabase(dbInfo)
c.Assert(err, IsNil)
v, err = t.GetDatabase(1)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, dbInfo)
dbs, err := t.ListDatabases()
c.Assert(err, IsNil)
c.Assert(dbs, DeepEquals, []*model.DBInfo{dbInfo})
tbInfo := &model.TableInfo{
ID: 1,
Name: model.NewCIStr("t"),
}
err = t.CreateTable(1, tbInfo)
c.Assert(err, IsNil)
n, err = t.GenAutoTableID(1, 1, 10)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(10))
n, err = t.GetAutoTableID(1, 1)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(10))
err = t.CreateTable(1, tbInfo)
c.Assert(err, NotNil)
tbInfo.Name = model.NewCIStr("tt")
err = t.UpdateTable(1, tbInfo)
c.Assert(err, IsNil)
table, err := t.GetTable(1, 1)
c.Assert(err, IsNil)
c.Assert(table, DeepEquals, tbInfo)
table, err = t.GetTable(1, 2)
c.Assert(err, IsNil)
c.Assert(table, IsNil)
tbInfo2 := &model.TableInfo{
ID: 2,
Name: model.NewCIStr("bb"),
}
err = t.CreateTable(1, tbInfo2)
c.Assert(err, IsNil)
tables, err := t.ListTables(1)
c.Assert(err, IsNil)
c.Assert(tables, DeepEquals, []*model.TableInfo{tbInfo, tbInfo2})
err = t.DropTable(1, 2)
c.Assert(err, IsNil)
tables, err = t.ListTables(1)
c.Assert(err, IsNil)
c.Assert(tables, DeepEquals, []*model.TableInfo{tbInfo})
err = t.DropDatabase(1)
c.Assert(err, IsNil)
dbs, err = t.ListDatabases()
c.Assert(err, IsNil)
c.Assert(dbs, HasLen, 0)
bootstrapped, err := t.IsBootstrapped()
c.Assert(err, IsNil)
c.Assert(bootstrapped, IsFalse)
err = t.FinishBootstrap()
c.Assert(err, IsNil)
bootstrapped, err = t.IsBootstrapped()
c.Assert(err, IsNil)
c.Assert(bootstrapped, IsTrue)
err = txn.Commit()
c.Assert(err, IsNil)
}
func (s *testSuite) TestDDL(c *C) {
defer testleak.AfterTest(c)()
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
txn, err := store.Begin()
c.Assert(err, IsNil)
defer txn.Rollback()
t := meta.NewMeta(txn)
owner := &model.Owner{OwnerID: "1"}
err = t.SetDDLJobOwner(owner)
c.Assert(err, IsNil)
ov, err := t.GetDDLJobOwner()
c.Assert(err, IsNil)
c.Assert(owner, DeepEquals, ov)
job := &model.Job{ID: 1}
err = t.EnQueueDDLJob(job)
c.Assert(err, IsNil)
n, err := t.DDLJobQueueLen()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
v, err := t.GetDDLJob(0)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, job)
v, err = t.GetDDLJob(1)
c.Assert(err, IsNil)
c.Assert(v, IsNil)
job.ID = 2
err = t.UpdateDDLJob(0, job)
c.Assert(err, IsNil)
err = t.UpdateDDLReorgHandle(job, 1)
c.Assert(err, IsNil)
h, err := t.GetDDLReorgHandle(job)
c.Assert(err, IsNil)
c.Assert(h, Equals, int64(1))
err = t.RemoveDDLReorgHandle(job)
c.Assert(err, IsNil)
v, err = t.DeQueueDDLJob()
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, job)
err = t.AddHistoryDDLJob(job)
c.Assert(err, IsNil)
v, err = t.GetHistoryDDLJob(2)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, job)
// DDL background job test
err = t.SetBgJobOwner(owner)
c.Assert(err, IsNil)
ov, err = t.GetBgJobOwner()
c.Assert(err, IsNil)
c.Assert(owner, DeepEquals, ov)
bgJob := &model.Job{ID: 1}
err = t.EnQueueBgJob(bgJob)
c.Assert(err, IsNil)
n, err = t.BgJobQueueLen()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
v, err = t.GetBgJob(0)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, bgJob)
v, err = t.GetBgJob(1)
c.Assert(err, IsNil)
c.Assert(v, IsNil)
bgJob.ID = 2
err = t.UpdateBgJob(0, bgJob)
c.Assert(err, IsNil)
v, err = t.DeQueueBgJob()
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, bgJob)
err = t.AddHistoryBgJob(bgJob)
c.Assert(err, IsNil)
v, err = t.GetHistoryBgJob(2)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, bgJob)
err = txn.Commit()
c.Assert(err, IsNil)
}
func (s *testSuite) TestMeta(c *C) {
driver := localstore.Driver{Driver: goleveldb.MemoryDriver{}}
store, err := driver.Open("memory")
c.Assert(err, IsNil)
defer store.Close()
m := meta.NewMeta(store)
t, err := m.Begin()
c.Assert(err, IsNil)
defer t.Rollback()
n, err := t.GenGlobalID()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetGlobalID()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(0))
n, err = t.GenSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
n, err = t.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(1))
dbInfo := &model.DBInfo{
ID: 1,
Name: model.NewCIStr("a"),
}
err = t.CreateDatabase(dbInfo)
c.Assert(err, IsNil)
err = t.CreateDatabase(dbInfo)
c.Assert(err, NotNil)
v, err := t.GetDatabase(1)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, dbInfo)
dbInfo.Name = model.NewCIStr("aa")
err = t.UpdateDatabase(dbInfo)
c.Assert(err, IsNil)
v, err = t.GetDatabase(1)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, dbInfo)
dbs, err := t.ListDatabases()
c.Assert(err, IsNil)
c.Assert(dbs, DeepEquals, []*model.DBInfo{dbInfo})
tbInfo := &model.TableInfo{
ID: 1,
Name: model.NewCIStr("t"),
}
err = t.CreateTable(1, tbInfo)
c.Assert(err, IsNil)
n, err = t.GenAutoTableID(1, 1, 10)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(10))
n, err = t.GetAutoTableID(1, 1)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(10))
err = t.CreateTable(1, tbInfo)
c.Assert(err, NotNil)
tbInfo.Name = model.NewCIStr("tt")
err = t.UpdateTable(1, tbInfo)
c.Assert(err, IsNil)
table, err := t.GetTable(1, 1)
c.Assert(err, IsNil)
c.Assert(table, DeepEquals, tbInfo)
table, err = t.GetTable(1, 2)
c.Assert(err, IsNil)
c.Assert(table, IsNil)
tbInfo2 := &model.TableInfo{
ID: 2,
Name: model.NewCIStr("bb"),
}
err = t.CreateTable(1, tbInfo2)
c.Assert(err, IsNil)
tables, err := t.ListTables(1)
c.Assert(err, IsNil)
c.Assert(tables, DeepEquals, []*model.TableInfo{tbInfo, tbInfo2})
err = t.DropTable(1, 2)
c.Assert(err, IsNil)
tables, err = t.ListTables(1)
c.Assert(err, IsNil)
c.Assert(tables, DeepEquals, []*model.TableInfo{tbInfo})
err = t.DropDatabase(1)
c.Assert(err, IsNil)
dbs, err = t.ListDatabases()
c.Assert(err, IsNil)
c.Assert(dbs, HasLen, 0)
err = t.Commit()
c.Assert(err, IsNil)
fn := func(m *meta.TMeta) error {
n, err = m.GenSchemaVersion()
c.Assert(err, IsNil)
var n1 int64
n1, err = m.GetSchemaVersion()
c.Assert(err, IsNil)
c.Assert(n, Equals, n1)
return nil
}
err = m.RunInNewTxn(false, fn)
c.Assert(err, IsNil)
n, err = m.GenGlobalID()
c.Assert(err, IsNil)
n1, err := m.GenGlobalID()
c.Assert(err, IsNil)
c.Assert(n1, Equals, n+1)
}