fix some tests

interface.go

@@ -23,6 +23,7 @@ type Interface interface {
 	CreateIndexes(bean interface{}) error
 	CreateUniques(bean interface{}) error
 	Decr(column string, arg ...interface{}) *Session
+	Desc(...string) *Session
 	Delete(interface{}) (int64, error)
 	Distinct(columns ...string) *Session
 	DropIndexes(bean interface{}) error
@@ -40,6 +41,7 @@ type Interface interface {
 	IsTableExist(beanOrTableName interface{}) (bool, error)
 	Iterate(interface{}, IterFunc) error
 	Limit(int, ...int) *Session
+	NoAutoCondition(...bool) *Session
 	NotIn(string, ...interface{}) *Session
 	Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session
 	Omit(columns ...string) *Session
@@ -58,6 +60,7 @@ type Interface interface {
 	Table(tableNameOrBean interface{}) *Session
 	Unscoped() *Session
 	Update(bean interface{}, condiBeans ...interface{}) (int64, error)
+	UseBool(...string) *Session
 	Where(interface{}, ...interface{}) *Session
 }
 
@@ -86,6 +89,7 @@ type EngineInterface interface {
 	SetTZDatabase(tz *time.Location)
 	SetTZLocation(tz *time.Location)
 	ShowSQL(show ...bool)
+	Sync(...interface{}) error
 	Sync2(...interface{}) error
 	StoreEngine(storeEngine string) *Session
 	TableInfo(bean interface{}) *Table

session.go

@@ -81,6 +81,7 @@ func (session *Session) Init() {
 	session.afterDeleteBeans = make(map[interface{}]*[]func(interface{}), 0)
 	session.beforeClosures = make([]func(interface{}), 0)
 	session.afterClosures = make([]func(interface{}), 0)
+	session.stmtCache = make(map[uint32]*core.Stmt)
 
 	session.afterProcessors = make([]executedProcessor, 0)
 
@@ -118,7 +119,7 @@ func (session *Session) resetStatement() {
 	session.isSqlFunc = false
 }
 
-// Prepare set a flag to session that should be prepare statment before execute query
+// Prepare set a flag to session that should be prepare statement before execute query
 func (session *Session) Prepare() *Session {
 	session.prepareStmt = true
 	return session

session_cols_test.go

@@ -28,7 +28,7 @@ func TestSetExpr(t *testing.T) {
 	assert.EqualValues(t, 1, cnt)
 
 	var not = "NOT"
-	if testEngine.dialect.DBType() == core.MSSQL {
+	if testEngine.Dialect().DBType() == core.MSSQL {
 		not = "~"
 	}
 	cnt, err = testEngine.SetExpr("show", not+" `show`").ID(1).Update(new(UserExpr))

session_cond_test.go

@@ -183,7 +183,7 @@ func TestIn(t *testing.T) {
 		idsInterface = append(idsInterface, id)
 	}
 
-	department := "`" + testEngine.ColumnMapper.Obj2Table("Departname") + "`"
+	department := "`" + testEngine.GetColumnMapper().Obj2Table("Departname") + "`"
 	err = testEngine.Where(department+" = ?", "dev").In("(id)", idsInterface...).Find(&users)
 	if err != nil {
 		t.Error(err)
@@ -205,7 +205,7 @@ func TestIn(t *testing.T) {
 		}
 	}
 
-	dev := testEngine.ColumnMapper.Obj2Table("Dev")
+	dev := testEngine.GetColumnMapper().Obj2Table("Dev")
 
 	err = testEngine.In("(id)", 1).In("(id)", 2).In(department, dev).Find(&users)
 

session_delete_test.go

@@ -77,7 +77,7 @@ func TestDeleted(t *testing.T) {
 
 	// Test normal Find()
 	var records1 []Deleted
-	err = testEngine.Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&records1, &Deleted{})
+	err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&records1, &Deleted{})
 	assert.EqualValues(t, 3, len(records1))
 
 	// Test normal Get()
@@ -96,7 +96,7 @@ func TestDeleted(t *testing.T) {
 	assert.False(t, has)
 
 	var records2 []Deleted
-	err = testEngine.Where("`" + testEngine.ColumnMapper.Obj2Table("Id") + "` > 0").Find(&records2)
+	err = testEngine.Where("`" + testEngine.GetColumnMapper().Obj2Table("Id") + "` > 0").Find(&records2)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, len(records2))
 
@@ -117,7 +117,7 @@ func TestDeleted(t *testing.T) {
 
 	// Test find all records whatever `deleted`.
 	var unscopedRecords1 []Deleted
-	err = testEngine.Unscoped().Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&unscopedRecords1, &Deleted{})
+	err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&unscopedRecords1, &Deleted{})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 3, len(unscopedRecords1))
 
@@ -127,13 +127,13 @@ func TestDeleted(t *testing.T) {
 	assert.EqualValues(t, 1, affected)
 
 	var unscopedRecords2 []Deleted
-	err = testEngine.Unscoped().Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&unscopedRecords2, &Deleted{})
+	err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&unscopedRecords2, &Deleted{})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, len(unscopedRecords2))
 
 	var records3 []Deleted
-	err = testEngine.Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").And("`"+testEngine.ColumnMapper.Obj2Table("Id")+"`> 1").
-		Or("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` = ?", 3).Find(&records3)
+	err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").And("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"`> 1").
+		Or("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` = ?", 3).Find(&records3)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, len(records3))
 }
@@ -141,7 +141,7 @@ func TestDeleted(t *testing.T) {
 func TestCacheDelete(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	oldCacher := testEngine.Cacher
+	oldCacher := testEngine.GetDefaultCacher()
 	cacher := NewLRUCacher(NewMemoryStore(), 1000)
 	testEngine.SetDefaultCacher(cacher)
 

session_find_test.go

@@ -64,7 +64,7 @@ func TestJoinLimit(t *testing.T) {
 func assertSync(t *testing.T, beans ...interface{}) {
 	for _, bean := range beans {
 		assert.NoError(t, testEngine.DropTables(bean))
-		assert.NoError(t, testEngine.Sync(bean))
+		assert.NoError(t, testEngine.Sync2(bean))
 	}
 }
 
@@ -105,8 +105,8 @@ func TestFind(t *testing.T) {
 	}
 
 	users2 := make([]Userinfo, 0)
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
-	err = testEngine.Sql("select * from " + testEngine.Quote(userinfo)).Find(&users2)
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
+	err = testEngine.SQL("select * from " + testEngine.Quote(userinfo)).Find(&users2)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -199,7 +199,7 @@ func TestDistinct(t *testing.T) {
 	assert.NoError(t, err)
 
 	users := make([]Userinfo, 0)
-	departname := testEngine.TableMapper.Obj2Table("Departname")
+	departname := testEngine.GetTableMapper().Obj2Table("Departname")
 	err = testEngine.Distinct(departname).Find(&users)
 	if err != nil {
 		t.Error(err)
@@ -273,13 +273,13 @@ func TestHaving(t *testing.T) {
 
 func TestOrderSameMapper(t *testing.T) {
 	assert.NoError(t, prepareEngine())
-	testEngine.unMapType(rValue(new(Userinfo)).Type())
+	testEngine.UnMapType(rValue(new(Userinfo)).Type())
 
-	mapper := testEngine.TableMapper
+	mapper := testEngine.GetTableMapper()
 	testEngine.SetMapper(core.SameMapper{})
 
 	defer func() {
-		testEngine.unMapType(rValue(new(Userinfo)).Type())
+		testEngine.UnMapType(rValue(new(Userinfo)).Type())
 		testEngine.SetMapper(mapper)
 	}()
 
@@ -304,12 +304,12 @@ func TestOrderSameMapper(t *testing.T) {
 
 func TestHavingSameMapper(t *testing.T) {
 	assert.NoError(t, prepareEngine())
-	testEngine.unMapType(rValue(new(Userinfo)).Type())
+	testEngine.UnMapType(rValue(new(Userinfo)).Type())
 
-	mapper := testEngine.TableMapper
+	mapper := testEngine.GetTableMapper()
 	testEngine.SetMapper(core.SameMapper{})
 	defer func() {
-		testEngine.unMapType(rValue(new(Userinfo)).Type())
+		testEngine.UnMapType(rValue(new(Userinfo)).Type())
 		testEngine.SetMapper(mapper)
 	}()
 	assertSync(t, new(Userinfo))
@@ -326,7 +326,7 @@ func TestFindInts(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
 
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var idsInt64 []int64
 	err := testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt64)
 	if err != nil {
@@ -367,8 +367,8 @@ func TestFindInts(t *testing.T) {
 func TestFindStrings(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
-	username := testEngine.ColumnMapper.Obj2Table("Username")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
+	username := testEngine.GetColumnMapper().Obj2Table("Username")
 	var idsString []string
 	err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsString)
 	if err != nil {
@@ -380,8 +380,8 @@ func TestFindStrings(t *testing.T) {
 func TestFindMyString(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
-	username := testEngine.ColumnMapper.Obj2Table("Username")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
+	username := testEngine.GetColumnMapper().Obj2Table("Username")
 
 	var idsMyString []MyString
 	err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsMyString)
@@ -395,8 +395,8 @@ func TestFindInterface(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
 
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
-	username := testEngine.ColumnMapper.Obj2Table("Username")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
+	username := testEngine.GetColumnMapper().Obj2Table("Username")
 	var idsInterface []interface{}
 	err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsInterface)
 	if err != nil {
@@ -409,7 +409,7 @@ func TestFindSliceBytes(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
 
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids [][][]byte
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
 	if err != nil {
@@ -424,7 +424,7 @@ func TestFindSlicePtrString(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
 
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids [][]*string
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
 	if err != nil {
@@ -439,7 +439,7 @@ func TestFindMapBytes(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
 
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids []map[string][]byte
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
 	if err != nil {
@@ -454,7 +454,7 @@ func TestFindMapPtrString(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(Userinfo))
 
-	userinfo := testEngine.TableMapper.Obj2Table("Userinfo")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
 	var ids []map[string]*string
 	err := testEngine.Table(userinfo).Desc("id").Find(&ids)
 	assert.NoError(t, err)

session_get_test.go

@@ -72,7 +72,7 @@ func TestGetVar(t *testing.T) {
 	assert.Equal(t, "1.5", valuesString["money"])
 
 	// for mymysql driver, interface{} will be []byte, so ignore it currently
-	if testEngine.dialect.DriverName() != "mymysql" {
+	if testEngine.Dialect().DriverName() != "mymysql" {
 		var valuesInter = make(map[string]interface{})
 		has, err = testEngine.Table("get_var").Where("id = ?", 1).Select("*").Get(&valuesInter)
 		assert.NoError(t, err)
@@ -121,10 +121,10 @@ func TestGetStruct(t *testing.T) {
 		IsMan bool
 	}
 
-	assert.NoError(t, testEngine.Sync(new(UserinfoGet)))
+	assert.NoError(t, testEngine.Sync2(new(UserinfoGet)))
 
 	var err error
-	if testEngine.dialect.DBType() == core.MSSQL {
+	if testEngine.Dialect().DBType() == core.MSSQL {
 		_, err = testEngine.Exec("SET IDENTITY_INSERT userinfo_get ON")
 		assert.NoError(t, err)
 	}
@@ -143,9 +143,9 @@ func TestGetStruct(t *testing.T) {
 		Total  int64
 	}
 
-	assert.NoError(t, testEngine.Sync(&NoIdUser{}))
+	assert.NoError(t, testEngine.Sync2(&NoIdUser{}))
 
-	userCol := testEngine.ColumnMapper.Obj2Table("User")
+	userCol := testEngine.GetColumnMapper().Obj2Table("User")
 	_, err = testEngine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIdUser{})
 	assert.NoError(t, err)
 

session_insert_test.go

@@ -235,7 +235,7 @@ func TestInsertDefault(t *testing.T) {
 	}
 
 	var di2 = DefaultInsert{Name: "test"}
-	_, err = testEngine.Omit(testEngine.ColumnMapper.Obj2Table("Status")).Insert(&di2)
+	_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("Status")).Insert(&di2)
 	if err != nil {
 		t.Error(err)
 	}
@@ -283,7 +283,7 @@ func TestInsertDefault2(t *testing.T) {
 	}
 
 	var di2 = DefaultInsert2{Name: "test"}
-	_, err = testEngine.Omit(testEngine.ColumnMapper.Obj2Table("CheckTime")).Insert(&di2)
+	_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("CheckTime")).Insert(&di2)
 	if err != nil {
 		t.Error(err)
 	}

session_raw_test.go

@@ -19,7 +19,7 @@ func TestQuery(t *testing.T) {
 		Name string
 	}
 
-	assert.NoError(t, testEngine.Sync(new(UserinfoQuery)))
+	assert.NoError(t, testEngine.Sync2(new(UserinfoQuery)))
 
 	res, err := testEngine.Exec("INSERT INTO `userinfo_query` (uid, name) VALUES (?, ?)", 1, "user")
 	assert.NoError(t, err)

session_schema_test.go

@@ -126,13 +126,13 @@ func TestIsTableEmpty(t *testing.T) {
 
 	assert.NoError(t, testEngine.DropTables(&PictureEmpty{}, &NumericEmpty{}))
 
-	assert.NoError(t, testEngine.Sync(new(PictureEmpty), new(NumericEmpty)))
+	assert.NoError(t, testEngine.Sync2(new(PictureEmpty), new(NumericEmpty)))
 
 	isEmpty, err := testEngine.IsTableEmpty(&PictureEmpty{})
 	assert.NoError(t, err)
 	assert.True(t, isEmpty)
 
-	tbName := testEngine.TableMapper.Obj2Table("PictureEmpty")
+	tbName := testEngine.GetTableMapper().Obj2Table("PictureEmpty")
 	isEmpty, err = testEngine.IsTableEmpty(tbName)
 	assert.NoError(t, err)
 	assert.True(t, isEmpty)

session_stats_test.go

@@ -46,8 +46,8 @@ func TestSum(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 3, cnt)
 
-	colInt := testEngine.ColumnMapper.Obj2Table("Int")
-	colFloat := testEngine.ColumnMapper.Obj2Table("Float")
+	colInt := testEngine.GetColumnMapper().Obj2Table("Int")
+	colFloat := testEngine.GetColumnMapper().Obj2Table("Float")
 
 	sumInt, err := testEngine.Sum(new(SumStruct), colInt)
 	assert.NoError(t, err)
@@ -109,7 +109,7 @@ func TestCount(t *testing.T) {
 	}
 	assert.NoError(t, testEngine.Sync2(new(UserinfoCount)))
 
-	colName := testEngine.ColumnMapper.Obj2Table("Departname")
+	colName := testEngine.GetColumnMapper().Obj2Table("Departname")
 	var cond builder.Cond = builder.Eq{
 		"`" + colName + "`": "dev",
 	}

session_test.go

@@ -11,7 +11,6 @@ import (
 )
 
 func TestClose(t *testing.T) {
-
 	assert.NoError(t, prepareEngine())
 
 	sess1 := testEngine.NewSession()

session_tx_test.go

@@ -128,11 +128,11 @@ func TestCombineTransaction(t *testing.T) {
 func TestCombineTransactionSameMapper(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	oldMapper := testEngine.ColumnMapper
-	testEngine.unMapType(rValue(new(Userinfo)).Type())
+	oldMapper := testEngine.GetColumnMapper()
+	testEngine.UnMapType(rValue(new(Userinfo)).Type())
 	testEngine.SetMapper(core.SameMapper{})
 	defer func() {
-		testEngine.unMapType(rValue(new(Userinfo)).Type())
+		testEngine.UnMapType(rValue(new(Userinfo)).Type())
 		testEngine.SetMapper(oldMapper)
 	}()
 

session_update_test.go

@@ -83,7 +83,7 @@ type ForUpdate struct {
 	Name string
 }
 
-func setupForUpdate(engine *Engine) error {
+func setupForUpdate(engine EngineInterface) error {
 	v := new(ForUpdate)
 	err := testEngine.DropTables(v)
 	if err != nil {
@@ -110,7 +110,7 @@ func setupForUpdate(engine *Engine) error {
 }
 
 func TestForUpdate(t *testing.T) {
-	if testEngine.DriverName() != "mysql" && testEngine.DriverName() != "mymysql" {
+	if testEngine.Dialect().DriverName() != "mysql" && testEngine.Dialect().DriverName() != "mymysql" {
 		return
 	}
 
@@ -517,8 +517,8 @@ func TestUpdate1(t *testing.T) {
 		}
 
 		col2 := &UpdateMustCols{col1.Id, true, ""}
-		boolStr := testEngine.ColumnMapper.Obj2Table("Bool")
-		stringStr := testEngine.ColumnMapper.Obj2Table("String")
+		boolStr := testEngine.GetColumnMapper().Obj2Table("Bool")
+		stringStr := testEngine.GetColumnMapper().Obj2Table("String")
 		_, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2)
 		if err != nil {
 			t.Error(err)
@@ -559,7 +559,7 @@ func TestUpdateIncrDecr(t *testing.T) {
 	_, err := testEngine.Insert(col1)
 	assert.NoError(t, err)
 
-	colName := testEngine.ColumnMapper.Obj2Table("Cnt")
+	colName := testEngine.GetColumnMapper().Obj2Table("Cnt")
 
 	cnt, err := testEngine.ID(col1.Id).Incr(colName).Update(col1)
 	assert.NoError(t, err)
@@ -759,21 +759,21 @@ func TestUpdateUpdated(t *testing.T) {
 func TestUpdateSameMapper(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	oldMapper := testEngine.ColumnMapper
-	testEngine.unMapType(rValue(new(Userinfo)).Type())
-	testEngine.unMapType(rValue(new(Condi)).Type())
-	testEngine.unMapType(rValue(new(Article)).Type())
-	testEngine.unMapType(rValue(new(UpdateAllCols)).Type())
-	testEngine.unMapType(rValue(new(UpdateMustCols)).Type())
-	testEngine.unMapType(rValue(new(UpdateIncr)).Type())
+	oldMapper := testEngine.GetColumnMapper()
+	testEngine.UnMapType(rValue(new(Userinfo)).Type())
+	testEngine.UnMapType(rValue(new(Condi)).Type())
+	testEngine.UnMapType(rValue(new(Article)).Type())
+	testEngine.UnMapType(rValue(new(UpdateAllCols)).Type())
+	testEngine.UnMapType(rValue(new(UpdateMustCols)).Type())
+	testEngine.UnMapType(rValue(new(UpdateIncr)).Type())
 	testEngine.SetMapper(core.SameMapper{})
 	defer func() {
-		testEngine.unMapType(rValue(new(Userinfo)).Type())
-		testEngine.unMapType(rValue(new(Condi)).Type())
-		testEngine.unMapType(rValue(new(Article)).Type())
-		testEngine.unMapType(rValue(new(UpdateAllCols)).Type())
-		testEngine.unMapType(rValue(new(UpdateMustCols)).Type())
-		testEngine.unMapType(rValue(new(UpdateIncr)).Type())
+		testEngine.UnMapType(rValue(new(Userinfo)).Type())
+		testEngine.UnMapType(rValue(new(Condi)).Type())
+		testEngine.UnMapType(rValue(new(Article)).Type())
+		testEngine.UnMapType(rValue(new(UpdateAllCols)).Type())
+		testEngine.UnMapType(rValue(new(UpdateMustCols)).Type())
+		testEngine.UnMapType(rValue(new(UpdateIncr)).Type())
 		testEngine.SetMapper(oldMapper)
 	}()
 
@@ -943,8 +943,8 @@ func TestUpdateSameMapper(t *testing.T) {
 		}
 
 		col2 := &UpdateMustCols{col1.Id, true, ""}
-		boolStr := testEngine.ColumnMapper.Obj2Table("Bool")
-		stringStr := testEngine.ColumnMapper.Obj2Table("String")
+		boolStr := testEngine.GetColumnMapper().Obj2Table("Bool")
+		stringStr := testEngine.GetColumnMapper().Obj2Table("String")
 		_, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2)
 		if err != nil {
 			t.Error(err)

statement_test.go

@@ -163,10 +163,20 @@ func (TestType) TableName() string {
 }
 
 func createTestStatement() *Statement {
-	statement := &Statement{}
-	statement.Init()
-	statement.Engine = testEngine
-	statement.setRefValue(reflect.ValueOf(TestType{}))
-
-	return statement
+	if engine, ok := testEngine.(*Engine); ok {
+		statement := &Statement{}
+		statement.Init()
+		statement.Engine = engine
+		statement.setRefValue(reflect.ValueOf(TestType{}))
+
+		return statement
+	} else if eg, ok := testEngine.(*EngineGroup); ok {
+		statement := &Statement{}
+		statement.Init()
+		statement.Engine = eg.Engine
+		statement.setRefValue(reflect.ValueOf(TestType{}))
+
+		return statement
+	}
+	return nil
 }

tag_extends_test.go

@@ -202,13 +202,13 @@ func TestExtends(t *testing.T) {
 
 	var info UserAndDetail
 	qt := testEngine.Quote
-	ui := testEngine.TableMapper.Obj2Table("Userinfo")
-	ud := testEngine.TableMapper.Obj2Table("Userdetail")
-	uiid := testEngine.TableMapper.Obj2Table("Id")
+	ui := testEngine.GetTableMapper().Obj2Table("Userinfo")
+	ud := testEngine.GetTableMapper().Obj2Table("Userdetail")
+	uiid := testEngine.GetTableMapper().Obj2Table("Id")
 	udid := "detail_id"
 	sql := fmt.Sprintf("select * from %s, %s where %s.%s = %s.%s",
 		qt(ui), qt(ud), qt(ui), qt(udid), qt(ud), qt(uiid))
-	b, err := testEngine.Sql(sql).NoCascade().Get(&info)
+	b, err := testEngine.SQL(sql).NoCascade().Get(&info)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -329,7 +329,7 @@ func TestExtends2(t *testing.T) {
 		Uid:     sender.Id,
 		ToUid:   receiver.Id,
 	}
-	if testEngine.dialect.DBType() == core.MSSQL {
+	if testEngine.Dialect().DBType() == core.MSSQL {
 		_, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
 		assert.NoError(t, err)
 	}
@@ -340,7 +340,7 @@ func TestExtends2(t *testing.T) {
 		panic(err)
 	}
 
-	var mapper = testEngine.TableMapper.Obj2Table
+	var mapper = testEngine.GetTableMapper().Obj2Table
 	userTableName := mapper("MessageUser")
 	typeTableName := mapper("MessageType")
 	msgTableName := mapper("Message")
@@ -401,7 +401,7 @@ func TestExtends3(t *testing.T) {
 		Uid:     sender.Id,
 		ToUid:   receiver.Id,
 	}
-	if testEngine.dialect.DBType() == core.MSSQL {
+	if testEngine.Dialect().DBType() == core.MSSQL {
 		_, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
 		assert.NoError(t, err)
 	}
@@ -411,7 +411,7 @@ func TestExtends3(t *testing.T) {
 		panic(err)
 	}
 
-	var mapper = testEngine.TableMapper.Obj2Table
+	var mapper = testEngine.GetTableMapper().Obj2Table
 	userTableName := mapper("MessageUser")
 	typeTableName := mapper("MessageType")
 	msgTableName := mapper("Message")
@@ -488,7 +488,7 @@ func TestExtends4(t *testing.T) {
 		Content: "test",
 		Uid:     sender.Id,
 	}
-	if testEngine.dialect.DBType() == core.MSSQL {
+	if testEngine.Dialect().DBType() == core.MSSQL {
 		_, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
 		assert.NoError(t, err)
 	}
@@ -498,7 +498,7 @@ func TestExtends4(t *testing.T) {
 		panic(err)
 	}
 
-	var mapper = testEngine.TableMapper.Obj2Table
+	var mapper = testEngine.GetTableMapper().Obj2Table
 	userTableName := mapper("MessageUser")
 	typeTableName := mapper("MessageType")
 	msgTableName := mapper("Message")

tag_id_test.go

@@ -18,11 +18,11 @@ type IDGonicMapper struct {
 func TestGonicMapperID(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	oldMapper := testEngine.ColumnMapper
-	testEngine.unMapType(rValue(new(IDGonicMapper)).Type())
+	oldMapper := testEngine.GetColumnMapper()
+	testEngine.UnMapType(rValue(new(IDGonicMapper)).Type())
 	testEngine.SetMapper(core.LintGonicMapper)
 	defer func() {
-		testEngine.unMapType(rValue(new(IDGonicMapper)).Type())
+		testEngine.UnMapType(rValue(new(IDGonicMapper)).Type())
 		testEngine.SetMapper(oldMapper)
 	}()
 
@@ -55,11 +55,11 @@ type IDSameMapper struct {
 func TestSameMapperID(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	oldMapper := testEngine.ColumnMapper
-	testEngine.unMapType(rValue(new(IDSameMapper)).Type())
+	oldMapper := testEngine.GetColumnMapper()
+	testEngine.UnMapType(rValue(new(IDSameMapper)).Type())
 	testEngine.SetMapper(core.SameMapper{})
 	defer func() {
-		testEngine.unMapType(rValue(new(IDSameMapper)).Type())
+		testEngine.UnMapType(rValue(new(IDSameMapper)).Type())
 		testEngine.SetMapper(oldMapper)
 	}()
 

tag_test.go

@@ -123,7 +123,7 @@ func TestCreatedUpdated(t *testing.T) {
 		Updated  time.Time `xorm:"updated"`
 	}
 
-	err := testEngine.Sync(&CreatedUpdated{})
+	err := testEngine.Sync2(&CreatedUpdated{})
 	assert.NoError(t, err)
 
 	c := &CreatedUpdated{Name: "test"}
@@ -178,7 +178,7 @@ type Lowercase struct {
 func TestLowerCase(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	err := testEngine.Sync(&Lowercase{})
+	err := testEngine.Sync2(&Lowercase{})
 	_, err = testEngine.Where("(id) > 0").Delete(&Lowercase{})
 	if err != nil {
 		t.Error(err)
@@ -255,7 +255,7 @@ func TestAutoIncrTag(t *testing.T) {
 func TestTagComment(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	// FIXME: only support mysql
-	if testEngine.dialect.DriverName() != core.MYSQL {
+	if testEngine.Dialect().DriverName() != core.MYSQL {
 		return
 	}
 
@@ -371,7 +371,7 @@ func TestTagTime(t *testing.T) {
 
 	assertSync(t, new(TagUTCStruct))
 
-	assert.EqualValues(t, time.Local.String(), testEngine.TZLocation.String())
+	assert.EqualValues(t, time.Local.String(), testEngine.GetTZLocation().String())
 
 	s := TagUTCStruct{
 		Name: "utc",

time_test.go

@@ -47,10 +47,10 @@ func TestTimeUserTimeDiffLoc(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	loc, err := time.LoadLocation("Asia/Shanghai")
 	assert.NoError(t, err)
-	testEngine.TZLocation = loc
+	testEngine.SetTZLocation(loc)
 	dbLoc, err := time.LoadLocation("America/New_York")
 	assert.NoError(t, err)
-	testEngine.DatabaseTZ = dbLoc
+	testEngine.SetTZDatabase(dbLoc)
 
 	type TimeUser2 struct {
 		Id       string
@@ -112,10 +112,10 @@ func TestTimeUserCreatedDiffLoc(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	loc, err := time.LoadLocation("Asia/Shanghai")
 	assert.NoError(t, err)
-	testEngine.TZLocation = loc
+	testEngine.SetTZLocation(loc)
 	dbLoc, err := time.LoadLocation("America/New_York")
 	assert.NoError(t, err)
-	testEngine.DatabaseTZ = dbLoc
+	testEngine.SetTZDatabase(dbLoc)
 
 	type UserCreated2 struct {
 		Id        string
@@ -198,10 +198,10 @@ func TestTimeUserUpdatedDiffLoc(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	loc, err := time.LoadLocation("Asia/Shanghai")
 	assert.NoError(t, err)
-	testEngine.TZLocation = loc
+	testEngine.SetTZLocation(loc)
 	dbLoc, err := time.LoadLocation("America/New_York")
 	assert.NoError(t, err)
-	testEngine.DatabaseTZ = dbLoc
+	testEngine.SetTZDatabase(dbLoc)
 
 	type UserUpdated2 struct {
 		Id        string
@@ -302,10 +302,10 @@ func TestTimeUserDeletedDiffLoc(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	loc, err := time.LoadLocation("Asia/Shanghai")
 	assert.NoError(t, err)
-	testEngine.TZLocation = loc
+	testEngine.SetTZLocation(loc)
 	dbLoc, err := time.LoadLocation("America/New_York")
 	assert.NoError(t, err)
-	testEngine.DatabaseTZ = dbLoc
+	testEngine.SetTZDatabase(dbLoc)
 
 	type UserDeleted2 struct {
 		Id        string
@@ -426,10 +426,10 @@ func TestCustomTimeUserDeletedDiffLoc(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	loc, err := time.LoadLocation("Asia/Shanghai")
 	assert.NoError(t, err)
-	testEngine.TZLocation = loc
+	testEngine.SetTZLocation(loc)
 	dbLoc, err := time.LoadLocation("America/New_York")
 	assert.NoError(t, err)
-	testEngine.DatabaseTZ = dbLoc
+	testEngine.SetTZDatabase(dbLoc)
 
 	type UserDeleted4 struct {
 		Id        string

types_test.go

@@ -154,7 +154,7 @@ func TestConversion(t *testing.T) {
 
 	c := new(ConvStruct)
 	assert.NoError(t, testEngine.DropTables(c))
-	assert.NoError(t, testEngine.Sync(c))
+	assert.NoError(t, testEngine.Sync2(c))
 
 	var s ConvString = "sssss"
 	c.Conv = "tttt"

xorm_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 var (
-	testEngine *Engine
+	testEngine EngineInterface
 	dbType     string
 	connString string
 
@@ -25,18 +25,26 @@ var (
 	ptrConnStr = flag.String("conn_str", "./test.db?cache=shared&mode=rwc", "test database connection string")
 	mapType    = flag.String("map_type", "snake", "indicate the name mapping")
 	cache      = flag.Bool("cache", false, "if enable cache")
+	cluster    = flag.Bool("cluster", false, "if this is a cluster")
+	splitter   = flag.String("splitter", ";", "the splitter on connstr for cluster")
 )
 
 func createEngine(dbType, connStr string) error {
 	if testEngine == nil {
 		var err error
-		testEngine, err = NewEngine(dbType, connStr)
+
+		if !*cluster {
+			testEngine, err = NewEngine(dbType, connStr)
+
+		} else {
+			testEngine, err = NewEngineGroup(dbType, strings.Split(connStr, *splitter))
+		}
 		if err != nil {
 			return err
 		}
 
 		testEngine.ShowSQL(*showSQL)
-		testEngine.logger.SetLevel(core.LOG_DEBUG)
+		testEngine.SetLogLevel(core.LOG_DEBUG)
 		if *cache {
 			cacher := NewLRUCacher(NewMemoryStore(), 100000)
 			testEngine.SetDefaultCacher(cacher)