HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge caf55f1ca3 into 29d4a0330a

This commit is contained in:
WhiteBatman 2017-09-30 01:36:32 +00:00 committed by GitHub
parent 29d4a0330a caf55f1ca3
commit c008681fc9
26 changed files with 621 additions and 1872 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cache_test.go
View File

@ -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)

75
engine.go
View File

@ -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)
}

194
engine_group.go Normal file
View File

@ -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
}

116
engine_group_policy.go Normal file
View File

@ -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]
}
}

8
engine_maxlife.go
View File

@ -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)
}
}

99
interface.go Normal file
View File

@ -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{}
)

5
session.go
View File

@ -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
}

2
session_cols_test.go
View File

@ -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))

4
session_cond_test.go
View File

@ -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)

14
session_delete_test.go
View File

@ -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)

42
session_find_test.go
View File

@ -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)

10
session_get_test.go
View File

@ -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)

638
session_insert_test.go
View File

@ -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)
}

13
session_raw.go
View File

@ -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
}

2
session_raw_test.go
View File

@ -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)

4
session_schema_test.go
View File

@ -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)

6
session_stats_test.go
View File

@ -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",
}

6
session_tx_test.go
View File

@ -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)
}()

1149
session_update_test.go
View File

File diff suppressed because it is too large Load Diff

20
statement_test.go
View File

@ -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
}

20
tag_extends_test.go
View File

@ -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")

12
tag_id_test.go
View File

@ -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)
}()

8
tag_test.go
View File

@ -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",

20
time_test.go
View File

@ -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

6
types_test.go
View File

@ -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))

14
xorm_test.go
View File

@ -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)