add support group engine
This commit is contained in:
WhiteBatman
parent
e9f95a9f8b
commit
a21b0243bd
|
|
@ -0,0 +1,772 @@
|
|||
package xorm
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
|
||||
"github.com/go-xorm/builder"
|
||||
)
|
||||
|
||||
type GESession struct {
|
||||
ge *GroupEngine
|
||||
operation []string
|
||||
args map[string]interface{}
|
||||
err error
|
||||
}
|
||||
|
||||
func (ges *GESession) operate(session *Session) *Session {
|
||||
for _, v := range ges.operation {
|
||||
switch v {
|
||||
case "Before":
|
||||
args := ges.args["Before"].(BeforeArgs)
|
||||
session = session.Before(args.closures)
|
||||
case "After":
|
||||
args := ges.args["After"].(AfterArgs)
|
||||
session = session.After(args.closures)
|
||||
case "Table":
|
||||
args := ges.args["Table"].(TableArgs)
|
||||
session = session.Table(args.tableNameOrBean)
|
||||
case "Alias":
|
||||
args := ges.args["Alias"].(AliasArgs)
|
||||
session = session.Alias(args.alias)
|
||||
case "NoCascade":
|
||||
session = session.NoCascade()
|
||||
case "ForUpdate":
|
||||
session = session.ForUpdate()
|
||||
case "NoAutoCondition":
|
||||
args := ges.args["NoAutoCondition"].(NoAutoConditionArgs)
|
||||
session = session.NoAutoCondition(args.no...)
|
||||
case "Limit":
|
||||
args := ges.args["Limit"].(LimitArgs)
|
||||
session = session.Limit(args.limit, args.start...)
|
||||
case "OrderBy":
|
||||
args := ges.args["OrderBy"].(OrderByArgs)
|
||||
session = session.OrderBy(args.order)
|
||||
case "Desc":
|
||||
args := ges.args["Desc"].(DescArgs)
|
||||
session = session.Desc(args.colNames...)
|
||||
case "Asc":
|
||||
args := ges.args["Asc"].(AscArgs)
|
||||
session = session.Asc(args.colNames...)
|
||||
case "StoreEngine":
|
||||
args := ges.args["StoreEngine"].(StoreEngineArgs)
|
||||
session = session.StoreEngine(args.storeEngine)
|
||||
case "Charset":
|
||||
args := ges.args["Charset"].(CharsetArgs)
|
||||
session = session.Charset(args.charset)
|
||||
case "Cascade":
|
||||
args := ges.args["Cascade"].(CascadeArgs)
|
||||
session = session.Cascade(args.trueOrFalse...)
|
||||
case "NoCache":
|
||||
session = session.NoCache()
|
||||
case "Join":
|
||||
args := ges.args["Join"].(JoinArgs)
|
||||
session = session.Join(args.joinOperator, args.tablename, args.condition, args.args...)
|
||||
case "GroupBy":
|
||||
args := ges.args["GroupBy"].(GroupByArgs)
|
||||
session = session.GroupBy(args.keys)
|
||||
case "Having":
|
||||
args := ges.args["Having"].(HavingArgs)
|
||||
session = session.Having(args.conditions)
|
||||
case "Unscoped":
|
||||
session = session.Unscoped()
|
||||
case "Incr":
|
||||
args := ges.args["Incr"].(IncrArgs)
|
||||
session = session.Incr(args.column, args.args...)
|
||||
case "Decr":
|
||||
args := ges.args["Decr"].(DecrArgs)
|
||||
session = session.Decr(args.column, args.args...)
|
||||
case "SetExpr":
|
||||
args := ges.args["SetExpr"].(SetExprArgs)
|
||||
session = session.SetExpr(args.column, args.expression)
|
||||
case "Select":
|
||||
args := ges.args["Select"].(SelectArgs)
|
||||
session = session.Select(args.str)
|
||||
case "Cols":
|
||||
args := ges.args["Cols"].(ColsArgs)
|
||||
session = session.Cols(args.columns...)
|
||||
case "AllCols":
|
||||
session = session.AllCols()
|
||||
case "MustCols":
|
||||
args := ges.args["MustCols"].(MustColsArgs)
|
||||
session = session.MustCols(args.columns...)
|
||||
case "UseBool":
|
||||
args := ges.args["UseBool"].(UseBoolArgs)
|
||||
session = session.UseBool(args.columns...)
|
||||
case "Distinct":
|
||||
args := ges.args["Distinct"].(DistinctArgs)
|
||||
session = session.Distinct(args.columns...)
|
||||
case "Omit":
|
||||
args := ges.args["Omit"].(OmitArgs)
|
||||
session = session.Omit(args.columns...)
|
||||
case "Nullable":
|
||||
args := ges.args["Nullable"].(NullableArgs)
|
||||
session = session.Nullable(args.columns...)
|
||||
case "NoAutoTime":
|
||||
session = session.NoAutoTime()
|
||||
case "Sql":
|
||||
args := ges.args["Sql"].(SqlArgs)
|
||||
session = session.Sql(args.query, args.args...)
|
||||
case "SQL":
|
||||
args := ges.args["SQL"].(SqlArgs)
|
||||
session = session.SQL(args.query, args.args...)
|
||||
case "Where":
|
||||
args := ges.args["Where"].(WhereArgs)
|
||||
session = session.Where(args.query, args.args...)
|
||||
case "And":
|
||||
args := ges.args["And"].(AndArgs)
|
||||
session = session.And(args.query, args.args...)
|
||||
case "Or":
|
||||
args := ges.args["Or"].(OrArgs)
|
||||
session = session.Or(args.query, args.args...)
|
||||
case "Id":
|
||||
args := ges.args["Id"].(IdArgs)
|
||||
session = session.Id(args.id)
|
||||
case "ID":
|
||||
args := ges.args["ID"].(IDArgs)
|
||||
session = session.ID(args.id)
|
||||
case "In":
|
||||
args := ges.args["In"].(InArgs)
|
||||
session = session.In(args.column, args.args...)
|
||||
case "NotIn":
|
||||
args := ges.args["NotIn"].(NotInArgs)
|
||||
session = session.NotIn(args.column, args.args...)
|
||||
case "BufferSize":
|
||||
args := ges.args["BufferSize"].(BufferSizeArgs)
|
||||
session = session.BufferSize(args.size)
|
||||
}
|
||||
}
|
||||
return session
|
||||
}
|
||||
|
||||
// Before Apply before Processor, affected bean is passed to closure arg
|
||||
func (ges *GESession) Before(closures func(interface{})) *GESession {
|
||||
ges.operation = append(ges.operation, "Before")
|
||||
args := BeforeArgs{
|
||||
closures: closures,
|
||||
}
|
||||
ges.args["Before"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// After Apply after Processor, affected bean is passed to closure arg
|
||||
func (ges *GESession) After(closures func(interface{})) *GESession {
|
||||
ges.operation = append(ges.operation, "After")
|
||||
args := AfterArgs{
|
||||
closures: closures,
|
||||
}
|
||||
ges.args["After"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Table can input a string or pointer to struct for special a table to operate.
|
||||
func (ges *GESession) Table(tableNameOrBean interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Table")
|
||||
args := TableArgs{
|
||||
tableNameOrBean: tableNameOrBean,
|
||||
}
|
||||
ges.args["Table"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Alias set the table alias
|
||||
func (ges *GESession) Alias(alias string) *GESession {
|
||||
ges.operation = append(ges.operation, "Alias")
|
||||
args := AliasArgs{
|
||||
alias: alias,
|
||||
}
|
||||
ges.args["Alias"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// NoCascade indicate that no cascade load child object
|
||||
func (ges *GESession) NoCascade() *GESession {
|
||||
ges.operation = append(ges.operation, "NoCascade")
|
||||
return ges
|
||||
}
|
||||
|
||||
// ForUpdate Set Read/Write locking for UPDATE
|
||||
func (ges *GESession) ForUpdate() *GESession {
|
||||
ges.operation = append(ges.operation, "ForUpdate")
|
||||
return ges
|
||||
}
|
||||
|
||||
// NoAutoCondition disable generate SQL condition from beans
|
||||
func (ges *GESession) NoAutoCondition(no ...bool) *GESession {
|
||||
ges.operation = append(ges.operation, "NoAutoCondition")
|
||||
args := NoAutoConditionArgs{
|
||||
no: no,
|
||||
}
|
||||
ges.args["NoAutoCondition"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Limit provide limit and offset query condition
|
||||
func (ges *GESession) Limit(limit int, start ...int) *GESession {
|
||||
ges.operation = append(ges.operation, "Limit")
|
||||
args := LimitArgs{
|
||||
limit: limit,
|
||||
start: start,
|
||||
}
|
||||
ges.args["Limit"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// OrderBy provide order by query condition, the input parameter is the content
|
||||
// after order by on a sql statement.
|
||||
func (ges *GESession) OrderBy(order string) *GESession {
|
||||
ges.operation = append(ges.operation, "OrderBy")
|
||||
args := OrderByArgs{
|
||||
order: order,
|
||||
}
|
||||
ges.args["OrderBy"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Desc provide desc order by query condition, the input parameters are columns.
|
||||
func (ges *GESession) Desc(colNames ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "Desc")
|
||||
args := DescArgs{
|
||||
colNames: colNames,
|
||||
}
|
||||
ges.args["Desc"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Asc provide asc order by query condition, the input parameters are columns.
|
||||
func (ges *GESession) Asc(colNames ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "Asc")
|
||||
args := AscArgs{
|
||||
colNames: colNames,
|
||||
}
|
||||
ges.args["Asc"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// StoreEngine is only avialble mysql dialect currently
|
||||
func (ges *GESession) StoreEngine(storeEngine string) *GESession {
|
||||
ges.operation = append(ges.operation, "StoreEngine")
|
||||
args := StoreEngineArgs{
|
||||
storeEngine: storeEngine,
|
||||
}
|
||||
ges.args["StoreEngine"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Charset is only avialble mysql dialect currently
|
||||
func (ges *GESession) Charset(charset string) *GESession {
|
||||
ges.operation = append(ges.operation, "Charset")
|
||||
args := CharsetArgs{
|
||||
charset: charset,
|
||||
}
|
||||
ges.args["Charset"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Cascade indicates if loading sub Struct
|
||||
func (ges *GESession) Cascade(trueOrFalse ...bool) *GESession {
|
||||
ges.operation = append(ges.operation, "Cascade")
|
||||
args := CascadeArgs{
|
||||
trueOrFalse: trueOrFalse,
|
||||
}
|
||||
ges.args["Cascade"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// NoCache ask this session do not retrieve data from cache system and
|
||||
// get data from database directly.
|
||||
func (ges *GESession) NoCache() *GESession {
|
||||
ges.operation = append(ges.operation, "NoCache")
|
||||
return ges
|
||||
}
|
||||
|
||||
// Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
|
||||
func (ges *GESession) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Join")
|
||||
joinArgs := JoinArgs{
|
||||
joinOperator: joinOperator,
|
||||
tablename: tablename,
|
||||
condition: condition,
|
||||
args: args,
|
||||
}
|
||||
ges.args["Join"] = joinArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// GroupBy Generate Group By statement
|
||||
func (ges *GESession) GroupBy(keys string) *GESession {
|
||||
ges.operation = append(ges.operation, "GroupBy")
|
||||
args := GroupByArgs{
|
||||
keys: keys,
|
||||
}
|
||||
ges.args["GroupBy"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Having Generate Having statement
|
||||
func (ges *GESession) Having(conditions string) *GESession {
|
||||
ges.operation = append(ges.operation, "Having")
|
||||
args := HavingArgs{
|
||||
conditions: conditions,
|
||||
}
|
||||
ges.args["Having"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Unscoped always disable struct tag "deleted"
|
||||
func (ges *GESession) Unscoped() *GESession {
|
||||
ges.operation = append(ges.operation, "Unscoped")
|
||||
return ges
|
||||
}
|
||||
|
||||
// Incr provides a query string like "count = count + 1"
|
||||
func (ges *GESession) Incr(column string, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Incr")
|
||||
incrArgs := IncrArgs{
|
||||
column: column,
|
||||
args: args,
|
||||
}
|
||||
ges.args["Incr"] = incrArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// Decr provides a query string like "count = count - 1"
|
||||
func (ges *GESession) Decr(column string, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Decr")
|
||||
decrArgs := DecrArgs{
|
||||
column: column,
|
||||
args: args,
|
||||
}
|
||||
ges.args["Decr"] = decrArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// SetExpr provides a query string like "column = {expression}"
|
||||
func (ges *GESession) SetExpr(column string, expression string) *GESession {
|
||||
ges.operation = append(ges.operation, "SetExpr")
|
||||
args := SetExprArgs{
|
||||
column: column,
|
||||
expression: expression,
|
||||
}
|
||||
ges.args["SetExpr"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Select provides some columns to special
|
||||
func (ges *GESession) Select(str string) *GESession {
|
||||
ges.operation = append(ges.operation, "Select")
|
||||
args := SelectArgs{
|
||||
str: str,
|
||||
}
|
||||
ges.args["Select"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Cols provides some columns to special
|
||||
func (ges *GESession) Cols(columns ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "Cols")
|
||||
args := ColsArgs{
|
||||
columns: columns,
|
||||
}
|
||||
ges.args["Cols"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// AllCols ask all columns
|
||||
func (ges *GESession) AllCols() *GESession {
|
||||
ges.operation = append(ges.operation, "AllCols")
|
||||
return ges
|
||||
}
|
||||
|
||||
// MustCols specify some columns must use even if they are empty
|
||||
func (ges *GESession) MustCols(columns ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "MustCols")
|
||||
args := MustColsArgs{
|
||||
columns: columns,
|
||||
}
|
||||
ges.args["MustCols"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// 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 (ges *GESession) UseBool(columns ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "UseBool")
|
||||
args := UseBoolArgs{
|
||||
columns: columns,
|
||||
}
|
||||
ges.args["UseBool"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// 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 (ges *GESession) Distinct(columns ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "Distinct")
|
||||
args := DistinctArgs{
|
||||
columns: columns,
|
||||
}
|
||||
ges.args["Distinct"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Omit Only not use the parameters as select or update columns
|
||||
func (ges *GESession) Omit(columns ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "Omit")
|
||||
args := OmitArgs{
|
||||
columns: columns,
|
||||
}
|
||||
ges.args["Omit"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// Nullable Set null when column is zero-value and nullable for update
|
||||
func (ges *GESession) Nullable(columns ...string) *GESession {
|
||||
ges.operation = append(ges.operation, "Nullable")
|
||||
args := NullableArgs{
|
||||
columns: columns,
|
||||
}
|
||||
ges.args["Nullable"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// NoAutoTime means do not automatically give created field and updated field
|
||||
// the current time on the current session temporarily
|
||||
func (ges *GESession) NoAutoTime() *GESession {
|
||||
ges.operation = append(ges.operation, "NoAutoTime")
|
||||
return ges
|
||||
}
|
||||
|
||||
// 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 (ges *GESession) Sql(query interface{}, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Sql")
|
||||
sqlArgs := SqlArgs{
|
||||
query: query,
|
||||
args: args,
|
||||
}
|
||||
ges.args["Sql"] = sqlArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// 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 (ges *GESession) SQL(query interface{}, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "SQL")
|
||||
sqlArgs := SqlArgs{
|
||||
query: query,
|
||||
args: args,
|
||||
}
|
||||
ges.args["SQL"] = sqlArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// Where provides custom query condition.
|
||||
func (ges *GESession) Where(query interface{}, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Where")
|
||||
whereArgs := WhereArgs{
|
||||
query: query,
|
||||
args: args,
|
||||
}
|
||||
ges.args["Where"] = whereArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
type AndArgs struct {
|
||||
query interface{}
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// And provides custom query condition.
|
||||
func (ges *GESession) And(query interface{}, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "And")
|
||||
andArgs := AndArgs{
|
||||
query: query,
|
||||
args: args,
|
||||
}
|
||||
ges.args["And"] = andArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
type OrArgs struct {
|
||||
query interface{}
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// Or provides custom query condition.
|
||||
func (ges *GESession) Or(query interface{}, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Or")
|
||||
orArgs := OrArgs{
|
||||
query: query,
|
||||
args: args,
|
||||
}
|
||||
ges.args["Or"] = orArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// Id provides converting id as a query condition
|
||||
//
|
||||
// Deprecated: use ID instead
|
||||
func (ges *GESession) Id(id interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "Id")
|
||||
args := IdArgs{
|
||||
id: id,
|
||||
}
|
||||
ges.args["Id"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// ID provides converting id as a query condition
|
||||
func (ges *GESession) ID(id interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "ID")
|
||||
args := IDArgs{
|
||||
id: id,
|
||||
}
|
||||
ges.args["ID"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
// In provides a query string like "id in (1, 2, 3)"
|
||||
func (ges *GESession) In(column string, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "In")
|
||||
inArgs := InArgs{
|
||||
column: column,
|
||||
args: args,
|
||||
}
|
||||
ges.args["In"] = inArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
// NotIn provides a query string like "id in (1, 2, 3)"
|
||||
func (ges *GESession) NotIn(column string, args ...interface{}) *GESession {
|
||||
ges.operation = append(ges.operation, "NotIn")
|
||||
notInArgs := NotInArgs{
|
||||
column: column,
|
||||
args: args,
|
||||
}
|
||||
ges.args["NotIn"] = notInArgs
|
||||
return ges
|
||||
}
|
||||
|
||||
//TODO 还需要分析如何实现
|
||||
// Conds returns session query conditions except auto bean conditions
|
||||
func (ges *GESession) Conds() builder.Cond {
|
||||
return ges.ge.Master().NewSession().Conds()
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Delete records, bean's non-empty fields are conditions
|
||||
func (ges *GESession) Delete(bean interface{}) (int64, error) {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Delete(bean)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Exist returns true if the record exist otherwise return false
|
||||
func (ges *GESession) Exist(bean ...interface{}) (bool, error) {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Exist(bean...)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Find retrieve records from table, condiBeans's non-empty fields
|
||||
// are conditions. beans could be []Struct, []*Struct, map[int64]Struct
|
||||
// map[int64]*Struct
|
||||
func (ges *GESession) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Find(rowsSlicePtr, condiBean...)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Get retrieve one record from database, bean's non-empty fields
|
||||
// will be as conditions
|
||||
func (ges *GESession) Get(bean interface{}) (bool, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Get(bean)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Insert insert one or more beans
|
||||
func (ges *GESession) Insert(beans ...interface{}) (int64, error) {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.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 (ges *GESession) Rows(bean interface{}) (*Rows, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.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 (ges *GESession) Iterate(bean interface{}, fun IterFunc) error {
|
||||
return ges.ge.Slave().Iterate(bean, fun)
|
||||
}
|
||||
|
||||
// BufferSize sets the buffersize for iterate
|
||||
func (ges *GESession) BufferSize(size int) *GESession {
|
||||
ges.operation = append(ges.operation, "BufferSize")
|
||||
args := BufferSizeArgs{
|
||||
size: size,
|
||||
}
|
||||
ges.args["BufferSize"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Query runs a raw sql and return records as []map[string][]byte
|
||||
func (ges *GESession) Query(sqlStr string, args ...interface{}) ([]map[string][]byte, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Query(sqlStr, args...)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// QueryString runs a raw sql and return records as []map[string]string
|
||||
func (ges *GESession) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.QueryString(sqlStr, args...)
|
||||
}
|
||||
|
||||
// QueryInterface runs a raw sql and return records as []map[string]interface{}
|
||||
func (ges *GESession) QueryInterface(sqlStr string, args ...interface{}) ([]map[string]interface{}, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.QueryInterface(sqlStr, args...)
|
||||
}
|
||||
|
||||
// Exec raw sql
|
||||
func (ges *GESession) Exec(sqlStr string, args ...interface{}) (sql.Result, error) {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Exec(sqlStr, args...)
|
||||
}
|
||||
|
||||
// CreateTable create a table according a bean
|
||||
func (ges *GESession) CreateTable(bean interface{}) error {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
return session.CreateTable(bean)
|
||||
}
|
||||
|
||||
// CreateIndexes create indexes
|
||||
func (ges *GESession) CreateIndexes(bean interface{}) error {
|
||||
return ges.ge.Master().CreateIndexes(bean)
|
||||
}
|
||||
|
||||
// CreateUniques create uniques
|
||||
func (ges *GESession) CreateUniques(bean interface{}) error {
|
||||
return ges.ge.Master().CreateUniques(bean)
|
||||
}
|
||||
|
||||
// DropIndexes drop indexes
|
||||
func (ges *GESession) DropIndexes(bean interface{}) error {
|
||||
return ges.ge.Master().DropIndexes(bean)
|
||||
}
|
||||
|
||||
// DropTable drop table will drop table if exist, if drop failed, it will return error
|
||||
func (ges *GESession) DropTable(beanOrTableName interface{}) error {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
return session.DropTable(beanOrTableName)
|
||||
}
|
||||
|
||||
// IsTableExist if a table is exist
|
||||
func (ges *GESession) IsTableExist(beanOrTableName interface{}) (bool, error) {
|
||||
return ges.ge.Master().IsTableExist(beanOrTableName)
|
||||
}
|
||||
|
||||
// IsTableEmpty if table have any records
|
||||
func (ges *GESession) IsTableEmpty(bean interface{}) (bool, error) {
|
||||
return ges.ge.Master().IsTableEmpty(bean)
|
||||
}
|
||||
|
||||
// Sync2 synchronize structs to database tables
|
||||
func (ges *GESession) Sync2(beans ...interface{}) error {
|
||||
return ges.ge.Master().Sync2(beans...)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Count counts the records. bean's non-empty fields
|
||||
// are conditions.
|
||||
func (ges *GESession) Count(bean ...interface{}) (int64, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Count(bean...)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// sum call sum some column. bean's non-empty fields are conditions.
|
||||
func (ges *GESession) Sum(bean interface{}, columnName string) (res float64, err error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Sum(bean, columnName)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// SumInt call sum some column. bean's non-empty fields are conditions.
|
||||
func (ges *GESession) SumInt(bean interface{}, columnName string) (res int64, err error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.SumInt(bean, columnName)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// Sums call sum some columns. bean's non-empty fields are conditions.
|
||||
func (ges *GESession) Sums(bean interface{}, columnNames ...string) ([]float64, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Sums(bean, columnNames...)
|
||||
}
|
||||
|
||||
//TODO 缺少前置session操作链
|
||||
// SumsInt sum specify columns and return as []int64 instead of []float64
|
||||
func (ges *GESession) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) {
|
||||
session := ges.ge.Slave().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.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 (ges *GESession) Update(bean interface{}, condiBean ...interface{}) (int64, error) {
|
||||
session := ges.ge.Master().NewSession()
|
||||
defer session.Close()
|
||||
session = ges.operate(session)
|
||||
return session.Update(bean, condiBean...)
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,744 @@
|
|||
// 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"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/go-xorm/builder"
|
||||
"github.com/go-xorm/core"
|
||||
)
|
||||
|
||||
type GroupEngine struct {
|
||||
engines []*Engine
|
||||
count uint64
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) Master() *Engine {
|
||||
return ge.engines[0]
|
||||
}
|
||||
|
||||
// Slave returns one of the physical databases which is a slave
|
||||
func (ge *GroupEngine) Slave() *Engine {
|
||||
return ge.engines[ge.slave(len(ge.engines))]
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) GetEngine(i int) *Engine {
|
||||
if i >= len(ge.engines) {
|
||||
return ge.engines[0]
|
||||
}
|
||||
return ge.engines[i]
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) slave(n int) int {
|
||||
if n <= 1 {
|
||||
return 0
|
||||
}
|
||||
return int(1 + (atomic.AddUint64(&ge.count, 1) % uint64(n-1)))
|
||||
}
|
||||
|
||||
// ShowSQL show SQL statement or not on logger if log level is great than INFO
|
||||
func (ge *GroupEngine) ShowSQL(show ...bool) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].ShowSQL(show...)
|
||||
}
|
||||
}
|
||||
|
||||
// ShowExecTime show SQL statement and execute time or not on logger if log level is great than INFO
|
||||
func (ge *GroupEngine) ShowExecTime(show ...bool) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].ShowExecTime(show...)
|
||||
}
|
||||
}
|
||||
|
||||
// SetMapper set the name mapping rules
|
||||
func (ge *GroupEngine) SetMapper(mapper core.IMapper) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].SetTableMapper(mapper)
|
||||
ge.engines[i].SetColumnMapper(mapper)
|
||||
}
|
||||
}
|
||||
|
||||
// SetTableMapper set the table name mapping rule
|
||||
func (ge *GroupEngine) SetTableMapper(mapper core.IMapper) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].TableMapper = mapper
|
||||
}
|
||||
}
|
||||
|
||||
// SetColumnMapper set the column name mapping rule
|
||||
func (ge *GroupEngine) SetColumnMapper(mapper core.IMapper) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].ColumnMapper = mapper
|
||||
}
|
||||
}
|
||||
|
||||
// SetMaxOpenConns is only available for go 1.2+
|
||||
func (ge *GroupEngine) SetMaxOpenConns(conns int) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].db.SetMaxOpenConns(conns)
|
||||
}
|
||||
}
|
||||
|
||||
// SetMaxIdleConns set the max idle connections on pool, default is 2
|
||||
func (ge *GroupEngine) SetMaxIdleConns(conns int) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[i].db.SetMaxIdleConns(conns)
|
||||
}
|
||||
}
|
||||
|
||||
// NoCascade If you do not want to auto cascade load object
|
||||
func (ge *GroupEngine) NoCascade() *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.NoCascade()
|
||||
}
|
||||
|
||||
// Close the engine
|
||||
func (ge *GroupEngine) Close() error {
|
||||
for i, _ := range ge.engines {
|
||||
err := ge.engines[i].db.Close()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Ping tests if database is alive
|
||||
func (ge *GroupEngine) Ping() error {
|
||||
return scatter(len(ge.engines), func(i int) error {
|
||||
return ge.engines[i].Ping()
|
||||
})
|
||||
}
|
||||
|
||||
// SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
|
||||
func (ge *GroupEngine) SetConnMaxLifetime(d time.Duration) {
|
||||
for i, _ := range ge.engines {
|
||||
ge.engines[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 (ge *GroupEngine) SqlType(c *core.Column) string {
|
||||
return ge.Master().SQLType(c)
|
||||
}
|
||||
|
||||
// SQLType A simple wrapper to dialect's core.SqlType method
|
||||
func (ge *GroupEngine) SQLType(c *core.Column) string {
|
||||
return ge.Master().dialect.SqlType(c)
|
||||
}
|
||||
|
||||
// NewSession New a session
|
||||
func (ge *GroupEngine) NewSession() *Session {
|
||||
return ge.Master().NewSession()
|
||||
}
|
||||
|
||||
// NewSession New a session
|
||||
func (ge *GroupEngine) NewGESession() *GESession {
|
||||
args := make(map[string]interface{})
|
||||
ges := &GESession{ge: ge, operation: []string{}, args: args}
|
||||
return ges
|
||||
}
|
||||
|
||||
type SqlArgs struct {
|
||||
query interface{}
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) Sql(query interface{}, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Sql(query, args...)
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) SQL(query interface{}, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.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 (ge *GroupEngine) NoAutoTime() *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.NoAutoTime()
|
||||
}
|
||||
|
||||
type NoAutoConditionArgs struct {
|
||||
no []bool
|
||||
}
|
||||
|
||||
// NoAutoCondition disable auto generate Where condition from bean or not
|
||||
func (ge *GroupEngine) NoAutoCondition(no ...bool) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.NoAutoCondition(no...)
|
||||
}
|
||||
|
||||
// DBMetas Retrieve all tables, columns, indexes' informations from database.
|
||||
func (ge *GroupEngine) DBMetas() ([]*core.Table, error) {
|
||||
return ge.Master().DBMetas()
|
||||
}
|
||||
|
||||
// DumpAllToFile dump database all table structs and data to a file
|
||||
func (ge *GroupEngine) DumpAllToFile(fp string, tp ...core.DbType) error {
|
||||
return ge.Master().DumpAllToFile(fp, tp...)
|
||||
}
|
||||
|
||||
// DumpAll dump database all table structs and data to w
|
||||
func (ge *GroupEngine) DumpAll(w io.Writer, tp ...core.DbType) error {
|
||||
return ge.Master().DumpAll(w, tp...)
|
||||
}
|
||||
|
||||
// DumpTablesToFile dump specified tables to SQL file.
|
||||
func (ge *GroupEngine) DumpTablesToFile(tables []*core.Table, fp string, tp ...core.DbType) error {
|
||||
return ge.Master().DumpTablesToFile(tables, fp, tp...)
|
||||
}
|
||||
|
||||
// DumpTables dump specify tables to io.Writer
|
||||
func (ge *GroupEngine) DumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error {
|
||||
return ge.Master().DumpTables(tables, w, tp...)
|
||||
}
|
||||
|
||||
type CascadeArgs struct {
|
||||
trueOrFalse []bool
|
||||
}
|
||||
|
||||
// Cascade use cascade or not
|
||||
func (ge *GroupEngine) Cascade(trueOrFalse ...bool) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Cascade(trueOrFalse...)
|
||||
}
|
||||
|
||||
type WhereArgs struct {
|
||||
query interface{}
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// Where method provide a condition query
|
||||
func (ge *GroupEngine) Where(query interface{}, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Where(query, args...)
|
||||
}
|
||||
|
||||
type IdArgs struct {
|
||||
id interface{}
|
||||
}
|
||||
|
||||
// Id will be deprecated, please use ID instead
|
||||
func (ge *GroupEngine) Id(id interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Id(id)
|
||||
}
|
||||
|
||||
type IDArgs struct {
|
||||
id interface{}
|
||||
}
|
||||
|
||||
// ID method provoide a condition as (id) = ?
|
||||
func (ge *GroupEngine) ID(id interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
ges.operation = append(ges.operation, "ID")
|
||||
args := IDArgs{
|
||||
id: id,
|
||||
}
|
||||
ges.args["ID"] = args
|
||||
return ges
|
||||
}
|
||||
|
||||
type BeforeArgs struct {
|
||||
closures func(interface{})
|
||||
}
|
||||
|
||||
// Before apply before Processor, affected bean is passed to closure arg
|
||||
func (ge *GroupEngine) Before(closures func(interface{})) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Before(closures)
|
||||
}
|
||||
|
||||
type AfterArgs struct {
|
||||
closures func(interface{})
|
||||
}
|
||||
|
||||
// After apply after insert Processor, affected bean is passed to closure arg
|
||||
func (ge *GroupEngine) After(closures func(interface{})) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.After(closures)
|
||||
}
|
||||
|
||||
type CharsetArgs struct {
|
||||
charset string
|
||||
}
|
||||
|
||||
// Charset set charset when create table, only support mysql now
|
||||
func (ge *GroupEngine) Charset(charset string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Charset(charset)
|
||||
}
|
||||
|
||||
type StoreEngineArgs struct {
|
||||
storeEngine string
|
||||
}
|
||||
|
||||
// StoreEngine set store engine when create table, only support mysql now
|
||||
func (ge *GroupEngine) StoreEngine(storeEngine string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.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 (ge *GroupEngine) Distinct(columns ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Distinct(columns...)
|
||||
}
|
||||
|
||||
type SelectArgs struct {
|
||||
str string
|
||||
}
|
||||
|
||||
// Select customerize your select columns or contents
|
||||
func (ge *GroupEngine) Select(str string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Select(str)
|
||||
}
|
||||
|
||||
type ColsArgs struct {
|
||||
columns []string
|
||||
}
|
||||
|
||||
// Cols only use the parameters as select or update columns
|
||||
func (ge *GroupEngine) Cols(columns ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Cols(columns...)
|
||||
}
|
||||
|
||||
// AllCols indicates that all columns should be use
|
||||
func (ge *GroupEngine) AllCols() *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.AllCols()
|
||||
}
|
||||
|
||||
type MustColsArgs struct {
|
||||
columns []string
|
||||
}
|
||||
|
||||
// MustCols specify some columns must use even if they are empty
|
||||
func (ge *GroupEngine) MustCols(columns ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.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 (ge *GroupEngine) UseBool(columns ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.UseBool(columns...)
|
||||
}
|
||||
|
||||
type OmitArgs struct {
|
||||
columns []string
|
||||
}
|
||||
|
||||
// Omit only not use the parameters as select or update columns
|
||||
func (ge *GroupEngine) Omit(columns ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Omit(columns...)
|
||||
}
|
||||
|
||||
type NullableArgs struct {
|
||||
columns []string
|
||||
}
|
||||
|
||||
// Nullable set null when column is zero-value and nullable for update
|
||||
func (ge *GroupEngine) Nullable(columns ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Nullable(columns...)
|
||||
}
|
||||
|
||||
type InArgs struct {
|
||||
column string
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// In will generate "column IN (?, ?)"
|
||||
func (ge *GroupEngine) In(column string, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.In(column, args...)
|
||||
}
|
||||
|
||||
type NotInArgs struct {
|
||||
column string
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// NotIn will generate "column NOT IN (?, ?)"
|
||||
func (ge *GroupEngine) NotIn(column string, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.NotIn(column, args...)
|
||||
}
|
||||
|
||||
type IncrArgs struct {
|
||||
column string
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// Incr provides a update string like "column = column + ?"
|
||||
func (ge *GroupEngine) Incr(column string, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Incr(column, args...)
|
||||
}
|
||||
|
||||
type DecrArgs struct {
|
||||
column string
|
||||
args []interface{}
|
||||
}
|
||||
|
||||
// Decr provides a update string like "column = column - ?"
|
||||
func (ge *GroupEngine) Decr(column string, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Decr(column, args...)
|
||||
}
|
||||
|
||||
type SetExprArgs struct {
|
||||
column string
|
||||
expression string
|
||||
}
|
||||
|
||||
// SetExpr provides a update string like "column = {expression}"
|
||||
func (ge *GroupEngine) SetExpr(column string, expression string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.SetExpr(column, expression)
|
||||
}
|
||||
|
||||
type TableArgs struct {
|
||||
tableNameOrBean interface{}
|
||||
}
|
||||
|
||||
// Table temporarily change the Get, Find, Update's table
|
||||
func (ge *GroupEngine) Table(tableNameOrBean interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Table(tableNameOrBean)
|
||||
}
|
||||
|
||||
type AliasArgs struct {
|
||||
alias string
|
||||
}
|
||||
|
||||
// Alias set the table alias
|
||||
func (ge *GroupEngine) Alias(alias string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Alias(alias)
|
||||
}
|
||||
|
||||
type LimitArgs struct {
|
||||
limit int
|
||||
start []int
|
||||
}
|
||||
|
||||
// Limit will generate "LIMIT start, limit"
|
||||
func (ge *GroupEngine) Limit(limit int, start ...int) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Limit(limit, start...)
|
||||
}
|
||||
|
||||
type DescArgs struct {
|
||||
colNames []string
|
||||
}
|
||||
|
||||
// Desc will generate "ORDER BY column1 DESC, column2 DESC"
|
||||
func (ge *GroupEngine) Desc(colNames ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.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 (ge *GroupEngine) Asc(colNames ...string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Asc(colNames...)
|
||||
}
|
||||
|
||||
type OrderByArgs struct {
|
||||
order string
|
||||
}
|
||||
|
||||
// OrderBy will generate "ORDER BY order"
|
||||
func (ge *GroupEngine) OrderBy(order string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.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 (ge *GroupEngine) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Join(joinOperator, tablename, condition, args...)
|
||||
}
|
||||
|
||||
type GroupByArgs struct {
|
||||
keys string
|
||||
}
|
||||
|
||||
// GroupBy generate group by statement
|
||||
func (ge *GroupEngine) GroupBy(keys string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.GroupBy(keys)
|
||||
}
|
||||
|
||||
type HavingArgs struct {
|
||||
conditions string
|
||||
}
|
||||
|
||||
// Having generate having statement
|
||||
func (ge *GroupEngine) Having(conditions string) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Having(conditions)
|
||||
}
|
||||
|
||||
// IdOf get id from one struct
|
||||
//
|
||||
// Deprecated: use IDOf instead.
|
||||
func (ge *GroupEngine) IdOf(bean interface{}) core.PK {
|
||||
return ge.Master().IdOf(bean)
|
||||
}
|
||||
|
||||
// IDOf get id from one struct
|
||||
func (ge *GroupEngine) IDOf(bean interface{}) core.PK {
|
||||
return ge.Master().IDOf(bean)
|
||||
}
|
||||
|
||||
// IdOfV get id from one value of struct
|
||||
//
|
||||
// Deprecated: use IDOfV instead.
|
||||
func (ge *GroupEngine) IdOfV(rv reflect.Value) core.PK {
|
||||
return ge.Master().IdOfV(rv)
|
||||
}
|
||||
|
||||
// IDOfV get id from one value of struct
|
||||
func (ge *GroupEngine) IDOfV(rv reflect.Value) core.PK {
|
||||
return ge.Master().IDOfV(rv)
|
||||
}
|
||||
|
||||
// CreateIndexes create indexes
|
||||
func (ge *GroupEngine) CreateIndexes(bean interface{}) error {
|
||||
return ge.Master().CreateIndexes(bean)
|
||||
}
|
||||
|
||||
// CreateUniques create uniques
|
||||
func (ge *GroupEngine) CreateUniques(bean interface{}) error {
|
||||
return ge.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 (ge *GroupEngine) Sync(beans ...interface{}) error {
|
||||
return ge.Master().Sync(beans...)
|
||||
}
|
||||
|
||||
// Sync2 synchronize structs to database tables
|
||||
func (ge *GroupEngine) Sync2(beans ...interface{}) error {
|
||||
return ge.Master().Sync2(beans...)
|
||||
}
|
||||
|
||||
// CreateTables create tabls according bean
|
||||
func (ge *GroupEngine) CreateTables(beans ...interface{}) error {
|
||||
return ge.Master().CreateTables(beans...)
|
||||
}
|
||||
|
||||
// DropTables drop specify tables
|
||||
func (ge *GroupEngine) DropTables(beans ...interface{}) error {
|
||||
return ge.Master().DropTables(beans...)
|
||||
}
|
||||
|
||||
// DropIndexes drop indexes of a table
|
||||
func (ge *GroupEngine) DropIndexes(bean interface{}) error {
|
||||
return ge.Master().DropIndexes(bean)
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) Exec(sql string, args ...interface{}) (sql.Result, error) {
|
||||
return ge.Master().Exec(sql, args...)
|
||||
}
|
||||
|
||||
// Query a raw sql and return records as []map[string][]byte
|
||||
func (ge *GroupEngine) Query(sql string, paramStr ...interface{}) (resultsSlice []map[string][]byte, err error) {
|
||||
return ge.Slave().Query(sql, paramStr...)
|
||||
}
|
||||
|
||||
// QueryString runs a raw sql and return records as []map[string]string
|
||||
func (ge *GroupEngine) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) {
|
||||
return ge.Slave().QueryString(sqlStr, args...)
|
||||
}
|
||||
|
||||
// QueryInterface runs a raw sql and return records as []map[string]interface{}
|
||||
func (ge *GroupEngine) QueryInterface(sqlStr string, args ...interface{}) ([]map[string]interface{}, error) {
|
||||
return ge.Slave().QueryInterface(sqlStr, args...)
|
||||
}
|
||||
|
||||
// Insert one or more records
|
||||
func (ge *GroupEngine) Insert(beans ...interface{}) (int64, error) {
|
||||
return ge.Master().Insert(beans...)
|
||||
}
|
||||
|
||||
// InsertOne insert only one record
|
||||
func (ge *GroupEngine) InsertOne(bean interface{}) (int64, error) {
|
||||
return ge.Master().InsertOne(bean)
|
||||
}
|
||||
|
||||
// IsTableEmpty if a table has any reocrd
|
||||
func (ge *GroupEngine) IsTableEmpty(bean interface{}) (bool, error) {
|
||||
return ge.Master().IsTableEmpty(bean)
|
||||
}
|
||||
|
||||
// IsTableExist if a table is exist
|
||||
func (ge *GroupEngine) IsTableExist(beanOrTableName interface{}) (bool, error) {
|
||||
return ge.Master().IsTableExist(beanOrTableName)
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) Update(bean interface{}, condiBeans ...interface{}) (int64, error) {
|
||||
return ge.Master().Update(bean, condiBeans...)
|
||||
}
|
||||
|
||||
// Delete records, bean's non-empty fields are conditions
|
||||
func (ge *GroupEngine) Delete(bean interface{}) (int64, error) {
|
||||
return ge.Master().Delete(bean)
|
||||
}
|
||||
|
||||
// Get retrieve one record from table, bean's non-empty fields
|
||||
// are conditions
|
||||
func (ge *GroupEngine) Get(bean interface{}) (bool, error) {
|
||||
return ge.Slave().Get(bean)
|
||||
}
|
||||
|
||||
// Exist returns true if the record exist otherwise return false
|
||||
func (ge *GroupEngine) Exist(bean ...interface{}) (bool, error) {
|
||||
return ge.Slave().Exist(bean...)
|
||||
}
|
||||
|
||||
// Iterate record by record handle records from table, bean's non-empty fields
|
||||
// are conditions.
|
||||
func (ge *GroupEngine) Iterate(bean interface{}, fun IterFunc) error {
|
||||
return ge.Master().Iterate(bean, fun)
|
||||
}
|
||||
|
||||
func (ge *GroupEngine) Find(beans interface{}, condiBeans ...interface{}) error {
|
||||
return ge.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 (ge *GroupEngine) Rows(bean interface{}) (*Rows, error) {
|
||||
return ge.Slave().Rows(bean)
|
||||
}
|
||||
|
||||
// Count counts the records. bean's non-empty fields are conditions.
|
||||
func (ge *GroupEngine) Count(bean ...interface{}) (int64, error) {
|
||||
return ge.Slave().Count(bean...)
|
||||
}
|
||||
|
||||
// Sum sum the records by some column. bean's non-empty fields are conditions.
|
||||
func (ge *GroupEngine) Sum(bean interface{}, colName string) (float64, error) {
|
||||
return ge.Slave().Sum(bean, colName)
|
||||
}
|
||||
|
||||
// SumInt sum the records by some column. bean's non-empty fields are conditions.
|
||||
func (ge *GroupEngine) SumInt(bean interface{}, colName string) (int64, error) {
|
||||
return ge.Slave().SumInt(bean, colName)
|
||||
}
|
||||
|
||||
// Sums sum the records by some columns. bean's non-empty fields are conditions.
|
||||
func (ge *GroupEngine) Sums(bean interface{}, colNames ...string) ([]float64, error) {
|
||||
return ge.Slave().Sums(bean, colNames...)
|
||||
}
|
||||
|
||||
// SumsInt like Sums but return slice of int64 instead of float64.
|
||||
func (ge *GroupEngine) SumsInt(bean interface{}, colNames ...string) ([]int64, error) {
|
||||
return ge.Slave().SumsInt(bean, colNames...)
|
||||
}
|
||||
|
||||
// ImportFile SQL DDL file
|
||||
func (ge *GroupEngine) ImportFile(ddlPath string) ([]sql.Result, error) {
|
||||
return ge.Master().ImportFile(ddlPath)
|
||||
}
|
||||
|
||||
// Import SQL DDL from io.Reader
|
||||
func (ge *GroupEngine) Import(r io.Reader) ([]sql.Result, error) {
|
||||
return ge.Master().Import(r)
|
||||
}
|
||||
|
||||
// NowTime2 return current time
|
||||
func (ge *GroupEngine) NowTime2(sqlTypeName string) (interface{}, time.Time) {
|
||||
return ge.Master().NowTime2(sqlTypeName)
|
||||
}
|
||||
|
||||
// Unscoped always disable struct tag "deleted"
|
||||
func (ge *GroupEngine) Unscoped() *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.Unscoped()
|
||||
}
|
||||
|
||||
// CondDeleted returns the conditions whether a record is soft deleted.
|
||||
func (ge *GroupEngine) CondDeleted(colName string) builder.Cond {
|
||||
return ge.Master().CondDeleted(colName)
|
||||
}
|
||||
|
||||
type BufferSizeArgs struct {
|
||||
size int
|
||||
}
|
||||
|
||||
// BufferSize sets buffer size for iterate
|
||||
func (ge *GroupEngine) BufferSize(size int) *GESession {
|
||||
ges := ge.NewGESession()
|
||||
return ges.BufferSize(size)
|
||||
}
|
||||
|
|
@ -10,7 +10,7 @@ import "github.com/go-xorm/builder"
|
|||
// and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.
|
||||
//
|
||||
// Deprecated: use SQL instead.
|
||||
func (session *Session) Sql(query string, args ...interface{}) *Session {
|
||||
func (session *Session) Sql(query interface{}, args ...interface{}) *Session {
|
||||
return session.SQL(query, args...)
|
||||
}
|
||||
|
||||
|
|
|
|||
17
xorm.go
17
xorm.go
|
|
@ -9,6 +9,7 @@ import (
|
|||
"os"
|
||||
"reflect"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
|
|
@ -54,6 +55,22 @@ func init() {
|
|||
regDrvsNDialects()
|
||||
}
|
||||
|
||||
func NewGroupEngine(driverName string, dataSourceNames string) (*GroupEngine, 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
|
||||
}
|
||||
ge := &GroupEngine{
|
||||
engines: engines,
|
||||
}
|
||||
return ge, nil
|
||||
}
|
||||
|
||||
// NewEngine new a db manager according to the parameter. Currently support four
|
||||
// drivers
|
||||
func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue