diff --git a/cache_test.go b/cache_test.go index 5f138f24..26d7ac68 100644 --- a/cache_test.go +++ b/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) diff --git a/engine.go b/engine.go index 15c619d3..2b986966 100644 --- a/engine.go +++ b/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) -} diff --git a/engine_group.go b/engine_group.go new file mode 100644 index 00000000..1de425f3 --- /dev/null +++ b/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 +} diff --git a/engine_group_policy.go b/engine_group_policy.go new file mode 100644 index 00000000..5b56e899 --- /dev/null +++ b/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] + } +} diff --git a/engine_maxlife.go b/engine_maxlife.go index 21daeaa1..22666c5f 100644 --- a/engine_maxlife.go +++ b/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) + } +} diff --git a/interface.go b/interface.go new file mode 100644 index 00000000..31180486 --- /dev/null +++ b/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{} +) diff --git a/session.go b/session.go index ed252058..4c8727b3 100644 --- a/session.go +++ b/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 } diff --git a/session_cols_test.go b/session_cols_test.go index 43854723..6ec17130 100644 --- a/session_cols_test.go +++ b/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)) diff --git a/session_cond_test.go b/session_cond_test.go index 5f8716f0..a80e7d03 100644 --- a/session_cond_test.go +++ b/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) diff --git a/session_delete_test.go b/session_delete_test.go index adabb269..916dab46 100644 --- a/session_delete_test.go +++ b/session_delete_test.go @@ -77,7 +77,7 @@ func TestDeleted(t *testing.T) { // Test normal Find() var records1 []Deleted - err = testEngine.Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&records1, &Deleted{}) + err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&records1, &Deleted{}) assert.EqualValues(t, 3, len(records1)) // Test normal Get() @@ -96,7 +96,7 @@ func TestDeleted(t *testing.T) { assert.False(t, has) var records2 []Deleted - err = testEngine.Where("`" + testEngine.ColumnMapper.Obj2Table("Id") + "` > 0").Find(&records2) + err = testEngine.Where("`" + testEngine.GetColumnMapper().Obj2Table("Id") + "` > 0").Find(&records2) assert.NoError(t, err) assert.EqualValues(t, 2, len(records2)) @@ -117,7 +117,7 @@ func TestDeleted(t *testing.T) { // Test find all records whatever `deleted`. var unscopedRecords1 []Deleted - err = testEngine.Unscoped().Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&unscopedRecords1, &Deleted{}) + err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&unscopedRecords1, &Deleted{}) assert.NoError(t, err) assert.EqualValues(t, 3, len(unscopedRecords1)) @@ -127,13 +127,13 @@ func TestDeleted(t *testing.T) { assert.EqualValues(t, 1, affected) var unscopedRecords2 []Deleted - err = testEngine.Unscoped().Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").Find(&unscopedRecords2, &Deleted{}) + err = testEngine.Unscoped().Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").Find(&unscopedRecords2, &Deleted{}) assert.NoError(t, err) assert.EqualValues(t, 2, len(unscopedRecords2)) var records3 []Deleted - err = testEngine.Where("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` > 0").And("`"+testEngine.ColumnMapper.Obj2Table("Id")+"`> 1"). - Or("`"+testEngine.ColumnMapper.Obj2Table("Id")+"` = ?", 3).Find(&records3) + err = testEngine.Where("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` > 0").And("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"`> 1"). + Or("`"+testEngine.GetColumnMapper().Obj2Table("Id")+"` = ?", 3).Find(&records3) assert.NoError(t, err) assert.EqualValues(t, 2, len(records3)) } @@ -141,7 +141,7 @@ func TestDeleted(t *testing.T) { func TestCacheDelete(t *testing.T) { assert.NoError(t, prepareEngine()) - oldCacher := testEngine.Cacher + oldCacher := testEngine.GetDefaultCacher() cacher := NewLRUCacher(NewMemoryStore(), 1000) testEngine.SetDefaultCacher(cacher) diff --git a/session_find_test.go b/session_find_test.go index 9739bc44..393e4621 100644 --- a/session_find_test.go +++ b/session_find_test.go @@ -64,7 +64,7 @@ func TestJoinLimit(t *testing.T) { func assertSync(t *testing.T, beans ...interface{}) { for _, bean := range beans { assert.NoError(t, testEngine.DropTables(bean)) - assert.NoError(t, testEngine.Sync(bean)) + assert.NoError(t, testEngine.Sync2(bean)) } } @@ -105,8 +105,8 @@ func TestFind(t *testing.T) { } users2 := make([]Userinfo, 0) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") - err = testEngine.Sql("select * from " + testEngine.Quote(userinfo)).Find(&users2) + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") + err = testEngine.SQL("select * from " + testEngine.Quote(userinfo)).Find(&users2) if err != nil { t.Error(err) panic(err) @@ -199,7 +199,7 @@ func TestDistinct(t *testing.T) { assert.NoError(t, err) users := make([]Userinfo, 0) - departname := testEngine.TableMapper.Obj2Table("Departname") + departname := testEngine.GetTableMapper().Obj2Table("Departname") err = testEngine.Distinct(departname).Find(&users) if err != nil { t.Error(err) @@ -273,13 +273,13 @@ func TestHaving(t *testing.T) { func TestOrderSameMapper(t *testing.T) { assert.NoError(t, prepareEngine()) - testEngine.unMapType(rValue(new(Userinfo)).Type()) + testEngine.UnMapType(rValue(new(Userinfo)).Type()) - mapper := testEngine.TableMapper + mapper := testEngine.GetTableMapper() testEngine.SetMapper(core.SameMapper{}) defer func() { - testEngine.unMapType(rValue(new(Userinfo)).Type()) + testEngine.UnMapType(rValue(new(Userinfo)).Type()) testEngine.SetMapper(mapper) }() @@ -304,12 +304,12 @@ func TestOrderSameMapper(t *testing.T) { func TestHavingSameMapper(t *testing.T) { assert.NoError(t, prepareEngine()) - testEngine.unMapType(rValue(new(Userinfo)).Type()) + testEngine.UnMapType(rValue(new(Userinfo)).Type()) - mapper := testEngine.TableMapper + mapper := testEngine.GetTableMapper() testEngine.SetMapper(core.SameMapper{}) defer func() { - testEngine.unMapType(rValue(new(Userinfo)).Type()) + testEngine.UnMapType(rValue(new(Userinfo)).Type()) testEngine.SetMapper(mapper) }() assertSync(t, new(Userinfo)) @@ -326,7 +326,7 @@ func TestFindInts(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") var idsInt64 []int64 err := testEngine.Table(userinfo).Cols("id").Desc("id").Find(&idsInt64) if err != nil { @@ -367,8 +367,8 @@ func TestFindInts(t *testing.T) { func TestFindStrings(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") - username := testEngine.ColumnMapper.Obj2Table("Username") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") + username := testEngine.GetColumnMapper().Obj2Table("Username") var idsString []string err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsString) if err != nil { @@ -380,8 +380,8 @@ func TestFindStrings(t *testing.T) { func TestFindMyString(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") - username := testEngine.ColumnMapper.Obj2Table("Username") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") + username := testEngine.GetColumnMapper().Obj2Table("Username") var idsMyString []MyString err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsMyString) @@ -395,8 +395,8 @@ func TestFindInterface(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") - username := testEngine.ColumnMapper.Obj2Table("Username") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") + username := testEngine.GetColumnMapper().Obj2Table("Username") var idsInterface []interface{} err := testEngine.Table(userinfo).Cols(username).Desc("id").Find(&idsInterface) if err != nil { @@ -409,7 +409,7 @@ func TestFindSliceBytes(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") var ids [][][]byte err := testEngine.Table(userinfo).Desc("id").Find(&ids) if err != nil { @@ -424,7 +424,7 @@ func TestFindSlicePtrString(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") var ids [][]*string err := testEngine.Table(userinfo).Desc("id").Find(&ids) if err != nil { @@ -439,7 +439,7 @@ func TestFindMapBytes(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") var ids []map[string][]byte err := testEngine.Table(userinfo).Desc("id").Find(&ids) if err != nil { @@ -454,7 +454,7 @@ func TestFindMapPtrString(t *testing.T) { assert.NoError(t, prepareEngine()) assertSync(t, new(Userinfo)) - userinfo := testEngine.TableMapper.Obj2Table("Userinfo") + userinfo := testEngine.GetTableMapper().Obj2Table("Userinfo") var ids []map[string]*string err := testEngine.Table(userinfo).Desc("id").Find(&ids) assert.NoError(t, err) diff --git a/session_get_test.go b/session_get_test.go index 91006365..73b23a81 100644 --- a/session_get_test.go +++ b/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) diff --git a/session_insert_test.go b/session_insert_test.go index d4878af6..b421e1b3 100644 --- a/session_insert_test.go +++ b/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) { - - 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) { +func TestInsertOne2(t *testing.T) { assert.NoError(t, prepareEngine()) - type TestPoint struct { - Id *int64 `xorm:"autoincr pk notnull 'id'"` - Msg *string `xorm:"varchar(255)"` - Created *time.Time `xorm:"created"` + type Test2 struct { + Id int64 `xorm:"autoincr pk"` + Msg string `xorm:"varchar(255)"` + Created time.Time `xorm:"datetime created"` } - assert.NoError(t, testEngine.Sync2(new(TestPoint))) - msg := "hi" - data := TestPoint{Msg: &msg} - _, err := testEngine.InsertOne(&data) + assert.NoError(t, testEngine.Sync2(new(Test2))) + + data := Test2{Msg: "hi"} + _, 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"` - } - - assert.NoError(t, testEngine.Sync2(new(TestCreatedInt64))) - - data := TestCreatedInt64{Msg: "hi"} - now := time.Now() - 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) -} diff --git a/session_raw.go b/session_raw.go index c225598e..69bf9b3c 100644 --- a/session_raw.go +++ b/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 } diff --git a/session_raw_test.go b/session_raw_test.go index cf381974..f52db7d3 100644 --- a/session_raw_test.go +++ b/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) diff --git a/session_schema_test.go b/session_schema_test.go index be999ce3..fa2fa7eb 100644 --- a/session_schema_test.go +++ b/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) diff --git a/session_stats_test.go b/session_stats_test.go index 17eaf6dc..ec5cace1 100644 --- a/session_stats_test.go +++ b/session_stats_test.go @@ -46,8 +46,8 @@ func TestSum(t *testing.T) { assert.NoError(t, err) assert.EqualValues(t, 3, cnt) - colInt := testEngine.ColumnMapper.Obj2Table("Int") - colFloat := testEngine.ColumnMapper.Obj2Table("Float") + colInt := testEngine.GetColumnMapper().Obj2Table("Int") + colFloat := testEngine.GetColumnMapper().Obj2Table("Float") sumInt, err := testEngine.Sum(new(SumStruct), colInt) assert.NoError(t, err) @@ -109,7 +109,7 @@ func TestCount(t *testing.T) { } assert.NoError(t, testEngine.Sync2(new(UserinfoCount))) - colName := testEngine.ColumnMapper.Obj2Table("Departname") + colName := testEngine.GetColumnMapper().Obj2Table("Departname") var cond builder.Cond = builder.Eq{ "`" + colName + "`": "dev", } diff --git a/session_tx_test.go b/session_tx_test.go index 3e71bb40..7102f5c7 100644 --- a/session_tx_test.go +++ b/session_tx_test.go @@ -128,11 +128,11 @@ func TestCombineTransaction(t *testing.T) { func TestCombineTransactionSameMapper(t *testing.T) { assert.NoError(t, prepareEngine()) - oldMapper := testEngine.ColumnMapper - testEngine.unMapType(rValue(new(Userinfo)).Type()) + oldMapper := testEngine.GetColumnMapper() + testEngine.UnMapType(rValue(new(Userinfo)).Type()) testEngine.SetMapper(core.SameMapper{}) defer func() { - testEngine.unMapType(rValue(new(Userinfo)).Type()) + testEngine.UnMapType(rValue(new(Userinfo)).Type()) testEngine.SetMapper(oldMapper) }() diff --git a/session_update_test.go b/session_update_test.go index 690bd106..a6aa805c 100644 --- a/session_update_test.go +++ b/session_update_test.go @@ -5,13 +5,9 @@ package xorm import ( - "errors" - "fmt" - "sync" "testing" "time" - "github.com/go-xorm/core" "github.com/stretchr/testify/assert" ) @@ -43,14 +39,14 @@ func TestUpdateMap(t *testing.T) { func TestUpdateLimit(t *testing.T) { assert.NoError(t, prepareEngine()) - type UpdateTable2 struct { + type UpdateTable struct { Id int64 Name string Age int } - assert.NoError(t, testEngine.Sync2(new(UpdateTable2))) - var tb = UpdateTable2{ + assert.NoError(t, testEngine.Sync2(new(UpdateTable))) + var tb = UpdateTable{ Name: "test1", Age: 35, } @@ -64,13 +60,13 @@ func TestUpdateLimit(t *testing.T) { assert.NoError(t, err) assert.EqualValues(t, 1, cnt) - cnt, err = testEngine.OrderBy("name desc").Limit(1).Update(&UpdateTable2{ + cnt, err = testEngine.OrderBy("name desc").Limit(1).Update(&UpdateTable{ Age: 30, }) assert.NoError(t, err) assert.EqualValues(t, 1, cnt) - var uts []UpdateTable2 + var uts []UpdateTable err = testEngine.Find(&uts) assert.NoError(t, err) assert.EqualValues(t, 2, len(uts)) @@ -78,1140 +74,27 @@ func TestUpdateLimit(t *testing.T) { assert.EqualValues(t, 30, uts[1].Age) } -type ForUpdate struct { - Id int64 `xorm:"pk"` - Name string -} - -func setupForUpdate(engine *Engine) error { - v := new(ForUpdate) - err := testEngine.DropTables(v) - if err != nil { - return err - } - err = testEngine.CreateTables(v) - if err != nil { - return err - } - - list := []ForUpdate{ - {1, "data1"}, - {2, "data2"}, - {3, "data3"}, - } - - for _, f := range list { - _, err = testEngine.Insert(f) - if err != nil { - return err - } - } - return nil -} - -func TestForUpdate(t *testing.T) { - if testEngine.DriverName() != "mysql" && testEngine.DriverName() != "mymysql" { - return - } - - err := setupForUpdate(testEngine) - if err != nil { - t.Error(err) - return - } - - session1 := testEngine.NewSession() - session2 := testEngine.NewSession() - session3 := testEngine.NewSession() - defer session1.Close() - defer session2.Close() - defer session3.Close() - - // start transaction - err = session1.Begin() - if err != nil { - t.Error(err) - return - } - - // use lock - fList := make([]ForUpdate, 0) - session1.ForUpdate() - session1.Where("(id) = ?", 1) - err = session1.Find(&fList) - switch { - case err != nil: - t.Error(err) - return - case len(fList) != 1: - t.Errorf("find not returned single row") - return - case fList[0].Name != "data1": - t.Errorf("for_update.name must be `data1`") - return - } - - // wait for lock - wg := &sync.WaitGroup{} - - // lock is used - wg.Add(1) - go func() { - f2 := new(ForUpdate) - session2.Where("(id) = ?", 1).ForUpdate() - has, err := session2.Get(f2) // wait release lock - switch { - case err != nil: - t.Error(err) - case !has: - t.Errorf("cannot find target row. for_update.id = 1") - case f2.Name != "updated by session1": - t.Errorf("read lock failed") - } - wg.Done() - }() - - // lock is NOT used - wg.Add(1) - go func() { - f3 := new(ForUpdate) - session3.Where("(id) = ?", 1) - has, err := session3.Get(f3) // wait release lock - switch { - case err != nil: - t.Error(err) - case !has: - t.Errorf("cannot find target row. for_update.id = 1") - case f3.Name != "data1": - t.Errorf("read lock failed") - } - wg.Done() - }() - - // wait for go rountines - time.Sleep(50 * time.Millisecond) - - f := new(ForUpdate) - f.Name = "updated by session1" - session1.Where("(id) = ?", 1) - session1.Update(f) - - // release lock - err = session1.Commit() - if err != nil { - t.Error(err) - return - } - - wg.Wait() -} - -func TestWithIn(t *testing.T) { - type temp3 struct { - Id int64 `xorm:"Id pk autoincr"` - Name string `xorm:"Name"` - Test bool `xorm:"Test"` - } - - assert.NoError(t, prepareEngine()) - assert.NoError(t, testEngine.Sync(new(temp3))) - - testEngine.Insert(&[]temp3{ - { - Name: "user1", - }, - { - Name: "user1", - }, - { - Name: "user1", - }, - }) - - cnt, err := testEngine.In("Id", 1, 2, 3, 4).Update(&temp3{Name: "aa"}, &temp3{Name: "user1"}) - assert.NoError(t, err) - assert.EqualValues(t, 3, cnt) -} - -type Condi map[string]interface{} - -type UpdateAllCols struct { - Id int64 - Bool bool - String string - Ptr *string -} - -type UpdateMustCols struct { - Id int64 - Bool bool - String string -} - -type UpdateIncr struct { - Id int64 - Cnt int - Name string -} - -type Article struct { - Id int32 `xorm:"pk INT autoincr"` - Name string `xorm:"VARCHAR(45)"` - Img string `xorm:"VARCHAR(100)"` - Aside string `xorm:"VARCHAR(200)"` - Desc string `xorm:"VARCHAR(200)"` - Content string `xorm:"TEXT"` - Status int8 `xorm:"TINYINT(4)"` -} - -func TestUpdateMap2(t *testing.T) { - assert.NoError(t, prepareEngine()) - assertSync(t, new(UpdateMustCols)) - - _, err := testEngine.Table("update_must_cols").Where("id =?", 1).Update(map[string]interface{}{ - "bool": true, - }) - if err != nil { - t.Error(err) - panic(err) - } -} - -func TestUpdate1(t *testing.T) { - assert.NoError(t, prepareEngine()) - assertSync(t, new(Userinfo)) - - _, err := testEngine.Insert(&Userinfo{ - Username: "user1", - }) - - var ori Userinfo - has, err := testEngine.Get(&ori) - if err != nil { - t.Error(err) - panic(err) - } - if !has { - t.Error(errors.New("not exist")) - panic(errors.New("not exist")) - } - - // update by id - user := Userinfo{Username: "xxx", Height: 1.2} - cnt, err := testEngine.ID(ori.Uid).Update(&user) - if err != nil { - t.Error(err) - panic(err) - } - if cnt != 1 { - err = errors.New("update not returned 1") - t.Error(err) - panic(err) - return - } - - condi := Condi{"username": "zzz", "departname": ""} - cnt, err = testEngine.Table(&user).ID(ori.Uid).Update(&condi) - if err != nil { - t.Error(err) - panic(err) - } - if cnt != 1 { - err = errors.New("update not returned 1") - t.Error(err) - panic(err) - return - } - - cnt, err = testEngine.Update(&Userinfo{Username: "yyy"}, &user) - if err != nil { - t.Error(err) - panic(err) - } - total, err := testEngine.Count(&user) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != total { - err = errors.New("insert not returned 1") - t.Error(err) - panic(err) - return - } - - // nullable update - { - user := &Userinfo{Username: "not null data", Height: 180.5} - _, err := testEngine.Insert(user) - if err != nil { - t.Error(err) - panic(err) - } - userID := user.Uid - - has, err := testEngine.ID(userID). - And("username = ?", user.Username). - And("height = ?", user.Height). - And("departname = ?", ""). - And("detail_id = ?", 0). - And("is_man = ?", 0). - Get(&Userinfo{}) - if err != nil { - t.Error(err) - panic(err) - } - if !has { - err = errors.New("cannot insert properly") - t.Error(err) - panic(err) - } - - updatedUser := &Userinfo{Username: "null data"} - cnt, err = testEngine.ID(userID). - Nullable("height", "departname", "is_man", "created"). - Update(updatedUser) - if err != nil { - t.Error(err) - panic(err) - } - if cnt != 1 { - err = errors.New("update not returned 1") - t.Error(err) - panic(err) - } - - has, err = testEngine.ID(userID). - And("username = ?", updatedUser.Username). - And("height IS NULL"). - And("departname IS NULL"). - And("is_man IS NULL"). - And("created IS NULL"). - And("detail_id = ?", 0). - Get(&Userinfo{}) - if err != nil { - t.Error(err) - panic(err) - } - if !has { - err = errors.New("cannot update with null properly") - t.Error(err) - panic(err) - } - - cnt, err = testEngine.ID(userID).Delete(&Userinfo{}) - if err != nil { - t.Error(err) - panic(err) - } - if cnt != 1 { - err = errors.New("delete not returned 1") - t.Error(err) - panic(err) - } - } - - err = testEngine.StoreEngine("Innodb").Sync2(&Article{}) - if err != nil { - t.Error(err) - panic(err) - } - - defer func() { - err = testEngine.DropTables(&Article{}) - if err != nil { - t.Error(err) - panic(err) - } - }() - - a := &Article{0, "1", "2", "3", "4", "5", 2} - cnt, err = testEngine.Insert(a) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != 1 { - err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) - t.Error(err) - panic(err) - } - - if a.Id == 0 { - err = errors.New("insert returned id is 0") - t.Error(err) - panic(err) - } - - cnt, err = testEngine.ID(a.Id).Update(&Article{Name: "6"}) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != 1 { - err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) - t.Error(err) - panic(err) - return - } - - var s = "test" - - col1 := &UpdateAllCols{Ptr: &s} - err = testEngine.Sync(col1) - if err != nil { - t.Error(err) - panic(err) - } - - _, err = testEngine.Insert(col1) - if err != nil { - t.Error(err) - panic(err) - } - - col2 := &UpdateAllCols{col1.Id, true, "", nil} - _, err = testEngine.ID(col2.Id).AllCols().Update(col2) - if err != nil { - t.Error(err) - panic(err) - } - - col3 := &UpdateAllCols{} - has, err = testEngine.ID(col2.Id).Get(col3) - if err != nil { - t.Error(err) - panic(err) - } - - if !has { - err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) - t.Error(err) - panic(err) - return - } - - if *col2 != *col3 { - err = errors.New(fmt.Sprintf("col2 should eq col3")) - t.Error(err) - panic(err) - return - } - - { - - col1 := &UpdateMustCols{} - err = testEngine.Sync(col1) - if err != nil { - t.Error(err) - panic(err) - } - - _, err = testEngine.Insert(col1) - if err != nil { - t.Error(err) - panic(err) - } - - col2 := &UpdateMustCols{col1.Id, true, ""} - boolStr := testEngine.ColumnMapper.Obj2Table("Bool") - stringStr := testEngine.ColumnMapper.Obj2Table("String") - _, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2) - if err != nil { - t.Error(err) - panic(err) - } - - col3 := &UpdateMustCols{} - has, err := testEngine.ID(col2.Id).Get(col3) - if err != nil { - t.Error(err) - panic(err) - } - - if !has { - err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) - t.Error(err) - panic(err) - return - } - - if *col2 != *col3 { - err = errors.New(fmt.Sprintf("col2 should eq col3")) - t.Error(err) - panic(err) - return - } - } -} - -func TestUpdateIncrDecr(t *testing.T) { +func TestUpdate(t *testing.T) { assert.NoError(t, prepareEngine()) - col1 := &UpdateIncr{ - Name: "test", + type UpdateTable2 struct { + Id int64 `xorm:"autoincr pk"` + Msg string `xorm:"varchar(255)"` + Created time.Time `xorm:"datetime updated"` } - assert.NoError(t, testEngine.Sync(col1)) - _, err := testEngine.Insert(col1) - assert.NoError(t, err) + assert.NoError(t, testEngine.Sync2(new(UpdateTable2))) - colName := testEngine.ColumnMapper.Obj2Table("Cnt") + data := UpdateTable2{Msg: "test1"} - cnt, err := testEngine.ID(col1.Id).Incr(colName).Update(col1) + cnt, err := testEngine.Insert(&data) assert.NoError(t, err) assert.EqualValues(t, 1, cnt) - newCol := new(UpdateIncr) - has, err := testEngine.ID(col1.Id).Get(newCol) - assert.NoError(t, err) - assert.True(t, has) - assert.EqualValues(t, 1, newCol.Cnt) - - cnt, err = testEngine.ID(col1.Id).Decr(colName).Update(col1) - assert.NoError(t, err) - assert.EqualValues(t, 1, cnt) - - newCol = new(UpdateIncr) - has, err = testEngine.ID(col1.Id).Get(newCol) - assert.NoError(t, err) - assert.True(t, has) - assert.EqualValues(t, 0, newCol.Cnt) - - cnt, err = testEngine.ID(col1.Id).Cols(colName).Incr(colName).Update(col1) - assert.NoError(t, err) - assert.EqualValues(t, 1, cnt) -} - -type UpdatedUpdate struct { - Id int64 - Updated time.Time `xorm:"updated"` -} - -type UpdatedUpdate2 struct { - Id int64 - Updated int64 `xorm:"updated"` -} - -type UpdatedUpdate3 struct { - Id int64 - Updated int `xorm:"updated bigint"` -} - -type UpdatedUpdate4 struct { - Id int64 - Updated int `xorm:"updated"` -} - -type UpdatedUpdate5 struct { - Id int64 - Updated time.Time `xorm:"updated bigint"` -} - -func TestUpdateUpdated(t *testing.T) { - assert.NoError(t, prepareEngine()) - - di := new(UpdatedUpdate) - err := testEngine.Sync2(di) - if err != nil { - t.Fatal(err) - } - - _, err = testEngine.Insert(&UpdatedUpdate{}) - if err != nil { - t.Fatal(err) - } - - ci := &UpdatedUpdate{} - _, err = testEngine.ID(1).Update(ci) - if err != nil { - t.Fatal(err) - } - - has, err := testEngine.ID(1).Get(di) - if err != nil { - t.Fatal(err) - } - if !has { - t.Fatal(ErrNotExist) - } - if ci.Updated.Unix() != di.Updated.Unix() { - t.Fatal("should equal:", ci, di) - } - fmt.Println("ci:", ci, "di:", di) - - di2 := new(UpdatedUpdate2) - err = testEngine.Sync2(di2) - assert.NoError(t, err) - - now := time.Now() - var di20 UpdatedUpdate2 - cnt, err := testEngine.Insert(&di20) - assert.NoError(t, err) - assert.EqualValues(t, 1, cnt) - assert.True(t, now.Unix() <= di20.Updated) - - var di21 UpdatedUpdate2 - has, err = testEngine.ID(di20.Id).Get(&di21) - assert.NoError(t, err) - assert.True(t, has) - assert.EqualValues(t, di20.Updated, di21.Updated) - - ci2 := &UpdatedUpdate2{} - _, err = testEngine.ID(1).Update(ci2) - assert.NoError(t, err) - - has, err = testEngine.ID(1).Get(di2) - assert.NoError(t, err) - assert.True(t, has) - assert.EqualValues(t, ci2.Updated, di2.Updated) - assert.True(t, ci2.Updated >= di21.Updated) - - di3 := new(UpdatedUpdate3) - err = testEngine.Sync2(di3) - if err != nil { - t.Fatal(err) - } - - _, err = testEngine.Insert(&UpdatedUpdate3{}) - if err != nil { - t.Fatal(err) - } - ci3 := &UpdatedUpdate3{} - _, err = testEngine.ID(1).Update(ci3) - if err != nil { - t.Fatal(err) - } - - has, err = testEngine.ID(1).Get(di3) - if err != nil { - t.Fatal(err) - } - if !has { - t.Fatal(ErrNotExist) - } - if ci3.Updated != di3.Updated { - t.Fatal("should equal:", ci3, di3) - } - fmt.Println("ci3:", ci3, "di3:", di3) - - di4 := new(UpdatedUpdate4) - err = testEngine.Sync2(di4) - if err != nil { - t.Fatal(err) - } - - _, err = testEngine.Insert(&UpdatedUpdate4{}) - if err != nil { - t.Fatal(err) - } - - ci4 := &UpdatedUpdate4{} - _, err = testEngine.ID(1).Update(ci4) - if err != nil { - t.Fatal(err) - } - - has, err = testEngine.ID(1).Get(di4) - if err != nil { - t.Fatal(err) - } - if !has { - t.Fatal(ErrNotExist) - } - if ci4.Updated != di4.Updated { - t.Fatal("should equal:", ci4, di4) - } - fmt.Println("ci4:", ci4, "di4:", di4) - - di5 := new(UpdatedUpdate5) - err = testEngine.Sync2(di5) - if err != nil { - t.Fatal(err) - } - - _, err = testEngine.Insert(&UpdatedUpdate5{}) - if err != nil { - t.Fatal(err) - } - ci5 := &UpdatedUpdate5{} - _, err = testEngine.ID(1).Update(ci5) - if err != nil { - t.Fatal(err) - } - - has, err = testEngine.ID(1).Get(di5) - if err != nil { - t.Fatal(err) - } - if !has { - t.Fatal(ErrNotExist) - } - if ci5.Updated.Unix() != di5.Updated.Unix() { - t.Fatal("should equal:", ci5, di5) - } - fmt.Println("ci5:", ci5, "di5:", di5) -} - -func TestUpdateSameMapper(t *testing.T) { - assert.NoError(t, prepareEngine()) - - oldMapper := testEngine.ColumnMapper - testEngine.unMapType(rValue(new(Userinfo)).Type()) - testEngine.unMapType(rValue(new(Condi)).Type()) - testEngine.unMapType(rValue(new(Article)).Type()) - testEngine.unMapType(rValue(new(UpdateAllCols)).Type()) - testEngine.unMapType(rValue(new(UpdateMustCols)).Type()) - testEngine.unMapType(rValue(new(UpdateIncr)).Type()) - testEngine.SetMapper(core.SameMapper{}) - defer func() { - testEngine.unMapType(rValue(new(Userinfo)).Type()) - testEngine.unMapType(rValue(new(Condi)).Type()) - testEngine.unMapType(rValue(new(Article)).Type()) - testEngine.unMapType(rValue(new(UpdateAllCols)).Type()) - testEngine.unMapType(rValue(new(UpdateMustCols)).Type()) - testEngine.unMapType(rValue(new(UpdateIncr)).Type()) - testEngine.SetMapper(oldMapper) - }() - - assertSync(t, new(Userinfo)) - - _, err := testEngine.Insert(&Userinfo{ - Username: "user1", - }) - assert.NoError(t, err) - - var ori Userinfo - has, err := testEngine.Get(&ori) - if err != nil { - t.Error(err) - panic(err) - } - if !has { - t.Error(errors.New("not exist")) - panic(errors.New("not exist")) - } - // update by id - user := Userinfo{Username: "xxx", Height: 1.2} - cnt, err := testEngine.ID(ori.Uid).Update(&user) - if err != nil { - t.Error(err) - panic(err) - } - if cnt != 1 { - err = errors.New("update not returned 1") - t.Error(err) - panic(err) - return - } - - condi := Condi{"Username": "zzz", "Departname": ""} - cnt, err = testEngine.Table(&user).ID(ori.Uid).Update(&condi) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != 1 { - err = errors.New("update not returned 1") - t.Error(err) - panic(err) - return - } - - cnt, err = testEngine.Update(&Userinfo{Username: "yyy"}, &user) - if err != nil { - t.Error(err) - panic(err) - } - - total, err := testEngine.Count(&user) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != total { - err = errors.New("insert not returned 1") - t.Error(err) - panic(err) - return - } - - err = testEngine.Sync(&Article{}) - if err != nil { - t.Error(err) - panic(err) - } - - defer func() { - err = testEngine.DropTables(&Article{}) - if err != nil { - t.Error(err) - panic(err) - } - }() - - a := &Article{0, "1", "2", "3", "4", "5", 2} - cnt, err = testEngine.Insert(a) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != 1 { - err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) - t.Error(err) - panic(err) - } - - if a.Id == 0 { - err = errors.New("insert returned id is 0") - t.Error(err) - panic(err) - } - - cnt, err = testEngine.ID(a.Id).Update(&Article{Name: "6"}) - if err != nil { - t.Error(err) - panic(err) - } - - if cnt != 1 { - err = errors.New(fmt.Sprintf("insert not returned 1 but %d", cnt)) - t.Error(err) - panic(err) - return - } - - col1 := &UpdateAllCols{} - err = testEngine.Sync(col1) - if err != nil { - t.Error(err) - panic(err) - } - - _, err = testEngine.Insert(col1) - if err != nil { - t.Error(err) - panic(err) - } - - col2 := &UpdateAllCols{col1.Id, true, "", nil} - _, err = testEngine.ID(col2.Id).AllCols().Update(col2) - if err != nil { - t.Error(err) - panic(err) - } - - col3 := &UpdateAllCols{} - has, err = testEngine.ID(col2.Id).Get(col3) - if err != nil { - t.Error(err) - panic(err) - } - - if !has { - err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) - t.Error(err) - panic(err) - return - } - - if *col2 != *col3 { - err = errors.New(fmt.Sprintf("col2 should eq col3")) - t.Error(err) - panic(err) - return - } - - { - col1 := &UpdateMustCols{} - err = testEngine.Sync(col1) - if err != nil { - t.Error(err) - panic(err) - } - - _, err = testEngine.Insert(col1) - if err != nil { - t.Error(err) - panic(err) - } - - col2 := &UpdateMustCols{col1.Id, true, ""} - boolStr := testEngine.ColumnMapper.Obj2Table("Bool") - stringStr := testEngine.ColumnMapper.Obj2Table("String") - _, err = testEngine.ID(col2.Id).MustCols(boolStr, stringStr).Update(col2) - if err != nil { - t.Error(err) - panic(err) - } - - col3 := &UpdateMustCols{} - has, err := testEngine.ID(col2.Id).Get(col3) - if err != nil { - t.Error(err) - panic(err) - } - - if !has { - err = errors.New(fmt.Sprintf("cannot get id %d", col2.Id)) - t.Error(err) - panic(err) - return - } - - if *col2 != *col3 { - err = errors.New(fmt.Sprintf("col2 should eq col3")) - t.Error(err) - panic(err) - return - } - } - - { - - col1 := &UpdateIncr{} - err = testEngine.Sync(col1) - if err != nil { - t.Error(err) - panic(err) - } - - _, err = testEngine.Insert(col1) - if err != nil { - t.Error(err) - panic(err) - } - - cnt, err := testEngine.ID(col1.Id).Incr("`Cnt`").Update(col1) - if err != nil { - t.Error(err) - panic(err) - } - if cnt != 1 { - err = errors.New("update incr failed") - t.Error(err) - panic(err) - } - - newCol := new(UpdateIncr) - has, err := testEngine.ID(col1.Id).Get(newCol) - if err != nil { - t.Error(err) - panic(err) - } - if !has { - err = errors.New("has incr failed") - t.Error(err) - panic(err) - } - if 1 != newCol.Cnt { - err = errors.New("incr failed") - t.Error(err) - panic(err) - } - } -} - -func TestUseBool(t *testing.T) { - assert.NoError(t, prepareEngine()) - assertSync(t, new(Userinfo)) - - cnt1, err := testEngine.Count(&Userinfo{}) - if err != nil { - t.Error(err) - panic(err) - } - - users := make([]Userinfo, 0) - err = testEngine.Find(&users) - if err != nil { - t.Error(err) - panic(err) - } - var fNumber int64 - for _, u := range users { - if u.IsMan == false { - fNumber += 1 - } - } - - cnt2, err := testEngine.UseBool().Update(&Userinfo{IsMan: true}) - if err != nil { - t.Error(err) - panic(err) - } - if fNumber != cnt2 { - fmt.Println("cnt1", cnt1, "fNumber", fNumber, "cnt2", cnt2) - /*err = errors.New("Updated number is not corrected.") - t.Error(err) - panic(err)*/ - } - - _, err = testEngine.Update(&Userinfo{IsMan: true}) - if err == nil { - err = errors.New("error condition") - t.Error(err) - panic(err) - } -} - -func TestBool(t *testing.T) { - assert.NoError(t, prepareEngine()) - assertSync(t, new(Userinfo)) - - _, err := testEngine.UseBool().Update(&Userinfo{IsMan: true}) - if err != nil { - t.Error(err) - panic(err) - } - users := make([]Userinfo, 0) - err = testEngine.Find(&users) - if err != nil { - t.Error(err) - panic(err) - } - for _, user := range users { - if !user.IsMan { - err = errors.New("update bool or find bool error") - t.Error(err) - panic(err) - } - } - - _, err = testEngine.UseBool().Update(&Userinfo{IsMan: false}) - if err != nil { - t.Error(err) - panic(err) - } - users = make([]Userinfo, 0) - err = testEngine.Find(&users) - if err != nil { - t.Error(err) - panic(err) - } - for _, user := range users { - if user.IsMan { - err = errors.New("update bool or find bool error") - t.Error(err) - panic(err) - } - } -} - -func TestNoUpdate(t *testing.T) { - assert.NoError(t, prepareEngine()) - - type NoUpdate struct { - Id int64 - Content string - } - - assertSync(t, new(NoUpdate)) - - cnt, err := testEngine.Insert(&NoUpdate{ - Content: "test", + cnt, err = testEngine.Update(&UpdateTable2{ + Id: data.Id, + Msg: "test2", }) assert.NoError(t, err) assert.EqualValues(t, 1, cnt) - - _, err = testEngine.ID(1).Update(&NoUpdate{}) - assert.Error(t, err) - assert.EqualValues(t, "No content found to be updated", err.Error()) -} - -func TestNewUpdate(t *testing.T) { - assert.NoError(t, prepareEngine()) - - type TbUserInfo struct { - Id int64 `xorm:"pk autoincr unique BIGINT" json:"id"` - Phone string `xorm:"not null unique VARCHAR(20)" json:"phone"` - UserName string `xorm:"VARCHAR(20)" json:"user_name"` - Gender int `xorm:"default 0 INTEGER" json:"gender"` - Pw string `xorm:"VARCHAR(100)" json:"pw"` - Token string `xorm:"TEXT" json:"token"` - Avatar string `xorm:"TEXT" json:"avatar"` - Extras interface{} `xorm:"JSON" json:"extras"` - Created time.Time `xorm:"DATETIME created"` - Updated time.Time `xorm:"DATETIME updated"` - Deleted time.Time `xorm:"DATETIME deleted"` - } - - assertSync(t, new(TbUserInfo)) - - targetUsr := TbUserInfo{Phone: "13126564922"} - changeUsr := TbUserInfo{Token: "ABCDEFG"} - af, err := testEngine.Update(&changeUsr, &targetUsr) - assert.NoError(t, err) - assert.EqualValues(t, 0, af) - - af, err = testEngine.Table(new(TbUserInfo)).Where("phone=?", 13126564922).Update(&changeUsr) - assert.NoError(t, err) - assert.EqualValues(t, 0, af) -} - -func TestUpdateUpdate(t *testing.T) { - assert.NoError(t, prepareEngine()) - - type PublicKeyUpdate struct { - Id int64 - UpdatedUnix int64 `xorm:"updated"` - } - - assertSync(t, new(PublicKeyUpdate)) - - cnt, err := testEngine.ID(1).Cols("updated_unix").Update(&PublicKeyUpdate{ - UpdatedUnix: time.Now().Unix(), - }) - assert.NoError(t, err) - assert.EqualValues(t, 0, cnt) -} - -func TestCreatedUpdated2(t *testing.T) { - assert.NoError(t, prepareEngine()) - - type CreatedUpdatedStruct struct { - Id int64 - Name string - CreateAt time.Time `xorm:"created" json:"create_at"` - UpdateAt time.Time `xorm:"updated" json:"update_at"` - } - - assertSync(t, new(CreatedUpdatedStruct)) - - var s = CreatedUpdatedStruct{ - Name: "test", - } - cnt, err := testEngine.Insert(&s) - assert.NoError(t, err) - assert.EqualValues(t, 1, cnt) - assert.EqualValues(t, s.UpdateAt.Unix(), s.CreateAt.Unix()) - - time.Sleep(time.Second) - - var s1 = CreatedUpdatedStruct{ - Name: "test1", - CreateAt: s.CreateAt, - UpdateAt: s.UpdateAt, - } - - cnt, err = testEngine.ID(1).Update(&s1) - assert.NoError(t, err) - assert.EqualValues(t, 1, cnt) - assert.EqualValues(t, s.CreateAt.Unix(), s1.CreateAt.Unix()) - assert.True(t, s1.UpdateAt.Unix() > s.UpdateAt.Unix()) - - var s2 CreatedUpdatedStruct - has, err := testEngine.ID(1).Get(&s2) - assert.NoError(t, err) - assert.True(t, has) - - assert.EqualValues(t, s.CreateAt.Unix(), s2.CreateAt.Unix()) - assert.True(t, s2.UpdateAt.Unix() > s.UpdateAt.Unix()) - assert.True(t, s2.UpdateAt.Unix() > s2.CreateAt.Unix()) } diff --git a/statement_test.go b/statement_test.go index 594aa4f3..758c2759 100644 --- a/statement_test.go +++ b/statement_test.go @@ -163,10 +163,20 @@ func (TestType) TableName() string { } func createTestStatement() *Statement { - statement := &Statement{} - statement.Init() - statement.Engine = testEngine - statement.setRefValue(reflect.ValueOf(TestType{})) + if engine, ok := testEngine.(*Engine); ok { + statement := &Statement{} + statement.Init() + 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 } diff --git a/tag_extends_test.go b/tag_extends_test.go index 61a61e9e..b70eefe3 100644 --- a/tag_extends_test.go +++ b/tag_extends_test.go @@ -202,13 +202,13 @@ func TestExtends(t *testing.T) { var info UserAndDetail qt := testEngine.Quote - ui := testEngine.TableMapper.Obj2Table("Userinfo") - ud := testEngine.TableMapper.Obj2Table("Userdetail") - uiid := testEngine.TableMapper.Obj2Table("Id") + ui := testEngine.GetTableMapper().Obj2Table("Userinfo") + ud := testEngine.GetTableMapper().Obj2Table("Userdetail") + uiid := testEngine.GetTableMapper().Obj2Table("Id") udid := "detail_id" sql := fmt.Sprintf("select * from %s, %s where %s.%s = %s.%s", qt(ui), qt(ud), qt(ui), qt(udid), qt(ud), qt(uiid)) - b, err := testEngine.Sql(sql).NoCascade().Get(&info) + b, err := testEngine.SQL(sql).NoCascade().Get(&info) if err != nil { t.Error(err) panic(err) @@ -329,7 +329,7 @@ func TestExtends2(t *testing.T) { Uid: sender.Id, ToUid: receiver.Id, } - if testEngine.dialect.DBType() == core.MSSQL { + if testEngine.Dialect().DBType() == core.MSSQL { _, err = testEngine.Exec("SET IDENTITY_INSERT message ON") assert.NoError(t, err) } @@ -340,7 +340,7 @@ func TestExtends2(t *testing.T) { panic(err) } - var mapper = testEngine.TableMapper.Obj2Table + var mapper = testEngine.GetTableMapper().Obj2Table userTableName := mapper("MessageUser") typeTableName := mapper("MessageType") msgTableName := mapper("Message") @@ -401,7 +401,7 @@ func TestExtends3(t *testing.T) { Uid: sender.Id, ToUid: receiver.Id, } - if testEngine.dialect.DBType() == core.MSSQL { + if testEngine.Dialect().DBType() == core.MSSQL { _, err = testEngine.Exec("SET IDENTITY_INSERT message ON") assert.NoError(t, err) } @@ -411,7 +411,7 @@ func TestExtends3(t *testing.T) { panic(err) } - var mapper = testEngine.TableMapper.Obj2Table + var mapper = testEngine.GetTableMapper().Obj2Table userTableName := mapper("MessageUser") typeTableName := mapper("MessageType") msgTableName := mapper("Message") @@ -488,7 +488,7 @@ func TestExtends4(t *testing.T) { Content: "test", Uid: sender.Id, } - if testEngine.dialect.DBType() == core.MSSQL { + if testEngine.Dialect().DBType() == core.MSSQL { _, err = testEngine.Exec("SET IDENTITY_INSERT message ON") assert.NoError(t, err) } @@ -498,7 +498,7 @@ func TestExtends4(t *testing.T) { panic(err) } - var mapper = testEngine.TableMapper.Obj2Table + var mapper = testEngine.GetTableMapper().Obj2Table userTableName := mapper("MessageUser") typeTableName := mapper("MessageType") msgTableName := mapper("Message") diff --git a/tag_id_test.go b/tag_id_test.go index d22cc7b1..a53fe6bd 100644 --- a/tag_id_test.go +++ b/tag_id_test.go @@ -18,11 +18,11 @@ type IDGonicMapper struct { func TestGonicMapperID(t *testing.T) { assert.NoError(t, prepareEngine()) - oldMapper := testEngine.ColumnMapper - testEngine.unMapType(rValue(new(IDGonicMapper)).Type()) + oldMapper := testEngine.GetColumnMapper() + testEngine.UnMapType(rValue(new(IDGonicMapper)).Type()) testEngine.SetMapper(core.LintGonicMapper) defer func() { - testEngine.unMapType(rValue(new(IDGonicMapper)).Type()) + testEngine.UnMapType(rValue(new(IDGonicMapper)).Type()) testEngine.SetMapper(oldMapper) }() @@ -55,11 +55,11 @@ type IDSameMapper struct { func TestSameMapperID(t *testing.T) { assert.NoError(t, prepareEngine()) - oldMapper := testEngine.ColumnMapper - testEngine.unMapType(rValue(new(IDSameMapper)).Type()) + oldMapper := testEngine.GetColumnMapper() + testEngine.UnMapType(rValue(new(IDSameMapper)).Type()) testEngine.SetMapper(core.SameMapper{}) defer func() { - testEngine.unMapType(rValue(new(IDSameMapper)).Type()) + testEngine.UnMapType(rValue(new(IDSameMapper)).Type()) testEngine.SetMapper(oldMapper) }() diff --git a/tag_test.go b/tag_test.go index ef5028f6..c9b76048 100644 --- a/tag_test.go +++ b/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", diff --git a/time_test.go b/time_test.go index 15b20c37..b7e4d12b 100644 --- a/time_test.go +++ b/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 diff --git a/types_test.go b/types_test.go index df4ee70e..3dc1cf9d 100644 --- a/types_test.go +++ b/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)) diff --git a/xorm_test.go b/xorm_test.go index 1a757d3f..569bc681 100644 --- a/xorm_test.go +++ b/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)