Merge caf55f1ca3 into 29d4a0330a

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

@@ -47,6 +47,23 @@ type Engine struct {
 	disableGlobalCache bool
 
 	tagHandlers map[string]tagHandler
+
+	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
@@ -79,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 {
@@ -201,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 {
@@ -757,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)
@@ -1564,24 +1592,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

@@ -0,0 +1,194 @@
+// 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 (
+	"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 {
+		eg.policy = policies[0]
+	} else {
+		eg.policy = RoundRobinPolicy()
+	}
+
+	driverName, ok1 := args1.(string)
+	conns, ok2 := args2.([]string)
+	if ok1 && ok2 {
+		engines := make([]*Engine, len(conns))
+		for i, conn := range conns {
+			engine, err := NewEngine(driverName, conn)
+			if err != nil {
+				return nil, err
+			}
+			engine.engineGroup = &eg
+			engines[i] = engine
+		}
+
+		eg.Engine = engines[0]
+		eg.slaves = engines[1:]
+		return &eg, nil
+	}
+
+	master, ok3 := args1.(*Engine)
+	slaves, ok4 := args2.([]*Engine)
+	if ok3 && ok4 {
+		master.engineGroup = &eg
+		for i := 0; i < len(slaves); i++ {
+			slaves[i].engineGroup = &eg
+		}
+		eg.Engine = master
+		eg.slaves = slaves
+		return &eg, nil
+	}
+	return nil, ErrParamsType
+}
+
+// Close the engine
+func (eg *EngineGroup) Close() error {
+	err := eg.Engine.Close()
+	if err != nil {
+		return err
+	}
+
+	for i := 0; i < len(eg.slaves); i++ {
+		err := eg.slaves[i].Close()
+		if err != nil {
+			return err
+		}
+	}
+	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 {
+		return err
+	}
+
+	for _, slave := range eg.slaves {
+		if err := slave.Ping(); err != nil {
+			return err
+		}
+	}
+	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
+}

engine_group_policy.go

@@ -0,0 +1,116 @@
+// 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 (
+	"math/rand"
+	"sync"
+	"time"
+)
+
+// GroupPolicy is be used by chosing the current slave from slaves
+type GroupPolicy interface {
+	Slave(*EngineGroup) *Engine
+}
+
+// GroupPolicyHandler should be used when a function is a GroupPolicy
+type GroupPolicyHandler func(*EngineGroup) *Engine
+
+// Slave implements the chosen of slaves
+func (h GroupPolicyHandler) Slave(eg *EngineGroup) *Engine {
+	return h(eg)
+}
+
+// RandomPolicy implmentes randomly chose the slave of slaves
+func RandomPolicy() GroupPolicyHandler {
+	var r = rand.New(rand.NewSource(time.Now().UnixNano()))
+	return func(g *EngineGroup) *Engine {
+		return g.Slaves()[r.Intn(len(g.Slaves()))]
+	}
+}
+
+// WeightRandomPolicy implmentes randomly chose the slave of slaves
+func WeightRandomPolicy(weights []int) GroupPolicyHandler {
+	var rands = make([]int, 0, len(weights))
+	for i := 0; i < len(weights); i++ {
+		for n := 0; n < weights[i]; n++ {
+			rands = append(rands, i)
+		}
+	}
+	var r = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	return func(g *EngineGroup) *Engine {
+		var slaves = g.Slaves()
+		idx := rands[r.Intn(len(rands))]
+		if idx >= len(slaves) {
+			idx = len(slaves) - 1
+		}
+		return slaves[idx]
+	}
+}
+
+func RoundRobinPolicy() GroupPolicyHandler {
+	var pos = -1
+	var lock sync.Mutex
+	return func(g *EngineGroup) *Engine {
+		var slaves = g.Slaves()
+
+		lock.Lock()
+		defer lock.Unlock()
+		pos++
+		if pos >= len(slaves) {
+			pos = 0
+		}
+
+		return slaves[pos]
+	}
+}
+
+func WeightRoundRobinPolicy(weights []int) GroupPolicyHandler {
+	var rands = make([]int, 0, len(weights))
+	for i := 0; i < len(weights); i++ {
+		for n := 0; n < weights[i]; n++ {
+			rands = append(rands, i)
+		}
+	}
+	var pos = -1
+	var lock sync.Mutex
+
+	return func(g *EngineGroup) *Engine {
+		var slaves = g.Slaves()
+		lock.Lock()
+		defer lock.Unlock()
+		pos++
+		if pos >= len(rands) {
+			pos = 0
+		}
+
+		idx := rands[pos]
+		if idx >= len(slaves) {
+			idx = len(slaves) - 1
+		}
+		return slaves[idx]
+	}
+}
+
+// LeastConnPolicy implements GroupPolicy, every time will get the least connections slave
+func LeastConnPolicy() GroupPolicyHandler {
+	return func(g *EngineGroup) *Engine {
+		var slaves = g.Slaves()
+		connections := 0
+		idx := 0
+		for i := 0; i < len(slaves); i++ {
+			openConnections := slaves[i].DB().Stats().OpenConnections
+			if i == 0 {
+				connections = openConnections
+				idx = i
+			} else if openConnections <= connections {
+				connections = openConnections
+				idx = i
+			}
+		}
+		return slaves[idx]
+	}
+}

engine_maxlife.go

@@ -12,3 +12,11 @@ import "time"
 func (engine *Engine) SetConnMaxLifetime(d time.Duration) {
 	engine.db.SetConnMaxLifetime(d)
 }
+
+// SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
+func (eg *EngineGroup) SetConnMaxLifetime(d time.Duration) {
+	eg.Engine.SetConnMaxLifetime(d)
+	for i := 0; i < len(eg.slaves); i++ {
+		eg.slaves[i].SetConnMaxLifetime(d)
+	}
+}

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

@@ -76,6 +76,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)
 
@@ -262,13 +263,13 @@ func (session *Session) canCache() bool {
 	return true
 }
 
-func (session *Session) doPrepare(sqlStr string) (stmt *core.Stmt, err error) {
+func (session *Session) doPrepare(db *core.DB, sqlStr string) (stmt *core.Stmt, err error) {
 	crc := crc32.ChecksumIEEE([]byte(sqlStr))
 	// TODO try hash(sqlStr+len(sqlStr))
 	var has bool
 	stmt, has = session.stmtCache[crc]
 	if !has {
-		stmt, err = session.DB().Prepare(sqlStr)
+		stmt, err = db.Prepare(sqlStr)
 		if err != nil {
 			return nil, err
 		}

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_insert_test.go

@@ -5,9 +5,6 @@
 package xorm
 
 import (
-	"errors"
-	"fmt"
-	"reflect"
 	"testing"
 	"time"
 
@@ -30,635 +27,18 @@ func TestInsertOne(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestInsertMulti(t *testing.T) {
+func TestInsertOne2(t *testing.T) {
-
-	assert.NoError(t, prepareEngine())
-	type TestMulti struct {
-		Id   int64  `xorm:"int(11) pk"`
-		Name string `xorm:"varchar(255)"`
-	}
-
-	assert.NoError(t, testEngine.Sync2(new(TestMulti)))
-
-	num, err := insertMultiDatas(1,
-		append([]TestMulti{}, TestMulti{1, "test1"}, TestMulti{2, "test2"}, TestMulti{3, "test3"}))
-	assert.NoError(t, err)
-	assert.EqualValues(t, 3, num)
-}
-
-func insertMultiDatas(step int, datas interface{}) (num int64, err error) {
-	sliceValue := reflect.Indirect(reflect.ValueOf(datas))
-	var iLen int64
-	if sliceValue.Kind() != reflect.Slice {
-		return 0, fmt.Errorf("not silce")
-	}
-	iLen = int64(sliceValue.Len())
-	if iLen == 0 {
-		return
-	}
-
-	session := testEngine.NewSession()
-	defer session.Close()
-
-	if err = callbackLooper(datas, step,
-		func(innerDatas interface{}) error {
-			n, e := session.InsertMulti(innerDatas)
-			if e != nil {
-				return e
-			}
-			num += n
-			return nil
-		}); err != nil {
-		return 0, err
-	} else if num != iLen {
-		return 0, fmt.Errorf("num error: %d - %d", num, iLen)
-	}
-	return
-}
-
-func callbackLooper(datas interface{}, step int, actionFunc func(interface{}) error) (err error) {
-
-	sliceValue := reflect.Indirect(reflect.ValueOf(datas))
-	if sliceValue.Kind() != reflect.Slice {
-		return fmt.Errorf("not slice")
-	}
-	if sliceValue.Len() <= 0 {
-		return
-	}
-
-	tempLen := 0
-	processedLen := sliceValue.Len()
-	for i := 0; i < sliceValue.Len(); i += step {
-		if processedLen > step {
-			tempLen = i + step
-		} else {
-			tempLen = sliceValue.Len()
-		}
-		var tempInterface []interface{}
-		for j := i; j < tempLen; j++ {
-			tempInterface = append(tempInterface, sliceValue.Index(j).Interface())
-		}
-		if err = actionFunc(tempInterface); err != nil {
-			return
-		}
-		processedLen = processedLen - step
-	}
-	return
-}
-
-func TestInsertOneIfPkIsPoint(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
-	type TestPoint struct {
+	type Test2 struct {
-		Id      *int64     `xorm:"autoincr pk notnull 'id'"`
-		Msg     *string    `xorm:"varchar(255)"`
-		Created *time.Time `xorm:"created"`
-	}
-
-	assert.NoError(t, testEngine.Sync2(new(TestPoint)))
-	msg := "hi"
-	data := TestPoint{Msg: &msg}
-	_, err := testEngine.InsertOne(&data)
-	assert.NoError(t, err)
-}
-
-func TestInsertOneIfPkIsPointRename(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-	type ID *int64
-	type TestPoint2 struct {
-		Id      ID         `xorm:"autoincr pk notnull 'id'"`
-		Msg     *string    `xorm:"varchar(255)"`
-		Created *time.Time `xorm:"created"`
-	}
-
-	assert.NoError(t, testEngine.Sync2(new(TestPoint2)))
-	msg := "hi"
-	data := TestPoint2{Msg: &msg}
-	_, err := testEngine.InsertOne(&data)
-	assert.NoError(t, err)
-}
-
-func TestInsert(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-	assertSync(t, new(Userinfo))
-
-	user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(),
-		Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, true}
-	cnt, err := testEngine.Insert(&user)
-	fmt.Println(user.Uid)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-	if cnt != 1 {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-	}
-
-	if user.Uid <= 0 {
-		err = errors.New("not return id error")
-		t.Error(err)
-		panic(err)
-	}
-
-	user.Uid = 0
-	cnt, err = testEngine.Insert(&user)
-	if err == nil {
-		err = errors.New("insert failed but no return error")
-		t.Error(err)
-		panic(err)
-	}
-	if cnt != 0 {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-		return
-	}
-}
-
-func TestInsertAutoIncr(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	assertSync(t, new(Userinfo))
-
-	// auto increment insert
-	user := Userinfo{Username: "xiaolunwen2", Departname: "dev", Alias: "lunny", Created: time.Now(),
-		Detail: Userdetail{Id: 1}, Height: 1.78, Avatar: []byte{1, 2, 3}, IsMan: true}
-	cnt, err := testEngine.Insert(&user)
-	fmt.Println(user.Uid)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-	if cnt != 1 {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-	}
-	if user.Uid <= 0 {
-		t.Error(errors.New("not return id error"))
-	}
-}
-
-type DefaultInsert struct {
-	Id      int64
-	Status  int `xorm:"default -1"`
-	Name    string
-	Created time.Time `xorm:"created"`
-	Updated time.Time `xorm:"updated"`
-}
-
-func TestInsertDefault(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	di := new(DefaultInsert)
-	err := testEngine.Sync2(di)
-	if err != nil {
-		t.Error(err)
-	}
-
-	var di2 = DefaultInsert{Name: "test"}
-	_, err = testEngine.Omit(testEngine.ColumnMapper.Obj2Table("Status")).Insert(&di2)
-	if err != nil {
-		t.Error(err)
-	}
-
-	has, err := testEngine.Desc("(id)").Get(di)
-	if err != nil {
-		t.Error(err)
-	}
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
-	if di.Status != -1 {
-		err = errors.New("inserted error data")
-		t.Error(err)
-		panic(err)
-	}
-	if di2.Updated.Unix() != di.Updated.Unix() {
-		err = errors.New("updated should equal")
-		t.Error(err, di.Updated, di2.Updated)
-		panic(err)
-	}
-	if di2.Created.Unix() != di.Created.Unix() {
-		err = errors.New("created should equal")
-		t.Error(err, di.Created, di2.Created)
-		panic(err)
-	}
-}
-
-type DefaultInsert2 struct {
-	Id        int64
-	Name      string
-	Url       string    `xorm:"text"`
-	CheckTime time.Time `xorm:"not null default '2000-01-01 00:00:00' TIMESTAMP"`
-}
-
-func TestInsertDefault2(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	di := new(DefaultInsert2)
-	err := testEngine.Sync2(di)
-	if err != nil {
-		t.Error(err)
-	}
-
-	var di2 = DefaultInsert2{Name: "test"}
-	_, err = testEngine.Omit(testEngine.ColumnMapper.Obj2Table("CheckTime")).Insert(&di2)
-	if err != nil {
-		t.Error(err)
-	}
-
-	has, err := testEngine.Desc("(id)").Get(di)
-	if err != nil {
-		t.Error(err)
-	}
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
-
-	has, err = testEngine.NoAutoCondition().Desc("(id)").Get(&di2)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
-
-	if *di != di2 {
-		err = fmt.Errorf("%v is not equal to %v", di, di2)
-		t.Error(err)
-		panic(err)
-	}
-
-	/*if di2.Updated.Unix() != di.Updated.Unix() {
-		err = errors.New("updated should equal")
-		t.Error(err, di.Updated, di2.Updated)
-		panic(err)
-	}
-	if di2.Created.Unix() != di.Created.Unix() {
-		err = errors.New("created should equal")
-		t.Error(err, di.Created, di2.Created)
-		panic(err)
-	}*/
-}
-
-type CreatedInsert struct {
-	Id      int64
-	Created time.Time `xorm:"created"`
-}
-
-type CreatedInsert2 struct {
-	Id      int64
-	Created int64 `xorm:"created"`
-}
-
-type CreatedInsert3 struct {
-	Id      int64
-	Created int `xorm:"created bigint"`
-}
-
-type CreatedInsert4 struct {
-	Id      int64
-	Created int `xorm:"created"`
-}
-
-type CreatedInsert5 struct {
-	Id      int64
-	Created time.Time `xorm:"created bigint"`
-}
-
-type CreatedInsert6 struct {
-	Id      int64
-	Created time.Time `xorm:"created bigint"`
-}
-
-func TestInsertCreated(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	di := new(CreatedInsert)
-	err := testEngine.Sync2(di)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ci := &CreatedInsert{}
-	_, err = testEngine.Insert(ci)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	has, err := testEngine.Desc("(id)").Get(di)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci.Created.Unix() != di.Created.Unix() {
-		t.Fatal("should equal:", ci, di)
-	}
-	fmt.Println("ci:", ci, "di:", di)
-
-	di2 := new(CreatedInsert2)
-	err = testEngine.Sync2(di2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ci2 := &CreatedInsert2{}
-	_, err = testEngine.Insert(ci2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci2.Created != di2.Created {
-		t.Fatal("should equal:", ci2, di2)
-	}
-	fmt.Println("ci2:", ci2, "di2:", di2)
-
-	di3 := new(CreatedInsert3)
-	err = testEngine.Sync2(di3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ci3 := &CreatedInsert3{}
-	_, err = testEngine.Insert(ci3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci3.Created != di3.Created {
-		t.Fatal("should equal:", ci3, di3)
-	}
-	fmt.Println("ci3:", ci3, "di3:", di3)
-
-	di4 := new(CreatedInsert4)
-	err = testEngine.Sync2(di4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ci4 := &CreatedInsert4{}
-	_, err = testEngine.Insert(ci4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci4.Created != di4.Created {
-		t.Fatal("should equal:", ci4, di4)
-	}
-	fmt.Println("ci4:", ci4, "di4:", di4)
-
-	di5 := new(CreatedInsert5)
-	err = testEngine.Sync2(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ci5 := &CreatedInsert5{}
-	_, err = testEngine.Insert(ci5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci5.Created.Unix() != di5.Created.Unix() {
-		t.Fatal("should equal:", ci5, di5)
-	}
-	fmt.Println("ci5:", ci5, "di5:", di5)
-
-	di6 := new(CreatedInsert6)
-	err = testEngine.Sync2(di6)
-	if err != nil {
-		t.Fatal(err)
-	}
-	oldTime := time.Now().Add(-time.Hour)
-	ci6 := &CreatedInsert6{Created: oldTime}
-	_, err = testEngine.Insert(ci6)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	has, err = testEngine.Desc("(id)").Get(di6)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if ci6.Created.Unix() != di6.Created.Unix() {
-		t.Fatal("should equal:", ci6, di6)
-	}
-	fmt.Println("ci6:", ci6, "di6:", di6)
-}
-
-type JsonTime time.Time
-
-func (j JsonTime) format() string {
-	t := time.Time(j)
-	if t.IsZero() {
-		return ""
-	}
-
-	return t.Format("2006-01-02")
-}
-
-func (j JsonTime) MarshalText() ([]byte, error) {
-	return []byte(j.format()), nil
-}
-
-func (j JsonTime) MarshalJSON() ([]byte, error) {
-	return []byte(`"` + j.format() + `"`), nil
-}
-
-func TestDefaultTime3(t *testing.T) {
-	type PrepareTask struct {
-		Id int `xorm:"not null pk autoincr INT(11)" json:"id"`
-		// ...
-		StartTime JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP index" json:"start_time"`
-		EndTime   JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP" json:"end_time"`
-		Cuser     string   `xorm:"not null default '' VARCHAR(64) index" json:"cuser"`
-		Muser     string   `xorm:"not null default '' VARCHAR(64)" json:"muser"`
-		Ctime     JsonTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP created" json:"ctime"`
-		Mtime     JsonTime `xorm:"not null default CURRENT_TIMESTAMP TIMESTAMP updated" json:"mtime"`
-	}
-
-	assert.NoError(t, prepareEngine())
-	assertSync(t, new(PrepareTask))
-
-	prepareTask := &PrepareTask{
-		StartTime: JsonTime(time.Now()),
-		Cuser:     "userId",
-		Muser:     "userId",
-	}
-	cnt, err := testEngine.Omit("end_time").InsertOne(prepareTask)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, cnt)
-}
-
-type MyJsonTime struct {
-	Id      int64    `json:"id"`
-	Created JsonTime `xorm:"created" json:"created_at"`
-}
-
-func TestCreatedJsonTime(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	di5 := new(MyJsonTime)
-	err := testEngine.Sync2(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ci5 := &MyJsonTime{}
-	_, err = testEngine.Insert(ci5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err := testEngine.Desc("(id)").Get(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if time.Time(ci5.Created).Unix() != time.Time(di5.Created).Unix() {
-		t.Fatal("should equal:", time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix())
-	}
-	fmt.Println("ci5:", ci5, "di5:", di5)
-
-	var dis = make([]MyJsonTime, 0)
-	err = testEngine.Find(&dis)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestInsertMulti2(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	assertSync(t, new(Userinfo))
-
-	users := []Userinfo{
-		{Username: "xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
-		{Username: "xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()},
-		{Username: "xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()},
-		{Username: "xlw22", Departname: "dev", Alias: "lunny3", Created: time.Now()},
-	}
-	cnt, err := testEngine.Insert(&users)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-	if cnt != int64(len(users)) {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-		return
-	}
-
-	users2 := []*Userinfo{
-		&Userinfo{Username: "1xlw", Departname: "dev", Alias: "lunny2", Created: time.Now()},
-		&Userinfo{Username: "1xlw2", Departname: "dev", Alias: "lunny3", Created: time.Now()},
-		&Userinfo{Username: "1xlw11", Departname: "dev", Alias: "lunny2", Created: time.Now()},
-		&Userinfo{Username: "1xlw22", Departname: "dev", Alias: "lunny3", Created: time.Now()},
-	}
-
-	cnt, err = testEngine.Insert(&users2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-
-	if cnt != int64(len(users2)) {
-		err = errors.New(fmt.Sprintf("insert not returned %v", len(users2)))
-		t.Error(err)
-		panic(err)
-	}
-}
-
-func TestInsertTwoTable(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	assertSync(t, new(Userinfo), new(Userdetail))
-
-	userdetail := Userdetail{ /*Id: 1, */ Intro: "I'm a very beautiful women.", Profile: "sfsaf"}
-	userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail}
-
-	cnt, err := testEngine.Insert(&userinfo, &userdetail)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-
-	if userinfo.Uid <= 0 {
-		err = errors.New("not return id error")
-		t.Error(err)
-		panic(err)
-	}
-
-	if userdetail.Id <= 0 {
-		err = errors.New("not return id error")
-		t.Error(err)
-		panic(err)
-	}
-
-	if cnt != 2 {
-		err = errors.New("insert not returned 2")
-		t.Error(err)
-		panic(err)
-	}
-}
-
-func TestInsertCreatedInt64(t *testing.T) {
-	assert.NoError(t, prepareEngine())
-
-	type TestCreatedInt64 struct {
 		Id      int64     `xorm:"autoincr pk"`
 		Msg     string    `xorm:"varchar(255)"`
-		Created int64  `xorm:"created"`
+		Created time.Time `xorm:"datetime created"`
 	}
 
-	assert.NoError(t, testEngine.Sync2(new(TestCreatedInt64)))
+	assert.NoError(t, testEngine.Sync2(new(Test2)))
 
-	data := TestCreatedInt64{Msg: "hi"}
+	data := Test2{Msg: "hi"}
-	now := time.Now()
+	_, err := testEngine.InsertOne(data)
-	cnt, err := testEngine.Insert(&data)
 	assert.NoError(t, err)
-	assert.EqualValues(t, 1, cnt)
-	assert.True(t, now.Unix() <= data.Created)
-
-	var data2 TestCreatedInt64
-	has, err := testEngine.Get(&data2)
-	assert.NoError(t, err)
-	assert.True(t, has)
-
-	assert.EqualValues(t, data.Created, data2.Created)
 }

session_raw.go

@@ -47,9 +47,16 @@ func (session *Session) queryRows(sqlStr string, args ...interface{}) (*core.Row
 	}
 
 	if session.isAutoCommit {
+		var db *core.DB
+		if session.engine.engineGroup != nil {
+			db = session.engine.engineGroup.Slave().DB()
+		} else {
+			db = session.DB()
+		}
+
 		if session.prepareStmt {
 			// don't clear stmt since session will cache them
-			stmt, err := session.doPrepare(sqlStr)
+			stmt, err := session.doPrepare(db, sqlStr)
 			if err != nil {
 				return nil, err
 			}
@@ -61,7 +68,7 @@ func (session *Session) queryRows(sqlStr string, args ...interface{}) (*core.Row
 			return rows, nil
 		}
 
-		rows, err := session.DB().Query(sqlStr, args...)
+		rows, err := db.Query(sqlStr, args...)
 		if err != nil {
 			return nil, err
 		}
@@ -171,7 +178,7 @@ func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, er
 	}
 
 	if session.prepareStmt {
-		stmt, err := session.doPrepare(sqlStr)
+		stmt, err := session.doPrepare(session.DB(), sqlStr)
 		if err != nil {
 			return nil, 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 {
+	if engine, ok := testEngine.(*Engine); ok {
 		statement := &Statement{}
 		statement.Init()
-	statement.Engine = testEngine
+		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")
+	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,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
+
+		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)