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)
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
if err != nil {
return nil, err
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatusFlag(mysql.ServerStatusAutocommit, true)
sessionMu.Lock()
defer sessionMu.Unlock()
_, ok := storeBootstrapped[store.UUID()]
if !ok {
bootstrap(s)
storeBootstrapped[store.UUID()] = true
}
// Add auth here
return s, nil
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
if err != nil {
return nil, err
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatusFlag(mysql.ServerStatusAutocommit, true)
// session implements variable.GlobalVarAccessor. Bind it to ctx.
variable.BindGlobalVarAccessor(s, s)
// session implements autocommit.Checker. Bind it to ctx
autocommit.BindAutocommitChecker(s, s)
sessionMu.Lock()
defer sessionMu.Unlock()
_, ok := storeBootstrapped[store.UUID()]
if !ok {
s.initing = true
bootstrap(s)
s.initing = false
storeBootstrapped[store.UUID()] = true
}
// TODO: Add auth here
privChecker := &privileges.UserPrivileges{}
privilege.BindPrivilegeChecker(s, privChecker)
return s, nil
}
func (p *testFromSuit) SetUpSuite(c *C) {
store, err := tidb.NewStore(tidb.EngineGoLevelDBMemory)
c.Assert(err, IsNil)
p.vars = map[string]interface{}{}
p.txn, _ = store.Begin()
p.cols = []*column.Col{
{
ColumnInfo: model.ColumnInfo{
ID: 0,
Name: model.NewCIStr("id"),
Offset: 0,
DefaultValue: 0,
FieldType: *types.NewFieldType(mysql.TypeLonglong),
},
},
{
ColumnInfo: model.ColumnInfo{
ID: 1,
Name: model.NewCIStr("name"),
Offset: 1,
DefaultValue: nil,
FieldType: *types.NewFieldType(mysql.TypeVarchar),
},
},
}
p.tbl = tables.NewTable(1, "t", "test", p.cols, &simpleAllocator{})
variable.BindSessionVars(p)
var i int64
for i = 0; i < 10; i++ {
p.tbl.AddRecord(p, []interface{}{i * 10, "hello"})
}
}
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 *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 (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 (p *testShowSuit) SetUpSuite(c *C) {
var err error
store, err := tidb.NewStore(tidb.EngineGoLevelDBMemory)
c.Assert(err, IsNil)
p.vars = map[string]interface{}{}
p.txn, _ = store.Begin()
variable.BindSessionVars(p)
}
func (s *testEvaluatorSuite) TestCurrentUser(c *C) {
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
sessionVars := variable.GetSessionVars(ctx)
sessionVars.User = "******"
d, err := builtinCurrentUser(types.MakeDatums(), ctx)
c.Assert(err, IsNil)
c.Assert(d.GetString(), Equals, "root@localhost")
}
func (s *testEvaluatorSuite) TestConnectionID(c *C) {
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
sessionVars := variable.GetSessionVars(ctx)
sessionVars.ConnectionID = uint64(1)
d, err := builtinConnectionID(types.MakeDatums(), ctx)
c.Assert(err, IsNil)
c.Assert(d.GetUint64(), Equals, uint64(1))
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
debugInfos: make(map[string]interface{}),
maxRetryCnt: 10,
parser: parser.New(),
}
domain, err := domap.Get(store)
if err != nil {
return nil, errors.Trace(err)
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatusFlag(mysql.ServerStatusAutocommit, true)
// session implements variable.GlobalVarAccessor. Bind it to ctx.
variable.BindGlobalVarAccessor(s, s)
// session implements autocommit.Checker. Bind it to ctx
autocommit.BindAutocommitChecker(s, s)
sessionMu.Lock()
defer sessionMu.Unlock()
ver := getStoreBootstrapVersion(store)
if ver == notBootstrapped {
// if no bootstrap and storage is remote, we must use a little lease time to
// bootstrap quickly, after bootstrapped, we will reset the lease time.
// TODO: Using a bootstap tool for doing this may be better later.
if !localstore.IsLocalStore(store) {
sessionctx.GetDomain(s).SetLease(chooseMinLease(100*time.Millisecond, schemaLease))
}
s.SetValue(context.Initing, true)
bootstrap(s)
s.ClearValue(context.Initing)
if !localstore.IsLocalStore(store) {
sessionctx.GetDomain(s).SetLease(schemaLease)
}
finishBootstrap(store)
} else if ver < currentBootstrapVersion {
s.SetValue(context.Initing, true)
upgrade(s)
s.ClearValue(context.Initing)
}
// TODO: Add auth here
privChecker := &privileges.UserPrivileges{}
privilege.BindPrivilegeChecker(s, privChecker)
return s, nil
}
func (s *testEvaluatorSuite) TestFoundRows(c *C) {
ctx := mock.NewContext()
d, err := builtinFoundRows(types.MakeDatums(), ctx)
c.Assert(err, NotNil)
variable.BindSessionVars(ctx)
d, err = builtinFoundRows(types.MakeDatums(), ctx)
c.Assert(err, IsNil)
c.Assert(d.GetUint64(), Equals, uint64(0))
}
func newMockResolve(node ast.Node) error {
indices := []*model.IndexInfo{
{
Name: model.NewCIStr("b"),
Columns: []*model.IndexColumn{
{
Name: model.NewCIStr("b"),
},
},
},
{
Name: model.NewCIStr("c_d_e"),
Columns: []*model.IndexColumn{
{
Name: model.NewCIStr("c"),
},
{
Name: model.NewCIStr("d"),
},
{
Name: model.NewCIStr("e"),
},
},
},
}
pkColumn := &model.ColumnInfo{
State: model.StatePublic,
Name: model.NewCIStr("a"),
}
col0 := &model.ColumnInfo{
State: model.StatePublic,
Name: model.NewCIStr("b"),
}
col1 := &model.ColumnInfo{
State: model.StatePublic,
Name: model.NewCIStr("c"),
}
col2 := &model.ColumnInfo{
State: model.StatePublic,
Name: model.NewCIStr("d"),
}
pkColumn.Flag = mysql.PriKeyFlag
table := &model.TableInfo{
Columns: []*model.ColumnInfo{pkColumn, col0, col1, col2},
Indices: indices,
Name: model.NewCIStr("t"),
PKIsHandle: true,
}
is := infoschema.MockInfoSchema([]*model.TableInfo{table})
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
return MockResolveName(node, is, "test", ctx)
}
func (p *testIndexSuit) SetUpSuite(c *C) {
store, err := tidb.NewStore(tidb.EngineGoLevelDBMemory)
c.Assert(err, IsNil)
p.store = store
p.vars = map[string]interface{}{}
p.txn, _ = p.store.Begin()
p.cols = []*column.Col{
{
ColumnInfo: model.ColumnInfo{
ID: 0,
Name: model.NewCIStr("id"),
Offset: 0,
DefaultValue: 0,
FieldType: *types.NewFieldType(mysql.TypeLonglong),
},
},
{
ColumnInfo: model.ColumnInfo{
ID: 1,
Name: model.NewCIStr("name"),
Offset: 1,
DefaultValue: nil,
FieldType: *types.NewFieldType(mysql.TypeVarchar),
},
},
}
p.tbl = tables.NewTable(2, "t2", "test", p.cols, &simpleAllocator{})
idxCol := &column.IndexedCol{
IndexInfo: model.IndexInfo{
Name: model.NewCIStr("id"),
Table: model.NewCIStr("t2"),
Columns: []*model.IndexColumn{
{
Name: model.NewCIStr("id"),
Offset: 0,
Length: 0,
},
},
Unique: false,
Primary: false,
},
X: kv.NewKVIndex("i", "id", false),
}
p.tbl.AddIndex(idxCol)
variable.BindSessionVars(p)
var i int64
for i = 0; i < 10; i++ {
p.tbl.AddRecord(p, []interface{}{i * 10, "hello"})
}
}
func (s *testBuiltinSuite) TestConnectionID(c *C) {
ctx := mock.NewContext()
m := map[interface{}]interface{}{}
variable.BindSessionVars(ctx)
sessionVars := variable.GetSessionVars(ctx)
sessionVars.ConnectionID = uint64(1)
m[ExprEvalArgCtx] = ctx
v, err := builtinConnectionID(nil, m)
c.Assert(err, IsNil)
c.Assert(v, Equals, uint64(1))
}
func (s *testBuiltinSuite) TestCurrentUser(c *C) {
ctx := mock.NewContext()
m := map[interface{}]interface{}{}
variable.BindSessionVars(ctx)
sessionVars := variable.GetSessionVars(ctx)
sessionVars.User = "******"
m[ExprEvalArgCtx] = ctx
v, err := builtinCurrentUser(nil, m)
c.Assert(err, IsNil)
c.Assert(v, Equals, "root@localhost")
}
func (s *testBuiltinSuite) TestFoundRows(c *C) {
ctx := newMockCtx()
m := map[interface{}]interface{}{}
v, err := builtinFoundRows(nil, m)
c.Assert(err, NotNil)
variable.BindSessionVars(ctx)
m[ExprEvalArgCtx] = ctx
v, err = builtinFoundRows(nil, m)
c.Assert(err, IsNil)
c.Assert(v, Equals, uint64(0))
}
// CreateSession creates a new session environment.
func CreateSession(store kv.Storage) (Session, error) {
s := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
if err != nil {
return nil, err
}
sessionctx.BindDomain(s, domain)
variable.BindSessionVars(s)
variable.GetSessionVars(s).SetStatus(mysql.ServerStatusAutocommit)
return s, nil
}
func (s *testStmtSuite) TestExplain(c *C) {
testSQL := "explain select 1"
stmtList, err := tidb.Compile(s.ctx, testSQL)
c.Assert(err, IsNil)
c.Assert(stmtList, HasLen, 1)
testStmt, ok := stmtList[0].(*stmts.ExplainStmt)
c.Assert(ok, IsTrue)
c.Assert(testStmt.IsDDL(), IsFalse)
c.Assert(len(testStmt.OriginText()), Greater, 0)
newTestSql := "explain " + testSQL
newTestStmt := &stmts.ExplainStmt{S: testStmt, Text: newTestSql}
mf := newMockFormatter()
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
newTestStmt.Explain(ctx, mf)
c.Assert(mf.Len(), Greater, 0)
_, err = testStmt.Exec(ctx)
c.Assert(err, IsNil)
showColumnSQL := "desc t;"
stmtList, err = tidb.Compile(s.ctx, showColumnSQL)
c.Assert(err, IsNil)
c.Assert(stmtList, HasLen, 1)
testStmt, ok = stmtList[0].(*stmts.ExplainStmt)
c.Assert(ok, IsTrue)
showStmt, ok := testStmt.S.(*stmts.ShowStmt)
c.Assert(ok, IsTrue)
// Mock DBName for ShowStmt
showStmt.DBName = "test"
mf = newMockFormatter()
testStmt.Explain(ctx, mf)
c.Assert(mf.Len(), Greater, 0)
_, err = testStmt.Exec(ctx)
c.Assert(err, IsNil)
}
func (*testSessionSuite) TestSession(c *C) {
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
v := variable.GetSessionVars(ctx)
c.Assert(v, NotNil)
// For AffectedRows
v.AddAffectedRows(1)
c.Assert(v.AffectedRows, Equals, uint64(1))
v.AddAffectedRows(1)
c.Assert(v.AffectedRows, Equals, uint64(2))
// For FoundRows
v.AddFoundRows(1)
c.Assert(v.FoundRows, Equals, uint64(1))
v.AddFoundRows(1)
c.Assert(v.FoundRows, Equals, uint64(2))
// For last insert id
v.SetLastInsertID(uint64(1))
c.Assert(v.LastInsertID, Equals, uint64(1))
v.SetSystemVar("autocommit", types.NewStringDatum("1"))
val := v.GetSystemVar("autocommit")
c.Assert(val.GetString(), Equals, "1")
c.Assert(v.SetSystemVar("autocommit", types.Datum{}), NotNil)
v.SetSystemVar("sql_mode", types.NewStringDatum("strict_trans_tables"))
val = v.GetSystemVar("sql_mode")
c.Assert(val.GetString(), Equals, "STRICT_TRANS_TABLES")
c.Assert(v.StrictSQLMode, IsTrue)
v.SetSystemVar("sql_mode", types.NewStringDatum(""))
c.Assert(v.StrictSQLMode, IsFalse)
v.SetSystemVar("character_set_connection", types.NewStringDatum("utf8"))
v.SetSystemVar("collation_connection", types.NewStringDatum("utf8_general_ci"))
charset, collation := variable.GetCharsetInfo(ctx)
c.Assert(charset, Equals, "utf8")
c.Assert(collation, Equals, "utf8_general_ci")
c.Assert(v.SetSystemVar("character_set_results", types.Datum{}), IsNil)
}
// Create a new session on store but only do ddl works.
func (s *testSessionSuite) bootstrapWithError(store kv.Storage, c *C) {
ss := &session{
values: make(map[fmt.Stringer]interface{}),
store: store,
sid: atomic.AddInt64(&sessionID, 1),
}
domain, err := domap.Get(store)
c.Assert(err, IsNil)
sessionctx.BindDomain(ss, domain)
variable.BindSessionVars(ss)
variable.GetSessionVars(ss).SetStatusFlag(mysql.ServerStatusAutocommit, true)
// session implements autocommit.Checker. Bind it to ctx
autocommit.BindAutocommitChecker(ss, ss)
sessionMu.Lock()
defer sessionMu.Unlock()
b, err := checkBootstrapped(ss)
c.Assert(b, IsFalse)
c.Assert(err, IsNil)
doDDLWorks(ss)
// Leave dml unfinished.
}
func (p *testFromSuit) SetUpSuite(c *C) {
store, err := tidb.NewStore(tidb.EngineGoLevelDBMemory)
c.Assert(err, IsNil)
p.vars = map[string]interface{}{}
p.txn, _ = store.Begin()
tbInfo := &model.TableInfo{
ID: 1,
Name: model.NewCIStr("t"),
State: model.StatePublic,
Columns: []*model.ColumnInfo{
{
ID: 0,
Name: model.NewCIStr("id"),
Offset: 0,
DefaultValue: 0,
FieldType: *types.NewFieldType(mysql.TypeLonglong),
State: model.StatePublic,
},
{
ID: 1,
Name: model.NewCIStr("name"),
Offset: 1,
DefaultValue: nil,
FieldType: *types.NewFieldType(mysql.TypeVarchar),
State: model.StatePublic,
},
},
}
p.tbl, err = tables.TableFromMeta(&simpleAllocator{}, tbInfo)
c.Assert(err, IsNil)
variable.BindSessionVars(p)
var i int64
for i = 0; i < 10; i++ {
_, err = p.tbl.AddRecord(p, []interface{}{i * 10, "hello"})
c.Assert(err, IsNil)
}
}
func (s *testEvaluatorSuite) TestSleep(c *C) {
defer testleak.AfterTest(c)()
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
sessVars := variable.GetSessionVars(ctx)
// non-strict model
sessVars.StrictSQLMode = false
d := make([]types.Datum, 1)
_, err := builtinSleep(d, nil)
c.Assert(err, NotNil)
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 (*testSessionSuite) TestSession(c *C) {
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
v := variable.GetSessionVars(ctx)
c.Assert(v, NotNil)
// For AffectedRows
v.AddAffectedRows(1)
c.Assert(v.AffectedRows, Equals, uint64(1))
v.AddAffectedRows(1)
c.Assert(v.AffectedRows, Equals, uint64(2))
// For FoundRows
v.AddFoundRows(1)
c.Assert(v.FoundRows, Equals, uint64(1))
v.AddFoundRows(1)
c.Assert(v.FoundRows, Equals, uint64(2))
// For last insert id
v.SetLastInsertID(uint64(1))
c.Assert(v.LastInsertID, Equals, uint64(1))
}
func (s *testEvaluatorSuite) TestLastInsertID(c *C) {
defer testleak.AfterTest(c)()
cases := []struct {
exprStr []ast.ExprNode
resultStr string
}{
{nil, "0"},
{[]ast.ExprNode{ast.NewValueExpr(1)}, "1"},
}
ctx := mock.NewContext()
variable.BindSessionVars(ctx)
c.Log(ctx)
for _, ca := range cases {
expr := &ast.FuncCallExpr{
FnName: model.NewCIStr("last_insert_id"),
Args: ca.exprStr,
}
val, err := Eval(ctx, expr)
c.Assert(err, IsNil)
valStr := fmt.Sprintf("%v", val.GetValue())
c.Assert(valStr, Equals, ca.resultStr, Commentf("for %s", ca.exprStr))
}
}
func (s *testVariableSuite) SetUpSuite(c *C) {
s.ctx = newMockCtx()
variable.BindSessionVars(s.ctx)
}
func testNewContext(c *C, d *ddl) context.Context {
ctx := d.newReorgContext()
variable.BindSessionVars(ctx)
return ctx
}
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 (s *testVariableSuite) SetUpSuite(c *C) {
nc := mock.NewContext()
s.ctx = nc
variable.BindSessionVars(s.ctx)
variable.BindGlobalVarAccessor(s.ctx, nc)
}
func (s *testHelperSuite) TestGetTimeValue(c *C) {
v, err := GetTimeValue(nil, "2012-12-12 00:00:00", mysql.TypeTimestamp, mysql.MinFsp)
c.Assert(err, IsNil)
timeValue, ok := v.(mysql.Time)
c.Assert(ok, IsTrue)
c.Assert(timeValue.String(), Equals, "2012-12-12 00:00:00")
ctx := newMockCtx()
variable.BindSessionVars(ctx)
sessionVars := variable.GetSessionVars(ctx)
sessionVars.Systems["timestamp"] = ""
v, err = GetTimeValue(ctx, "2012-12-12 00:00:00", mysql.TypeTimestamp, mysql.MinFsp)
c.Assert(err, IsNil)
timeValue, ok = v.(mysql.Time)
c.Assert(ok, IsTrue)
c.Assert(timeValue.String(), Equals, "2012-12-12 00:00:00")
sessionVars.Systems["timestamp"] = "0"
v, err = GetTimeValue(ctx, "2012-12-12 00:00:00", mysql.TypeTimestamp, mysql.MinFsp)
c.Assert(err, IsNil)
timeValue, ok = v.(mysql.Time)
c.Assert(ok, IsTrue)
c.Assert(timeValue.String(), Equals, "2012-12-12 00:00:00")
delete(sessionVars.Systems, "timestamp")
v, err = GetTimeValue(ctx, "2012-12-12 00:00:00", mysql.TypeTimestamp, mysql.MinFsp)
c.Assert(err, IsNil)
timeValue, ok = v.(mysql.Time)
c.Assert(ok, IsTrue)
c.Assert(timeValue.String(), Equals, "2012-12-12 00:00:00")
sessionVars.Systems["timestamp"] = "1234"
tbl := []struct {
Expr interface{}
Ret interface{}
}{
{"2012-12-12 00:00:00", "2012-12-12 00:00:00"},
{CurrentTimestamp, time.Unix(1234, 0).Format(mysql.TimeFormat)},
{ZeroTimestamp, "0000-00-00 00:00:00"},
{Value{"2012-12-12 00:00:00"}, "2012-12-12 00:00:00"},
{Value{int64(0)}, "0000-00-00 00:00:00"},
{Value{}, nil},
{CurrentTimeExpr, CurrentTimestamp},
{NewUnaryOperation(opcode.Minus, Value{int64(0)}), "0000-00-00 00:00:00"},
{mockExpr{}, nil},
}
for _, t := range tbl {
v, err := GetTimeValue(ctx, t.Expr, mysql.TypeTimestamp, mysql.MinFsp)
c.Assert(err, IsNil)
switch x := v.(type) {
case mysql.Time:
c.Assert(x.String(), DeepEquals, t.Ret)
default:
c.Assert(x, DeepEquals, t.Ret)
}
}
errTbl := []struct {
Expr interface{}
}{
{"2012-13-12 00:00:00"},
{Value{"2012-13-12 00:00:00"}},
{Value{0}},
{Value{int64(1)}},
{&Ident{CIStr: model.NewCIStr("xxx")}},
{NewUnaryOperation(opcode.Minus, Value{int64(1)})},
}
for _, t := range errTbl {
_, err := GetTimeValue(ctx, t.Expr, mysql.TypeTimestamp, mysql.MinFsp)
c.Assert(err, NotNil)
}
}