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

hide all undocument variables on session (#660)

This commit is contained in:
Lunny Xiao 2017-07-27 13:32:35 +08:00 committed by GitHub
parent 7c2d924794
commit f1aebd5729
17 changed files with 536 additions and 538 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
engine.go
View File

@ -205,14 +205,14 @@ func (engine *Engine) SetDefaultCacher(cacher core.Cacher) {
// you can use NoCache() // you can use NoCache()
func (engine *Engine) NoCache() *Session { func (engine *Engine) NoCache() *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.NoCache() return session.NoCache()
} }
// NoCascade If you do not want to auto cascade load object // NoCascade If you do not want to auto cascade load object
func (engine *Engine) NoCascade() *Session { func (engine *Engine) NoCascade() *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.NoCascade() return session.NoCascade()
} }
@ -245,7 +245,7 @@ func (engine *Engine) Dialect() core.Dialect {
// NewSession New a session // NewSession New a session
func (engine *Engine) NewSession() *Session { func (engine *Engine) NewSession() *Session {
session := &Session{Engine: engine} session := &Session{engine: engine}
session.Init() session.Init()
return session return session
} }
@ -320,7 +320,7 @@ func (engine *Engine) Sql(querystring string, args ...interface{}) *Session {
// This code will execute "select * from user" and set the records to users // This code will execute "select * from user" and set the records to users
func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session { func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.SQL(query, args...) return session.SQL(query, args...)
} }
@ -329,14 +329,14 @@ func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session {
// invoked. Call NoAutoTime if you dont' want to fill automatically. // invoked. Call NoAutoTime if you dont' want to fill automatically.
func (engine *Engine) NoAutoTime() *Session { func (engine *Engine) NoAutoTime() *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.NoAutoTime() return session.NoAutoTime()
} }
// NoAutoCondition disable auto generate Where condition from bean or not // NoAutoCondition disable auto generate Where condition from bean or not
func (engine *Engine) NoAutoCondition(no ...bool) *Session { func (engine *Engine) NoAutoCondition(no ...bool) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.NoAutoCondition(no...) return session.NoAutoCondition(no...)
} }
@ -570,56 +570,56 @@ func (engine *Engine) tbName(v reflect.Value) string {
// Cascade use cascade or not // Cascade use cascade or not
func (engine *Engine) Cascade(trueOrFalse ...bool) *Session { func (engine *Engine) Cascade(trueOrFalse ...bool) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Cascade(trueOrFalse...) return session.Cascade(trueOrFalse...)
} }
// Where method provide a condition query // Where method provide a condition query
func (engine *Engine) Where(query interface{}, args ...interface{}) *Session { func (engine *Engine) Where(query interface{}, args ...interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Where(query, args...) return session.Where(query, args...)
} }
// Id will be depracated, please use ID instead // Id will be depracated, please use ID instead
func (engine *Engine) Id(id interface{}) *Session { func (engine *Engine) Id(id interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Id(id) return session.Id(id)
} }
// ID method provoide a condition as (id) = ? // ID method provoide a condition as (id) = ?
func (engine *Engine) ID(id interface{}) *Session { func (engine *Engine) ID(id interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.ID(id) return session.ID(id)
} }
// Before apply before Processor, affected bean is passed to closure arg // Before apply before Processor, affected bean is passed to closure arg
func (engine *Engine) Before(closures func(interface{})) *Session { func (engine *Engine) Before(closures func(interface{})) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Before(closures) return session.Before(closures)
} }
// After apply after insert Processor, affected bean is passed to closure arg // After apply after insert Processor, affected bean is passed to closure arg
func (engine *Engine) After(closures func(interface{})) *Session { func (engine *Engine) After(closures func(interface{})) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.After(closures) return session.After(closures)
} }
// Charset set charset when create table, only support mysql now // Charset set charset when create table, only support mysql now
func (engine *Engine) Charset(charset string) *Session { func (engine *Engine) Charset(charset string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Charset(charset) return session.Charset(charset)
} }
// StoreEngine set store engine when create table, only support mysql now // StoreEngine set store engine when create table, only support mysql now
func (engine *Engine) StoreEngine(storeEngine string) *Session { func (engine *Engine) StoreEngine(storeEngine string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.StoreEngine(storeEngine) return session.StoreEngine(storeEngine)
} }
@ -628,35 +628,35 @@ func (engine *Engine) StoreEngine(storeEngine string) *Session {
// but distinct will not provide id // but distinct will not provide id
func (engine *Engine) Distinct(columns ...string) *Session { func (engine *Engine) Distinct(columns ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Distinct(columns...) return session.Distinct(columns...)
} }
// Select customerize your select columns or contents // Select customerize your select columns or contents
func (engine *Engine) Select(str string) *Session { func (engine *Engine) Select(str string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Select(str) return session.Select(str)
} }
// Cols only use the parameters as select or update columns // Cols only use the parameters as select or update columns
func (engine *Engine) Cols(columns ...string) *Session { func (engine *Engine) Cols(columns ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Cols(columns...) return session.Cols(columns...)
} }
// AllCols indicates that all columns should be use // AllCols indicates that all columns should be use
func (engine *Engine) AllCols() *Session { func (engine *Engine) AllCols() *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.AllCols() return session.AllCols()
} }
// MustCols specify some columns must use even if they are empty // MustCols specify some columns must use even if they are empty
func (engine *Engine) MustCols(columns ...string) *Session { func (engine *Engine) MustCols(columns ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.MustCols(columns...) return session.MustCols(columns...)
} }
@ -667,77 +667,77 @@ func (engine *Engine) MustCols(columns ...string) *Session {
// it will use parameters's columns // it will use parameters's columns
func (engine *Engine) UseBool(columns ...string) *Session { func (engine *Engine) UseBool(columns ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.UseBool(columns...) return session.UseBool(columns...)
} }
// Omit only not use the parameters as select or update columns // Omit only not use the parameters as select or update columns
func (engine *Engine) Omit(columns ...string) *Session { func (engine *Engine) Omit(columns ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Omit(columns...) return session.Omit(columns...)
} }
// Nullable set null when column is zero-value and nullable for update // Nullable set null when column is zero-value and nullable for update
func (engine *Engine) Nullable(columns ...string) *Session { func (engine *Engine) Nullable(columns ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Nullable(columns...) return session.Nullable(columns...)
} }
// In will generate "column IN (?, ?)" // In will generate "column IN (?, ?)"
func (engine *Engine) In(column string, args ...interface{}) *Session { func (engine *Engine) In(column string, args ...interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.In(column, args...) return session.In(column, args...)
} }
// Incr provides a update string like "column = column + ?" // Incr provides a update string like "column = column + ?"
func (engine *Engine) Incr(column string, arg ...interface{}) *Session { func (engine *Engine) Incr(column string, arg ...interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Incr(column, arg...) return session.Incr(column, arg...)
} }
// Decr provides a update string like "column = column - ?" // Decr provides a update string like "column = column - ?"
func (engine *Engine) Decr(column string, arg ...interface{}) *Session { func (engine *Engine) Decr(column string, arg ...interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Decr(column, arg...) return session.Decr(column, arg...)
} }
// SetExpr provides a update string like "column = {expression}" // SetExpr provides a update string like "column = {expression}"
func (engine *Engine) SetExpr(column string, expression string) *Session { func (engine *Engine) SetExpr(column string, expression string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.SetExpr(column, expression) return session.SetExpr(column, expression)
} }
// Table temporarily change the Get, Find, Update's table // Table temporarily change the Get, Find, Update's table
func (engine *Engine) Table(tableNameOrBean interface{}) *Session { func (engine *Engine) Table(tableNameOrBean interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Table(tableNameOrBean) return session.Table(tableNameOrBean)
} }
// Alias set the table alias // Alias set the table alias
func (engine *Engine) Alias(alias string) *Session { func (engine *Engine) Alias(alias string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Alias(alias) return session.Alias(alias)
} }
// Limit will generate "LIMIT start, limit" // Limit will generate "LIMIT start, limit"
func (engine *Engine) Limit(limit int, start ...int) *Session { func (engine *Engine) Limit(limit int, start ...int) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Limit(limit, start...) return session.Limit(limit, start...)
} }
// Desc will generate "ORDER BY column1 DESC, column2 DESC" // Desc will generate "ORDER BY column1 DESC, column2 DESC"
func (engine *Engine) Desc(colNames ...string) *Session { func (engine *Engine) Desc(colNames ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Desc(colNames...) return session.Desc(colNames...)
} }
@ -749,35 +749,35 @@ func (engine *Engine) Desc(colNames ...string) *Session {
// //
func (engine *Engine) Asc(colNames ...string) *Session { func (engine *Engine) Asc(colNames ...string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Asc(colNames...) return session.Asc(colNames...)
} }
// OrderBy will generate "ORDER BY order" // OrderBy will generate "ORDER BY order"
func (engine *Engine) OrderBy(order string) *Session { func (engine *Engine) OrderBy(order string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.OrderBy(order) return session.OrderBy(order)
} }
// Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN // Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
func (engine *Engine) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session { func (engine *Engine) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Join(joinOperator, tablename, condition, args...) return session.Join(joinOperator, tablename, condition, args...)
} }
// GroupBy generate group by statement // GroupBy generate group by statement
func (engine *Engine) GroupBy(keys string) *Session { func (engine *Engine) GroupBy(keys string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.GroupBy(keys) return session.GroupBy(keys)
} }
// Having generate having statement // Having generate having statement
func (engine *Engine) Having(conditions string) *Session { func (engine *Engine) Having(conditions string) *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Having(conditions) return session.Having(conditions)
} }
@ -1251,7 +1251,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
if !isExist { if !isExist {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
err = session.addColumn(col.Name) err = session.addColumn(col.Name)
@ -1264,7 +1264,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
for name, index := range table.Indexes { for name, index := range table.Indexes {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
if index.Type == core.UniqueType { if index.Type == core.UniqueType {
@ -1275,7 +1275,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
if !isExist { if !isExist {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
@ -1292,7 +1292,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
if !isExist { if !isExist {
session := engine.NewSession() session := engine.NewSession()
defer session.Close() defer session.Close()
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
@ -1587,7 +1587,7 @@ func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}
// Unscoped always disable struct tag "deleted" // Unscoped always disable struct tag "deleted"
func (engine *Engine) Unscoped() *Session { func (engine *Engine) Unscoped() *Session {
session := engine.NewSession() session := engine.NewSession()
session.IsAutoClose = true session.isAutoClose = true
return session.Unscoped() return session.Unscoped()
} }

24
helpers.go
View File

@ -358,7 +358,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
for _, col := range table.Columns() { for _, col := range table.Columns() {
if useCol && !col.IsVersion && !col.IsCreated && !col.IsUpdated { if useCol && !col.IsVersion && !col.IsCreated && !col.IsUpdated {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
continue continue
} }
} }
@ -397,32 +397,32 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
continue continue
} }
if session.Statement.ColumnStr != "" { if session.statement.ColumnStr != "" {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
continue continue
} else if _, ok := session.Statement.incrColumns[col.Name]; ok { } else if _, ok := session.statement.incrColumns[col.Name]; ok {
continue continue
} else if _, ok := session.Statement.decrColumns[col.Name]; ok { } else if _, ok := session.statement.decrColumns[col.Name]; ok {
continue continue
} }
} }
if session.Statement.OmitStr != "" { if session.statement.OmitStr != "" {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
continue continue
} }
} }
// !evalphobia! set fieldValue as nil when column is nullable and zero-value // !evalphobia! set fieldValue as nil when column is nullable and zero-value
if _, ok := getFlagForColumn(session.Statement.nullableMap, col); ok { if _, ok := getFlagForColumn(session.statement.nullableMap, col); ok {
if col.Nullable && isZero(fieldValue.Interface()) { if col.Nullable && isZero(fieldValue.Interface()) {
var nilValue *int var nilValue *int
fieldValue = reflect.ValueOf(nilValue) fieldValue = reflect.ValueOf(nilValue)
} }
} }
if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ { if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
// if time is non-empty, then set to auto time // if time is non-empty, then set to auto time
val, t := session.Engine.NowTime2(col.SQLType.Name) val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val) args = append(args, val)
var colName = col.Name var colName = col.Name
@ -430,7 +430,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
} else if col.IsVersion && session.Statement.checkVersion { } else if col.IsVersion && session.statement.checkVersion {
args = append(args, 1) args = append(args, 1)
} else { } else {
arg, err := session.value2Interface(col, fieldValue) arg, err := session.value2Interface(col, fieldValue)
@ -441,7 +441,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
} }
if includeQuote { if includeQuote {
colNames = append(colNames, session.Engine.Quote(col.Name)+" = ?") colNames = append(colNames, session.engine.Quote(col.Name)+" = ?")
} else { } else {
colNames = append(colNames, col.Name) colNames = append(colNames, col.Name)
} }

22
rows.go
View File

@ -35,26 +35,26 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
var args []interface{} var args []interface{}
var err error var err error
if err = rows.session.Statement.setRefValue(rValue(bean)); err != nil { if err = rows.session.statement.setRefValue(rValue(bean)); err != nil {
return nil, err return nil, err
} }
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return nil, ErrTableNotFound return nil, ErrTableNotFound
} }
if rows.session.Statement.RawSQL == "" { if rows.session.statement.RawSQL == "" {
sqlStr, args, err = rows.session.Statement.genGetSQL(bean) sqlStr, args, err = rows.session.statement.genGetSQL(bean)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} else { } else {
sqlStr = rows.session.Statement.RawSQL sqlStr = rows.session.statement.RawSQL
args = rows.session.Statement.RawParams args = rows.session.statement.RawParams
} }
for _, filter := range rows.session.Engine.dialect.Filters() { for _, filter := range rows.session.engine.dialect.Filters() {
sqlStr = filter.Do(sqlStr, session.Engine.dialect, rows.session.Statement.RefTable) sqlStr = filter.Do(sqlStr, session.engine.dialect, rows.session.statement.RefTable)
} }
rows.session.saveLastSQL(sqlStr, args...) rows.session.saveLastSQL(sqlStr, args...)
@ -119,7 +119,7 @@ func (rows *Rows) Scan(bean interface{}) error {
} }
dataStruct := rValue(bean) dataStruct := rValue(bean)
if err := rows.session.Statement.setRefValue(dataStruct); err != nil { if err := rows.session.statement.setRefValue(dataStruct); err != nil {
return err return err
} }
@ -128,13 +128,13 @@ func (rows *Rows) Scan(bean interface{}) error {
return err return err
} }
_, err = rows.session.slice2Bean(scanResults, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.Statement.RefTable) _, err = rows.session.slice2Bean(scanResults, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.statement.RefTable)
return err return err
} }
// Close session if session.IsAutoClose is true, and claimed any opened resources // Close session if session.IsAutoClose is true, and claimed any opened resources
func (rows *Rows) Close() error { func (rows *Rows) Close() error {
if rows.session.IsAutoClose { if rows.session.isAutoClose {
defer rows.session.Close() defer rows.session.Close()
} }

120
session.go
View File

@ -21,16 +21,16 @@ import (
// kind of database operations. // kind of database operations.
type Session struct { type Session struct {
db *core.DB db *core.DB
Engine *Engine engine *Engine
Tx *core.Tx tx *core.Tx
Statement Statement statement Statement
IsAutoCommit bool isAutoCommit bool
IsCommitedOrRollbacked bool isCommitedOrRollbacked bool
IsAutoClose bool isAutoClose bool
// Automatically reset the statement after operations that execute a SQL // Automatically reset the statement after operations that execute a SQL
// query such as Count(), Find(), Get(), ... // query such as Count(), Find(), Get(), ...
AutoResetStatement bool autoResetStatement bool
// !nashtsai! storing these beans due to yet committed tx // !nashtsai! storing these beans due to yet committed tx
afterInsertBeans map[interface{}]*[]func(interface{}) afterInsertBeans map[interface{}]*[]func(interface{})
@ -60,12 +60,12 @@ func (session *Session) Clone() *Session {
// Init reset the session as the init status. // Init reset the session as the init status.
func (session *Session) Init() { func (session *Session) Init() {
session.Statement.Init() session.statement.Init()
session.Statement.Engine = session.Engine session.statement.Engine = session.engine
session.IsAutoCommit = true session.isAutoCommit = true
session.IsCommitedOrRollbacked = false session.isCommitedOrRollbacked = false
session.IsAutoClose = false session.isAutoClose = false
session.AutoResetStatement = true session.autoResetStatement = true
session.prepareStmt = false session.prepareStmt = false
// !nashtsai! is lazy init better? // !nashtsai! is lazy init better?
@ -88,10 +88,10 @@ func (session *Session) Close() {
if session.db != nil { if session.db != nil {
// When Close be called, if session is a transaction and do not call // When Close be called, if session is a transaction and do not call
// Commit or Rollback, then call Rollback. // Commit or Rollback, then call Rollback.
if session.Tx != nil && !session.IsCommitedOrRollbacked { if session.tx != nil && !session.isCommitedOrRollbacked {
session.Rollback() session.Rollback()
} }
session.Tx = nil session.tx = nil
session.stmtCache = nil session.stmtCache = nil
session.db = nil session.db = nil
} }
@ -103,8 +103,8 @@ func (session *Session) IsClosed() bool {
} }
func (session *Session) resetStatement() { func (session *Session) resetStatement() {
if session.AutoResetStatement { if session.autoResetStatement {
session.Statement.Init() session.statement.Init()
} }
} }
@ -132,75 +132,75 @@ func (session *Session) After(closures func(interface{})) *Session {
// Table can input a string or pointer to struct for special a table to operate. // Table can input a string or pointer to struct for special a table to operate.
func (session *Session) Table(tableNameOrBean interface{}) *Session { func (session *Session) Table(tableNameOrBean interface{}) *Session {
session.Statement.Table(tableNameOrBean) session.statement.Table(tableNameOrBean)
return session return session
} }
// Alias set the table alias // Alias set the table alias
func (session *Session) Alias(alias string) *Session { func (session *Session) Alias(alias string) *Session {
session.Statement.Alias(alias) session.statement.Alias(alias)
return session return session
} }
// NoCascade indicate that no cascade load child object // NoCascade indicate that no cascade load child object
func (session *Session) NoCascade() *Session { func (session *Session) NoCascade() *Session {
session.Statement.UseCascade = false session.statement.UseCascade = false
return session return session
} }
// ForUpdate Set Read/Write locking for UPDATE // ForUpdate Set Read/Write locking for UPDATE
func (session *Session) ForUpdate() *Session { func (session *Session) ForUpdate() *Session {
session.Statement.IsForUpdate = true session.statement.IsForUpdate = true
return session return session
} }
// NoAutoCondition disable generate SQL condition from beans // NoAutoCondition disable generate SQL condition from beans
func (session *Session) NoAutoCondition(no ...bool) *Session { func (session *Session) NoAutoCondition(no ...bool) *Session {
session.Statement.NoAutoCondition(no...) session.statement.NoAutoCondition(no...)
return session return session
} }
// Limit provide limit and offset query condition // Limit provide limit and offset query condition
func (session *Session) Limit(limit int, start ...int) *Session { func (session *Session) Limit(limit int, start ...int) *Session {
session.Statement.Limit(limit, start...) session.statement.Limit(limit, start...)
return session return session
} }
// OrderBy provide order by query condition, the input parameter is the content // OrderBy provide order by query condition, the input parameter is the content
// after order by on a sql statement. // after order by on a sql statement.
func (session *Session) OrderBy(order string) *Session { func (session *Session) OrderBy(order string) *Session {
session.Statement.OrderBy(order) session.statement.OrderBy(order)
return session return session
} }
// Desc provide desc order by query condition, the input parameters are columns. // Desc provide desc order by query condition, the input parameters are columns.
func (session *Session) Desc(colNames ...string) *Session { func (session *Session) Desc(colNames ...string) *Session {
session.Statement.Desc(colNames...) session.statement.Desc(colNames...)
return session return session
} }
// Asc provide asc order by query condition, the input parameters are columns. // Asc provide asc order by query condition, the input parameters are columns.
func (session *Session) Asc(colNames ...string) *Session { func (session *Session) Asc(colNames ...string) *Session {
session.Statement.Asc(colNames...) session.statement.Asc(colNames...)
return session return session
} }
// StoreEngine is only avialble mysql dialect currently // StoreEngine is only avialble mysql dialect currently
func (session *Session) StoreEngine(storeEngine string) *Session { func (session *Session) StoreEngine(storeEngine string) *Session {
session.Statement.StoreEngine = storeEngine session.statement.StoreEngine = storeEngine
return session return session
} }
// Charset is only avialble mysql dialect currently // Charset is only avialble mysql dialect currently
func (session *Session) Charset(charset string) *Session { func (session *Session) Charset(charset string) *Session {
session.Statement.Charset = charset session.statement.Charset = charset
return session return session
} }
// Cascade indicates if loading sub Struct // Cascade indicates if loading sub Struct
func (session *Session) Cascade(trueOrFalse ...bool) *Session { func (session *Session) Cascade(trueOrFalse ...bool) *Session {
if len(trueOrFalse) >= 1 { if len(trueOrFalse) >= 1 {
session.Statement.UseCascade = trueOrFalse[0] session.statement.UseCascade = trueOrFalse[0]
} }
return session return session
} }
@ -208,32 +208,32 @@ func (session *Session) Cascade(trueOrFalse ...bool) *Session {
// NoCache ask this session do not retrieve data from cache system and // NoCache ask this session do not retrieve data from cache system and
// get data from database directly. // get data from database directly.
func (session *Session) NoCache() *Session { func (session *Session) NoCache() *Session {
session.Statement.UseCache = false session.statement.UseCache = false
return session return session
} }
// Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN // Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
func (session *Session) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session { func (session *Session) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session {
session.Statement.Join(joinOperator, tablename, condition, args...) session.statement.Join(joinOperator, tablename, condition, args...)
return session return session
} }
// GroupBy Generate Group By statement // GroupBy Generate Group By statement
func (session *Session) GroupBy(keys string) *Session { func (session *Session) GroupBy(keys string) *Session {
session.Statement.GroupBy(keys) session.statement.GroupBy(keys)
return session return session
} }
// Having Generate Having statement // Having Generate Having statement
func (session *Session) Having(conditions string) *Session { func (session *Session) Having(conditions string) *Session {
session.Statement.Having(conditions) session.statement.Having(conditions)
return session return session
} }
// DB db return the wrapper of sql.DB // DB db return the wrapper of sql.DB
func (session *Session) DB() *core.DB { func (session *Session) DB() *core.DB {
if session.db == nil { if session.db == nil {
session.db = session.Engine.db session.db = session.engine.db
session.stmtCache = make(map[uint32]*core.Stmt, 0) session.stmtCache = make(map[uint32]*core.Stmt, 0)
} }
return session.db return session.db
@ -246,13 +246,13 @@ func cleanupProcessorsClosures(slices *[]func(interface{})) {
} }
func (session *Session) canCache() bool { func (session *Session) canCache() bool {
if session.Statement.RefTable == nil || if session.statement.RefTable == nil ||
session.Statement.JoinStr != "" || session.statement.JoinStr != "" ||
session.Statement.RawSQL != "" || session.statement.RawSQL != "" ||
!session.Statement.UseCache || !session.statement.UseCache ||
session.Statement.IsForUpdate || session.statement.IsForUpdate ||
session.Tx != nil || session.tx != nil ||
len(session.Statement.selectStr) > 0 { len(session.statement.selectStr) > 0 {
return false return false
} }
return true return true
@ -276,18 +276,18 @@ func (session *Session) doPrepare(sqlStr string) (stmt *core.Stmt, err error) {
func (session *Session) getField(dataStruct *reflect.Value, key string, table *core.Table, idx int) *reflect.Value { func (session *Session) getField(dataStruct *reflect.Value, key string, table *core.Table, idx int) *reflect.Value {
var col *core.Column var col *core.Column
if col = table.GetColumnIdx(key, idx); col == nil { if col = table.GetColumnIdx(key, idx); col == nil {
//session.Engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq()) //session.engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq())
return nil return nil
} }
fieldValue, err := col.ValueOfV(dataStruct) fieldValue, err := col.ValueOfV(dataStruct)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return nil return nil
} }
if !fieldValue.IsValid() || !fieldValue.CanSet() { if !fieldValue.IsValid() || !fieldValue.CanSet() {
session.Engine.logger.Warnf("table %v's column %v is not valid or cannot set", table.Name, key) session.engine.logger.Warnf("table %v's column %v is not valid or cannot set", table.Name, key)
return nil return nil
} }
return fieldValue return fieldValue
@ -532,7 +532,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
} }
case reflect.Struct: case reflect.Struct:
if fieldType.ConvertibleTo(core.TimeType) { if fieldType.ConvertibleTo(core.TimeType) {
dbTZ := session.Engine.DatabaseTZ dbTZ := session.engine.DatabaseTZ
if col.TimeZone != nil { if col.TimeZone != nil {
dbTZ = col.TimeZone dbTZ = col.TimeZone
} }
@ -545,25 +545,25 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
z, _ := t.Zone() z, _ := t.Zone()
// set new location if database don't save timezone or give an incorrect timezone // set new location if database don't save timezone or give an incorrect timezone
if len(z) == 0 || t.Year() == 0 || t.Location().String() != dbTZ.String() { // !nashtsai! HACK tmp work around for lib/pq doesn't properly time with location if len(z) == 0 || t.Year() == 0 || t.Location().String() != dbTZ.String() { // !nashtsai! HACK tmp work around for lib/pq doesn't properly time with location
session.Engine.logger.Debugf("empty zone key[%v] : %v | zone: %v | location: %+v\n", key, t, z, *t.Location()) session.engine.logger.Debugf("empty zone key[%v] : %v | zone: %v | location: %+v\n", key, t, z, *t.Location())
t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(),
t.Minute(), t.Second(), t.Nanosecond(), dbTZ) t.Minute(), t.Second(), t.Nanosecond(), dbTZ)
} }
t = t.In(session.Engine.TZLocation) t = t.In(session.engine.TZLocation)
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
} else if rawValueType == core.IntType || rawValueType == core.Int64Type || } else if rawValueType == core.IntType || rawValueType == core.Int64Type ||
rawValueType == core.Int32Type { rawValueType == core.Int32Type {
hasAssigned = true hasAssigned = true
t := time.Unix(vv.Int(), 0).In(session.Engine.TZLocation) t := time.Unix(vv.Int(), 0).In(session.engine.TZLocation)
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
} else { } else {
if d, ok := vv.Interface().([]uint8); ok { if d, ok := vv.Interface().([]uint8); ok {
hasAssigned = true hasAssigned = true
t, err := session.byte2Time(col, d) t, err := session.byte2Time(col, d)
if err != nil { if err != nil {
session.Engine.logger.Error("byte2Time error:", err.Error()) session.engine.logger.Error("byte2Time error:", err.Error())
hasAssigned = false hasAssigned = false
} else { } else {
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
@ -572,7 +572,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
hasAssigned = true hasAssigned = true
t, err := session.str2Time(col, d) t, err := session.str2Time(col, d)
if err != nil { if err != nil {
session.Engine.logger.Error("byte2Time error:", err.Error()) session.engine.logger.Error("byte2Time error:", err.Error())
hasAssigned = false hasAssigned = false
} else { } else {
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
@ -585,7 +585,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString // !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
hasAssigned = true hasAssigned = true
if err := nulVal.Scan(vv.Interface()); err != nil { if err := nulVal.Scan(vv.Interface()); err != nil {
session.Engine.logger.Error("sql.Sanner error:", err.Error()) session.engine.logger.Error("sql.Sanner error:", err.Error())
hasAssigned = false hasAssigned = false
} }
} else if col.SQLType.IsJson() { } else if col.SQLType.IsJson() {
@ -610,8 +610,8 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
} }
} }
} else if session.Statement.UseCascade { } else if session.statement.UseCascade {
table, err := session.Engine.autoMapType(*fieldValue) table, err := session.engine.autoMapType(*fieldValue)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -631,7 +631,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne // however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
// property to be fetched lazily // property to be fetched lazily
structInter := reflect.New(fieldValue.Type()) structInter := reflect.New(fieldValue.Type())
newsession := session.Engine.NewSession() newsession := session.engine.NewSession()
defer newsession.Close() defer newsession.Close()
has, err := newsession.ID(pk).NoCascade().Get(structInter.Interface()) has, err := newsession.ID(pk).NoCascade().Get(structInter.Interface())
if err != nil { if err != nil {
@ -778,8 +778,8 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
} }
func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) { func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) {
for _, filter := range session.Engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
*sqlStr = filter.Do(*sqlStr, session.Engine.dialect, session.Statement.RefTable) *sqlStr = filter.Do(*sqlStr, session.engine.dialect, session.statement.RefTable)
} }
session.saveLastSQL(*sqlStr, paramStr...) session.saveLastSQL(*sqlStr, paramStr...)
@ -789,7 +789,7 @@ func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{})
func (session *Session) saveLastSQL(sql string, args ...interface{}) { func (session *Session) saveLastSQL(sql string, args ...interface{}) {
session.lastSQL = sql session.lastSQL = sql
session.lastSQLArgs = args session.lastSQLArgs = args
session.Engine.logSQL(sql, args...) session.engine.logSQL(sql, args...)
} }
// LastSQL returns last query information // LastSQL returns last query information
@ -799,8 +799,8 @@ func (session *Session) LastSQL() (string, []interface{}) {
// tbName get some table's table name // tbName get some table's table name
func (session *Session) tbNameNoSchema(table *core.Table) string { func (session *Session) tbNameNoSchema(table *core.Table) string {
if len(session.Statement.AltTableName) > 0 { if len(session.statement.AltTableName) > 0 {
return session.Statement.AltTableName return session.statement.AltTableName
} }
return table.Name return table.Name
@ -808,6 +808,6 @@ func (session *Session) tbNameNoSchema(table *core.Table) string {
// Unscoped always disable struct tag "deleted" // Unscoped always disable struct tag "deleted"
func (session *Session) Unscoped() *Session { func (session *Session) Unscoped() *Session {
session.Statement.Unscoped() session.statement.Unscoped()
return session return session
} }

24
session_cols.go
View File

@ -6,43 +6,43 @@ package xorm
// Incr provides a query string like "count = count + 1" // Incr provides a query string like "count = count + 1"
func (session *Session) Incr(column string, arg ...interface{}) *Session { func (session *Session) Incr(column string, arg ...interface{}) *Session {
session.Statement.Incr(column, arg...) session.statement.Incr(column, arg...)
return session return session
} }
// Decr provides a query string like "count = count - 1" // Decr provides a query string like "count = count - 1"
func (session *Session) Decr(column string, arg ...interface{}) *Session { func (session *Session) Decr(column string, arg ...interface{}) *Session {
session.Statement.Decr(column, arg...) session.statement.Decr(column, arg...)
return session return session
} }
// SetExpr provides a query string like "column = {expression}" // SetExpr provides a query string like "column = {expression}"
func (session *Session) SetExpr(column string, expression string) *Session { func (session *Session) SetExpr(column string, expression string) *Session {
session.Statement.SetExpr(column, expression) session.statement.SetExpr(column, expression)
return session return session
} }
// Select provides some columns to special // Select provides some columns to special
func (session *Session) Select(str string) *Session { func (session *Session) Select(str string) *Session {
session.Statement.Select(str) session.statement.Select(str)
return session return session
} }
// Cols provides some columns to special // Cols provides some columns to special
func (session *Session) Cols(columns ...string) *Session { func (session *Session) Cols(columns ...string) *Session {
session.Statement.Cols(columns...) session.statement.Cols(columns...)
return session return session
} }
// AllCols ask all columns // AllCols ask all columns
func (session *Session) AllCols() *Session { func (session *Session) AllCols() *Session {
session.Statement.AllCols() session.statement.AllCols()
return session return session
} }
// MustCols specify some columns must use even if they are empty // MustCols specify some columns must use even if they are empty
func (session *Session) MustCols(columns ...string) *Session { func (session *Session) MustCols(columns ...string) *Session {
session.Statement.MustCols(columns...) session.statement.MustCols(columns...)
return session return session
} }
@ -52,7 +52,7 @@ func (session *Session) MustCols(columns ...string) *Session {
// If no parameters, it will use all the bool field of struct, or // If no parameters, it will use all the bool field of struct, or
// it will use parameters's columns // it will use parameters's columns
func (session *Session) UseBool(columns ...string) *Session { func (session *Session) UseBool(columns ...string) *Session {
session.Statement.UseBool(columns...) session.statement.UseBool(columns...)
return session return session
} }
@ -60,25 +60,25 @@ func (session *Session) UseBool(columns ...string) *Session {
// distinct will not be cached because cache system need id, // distinct will not be cached because cache system need id,
// but distinct will not provide id // but distinct will not provide id
func (session *Session) Distinct(columns ...string) *Session { func (session *Session) Distinct(columns ...string) *Session {
session.Statement.Distinct(columns...) session.statement.Distinct(columns...)
return session return session
} }
// Omit Only not use the parameters as select or update columns // Omit Only not use the parameters as select or update columns
func (session *Session) Omit(columns ...string) *Session { func (session *Session) Omit(columns ...string) *Session {
session.Statement.Omit(columns...) session.statement.Omit(columns...)
return session return session
} }
// Nullable Set null when column is zero-value and nullable for update // Nullable Set null when column is zero-value and nullable for update
func (session *Session) Nullable(columns ...string) *Session { func (session *Session) Nullable(columns ...string) *Session {
session.Statement.Nullable(columns...) session.statement.Nullable(columns...)
return session return session
} }
// NoAutoTime means do not automatically give created field and updated field // NoAutoTime means do not automatically give created field and updated field
// the current time on the current session temporarily // the current time on the current session temporarily
func (session *Session) NoAutoTime() *Session { func (session *Session) NoAutoTime() *Session {
session.Statement.UseAutoTime = false session.statement.UseAutoTime = false
return session return session
} }

16
session_cond.go
View File

@ -17,25 +17,25 @@ func (session *Session) Sql(query string, args ...interface{}) *Session {
// SQL provides raw sql input parameter. When you have a complex SQL statement // 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. // and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.
func (session *Session) SQL(query interface{}, args ...interface{}) *Session { func (session *Session) SQL(query interface{}, args ...interface{}) *Session {
session.Statement.SQL(query, args...) session.statement.SQL(query, args...)
return session return session
} }
// Where provides custom query condition. // Where provides custom query condition.
func (session *Session) Where(query interface{}, args ...interface{}) *Session { func (session *Session) Where(query interface{}, args ...interface{}) *Session {
session.Statement.Where(query, args...) session.statement.Where(query, args...)
return session return session
} }
// And provides custom query condition. // And provides custom query condition.
func (session *Session) And(query interface{}, args ...interface{}) *Session { func (session *Session) And(query interface{}, args ...interface{}) *Session {
session.Statement.And(query, args...) session.statement.And(query, args...)
return session return session
} }
// Or provides custom query condition. // Or provides custom query condition.
func (session *Session) Or(query interface{}, args ...interface{}) *Session { func (session *Session) Or(query interface{}, args ...interface{}) *Session {
session.Statement.Or(query, args...) session.statement.Or(query, args...)
return session return session
} }
@ -48,23 +48,23 @@ func (session *Session) Id(id interface{}) *Session {
// ID provides converting id as a query condition // ID provides converting id as a query condition
func (session *Session) ID(id interface{}) *Session { func (session *Session) ID(id interface{}) *Session {
session.Statement.ID(id) session.statement.ID(id)
return session return session
} }
// In provides a query string like "id in (1, 2, 3)" // In provides a query string like "id in (1, 2, 3)"
func (session *Session) In(column string, args ...interface{}) *Session { func (session *Session) In(column string, args ...interface{}) *Session {
session.Statement.In(column, args...) session.statement.In(column, args...)
return session return session
} }
// NotIn provides a query string like "id in (1, 2, 3)" // NotIn provides a query string like "id in (1, 2, 3)"
func (session *Session) NotIn(column string, args ...interface{}) *Session { func (session *Session) NotIn(column string, args ...interface{}) *Session {
session.Statement.NotIn(column, args...) session.statement.NotIn(column, args...)
return session return session
} }
// Conds returns session query conditions except auto bean conditions // Conds returns session query conditions except auto bean conditions
func (session *Session) Conds() builder.Cond { func (session *Session) Conds() builder.Cond {
return session.Statement.cond return session.statement.cond
} }

72
session_convert.go
View File

@ -23,7 +23,7 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
var x time.Time var x time.Time
var err error var err error
var parseLoc = session.Engine.DatabaseTZ var parseLoc = session.engine.DatabaseTZ
if col.TimeZone != nil { if col.TimeZone != nil {
parseLoc = col.TimeZone parseLoc = col.TimeZone
} }
@ -34,27 +34,27 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
sd, err := strconv.ParseInt(sdata, 10, 64) sd, err := strconv.ParseInt(sdata, 10, 64)
if err == nil { if err == nil {
x = time.Unix(sd, 0) x = time.Unix(sd, 0)
session.Engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else { } else {
session.Engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} }
} else if len(sdata) > 19 && strings.Contains(sdata, "-") { } else if len(sdata) > 19 && strings.Contains(sdata, "-") {
x, err = time.ParseInLocation(time.RFC3339Nano, sdata, parseLoc) x, err = time.ParseInLocation(time.RFC3339Nano, sdata, parseLoc)
session.Engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
if err != nil { if err != nil {
x, err = time.ParseInLocation("2006-01-02 15:04:05.999999999", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05.999999999", sdata, parseLoc)
session.Engine.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} }
if err != nil { if err != nil {
x, err = time.ParseInLocation("2006-01-02 15:04:05.9999999 Z07:00", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05.9999999 Z07:00", sdata, parseLoc)
session.Engine.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} }
} else if len(sdata) == 19 && strings.Contains(sdata, "-") { } else if len(sdata) == 19 && strings.Contains(sdata, "-") {
x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, parseLoc)
session.Engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else if len(sdata) == 10 && sdata[4] == '-' && sdata[7] == '-' { } else if len(sdata) == 10 && sdata[4] == '-' && sdata[7] == '-' {
x, err = time.ParseInLocation("2006-01-02", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02", sdata, parseLoc)
session.Engine.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else if col.SQLType.Name == core.Time { } else if col.SQLType.Name == core.Time {
if strings.Contains(sdata, " ") { if strings.Contains(sdata, " ") {
ssd := strings.Split(sdata, " ") ssd := strings.Split(sdata, " ")
@ -62,13 +62,13 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
} }
sdata = strings.TrimSpace(sdata) sdata = strings.TrimSpace(sdata)
if session.Engine.dialect.DBType() == core.MYSQL && len(sdata) > 8 { if session.engine.dialect.DBType() == core.MYSQL && len(sdata) > 8 {
sdata = sdata[len(sdata)-8:] sdata = sdata[len(sdata)-8:]
} }
st := fmt.Sprintf("2006-01-02 %v", sdata) st := fmt.Sprintf("2006-01-02 %v", sdata)
x, err = time.ParseInLocation("2006-01-02 15:04:05", st, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05", st, parseLoc)
session.Engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else { } else {
outErr = fmt.Errorf("unsupported time format %v", sdata) outErr = fmt.Errorf("unsupported time format %v", sdata)
return return
@ -77,7 +77,7 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
outErr = fmt.Errorf("unsupported time format %v: %v", sdata, err) outErr = fmt.Errorf("unsupported time format %v: %v", sdata, err)
return return
} }
outTime = x.In(session.Engine.TZLocation) outTime = x.In(session.engine.TZLocation)
return return
} }
@ -105,7 +105,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := json.Unmarshal(data, x.Interface()) err := json.Unmarshal(data, x.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return err return err
} }
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
@ -119,7 +119,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := json.Unmarshal(data, x.Interface()) err := json.Unmarshal(data, x.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return err return err
} }
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
@ -132,7 +132,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := json.Unmarshal(data, x.Interface()) err := json.Unmarshal(data, x.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return err return err
} }
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
@ -156,7 +156,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
var err error var err error
// for mysql, when use bit, it returned \x01 // for mysql, when use bit, it returned \x01
if col.SQLType.Name == core.Bit && if col.SQLType.Name == core.Bit &&
session.Engine.dialect.DBType() == core.MYSQL { // !nashtsai! TODO dialect needs to provide conversion interface API session.engine.dialect.DBType() == core.MYSQL { // !nashtsai! TODO dialect needs to provide conversion interface API
if len(data) == 1 { if len(data) == 1 {
x = int64(data[0]) x = int64(data[0])
} else { } else {
@ -204,8 +204,8 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
} }
v = x v = x
fieldValue.Set(reflect.ValueOf(v).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(v).Convert(fieldType))
} else if session.Statement.UseCascade { } else if session.statement.UseCascade {
table, err := session.Engine.autoMapType(*fieldValue) table, err := session.engine.autoMapType(*fieldValue)
if err != nil { if err != nil {
return err return err
} }
@ -227,7 +227,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne // however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
// property to be fetched lazily // property to be fetched lazily
structInter := reflect.New(fieldValue.Type()) structInter := reflect.New(fieldValue.Type())
newsession := session.Engine.NewSession() newsession := session.engine.NewSession()
defer newsession.Close() defer newsession.Close()
has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface()) has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
if err != nil { if err != nil {
@ -264,7 +264,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := json.Unmarshal(data, &x) err := json.Unmarshal(data, &x)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return err return err
} }
fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
@ -275,7 +275,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := json.Unmarshal(data, &x) err := json.Unmarshal(data, &x)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return err return err
} }
fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
@ -347,7 +347,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
var err error var err error
// for mysql, when use bit, it returned \x01 // for mysql, when use bit, it returned \x01
if col.SQLType.Name == core.Bit && if col.SQLType.Name == core.Bit &&
strings.Contains(session.Engine.DriverName(), "mysql") { strings.Contains(session.engine.DriverName(), "mysql") {
if len(data) == 1 { if len(data) == 1 {
x = int64(data[0]) x = int64(data[0])
} else { } else {
@ -372,7 +372,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
var err error var err error
// for mysql, when use bit, it returned \x01 // for mysql, when use bit, it returned \x01
if col.SQLType.Name == core.Bit && if col.SQLType.Name == core.Bit &&
strings.Contains(session.Engine.DriverName(), "mysql") { strings.Contains(session.engine.DriverName(), "mysql") {
if len(data) == 1 { if len(data) == 1 {
x = int(data[0]) x = int(data[0])
} else { } else {
@ -400,7 +400,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
var err error var err error
// for mysql, when use bit, it returned \x01 // for mysql, when use bit, it returned \x01
if col.SQLType.Name == core.Bit && if col.SQLType.Name == core.Bit &&
session.Engine.dialect.DBType() == core.MYSQL { session.engine.dialect.DBType() == core.MYSQL {
if len(data) == 1 { if len(data) == 1 {
x = int32(data[0]) x = int32(data[0])
} else { } else {
@ -428,7 +428,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
var err error var err error
// for mysql, when use bit, it returned \x01 // for mysql, when use bit, it returned \x01
if col.SQLType.Name == core.Bit && if col.SQLType.Name == core.Bit &&
strings.Contains(session.Engine.DriverName(), "mysql") { strings.Contains(session.engine.DriverName(), "mysql") {
if len(data) == 1 { if len(data) == 1 {
x = int8(data[0]) x = int8(data[0])
} else { } else {
@ -456,7 +456,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
var err error var err error
// for mysql, when use bit, it returned \x01 // for mysql, when use bit, it returned \x01
if col.SQLType.Name == core.Bit && if col.SQLType.Name == core.Bit &&
strings.Contains(session.Engine.DriverName(), "mysql") { strings.Contains(session.engine.DriverName(), "mysql") {
if len(data) == 1 { if len(data) == 1 {
x = int16(data[0]) x = int16(data[0])
} else { } else {
@ -488,9 +488,9 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
v = x v = x
fieldValue.Set(reflect.ValueOf(&x)) fieldValue.Set(reflect.ValueOf(&x))
default: default:
if session.Statement.UseCascade { if session.statement.UseCascade {
structInter := reflect.New(fieldType.Elem()) structInter := reflect.New(fieldType.Elem())
table, err := session.Engine.autoMapType(structInter.Elem()) table, err := session.engine.autoMapType(structInter.Elem())
if err != nil { if err != nil {
return err return err
} }
@ -510,7 +510,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
// !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch // !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch
// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne // however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
// property to be fetched lazily // property to be fetched lazily
newsession := session.Engine.NewSession() newsession := session.engine.NewSession()
defer newsession.Close() defer newsession.Close()
has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface()) has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
if err != nil { if err != nil {
@ -569,7 +569,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
if fieldValue.IsNil() { if fieldValue.IsNil() {
return nil, nil return nil, nil
} else if !fieldValue.IsValid() { } else if !fieldValue.IsValid() {
session.Engine.logger.Warn("the field[", col.FieldName, "] is invalid") session.engine.logger.Warn("the field[", col.FieldName, "] is invalid")
return nil, nil return nil, nil
} else { } else {
// !nashtsai! deference pointer type to instance type // !nashtsai! deference pointer type to instance type
@ -587,7 +587,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
case reflect.Struct: case reflect.Struct:
if fieldType.ConvertibleTo(core.TimeType) { if fieldType.ConvertibleTo(core.TimeType) {
t := fieldValue.Convert(core.TimeType).Interface().(time.Time) t := fieldValue.Convert(core.TimeType).Interface().(time.Time)
tf := session.Engine.formatColTime(col, t) tf := session.engine.formatColTime(col, t)
return tf, nil return tf, nil
} }
@ -597,7 +597,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
return v.Value() return v.Value()
} }
fieldTable, err := session.Engine.autoMapType(fieldValue) fieldTable, err := session.engine.autoMapType(fieldValue)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -611,14 +611,14 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
if col.SQLType.IsText() { if col.SQLType.IsText() {
bytes, err := json.Marshal(fieldValue.Interface()) bytes, err := json.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return 0, err return 0, err
} }
return string(bytes), nil return string(bytes), nil
} else if col.SQLType.IsBlob() { } else if col.SQLType.IsBlob() {
bytes, err := json.Marshal(fieldValue.Interface()) bytes, err := json.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return 0, err return 0, err
} }
return bytes, nil return bytes, nil
@ -627,7 +627,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
case reflect.Complex64, reflect.Complex128: case reflect.Complex64, reflect.Complex128:
bytes, err := json.Marshal(fieldValue.Interface()) bytes, err := json.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return 0, err return 0, err
} }
return string(bytes), nil return string(bytes), nil
@ -639,7 +639,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
if col.SQLType.IsText() { if col.SQLType.IsText() {
bytes, err := json.Marshal(fieldValue.Interface()) bytes, err := json.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return 0, err return 0, err
} }
return string(bytes), nil return string(bytes), nil
@ -652,7 +652,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
} else { } else {
bytes, err = json.Marshal(fieldValue.Interface()) bytes, err = json.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
return 0, err return 0, err
} }
} }

60
session_delete.go
View File

@ -13,22 +13,22 @@ import (
) )
func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error { func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
if session.Statement.RefTable == nil || if session.statement.RefTable == nil ||
session.Tx != nil { session.tx != nil {
return ErrCacheFailed return ErrCacheFailed
} }
for _, filter := range session.Engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable) sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
} }
newsql := session.Statement.convertIDSQL(sqlStr) newsql := session.statement.convertIDSQL(sqlStr)
if newsql == "" { if newsql == "" {
return ErrCacheFailed return ErrCacheFailed
} }
cacher := session.Engine.getCacher2(session.Statement.RefTable) cacher := session.engine.getCacher2(session.statement.RefTable)
tableName := session.Statement.TableName() tableName := session.statement.TableName()
ids, err := core.GetCacheSql(cacher, tableName, newsql, args) ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
if err != nil { if err != nil {
resultsSlice, err := session.query(newsql, args...) resultsSlice, err := session.query(newsql, args...)
@ -40,7 +40,7 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
for _, data := range resultsSlice { for _, data := range resultsSlice {
var id int64 var id int64
var pk core.PK = make([]interface{}, 0) var pk core.PK = make([]interface{}, 0)
for _, col := range session.Statement.RefTable.PKColumns() { for _, col := range session.statement.RefTable.PKColumns() {
if v, ok := data[col.Name]; !ok { if v, ok := data[col.Name]; !ok {
return errors.New("no id") return errors.New("no id")
} else if col.SQLType.IsText() { } else if col.SQLType.IsText() {
@ -59,19 +59,19 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
} }
} }
} /*else { } /*else {
session.Engine.LogDebug("delete cache sql %v", newsql) session.engine.LogDebug("delete cache sql %v", newsql)
cacher.DelIds(tableName, genSqlKey(newsql, args)) cacher.DelIds(tableName, genSqlKey(newsql, args))
}*/ }*/
for _, id := range ids { for _, id := range ids {
session.Engine.logger.Debug("[cacheDelete] delete cache obj", tableName, id) session.engine.logger.Debug("[cacheDelete] delete cache obj", tableName, id)
sid, err := id.ToString() sid, err := id.ToString()
if err != nil { if err != nil {
return err return err
} }
cacher.DelBean(tableName, sid) cacher.DelBean(tableName, sid)
} }
session.Engine.logger.Debug("[cacheDelete] clear cache sql", tableName) session.engine.logger.Debug("[cacheDelete] clear cache sql", tableName)
cacher.ClearIds(tableName) cacher.ClearIds(tableName)
return nil return nil
} }
@ -79,14 +79,14 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
// Delete records, bean's non-empty fields are conditions // Delete records, bean's non-empty fields are conditions
func (session *Session) Delete(bean interface{}) (int64, error) { func (session *Session) Delete(bean interface{}) (int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
if err := session.Statement.setRefValue(rValue(bean)); err != nil { if err := session.statement.setRefValue(rValue(bean)); err != nil {
return 0, err return 0, err
} }
var table = session.Statement.RefTable var table = session.statement.RefTable
// handle before delete processors // handle before delete processors
for _, closure := range session.beforeClosures { for _, closure := range session.beforeClosures {
@ -98,15 +98,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
processor.BeforeDelete() processor.BeforeDelete()
} }
condSQL, condArgs, err := session.Statement.genConds(bean) condSQL, condArgs, err := session.statement.genConds(bean)
if err != nil { if err != nil {
return 0, err return 0, err
} }
if len(condSQL) == 0 && session.Statement.LimitN == 0 { if len(condSQL) == 0 && session.statement.LimitN == 0 {
return 0, ErrNeedDeletedCond return 0, ErrNeedDeletedCond
} }
var tableName = session.Engine.Quote(session.Statement.TableName()) var tableName = session.engine.Quote(session.statement.TableName())
var deleteSQL string var deleteSQL string
if len(condSQL) > 0 { if len(condSQL) > 0 {
deleteSQL = fmt.Sprintf("DELETE FROM %v WHERE %v", tableName, condSQL) deleteSQL = fmt.Sprintf("DELETE FROM %v WHERE %v", tableName, condSQL)
@ -115,15 +115,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
} }
var orderSQL string var orderSQL string
if len(session.Statement.OrderStr) > 0 { if len(session.statement.OrderStr) > 0 {
orderSQL += fmt.Sprintf(" ORDER BY %s", session.Statement.OrderStr) orderSQL += fmt.Sprintf(" ORDER BY %s", session.statement.OrderStr)
} }
if session.Statement.LimitN > 0 { if session.statement.LimitN > 0 {
orderSQL += fmt.Sprintf(" LIMIT %d", session.Statement.LimitN) orderSQL += fmt.Sprintf(" LIMIT %d", session.statement.LimitN)
} }
if len(orderSQL) > 0 { if len(orderSQL) > 0 {
switch session.Engine.dialect.DBType() { switch session.engine.dialect.DBType() {
case core.POSTGRES: case core.POSTGRES:
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL) inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 { if len(condSQL) > 0 {
@ -148,7 +148,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
var realSQL string var realSQL string
argsForCache := make([]interface{}, 0, len(condArgs)*2) argsForCache := make([]interface{}, 0, len(condArgs)*2)
if session.Statement.unscoped || table.DeletedColumn() == nil { // tag "deleted" is disabled if session.statement.unscoped || table.DeletedColumn() == nil { // tag "deleted" is disabled
realSQL = deleteSQL realSQL = deleteSQL
copy(argsForCache, condArgs) copy(argsForCache, condArgs)
argsForCache = append(condArgs, argsForCache...) argsForCache = append(condArgs, argsForCache...)
@ -159,12 +159,12 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
deletedColumn := table.DeletedColumn() deletedColumn := table.DeletedColumn()
realSQL = fmt.Sprintf("UPDATE %v SET %v = ? WHERE %v", realSQL = fmt.Sprintf("UPDATE %v SET %v = ? WHERE %v",
session.Engine.Quote(session.Statement.TableName()), session.engine.Quote(session.statement.TableName()),
session.Engine.Quote(deletedColumn.Name), session.engine.Quote(deletedColumn.Name),
condSQL) condSQL)
if len(orderSQL) > 0 { if len(orderSQL) > 0 {
switch session.Engine.dialect.DBType() { switch session.engine.dialect.DBType() {
case core.POSTGRES: case core.POSTGRES:
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL) inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 { if len(condSQL) > 0 {
@ -187,12 +187,12 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
} }
} }
// !oinume! Insert NowTime to the head of session.Statement.Params // !oinume! Insert NowTime to the head of session.statement.Params
condArgs = append(condArgs, "") condArgs = append(condArgs, "")
paramsLen := len(condArgs) paramsLen := len(condArgs)
copy(condArgs[1:paramsLen], condArgs[0:paramsLen-1]) copy(condArgs[1:paramsLen], condArgs[0:paramsLen-1])
val, t := session.Engine.NowTime2(deletedColumn.SQLType.Name) val, t := session.engine.NowTime2(deletedColumn.SQLType.Name)
condArgs[0] = val condArgs[0] = val
var colName = deletedColumn.Name var colName = deletedColumn.Name
@ -202,7 +202,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
}) })
} }
if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil && session.Statement.UseCache { if cacher := session.engine.getCacher2(session.statement.RefTable); cacher != nil && session.statement.UseCache {
session.cacheDelete(deleteSQL, argsForCache...) session.cacheDelete(deleteSQL, argsForCache...)
} }
@ -212,7 +212,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
} }
// handle after delete processors // handle after delete processors
if session.IsAutoCommit { if session.isAutoCommit {
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(bean) closure(bean)
} }

26
session_exist.go
View File

@ -16,7 +16,7 @@ import (
// Exist returns true if the record exist otherwise return false // Exist returns true if the record exist otherwise return false
func (session *Session) Exist(bean ...interface{}) (bool, error) { func (session *Session) Exist(bean ...interface{}) (bool, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -24,15 +24,15 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
var args []interface{} var args []interface{}
var err error var err error
if session.Statement.RawSQL == "" { if session.statement.RawSQL == "" {
if len(bean) == 0 { if len(bean) == 0 {
tableName := session.Statement.TableName() tableName := session.statement.TableName()
if len(tableName) <= 0 { if len(tableName) <= 0 {
return false, ErrTableNotFound return false, ErrTableNotFound
} }
if session.Statement.cond.IsValid() { if session.statement.cond.IsValid() {
condSQL, condArgs, err := builder.ToSQL(session.Statement.cond) condSQL, condArgs, err := builder.ToSQL(session.statement.cond)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -50,32 +50,32 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
} }
if beanValue.Elem().Kind() == reflect.Struct { if beanValue.Elem().Kind() == reflect.Struct {
if err := session.Statement.setRefValue(beanValue.Elem()); err != nil { if err := session.statement.setRefValue(beanValue.Elem()); err != nil {
return false, err return false, err
} }
} }
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return false, ErrTableNotFound return false, ErrTableNotFound
} }
session.Statement.Limit(1) session.statement.Limit(1)
sqlStr, args, err = session.Statement.genGetSQL(bean[0]) sqlStr, args, err = session.statement.genGetSQL(bean[0])
if err != nil { if err != nil {
return false, err return false, err
} }
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
var rawRows *core.Rows var rawRows *core.Rows
if session.IsAutoCommit { if session.isAutoCommit {
_, rawRows, err = session.innerQuery(sqlStr, args...) _, rawRows, err = session.innerQuery(sqlStr, args...)
} else { } else {
rawRows, err = session.Tx.Query(sqlStr, args...) rawRows, err = session.tx.Query(sqlStr, args...)
} }
if err != nil { if err != nil {
return false, err return false, err

112
session_find.go
View File

@ -24,7 +24,7 @@ const (
// map[int64]*Struct // map[int64]*Struct
func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error { func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -36,11 +36,11 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
sliceElementType := sliceValue.Type().Elem() sliceElementType := sliceValue.Type().Elem()
var tp = tpStruct var tp = tpStruct
if session.Statement.RefTable == nil { if session.statement.RefTable == nil {
if sliceElementType.Kind() == reflect.Ptr { if sliceElementType.Kind() == reflect.Ptr {
if sliceElementType.Elem().Kind() == reflect.Struct { if sliceElementType.Elem().Kind() == reflect.Struct {
pv := reflect.New(sliceElementType.Elem()) pv := reflect.New(sliceElementType.Elem())
if err := session.Statement.setRefValue(pv.Elem()); err != nil { if err := session.statement.setRefValue(pv.Elem()); err != nil {
return err return err
} }
} else { } else {
@ -48,7 +48,7 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
} }
} else if sliceElementType.Kind() == reflect.Struct { } else if sliceElementType.Kind() == reflect.Struct {
pv := reflect.New(sliceElementType) pv := reflect.New(sliceElementType)
if err := session.Statement.setRefValue(pv.Elem()); err != nil { if err := session.statement.setRefValue(pv.Elem()); err != nil {
return err return err
} }
} else { } else {
@ -56,31 +56,31 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
} }
} }
var table = session.Statement.RefTable var table = session.statement.RefTable
var addedTableName = (len(session.Statement.JoinStr) > 0) var addedTableName = (len(session.statement.JoinStr) > 0)
var autoCond builder.Cond var autoCond builder.Cond
if tp == tpStruct { if tp == tpStruct {
if !session.Statement.noAutoCondition && len(condiBean) > 0 { if !session.statement.noAutoCondition && len(condiBean) > 0 {
var err error var err error
autoCond, err = session.Statement.buildConds(table, condiBean[0], true, true, false, true, addedTableName) autoCond, err = session.statement.buildConds(table, condiBean[0], true, true, false, true, addedTableName)
if err != nil { if err != nil {
return err return err
} }
} else { } else {
// !oinume! Add "<col> IS NULL" to WHERE whatever condiBean is given. // !oinume! Add "<col> IS NULL" to WHERE whatever condiBean is given.
// See https://github.com/go-xorm/xorm/issues/179 // See https://github.com/go-xorm/xorm/issues/179
if col := table.DeletedColumn(); col != nil && !session.Statement.unscoped { // tag "deleted" is enabled if col := table.DeletedColumn(); col != nil && !session.statement.unscoped { // tag "deleted" is enabled
var colName = session.Engine.Quote(col.Name) var colName = session.engine.Quote(col.Name)
if addedTableName { if addedTableName {
var nm = session.Statement.TableName() var nm = session.statement.TableName()
if len(session.Statement.TableAlias) > 0 { if len(session.statement.TableAlias) > 0 {
nm = session.Statement.TableAlias nm = session.statement.TableAlias
} }
colName = session.Engine.Quote(nm) + "." + colName colName = session.engine.Quote(nm) + "." + colName
} }
autoCond = session.Engine.CondDeleted(colName) autoCond = session.engine.CondDeleted(colName)
} }
} }
} }
@ -88,27 +88,27 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
var sqlStr string var sqlStr string
var args []interface{} var args []interface{}
var err error var err error
if session.Statement.RawSQL == "" { if session.statement.RawSQL == "" {
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return ErrTableNotFound return ErrTableNotFound
} }
var columnStr = session.Statement.ColumnStr var columnStr = session.statement.ColumnStr
if len(session.Statement.selectStr) > 0 { if len(session.statement.selectStr) > 0 {
columnStr = session.Statement.selectStr columnStr = session.statement.selectStr
} else { } else {
if session.Statement.JoinStr == "" { if session.statement.JoinStr == "" {
if columnStr == "" { if columnStr == "" {
if session.Statement.GroupByStr != "" { if session.statement.GroupByStr != "" {
columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1)) columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
} else { } else {
columnStr = session.Statement.genColumnStr() columnStr = session.statement.genColumnStr()
} }
} }
} else { } else {
if columnStr == "" { if columnStr == "" {
if session.Statement.GroupByStr != "" { if session.statement.GroupByStr != "" {
columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1)) columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
} else { } else {
columnStr = "*" columnStr = "*"
} }
@ -119,14 +119,14 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
} }
} }
session.Statement.cond = session.Statement.cond.And(autoCond) session.statement.cond = session.statement.cond.And(autoCond)
condSQL, condArgs, err := builder.ToSQL(session.Statement.cond) condSQL, condArgs, err := builder.ToSQL(session.statement.cond)
if err != nil { if err != nil {
return err return err
} }
args = append(session.Statement.joinArgs, condArgs...) args = append(session.statement.joinArgs, condArgs...)
sqlStr, err = session.Statement.genSelectSQL(columnStr, condSQL) sqlStr, err = session.statement.genSelectSQL(columnStr, condSQL)
if err != nil { if err != nil {
return err return err
} }
@ -136,20 +136,20 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
args = append(args, args...) args = append(args, args...)
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
if session.canCache() { if session.canCache() {
if cacher := session.Engine.getCacher2(table); cacher != nil && if cacher := session.engine.getCacher2(table); cacher != nil &&
!session.Statement.IsDistinct && !session.statement.IsDistinct &&
!session.Statement.unscoped { !session.statement.unscoped {
err = session.cacheFind(sliceElementType, sqlStr, rowsSlicePtr, args...) err = session.cacheFind(sliceElementType, sqlStr, rowsSlicePtr, args...)
if err != ErrCacheFailed { if err != ErrCacheFailed {
return err return err
} }
err = nil // !nashtsai! reset err to nil for ErrCacheFailed err = nil // !nashtsai! reset err to nil for ErrCacheFailed
session.Engine.logger.Warn("Cache Find Failed") session.engine.logger.Warn("Cache Find Failed")
} }
} }
@ -161,10 +161,10 @@ func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Va
var err error var err error
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
if session.IsAutoCommit { if session.isAutoCommit {
_, rawRows, err = session.innerQuery(sqlStr, args...) _, rawRows, err = session.innerQuery(sqlStr, args...)
} else { } else {
rawRows, err = session.Tx.Query(sqlStr, args...) rawRows, err = session.tx.Query(sqlStr, args...)
} }
if err != nil { if err != nil {
return err return err
@ -241,7 +241,7 @@ func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Va
if elemType.Kind() == reflect.Struct { if elemType.Kind() == reflect.Struct {
var newValue = newElemFunc(fields) var newValue = newElemFunc(fields)
dataStruct := rValue(newValue.Interface()) dataStruct := rValue(newValue.Interface())
tb, err := session.Engine.autoMapType(dataStruct) tb, err := session.engine.autoMapType(dataStruct)
if err != nil { if err != nil {
return err return err
} }
@ -289,19 +289,19 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
return ErrCacheFailed return ErrCacheFailed
} }
for _, filter := range session.Engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable) sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
} }
newsql := session.Statement.convertIDSQL(sqlStr) newsql := session.statement.convertIDSQL(sqlStr)
if newsql == "" { if newsql == "" {
return ErrCacheFailed return ErrCacheFailed
} }
tableName := session.Statement.TableName() tableName := session.statement.TableName()
table := session.Statement.RefTable table := session.statement.RefTable
cacher := session.Engine.getCacher2(table) cacher := session.engine.getCacher2(table)
ids, err := core.GetCacheSql(cacher, tableName, newsql, args) ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
if err != nil { if err != nil {
rows, err := session.DB().Query(newsql, args...) rows, err := session.DB().Query(newsql, args...)
@ -315,7 +315,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
for rows.Next() { for rows.Next() {
i++ i++
if i > 500 { if i > 500 {
session.Engine.logger.Debug("[cacheFind] ids length > 500, no cache") session.engine.logger.Debug("[cacheFind] ids length > 500, no cache")
return ErrCacheFailed return ErrCacheFailed
} }
var res = make([]string, len(table.PrimaryKeys)) var res = make([]string, len(table.PrimaryKeys))
@ -325,7 +325,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
} }
var pk core.PK = make([]interface{}, len(table.PrimaryKeys)) var pk core.PK = make([]interface{}, len(table.PrimaryKeys))
for i, col := range table.PKColumns() { for i, col := range table.PKColumns() {
pk[i], err = session.Engine.idTypeAssertion(col, res[i]) pk[i], err = session.engine.idTypeAssertion(col, res[i])
if err != nil { if err != nil {
return err return err
} }
@ -334,13 +334,13 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
ids = append(ids, pk) ids = append(ids, pk)
} }
session.Engine.logger.Debug("[cacheFind] cache sql:", ids, tableName, newsql, args) session.engine.logger.Debug("[cacheFind] cache sql:", ids, tableName, newsql, args)
err = core.PutCacheSql(cacher, ids, tableName, newsql, args) err = core.PutCacheSql(cacher, ids, tableName, newsql, args)
if err != nil { if err != nil {
return err return err
} }
} else { } else {
session.Engine.logger.Debug("[cacheFind] cache hit sql:", newsql, args) session.engine.logger.Debug("[cacheFind] cache hit sql:", newsql, args)
} }
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr)) sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
@ -359,16 +359,16 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
ides = append(ides, id) ides = append(ides, id)
ididxes[sid] = idx ididxes[sid] = idx
} else { } else {
session.Engine.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean) session.engine.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean)
pk := session.Engine.IdOf(bean) pk := session.engine.IdOf(bean)
xid, err := pk.ToString() xid, err := pk.ToString()
if err != nil { if err != nil {
return err return err
} }
if sid != xid { if sid != xid {
session.Engine.logger.Error("[cacheFind] error cache", xid, sid, bean) session.engine.logger.Error("[cacheFind] error cache", xid, sid, bean)
return ErrCacheFailed return ErrCacheFailed
} }
temps[idx] = bean temps[idx] = bean
@ -376,7 +376,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
} }
if len(ides) > 0 { if len(ides) > 0 {
newSession := session.Engine.NewSession() newSession := session.engine.NewSession()
defer newSession.Close() defer newSession.Close()
slices := reflect.New(reflect.SliceOf(t)) slices := reflect.New(reflect.SliceOf(t))
@ -410,7 +410,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
if rv.Kind() != reflect.Ptr { if rv.Kind() != reflect.Ptr {
rv = rv.Addr() rv = rv.Addr()
} }
id, err := session.Engine.idOfV(rv) id, err := session.engine.idOfV(rv)
if err != nil { if err != nil {
return err return err
} }
@ -421,7 +421,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
bean := rv.Interface() bean := rv.Interface()
temps[ididxes[sid]] = bean temps[ididxes[sid]] = bean
session.Engine.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps) session.engine.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps)
cacher.PutBean(tableName, sid, bean) cacher.PutBean(tableName, sid, bean)
} }
} }
@ -429,7 +429,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
for j := 0; j < len(temps); j++ { for j := 0; j < len(temps); j++ {
bean := temps[j] bean := temps[j]
if bean == nil { if bean == nil {
session.Engine.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps) session.engine.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps)
// return errors.New("cache error") // !nashtsai! no need to return error, but continue instead // return errors.New("cache error") // !nashtsai! no need to return error, but continue instead
continue continue
} }

52
session_get.go
View File

@ -16,7 +16,7 @@ import (
// will be as conditions // will be as conditions
func (session *Session) Get(bean interface{}) (bool, error) { func (session *Session) Get(bean interface{}) (bool, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -26,7 +26,7 @@ func (session *Session) Get(bean interface{}) (bool, error) {
} }
if beanValue.Elem().Kind() == reflect.Struct { if beanValue.Elem().Kind() == reflect.Struct {
if err := session.Statement.setRefValue(beanValue.Elem()); err != nil { if err := session.statement.setRefValue(beanValue.Elem()); err != nil {
return false, err return false, err
} }
} }
@ -35,23 +35,23 @@ func (session *Session) Get(bean interface{}) (bool, error) {
var args []interface{} var args []interface{}
var err error var err error
if session.Statement.RawSQL == "" { if session.statement.RawSQL == "" {
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return false, ErrTableNotFound return false, ErrTableNotFound
} }
session.Statement.Limit(1) session.statement.Limit(1)
sqlStr, args, err = session.Statement.genGetSQL(bean) sqlStr, args, err = session.statement.genGetSQL(bean)
if err != nil { if err != nil {
return false, err return false, err
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
if session.canCache() && beanValue.Elem().Kind() == reflect.Struct { if session.canCache() && beanValue.Elem().Kind() == reflect.Struct {
if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil && if cacher := session.engine.getCacher2(session.statement.RefTable); cacher != nil &&
!session.Statement.unscoped { !session.statement.unscoped {
has, err := session.cacheGet(bean, sqlStr, args...) has, err := session.cacheGet(bean, sqlStr, args...)
if err != ErrCacheFailed { if err != ErrCacheFailed {
return has, err return has, err
@ -67,10 +67,10 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
var rawRows *core.Rows var rawRows *core.Rows
var err error var err error
if session.IsAutoCommit { if session.isAutoCommit {
_, rawRows, err = session.innerQuery(sqlStr, args...) _, rawRows, err = session.innerQuery(sqlStr, args...)
} else { } else {
rawRows, err = session.Tx.Query(sqlStr, args...) rawRows, err = session.tx.Query(sqlStr, args...)
} }
if err != nil { if err != nil {
return false, err return false, err
@ -90,7 +90,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
return true, err return true, err
} }
dataStruct := rValue(bean) dataStruct := rValue(bean)
if err := session.Statement.setRefValue(dataStruct); err != nil { if err := session.statement.setRefValue(dataStruct); err != nil {
return false, err return false, err
} }
@ -100,7 +100,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
} }
rawRows.Close() rawRows.Close()
_, err = session.slice2Bean(scanResults, fields, len(fields), bean, &dataStruct, session.Statement.RefTable) _, err = session.slice2Bean(scanResults, fields, len(fields), bean, &dataStruct, session.statement.RefTable)
case reflect.Slice: case reflect.Slice:
err = rawRows.ScanSlice(bean) err = rawRows.ScanSlice(bean)
case reflect.Map: case reflect.Map:
@ -118,19 +118,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
return false, ErrCacheFailed return false, ErrCacheFailed
} }
for _, filter := range session.Engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable) sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
} }
newsql := session.Statement.convertIDSQL(sqlStr) newsql := session.statement.convertIDSQL(sqlStr)
if newsql == "" { if newsql == "" {
return false, ErrCacheFailed return false, ErrCacheFailed
} }
cacher := session.Engine.getCacher2(session.Statement.RefTable) cacher := session.engine.getCacher2(session.statement.RefTable)
tableName := session.Statement.TableName() tableName := session.statement.TableName()
session.Engine.logger.Debug("[cacheGet] find sql:", newsql, args) session.engine.logger.Debug("[cacheGet] find sql:", newsql, args)
ids, err := core.GetCacheSql(cacher, tableName, newsql, args) ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
table := session.Statement.RefTable table := session.statement.RefTable
if err != nil { if err != nil {
var res = make([]string, len(table.PrimaryKeys)) var res = make([]string, len(table.PrimaryKeys))
rows, err := session.DB().Query(newsql, args...) rows, err := session.DB().Query(newsql, args...)
@ -164,19 +164,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
} }
ids = []core.PK{pk} ids = []core.PK{pk}
session.Engine.logger.Debug("[cacheGet] cache ids:", newsql, ids) session.engine.logger.Debug("[cacheGet] cache ids:", newsql, ids)
err = core.PutCacheSql(cacher, ids, tableName, newsql, args) err = core.PutCacheSql(cacher, ids, tableName, newsql, args)
if err != nil { if err != nil {
return false, err return false, err
} }
} else { } else {
session.Engine.logger.Debug("[cacheGet] cache hit sql:", newsql) session.engine.logger.Debug("[cacheGet] cache hit sql:", newsql)
} }
if len(ids) > 0 { if len(ids) > 0 {
structValue := reflect.Indirect(reflect.ValueOf(bean)) structValue := reflect.Indirect(reflect.ValueOf(bean))
id := ids[0] id := ids[0]
session.Engine.logger.Debug("[cacheGet] get bean:", tableName, id) session.engine.logger.Debug("[cacheGet] get bean:", tableName, id)
sid, err := id.ToString() sid, err := id.ToString()
if err != nil { if err != nil {
return false, err return false, err
@ -189,10 +189,10 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
return has, err return has, err
} }
session.Engine.logger.Debug("[cacheGet] cache bean:", tableName, id, cacheBean) session.engine.logger.Debug("[cacheGet] cache bean:", tableName, id, cacheBean)
cacher.PutBean(tableName, sid, cacheBean) cacher.PutBean(tableName, sid, cacheBean)
} else { } else {
session.Engine.logger.Debug("[cacheGet] cache hit bean:", tableName, id, cacheBean) session.engine.logger.Debug("[cacheGet] cache hit bean:", tableName, id, cacheBean)
has = true has = true
} }
structValue.Set(reflect.Indirect(reflect.ValueOf(cacheBean))) structValue.Set(reflect.Indirect(reflect.ValueOf(cacheBean)))

144
session_insert.go
View File

@ -19,7 +19,7 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
var affected int64 var affected int64
var err error var err error
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
defer session.resetStatement() defer session.resetStatement()
@ -29,7 +29,7 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
if sliceValue.Kind() == reflect.Slice { if sliceValue.Kind() == reflect.Slice {
size := sliceValue.Len() size := sliceValue.Len()
if size > 0 { if size > 0 {
if session.Engine.SupportInsertMany() { if session.engine.SupportInsertMany() {
cnt, err := session.innerInsertMulti(bean) cnt, err := session.innerInsertMulti(bean)
if err != nil { if err != nil {
return affected, err return affected, err
@ -67,15 +67,15 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
return 0, errors.New("could not insert a empty slice") return 0, errors.New("could not insert a empty slice")
} }
if err := session.Statement.setRefValue(reflect.ValueOf(sliceValue.Index(0).Interface())); err != nil { if err := session.statement.setRefValue(reflect.ValueOf(sliceValue.Index(0).Interface())); err != nil {
return 0, err return 0, err
} }
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return 0, ErrTableNotFound return 0, ErrTableNotFound
} }
table := session.Statement.RefTable table := session.statement.RefTable
size := sliceValue.Len() size := sliceValue.Len()
var colNames []string var colNames []string
@ -116,18 +116,18 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
if col.IsDeleted { if col.IsDeleted {
continue continue
} }
if session.Statement.ColumnStr != "" { if session.statement.ColumnStr != "" {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
continue continue
} }
} }
if session.Statement.OmitStr != "" { if session.statement.OmitStr != "" {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
continue continue
} }
} }
if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime { if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
val, t := session.Engine.NowTime2(col.SQLType.Name) val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val) args = append(args, val)
var colName = col.Name var colName = col.Name
@ -135,7 +135,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
} else if col.IsVersion && session.Statement.checkVersion { } else if col.IsVersion && session.statement.checkVersion {
args = append(args, 1) args = append(args, 1)
var colName = col.Name var colName = col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean interface{}) {
@ -171,18 +171,18 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
if col.IsDeleted { if col.IsDeleted {
continue continue
} }
if session.Statement.ColumnStr != "" { if session.statement.ColumnStr != "" {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
continue continue
} }
} }
if session.Statement.OmitStr != "" { if session.statement.OmitStr != "" {
if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok { if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
continue continue
} }
} }
if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime { if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
val, t := session.Engine.NowTime2(col.SQLType.Name) val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val) args = append(args, val)
var colName = col.Name var colName = col.Name
@ -190,7 +190,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
col := table.GetColumn(colName) col := table.GetColumn(colName)
setColumnTime(bean, col, t) setColumnTime(bean, col, t)
}) })
} else if col.IsVersion && session.Statement.checkVersion { } else if col.IsVersion && session.statement.checkVersion {
args = append(args, 1) args = append(args, 1)
var colName = col.Name var colName = col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) { session.afterClosures = append(session.afterClosures, func(bean interface{}) {
@ -214,25 +214,25 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
var sql = "INSERT INTO %s (%v%v%v) VALUES (%v)" var sql = "INSERT INTO %s (%v%v%v) VALUES (%v)"
var statement string var statement string
if session.Engine.dialect.DBType() == core.ORACLE { if session.engine.dialect.DBType() == core.ORACLE {
sql = "INSERT ALL INTO %s (%v%v%v) VALUES (%v) SELECT 1 FROM DUAL" sql = "INSERT ALL INTO %s (%v%v%v) VALUES (%v) SELECT 1 FROM DUAL"
temp := fmt.Sprintf(") INTO %s (%v%v%v) VALUES (", temp := fmt.Sprintf(") INTO %s (%v%v%v) VALUES (",
session.Engine.Quote(session.Statement.TableName()), session.engine.Quote(session.statement.TableName()),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()), strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
session.Engine.QuoteStr()) session.engine.QuoteStr())
statement = fmt.Sprintf(sql, statement = fmt.Sprintf(sql,
session.Engine.Quote(session.Statement.TableName()), session.engine.Quote(session.statement.TableName()),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()), strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
strings.Join(colMultiPlaces, temp)) strings.Join(colMultiPlaces, temp))
} else { } else {
statement = fmt.Sprintf(sql, statement = fmt.Sprintf(sql,
session.Engine.Quote(session.Statement.TableName()), session.engine.Quote(session.statement.TableName()),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()), strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
strings.Join(colMultiPlaces, "),(")) strings.Join(colMultiPlaces, "),("))
} }
res, err := session.exec(statement, args...) res, err := session.exec(statement, args...)
@ -240,8 +240,8 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
return 0, err return 0, err
} }
if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache { if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
session.cacheInsert(session.Statement.TableName()) session.cacheInsert(session.statement.TableName())
} }
lenAfterClosures := len(session.afterClosures) lenAfterClosures := len(session.afterClosures)
@ -249,7 +249,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
elemValue := reflect.Indirect(sliceValue.Index(i)).Addr().Interface() elemValue := reflect.Indirect(sliceValue.Index(i)).Addr().Interface()
// handle AfterInsertProcessor // handle AfterInsertProcessor
if session.IsAutoCommit { if session.isAutoCommit {
// !nashtsai! does user expect it's same slice to passed closure when using Before()/After() when insert multi?? // !nashtsai! does user expect it's same slice to passed closure when using Before()/After() when insert multi??
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(elemValue) closure(elemValue)
@ -281,7 +281,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
// InsertMulti insert multiple records // InsertMulti insert multiple records
func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) { func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -299,14 +299,14 @@ func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
} }
func (session *Session) innerInsert(bean interface{}) (int64, error) { func (session *Session) innerInsert(bean interface{}) (int64, error) {
if err := session.Statement.setRefValue(rValue(bean)); err != nil { if err := session.statement.setRefValue(rValue(bean)); err != nil {
return 0, err return 0, err
} }
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return 0, ErrTableNotFound return 0, ErrTableNotFound
} }
table := session.Statement.RefTable table := session.statement.RefTable
// handle BeforeInsertProcessor // handle BeforeInsertProcessor
for _, closure := range session.beforeClosures { for _, closure := range session.beforeClosures {
@ -318,12 +318,12 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
processor.BeforeInsert() processor.BeforeInsert()
} }
// -- // --
colNames, args, err := genCols(session.Statement.RefTable, session, bean, false, false) colNames, args, err := genCols(session.statement.RefTable, session, bean, false, false)
if err != nil { if err != nil {
return 0, err return 0, err
} }
// insert expr columns, override if exists // insert expr columns, override if exists
exprColumns := session.Statement.getExpr() exprColumns := session.statement.getExpr()
exprColVals := make([]string, 0, len(exprColumns)) exprColVals := make([]string, 0, len(exprColumns))
for _, v := range exprColumns { for _, v := range exprColumns {
// remove the expr columns // remove the expr columns
@ -351,21 +351,21 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
var sqlStr string var sqlStr string
if len(colPlaces) > 0 { if len(colPlaces) > 0 {
sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)", sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
session.Engine.Quote(session.Statement.TableName()), session.engine.Quote(session.statement.TableName()),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
strings.Join(colNames, session.Engine.Quote(", ")), strings.Join(colNames, session.engine.Quote(", ")),
session.Engine.QuoteStr(), session.engine.QuoteStr(),
colPlaces) colPlaces)
} else { } else {
if session.Engine.dialect.DBType() == core.MYSQL { if session.engine.dialect.DBType() == core.MYSQL {
sqlStr = fmt.Sprintf("INSERT INTO %s VALUES ()", session.Engine.Quote(session.Statement.TableName())) sqlStr = fmt.Sprintf("INSERT INTO %s VALUES ()", session.engine.Quote(session.statement.TableName()))
} else { } else {
sqlStr = fmt.Sprintf("INSERT INTO %s DEFAULT VALUES", session.Engine.Quote(session.Statement.TableName())) sqlStr = fmt.Sprintf("INSERT INTO %s DEFAULT VALUES", session.engine.Quote(session.statement.TableName()))
} }
} }
handleAfterInsertProcessorFunc := func(bean interface{}) { handleAfterInsertProcessorFunc := func(bean interface{}) {
if session.IsAutoCommit { if session.isAutoCommit {
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(bean) closure(bean)
} }
@ -394,7 +394,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
// for postgres, many of them didn't implement lastInsertId, so we should // for postgres, many of them didn't implement lastInsertId, so we should
// implemented it ourself. // implemented it ourself.
if session.Engine.dialect.DBType() == core.ORACLE && len(table.AutoIncrement) > 0 { if session.engine.dialect.DBType() == core.ORACLE && len(table.AutoIncrement) > 0 {
res, err := session.query("select seq_atable.currval from dual", args...) res, err := session.query("select seq_atable.currval from dual", args...)
if err != nil { if err != nil {
return 0, err return 0, err
@ -402,14 +402,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
handleAfterInsertProcessorFunc(bean) handleAfterInsertProcessorFunc(bean)
if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache { if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
session.cacheInsert(session.Statement.TableName()) session.cacheInsert(session.statement.TableName())
} }
if table.Version != "" && session.Statement.checkVersion { if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean) verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() { } else if verValue.IsValid() && verValue.CanSet() {
verValue.SetInt(1) verValue.SetInt(1)
} }
@ -427,7 +427,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue, err := table.AutoIncrColumn().ValueOf(bean) aiValue, err := table.AutoIncrColumn().ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} }
if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() { if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@ -437,9 +437,9 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue.Set(int64ToIntValue(id, aiValue.Type())) aiValue.Set(int64ToIntValue(id, aiValue.Type()))
return 1, nil return 1, nil
} else if session.Engine.dialect.DBType() == core.POSTGRES && len(table.AutoIncrement) > 0 { } else if session.engine.dialect.DBType() == core.POSTGRES && len(table.AutoIncrement) > 0 {
//assert table.AutoIncrement != "" //assert table.AutoIncrement != ""
sqlStr = sqlStr + " RETURNING " + session.Engine.Quote(table.AutoIncrement) sqlStr = sqlStr + " RETURNING " + session.engine.Quote(table.AutoIncrement)
res, err := session.query(sqlStr, args...) res, err := session.query(sqlStr, args...)
if err != nil { if err != nil {
@ -447,14 +447,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
} }
handleAfterInsertProcessorFunc(bean) handleAfterInsertProcessorFunc(bean)
if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache { if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
session.cacheInsert(session.Statement.TableName()) session.cacheInsert(session.statement.TableName())
} }
if table.Version != "" && session.Statement.checkVersion { if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean) verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() { } else if verValue.IsValid() && verValue.CanSet() {
verValue.SetInt(1) verValue.SetInt(1)
} }
@ -472,7 +472,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue, err := table.AutoIncrColumn().ValueOf(bean) aiValue, err := table.AutoIncrColumn().ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} }
if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() { if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@ -490,14 +490,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
defer handleAfterInsertProcessorFunc(bean) defer handleAfterInsertProcessorFunc(bean)
if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache { if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
session.cacheInsert(session.Statement.TableName()) session.cacheInsert(session.statement.TableName())
} }
if table.Version != "" && session.Statement.checkVersion { if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean) verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() { } else if verValue.IsValid() && verValue.CanSet() {
verValue.SetInt(1) verValue.SetInt(1)
} }
@ -515,7 +515,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue, err := table.AutoIncrColumn().ValueOf(bean) aiValue, err := table.AutoIncrColumn().ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} }
if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() { if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@ -533,7 +533,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
// parameter is inserted and error // parameter is inserted and error
func (session *Session) InsertOne(bean interface{}) (int64, error) { func (session *Session) InsertOne(bean interface{}) (int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -541,15 +541,15 @@ func (session *Session) InsertOne(bean interface{}) (int64, error) {
} }
func (session *Session) cacheInsert(tables ...string) error { func (session *Session) cacheInsert(tables ...string) error {
if session.Statement.RefTable == nil { if session.statement.RefTable == nil {
return ErrCacheFailed return ErrCacheFailed
} }
table := session.Statement.RefTable table := session.statement.RefTable
cacher := session.Engine.getCacher2(table) cacher := session.engine.getCacher2(table)
for _, t := range tables { for _, t := range tables {
session.Engine.logger.Debug("[cache] clear sql:", t) session.engine.logger.Debug("[cache] clear sql:", t)
cacher.ClearIds(t) cacher.ClearIds(t)
} }

30
session_raw.go
View File

@ -17,10 +17,10 @@ import (
func (session *Session) query(sqlStr string, paramStr ...interface{}) ([]map[string][]byte, error) { func (session *Session) query(sqlStr string, paramStr ...interface{}) ([]map[string][]byte, error) {
session.queryPreprocess(&sqlStr, paramStr...) session.queryPreprocess(&sqlStr, paramStr...)
if session.IsAutoCommit { if session.isAutoCommit {
return session.innerQuery2(sqlStr, paramStr...) return session.innerQuery2(sqlStr, paramStr...)
} }
return session.txQuery(session.Tx, sqlStr, paramStr...) return session.txQuery(session.tx, sqlStr, paramStr...)
} }
func (session *Session) txQuery(tx *core.Tx, sqlStr string, params ...interface{}) ([]map[string][]byte, error) { func (session *Session) txQuery(tx *core.Tx, sqlStr string, params ...interface{}) ([]map[string][]byte, error) {
@ -56,7 +56,7 @@ func (session *Session) innerQuery(sqlStr string, params ...interface{}) (*core.
return nil, rows, err return nil, rows, err
} }
} }
stmt, rows, err := session.Engine.logSQLQueryTime(sqlStr, params, callback) stmt, rows, err := session.engine.logSQLQueryTime(sqlStr, params, callback)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
@ -131,7 +131,7 @@ func (session *Session) innerQuery2(sqlStr string, params ...interface{}) ([]map
// Query runs a raw sql and return records as []map[string][]byte // Query runs a raw sql and return records as []map[string][]byte
func (session *Session) Query(sqlStr string, paramStr ...interface{}) ([]map[string][]byte, error) { func (session *Session) Query(sqlStr string, paramStr ...interface{}) ([]map[string][]byte, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -256,16 +256,16 @@ func query2(db *core.DB, sqlStr string, params ...interface{}) ([]map[string]str
// QueryString runs a raw sql and return records as []map[string]string // QueryString runs a raw sql and return records as []map[string]string
func (session *Session) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) { func (session *Session) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
if session.IsAutoCommit { if session.isAutoCommit {
return query2(session.DB(), sqlStr, args...) return query2(session.DB(), sqlStr, args...)
} }
return txQuery2(session.Tx, sqlStr, args...) return txQuery2(session.tx, sqlStr, args...)
} }
// Execute sql // Execute sql
@ -287,32 +287,32 @@ func (session *Session) innerExec(sqlStr string, args ...interface{}) (sql.Resul
} }
func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, error) { func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, error) {
for _, filter := range session.Engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
// TODO: for table name, it's no need to RefTable // TODO: for table name, it's no need to RefTable
sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable) sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
} }
session.saveLastSQL(sqlStr, args...) session.saveLastSQL(sqlStr, args...)
return session.Engine.logSQLExecutionTime(sqlStr, args, func() (sql.Result, error) { return session.engine.logSQLExecutionTime(sqlStr, args, func() (sql.Result, error) {
if session.IsAutoCommit { if session.isAutoCommit {
// FIXME: oci8 can not auto commit (github.com/mattn/go-oci8) // FIXME: oci8 can not auto commit (github.com/mattn/go-oci8)
if session.Engine.dialect.DBType() == core.ORACLE { if session.engine.dialect.DBType() == core.ORACLE {
session.Begin() session.Begin()
r, err := session.Tx.Exec(sqlStr, args...) r, err := session.tx.Exec(sqlStr, args...)
session.Commit() session.Commit()
return r, err return r, err
} }
return session.innerExec(sqlStr, args...) return session.innerExec(sqlStr, args...)
} }
return session.Tx.Exec(sqlStr, args...) return session.tx.Exec(sqlStr, args...)
}) })
} }
// Exec raw sql // Exec raw sql
func (session *Session) Exec(sqlStr string, args ...interface{}) (sql.Result, error) { func (session *Session) Exec(sqlStr string, args ...interface{}) (sql.Result, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }

82
session_schema.go
View File

@ -17,7 +17,7 @@ import (
// Ping test if database is ok // Ping test if database is ok
func (session *Session) Ping() error { func (session *Session) Ping() error {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -27,12 +27,12 @@ func (session *Session) Ping() error {
// CreateTable create a table according a bean // CreateTable create a table according a bean
func (session *Session) CreateTable(bean interface{}) error { func (session *Session) CreateTable(bean interface{}) error {
v := rValue(bean) v := rValue(bean)
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -42,16 +42,16 @@ func (session *Session) CreateTable(bean interface{}) error {
// CreateIndexes create indexes // CreateIndexes create indexes
func (session *Session) CreateIndexes(bean interface{}) error { func (session *Session) CreateIndexes(bean interface{}) error {
v := rValue(bean) v := rValue(bean)
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
sqls := session.Statement.genIndexSQL() sqls := session.statement.genIndexSQL()
for _, sqlStr := range sqls { for _, sqlStr := range sqls {
_, err := session.exec(sqlStr) _, err := session.exec(sqlStr)
if err != nil { if err != nil {
@ -64,16 +64,16 @@ func (session *Session) CreateIndexes(bean interface{}) error {
// CreateUniques create uniques // CreateUniques create uniques
func (session *Session) CreateUniques(bean interface{}) error { func (session *Session) CreateUniques(bean interface{}) error {
v := rValue(bean) v := rValue(bean)
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
sqls := session.Statement.genUniqueSQL() sqls := session.statement.genUniqueSQL()
for _, sqlStr := range sqls { for _, sqlStr := range sqls {
_, err := session.exec(sqlStr) _, err := session.exec(sqlStr)
if err != nil { if err != nil {
@ -84,7 +84,7 @@ func (session *Session) CreateUniques(bean interface{}) error {
} }
func (session *Session) createOneTable() error { func (session *Session) createOneTable() error {
sqlStr := session.Statement.genCreateTableSQL() sqlStr := session.statement.genCreateTableSQL()
_, err := session.exec(sqlStr) _, err := session.exec(sqlStr)
return err return err
} }
@ -92,16 +92,16 @@ func (session *Session) createOneTable() error {
// DropIndexes drop indexes // DropIndexes drop indexes
func (session *Session) DropIndexes(bean interface{}) error { func (session *Session) DropIndexes(bean interface{}) error {
v := rValue(bean) v := rValue(bean)
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return err return err
} }
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
sqls := session.Statement.genDelIndexSQL() sqls := session.statement.genDelIndexSQL()
for _, sqlStr := range sqls { for _, sqlStr := range sqls {
_, err := session.exec(sqlStr) _, err := session.exec(sqlStr)
if err != nil { if err != nil {
@ -113,14 +113,14 @@ func (session *Session) DropIndexes(bean interface{}) error {
// DropTable drop table will drop table if exist, if drop failed, it will return error // DropTable drop table will drop table if exist, if drop failed, it will return error
func (session *Session) DropTable(beanOrTableName interface{}) error { func (session *Session) DropTable(beanOrTableName interface{}) error {
tableName, err := session.Engine.tableName(beanOrTableName) tableName, err := session.engine.tableName(beanOrTableName)
if err != nil { if err != nil {
return err return err
} }
var needDrop = true var needDrop = true
if !session.Engine.dialect.SupportDropIfExists() { if !session.engine.dialect.SupportDropIfExists() {
sqlStr, args := session.Engine.dialect.TableCheckSql(tableName) sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
results, err := session.query(sqlStr, args...) results, err := session.query(sqlStr, args...)
if err != nil { if err != nil {
return err return err
@ -129,7 +129,7 @@ func (session *Session) DropTable(beanOrTableName interface{}) error {
} }
if needDrop { if needDrop {
sqlStr := session.Engine.Dialect().DropTableSql(tableName) sqlStr := session.engine.Dialect().DropTableSql(tableName)
_, err = session.exec(sqlStr) _, err = session.exec(sqlStr)
return err return err
} }
@ -138,7 +138,7 @@ func (session *Session) DropTable(beanOrTableName interface{}) error {
// IsTableExist if a table is exist // IsTableExist if a table is exist
func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error) { func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error) {
tableName, err := session.Engine.tableName(beanOrTableName) tableName, err := session.engine.tableName(beanOrTableName)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -148,10 +148,10 @@ func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error)
func (session *Session) isTableExist(tableName string) (bool, error) { func (session *Session) isTableExist(tableName string) (bool, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
sqlStr, args := session.Engine.dialect.TableCheckSql(tableName) sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
results, err := session.query(sqlStr, args...) results, err := session.query(sqlStr, args...)
return len(results) > 0, err return len(results) > 0, err
} }
@ -172,12 +172,12 @@ func (session *Session) IsTableEmpty(bean interface{}) (bool, error) {
func (session *Session) isTableEmpty(tableName string) (bool, error) { func (session *Session) isTableEmpty(tableName string) (bool, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
var total int64 var total int64
sqlStr := fmt.Sprintf("select count(*) from %s", session.Engine.Quote(tableName)) sqlStr := fmt.Sprintf("select count(*) from %s", session.engine.Quote(tableName))
err := session.DB().QueryRow(sqlStr).Scan(&total) err := session.DB().QueryRow(sqlStr).Scan(&total)
session.saveLastSQL(sqlStr) session.saveLastSQL(sqlStr)
if err != nil { if err != nil {
@ -193,11 +193,11 @@ func (session *Session) isTableEmpty(tableName string) (bool, error) {
// find if index is exist according cols // find if index is exist according cols
func (session *Session) isIndexExist2(tableName string, cols []string, unique bool) (bool, error) { func (session *Session) isIndexExist2(tableName string, cols []string, unique bool) (bool, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
indexes, err := session.Engine.dialect.GetIndexes(tableName) indexes, err := session.engine.dialect.GetIndexes(tableName)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -215,23 +215,23 @@ func (session *Session) isIndexExist2(tableName string, cols []string, unique bo
func (session *Session) addColumn(colName string) error { func (session *Session) addColumn(colName string) error {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
col := session.Statement.RefTable.GetColumn(colName) col := session.statement.RefTable.GetColumn(colName)
sql, args := session.Statement.genAddColumnStr(col) sql, args := session.statement.genAddColumnStr(col)
_, err := session.exec(sql, args...) _, err := session.exec(sql, args...)
return err return err
} }
func (session *Session) addIndex(tableName, idxName string) error { func (session *Session) addIndex(tableName, idxName string) error {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
index := session.Statement.RefTable.Indexes[idxName] index := session.statement.RefTable.Indexes[idxName]
sqlStr := session.Engine.dialect.CreateIndexSql(tableName, index) sqlStr := session.engine.dialect.CreateIndexSql(tableName, index)
_, err := session.exec(sqlStr) _, err := session.exec(sqlStr)
return err return err
@ -239,18 +239,18 @@ func (session *Session) addIndex(tableName, idxName string) error {
func (session *Session) addUnique(tableName, uqeName string) error { func (session *Session) addUnique(tableName, uqeName string) error {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
index := session.Statement.RefTable.Indexes[uqeName] index := session.statement.RefTable.Indexes[uqeName]
sqlStr := session.Engine.dialect.CreateIndexSql(tableName, index) sqlStr := session.engine.dialect.CreateIndexSql(tableName, index)
_, err := session.exec(sqlStr) _, err := session.exec(sqlStr)
return err return err
} }
// Sync2 synchronize structs to database tables // Sync2 synchronize structs to database tables
func (session *Session) Sync2(beans ...interface{}) error { func (session *Session) Sync2(beans ...interface{}) error {
engine := session.Engine engine := session.engine
tables, err := engine.DBMetas() tables, err := engine.DBMetas()
if err != nil { if err != nil {
@ -277,7 +277,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
} }
if oriTable == nil { if oriTable == nil {
err = session.StoreEngine(session.Statement.StoreEngine).CreateTable(bean) err = session.StoreEngine(session.statement.StoreEngine).CreateTable(bean)
if err != nil { if err != nil {
return err return err
} }
@ -350,8 +350,8 @@ func (session *Session) Sync2(beans ...interface{}) error {
} }
} else { } else {
session := engine.NewSession() session := engine.NewSession()
session.Statement.RefTable = table session.statement.RefTable = table
session.Statement.tableName = tbName session.statement.tableName = tbName
defer session.Close() defer session.Close()
err = session.addColumn(col.Name) err = session.addColumn(col.Name)
} }
@ -402,14 +402,14 @@ func (session *Session) Sync2(beans ...interface{}) error {
for name, index := range addedNames { for name, index := range addedNames {
if index.Type == core.UniqueType { if index.Type == core.UniqueType {
session := engine.NewSession() session := engine.NewSession()
session.Statement.RefTable = table session.statement.RefTable = table
session.Statement.tableName = tbName session.statement.tableName = tbName
defer session.Close() defer session.Close()
err = session.addUnique(tbName, name) err = session.addUnique(tbName, name)
} else if index.Type == core.IndexType { } else if index.Type == core.IndexType {
session := engine.NewSession() session := engine.NewSession()
session.Statement.RefTable = table session.statement.RefTable = table
session.Statement.tableName = tbName session.statement.tableName = tbName
defer session.Close() defer session.Close()
err = session.addIndex(tbName, name) err = session.addIndex(tbName, name)
} }

70
session_stats.go
View File

@ -10,30 +10,30 @@ import "database/sql"
// are conditions. // are conditions.
func (session *Session) Count(bean ...interface{}) (int64, error) { func (session *Session) Count(bean ...interface{}) (int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
var sqlStr string var sqlStr string
var args []interface{} var args []interface{}
var err error var err error
if session.Statement.RawSQL == "" { if session.statement.RawSQL == "" {
sqlStr, args, err = session.Statement.genCountSQL(bean...) sqlStr, args, err = session.statement.genCountSQL(bean...)
if err != nil { if err != nil {
return 0, err return 0, err
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
var total int64 var total int64
if session.IsAutoCommit { if session.isAutoCommit {
err = session.DB().QueryRow(sqlStr, args...).Scan(&total) err = session.DB().QueryRow(sqlStr, args...).Scan(&total)
} else { } else {
err = session.Tx.QueryRow(sqlStr, args...).Scan(&total) err = session.tx.QueryRow(sqlStr, args...).Scan(&total)
} }
if err == sql.ErrNoRows || err == nil { if err == sql.ErrNoRows || err == nil {
@ -46,30 +46,30 @@ func (session *Session) Count(bean ...interface{}) (int64, error) {
// Sum call sum some column. bean's non-empty fields are conditions. // Sum call sum some column. bean's non-empty fields are conditions.
func (session *Session) Sum(bean interface{}, columnName string) (float64, error) { func (session *Session) Sum(bean interface{}, columnName string) (float64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
var sqlStr string var sqlStr string
var args []interface{} var args []interface{}
var err error var err error
if len(session.Statement.RawSQL) == 0 { if len(session.statement.RawSQL) == 0 {
sqlStr, args, err = session.Statement.genSumSQL(bean, columnName) sqlStr, args, err = session.statement.genSumSQL(bean, columnName)
if err != nil { if err != nil {
return 0, err return 0, err
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
var res float64 var res float64
if session.IsAutoCommit { if session.isAutoCommit {
err = session.DB().QueryRow(sqlStr, args...).Scan(&res) err = session.DB().QueryRow(sqlStr, args...).Scan(&res)
} else { } else {
err = session.Tx.QueryRow(sqlStr, args...).Scan(&res) err = session.tx.QueryRow(sqlStr, args...).Scan(&res)
} }
if err == sql.ErrNoRows || err == nil { if err == sql.ErrNoRows || err == nil {
@ -81,30 +81,30 @@ func (session *Session) Sum(bean interface{}, columnName string) (float64, error
// SumInt call sum some column. bean's non-empty fields are conditions. // SumInt call sum some column. bean's non-empty fields are conditions.
func (session *Session) SumInt(bean interface{}, columnName string) (int64, error) { func (session *Session) SumInt(bean interface{}, columnName string) (int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
var sqlStr string var sqlStr string
var args []interface{} var args []interface{}
var err error var err error
if len(session.Statement.RawSQL) == 0 { if len(session.statement.RawSQL) == 0 {
sqlStr, args, err = session.Statement.genSumSQL(bean, columnName) sqlStr, args, err = session.statement.genSumSQL(bean, columnName)
if err != nil { if err != nil {
return 0, err return 0, err
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
var res int64 var res int64
if session.IsAutoCommit { if session.isAutoCommit {
err = session.DB().QueryRow(sqlStr, args...).Scan(&res) err = session.DB().QueryRow(sqlStr, args...).Scan(&res)
} else { } else {
err = session.Tx.QueryRow(sqlStr, args...).Scan(&res) err = session.tx.QueryRow(sqlStr, args...).Scan(&res)
} }
if err == sql.ErrNoRows || err == nil { if err == sql.ErrNoRows || err == nil {
@ -116,30 +116,30 @@ func (session *Session) SumInt(bean interface{}, columnName string) (int64, erro
// Sums call sum some columns. bean's non-empty fields are conditions. // Sums call sum some columns. bean's non-empty fields are conditions.
func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) { func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
var sqlStr string var sqlStr string
var args []interface{} var args []interface{}
var err error var err error
if len(session.Statement.RawSQL) == 0 { if len(session.statement.RawSQL) == 0 {
sqlStr, args, err = session.Statement.genSumSQL(bean, columnNames...) sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
var res = make([]float64, len(columnNames), len(columnNames)) var res = make([]float64, len(columnNames), len(columnNames))
if session.IsAutoCommit { if session.isAutoCommit {
err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res) err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res)
} else { } else {
err = session.Tx.QueryRow(sqlStr, args...).ScanSlice(&res) err = session.tx.QueryRow(sqlStr, args...).ScanSlice(&res)
} }
if err == sql.ErrNoRows || err == nil { if err == sql.ErrNoRows || err == nil {
@ -151,30 +151,30 @@ func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64
// SumsInt sum specify columns and return as []int64 instead of []float64 // SumsInt sum specify columns and return as []int64 instead of []float64
func (session *Session) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) { func (session *Session) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
var sqlStr string var sqlStr string
var args []interface{} var args []interface{}
var err error var err error
if len(session.Statement.RawSQL) == 0 { if len(session.statement.RawSQL) == 0 {
sqlStr, args, err = session.Statement.genSumSQL(bean, columnNames...) sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} else { } else {
sqlStr = session.Statement.RawSQL sqlStr = session.statement.RawSQL
args = session.Statement.RawParams args = session.statement.RawParams
} }
session.queryPreprocess(&sqlStr, args...) session.queryPreprocess(&sqlStr, args...)
var res = make([]int64, len(columnNames), len(columnNames)) var res = make([]int64, len(columnNames), len(columnNames))
if session.IsAutoCommit { if session.isAutoCommit {
err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res) err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res)
} else { } else {
err = session.Tx.QueryRow(sqlStr, args...).ScanSlice(&res) err = session.tx.QueryRow(sqlStr, args...).ScanSlice(&res)
} }
if err == sql.ErrNoRows || err == nil { if err == sql.ErrNoRows || err == nil {

24
session_tx.go
View File

@ -6,14 +6,14 @@ package xorm
// Begin a transaction // Begin a transaction
func (session *Session) Begin() error { func (session *Session) Begin() error {
if session.IsAutoCommit { if session.isAutoCommit {
tx, err := session.DB().Begin() tx, err := session.DB().Begin()
if err != nil { if err != nil {
return err return err
} }
session.IsAutoCommit = false session.isAutoCommit = false
session.IsCommitedOrRollbacked = false session.isCommitedOrRollbacked = false
session.Tx = tx session.tx = tx
session.saveLastSQL("BEGIN TRANSACTION") session.saveLastSQL("BEGIN TRANSACTION")
} }
return nil return nil
@ -21,25 +21,23 @@ func (session *Session) Begin() error {
// Rollback When using transaction, you can rollback if any error // Rollback When using transaction, you can rollback if any error
func (session *Session) Rollback() error { func (session *Session) Rollback() error {
if !session.IsAutoCommit && !session.IsCommitedOrRollbacked { if !session.isAutoCommit && !session.isCommitedOrRollbacked {
session.saveLastSQL(session.Engine.dialect.RollBackStr()) session.saveLastSQL(session.engine.dialect.RollBackStr())
session.IsCommitedOrRollbacked = true session.isCommitedOrRollbacked = true
return session.Tx.Rollback() return session.tx.Rollback()
} }
return nil return nil
} }
// Commit When using transaction, Commit will commit all operations. // Commit When using transaction, Commit will commit all operations.
func (session *Session) Commit() error { func (session *Session) Commit() error {
if !session.IsAutoCommit && !session.IsCommitedOrRollbacked { if !session.isAutoCommit && !session.isCommitedOrRollbacked {
session.saveLastSQL("COMMIT") session.saveLastSQL("COMMIT")
session.IsCommitedOrRollbacked = true session.isCommitedOrRollbacked = true
var err error var err error
if err = session.Tx.Commit(); err == nil { if err = session.tx.Commit(); err == nil {
// handle processors after tx committed // handle processors after tx committed
closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) { closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
if closuresPtr != nil { if closuresPtr != nil {
for _, closure := range *closuresPtr { for _, closure := range *closuresPtr {
closure(bean) closure(bean)

116
session_update.go
View File

@ -16,19 +16,19 @@ import (
) )
func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error { func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
if session.Statement.RefTable == nil || if session.statement.RefTable == nil ||
session.Tx != nil { session.tx != nil {
return ErrCacheFailed return ErrCacheFailed
} }
oldhead, newsql := session.Statement.convertUpdateSQL(sqlStr) oldhead, newsql := session.statement.convertUpdateSQL(sqlStr)
if newsql == "" { if newsql == "" {
return ErrCacheFailed return ErrCacheFailed
} }
for _, filter := range session.Engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
newsql = filter.Do(newsql, session.Engine.dialect, session.Statement.RefTable) newsql = filter.Do(newsql, session.engine.dialect, session.statement.RefTable)
} }
session.Engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql) session.engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
var nStart int var nStart int
if len(args) > 0 { if len(args) > 0 {
@ -39,10 +39,10 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
nStart = strings.Count(oldhead, "$") nStart = strings.Count(oldhead, "$")
} }
} }
table := session.Statement.RefTable table := session.statement.RefTable
cacher := session.Engine.getCacher2(table) cacher := session.engine.getCacher2(table)
tableName := session.Statement.TableName() tableName := session.statement.TableName()
session.Engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:]) session.engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:]) ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:])
if err != nil { if err != nil {
rows, err := session.DB().Query(newsql, args[nStart:]...) rows, err := session.DB().Query(newsql, args[nStart:]...)
@ -75,9 +75,9 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
ids = append(ids, pk) ids = append(ids, pk)
} }
session.Engine.logger.Debug("[cacheUpdate] find updated id", ids) session.engine.logger.Debug("[cacheUpdate] find updated id", ids)
} /*else { } /*else {
session.Engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args) session.engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args)
cacher.DelIds(tableName, genSqlKey(newsql, args)) cacher.DelIds(tableName, genSqlKey(newsql, args))
}*/ }*/
@ -103,36 +103,36 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
colName := sps2[len(sps2)-1] colName := sps2[len(sps2)-1]
if strings.Contains(colName, "`") { if strings.Contains(colName, "`") {
colName = strings.TrimSpace(strings.Replace(colName, "`", "", -1)) colName = strings.TrimSpace(strings.Replace(colName, "`", "", -1))
} else if strings.Contains(colName, session.Engine.QuoteStr()) { } else if strings.Contains(colName, session.engine.QuoteStr()) {
colName = strings.TrimSpace(strings.Replace(colName, session.Engine.QuoteStr(), "", -1)) colName = strings.TrimSpace(strings.Replace(colName, session.engine.QuoteStr(), "", -1))
} else { } else {
session.Engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName) session.engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
return ErrCacheFailed return ErrCacheFailed
} }
if col := table.GetColumn(colName); col != nil { if col := table.GetColumn(colName); col != nil {
fieldValue, err := col.ValueOf(bean) fieldValue, err := col.ValueOf(bean)
if err != nil { if err != nil {
session.Engine.logger.Error(err) session.engine.logger.Error(err)
} else { } else {
session.Engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface()) session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
if col.IsVersion && session.Statement.checkVersion { if col.IsVersion && session.statement.checkVersion {
fieldValue.SetInt(fieldValue.Int() + 1) fieldValue.SetInt(fieldValue.Int() + 1)
} else { } else {
fieldValue.Set(reflect.ValueOf(args[idx])) fieldValue.Set(reflect.ValueOf(args[idx]))
} }
} }
} else { } else {
session.Engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's", session.engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
colName, table.Name) colName, table.Name)
} }
} }
session.Engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean) session.engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
cacher.PutBean(tableName, sid, bean) cacher.PutBean(tableName, sid, bean)
} }
} }
session.Engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName) session.engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
cacher.ClearIds(tableName) cacher.ClearIds(tableName)
return nil return nil
} }
@ -145,7 +145,7 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
// 2.float32 & float64 may be not inexact as conditions // 2.float32 & float64 may be not inexact as conditions
func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error) { func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error) {
defer session.resetStatement() defer session.resetStatement()
if session.IsAutoClose { if session.isAutoClose {
defer session.Close() defer session.Close()
} }
@ -169,21 +169,21 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
var isMap = t.Kind() == reflect.Map var isMap = t.Kind() == reflect.Map
var isStruct = t.Kind() == reflect.Struct var isStruct = t.Kind() == reflect.Struct
if isStruct { if isStruct {
if err := session.Statement.setRefValue(v); err != nil { if err := session.statement.setRefValue(v); err != nil {
return 0, err return 0, err
} }
if len(session.Statement.TableName()) <= 0 { if len(session.statement.TableName()) <= 0 {
return 0, ErrTableNotFound return 0, ErrTableNotFound
} }
if session.Statement.ColumnStr == "" { if session.statement.ColumnStr == "" {
colNames, args = buildUpdates(session.Engine, session.Statement.RefTable, bean, false, false, colNames, args = buildUpdates(session.engine, session.statement.RefTable, bean, false, false,
false, false, session.Statement.allUseBool, session.Statement.useAllCols, false, false, session.statement.allUseBool, session.statement.useAllCols,
session.Statement.mustColumnMap, session.Statement.nullableMap, session.statement.mustColumnMap, session.statement.nullableMap,
session.Statement.columnMap, true, session.Statement.unscoped) session.statement.columnMap, true, session.statement.unscoped)
} else { } else {
colNames, args, err = genCols(session.Statement.RefTable, session, bean, true, true) colNames, args, err = genCols(session.statement.RefTable, session, bean, true, true)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -194,19 +194,19 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
bValue := reflect.Indirect(reflect.ValueOf(bean)) bValue := reflect.Indirect(reflect.ValueOf(bean))
for _, v := range bValue.MapKeys() { for _, v := range bValue.MapKeys() {
colNames = append(colNames, session.Engine.Quote(v.String())+" = ?") colNames = append(colNames, session.engine.Quote(v.String())+" = ?")
args = append(args, bValue.MapIndex(v).Interface()) args = append(args, bValue.MapIndex(v).Interface())
} }
} else { } else {
return 0, ErrParamsType return 0, ErrParamsType
} }
table := session.Statement.RefTable table := session.statement.RefTable
if session.Statement.UseAutoTime && table != nil && table.Updated != "" { if session.statement.UseAutoTime && table != nil && table.Updated != "" {
colNames = append(colNames, session.Engine.Quote(table.Updated)+" = ?") colNames = append(colNames, session.engine.Quote(table.Updated)+" = ?")
col := table.UpdatedColumn() col := table.UpdatedColumn()
val, t := session.Engine.NowTime2(col.SQLType.Name) val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val) args = append(args, val)
var colName = col.Name var colName = col.Name
@ -219,45 +219,45 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
} }
//for update action to like "column = column + ?" //for update action to like "column = column + ?"
incColumns := session.Statement.getInc() incColumns := session.statement.getInc()
for _, v := range incColumns { for _, v := range incColumns {
colNames = append(colNames, session.Engine.Quote(v.colName)+" = "+session.Engine.Quote(v.colName)+" + ?") colNames = append(colNames, session.engine.Quote(v.colName)+" = "+session.engine.Quote(v.colName)+" + ?")
args = append(args, v.arg) args = append(args, v.arg)
} }
//for update action to like "column = column - ?" //for update action to like "column = column - ?"
decColumns := session.Statement.getDec() decColumns := session.statement.getDec()
for _, v := range decColumns { for _, v := range decColumns {
colNames = append(colNames, session.Engine.Quote(v.colName)+" = "+session.Engine.Quote(v.colName)+" - ?") colNames = append(colNames, session.engine.Quote(v.colName)+" = "+session.engine.Quote(v.colName)+" - ?")
args = append(args, v.arg) args = append(args, v.arg)
} }
//for update action to like "column = expression" //for update action to like "column = expression"
exprColumns := session.Statement.getExpr() exprColumns := session.statement.getExpr()
for _, v := range exprColumns { for _, v := range exprColumns {
colNames = append(colNames, session.Engine.Quote(v.colName)+" = "+v.expr) colNames = append(colNames, session.engine.Quote(v.colName)+" = "+v.expr)
} }
if err = session.Statement.processIDParam(); err != nil { if err = session.statement.processIDParam(); err != nil {
return 0, err return 0, err
} }
var autoCond builder.Cond var autoCond builder.Cond
if !session.Statement.noAutoCondition && len(condiBean) > 0 { if !session.statement.noAutoCondition && len(condiBean) > 0 {
var err error var err error
autoCond, err = session.Statement.buildConds(session.Statement.RefTable, condiBean[0], true, true, false, true, false) autoCond, err = session.statement.buildConds(session.statement.RefTable, condiBean[0], true, true, false, true, false)
if err != nil { if err != nil {
return 0, err return 0, err
} }
} }
st := session.Statement st := session.statement
defer session.resetStatement() defer session.resetStatement()
var sqlStr string var sqlStr string
var condArgs []interface{} var condArgs []interface{}
var condSQL string var condSQL string
cond := session.Statement.cond.And(autoCond) cond := session.statement.cond.And(autoCond)
var doIncVer = (table != nil && table.Version != "" && session.Statement.checkVersion) var doIncVer = (table != nil && table.Version != "" && session.statement.checkVersion)
var verValue *reflect.Value var verValue *reflect.Value
if doIncVer { if doIncVer {
verValue, err = table.VersionColumn().ValueOf(bean) verValue, err = table.VersionColumn().ValueOf(bean)
@ -265,8 +265,8 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
return 0, err return 0, err
} }
cond = cond.And(builder.Eq{session.Engine.Quote(table.Version): verValue.Interface()}) cond = cond.And(builder.Eq{session.engine.Quote(table.Version): verValue.Interface()})
colNames = append(colNames, session.Engine.Quote(table.Version)+" = "+session.Engine.Quote(table.Version)+" + 1") colNames = append(colNames, session.engine.Quote(table.Version)+" = "+session.engine.Quote(table.Version)+" + 1")
} }
condSQL, condArgs, err = builder.ToSQL(cond) condSQL, condArgs, err = builder.ToSQL(cond)
@ -290,7 +290,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
} else if st.Engine.dialect.DBType() == core.SQLITE { } else if st.Engine.dialect.DBType() == core.SQLITE {
tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", st.LimitN) tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", st.LimitN)
cond = cond.And(builder.Expr(fmt.Sprintf("rowid IN (SELECT rowid FROM %v %v)", cond = cond.And(builder.Expr(fmt.Sprintf("rowid IN (SELECT rowid FROM %v %v)",
session.Engine.Quote(session.Statement.TableName()), tempCondSQL), condArgs...)) session.engine.Quote(session.statement.TableName()), tempCondSQL), condArgs...))
condSQL, condArgs, err = builder.ToSQL(cond) condSQL, condArgs, err = builder.ToSQL(cond)
if err != nil { if err != nil {
return 0, err return 0, err
@ -301,7 +301,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
} else if st.Engine.dialect.DBType() == core.POSTGRES { } else if st.Engine.dialect.DBType() == core.POSTGRES {
tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", st.LimitN) tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", st.LimitN)
cond = cond.And(builder.Expr(fmt.Sprintf("CTID IN (SELECT CTID FROM %v %v)", cond = cond.And(builder.Expr(fmt.Sprintf("CTID IN (SELECT CTID FROM %v %v)",
session.Engine.Quote(session.Statement.TableName()), tempCondSQL), condArgs...)) session.engine.Quote(session.statement.TableName()), tempCondSQL), condArgs...))
condSQL, condArgs, err = builder.ToSQL(cond) condSQL, condArgs, err = builder.ToSQL(cond)
if err != nil { if err != nil {
return 0, err return 0, err
@ -315,7 +315,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
table != nil && len(table.PrimaryKeys) == 1 { table != nil && len(table.PrimaryKeys) == 1 {
cond = builder.Expr(fmt.Sprintf("%s IN (SELECT TOP (%d) %s FROM %v%v)", cond = builder.Expr(fmt.Sprintf("%s IN (SELECT TOP (%d) %s FROM %v%v)",
table.PrimaryKeys[0], st.LimitN, table.PrimaryKeys[0], table.PrimaryKeys[0], st.LimitN, table.PrimaryKeys[0],
session.Engine.Quote(session.Statement.TableName()), condSQL), condArgs...) session.engine.Quote(session.statement.TableName()), condSQL), condArgs...)
condSQL, condArgs, err = builder.ToSQL(cond) condSQL, condArgs, err = builder.ToSQL(cond)
if err != nil { if err != nil {
@ -336,7 +336,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
sqlStr = fmt.Sprintf("UPDATE %v%v SET %v %v", sqlStr = fmt.Sprintf("UPDATE %v%v SET %v %v",
top, top,
session.Engine.Quote(session.Statement.TableName()), session.engine.Quote(session.statement.TableName()),
strings.Join(colNames, ", "), strings.Join(colNames, ", "),
condSQL) condSQL)
@ -350,19 +350,19 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
} }
if table != nil { if table != nil {
if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache { if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
cacher.ClearIds(session.Statement.TableName()) cacher.ClearIds(session.statement.TableName())
cacher.ClearBeans(session.Statement.TableName()) cacher.ClearBeans(session.statement.TableName())
} }
} }
// handle after update processors // handle after update processors
if session.IsAutoCommit { if session.isAutoCommit {
for _, closure := range session.afterClosures { for _, closure := range session.afterClosures {
closure(bean) closure(bean)
} }
if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok { if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
session.Engine.logger.Debug("[event]", session.Statement.TableName(), " has after update processor") session.engine.logger.Debug("[event]", session.statement.TableName(), " has after update processor")
processor.AfterUpdate() processor.AfterUpdate()
} }
} else { } else {