Merge branch 'master' into leafsoar

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)
@@ -1516,10 +1544,14 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
 	return results, lastError
 }
 
-// NowTime2 return current time
+// nowTime return current time
-func (engine *Engine) NowTime2(sqlTypeName string) (interface{}, time.Time) {
+func (engine *Engine) nowTime(col *core.Column) (interface{}, time.Time) {
 	t := time.Now()
-	return engine.formatTime(sqlTypeName, t.In(engine.DatabaseTZ)), t.In(engine.TZLocation)
+	var tz = engine.DatabaseTZ
+	if !col.DisableTimeZone && col.TimeZone != nil {
+		tz = col.TimeZone
+	}
+	return engine.formatTime(col.SQLType.Name, t.In(tz)), t.In(engine.TZLocation)
 }
 
 func (engine *Engine) formatColTime(col *core.Column, t time.Time) (v interface{}) {
@@ -1560,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)
+	}
+}

helpers.go

@@ -422,7 +422,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 
 		if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
 			// if time is non-empty, then set to auto time
-			val, t := session.engine.NowTime2(col.SQLType.Name)
+			val, t := session.engine.nowTime(col)
 			args = append(args, val)
 
 			var colName = col.Name

interface.go

@@ -0,0 +1,103 @@
+// 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
+	Desc(...string) *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
+	NoAutoCondition(...bool) *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)
+	UseBool(...string) *Session
+	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)
+	Sync(...interface{}) error
+	Sync2(...interface{}) error
+	StoreEngine(storeEngine string) *Session
+	TableInfo(bean interface{}) *Table
+	UnMapType(reflect.Type)
+}
+
+var (
+	_ Interface       = &Session{}
+	_ EngineInterface = &Engine{}
+	_ EngineInterface = &EngineGroup{}
+)

processors.go

@@ -29,13 +29,6 @@ type AfterSetProcessor interface {
 	AfterSet(string, Cell)
 }
 
-// !nashtsai! TODO enable BeforeValidateProcessor when xorm start to support validations
-//// Executed before an object is validated
-//type BeforeValidateProcessor interface {
-//    BeforeValidate()
-//}
-// --
-
 // AfterInsertProcessor executed after an object is persisted to the database
 type AfterInsertProcessor interface {
 	AfterInsert()
@@ -50,3 +43,36 @@ type AfterUpdateProcessor interface {
 type AfterDeleteProcessor interface {
 	AfterDelete()
 }
+
+// AfterLoadProcessor executed after an ojbect has been loaded from database
+type AfterLoadProcessor interface {
+	AfterLoad()
+}
+
+// AfterLoadSessionProcessor executed after an ojbect has been loaded from database with session parameter
+type AfterLoadSessionProcessor interface {
+	AfterLoad(*Session)
+}
+
+type executedProcessorFunc func(*Session, interface{}) error
+
+type executedProcessor struct {
+	fun     executedProcessorFunc
+	session *Session
+	bean    interface{}
+}
+
+func (executor *executedProcessor) execute() error {
+	return executor.fun(executor.session, executor.bean)
+}
+
+func (session *Session) executeProcessors() error {
+	processors := session.afterProcessors
+	session.afterProcessors = make([]executedProcessor, 0)
+	for _, processor := range processors {
+		if err := processor.execute(); err != nil {
+			return err
+		}
+	}
+	return nil
+}

processors_test.go

@@ -964,3 +964,87 @@ func TestProcessorsTx(t *testing.T) {
 	session.Close()
 	// --
 }
+
+type AfterLoadStructA struct {
+	Id      int64
+	Content string
+}
+
+type AfterLoadStructB struct {
+	Id      int64
+	Content string
+	AId     int64
+	A       AfterLoadStructA `xorm:"-"`
+	Err     error            `xorm:"-"`
+}
+
+func (s *AfterLoadStructB) AfterLoad(session *Session) {
+	has, err := session.ID(s.AId).NoAutoCondition().Get(&s.A)
+	if err != nil {
+		s.Err = err
+		return
+	}
+	if !has {
+		s.Err = ErrNotExist
+	}
+}
+
+func TestAfterLoadProcessor(t *testing.T) {
+	assert.NoError(t, prepareEngine())
+
+	assertSync(t, new(AfterLoadStructA), new(AfterLoadStructB))
+
+	var a = AfterLoadStructA{
+		Content: "testa",
+	}
+	_, err := testEngine.Insert(&a)
+	assert.NoError(t, err)
+
+	var b = AfterLoadStructB{
+		Content: "testb",
+		AId:     a.Id,
+	}
+	_, err = testEngine.Insert(&b)
+	assert.NoError(t, err)
+
+	var b2 AfterLoadStructB
+	has, err := testEngine.ID(b.Id).Get(&b2)
+	assert.NoError(t, err)
+	assert.True(t, has)
+	assert.EqualValues(t, a.Id, b2.A.Id)
+	assert.EqualValues(t, a.Content, b2.A.Content)
+	assert.NoError(t, b2.Err)
+
+	b.Id = 0
+	_, err = testEngine.Insert(&b)
+	assert.NoError(t, err)
+
+	var bs []AfterLoadStructB
+	err = testEngine.Find(&bs)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 2, len(bs))
+	for i := 0; i < len(bs); i++ {
+		assert.EqualValues(t, a.Id, bs[i].A.Id)
+		assert.EqualValues(t, a.Content, bs[i].A.Content)
+		assert.NoError(t, bs[i].Err)
+	}
+}
+
+type AfterInsertStruct struct {
+	Id int64
+}
+
+func (a *AfterInsertStruct) AfterInsert() {
+	if a.Id == 0 {
+		panic("a.Id")
+	}
+}
+
+func TestAfterInsert(t *testing.T) {
+	assert.NoError(t, prepareEngine())
+
+	assertSync(t, new(AfterInsertStruct))
+
+	_, err := testEngine.Insert(&AfterInsertStruct{})
+	assert.NoError(t, err)
+}

rows.go

@@ -99,13 +99,17 @@ func (rows *Rows) Scan(bean interface{}) error {
 		return err
 	}
 
-	scanResults, err := rows.session.row2Slice(rows.rows, rows.fields, len(rows.fields), bean)
+	scanResults, err := rows.session.row2Slice(rows.rows, rows.fields, bean)
 	if err != nil {
 		return err
 	}
 
-	_, err = rows.session.slice2Bean(scanResults, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.statement.RefTable)
+	_, err = rows.session.slice2Bean(scanResults, rows.fields, bean, &dataStruct, rows.session.statement.RefTable)
-	return err
+	if err != nil {
+		return err
+	}
+
+	return rows.session.executeProcessors()
 }
 
 // Close session if session.IsAutoClose is true, and claimed any opened resources

session.go

@@ -41,6 +41,8 @@ type Session struct {
 	beforeClosures []func(interface{})
 	afterClosures  []func(interface{})
 
+	afterProcessors []executedProcessor
+
 	prepareStmt bool
 	stmtCache   map[uint32]*core.Stmt //key: hash.Hash32 of (queryStr, len(queryStr))
 
@@ -74,6 +76,9 @@ 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)
 
 	session.lastSQL = ""
 	session.lastSQLArgs = []interface{}{}
@@ -258,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
 		}
@@ -296,37 +301,40 @@ func (session *Session) getField(dataStruct *reflect.Value, key string, table *c
 // Cell cell is a result of one column field
 type Cell *interface{}
 
-func (session *Session) rows2Beans(rows *core.Rows, fields []string, fieldsCount int,
+func (session *Session) rows2Beans(rows *core.Rows, fields []string,
 	table *core.Table, newElemFunc func([]string) reflect.Value,
 	sliceValueSetFunc func(*reflect.Value, core.PK) error) error {
 	for rows.Next() {
 		var newValue = newElemFunc(fields)
 		bean := newValue.Interface()
-		dataStruct := rValue(bean)
+		dataStruct := newValue.Elem()
 
 		// handle beforeClosures
-		scanResults, err := session.row2Slice(rows, fields, fieldsCount, bean)
+		scanResults, err := session.row2Slice(rows, fields, bean)
 		if err != nil {
 			return err
 		}
-		pk, err := session.slice2Bean(scanResults, fields, fieldsCount, bean, &dataStruct, table)
+		pk, err := session.slice2Bean(scanResults, fields, bean, &dataStruct, table)
-		if err != nil {
-			return err
-		}
-		err = sliceValueSetFunc(&newValue, pk)
 		if err != nil {
 			return err
 		}
+		session.afterProcessors = append(session.afterProcessors, executedProcessor{
+			fun: func(*Session, interface{}) error {
+				return sliceValueSetFunc(&newValue, pk)
+			},
+			session: session,
+			bean:    bean,
+		})
 	}
 	return nil
 }
 
-func (session *Session) row2Slice(rows *core.Rows, fields []string, fieldsCount int, bean interface{}) ([]interface{}, error) {
+func (session *Session) row2Slice(rows *core.Rows, fields []string, bean interface{}) ([]interface{}, error) {
 	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
 
-	scanResults := make([]interface{}, fieldsCount)
+	scanResults := make([]interface{}, len(fields))
 	for i := 0; i < len(fields); i++ {
 		var cell interface{}
 		scanResults[i] = &cell
@@ -343,20 +351,49 @@ func (session *Session) row2Slice(rows *core.Rows, fields []string, fieldsCount
 	return scanResults, nil
 }
 
-func (session *Session) slice2Bean(scanResults []interface{}, fields []string, fieldsCount int, bean interface{}, dataStruct *reflect.Value, table *core.Table) (core.PK, error) {
+func (session *Session) slice2Bean(scanResults []interface{}, fields []string, bean interface{}, dataStruct *reflect.Value, table *core.Table) (core.PK, error) {
 	defer func() {
 		if b, hasAfterSet := bean.(AfterSetProcessor); hasAfterSet {
 			for ii, key := range fields {
 				b.AfterSet(key, Cell(scanResults[ii].(*interface{})))
 			}
 		}
-
-		// handle afterClosures
-		for _, closure := range session.afterClosures {
-			closure(bean)
-		}
 	}()
 
+	// handle afterClosures
+	for _, closure := range session.afterClosures {
+		session.afterProcessors = append(session.afterProcessors, executedProcessor{
+			fun: func(sess *Session, bean interface{}) error {
+				closure(bean)
+				return nil
+			},
+			session: session,
+			bean:    bean,
+		})
+	}
+
+	if a, has := bean.(AfterLoadProcessor); has {
+		session.afterProcessors = append(session.afterProcessors, executedProcessor{
+			fun: func(sess *Session, bean interface{}) error {
+				a.AfterLoad()
+				return nil
+			},
+			session: session,
+			bean:    bean,
+		})
+	}
+
+	if a, has := bean.(AfterLoadSessionProcessor); has {
+		session.afterProcessors = append(session.afterProcessors, executedProcessor{
+			fun: func(sess *Session, bean interface{}) error {
+				a.AfterLoad(sess)
+				return nil
+			},
+			session: session,
+			bean:    bean,
+		})
+	}
+
 	var tempMap = make(map[string]int)
 	var pk core.PK
 	for ii, key := range fields {

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

@@ -184,12 +184,12 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 			}
 		}
 
-		// !oinume! Insert NowTime to the head of session.statement.Params
+		// !oinume! Insert nowTime to the head of session.statement.Params
 		condArgs = append(condArgs, "")
 		paramsLen := len(condArgs)
 		copy(condArgs[1:paramsLen], condArgs[0:paramsLen-1])
 
-		val, t := session.engine.NowTime2(deletedColumn.SQLType.Name)
+		val, t := session.engine.nowTime(deletedColumn)
 		condArgs[0] = val
 
 		var colName = deletedColumn.Name

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

@@ -239,7 +239,12 @@ func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Va
 		if err != nil {
 			return err
 		}
-		return session.rows2Beans(rows, fields, len(fields), tb, newElemFunc, containerValueSetFunc)
+		err = session.rows2Beans(rows, fields, tb, newElemFunc, containerValueSetFunc)
+		rows.Close()
+		if err != nil {
+			return err
+		}
+		return session.executeProcessors()
 	}
 
 	for rows.Next() {

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

@@ -87,7 +87,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, table *core.Table, bea
 			return true, err
 		}
 
-		scanResults, err := session.row2Slice(rows, fields, len(fields), bean)
+		scanResults, err := session.row2Slice(rows, fields, bean)
 		if err != nil {
 			return false, err
 		}
@@ -95,7 +95,12 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, table *core.Table, bea
 		rows.Close()
 
 		dataStruct := rValue(bean)
-		_, err = session.slice2Bean(scanResults, fields, len(fields), bean, &dataStruct, table)
+		_, err = session.slice2Bean(scanResults, fields, bean, &dataStruct, table)
+		if err != nil {
+			return true, err
+		}
+
+		return true, session.executeProcessors()
 	case reflect.Slice:
 		err = rows.ScanSlice(bean)
 	case reflect.Map:

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

@@ -126,7 +126,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 					}
 				}
 				if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
-					val, t := session.engine.NowTime2(col.SQLType.Name)
+					val, t := session.engine.nowTime(col)
 					args = append(args, val)
 
 					var colName = col.Name
@@ -181,7 +181,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 					}
 				}
 				if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
-					val, t := session.engine.NowTime2(col.SQLType.Name)
+					val, t := session.engine.nowTime(col)
 					args = append(args, val)
 
 					var colName = col.Name
@@ -400,7 +400,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 			return 0, err
 		}
 
-		handleAfterInsertProcessorFunc(bean)
+		defer handleAfterInsertProcessorFunc(bean)
 
 		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
 			session.cacheInsert(table, tableName)
@@ -445,7 +445,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		if err != nil {
 			return 0, err
 		}
-		handleAfterInsertProcessorFunc(bean)
+		defer handleAfterInsertProcessorFunc(bean)
 
 		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
 			session.cacheInsert(table, tableName)

session_insert_test.go

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

session_raw.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)
 	}()
 

session_update.go

@@ -205,7 +205,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		if _, ok := session.statement.columnMap[strings.ToLower(table.Updated)]; !ok {
 			colNames = append(colNames, session.engine.Quote(table.Updated)+" = ?")
 			col := table.UpdatedColumn()
-			val, t := session.engine.NowTime2(col.SQLType.Name)
+			val, t := session.engine.nowTime(col)
 			args = append(args, val)
 
 			var colName = col.Name

session_update_test.go

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

statement_test.go

@@ -163,10 +163,20 @@ func (TestType) TableName() string {
 }
 
 func createTestStatement() *Statement {
-	statement := &Statement{}
+	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,26 @@ var (
 	ptrConnStr = flag.String("conn_str", "./test.db?cache=shared&mode=rwc", "test database connection string")
 	mapType    = flag.String("map_type", "snake", "indicate the name mapping")
 	cache      = flag.Bool("cache", false, "if enable cache")
+	cluster    = flag.Bool("cluster", false, "if this is a cluster")
+	splitter   = flag.String("splitter", ";", "the splitter on connstr for cluster")
 )
 
 func createEngine(dbType, connStr string) error {
 	if testEngine == nil {
 		var err error
-		testEngine, err = NewEngine(dbType, connStr)
+
+		if !*cluster {
+			testEngine, err = NewEngine(dbType, connStr)
+
+		} else {
+			testEngine, err = NewEngineGroup(dbType, strings.Split(connStr, *splitter))
+		}
 		if err != nil {
 			return err
 		}
 
 		testEngine.ShowSQL(*showSQL)
-		testEngine.logger.SetLevel(core.LOG_DEBUG)
+		testEngine.SetLogLevel(core.LOG_DEBUG)
 		if *cache {
 			cacher := NewLRUCacher(NewMemoryStore(), 100000)
 			testEngine.SetDefaultCacher(cacher)