add tests support for EngineGroup & fix some bugs

cache_test.go

@@ -20,7 +20,7 @@ func TestCacheFind(t *testing.T) {
 		Password string
 	}
 
-	oldCacher := testEngine.Cacher
+	oldCacher := testEngine.GetDefaultCacher()
 	cacher := NewLRUCacher2(NewMemoryStore(), time.Hour, 10000)
 	testEngine.SetDefaultCacher(cacher)
 
@@ -95,7 +95,7 @@ func TestCacheFind2(t *testing.T) {
 		Password string
 	}
 
-	oldCacher := testEngine.Cacher
+	oldCacher := testEngine.GetDefaultCacher()
 	cacher := NewLRUCacher2(NewMemoryStore(), time.Hour, 10000)
 	testEngine.SetDefaultCacher(cacher)
 
@@ -146,7 +146,7 @@ func TestCacheGet(t *testing.T) {
 		Password string
 	}
 
-	oldCacher := testEngine.Cacher
+	oldCacher := testEngine.GetDefaultCacher()
 	cacher := NewLRUCacher2(NewMemoryStore(), time.Hour, 10000)
 	testEngine.SetDefaultCacher(cacher)
 

engine.go

@@ -51,6 +51,21 @@ type Engine struct {
 	engineGroup *EngineGroup
 }
 
+// BufferSize sets buffer size for iterate
+func (engine *Engine) BufferSize(size int) *Session {
+	session := engine.NewSession()
+	session.isAutoClose = true
+	return session.BufferSize(size)
+}
+
+// CondDeleted returns the conditions whether a record is soft deleted.
+func (engine *Engine) CondDeleted(colName string) builder.Cond {
+	if engine.dialect.DBType() == core.MSSQL {
+		return builder.IsNull{colName}
+	}
+	return builder.IsNull{colName}.Or(builder.Eq{colName: zeroTime1})
+}
+
 // ShowSQL show SQL statement or not on logger if log level is great than INFO
 func (engine *Engine) ShowSQL(show ...bool) {
 	engine.logger.ShowSQL(show...)
@@ -81,6 +96,11 @@ func (engine *Engine) SetLogger(logger core.ILogger) {
 	engine.dialect.SetLogger(logger)
 }
 
+// SetLogLevel sets the logger level
+func (engine *Engine) SetLogLevel(level core.LogLevel) {
+	engine.logger.SetLevel(level)
+}
+
 // SetDisableGlobalCache disable global cache or not
 func (engine *Engine) SetDisableGlobalCache(disable bool) {
 	if engine.disableGlobalCache != disable {
@@ -203,6 +223,11 @@ func (engine *Engine) SetDefaultCacher(cacher core.Cacher) {
 	engine.Cacher = cacher
 }
 
+// GetDefaultCacher returns the default cacher
+func (engine *Engine) GetDefaultCacher() core.Cacher {
+	return engine.Cacher
+}
+
 // NoCache If you has set default cacher, and you want temporilly stop use cache,
 // you can use NoCache()
 func (engine *Engine) NoCache() *Session {
@@ -759,7 +784,8 @@ func (engine *Engine) Having(conditions string) *Session {
 	return session.Having(conditions)
 }
 
-func (engine *Engine) unMapType(t reflect.Type) {
+// UnMapType removes the datbase mapper of a type
+func (engine *Engine) UnMapType(t reflect.Type) {
 	engine.mutex.Lock()
 	defer engine.mutex.Unlock()
 	delete(engine.Tables, t)
@@ -1562,24 +1588,39 @@ func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}
 	return
 }
 
+// GetColumnMapper returns the column name mapper
+func (engine *Engine) GetColumnMapper() core.IMapper {
+	return engine.ColumnMapper
+}
+
+// GetTableMapper returns the table name mapper
+func (engine *Engine) GetTableMapper() core.IMapper {
+	return engine.TableMapper
+}
+
+// GetTZLocation returns time zone of the application
+func (engine *Engine) GetTZLocation() *time.Location {
+	return engine.TZLocation
+}
+
+// SetTZLocation sets time zone of the application
+func (engine *Engine) SetTZLocation(tz *time.Location) {
+	engine.TZLocation = tz
+}
+
+// GetTZDatabase returns time zone of the database
+func (engine *Engine) GetTZDatabase() *time.Location {
+	return engine.DatabaseTZ
+}
+
+// SetTZDatabase sets time zone of the database
+func (engine *Engine) SetTZDatabase(tz *time.Location) {
+	engine.DatabaseTZ = tz
+}
+
 // Unscoped always disable struct tag "deleted"
 func (engine *Engine) Unscoped() *Session {
 	session := engine.NewSession()
 	session.isAutoClose = true
 	return session.Unscoped()
 }
-
-// CondDeleted returns the conditions whether a record is soft deleted.
-func (engine *Engine) CondDeleted(colName string) builder.Cond {
-	if engine.dialect.DBType() == core.MSSQL {
-		return builder.IsNull{colName}
-	}
-	return builder.IsNull{colName}.Or(builder.Eq{colName: zeroTime1})
-}
-
-// BufferSize sets buffer size for iterate
-func (engine *Engine) BufferSize(size int) *Session {
-	session := engine.NewSession()
-	session.isAutoClose = true
-	return session.BufferSize(size)
-}

engine_group.go

@@ -10,12 +10,14 @@ import (
 	"github.com/go-xorm/core"
 )
 
+// EngineGroup defines an engine group
 type EngineGroup struct {
 	*Engine
 	slaves []*Engine
 	policy GroupPolicy
 }
 
+// NewEngineGroup creates a new engine group
 func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolicy) (*EngineGroup, error) {
 	var eg EngineGroup
 	if len(policies) > 0 {
@@ -57,98 +59,6 @@ func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolic
 	return nil, ErrParamsType
 }
 
-func (eg *EngineGroup) SetPolicy(policy GroupPolicy) *EngineGroup {
-	eg.policy = policy
-	return eg
-}
-
-func (eg *EngineGroup) Master() *Engine {
-	return eg.Engine
-}
-
-// Slave returns one of the physical databases which is a slave according the policy
-func (eg *EngineGroup) Slave() *Engine {
-	switch len(eg.slaves) {
-	case 0:
-		return eg.Engine
-	case 1:
-		return eg.slaves[0]
-	}
-	return eg.policy.Slave(eg)
-}
-
-func (eg *EngineGroup) Slaves() []*Engine {
-	return eg.slaves
-}
-
-func (eg *EngineGroup) GetSlave(i int) *Engine {
-	return eg.slaves[i]
-}
-
-// ShowSQL show SQL statement or not on logger if log level is great than INFO
-func (eg *EngineGroup) ShowSQL(show ...bool) {
-	eg.Engine.ShowSQL(show...)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].ShowSQL(show...)
-	}
-}
-
-// ShowExecTime show SQL statement and execute time or not on logger if log level is great than INFO
-func (eg *EngineGroup) ShowExecTime(show ...bool) {
-	eg.Engine.ShowExecTime(show...)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].ShowExecTime(show...)
-	}
-}
-
-// SetMapper set the name mapping rules
-func (eg *EngineGroup) SetMapper(mapper core.IMapper) {
-	eg.Engine.SetMapper(mapper)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].SetMapper(mapper)
-	}
-}
-
-// SetLogger set the new logger
-func (eg *EngineGroup) SetLogger(logger core.ILogger) {
-	eg.Engine.SetLogger(logger)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].SetLogger(logger)
-	}
-}
-
-// SetTableMapper set the table name mapping rule
-func (eg *EngineGroup) SetTableMapper(mapper core.IMapper) {
-	eg.Engine.TableMapper = mapper
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].TableMapper = mapper
-	}
-}
-
-// SetColumnMapper set the column name mapping rule
-func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) {
-	eg.Engine.ColumnMapper = mapper
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].ColumnMapper = mapper
-	}
-}
-
-// SetMaxOpenConns is only available for go 1.2+
-func (eg *EngineGroup) SetMaxOpenConns(conns int) {
-	eg.Engine.db.SetMaxOpenConns(conns)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].db.SetMaxOpenConns(conns)
-	}
-}
-
-// SetMaxIdleConns set the max idle connections on pool, default is 2
-func (eg *EngineGroup) SetMaxIdleConns(conns int) {
-	eg.Engine.db.SetMaxIdleConns(conns)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].db.SetMaxIdleConns(conns)
-	}
-}
-
 // Close the engine
 func (eg *EngineGroup) Close() error {
 	err := eg.Engine.Close()
@@ -165,6 +75,11 @@ func (eg *EngineGroup) Close() error {
 	return nil
 }
 
+// Master returns the master engine
+func (eg *EngineGroup) Master() *Engine {
+	return eg.Engine
+}
+
 // Ping tests if database is alive
 func (eg *EngineGroup) Ping() error {
 	if err := eg.Engine.Ping(); err != nil {
@@ -178,3 +93,105 @@ func (eg *EngineGroup) Ping() error {
 	}
 	return nil
 }
+
+// SetColumnMapper set the column name mapping rule
+func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) {
+	eg.Engine.ColumnMapper = mapper
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].ColumnMapper = mapper
+	}
+}
+
+// SetDefaultCacher set the default cacher
+func (eg *EngineGroup) SetDefaultCacher(cacher core.Cacher) {
+	eg.Engine.SetDefaultCacher(cacher)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].SetDefaultCacher(cacher)
+	}
+}
+
+// SetLogger set the new logger
+func (eg *EngineGroup) SetLogger(logger core.ILogger) {
+	eg.Engine.SetLogger(logger)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].SetLogger(logger)
+	}
+}
+
+// SetLogLevel sets the logger level
+func (eg *EngineGroup) SetLogLevel(level core.LogLevel) {
+	eg.Engine.SetLogLevel(level)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].SetLogLevel(level)
+	}
+}
+
+// SetMapper set the name mapping rules
+func (eg *EngineGroup) SetMapper(mapper core.IMapper) {
+	eg.Engine.SetMapper(mapper)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].SetMapper(mapper)
+	}
+}
+
+// SetMaxIdleConns set the max idle connections on pool, default is 2
+func (eg *EngineGroup) SetMaxIdleConns(conns int) {
+	eg.Engine.db.SetMaxIdleConns(conns)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].db.SetMaxIdleConns(conns)
+	}
+}
+
+// SetMaxOpenConns is only available for go 1.2+
+func (eg *EngineGroup) SetMaxOpenConns(conns int) {
+	eg.Engine.db.SetMaxOpenConns(conns)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].db.SetMaxOpenConns(conns)
+	}
+}
+
+// SetPolicy set the group policy
+func (eg *EngineGroup) SetPolicy(policy GroupPolicy) *EngineGroup {
+	eg.policy = policy
+	return eg
+}
+
+// SetTableMapper set the table name mapping rule
+func (eg *EngineGroup) SetTableMapper(mapper core.IMapper) {
+	eg.Engine.TableMapper = mapper
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].TableMapper = mapper
+	}
+}
+
+// ShowExecTime show SQL statement and execute time or not on logger if log level is great than INFO
+func (eg *EngineGroup) ShowExecTime(show ...bool) {
+	eg.Engine.ShowExecTime(show...)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].ShowExecTime(show...)
+	}
+}
+
+// ShowSQL show SQL statement or not on logger if log level is great than INFO
+func (eg *EngineGroup) ShowSQL(show ...bool) {
+	eg.Engine.ShowSQL(show...)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].ShowSQL(show...)
+	}
+}
+
+// Slave returns one of the physical databases which is a slave according the policy
+func (eg *EngineGroup) Slave() *Engine {
+	switch len(eg.slaves) {
+	case 0:
+		return eg.Engine
+	case 1:
+		return eg.slaves[0]
+	}
+	return eg.policy.Slave(eg)
+}
+
+// Slaves returns all the slaves
+func (eg *EngineGroup) Slaves() []*Engine {
+	return eg.slaves
+}

interface.go

@@ -0,0 +1,99 @@
+// Copyright 2017 The Xorm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xorm
+
+import (
+	"database/sql"
+	"reflect"
+	"time"
+
+	"github.com/go-xorm/core"
+)
+
+// Interface defines the interface which Engine, EngineGroup and Session will implementate.
+type Interface interface {
+	AllCols() *Session
+	Alias(alias string) *Session
+	Asc(colNames ...string) *Session
+	BufferSize(size int) *Session
+	Cols(columns ...string) *Session
+	Count(...interface{}) (int64, error)
+	CreateIndexes(bean interface{}) error
+	CreateUniques(bean interface{}) error
+	Decr(column string, arg ...interface{}) *Session
+	Delete(interface{}) (int64, error)
+	Distinct(columns ...string) *Session
+	DropIndexes(bean interface{}) error
+	Exec(string, ...interface{}) (sql.Result, error)
+	Exist(bean ...interface{}) (bool, error)
+	Find(interface{}, ...interface{}) error
+	Get(interface{}) (bool, error)
+	GroupBy(keys string) *Session
+	ID(interface{}) *Session
+	In(string, ...interface{}) *Session
+	Incr(column string, arg ...interface{}) *Session
+	Insert(...interface{}) (int64, error)
+	InsertOne(interface{}) (int64, error)
+	IsTableEmpty(bean interface{}) (bool, error)
+	IsTableExist(beanOrTableName interface{}) (bool, error)
+	Iterate(interface{}, IterFunc) error
+	Limit(int, ...int) *Session
+	NotIn(string, ...interface{}) *Session
+	Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session
+	Omit(columns ...string) *Session
+	OrderBy(order string) *Session
+	Ping() error
+	Query(sql string, paramStr ...interface{}) (resultsSlice []map[string][]byte, err error)
+	QueryInterface(sqlStr string, args ...interface{}) ([]map[string]interface{}, error)
+	QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error)
+	Rows(bean interface{}) (*Rows, error)
+	SetExpr(string, string) *Session
+	SQL(interface{}, ...interface{}) *Session
+	Sum(bean interface{}, colName string) (float64, error)
+	SumInt(bean interface{}, colName string) (int64, error)
+	Sums(bean interface{}, colNames ...string) ([]float64, error)
+	SumsInt(bean interface{}, colNames ...string) ([]int64, error)
+	Table(tableNameOrBean interface{}) *Session
+	Unscoped() *Session
+	Update(bean interface{}, condiBeans ...interface{}) (int64, error)
+	Where(interface{}, ...interface{}) *Session
+}
+
+// EngineInterface defines the interface which Engine, EngineGroup will implementate.
+type EngineInterface interface {
+	Interface
+
+	Before(func(interface{})) *Session
+	Charset(charset string) *Session
+	CreateTables(...interface{}) error
+	DBMetas() ([]*core.Table, error)
+	Dialect() core.Dialect
+	DropTables(...interface{}) error
+	DumpAllToFile(fp string, tp ...core.DbType) error
+	GetColumnMapper() core.IMapper
+	GetDefaultCacher() core.Cacher
+	GetTableMapper() core.IMapper
+	GetTZDatabase() *time.Location
+	GetTZLocation() *time.Location
+	NewSession() *Session
+	NoAutoTime() *Session
+	Quote(string) string
+	SetDefaultCacher(core.Cacher)
+	SetLogLevel(core.LogLevel)
+	SetMapper(core.IMapper)
+	SetTZDatabase(tz *time.Location)
+	SetTZLocation(tz *time.Location)
+	ShowSQL(show ...bool)
+	Sync2(...interface{}) error
+	StoreEngine(storeEngine string) *Session
+	TableInfo(bean interface{}) *Table
+	UnMapType(reflect.Type)
+}
+
+var (
+	_ Interface       = &Session{}
+	_ EngineInterface = &Engine{}
+	_ EngineInterface = &EngineGroup{}
+)

session.go

@@ -74,6 +74,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.lastSQL = ""
 	session.lastSQLArgs = []interface{}{}

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").
+	err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").And("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"`> 1").
-		Or("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` = ?", 3).Find(&records3)
+		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")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
-	err = testEngine.Sql("select * from " + testEngine.Quote(userinfo)).Find(&users2)
+	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")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
-	username := testEngine.ColumnMapper.Obj2Table("Username")
+	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")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
-	username := testEngine.ColumnMapper.Obj2Table("Username")
+	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")
+	userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo")
-	username := testEngine.ColumnMapper.Obj2Table("Username")
+	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_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")
+	colInt := testEngine.GetColumnMapper().Obj2Table("Int")
-	colFloat := testEngine.ColumnMapper.Obj2Table("Float")
+	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_tx_test.go

@@ -128,11 +128,11 @@ func TestCombineTransaction(t *testing.T) {
 func TestCombineTransactionSameMapper(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	oldMapper := testEngine.ColumnMapper
+	oldMapper := testEngine.GetColumnMapper()
-	testEngine.unMapType(rValue(new(Userinfo)).Type())
+	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)
 	}()
 

statement_test.go

@@ -163,10 +163,20 @@ func (TestType) TableName() string {
 }
 
 func createTestStatement() *Statement {
-	statement := &Statement{}
+	if engine, ok := testEngine.(*Engine); ok {
-	statement.Init()
+		statement := &Statement{}
-	statement.Engine = testEngine
+		statement.Init()
-	statement.setRefValue(reflect.ValueOf(TestType{}))
+		statement.Engine = engine
+		statement.setRefValue(reflect.ValueOf(TestType{}))
 
-	return statement
+		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")
+	ui := testEngine.GetTableMapper().Obj2Table("Userinfo")
-	ud := testEngine.TableMapper.Obj2Table("Userdetail")
+	ud := testEngine.GetTableMapper().Obj2Table("Userdetail")
-	uiid := testEngine.TableMapper.Obj2Table("Id")
+	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
+	oldMapper := testEngine.GetColumnMapper()
-	testEngine.unMapType(rValue(new(IDGonicMapper)).Type())
+	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
+	oldMapper := testEngine.GetColumnMapper()
-	testEngine.unMapType(rValue(new(IDSameMapper)).Type())
+	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"
@@ -304,7 +304,7 @@ func TestCustomType2(t *testing.T) {
 	err := testEngine.CreateTables(&UserCus{})
 	assert.NoError(t, err)
 
-	tableName := testEngine.TableMapper.Obj2Table("UserCus")
+	tableName := testEngine.GetTableMapper().Obj2Table("UserCus")
 	_, err = testEngine.Exec("delete from " + testEngine.Quote(tableName))
 	assert.NoError(t, err)
 
@@ -327,7 +327,7 @@ func TestCustomType2(t *testing.T) {
 	fmt.Println(user)
 
 	users := make([]UserCus, 0)
-	err = testEngine.Where("`"+testEngine.ColumnMapper.Obj2Table("Status")+"` = ?", "Registed").Find(&users)
+	err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Status")+"` = ?", "Registed").Find(&users)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(users))
 

xorm_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 var (
-	testEngine *Engine
+	testEngine EngineInterface
 	dbType     string
 	connString string
 
@@ -25,18 +25,25 @@ 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")
 )
 
 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, connStr)
+		}
 		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)