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

Merge 4d30c6865a into c9690500fa

This commit is contained in:
WhiteBatman 2017-09-26 02:22:36 +00:00 committed by GitHub
parent c9690500fa 4d30c6865a
commit 42ab3b2b1e
6 changed files with 1815 additions and 1762 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
engine.go
View File

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

887
engine_group.go Normal file
View File

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

134
engine_group_policy.go Normal file
View File

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

764
engine_group_session.go Normal file
View File

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

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

1149
session_update_test.go
View File

File diff suppressed because it is too large Load Diff