1.improve the NewEngineGroup interface

2.change the default policy of engine group

engine_group.go

@@ -5,29 +5,28 @@
 package xorm
 
 import (
-	"strings"
-
 	"github.com/xormplus/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 = RandomPolicy()
+		eg.policy = RoundRobinPolicy()
 	}
 
 	driverName, ok1 := args1.(string)
-	dataSourceNames, ok2 := args2.(string)
+	conns, ok2 := args2.([]string)
 	if ok1 && ok2 {
-		conns := strings.Split(dataSourceNames, ";")
 		engines := make([]*Engine, len(conns))
 		for i, conn := range conns {
 			engine, err := NewEngine(driverName, conn)
@@ -57,55 +56,54 @@ func NewEngineGroup(args1 interface{}, args2 interface{}, policies ...GroupPolic
 	return nil, ErrParamsType
 }
 
-func (eg *EngineGroup) SetPolicy(policy GroupPolicy) *EngineGroup {
-	eg.policy = policy
-	return eg
+// 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
 }
 
-// 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]
+// Ping tests if database is alive
+func (eg *EngineGroup) Ping() error {
+	if err := eg.Engine.Ping(); err != nil {
+		return err
 	}
-	return eg.policy.Slave(eg)
-}
 
-func (eg *EngineGroup) Slaves() []*Engine {
-	return eg.slaves
-}
-
-func (eg *EngineGroup) GetSlave(i int) *Engine {
-	return eg.slaves[i]
-}
-
-// ShowSQL show SQL statement or not on logger if log level is great than INFO
-func (eg *EngineGroup) ShowSQL(show ...bool) {
-	eg.Engine.ShowSQL(show...)
-	for i := 0; i < len(eg.slaves); i++ {
-		eg.slaves[i].ShowSQL(show...)
+	for _, slave := range eg.slaves {
+		if err := slave.Ping(); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
-// 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...)
+// 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].ShowExecTime(show...)
+		eg.slaves[i].ColumnMapper = mapper
 	}
 }
 
-// SetMapper set the name mapping rules
-func (eg *EngineGroup) SetMapper(mapper core.IMapper) {
-	eg.Engine.SetMapper(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].SetMapper(mapper)
+		eg.slaves[i].SetDefaultCacher(cacher)
 	}
 }
 
@@ -117,19 +115,27 @@ func (eg *EngineGroup) SetLogger(logger core.ILogger) {
 	}
 }
 
-// SetTableMapper set the table name mapping rule
-func (eg *EngineGroup) SetTableMapper(mapper core.IMapper) {
-	eg.Engine.TableMapper = mapper
+// 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].TableMapper = mapper
+		eg.slaves[i].SetLogLevel(level)
 	}
 }
 
-// SetColumnMapper set the column name mapping rule
-func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) {
-	eg.Engine.ColumnMapper = mapper
+// 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].ColumnMapper = mapper
+		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)
 	}
 }
 
@@ -141,40 +147,48 @@ func (eg *EngineGroup) SetMaxOpenConns(conns int) {
 	}
 }
 
-// SetMaxIdleConns set the max idle connections on pool, default is 2
-func (eg *EngineGroup) SetMaxIdleConns(conns int) {
-	eg.Engine.db.SetMaxIdleConns(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].db.SetMaxIdleConns(conns)
+		eg.slaves[i].TableMapper = mapper
 	}
 }
 
-// Close the engine
-func (eg *EngineGroup) Close() error {
-	err := eg.Engine.Close()
-	if err != nil {
-		return err
+// 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++ {
-		err := eg.slaves[i].Close()
-		if err != nil {
-			return err
-		}
+		eg.slaves[i].ShowSQL(show...)
 	}
-	return nil
 }
 
-// Ping tests if database is alive
-func (eg *EngineGroup) Ping() error {
-	if err := eg.Engine.Ping(); err != nil {
-		return err
+// 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)
+}
 
-	for _, slave := range eg.slaves {
-		if err := slave.Ping(); err != nil {
-			return err
-		}
-	}
-	return nil
+// Slaves returns all the slaves
+func (eg *EngineGroup) Slaves() []*Engine {
+	return eg.slaves
 }