func (s *testStatSuite) TestStat(c *C) {
defer testleak.AfterTest(c)()
store := testCreateStore(c, "test_stat")
defer store.Close()
lease := 50 * time.Millisecond
d := newDDL(store, nil, nil, lease)
defer d.close()
time.Sleep(lease)
dbInfo := testSchemaInfo(c, d, "test")
testCreateSchema(c, mock.NewContext(), d, dbInfo)
m, err := d.Stats()
c.Assert(err, IsNil)
c.Assert(m[ddlOwnerID], Equals, d.uuid)
job := &model.Job{
SchemaID: dbInfo.ID,
Type: model.ActionDropSchema,
Args: []interface{}{dbInfo.Name},
}
ctx := mock.NewContext()
done := make(chan error, 1)
go func() {
done <- d.doDDLJob(ctx, job)
}()
ticker := time.NewTicker(d.lease * 1)
defer ticker.Stop()
ver := s.getDDLSchemaVer(c, d)
LOOP:
for {
select {
case <-ticker.C:
d.close()
c.Assert(s.getDDLSchemaVer(c, d), GreaterEqual, ver)
d.start()
case err := <-done:
c.Assert(err, IsNil)
m, err := d.Stats()
c.Assert(err, IsNil)
c.Assert(m[bgOwnerID], Equals, d.uuid)
break LOOP
}
}
}
func (s *testEvaluatorSuite) TestVersion(c *C) {
defer testleak.AfterTest(c)()
ctx := mock.NewContext()
v, err := builtinVersion(nil, ctx)
c.Assert(err, IsNil)
c.Assert(v.GetString(), Equals, mysql.ServerVersion)
}
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 (s *testEvaluatorSuite) TestSleep(c *C) {
defer testleak.AfterTest(c)()
ctx := mock.NewContext()
sessVars := ctx.GetSessionVars()
// non-strict model
sessVars.StrictSQLMode = false
d := make([]types.Datum, 1)
ret, err := builtinSleep(d, ctx)
c.Assert(err, IsNil)
c.Assert(ret, DeepEquals, types.NewIntDatum(0))
d[0].SetInt64(-1)
ret, err = builtinSleep(d, ctx)
c.Assert(err, IsNil)
c.Assert(ret, DeepEquals, types.NewIntDatum(0))
// for error case under the strict model
sessVars.StrictSQLMode = true
d[0].SetNull()
_, err = builtinSleep(d, ctx)
c.Assert(err, NotNil)
d[0].SetFloat64(-2.5)
_, err = builtinSleep(d, ctx)
c.Assert(err, NotNil)
// strict model
d[0].SetFloat64(0.5)
start := time.Now()
ret, err = builtinSleep(d, ctx)
c.Assert(err, IsNil)
c.Assert(ret, DeepEquals, types.NewIntDatum(0))
sub := time.Since(start)
c.Assert(sub.Nanoseconds(), GreaterEqual, int64(0.5*1e9))
}
func (t *testDistinctSuit) TestDistinct(c *C) {
tblPlan := &testTablePlan{distinctTestData, []string{"id", "name"}, 0}
p := plans.DistinctDefaultPlan{
SelectList: &plans.SelectList{
HiddenFieldOffset: len(tblPlan.GetFields()),
},
Src: tblPlan,
}
rset := rsets.Recordset{
Plan: &p,
Ctx: mock.NewContext(),
}
r := map[int][]interface{}{}
err := rset.Do(func(data []interface{}) (bool, error) {
r[data[0].(int)] = data
return true, nil
})
c.Assert(err, IsNil)
expected := map[int][]interface{}{
10: {10, "hello"},
40: {40, "hello"},
60: {60, "hello"},
}
c.Assert(reflect.DeepEqual(r, expected), Equals, true)
}
func (s *testAggFuncSuite) TestCount(c *C) {
// Compose aggregate exec for "select c1, count(c2) from t";
// c1 c2
// 1 1
// 2 1
// 3 nil
c1 := ast.NewValueExpr(0)
rf1 := &ast.ResultField{Expr: c1}
col1 := &ast.ColumnNameExpr{Refer: rf1}
fc1 := &ast.AggregateFuncExpr{
F: ast.AggFuncFirstRow,
Args: []ast.ExprNode{col1},
}
c2 := ast.NewValueExpr(0)
rf2 := &ast.ResultField{Expr: c2}
col2 := &ast.ColumnNameExpr{Refer: rf2}
fc2 := &ast.AggregateFuncExpr{
F: ast.AggFuncCount,
Args: []ast.ExprNode{col2},
}
row1 := []interface{}{1, 1}
row2 := []interface{}{2, 1}
row3 := []interface{}{3, nil}
data := []([]interface{}){row1, row2, row3}
rows := make([]*Row, 0, 3)
for _, d := range data {
rows = append(rows, &Row{Data: d})
}
src := &mockExec{
rows: rows,
fields: []*ast.ResultField{rf1, rf2},
}
agg := &AggregateExec{
AggFuncs: []*ast.AggregateFuncExpr{fc1, fc2},
Src: src,
}
var (
row *Row
cnt int
)
for {
r, err := agg.Next()
c.Assert(err, IsNil)
if r == nil {
break
}
row = r
cnt++
}
c.Assert(cnt, Equals, 1)
c.Assert(row, NotNil)
ctx := mock.NewContext()
val, err := evaluator.Eval(ctx, fc1)
c.Assert(err, IsNil)
c.Assert(val, Equals, 1)
val, err = evaluator.Eval(ctx, fc2)
c.Assert(err, IsNil)
c.Assert(val, Equals, int64(2))
}
func (s *testEvaluatorSuite) TestRegexp(c *C) {
tbl := []struct {
pattern string
input string
match int64
}{
{"^$", "a", 0},
{"a", "a", 1},
{"a", "b", 0},
{"aA", "aA", 1},
{".", "a", 1},
{"^.$", "ab", 0},
{"..", "b", 0},
{".ab", "aab", 1},
{".*", "abcd", 1},
}
ctx := mock.NewContext()
for _, v := range tbl {
pattern := &ast.PatternRegexpExpr{
Pattern: ast.NewValueExpr(v.pattern),
Expr: ast.NewValueExpr(v.input),
}
match, err := Eval(ctx, pattern)
c.Assert(err, IsNil)
c.Assert(match, Equals, v.match, Commentf("%v", v))
}
}
func (s *testSchemaSuite) TestSchema(c *C) {
store := testCreateStore(c, "test_schema")
defer store.Close()
lease := 100 * time.Millisecond
d1 := newDDL(store, nil, nil, lease)
defer d1.close()
ctx := mock.NewContext()
dbInfo := testSchemaInfo(c, d1, "test")
job := testCreateSchema(c, ctx, d1, dbInfo)
testCheckSchemaState(c, d1, dbInfo, model.StatePublic)
testCheckJobDone(c, d1, job, true)
job = testDropSchema(c, ctx, d1, dbInfo)
testCheckSchemaState(c, d1, dbInfo, model.StateNone)
testCheckJobDone(c, d1, job, false)
job = &model.Job{
SchemaID: dbInfo.ID,
Type: model.ActionDropSchema,
}
err := d1.startDDLJob(ctx, job)
c.Assert(terror.ErrorEqual(err, infoschema.DatabaseNotExists), IsTrue)
}
func (p *testShowSuit) SetUpSuite(c *C) {
nc := mock.NewContext()
p.ctx = nc
variable.BindSessionVars(p.ctx)
variable.BindGlobalVarAccessor(p.ctx, nc)
variable.RegisterStatistics(p.ms)
p.dbName = "testshowplan"
p.store = newStore(c, p.dbName)
p.txn, _ = p.store.Begin()
se := newSession(c, p.store, p.dbName)
p.createDBSQL = fmt.Sprintf("create database if not exists %s;", p.dbName)
p.dropDBSQL = fmt.Sprintf("drop database if exists %s;", p.dbName)
p.useDBSQL = fmt.Sprintf("use %s;", p.dbName)
p.createTableSQL = `CREATE TABLE test(id INT NOT NULL DEFAULT 1, name varchar(255), PRIMARY KEY(id));`
mustExecSQL(c, se, p.createDBSQL)
mustExecSQL(c, se, p.useDBSQL)
mustExecSQL(c, se, p.createTableSQL)
p.createSystemDBSQL = fmt.Sprintf("create database if not exists %s;", mysql.SystemDB)
p.createUserTableSQL = tidb.CreateUserTable
p.createDBPrivTableSQL = tidb.CreateDBPrivTable
p.createTablePrivTableSQL = tidb.CreateTablePrivTable
p.createColumnPrivTableSQL = tidb.CreateColumnPrivTable
mustExecSQL(c, se, p.createSystemDBSQL)
mustExecSQL(c, se, p.createUserTableSQL)
mustExecSQL(c, se, p.createDBPrivTableSQL)
mustExecSQL(c, se, p.createTablePrivTableSQL)
mustExecSQL(c, se, p.createColumnPrivTableSQL)
}
func (s *testPlanSuite) TestTableScanWithOrder(c *C) {
defer testleak.AfterTest(c)()
// Sort result by scanning PKHandle column.
sql := "select * from t order by a limit 1;"
stmt, err := s.ParseOneStmt(sql, "", "")
c.Assert(err, IsNil)
ast.SetFlag(stmt)
err = newMockResolve(stmt)
c.Assert(err, IsNil)
builder := &planBuilder{
allocator: new(idAllocator),
ctx: mock.NewContext(),
colMapper: make(map[*ast.ColumnNameExpr]int),
}
p := builder.build(stmt)
c.Assert(builder.err, IsNil)
logic, ok := p.(LogicalPlan)
c.Assert(ok, IsTrue)
// Get physical plan.
_, pp, _, err := logic.convert2PhysicalPlan(nil)
c.Assert(err, IsNil)
// Limit->Projection->PhysicalTableScan
// Get PhysicalTableScan plan.
cpp, ok := pp.p.GetChildByIndex(0).GetChildByIndex(0).(*PhysicalTableScan)
c.Assert(cpp, NotNil)
c.Assert(ok, IsTrue)
// Make sure KeepOrder is true.
c.Assert(cpp.KeepOrder, IsTrue)
}
func (t *testWhereSuit) TestWhere(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
pln := &plans.FilterDefaultPlan{
Plan: tblPlan,
Expr: &expression.BinaryOperation{
Op: opcode.GE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
ReferScope: expression.IdentReferFromTable,
ReferIndex: 0,
},
R: expression.Value{
Val: 30,
},
},
}
cnt := 0
rset := rsets.Recordset{Plan: pln,
Ctx: mock.NewContext()}
rset.Do(func(data []interface{}) (bool, error) {
cnt++
return true, nil
})
c.Assert(cnt, Equals, 2)
}
func (t *testOrderBySuit) TestOrderBy(c *C) {
tblPlan := &testTablePlan{t.data, []string{"id", "name"}, 0}
pln := &plans.OrderByDefaultPlan{
SelectList: &plans.SelectList{
HiddenFieldOffset: len(tblPlan.GetFields()),
ResultFields: tblPlan.GetFields(),
},
Src: tblPlan,
By: []expression.Expression{
&expression.Ident{
CIStr: model.NewCIStr("id"),
},
},
Ascs: []bool{false},
}
prev := 10000
rset := rsets.Recordset{
Plan: pln,
Ctx: mock.NewContext(),
}
err := rset.Do(func(data []interface{}) (bool, error) {
// DESC
if data[0].(int) > prev {
c.Error("should no be here", data[0], prev)
}
prev = data[0].(int)
return true, nil
})
if err != nil {
log.Error(err)
}
}
func (s *testStmtSuite) SetUpTest(c *C) {
log.SetLevelByString("error")
s.dbName = "teststmts"
var err error
s.testDB, err = sql.Open(tidb.DriverName, tidb.EngineGoLevelDBMemory+"/"+s.dbName+"/"+s.dbName)
c.Assert(err, IsNil)
// create db
s.createDBSql = fmt.Sprintf("create database if not exists %s;", s.dbName)
s.dropDBSql = fmt.Sprintf("drop database if exists %s;", s.dbName)
s.useDBSql = fmt.Sprintf("use %s;", s.dbName)
s.createTableSql = `
CREATE TABLE test(id INT NOT NULL DEFAULT 1, name varchar(255), PRIMARY KEY(id));
CREATE TABLE test1(id INT NOT NULL DEFAULT 2, name varchar(255), PRIMARY KEY(id), INDEX name(name));
CREATE TABLE test2(id INT NOT NULL DEFAULT 3, name varchar(255), PRIMARY KEY(id));`
s.selectSql = `SELECT * from test limit 2;`
mustExec(c, s.testDB, s.createDBSql)
mustExec(c, s.testDB, s.useDBSql)
s.createSystemDBSQL = fmt.Sprintf("create database if not exists %s;", mysql.SystemDB)
s.createUserTableSQL = tidb.CreateUserTable
s.createDBPrivTableSQL = tidb.CreateDBPrivTable
s.createTablePrivTableSQL = tidb.CreateTablePrivTable
s.createColumnPrivTableSQL = tidb.CreateColumnPrivTable
mustExec(c, s.testDB, s.createSystemDBSQL)
mustExec(c, s.testDB, s.createUserTableSQL)
mustExec(c, s.testDB, s.createDBPrivTableSQL)
mustExec(c, s.testDB, s.createTablePrivTableSQL)
mustExec(c, s.testDB, s.createColumnPrivTableSQL)
s.ctx = mock.NewContext()
variable.BindSessionVars(s.ctx)
}
func (s *testStmtSuite) TestSetCharsetStmt(c *C) {
testSQL := `SET NAMES utf8;`
stmtList, err := tidb.Compile(testSQL)
c.Assert(err, IsNil)
c.Assert(stmtList, HasLen, 1)
testStmt, ok := stmtList[0].(*stmts.SetCharsetStmt)
c.Assert(ok, IsTrue)
c.Assert(testStmt.IsDDL(), IsFalse)
c.Assert(len(testStmt.OriginText()), Greater, 0)
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
sessionVars := variable.GetSessionVars(ctx)
for _, v := range variable.SetNamesVariables {
c.Assert(sessionVars.Systems[v] != "utf8", IsTrue)
}
_, err = testStmt.Exec(ctx)
c.Assert(err, IsNil)
for _, v := range variable.SetNamesVariables {
c.Assert(sessionVars.Systems[v], Equals, "utf8")
}
c.Assert(sessionVars.Systems[variable.CollationConnection], Equals, "utf8_general_ci")
mf := newMockFormatter()
testStmt.Explain(nil, mf)
c.Assert(mf.Len(), Greater, 0)
}
func (s *testEvaluatorSuite) TestCast(c *C) {
f := types.NewFieldType(mysql.TypeLonglong)
expr := &ast.FuncCastExpr{
Expr: ast.NewValueExpr(1),
Tp: f,
}
ctx := mock.NewContext()
v, err := Eval(ctx, expr)
c.Assert(err, IsNil)
c.Assert(v, Equals, int64(1))
f.Flag |= mysql.UnsignedFlag
v, err = Eval(ctx, expr)
c.Assert(err, IsNil)
c.Assert(v, Equals, uint64(1))
f.Tp = mysql.TypeString
f.Charset = charset.CharsetBin
v, err = Eval(ctx, expr)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, []byte("1"))
f.Tp = mysql.TypeString
f.Charset = "utf8"
v, err = Eval(ctx, expr)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, "1")
expr.Expr = ast.NewValueExpr(nil)
v, err = Eval(ctx, expr)
c.Assert(err, IsNil)
c.Assert(v, IsNil)
}
func (s *testColumnSuite) TearDownSuite(c *C) {
testDropSchema(c, mock.NewContext(), s.d, s.dbInfo)
s.d.close()
err := s.store.Close()
c.Assert(err, IsNil)
}
func (t *testHavingPlan) TestHaving(c *C) {
tblPlan := &testTablePlan{groupByTestData, []string{"id", "name"}, 0}
havingPlan := &plans.HavingPlan{
Src: tblPlan,
Expr: &expression.BinaryOperation{
Op: opcode.GE,
L: &expression.Ident{
CIStr: model.NewCIStr("id"),
},
R: &expression.Value{
Val: 20,
},
},
}
// having's behavior just like where
cnt := 0
rset := rsets.Recordset{
Plan: havingPlan,
Ctx: mock.NewContext(),
}
rset.Do(func(data []interface{}) (bool, error) {
cnt++
return true, nil
})
c.Assert(cnt, Equals, 2)
}
func (s *testColumnSuite) SetUpSuite(c *C) {
s.store = testCreateStore(c, "test_column")
s.d = newDDL(s.store, nil, nil, testLease)
s.dbInfo = testSchemaInfo(c, s.d, "test_column")
testCreateSchema(c, mock.NewContext(), s.d, s.dbInfo)
}
func mockContext() context.Context {
ctx := mock.NewContext()
ctx.Store = &mockStore{
client: &mockClient{},
}
return ctx
}
func (s *testEvaluatorSuite) TestTrim(c *C) {
tbl := []struct {
str interface{}
remstr interface{}
dir ast.TrimDirectionType
result interface{}
}{
{" bar ", nil, ast.TrimBothDefault, "bar"},
{"xxxbarxxx", "x", ast.TrimLeading, "barxxx"},
{"xxxbarxxx", "x", ast.TrimBoth, "bar"},
{"barxxyz", "xyz", ast.TrimTrailing, "barx"},
{nil, "xyz", ast.TrimBoth, nil},
{1, 2, ast.TrimBoth, "1"},
{" \t\rbar\n ", nil, ast.TrimBothDefault, "bar"},
}
ctx := mock.NewContext()
for _, v := range tbl {
f := &ast.FuncTrimExpr{
Str: ast.NewValueExpr(v.str),
Direction: v.dir,
}
if v.remstr != nil {
f.RemStr = ast.NewValueExpr(v.remstr)
}
r, err := Eval(ctx, f)
c.Assert(err, IsNil)
c.Assert(r, Equals, v.result)
}
}
func (s *testDDLSuite) TestDropTableError(c *C) {
defer testleak.AfterTest(c)()
store := testCreateStore(c, "test_drop_table")
defer store.Close()
d := newDDL(store, nil, nil, testLease)
defer d.close()
dbInfo := testSchemaInfo(c, d, "test")
testCreateSchema(c, mock.NewContext(), d, dbInfo)
job := &model.Job{
SchemaID: dbInfo.ID,
Type: model.ActionDropTable,
Args: []interface{}{&model.TableInfo{
ID: 1,
Name: model.CIStr{O: "t"},
}},
}
err := kv.RunInNewTxn(store, false, func(txn kv.Transaction) error {
t := meta.NewMeta(txn)
return d.prepareBgJob(t, job)
})
c.Check(err, IsNil)
d.startBgJob(job.Type)
time.Sleep(testLease * 3)
verifyBgJobState(c, d, job, model.JobDone)
}
func (s *testEvaluatorSuite) TestSubstring(c *C) {
tbl := []struct {
str string
pos int64
slen int64
result string
}{
{"Quadratically", 5, -1, "ratically"},
{"foobarbar", 4, -1, "barbar"},
{"Quadratically", 5, 6, "ratica"},
{"Sakila", -3, -1, "ila"},
{"Sakila", -5, 3, "aki"},
{"Sakila", -4, 2, "ki"},
{"Sakila", 1000, 2, ""},
{"", 2, 3, ""},
}
ctx := mock.NewContext()
for _, v := range tbl {
f := &ast.FuncSubstringExpr{
StrExpr: ast.NewValueExpr(v.str),
Pos: ast.NewValueExpr(v.pos),
}
if v.slen != -1 {
f.Len = ast.NewValueExpr(v.slen)
}
r, err := Eval(ctx, f)
c.Assert(err, IsNil)
s, ok := r.(string)
c.Assert(ok, IsTrue)
c.Assert(s, Equals, v.result)
r1, err := Eval(ctx, f)
c.Assert(err, IsNil)
s1, ok := r1.(string)
c.Assert(ok, IsTrue)
c.Assert(s, Equals, s1)
}
errTbl := []struct {
str interface{}
pos interface{}
len interface{}
result string
}{
{1, 5, -1, "ratically"},
{"foobarbar", "4", -1, "barbar"},
{"Quadratically", 5, "6", "ratica"},
}
for _, v := range errTbl {
f := &ast.FuncSubstringExpr{
StrExpr: ast.NewValueExpr(v.str),
Pos: ast.NewValueExpr(v.pos),
}
if v.len != -1 {
f.Len = ast.NewValueExpr(v.len)
}
_, err := Eval(ctx, f)
c.Assert(err, NotNil)
}
}
func (s *testEvaluatorSuite) TestBinopBitop(c *C) {
ctx := mock.NewContext()
tbl := []struct {
lhs interface{}
op opcode.Op
rhs interface{}
ret interface{}
}{
{1, opcode.And, 1, 1},
{1, opcode.Or, 1, 1},
{1, opcode.Xor, 1, 0},
{1, opcode.LeftShift, 1, 2},
{2, opcode.RightShift, 1, 1},
{nil, opcode.And, 1, nil},
{1, opcode.And, nil, nil},
{nil, opcode.Or, 1, nil},
{nil, opcode.Xor, 1, nil},
{nil, opcode.LeftShift, 1, nil},
{nil, opcode.RightShift, 1, nil},
}
for _, t := range tbl {
expr := &ast.BinaryOperationExpr{Op: t.op, L: ast.NewValueExpr(t.lhs), R: ast.NewValueExpr(t.rhs)}
v, err := Eval(ctx, expr)
c.Assert(err, IsNil)
switch x := t.ret.(type) {
case nil:
c.Assert(v, IsNil)
case int:
c.Assert(v, DeepEquals, uint64(x))
}
}
}
func (s *testDDLSuite) TestDropTableError(c *C) {
defer testleak.AfterTest(c)()
store := testCreateStore(c, "test_drop_table")
defer store.Close()
lease := 50 * time.Millisecond
d := newDDL(store, nil, nil, lease)
defer d.close()
dbInfo := testSchemaInfo(c, d, "test")
testCreateSchema(c, mock.NewContext(), d, dbInfo)
job := &model.Job{
SchemaID: dbInfo.ID,
Type: model.ActionDropTable,
Args: []interface{}{&model.TableInfo{
ID: 1,
Name: model.CIStr{O: "t"},
}},
}
d.prepareBgJob(job)
d.startBgJob(job.Type)
time.Sleep(lease)
verifyBgJobState(c, d, job, model.JobDone)
}
func (s *testSchemaSuite) TestSchema(c *C) {
defer testleak.AfterTest(c)()
store := testCreateStore(c, "test_schema")
defer store.Close()
d1 := newDDL(store, nil, nil, testLease)
defer d1.close()
ctx := mock.NewContext()
dbInfo := testSchemaInfo(c, d1, "test")
job := testCreateSchema(c, ctx, d1, dbInfo)
testCheckSchemaState(c, d1, dbInfo, model.StatePublic)
testCheckJobDone(c, d1, job, true)
job = testDropSchema(c, ctx, d1, dbInfo)
testCheckSchemaState(c, d1, dbInfo, model.StateNone)
testCheckJobDone(c, d1, job, false)
job = &model.Job{
SchemaID: dbInfo.ID,
Type: model.ActionDropSchema,
}
err := d1.doDDLJob(ctx, job)
c.Assert(terror.ErrorEqual(err, infoschema.ErrDatabaseDropExists), IsTrue)
}
func (s *testPlanSuite) TestJoinReOrder(c *C) {
defer testleak.AfterTest(c)()
cases := []struct {
sql string
best string
}{
{
sql: "select * from t t1, t t2, t t3, t t4, t t5, t t6 where t1.a = t2.b and t2.a = t3.b and t3.c = t4.a and t4.d = t2.c and t5.d = t6.d",
best: "LeftHashJoin{LeftHashJoin{LeftHashJoin{LeftHashJoin{Table(t)->Table(t)}(t1.a,t2.b)->Table(t)}(t2.a,t3.b)->Table(t)}(t3.c,t4.a)(t2.c,t4.d)->LeftHashJoin{Table(t)->Table(t)}(t5.d,t6.d)}->Projection",
},
{
sql: "select * from t t1, t t2, t t3, t t4, t t5, t t6, t t7, t t8 where t1.a = t8.a",
best: "LeftHashJoin{LeftHashJoin{LeftHashJoin{LeftHashJoin{Table(t)->Table(t)}(t1.a,t8.a)->Table(t)}->LeftHashJoin{Table(t)->Table(t)}}->LeftHashJoin{LeftHashJoin{Table(t)->Table(t)}->Table(t)}}->Projection",
},
{
sql: "select * from t t1, t t2, t t3, t t4, t t5 where t1.a = t5.a and t5.a = t4.a and t4.a = t3.a and t3.a = t2.a and t2.a = t1.a and t1.a = t3.a and t2.a = t4.a and t5.b < 8",
best: "LeftHashJoin{LeftHashJoin{LeftHashJoin{RightHashJoin{Table(t)->Selection->Table(t)}(t5.a,t1.a)->Table(t)}(t1.a,t2.a)->Table(t)}(t2.a,t3.a)(t1.a,t3.a)->Table(t)}(t5.a,t4.a)(t3.a,t4.a)(t2.a,t4.a)->Projection",
},
{
sql: "select * from t t1, t t2, t t3, t t4, t t5 where t1.a = t5.a and t5.a = t4.a and t4.a = t3.a and t3.a = t2.a and t2.a = t1.a and t1.a = t3.a and t2.a = t4.a and t3.b = 1 and t4.a = 1",
best: "LeftHashJoin{LeftHashJoin{LeftHashJoin{Table(t)->Selection->Table(t)}->LeftHashJoin{Table(t)->Table(t)}}->Table(t)}->Projection",
},
{
sql: "select * from t o where o.b in (select t3.c from t t1, t t2, t t3 where t1.a = t3.a and t2.a = t3.a and t2.a = o.a)",
best: "Table(t)->Apply(LeftHashJoin{RightHashJoin{Table(t)->Selection->Table(t)}(t2.a,t3.a)->Table(t)}(t3.a,t1.a)->Projection)->Selection->Projection",
},
{
sql: "select * from t o where o.b in (select t3.c from t t1, t t2, t t3 where t1.a = t3.a and t2.a = t3.a and t2.a = o.a and t1.a = 1)",
best: "Table(t)->Apply(LeftHashJoin{LeftHashJoin{Table(t)->Table(t)}->Table(t)->Selection}->Projection)->Selection->Projection",
},
}
for _, ca := range cases {
comment := Commentf("for %s", ca.sql)
stmt, err := s.ParseOneStmt(ca.sql, "", "")
c.Assert(err, IsNil, comment)
ast.SetFlag(stmt)
err = mockResolve(stmt)
c.Assert(err, IsNil)
builder := &planBuilder{
allocator: new(idAllocator),
ctx: mock.NewContext(),
colMapper: make(map[*ast.ColumnNameExpr]int),
}
p := builder.build(stmt)
c.Assert(builder.err, IsNil)
lp := p.(LogicalPlan)
_, lp, err = lp.PredicatePushDown(nil)
c.Assert(err, IsNil)
_, err = lp.PruneColumnsAndResolveIndices(lp.GetSchema())
c.Assert(err, IsNil)
_, res, _, err := lp.convert2PhysicalPlan(nil)
c.Assert(err, IsNil)
p = res.p.PushLimit(nil)
c.Assert(ToString(p), Equals, ca.best, Commentf("for %s", ca.sql))
}
}
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 (s *testTableSuite) SetUpSuite(c *C) {
s.store = testCreateStore(c, "test_table")
lease := 50 * time.Millisecond
s.d = newDDL(s.store, nil, nil, lease)
s.dbInfo = testSchemaInfo(c, s.d, "test")
testCreateSchema(c, mock.NewContext(), s.d, s.dbInfo)
}
func (p *testShowSuit) SetUpSuite(c *C) {
var err error
store, err := tidb.NewStore(tidb.EngineGoLevelDBMemory)
c.Assert(err, IsNil)
p.ctx = mock.NewContext()
p.txn, _ = store.Begin()
variable.BindSessionVars(p.ctx)
}
func (s *testPlanSuite) TestAllocID(c *C) {
pA := &DataSource{baseLogicalPlan: newBaseLogicalPlan(Tbl, new(idAllocator))}
pB := &DataSource{baseLogicalPlan: newBaseLogicalPlan(Tbl, new(idAllocator))}
ctx := mock.NewContext()
pA.initIDAndContext(ctx)
pB.initIDAndContext(ctx)
c.Assert(pA.id, Equals, pB.id)
}