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 initMemoryTables(h *memSchemaHandle) error {
// Init Information_Schema
var (
err error
tbl table.Table
)
for _, tblInfo := range infoSchemaDB.Tables {
alloc := autoid.NewMemoryAllocator(infoSchemaDB.ID)
tbl, err = createMemoryTable(tblInfo, alloc)
if err != nil {
return errors.Trace(err)
}
h.nameToTable[tblInfo.Name.L] = tbl
}
h.schemataTbl = h.nameToTable[strings.ToLower(tableSchemata)]
h.tablesTbl = h.nameToTable[strings.ToLower(tableTables)]
h.columnsTbl = h.nameToTable[strings.ToLower(tableColumns)]
h.statisticsTbl = h.nameToTable[strings.ToLower(tableStatistics)]
h.charsetTbl = h.nameToTable[strings.ToLower(tableCharacterSets)]
h.collationsTbl = h.nameToTable[strings.ToLower(tableCollations)]
// CharacterSets/Collations contain static data. Init them now.
err = insertData(h.charsetTbl, dataForCharacterSets())
if err != nil {
return errors.Trace(err)
}
err = insertData(h.collationsTbl, dataForColltions())
if err != nil {
return errors.Trace(err)
}
return nil
}
func initMemoryTables(store kv.Storage) error {
// Init Information_Schema
var (
err error
tbl table.Table
)
dbID, err := genGlobalID(store)
if err != nil {
return errors.Trace(err)
}
nameToTable = make(map[string]table.Table)
isTables := make([]*model.TableInfo, 0, len(tableNameToColumns))
for name, cols := range tableNameToColumns {
meta := buildTableMeta(name, cols)
isTables = append(isTables, meta)
meta.ID, err = genGlobalID(store)
if err != nil {
return errors.Trace(err)
}
err = setColumnID(meta, store)
if err != nil {
return errors.Trace(err)
}
alloc := autoid.NewMemoryAllocator(dbID)
tbl, err = createMemoryTable(meta, alloc)
if err != nil {
return errors.Trace(err)
}
nameToTable[meta.Name.L] = tbl
}
schemataTbl = nameToTable[strings.ToLower(tableSchemata)]
tablesTbl = nameToTable[strings.ToLower(tableTables)]
columnsTbl = nameToTable[strings.ToLower(tableColumns)]
statisticsTbl = nameToTable[strings.ToLower(tableStatistics)]
charsetTbl = nameToTable[strings.ToLower(tableCharacterSets)]
collationsTbl = nameToTable[strings.ToLower(tableCollations)]
// CharacterSets/Collations contain static data. Init them now.
err = insertData(charsetTbl, dataForCharacterSets())
if err != nil {
return errors.Trace(err)
}
err = insertData(collationsTbl, dataForColltions())
if err != nil {
return errors.Trace(err)
}
// create db
isDB = &model.DBInfo{
ID: dbID,
Name: model.NewCIStr(Name),
Charset: mysql.DefaultCharset,
Collate: mysql.DefaultCollationName,
Tables: isTables,
}
return nil
}
func initMemoryTables(h *memSchemaHandle) error {
// Init Information_Schema
var (
err error
tbl table.Table
)
dbID := autoid.GenLocalSchemaID()
isTables := make([]*model.TableInfo, 0, len(tableNameToColumns))
for name, cols := range tableNameToColumns {
meta := buildTableMeta(name, cols)
isTables = append(isTables, meta)
meta.ID = autoid.GenLocalSchemaID()
for _, c := range meta.Columns {
c.ID = autoid.GenLocalSchemaID()
}
alloc := autoid.NewMemoryAllocator(dbID)
tbl, err = createMemoryTable(meta, alloc)
if err != nil {
return errors.Trace(err)
}
h.nameToTable[meta.Name.L] = tbl
}
h.schemataTbl = h.nameToTable[strings.ToLower(tableSchemata)]
h.tablesTbl = h.nameToTable[strings.ToLower(tableTables)]
h.columnsTbl = h.nameToTable[strings.ToLower(tableColumns)]
h.statisticsTbl = h.nameToTable[strings.ToLower(tableStatistics)]
h.charsetTbl = h.nameToTable[strings.ToLower(tableCharacterSets)]
h.collationsTbl = h.nameToTable[strings.ToLower(tableCollations)]
// CharacterSets/Collations contain static data. Init them now.
err = insertData(h.charsetTbl, dataForCharacterSets())
if err != nil {
return errors.Trace(err)
}
err = insertData(h.collationsTbl, dataForColltions())
if err != nil {
return errors.Trace(err)
}
// create db
h.isDB = &model.DBInfo{
ID: dbID,
Name: model.NewCIStr(Name),
Charset: mysql.DefaultCharset,
Collate: mysql.DefaultCollationName,
Tables: isTables,
}
return nil
}
func (ps *perfSchema) buildTables() error {
tbls := make([]*model.TableInfo, 0, len(ps.tables))
dbID := autoid.GenLocalSchemaID()
for name, meta := range ps.tables {
tbls = append(tbls, meta)
meta.ID = autoid.GenLocalSchemaID()
for _, c := range meta.Columns {
c.ID = autoid.GenLocalSchemaID()
}
alloc := autoid.NewMemoryAllocator(dbID)
var tbl table.Table
switch name {
case TableStmtsCurrent, TablePreparedStmtsInstances, TableTransCurrent, TableStagesCurrent:
tbl = createBoundedTable(meta, alloc, currentElemMax)
case TableStmtsHistory, TableStmtsHistoryLong, TableTransHistory, TableTransHistoryLong, TableStagesHistory, TableStagesHistoryLong:
tbl = createBoundedTable(meta, alloc, historyElemMax)
default:
var err error
tbl, err = createMemoryTable(meta, alloc)
if err != nil {
return errors.Trace(err)
}
}
ps.mTables[name] = tbl
}
ps.dbInfo = &model.DBInfo{
ID: dbID,
Name: model.NewCIStr(Name),
Charset: mysql.DefaultCharset,
Collate: mysql.DefaultCollationName,
Tables: tbls,
}
return nil
}