diff --git a/engine.go b/engine.go index 17d16063..5fccf6c1 100644 --- a/engine.go +++ b/engine.go @@ -1581,3 +1581,8 @@ func (engine *Engine) BufferSize(size int) *Session { session.isAutoClose = true return session.BufferSize(size) } + +//Stats return the number of open connections to the database +func (engine *Engine) Stats() int { + return engine.DB().Stats().OpenConnections +} diff --git a/engine_group.go b/engine_group.go new file mode 100644 index 00000000..9bbe854a --- /dev/null +++ b/engine_group.go @@ -0,0 +1,887 @@ +// Copyright 2015 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" + "io" + "reflect" + "strings" + "time" + + "github.com/go-xorm/builder" + "github.com/go-xorm/core" +) + +type EngineGroup struct { + master *Engine + slaves []*Engine + weight []int + count int + s_count int + policy Policy + p int +} + +func NewGroup(args1 interface{}, args2 interface{}, policy ...Policy) (*EngineGroup, error) { + driverName, ok1 := args1.(string) + dataSourceNames, ok2 := args2.(string) + if ok1 && ok2 { + return newGroup1(driverName, dataSourceNames, policy...) + } + + Master, ok3 := args1.(*Engine) + Slaves, ok4 := args2.([]*Engine) + if ok3 && ok4 { + return newGroup2(Master, Slaves, policy...) + } + return nil, ErrParamsType +} + +func newGroup1(driverName string, dataSourceNames string, policy ...Policy) (*EngineGroup, error) { + conns := strings.Split(dataSourceNames, ";") + engines := make([]*Engine, len(conns)) + for i, _ := range conns { + engine, err := NewEngine(driverName, conns[i]) + if err != nil { + return nil, err + } + engines[i] = engine + } + + n := len(policy) + if n > 1 { + return nil, ErrParamsType + } else if n == 1 { + eg := &EngineGroup{ + master: engines[0], + slaves: engines[1:], + count: len(engines), + s_count: len(engines[1:]), + policy: policy[0], + } + eg.policy.Init() + return eg, nil + } else { + xPolicy := new(XormEngineGroupPolicy) + eg := &EngineGroup{ + master: engines[0], + slaves: engines[1:], + count: len(engines), + s_count: len(engines[1:]), + policy: xPolicy, + } + xPolicy.Init() + return eg, nil + } + +} + +func newGroup2(Master *Engine, Slaves []*Engine, policy ...Policy) (*EngineGroup, error) { + n := len(policy) + if n > 1 { + return nil, ErrParamsType + } else if n == 1 { + eg := &EngineGroup{ + master: Master, + slaves: Slaves, + count: 1 + len(Slaves), + s_count: len(Slaves), + policy: policy[0], + } + eg.policy.Init() + return eg, nil + } else { + xPolicy := new(XormEngineGroupPolicy) + eg := &EngineGroup{ + master: Master, + slaves: Slaves, + count: 1 + len(Slaves), + s_count: len(Slaves), + policy: xPolicy, + } + xPolicy.Init() + return eg, nil + } +} + +func (eg *EngineGroup) SetPolicy(policy Policy) *EngineGroup { + eg.policy = policy + return eg +} + +func (eg *EngineGroup) UsePolicy(policy int) *EngineGroup { + eg.p = policy + return eg +} + +func (eg *EngineGroup) SetWeight(weight ...interface{}) *EngineGroup { + l := len(weight) + if l == 1 { + switch weight[0].(type) { + case []int: + eg.weight = weight[0].([]int) + } + } else if l > 1 { + s := make([]int, 0) + for i, _ := range weight { + switch weight[i].(type) { + case int: + s = append(s, weight[i].(int)) + default: + s = append(s, 1) + } + } + eg.weight = s + } + + return eg +} + +func (eg *EngineGroup) Master() *Engine { + return eg.master +} + +// Slave returns one of the physical databases which is a slave +func (eg *EngineGroup) Slave() *Engine { + if eg.count == 1 { + return eg.master + } + return eg.policy.Slave(eg) +} + +func (eg *EngineGroup) Slaves() []*Engine { + if eg.count == 1 { + return []*Engine{eg.master} + } + return eg.slaves +} + +func (eg *EngineGroup) GetSlave(i int) *Engine { + if eg.count == 1 || i == 0 { + return eg.master + } + if i > eg.s_count { + return eg.slaves[0] + } + return eg.slaves[i] +} + +func (eg *EngineGroup) GetEngine(i int) *Engine { + if i >= eg.count || i == 0 { + return eg.master + } + return eg.slaves[i-1] +} + +// ShowSQL show SQL statement or not on logger if log level is great than INFO +func (eg *EngineGroup) ShowSQL(show ...bool) { + eg.master.ShowSQL(show...) + for i, _ := range eg.slaves { + eg.slaves[i].ShowSQL(show...) + } +} + +// 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.master.ShowExecTime(show...) + for i, _ := range eg.slaves { + eg.slaves[i].ShowExecTime(show...) + } +} + +// SetMapper set the name mapping rules +func (eg *EngineGroup) SetMapper(mapper core.IMapper) { + eg.master.SetTableMapper(mapper) + eg.master.SetColumnMapper(mapper) + for i, _ := range eg.slaves { + eg.slaves[i].SetTableMapper(mapper) + eg.slaves[i].SetColumnMapper(mapper) + } +} + +// SetTableMapper set the table name mapping rule +func (eg *EngineGroup) SetTableMapper(mapper core.IMapper) { + eg.master.TableMapper = mapper + for i, _ := range eg.slaves { + eg.slaves[i].TableMapper = mapper + } +} + +// SetColumnMapper set the column name mapping rule +func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) { + eg.master.ColumnMapper = mapper + for i, _ := range eg.slaves { + eg.slaves[i].ColumnMapper = mapper + } +} + +// SetMaxOpenConns is only available for go 1.2+ +func (eg *EngineGroup) SetMaxOpenConns(conns int) { + eg.master.db.SetMaxOpenConns(conns) + for i, _ := range eg.slaves { + eg.slaves[i].db.SetMaxOpenConns(conns) + } +} + +// SetMaxIdleConns set the max idle connections on pool, default is 2 +func (eg *EngineGroup) SetMaxIdleConns(conns int) { + eg.master.db.SetMaxIdleConns(conns) + for i, _ := range eg.slaves { + eg.slaves[i].db.SetMaxIdleConns(conns) + } +} + +// NoCascade If you do not want to auto cascade load object +func (eg *EngineGroup) NoCascade() *EGSession { + egs := eg.NewEGSession() + return egs.NoCascade() +} + +// Close the engine +func (eg *EngineGroup) Close() error { + err := eg.master.db.Close() + if err != nil { + return err + } + + for i, _ := range eg.slaves { + err := eg.slaves[i].db.Close() + if err != nil { + return err + } + } + return nil +} + +// Ping tests if database is alive +func (eg *EngineGroup) Ping() error { + eg.master.Ping() + return scatter(eg.s_count, func(i int) error { + return eg.slaves[i].Ping() + }) +} + +// SetConnMaxLifetime sets the maximum amount of time a connection may be reused. +func (eg *EngineGroup) SetConnMaxLifetime(d time.Duration) { + eg.master.db.SetConnMaxLifetime(d) + for i, _ := range eg.slaves { + eg.slaves[i].db.SetConnMaxLifetime(d) + } +} + +func scatter(n int, fn func(i int) error) error { + errors := make(chan error, n) + + var i int + for i = 0; i < n; i++ { + go func(i int) { errors <- fn(i) }(i) + } + + var err, innerErr error + for i = 0; i < cap(errors); i++ { + if innerErr = <-errors; innerErr != nil { + err = innerErr + } + } + + return err +} + +// SqlType will be deprecated, please use SQLType instead +// +// Deprecated: use SQLType instead +func (eg *EngineGroup) SqlType(c *core.Column) string { + return eg.Master().SQLType(c) +} + +// SQLType A simple wrapper to dialect's core.SqlType method +func (eg *EngineGroup) SQLType(c *core.Column) string { + return eg.Master().dialect.SqlType(c) +} + +// NewSession New a session +func (eg *EngineGroup) NewSession() *Session { + return eg.Master().NewSession() +} + +// NewSession New a session +func (eg *EngineGroup) NewEGSession() *EGSession { + args := make(map[string]interface{}) + egs := &EGSession{eg: eg, operation: []string{}, args: args} + return egs +} + +type SqlArgs struct { + query string + args []interface{} +} + +func (eg *EngineGroup) Sql(query string, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Sql(query, args...) +} + +func (eg *EngineGroup) SQL(query interface{}, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.SQL(query, args...) +} + +// NoAutoTime Default if your struct has "created" or "updated" filed tag, the fields +// will automatically be filled with current time when Insert or Update +// invoked. Call NoAutoTime if you dont' want to fill automatically. +func (eg *EngineGroup) NoAutoTime() *EGSession { + egs := eg.NewEGSession() + return egs.NoAutoTime() +} + +type NoAutoConditionArgs struct { + no []bool +} + +// NoAutoCondition disable auto generate Where condition from bean or not +func (eg *EngineGroup) NoAutoCondition(no ...bool) *EGSession { + egs := eg.NewEGSession() + return egs.NoAutoCondition(no...) +} + +// DBMetas Retrieve all tables, columns, indexes' informations from database. +func (eg *EngineGroup) DBMetas() ([]*core.Table, error) { + return eg.Master().DBMetas() +} + +// DumpAllToFile dump database all table structs and data to a file +func (eg *EngineGroup) DumpAllToFile(fp string, tp ...core.DbType) error { + return eg.Master().DumpAllToFile(fp, tp...) +} + +// DumpAll dump database all table structs and data to w +func (eg *EngineGroup) DumpAll(w io.Writer, tp ...core.DbType) error { + return eg.Master().DumpAll(w, tp...) +} + +// DumpTablesToFile dump specified tables to SQL file. +func (eg *EngineGroup) DumpTablesToFile(tables []*core.Table, fp string, tp ...core.DbType) error { + return eg.Master().DumpTablesToFile(tables, fp, tp...) +} + +// DumpTables dump specify tables to io.Writer +func (eg *EngineGroup) DumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error { + return eg.Master().DumpTables(tables, w, tp...) +} + +type CascadeArgs struct { + trueOrFalse []bool +} + +// Cascade use cascade or not +func (eg *EngineGroup) Cascade(trueOrFalse ...bool) *EGSession { + egs := eg.NewEGSession() + return egs.Cascade(trueOrFalse...) +} + +type WhereArgs struct { + query interface{} + args []interface{} +} + +// Where method provide a condition query +func (eg *EngineGroup) Where(query interface{}, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Where(query, args...) +} + +type IdArgs struct { + id interface{} +} + +// Id will be deprecated, please use ID instead +func (eg *EngineGroup) Id(id interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Id(id) +} + +type IDArgs struct { + id interface{} +} + +// ID method provoide a condition as (id) = ? +func (eg *EngineGroup) ID(id interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.ID(id) +} + +type BeforeArgs struct { + closures func(interface{}) +} + +// Before apply before Processor, affected bean is passed to closure arg +func (eg *EngineGroup) Before(closures func(interface{})) *EGSession { + egs := eg.NewEGSession() + return egs.Before(closures) +} + +type AfterArgs struct { + closures func(interface{}) +} + +// After apply after insert Processor, affected bean is passed to closure arg +func (eg *EngineGroup) After(closures func(interface{})) *EGSession { + egs := eg.NewEGSession() + return egs.After(closures) +} + +type CharsetArgs struct { + charset string +} + +// Charset set charset when create table, only support mysql now +func (eg *EngineGroup) Charset(charset string) *EGSession { + egs := eg.NewEGSession() + return egs.Charset(charset) +} + +type StoreEngineArgs struct { + storeEngine string +} + +// StoreEngine set store engine when create table, only support mysql now +func (eg *EngineGroup) StoreEngine(storeEngine string) *EGSession { + egs := eg.NewEGSession() + return egs.StoreEngine(storeEngine) +} + +type DistinctArgs struct { + columns []string +} + +// Distinct use for distinct columns. Caution: when you are using cache, +// distinct will not be cached because cache system need id, +// but distinct will not provide id +func (eg *EngineGroup) Distinct(columns ...string) *EGSession { + egs := eg.NewEGSession() + return egs.Distinct(columns...) +} + +type SelectArgs struct { + str string +} + +// Select customerize your select columns or contents +func (eg *EngineGroup) Select(str string) *EGSession { + egs := eg.NewEGSession() + return egs.Select(str) +} + +type ColsArgs struct { + columns []string +} + +// Cols only use the parameters as select or update columns +func (eg *EngineGroup) Cols(columns ...string) *EGSession { + egs := eg.NewEGSession() + return egs.Cols(columns...) +} + +// AllCols indicates that all columns should be use +func (eg *EngineGroup) AllCols() *EGSession { + egs := eg.NewEGSession() + return egs.AllCols() +} + +type MustColsArgs struct { + columns []string +} + +// MustCols specify some columns must use even if they are empty +func (eg *EngineGroup) MustCols(columns ...string) *EGSession { + egs := eg.NewEGSession() + return egs.MustCols(columns...) +} + +type UseBoolArgs struct { + columns []string +} + +// UseBool xorm automatically retrieve condition according struct, but +// if struct has bool field, it will ignore them. So use UseBool +// to tell system to do not ignore them. +// If no parameters, it will use all the bool field of struct, or +// it will use parameters's columns +func (eg *EngineGroup) UseBool(columns ...string) *EGSession { + egs := eg.NewEGSession() + return egs.UseBool(columns...) +} + +type OmitArgs struct { + columns []string +} + +// Omit only not use the parameters as select or update columns +func (eg *EngineGroup) Omit(columns ...string) *EGSession { + egs := eg.NewEGSession() + return egs.Omit(columns...) +} + +type NullableArgs struct { + columns []string +} + +// Nullable set null when column is zero-value and nullable for update +func (eg *EngineGroup) Nullable(columns ...string) *EGSession { + egs := eg.NewEGSession() + return egs.Nullable(columns...) +} + +type InArgs struct { + column string + args []interface{} +} + +// In will generate "column IN (?, ?)" +func (eg *EngineGroup) In(column string, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.In(column, args...) +} + +type NotInArgs struct { + column string + args []interface{} +} + +// NotIn will generate "column NOT IN (?, ?)" +func (eg *EngineGroup) NotIn(column string, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.NotIn(column, args...) +} + +type IncrArgs struct { + column string + args []interface{} +} + +// Incr provides a update string like "column = column + ?" +func (eg *EngineGroup) Incr(column string, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Incr(column, args...) +} + +type DecrArgs struct { + column string + args []interface{} +} + +// Decr provides a update string like "column = column - ?" +func (eg *EngineGroup) Decr(column string, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Decr(column, args...) +} + +type SetExprArgs struct { + column string + expression string +} + +// SetExpr provides a update string like "column = {expression}" +func (eg *EngineGroup) SetExpr(column string, expression string) *EGSession { + egs := eg.NewEGSession() + return egs.SetExpr(column, expression) +} + +type TableArgs struct { + tableNameOrBean interface{} +} + +// Table temporarily change the Get, Find, Update's table +func (eg *EngineGroup) Table(tableNameOrBean interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Table(tableNameOrBean) +} + +type AliasArgs struct { + alias string +} + +// Alias set the table alias +func (eg *EngineGroup) Alias(alias string) *EGSession { + egs := eg.NewEGSession() + return egs.Alias(alias) +} + +type LimitArgs struct { + limit int + start []int +} + +// Limit will generate "LIMIT start, limit" +func (eg *EngineGroup) Limit(limit int, start ...int) *EGSession { + egs := eg.NewEGSession() + return egs.Limit(limit, start...) +} + +type DescArgs struct { + colNames []string +} + +// Desc will generate "ORDER BY column1 DESC, column2 DESC" +func (eg *EngineGroup) Desc(colNames ...string) *EGSession { + egs := eg.NewEGSession() + return egs.Desc(colNames...) +} + +type AscArgs struct { + colNames []string +} + +// Asc will generate "ORDER BY column1,column2 Asc" +// This method can chainable use. +// +// engine.Desc("name").Asc("age").Find(&users) +// // SELECT * FROM user ORDER BY name DESC, age ASC +// +func (eg *EngineGroup) Asc(colNames ...string) *EGSession { + egs := eg.NewEGSession() + return egs.Asc(colNames...) +} + +type OrderByArgs struct { + order string +} + +// OrderBy will generate "ORDER BY order" +func (eg *EngineGroup) OrderBy(order string) *EGSession { + egs := eg.NewEGSession() + return egs.OrderBy(order) +} + +type JoinArgs struct { + joinOperator string + tablename interface{} + condition string + args []interface{} +} + +// Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN +func (eg *EngineGroup) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *EGSession { + egs := eg.NewEGSession() + return egs.Join(joinOperator, tablename, condition, args...) +} + +type GroupByArgs struct { + keys string +} + +// GroupBy generate group by statement +func (eg *EngineGroup) GroupBy(keys string) *EGSession { + egs := eg.NewEGSession() + return egs.GroupBy(keys) +} + +type HavingArgs struct { + conditions string +} + +// Having generate having statement +func (eg *EngineGroup) Having(conditions string) *EGSession { + egs := eg.NewEGSession() + return egs.Having(conditions) +} + +// IdOf get id from one struct +// +// Deprecated: use IDOf instead. +func (eg *EngineGroup) IdOf(bean interface{}) core.PK { + return eg.Master().IdOf(bean) +} + +// IDOf get id from one struct +func (eg *EngineGroup) IDOf(bean interface{}) core.PK { + return eg.Master().IDOf(bean) +} + +// IdOfV get id from one value of struct +// +// Deprecated: use IDOfV instead. +func (eg *EngineGroup) IdOfV(rv reflect.Value) core.PK { + return eg.Master().IdOfV(rv) +} + +// IDOfV get id from one value of struct +func (eg *EngineGroup) IDOfV(rv reflect.Value) core.PK { + return eg.Master().IDOfV(rv) +} + +// CreateIndexes create indexes +func (eg *EngineGroup) CreateIndexes(bean interface{}) error { + return eg.Master().CreateIndexes(bean) +} + +// CreateUniques create uniques +func (eg *EngineGroup) CreateUniques(bean interface{}) error { + return eg.Master().CreateUniques(bean) +} + +// Sync the new struct changes to database, this method will automatically add +// table, column, index, unique. but will not delete or change anything. +// If you change some field, you should change the database manually. +func (eg *EngineGroup) Sync(beans ...interface{}) error { + return eg.Master().Sync(beans...) +} + +// Sync2 synchronize structs to database tables +func (eg *EngineGroup) Sync2(beans ...interface{}) error { + return eg.Master().Sync2(beans...) +} + +// CreateTables create tabls according bean +func (eg *EngineGroup) CreateTables(beans ...interface{}) error { + return eg.Master().CreateTables(beans...) +} + +// DropTables drop specify tables +func (eg *EngineGroup) DropTables(beans ...interface{}) error { + return eg.Master().DropTables(beans...) +} + +// DropIndexes drop indexes of a table +func (eg *EngineGroup) DropIndexes(bean interface{}) error { + return eg.Master().DropIndexes(bean) +} + +func (eg *EngineGroup) Exec(sql string, args ...interface{}) (sql.Result, error) { + return eg.Master().Exec(sql, args...) +} + +// Query a raw sql and return records as []map[string][]byte +func (eg *EngineGroup) Query(sql string, paramStr ...interface{}) (resultsSlice []map[string][]byte, err error) { + return eg.Slave().Query(sql, paramStr...) +} + +// QueryString runs a raw sql and return records as []map[string]string +func (eg *EngineGroup) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) { + return eg.Slave().QueryString(sqlStr, args...) +} + +// QueryInterface runs a raw sql and return records as []map[string]interface{} +func (eg *EngineGroup) QueryInterface(sqlStr string, args ...interface{}) ([]map[string]interface{}, error) { + return eg.Slave().QueryInterface(sqlStr, args...) +} + +// Insert one or more records +func (eg *EngineGroup) Insert(beans ...interface{}) (int64, error) { + return eg.Master().Insert(beans...) +} + +// InsertOne insert only one record +func (eg *EngineGroup) InsertOne(bean interface{}) (int64, error) { + return eg.Master().InsertOne(bean) +} + +// IsTableEmpty if a table has any reocrd +func (eg *EngineGroup) IsTableEmpty(bean interface{}) (bool, error) { + return eg.Master().IsTableEmpty(bean) +} + +// IsTableExist if a table is exist +func (eg *EngineGroup) IsTableExist(beanOrTableName interface{}) (bool, error) { + return eg.Master().IsTableExist(beanOrTableName) +} + +func (eg *EngineGroup) Update(bean interface{}, condiBeans ...interface{}) (int64, error) { + return eg.Master().Update(bean, condiBeans...) +} + +// Delete records, bean's non-empty fields are conditions +func (eg *EngineGroup) Delete(bean interface{}) (int64, error) { + return eg.Master().Delete(bean) +} + +// Get retrieve one record from table, bean's non-empty fields +// are conditions +func (eg *EngineGroup) Get(bean interface{}) (bool, error) { + return eg.Slave().Get(bean) +} + +// Exist returns true if the record exist otherwise return false +func (eg *EngineGroup) Exist(bean ...interface{}) (bool, error) { + return eg.Slave().Exist(bean...) +} + +// Iterate record by record handle records from table, bean's non-empty fields +// are conditions. +func (eg *EngineGroup) Iterate(bean interface{}, fun IterFunc) error { + return eg.Master().Iterate(bean, fun) +} + +func (eg *EngineGroup) Find(beans interface{}, condiBeans ...interface{}) error { + return eg.Slave().Find(beans, condiBeans...) +} + +// Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields +// are conditions. +func (eg *EngineGroup) Rows(bean interface{}) (*Rows, error) { + return eg.Slave().Rows(bean) +} + +// Count counts the records. bean's non-empty fields are conditions. +func (eg *EngineGroup) Count(bean ...interface{}) (int64, error) { + return eg.Slave().Count(bean...) +} + +// Sum sum the records by some column. bean's non-empty fields are conditions. +func (eg *EngineGroup) Sum(bean interface{}, colName string) (float64, error) { + return eg.Slave().Sum(bean, colName) +} + +// SumInt sum the records by some column. bean's non-empty fields are conditions. +func (eg *EngineGroup) SumInt(bean interface{}, colName string) (int64, error) { + return eg.Slave().SumInt(bean, colName) +} + +// Sums sum the records by some columns. bean's non-empty fields are conditions. +func (eg *EngineGroup) Sums(bean interface{}, colNames ...string) ([]float64, error) { + return eg.Slave().Sums(bean, colNames...) +} + +// SumsInt like Sums but return slice of int64 instead of float64. +func (eg *EngineGroup) SumsInt(bean interface{}, colNames ...string) ([]int64, error) { + return eg.Slave().SumsInt(bean, colNames...) +} + +// ImportFile SQL DDL file +func (eg *EngineGroup) ImportFile(ddlPath string) ([]sql.Result, error) { + return eg.Master().ImportFile(ddlPath) +} + +// Import SQL DDL from io.Reader +func (eg *EngineGroup) Import(r io.Reader) ([]sql.Result, error) { + return eg.Master().Import(r) +} + +// NowTime2 return current time +func (eg *EngineGroup) NowTime2(sqlTypeName string) (interface{}, time.Time) { + return eg.Master().NowTime2(sqlTypeName) +} + +// Unscoped always disable struct tag "deleted" +func (eg *EngineGroup) Unscoped() *EGSession { + egs := eg.NewEGSession() + return egs.Unscoped() +} + +// CondDeleted returns the conditions whether a record is soft deleted. +func (eg *EngineGroup) CondDeleted(colName string) builder.Cond { + return eg.Master().CondDeleted(colName) +} + +type BufferSizeArgs struct { + size int +} + +// BufferSize sets buffer size for iterate +func (eg *EngineGroup) BufferSize(size int) *EGSession { + egs := eg.NewEGSession() + return egs.BufferSize(size) +} diff --git a/engine_group_policy.go b/engine_group_policy.go new file mode 100644 index 00000000..2219d9f5 --- /dev/null +++ b/engine_group_policy.go @@ -0,0 +1,134 @@ +// Copyright 2015 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" + + "time" +) + +const ( + ENGINE_GROUP_POLICY_RANDOM = iota + ENGINE_GROUP_POLICY_WEIGHTRANDOM + ENGINE_GROUP_POLICY_ROUNDROBIN + ENGINE_GROUP_POLICY_WEIGHTROUNDROBIN + ENGINE_GROUP_POLICY_LEASTCONNECTIONS +) + +type Policy interface { + Init() + Slave(*EngineGroup) *Engine +} + +type XormEngineGroupPolicy struct { + pos int + slaves []int + eg *EngineGroup + r *rand.Rand +} + +func (xgep *XormEngineGroupPolicy) Init() { + xgep.r = rand.New(rand.NewSource(time.Now().UnixNano())) +} + +func (xgep *XormEngineGroupPolicy) Slave(eg *EngineGroup) *Engine { + xgep.eg = eg + return eg.slaves[xgep.slave()] +} + +func (xgep *XormEngineGroupPolicy) SetWeight() { + for i, _ := range xgep.eg.weight { + w := xgep.eg.weight[i] + for n := 0; n < w; n++ { + xgep.slaves = append(xgep.slaves, i) + } + } +} + +func (xgep *XormEngineGroupPolicy) slave() int { + switch xgep.eg.p { + case ENGINE_GROUP_POLICY_RANDOM: + return xgep.Random() + case ENGINE_GROUP_POLICY_WEIGHTRANDOM: + return xgep.WeightRandom() + case ENGINE_GROUP_POLICY_ROUNDROBIN: + return xgep.RoundRobin() + case ENGINE_GROUP_POLICY_WEIGHTROUNDROBIN: + return xgep.WeightRoundRobin() + case ENGINE_GROUP_POLICY_LEASTCONNECTIONS: + return xgep.LeastConnections() + default: + return xgep.Random() + } + +} + +func (xgep *XormEngineGroupPolicy) Random() int { + if xgep.eg.s_count <= 1 { + return 0 + } + + rnd := xgep.r.Intn(xgep.eg.s_count) + return rnd +} + +func (xgep *XormEngineGroupPolicy) WeightRandom() int { + if xgep.eg.s_count <= 1 { + return 0 + } + + xgep.SetWeight() + s := len(xgep.slaves) + rnd := xgep.r.Intn(s) + return xgep.slaves[rnd] +} + +func (xgep *XormEngineGroupPolicy) RoundRobin() int { + if xgep.eg.s_count <= 1 { + return 0 + } + + if xgep.pos >= xgep.eg.s_count { + xgep.pos = 0 + } + xgep.pos++ + + return xgep.pos - 1 +} + +func (xgep *XormEngineGroupPolicy) WeightRoundRobin() int { + if xgep.eg.s_count <= 1 { + return 0 + } + + xgep.SetWeight() + count := len(xgep.slaves) + if xgep.pos >= count { + xgep.pos = 0 + } + xgep.pos++ + + return xgep.slaves[xgep.pos-1] +} + +func (xgep *XormEngineGroupPolicy) LeastConnections() int { + if xgep.eg.s_count <= 1 { + return 0 + } + connections := 0 + slave := 0 + for i, _ := range xgep.eg.slaves { + open_connections := xgep.eg.slaves[i].Stats() + if i == 0 { + connections = open_connections + slave = i + } else if open_connections <= connections { + slave = i + connections = open_connections + } + } + return slave +} diff --git a/engine_group_session.go b/engine_group_session.go new file mode 100644 index 00000000..0f333cb1 --- /dev/null +++ b/engine_group_session.go @@ -0,0 +1,764 @@ +package xorm + +import ( + "database/sql" + + "github.com/go-xorm/builder" +) + +type EGSession struct { + eg *EngineGroup + operation []string + args map[string]interface{} + err error +} + +func (egs *EGSession) operate(session *Session) *Session { + for _, v := range egs.operation { + switch v { + case "Before": + args := egs.args["Before"].(BeforeArgs) + session = session.Before(args.closures) + case "After": + args := egs.args["After"].(AfterArgs) + session = session.After(args.closures) + case "Table": + args := egs.args["Table"].(TableArgs) + session = session.Table(args.tableNameOrBean) + case "Alias": + args := egs.args["Alias"].(AliasArgs) + session = session.Alias(args.alias) + case "NoCascade": + session = session.NoCascade() + case "ForUpdate": + session = session.ForUpdate() + case "NoAutoCondition": + args := egs.args["NoAutoCondition"].(NoAutoConditionArgs) + session = session.NoAutoCondition(args.no...) + case "Limit": + args := egs.args["Limit"].(LimitArgs) + session = session.Limit(args.limit, args.start...) + case "OrderBy": + args := egs.args["OrderBy"].(OrderByArgs) + session = session.OrderBy(args.order) + case "Desc": + args := egs.args["Desc"].(DescArgs) + session = session.Desc(args.colNames...) + case "Asc": + args := egs.args["Asc"].(AscArgs) + session = session.Asc(args.colNames...) + case "StoreEngine": + args := egs.args["StoreEngine"].(StoreEngineArgs) + session = session.StoreEngine(args.storeEngine) + case "Charset": + args := egs.args["Charset"].(CharsetArgs) + session = session.Charset(args.charset) + case "Cascade": + args := egs.args["Cascade"].(CascadeArgs) + session = session.Cascade(args.trueOrFalse...) + case "NoCache": + session = session.NoCache() + case "Join": + args := egs.args["Join"].(JoinArgs) + session = session.Join(args.joinOperator, args.tablename, args.condition, args.args...) + case "GroupBy": + args := egs.args["GroupBy"].(GroupByArgs) + session = session.GroupBy(args.keys) + case "Having": + args := egs.args["Having"].(HavingArgs) + session = session.Having(args.conditions) + case "Unscoped": + session = session.Unscoped() + case "Incr": + args := egs.args["Incr"].(IncrArgs) + session = session.Incr(args.column, args.args...) + case "Decr": + args := egs.args["Decr"].(DecrArgs) + session = session.Decr(args.column, args.args...) + case "SetExpr": + args := egs.args["SetExpr"].(SetExprArgs) + session = session.SetExpr(args.column, args.expression) + case "Select": + args := egs.args["Select"].(SelectArgs) + session = session.Select(args.str) + case "Cols": + args := egs.args["Cols"].(ColsArgs) + session = session.Cols(args.columns...) + case "AllCols": + session = session.AllCols() + case "MustCols": + args := egs.args["MustCols"].(MustColsArgs) + session = session.MustCols(args.columns...) + case "UseBool": + args := egs.args["UseBool"].(UseBoolArgs) + session = session.UseBool(args.columns...) + case "Distinct": + args := egs.args["Distinct"].(DistinctArgs) + session = session.Distinct(args.columns...) + case "Omit": + args := egs.args["Omit"].(OmitArgs) + session = session.Omit(args.columns...) + case "Nullable": + args := egs.args["Nullable"].(NullableArgs) + session = session.Nullable(args.columns...) + case "NoAutoTime": + session = session.NoAutoTime() + case "Sql": + args := egs.args["Sql"].(SqlArgs) + session = session.Sql(args.query, args.args...) + case "SQL": + args := egs.args["SQL"].(SqlArgs) + session = session.SQL(args.query, args.args...) + case "Where": + args := egs.args["Where"].(WhereArgs) + session = session.Where(args.query, args.args...) + case "And": + args := egs.args["And"].(AndArgs) + session = session.And(args.query, args.args...) + case "Or": + args := egs.args["Or"].(OrArgs) + session = session.Or(args.query, args.args...) + case "Id": + args := egs.args["Id"].(IdArgs) + session = session.Id(args.id) + case "ID": + args := egs.args["ID"].(IDArgs) + session = session.ID(args.id) + case "In": + args := egs.args["In"].(InArgs) + session = session.In(args.column, args.args...) + case "NotIn": + args := egs.args["NotIn"].(NotInArgs) + session = session.NotIn(args.column, args.args...) + case "BufferSize": + args := egs.args["BufferSize"].(BufferSizeArgs) + session = session.BufferSize(args.size) + } + } + return session +} + +// Before Apply before Processor, affected bean is passed to closure arg +func (egs *EGSession) Before(closures func(interface{})) *EGSession { + egs.operation = append(egs.operation, "Before") + args := BeforeArgs{ + closures: closures, + } + egs.args["Before"] = args + return egs +} + +// After Apply after Processor, affected bean is passed to closure arg +func (egs *EGSession) After(closures func(interface{})) *EGSession { + egs.operation = append(egs.operation, "After") + args := AfterArgs{ + closures: closures, + } + egs.args["After"] = args + return egs +} + +// Table can input a string or pointer to struct for special a table to operate. +func (egs *EGSession) Table(tableNameOrBean interface{}) *EGSession { + egs.operation = append(egs.operation, "Table") + args := TableArgs{ + tableNameOrBean: tableNameOrBean, + } + egs.args["Table"] = args + return egs +} + +// Alias set the table alias +func (egs *EGSession) Alias(alias string) *EGSession { + egs.operation = append(egs.operation, "Alias") + args := AliasArgs{ + alias: alias, + } + egs.args["Alias"] = args + return egs +} + +// NoCascade indicate that no cascade load child object +func (egs *EGSession) NoCascade() *EGSession { + egs.operation = append(egs.operation, "NoCascade") + return egs +} + +// ForUpdate Set Read/Write locking for UPDATE +func (egs *EGSession) ForUpdate() *EGSession { + egs.operation = append(egs.operation, "ForUpdate") + return egs +} + +// NoAutoCondition disable generate SQL condition from beans +func (egs *EGSession) NoAutoCondition(no ...bool) *EGSession { + egs.operation = append(egs.operation, "NoAutoCondition") + args := NoAutoConditionArgs{ + no: no, + } + egs.args["NoAutoCondition"] = args + return egs +} + +// Limit provide limit and offset query condition +func (egs *EGSession) Limit(limit int, start ...int) *EGSession { + egs.operation = append(egs.operation, "Limit") + args := LimitArgs{ + limit: limit, + start: start, + } + egs.args["Limit"] = args + return egs +} + +// OrderBy provide order by query condition, the input parameter is the content +// after order by on a sql statement. +func (egs *EGSession) OrderBy(order string) *EGSession { + egs.operation = append(egs.operation, "OrderBy") + args := OrderByArgs{ + order: order, + } + egs.args["OrderBy"] = args + return egs +} + +// Desc provide desc order by query condition, the input parameters are columns. +func (egs *EGSession) Desc(colNames ...string) *EGSession { + egs.operation = append(egs.operation, "Desc") + args := DescArgs{ + colNames: colNames, + } + egs.args["Desc"] = args + return egs +} + +// Asc provide asc order by query condition, the input parameters are columns. +func (egs *EGSession) Asc(colNames ...string) *EGSession { + egs.operation = append(egs.operation, "Asc") + args := AscArgs{ + colNames: colNames, + } + egs.args["Asc"] = args + return egs +} + +// StoreEngine is only avialble mysql dialect currently +func (egs *EGSession) StoreEngine(storeEngine string) *EGSession { + egs.operation = append(egs.operation, "StoreEngine") + args := StoreEngineArgs{ + storeEngine: storeEngine, + } + egs.args["StoreEngine"] = args + return egs +} + +// Charset is only avialble mysql dialect currently +func (egs *EGSession) Charset(charset string) *EGSession { + egs.operation = append(egs.operation, "Charset") + args := CharsetArgs{ + charset: charset, + } + egs.args["Charset"] = args + return egs +} + +// Cascade indicates if loading sub Struct +func (egs *EGSession) Cascade(trueOrFalse ...bool) *EGSession { + egs.operation = append(egs.operation, "Cascade") + args := CascadeArgs{ + trueOrFalse: trueOrFalse, + } + egs.args["Cascade"] = args + return egs +} + +// NoCache ask this session do not retrieve data from cache system and +// get data from database directly. +func (egs *EGSession) NoCache() *EGSession { + egs.operation = append(egs.operation, "NoCache") + return egs +} + +// Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN +func (egs *EGSession) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "Join") + joinArgs := JoinArgs{ + joinOperator: joinOperator, + tablename: tablename, + condition: condition, + args: args, + } + egs.args["Join"] = joinArgs + return egs +} + +// GroupBy Generate Group By statement +func (egs *EGSession) GroupBy(keys string) *EGSession { + egs.operation = append(egs.operation, "GroupBy") + args := GroupByArgs{ + keys: keys, + } + egs.args["GroupBy"] = args + return egs +} + +// Having Generate Having statement +func (egs *EGSession) Having(conditions string) *EGSession { + egs.operation = append(egs.operation, "Having") + args := HavingArgs{ + conditions: conditions, + } + egs.args["Having"] = args + return egs +} + +// Unscoped always disable struct tag "deleted" +func (egs *EGSession) Unscoped() *EGSession { + egs.operation = append(egs.operation, "Unscoped") + return egs +} + +// Incr provides a query string like "count = count + 1" +func (egs *EGSession) Incr(column string, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "Incr") + incrArgs := IncrArgs{ + column: column, + args: args, + } + egs.args["Incr"] = incrArgs + return egs +} + +// Decr provides a query string like "count = count - 1" +func (egs *EGSession) Decr(column string, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "Decr") + decrArgs := DecrArgs{ + column: column, + args: args, + } + egs.args["Decr"] = decrArgs + return egs +} + +// SetExpr provides a query string like "column = {expression}" +func (egs *EGSession) SetExpr(column string, expression string) *EGSession { + egs.operation = append(egs.operation, "SetExpr") + args := SetExprArgs{ + column: column, + expression: expression, + } + egs.args["SetExpr"] = args + return egs +} + +// Select provides some columns to special +func (egs *EGSession) Select(str string) *EGSession { + egs.operation = append(egs.operation, "Select") + args := SelectArgs{ + str: str, + } + egs.args["Select"] = args + return egs +} + +// Cols provides some columns to special +func (egs *EGSession) Cols(columns ...string) *EGSession { + egs.operation = append(egs.operation, "Cols") + args := ColsArgs{ + columns: columns, + } + egs.args["Cols"] = args + return egs +} + +// AllCols ask all columns +func (egs *EGSession) AllCols() *EGSession { + egs.operation = append(egs.operation, "AllCols") + return egs +} + +// MustCols specify some columns must use even if they are empty +func (egs *EGSession) MustCols(columns ...string) *EGSession { + egs.operation = append(egs.operation, "MustCols") + args := MustColsArgs{ + columns: columns, + } + egs.args["MustCols"] = args + return egs +} + +// UseBool automatically retrieve condition according struct, but +// if struct has bool field, it will ignore them. So use UseBool +// to tell system to do not ignore them. +// If no parameters, it will use all the bool field of struct, or +// it will use parameters's columns +func (egs *EGSession) UseBool(columns ...string) *EGSession { + egs.operation = append(egs.operation, "UseBool") + args := UseBoolArgs{ + columns: columns, + } + egs.args["UseBool"] = args + return egs +} + +// Distinct use for distinct columns. Caution: when you are using cache, +// distinct will not be cached because cache system need id, +// but distinct will not provide id +func (egs *EGSession) Distinct(columns ...string) *EGSession { + egs.operation = append(egs.operation, "Distinct") + args := DistinctArgs{ + columns: columns, + } + egs.args["Distinct"] = args + return egs +} + +// Omit Only not use the parameters as select or update columns +func (egs *EGSession) Omit(columns ...string) *EGSession { + egs.operation = append(egs.operation, "Omit") + args := OmitArgs{ + columns: columns, + } + egs.args["Omit"] = args + return egs +} + +// Nullable Set null when column is zero-value and nullable for update +func (egs *EGSession) Nullable(columns ...string) *EGSession { + egs.operation = append(egs.operation, "Nullable") + args := NullableArgs{ + columns: columns, + } + egs.args["Nullable"] = args + return egs +} + +// NoAutoTime means do not automatically give created field and updated field +// the current time on the current session temporarily +func (egs *EGSession) NoAutoTime() *EGSession { + egs.operation = append(egs.operation, "NoAutoTime") + return egs +} + +// Sql provides raw sql input parameter. When you have a complex SQL statement +// and cannot use Where, Id, In and etc. Methods to describe, you can use SQL. +// +// Deprecated: use SQL instead. +func (egs *EGSession) Sql(query string, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "Sql") + sqlArgs := SqlArgs{ + query: query, + args: args, + } + egs.args["Sql"] = sqlArgs + return egs +} + +type SQLArgs struct { + query interface{} + args []interface{} +} + +// SQL provides raw sql input parameter. When you have a complex SQL statement +// and cannot use Where, Id, In and etc. Methods to describe, you can use SQL. +func (egs *EGSession) SQL(query interface{}, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "SQL") + sqlArgs := SQLArgs{ + query: query, + args: args, + } + egs.args["SQL"] = sqlArgs + return egs +} + +// Where provides custom query condition. +func (egs *EGSession) Where(query interface{}, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "Where") + whereArgs := WhereArgs{ + query: query, + args: args, + } + egs.args["Where"] = whereArgs + return egs +} + +type AndArgs struct { + query interface{} + args []interface{} +} + +// And provides custom query condition. +func (egs *EGSession) And(query interface{}, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "And") + andArgs := AndArgs{ + query: query, + args: args, + } + egs.args["And"] = andArgs + return egs +} + +type OrArgs struct { + query interface{} + args []interface{} +} + +// Or provides custom query condition. +func (egs *EGSession) Or(query interface{}, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "Or") + orArgs := OrArgs{ + query: query, + args: args, + } + egs.args["Or"] = orArgs + return egs +} + +// Id provides converting id as a query condition +// +// Deprecated: use ID instead +func (egs *EGSession) Id(id interface{}) *EGSession { + egs.operation = append(egs.operation, "Id") + args := IdArgs{ + id: id, + } + egs.args["Id"] = args + return egs +} + +// ID provides converting id as a query condition +func (egs *EGSession) ID(id interface{}) *EGSession { + egs.operation = append(egs.operation, "ID") + args := IDArgs{ + id: id, + } + egs.args["ID"] = args + return egs +} + +// In provides a query string like "id in (1, 2, 3)" +func (egs *EGSession) In(column string, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "In") + inArgs := InArgs{ + column: column, + args: args, + } + egs.args["In"] = inArgs + return egs +} + +// NotIn provides a query string like "id in (1, 2, 3)" +func (egs *EGSession) NotIn(column string, args ...interface{}) *EGSession { + egs.operation = append(egs.operation, "NotIn") + notInArgs := NotInArgs{ + column: column, + args: args, + } + egs.args["NotIn"] = notInArgs + return egs +} + +// Conds returns session query conditions except auto bean conditions +func (egs *EGSession) Conds() builder.Cond { + return egs.eg.Master().NewSession().Conds() +} + +// Delete records, bean's non-empty fields are conditions +func (egs *EGSession) Delete(bean interface{}) (int64, error) { + session := egs.eg.Master().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Delete(bean) +} + +// Exist returns true if the record exist otherwise return false +func (egs *EGSession) Exist(bean ...interface{}) (bool, error) { + session := egs.eg.Master().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Exist(bean...) +} + +// Find retrieve records from table, condiBeans's non-empty fields +// are conditions. beans could be []Struct, []*Struct, map[int64]Struct +// map[int64]*Struct +func (egs *EGSession) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Find(rowsSlicePtr, condiBean...) +} + +// Get retrieve one record from database, bean's non-empty fields +// will be as conditions +func (egs *EGSession) Get(bean interface{}) (bool, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Get(bean) +} + +// Insert insert one or more beans +func (egs *EGSession) Insert(beans ...interface{}) (int64, error) { + session := egs.eg.Master().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Insert(beans...) +} + +// Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields +// are conditions. +func (egs *EGSession) Rows(bean interface{}) (*Rows, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Rows(bean) +} + +// Iterate record by record handle records from table, condiBeans's non-empty fields +// are conditions. beans could be []Struct, []*Struct, map[int64]Struct +// map[int64]*Struct +func (egs *EGSession) Iterate(bean interface{}, fun IterFunc) error { + return egs.eg.Slave().Iterate(bean, fun) +} + +// BufferSize sets the buffersize for iterate +func (egs *EGSession) BufferSize(size int) *EGSession { + egs.operation = append(egs.operation, "BufferSize") + args := BufferSizeArgs{ + size: size, + } + egs.args["BufferSize"] = args + return egs +} + +// Query runs a raw sql and return records as []map[string][]byte +func (egs *EGSession) Query(sqlStr string, args ...interface{}) ([]map[string][]byte, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Query(sqlStr, args...) +} + +// QueryString runs a raw sql and return records as []map[string]string +func (egs *EGSession) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.QueryString(sqlStr, args...) +} + +// QueryInterface runs a raw sql and return records as []map[string]interface{} +func (egs *EGSession) QueryInterface(sqlStr string, args ...interface{}) ([]map[string]interface{}, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.QueryInterface(sqlStr, args...) +} + +// Exec raw sql +func (egs *EGSession) Exec(sqlStr string, args ...interface{}) (sql.Result, error) { + session := egs.eg.Master().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Exec(sqlStr, args...) +} + +// CreateTable create a table according a bean +func (egs *EGSession) CreateTable(bean interface{}) error { + session := egs.eg.Master().NewSession() + defer session.Close() + return session.CreateTable(bean) +} + +// CreateIndexes create indexes +func (egs *EGSession) CreateIndexes(bean interface{}) error { + return egs.eg.Master().CreateIndexes(bean) +} + +// CreateUniques create uniques +func (egs *EGSession) CreateUniques(bean interface{}) error { + return egs.eg.Master().CreateUniques(bean) +} + +// DropIndexes drop indexes +func (egs *EGSession) DropIndexes(bean interface{}) error { + return egs.eg.Master().DropIndexes(bean) +} + +// DropTable drop table will drop table if exist, if drop failed, it will return error +func (egs *EGSession) DropTable(beanOrTableName interface{}) error { + session := egs.eg.Master().NewSession() + defer session.Close() + return session.DropTable(beanOrTableName) +} + +// IsTableExist if a table is exist +func (egs *EGSession) IsTableExist(beanOrTableName interface{}) (bool, error) { + return egs.eg.Master().IsTableExist(beanOrTableName) +} + +// IsTableEmpty if table have any records +func (egs *EGSession) IsTableEmpty(bean interface{}) (bool, error) { + return egs.eg.Master().IsTableEmpty(bean) +} + +// Sync2 synchronize structs to database tables +func (egs *EGSession) Sync2(beans ...interface{}) error { + return egs.eg.Master().Sync2(beans...) +} + +// Count counts the records. bean's non-empty fields +// are conditions. +func (egs *EGSession) Count(bean ...interface{}) (int64, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Count(bean...) +} + +// sum call sum some column. bean's non-empty fields are conditions. +func (egs *EGSession) Sum(bean interface{}, columnName string) (res float64, err error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Sum(bean, columnName) +} + +// SumInt call sum some column. bean's non-empty fields are conditions. +func (egs *EGSession) SumInt(bean interface{}, columnName string) (res int64, err error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.SumInt(bean, columnName) +} + +// Sums call sum some columns. bean's non-empty fields are conditions. +func (egs *EGSession) Sums(bean interface{}, columnNames ...string) ([]float64, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Sums(bean, columnNames...) +} + +// SumsInt sum specify columns and return as []int64 instead of []float64 +func (egs *EGSession) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) { + session := egs.eg.Slave().NewSession() + defer session.Close() + session = egs.operate(session) + return session.SumsInt(bean, columnNames...) +} + +// Update records, bean's non-empty fields are updated contents, +// condiBean' non-empty filds are conditions +// CAUTION: +// 1.bool will defaultly be updated content nor conditions +// You should call UseBool if you have bool to use. +// 2.float32 & float64 may be not inexact as conditions +func (egs *EGSession) Update(bean interface{}, condiBean ...interface{}) (int64, error) { + session := egs.eg.Master().NewSession() + defer session.Close() + session = egs.operate(session) + return session.Update(bean, condiBean...) + +} 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_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()) }