You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

422 lines
12 KiB

// Copyright 2015 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package ddl
import (
"bytes"
"context"
"fmt"
. "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/parser/auth"
"github.com/pingcap/parser/model"
"github.com/pingcap/parser/mysql"
"github.com/pingcap/tidb/kv"
"github.com/pingcap/tidb/meta"
"github.com/pingcap/tidb/meta/autoid"
"github.com/pingcap/tidb/sessionctx"
"github.com/pingcap/tidb/table"
"github.com/pingcap/tidb/types"
)
var _ = Suite(&testTableSuite{})
type testTableSuite struct {
store kv.Storage
dbInfo *model.DBInfo
d *ddl
}
// testTableInfo creates a test table with num int columns and with no index.
func testTableInfo(c *C, d *ddl, name string, num int) *model.TableInfo {
tblInfo := &model.TableInfo{
Name: model.NewCIStr(name),
}
genIDs, err := d.genGlobalIDs(1)
c.Assert(err, IsNil)
tblInfo.ID = genIDs[0]
cols := make([]*model.ColumnInfo, num)
for i := range cols {
col := &model.ColumnInfo{
Name: model.NewCIStr(fmt.Sprintf("c%d", i+1)),
Offset: i,
DefaultValue: i + 1,
State: model.StatePublic,
}
col.FieldType = *types.NewFieldType(mysql.TypeLong)
col.ID = allocateColumnID(tblInfo)
cols[i] = col
}
tblInfo.Columns = cols
tblInfo.Charset = "utf8"
tblInfo.Collate = "utf8_bin"
return tblInfo
}
// testTableInfoWithPartition creates a test table with num int columns and with no index.
func testTableInfoWithPartition(c *C, d *ddl, name string, num int) *model.TableInfo {
tblInfo := testTableInfo(c, d, name, num)
genIDs, err := d.genGlobalIDs(1)
c.Assert(err, IsNil)
pid := genIDs[0]
tblInfo.Partition = &model.PartitionInfo{
Type: model.PartitionTypeRange,
Expr: tblInfo.Columns[0].Name.L,
Enable: true,
Definitions: []model.PartitionDefinition{{
ID: pid,
Name: model.NewCIStr("p0"),
LessThan: []string{"maxvalue"},
}},
}
return tblInfo
}
// testTableInfoWithPartitionLessThan creates a test table with num int columns and one partition specified with lessthan.
func testTableInfoWithPartitionLessThan(c *C, d *ddl, name string, num int, lessthan string) *model.TableInfo {
tblInfo := testTableInfoWithPartition(c, d, name, num)
tblInfo.Partition.Definitions[0].LessThan = []string{lessthan}
return tblInfo
}
func testAddedNewTablePartitionInfo(c *C, d *ddl, tblInfo *model.TableInfo, partName, lessthan string) *model.PartitionInfo {
genIDs, err := d.genGlobalIDs(1)
c.Assert(err, IsNil)
pid := genIDs[0]
// the new added partition should change the partition state to state none at the beginning.
return &model.PartitionInfo{
Type: model.PartitionTypeRange,
Expr: tblInfo.Columns[0].Name.L,
Enable: true,
Definitions: []model.PartitionDefinition{{
ID: pid,
Name: model.NewCIStr(partName),
LessThan: []string{lessthan},
}},
}
}
// testViewInfo creates a test view with num int columns.
func testViewInfo(c *C, d *ddl, name string, num int) *model.TableInfo {
tblInfo := &model.TableInfo{
Name: model.NewCIStr(name),
}
genIDs, err := d.genGlobalIDs(1)
c.Assert(err, IsNil)
tblInfo.ID = genIDs[0]
cols := make([]*model.ColumnInfo, num)
viewCols := make([]model.CIStr, num)
var stmtBuffer bytes.Buffer
stmtBuffer.WriteString("SELECT ")
for i := range cols {
col := &model.ColumnInfo{
Name: model.NewCIStr(fmt.Sprintf("c%d", i+1)),
Offset: i,
State: model.StatePublic,
}
col.ID = allocateColumnID(tblInfo)
cols[i] = col
viewCols[i] = col.Name
stmtBuffer.WriteString(cols[i].Name.L + ",")
}
stmtBuffer.WriteString("1 FROM t")
view := model.ViewInfo{Cols: viewCols, Security: model.SecurityDefiner, Algorithm: model.AlgorithmMerge,
SelectStmt: stmtBuffer.String(), CheckOption: model.CheckOptionCascaded, Definer: &auth.UserIdentity{CurrentUser: true}}
tblInfo.View = &view
tblInfo.Columns = cols
return tblInfo
}
func testCreateTable(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo) *model.Job {
job := &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionCreateTable,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{tblInfo},
}
err := d.doDDLJob(ctx, job)
c.Assert(err, IsNil)
v := getSchemaVer(c, ctx)
tblInfo.State = model.StatePublic
checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
tblInfo.State = model.StateNone
return job
}
func testCreateView(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo) *model.Job {
job := &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionCreateView,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{tblInfo, false, 0},
}
c.Assert(tblInfo.IsView(), IsTrue)
err := d.doDDLJob(ctx, job)
c.Assert(err, IsNil)
v := getSchemaVer(c, ctx)
tblInfo.State = model.StatePublic
checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
tblInfo.State = model.StateNone
return job
}
func testRenameTable(c *C, ctx sessionctx.Context, d *ddl, newSchemaID, oldSchemaID int64, tblInfo *model.TableInfo) *model.Job {
job := &model.Job{
SchemaID: newSchemaID,
TableID: tblInfo.ID,
Type: model.ActionRenameTable,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{oldSchemaID, tblInfo.Name},
}
err := d.doDDLJob(ctx, job)
c.Assert(err, IsNil)
v := getSchemaVer(c, ctx)
tblInfo.State = model.StatePublic
checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
tblInfo.State = model.StateNone
return job
}
func testLockTable(c *C, ctx sessionctx.Context, d *ddl, newSchemaID int64, tblInfo *model.TableInfo, lockTp model.TableLockType) *model.Job {
arg := &lockTablesArg{
LockTables: []model.TableLockTpInfo{{SchemaID: newSchemaID, TableID: tblInfo.ID, Tp: lockTp}},
SessionInfo: model.SessionInfo{
ServerID: d.GetID(),
SessionID: ctx.GetSessionVars().ConnectionID,
},
}
job := &model.Job{
SchemaID: newSchemaID,
TableID: tblInfo.ID,
Type: model.ActionLockTable,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{arg},
}
err := d.doDDLJob(ctx, job)
c.Assert(err, IsNil)
v := getSchemaVer(c, ctx)
checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v})
return job
}
func checkTableLockedTest(c *C, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, serverID string, sessionID uint64, lockTp model.TableLockType) {
err := kv.RunInNewTxn(d.store, false, func(txn kv.Transaction) error {
t := meta.NewMeta(txn)
info, err := t.GetTable(dbInfo.ID, tblInfo.ID)
c.Assert(err, IsNil)
c.Assert(info, NotNil)
c.Assert(info.Lock, NotNil)
c.Assert(len(info.Lock.Sessions) == 1, IsTrue)
c.Assert(info.Lock.Sessions[0].ServerID, Equals, serverID)
c.Assert(info.Lock.Sessions[0].SessionID, Equals, sessionID)
c.Assert(info.Lock.Tp, Equals, lockTp)
c.Assert(info.Lock.State, Equals, model.TableLockStatePublic)
return nil
})
c.Assert(err, IsNil)
}
func testDropTable(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo) *model.Job {
job := &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionDropTable,
BinlogInfo: &model.HistoryInfo{},
}
err := d.doDDLJob(ctx, job)
c.Assert(err, IsNil)
v := getSchemaVer(c, ctx)
checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func testTruncateTable(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo) *model.Job {
genIDs, err := d.genGlobalIDs(1)
c.Assert(err, IsNil)
newTableID := genIDs[0]
job := &model.Job{
SchemaID: dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionTruncateTable,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{newTableID},
}
err = d.doDDLJob(ctx, job)
c.Assert(err, IsNil)
v := getSchemaVer(c, ctx)
tblInfo.ID = newTableID
checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo})
return job
}
func testCheckTableState(c *C, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, state model.SchemaState) {
err := kv.RunInNewTxn(d.store, false, func(txn kv.Transaction) error {
t := meta.NewMeta(txn)
info, err := t.GetTable(dbInfo.ID, tblInfo.ID)
c.Assert(err, IsNil)
if state == model.StateNone {
c.Assert(info, IsNil)
return nil
}
c.Assert(info.Name, DeepEquals, tblInfo.Name)
c.Assert(info.State, Equals, state)
return nil
})
c.Assert(err, IsNil)
}
func testGetTable(c *C, d *ddl, schemaID int64, tableID int64) table.Table {
tbl, err := testGetTableWithError(d, schemaID, tableID)
c.Assert(err, IsNil)
return tbl
}
func testGetTableWithError(d *ddl, schemaID, tableID int64) (table.Table, error) {
var tblInfo *model.TableInfo
err := kv.RunInNewTxn(d.store, false, func(txn kv.Transaction) error {
t := meta.NewMeta(txn)
var err1 error
tblInfo, err1 = t.GetTable(schemaID, tableID)
if err1 != nil {
return errors.Trace(err1)
}
return nil
})
if err != nil {
return nil, errors.Trace(err)
}
if tblInfo == nil {
return nil, errors.New("table not found")
}
alloc := autoid.NewAllocator(d.store, schemaID, false, autoid.RowIDAllocType)
tbl, err := table.TableFromMeta(autoid.NewAllocators(alloc), tblInfo)
if err != nil {
return nil, errors.Trace(err)
}
return tbl, nil
}
func (s *testTableSuite) SetUpSuite(c *C) {
s.store = testCreateStore(c, "test_table")
s.d = testNewDDLAndStart(
context.Background(),
c,
WithStore(s.store),
WithLease(testLease),
)
s.dbInfo = testSchemaInfo(c, s.d, "test")
testCreateSchema(c, testNewContext(s.d), s.d, s.dbInfo)
}
func (s *testTableSuite) TearDownSuite(c *C) {
testDropSchema(c, testNewContext(s.d), s.d, s.dbInfo)
s.d.Stop()
s.store.Close()
}
func (s *testTableSuite) TestTable(c *C) {
d := s.d
ctx := testNewContext(d)
tblInfo := testTableInfo(c, d, "t", 3)
job := testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
testCheckTableState(c, d, s.dbInfo, tblInfo, model.StatePublic)
testCheckJobDone(c, d, job, true)
// Create an existing table.
newTblInfo := testTableInfo(c, d, "t", 3)
doDDLJobErr(c, s.dbInfo.ID, newTblInfo.ID, model.ActionCreateTable, []interface{}{newTblInfo}, ctx, d)
count := 2000
tbl := testGetTable(c, d, s.dbInfo.ID, tblInfo.ID)
for i := 1; i <= count; i++ {
_, err := tbl.AddRecord(ctx, types.MakeDatums(i, i, i))
c.Assert(err, IsNil)
}
job = testDropTable(c, ctx, d, s.dbInfo, tblInfo)
testCheckJobDone(c, d, job, false)
// for truncate table
tblInfo = testTableInfo(c, d, "tt", 3)
job = testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
testCheckTableState(c, d, s.dbInfo, tblInfo, model.StatePublic)
testCheckJobDone(c, d, job, true)
job = testTruncateTable(c, ctx, d, s.dbInfo, tblInfo)
testCheckTableState(c, d, s.dbInfo, tblInfo, model.StatePublic)
testCheckJobDone(c, d, job, true)
// for rename table
dbInfo1 := testSchemaInfo(c, s.d, "test_rename_table")
testCreateSchema(c, testNewContext(s.d), s.d, dbInfo1)
job = testRenameTable(c, ctx, d, dbInfo1.ID, s.dbInfo.ID, tblInfo)
testCheckTableState(c, d, dbInfo1, tblInfo, model.StatePublic)
testCheckJobDone(c, d, job, true)
job = testLockTable(c, ctx, d, dbInfo1.ID, tblInfo, model.TableLockWrite)
testCheckTableState(c, d, dbInfo1, tblInfo, model.StatePublic)
testCheckJobDone(c, d, job, true)
checkTableLockedTest(c, d, dbInfo1, tblInfo, d.GetID(), ctx.GetSessionVars().ConnectionID, model.TableLockWrite)
}
func (s *testTableSuite) TestTableResume(c *C) {
d := s.d
testCheckOwner(c, d, true)
tblInfo := testTableInfo(c, d, "t1", 3)
job := &model.Job{
SchemaID: s.dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionCreateTable,
BinlogInfo: &model.HistoryInfo{},
Args: []interface{}{tblInfo},
}
testRunInterruptedJob(c, d, job)
testCheckTableState(c, d, s.dbInfo, tblInfo, model.StatePublic)
job = &model.Job{
SchemaID: s.dbInfo.ID,
TableID: tblInfo.ID,
Type: model.ActionDropTable,
BinlogInfo: &model.HistoryInfo{},
}
testRunInterruptedJob(c, d, job)
testCheckTableState(c, d, s.dbInfo, tblInfo, model.StateNone)
}