From 69b0a9b713e87ab371ea5c6127e2acd15c7e8242 Mon Sep 17 00:00:00 2001 From: Nash Tsai Date: Sat, 30 Nov 2013 17:50:04 +0800 Subject: [PATCH] implementation of before/after processors --- base_test.go | 161 +++++++++++++++++++++++++++++++ engine.go | 42 +++++++++ processors.go | 39 ++++++++ session.go | 256 +++++++++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 497 insertions(+), 1 deletion(-) create mode 100644 processors.go diff --git a/base_test.go b/base_test.go index 93c11d4c..4e7f20fa 100644 --- a/base_test.go +++ b/base_test.go @@ -1706,6 +1706,165 @@ func testPrefixTableName(engine *Engine, t *testing.T) { } } +type ProcessorsStruct struct { + Id int64 + + B4InsertFlag bool + AfterInsertedFlag bool + B4UpdateFlag bool + AfterUpdatedFlag bool + B4DeleteFlag bool `xorm:"-"` + AfterDeletedFlag bool `xorm:"-"` + + B4InsertViaExt bool + AfterInsertedViaExt bool + B4UpdateViaExt bool + AfterUpdatedViaExt bool + B4DeleteViaExt bool `xorm:"-"` + AfterDeletedViaExt bool `xorm:"-"` +} + +func (p *ProcessorsStruct) BeforeInsert() { + p.B4InsertFlag = true +} + +func (p *ProcessorsStruct) BeforeUpdate() { + p.B4UpdateFlag = true +} + +func (p *ProcessorsStruct) BeforeDelete() { + p.B4DeleteFlag = true +} + +func (p *ProcessorsStruct) AfterInsert() { + p.AfterInsertedFlag = true +} + +func (p *ProcessorsStruct) AfterUpdate() { + p.AfterUpdatedFlag = true +} + +func (p *ProcessorsStruct) AfterDelete() { + p.AfterDeletedFlag = true +} + +func testProcessors(engine *Engine, t *testing.T) { + err := engine.Sync(&ProcessorsStruct{}) + if err != nil { + t.Error(err) + panic(err) + } + + p := &ProcessorsStruct{} + b4InsertFunc := func(bean interface{}) { + if v, ok := interface{}(bean).(ProcessorsStruct); ok { + v.B4InsertViaExt = true + } else { + t.Fail() + } + } + + afterInsertFunc := func(bean interface{}) { + if v, ok := interface{}(bean).(ProcessorsStruct); ok { + v.AfterInsertedViaExt = true + } else { + t.Fail() + } + } + + _, err = engine.BeforeInsert(b4InsertFunc).AfterInsert(afterInsertFunc).Insert(p) + if err != nil { + t.Error(err) + panic(err) + } else { + if !p.B4InsertFlag { t.Fail() } + if !p.AfterInsertedFlag { t.Fail() } + if !p.B4InsertViaExt { t.Fail() } + if !p.AfterInsertedViaExt { t.Fail() } + } + + p2 := &ProcessorsStruct{} + _, err = engine.Id(p.Id).Get(p2) + if err != nil { + t.Error(err) + panic(err) + } else { + if !p.B4InsertFlag { t.Fail() } + if p.AfterInsertedFlag { t.Fail() } + if !p.B4InsertViaExt { t.Fail() } + if p.AfterInsertedViaExt { t.Fail() } + } + + b4UpdateFunc := func(bean interface{}) { + if v, ok := interface{}(bean).(ProcessorsStruct); ok { + v.B4UpdateViaExt = true + } else { + t.Fail() + } + } + + afterUpdateFunc := func(bean interface{}) { + if v, ok := interface{}(bean).(ProcessorsStruct); ok { + v.AfterUpdatedViaExt = true + } else { + t.Fail() + } + } + + _, err = engine.BeforeUpdate(b4UpdateFunc).AfterUpdate(afterUpdateFunc).Update(p) + if err != nil { + t.Error(err) + panic(err) + } else { + if !p.B4UpdateFlag { t.Fail() } + if !p.AfterUpdatedFlag { t.Fail() } + if !p.B4UpdateViaExt { t.Fail() } + if !p.AfterUpdatedViaExt { t.Fail() } + } + + _, err = engine.Id(p.Id).Get(p2) + if err != nil { + t.Error(err) + panic(err) + } else { + if !p.B4UpdateFlag { t.Fail() } + if p.AfterUpdatedFlag { t.Fail() } + if !p.B4UpdateViaExt { t.Fail() } + if p.AfterUpdatedViaExt { t.Fail() } + } + + b4DeleteFunc := func(bean interface{}) { + if v, ok := interface{}(bean).(ProcessorsStruct); ok { + v.B4DeleteViaExt = true + } else { + t.Fail() + } + } + + afterDeleteFunc := func(bean interface{}) { + if v, ok := interface{}(bean).(ProcessorsStruct); ok { + v.AfterDeletedViaExt = true + } else { + t.Fail() + } + } + + + _, err = engine.BeforeDelete(b4DeleteFunc).AfterDelete(afterDeleteFunc).Delete(p) + if err != nil { + t.Error(err) + panic(err) + } else { + if !p.B4DeleteFlag { t.Fail() } + if !p.AfterDeletedFlag { t.Fail() } + if !p.B4DeleteViaExt { t.Fail() } + if !p.AfterDeletedViaExt { t.Fail() } + } + + // !nashtsai! TODO insert many beans tests + +} + func testAll(engine *Engine, t *testing.T) { fmt.Println("-------------- directCreateTable --------------") directCreateTable(engine, t) @@ -1802,4 +1961,6 @@ func testAll2(engine *Engine, t *testing.T) { testPrefixTableName(engine, t) fmt.Println("-------------- transaction --------------") transaction(engine, t) + fmt.Println("-------------- processors --------------") + testProcessors(engine, t) } diff --git a/engine.go b/engine.go index 570f221d..b4ad2f8f 100644 --- a/engine.go +++ b/engine.go @@ -272,6 +272,48 @@ func (engine *Engine) Id(id int64) *Session { return session.Id(id) } +// Apply before insert Processor, affected bean is passed to closure arg +func (engine *Engine) BeforeInsert(closures func(interface{})) *Session { + session := engine.NewSession() + session.IsAutoClose = true + return session.BeforeInsert(closures) +} + +// Apply before update Processor, affected bean is passed to closure arg +func (engine *Engine) BeforeUpdate(closures func(interface{})) *Session { + session := engine.NewSession() + session.IsAutoClose = true + return session.BeforeUpdate(closures) +} + +// Apply before delete Processor, affected bean is passed to closure arg +func (engine *Engine) BeforeDelete(closures func(interface{})) *Session { + session := engine.NewSession() + session.IsAutoClose = true + return session.BeforeDelete(closures) +} + +// Apply after insert Processor, affected bean is passed to closure arg +func (engine *Engine) AfterInsert(closures func(interface{})) *Session { + session := engine.NewSession() + session.IsAutoClose = true + return session.AfterInsert(closures) +} + +// Apply after update Processor, affected bean is passed to closure arg +func (engine *Engine) AfterUpdate(closures func(interface{})) *Session { + session := engine.NewSession() + session.IsAutoClose = true + return session.AfterUpdate(closures) +} + +// Apply after delete Processor, affected bean is passed to closure arg +func (engine *Engine) AfterDelete(closures func(interface{})) *Session { + session := engine.NewSession() + session.IsAutoClose = true + return session.AfterDelete(closures) +} + // set charset when create table, only support mysql now func (engine *Engine) Charset(charset string) *Session { session := engine.NewSession() diff --git a/processors.go b/processors.go new file mode 100644 index 00000000..271a1f08 --- /dev/null +++ b/processors.go @@ -0,0 +1,39 @@ +package xorm + +// Executed before an object is initially persisted to the database +type BeforeInsertProcessor interface { + BeforeInsert() +} + +// Executed before an object is updated +type BeforeUpdateProcessor interface { + BeforeUpdate() +} + +// Executed before an object is deleted +type BeforeDeleteProcessor interface { + BeforeDelete() +} + +// !nashtsai! TODO enable BeforeValidateProcessor when xorm start to support validations +//// Executed before an object is validated +//type BeforeValidateProcessor interface { +// BeforeValidate() +//} +// -- + +// Executed after an object is persisted to the database +type AfterInsertProcessor interface { + AfterInsert() +} + +// Executed after an object has been updated +type AfterUpdateProcessor interface { + AfterUpdate() +} + +// Executed after an object has been deleted +type AfterDeleteProcessor interface { + AfterDelete() +} + diff --git a/session.go b/session.go index c29844fe..4ef3b67d 100644 --- a/session.go +++ b/session.go @@ -22,6 +22,19 @@ type Session struct { IsCommitedOrRollbacked bool TransType string IsAutoClose bool + + // !nashtsai! storing these beans due to yet committed tx + afterInsertBeans []interface{} + afterUpdateBeans []interface{} + afterDeleteBeans []interface{} + // -- + + beforeInsertClosures []func(interface{}) + beforeUpdateClosures []func(interface{}) + beforeDeleteClosures []func(interface{}) + afterInsertClosures []func(interface{}) + afterUpdateClosures []func(interface{}) + afterDeleteClosures []func(interface{}) } // Method Init reset the session as the init status. @@ -31,6 +44,17 @@ func (session *Session) Init() { session.IsAutoCommit = true session.IsCommitedOrRollbacked = false session.IsAutoClose = false + + // !nashtsai! is lazy init better? + session.afterInsertBeans = make([]interface{}, 0) + session.afterUpdateBeans = make([]interface{}, 0) + session.afterDeleteBeans = make([]interface{}, 0) + session.beforeInsertClosures = make([]func(interface{}), 0) + session.beforeUpdateClosures = make([]func(interface{}), 0) + session.beforeDeleteClosures = make([]func(interface{}), 0) + session.afterInsertClosures = make([]func(interface{}), 0) + session.afterUpdateClosures = make([]func(interface{}), 0) + session.afterDeleteClosures = make([]func(interface{}), 0) } // Method Close release the connection from pool @@ -76,6 +100,54 @@ func (session *Session) Id(id int64) *Session { return session } +// Apply before insert Processor, affected bean is passed to closure arg +func (session *Session) BeforeInsert(closures func(interface{})) *Session { + if closures != nil { + session.beforeInsertClosures = append(session.beforeInsertClosures, closures) + } + return session +} + +// Apply before update Processor, affected bean is passed to closure arg +func (session *Session) BeforeUpdate(closures func(interface{})) *Session { + if closures != nil { + session.beforeUpdateClosures = append(session.beforeUpdateClosures, closures) + } + return session +} + +// Apply before delete Processor, affected bean is passed to closure arg +func (session *Session) BeforeDelete(closures func(interface{})) *Session { + if closures != nil { + session.beforeDeleteClosures = append(session.beforeDeleteClosures, closures) + } + return session +} + +// Apply after insert Processor, affected bean is passed to closure arg +func (session *Session) AfterInsert(closures func(interface{})) *Session { + if closures != nil { + session.afterInsertClosures = append(session.afterInsertClosures, closures) + } + return session +} + +// Apply after update Processor, affected bean is passed to closure arg +func (session *Session) AfterUpdate(closures func(interface{})) *Session { + if closures != nil { + session.afterUpdateClosures = append(session.afterUpdateClosures, closures) + } + return session +} + +// Apply after delete Processor, affected bean is passed to closure arg +func (session *Session) AfterDelete(closures func(interface{})) *Session { + if closures != nil { + session.afterDeleteClosures = append(session.afterDeleteClosures, closures) + } + return session +} + // Method Table can input a string or pointer to struct for special a table to operate. func (session *Session) Table(tableNameOrBean interface{}) *Session { session.Statement.Table(tableNameOrBean) @@ -251,7 +323,56 @@ func (session *Session) Commit() error { if !session.IsAutoCommit && !session.IsCommitedOrRollbacked { session.Engine.LogSQL("COMMIT") session.IsCommitedOrRollbacked = true - return session.Tx.Commit() + var err error + + + if err = session.Tx.Commit(); err == nil { + // handle processors after tx committed + for _, elem := range session.afterInsertBeans { + for _, closure := range session.afterInsertClosures { + closure(elem) + } + + if processor, ok := interface{}(elem).(AfterInsertProcessor); ok { + processor.AfterInsert() + } + } + for _, elem := range session.afterUpdateBeans { + for _, closure := range session.afterUpdateClosures { + closure(elem) + } + if processor, ok := interface{}(elem).(AfterUpdateProcessor); ok { + processor.AfterUpdate() + } + } + for _, elem := range session.afterDeleteBeans { + for _, closure := range session.afterDeleteClosures { + closure(elem) + } + if processor, ok := interface{}(elem).(AfterDeleteProcessor); ok { + processor.AfterDelete() + } + } + cleanUpFunc := func(slices *[]interface{}) { + if len(*slices) > 0 { + *slices = make([]interface{}, 0) + } + } + cleanUpProcessorsFunc := func(slices *[]func(interface{})) { + if len(*slices) > 0 { + *slices = make([]func(interface{}), 0) + } + } + cleanUpFunc(&session.afterInsertBeans) + cleanUpFunc(&session.afterUpdateBeans) + cleanUpFunc(&session.afterDeleteBeans) + + // !nash! shoule session based processors get cleanup? + cleanUpProcessorsFunc(&session.afterInsertClosures) + cleanUpProcessorsFunc(&session.afterUpdateClosures) + cleanUpProcessorsFunc(&session.afterDeleteClosures) + } + return err } return nil } @@ -1333,6 +1454,17 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error for i := 0; i < size; i++ { elemValue := sliceValue.Index(i).Interface() colPlaces := make([]string, 0) + + // handle BeforeInsertProcessor + for _, closure := range session.beforeInsertClosures { + closure(elemValue) + } + + if processor, ok := interface{}(elemValue).(BeforeInsertProcessor); ok { + processor.BeforeInsert() + } + // -- + if i == 0 { for _, col := range table.Columns { @@ -1409,6 +1541,28 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error if table.Cacher != nil && session.Statement.UseCache { session.cacheInsert(session.Statement.TableName()) } + + hasAfterInsertClosures := len(session.afterInsertClosures) > 0 + for i := 0; i < size; i++ { + elemValue := sliceValue.Index(i).Interface() + // handle AfterInsertProcessor + if session.IsAutoCommit { + for _, closure := range session.afterInsertClosures { + closure(elemValue) + } + if processor, ok := interface{}(elemValue).(AfterInsertProcessor); ok { + processor.AfterInsert() + } + } else { + if hasAfterInsertClosures { + session.afterInsertBeans = append(session.afterInsertBeans, elemValue) + } else { + if _, ok := interface{}(elemValue).(AfterInsertProcessor); ok { + session.afterInsertBeans = append(session.afterInsertBeans, elemValue) + } + } + } + } return res.RowsAffected() } @@ -1682,6 +1836,18 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) { table := session.Engine.autoMap(bean) session.Statement.RefTable = table + // handle BeforeInsertProcessor + for _, closure := range session.beforeInsertClosures { + closure(bean) + } + if processor, ok := interface{}(bean).(BeforeInsertProcessor); ok { + session.Engine.LogDebug(session.Statement.TableName(), " has before insert processor") + processor.BeforeInsert() + } else { + session.Engine.LogDebug(session.Statement.TableName(), " has no before insert processor") + } + // -- + colNames, args, err := table.genCols(session, bean, false, false) if err != nil { return 0, err @@ -1699,12 +1865,36 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) { session.Engine.QuoteStr(), colPlaces) + + handleAfterInsertProcessorFunc := func(bean interface{}) { + + if session.IsAutoCommit { + for _, closure := range session.afterInsertClosures { + closure(bean) + } + if processor, ok := interface{}(bean).(AfterInsertProcessor); ok { + session.Engine.LogDebug(session.Statement.TableName(), " has after insert processor") + processor.AfterInsert() + } + } else { + if len(session.afterInsertClosures) > 0 { + session.afterInsertBeans = append(session.afterInsertBeans, bean) + } else { + if _, ok := interface{}(bean).(AfterInsertProcessor); ok { + session.afterInsertBeans = append(session.afterInsertBeans, bean) + } + } + } + } + // for postgres, many of them didn't implement lastInsertId, so we should // implemented it ourself. if session.Engine.DriverName != POSTGRES || table.PrimaryKey == "" { res, err := session.exec(sql, args...) if err != nil { return 0, err + } else { + handleAfterInsertProcessorFunc(bean) } if table.Cacher != nil && session.Statement.UseCache { @@ -1748,6 +1938,8 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) { res, err := session.query(sql, args...) if err != nil { return 0, err + } else { + handleAfterInsertProcessorFunc(bean) } if table.Cacher != nil && session.Statement.UseCache { @@ -1979,6 +2171,17 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6 var args []interface{} var table *Table + + // handle before update processors + for _, closure := range session.beforeUpdateClosures { + closure(bean) + } + + if processor, ok := interface{}(bean).(BeforeUpdateProcessor); ok { + processor.BeforeUpdate() + } + // -- + if t.Kind() == reflect.Struct { table = session.Engine.autoMap(bean) session.Statement.RefTable = table @@ -2077,6 +2280,26 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6 table.Cacher.ClearBeans(session.Statement.TableName()) } + // handle after update processors + if session.IsAutoCommit { + for _, closure := range session.afterUpdateClosures { + closure(bean) + } + if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok { + session.Engine.LogDebug(session.Statement.TableName(), " has after update processor") + processor.AfterUpdate() + } + } else { + if len(session.afterInsertClosures) > 0 { + session.afterUpdateBeans = append(session.afterUpdateBeans, bean) + } else { + if _, ok := interface{}(bean).(AfterUpdateProcessor); ok { + session.afterUpdateBeans = append(session.afterUpdateBeans, bean) + } + } + } + // -- + return res.RowsAffected() } @@ -2142,6 +2365,17 @@ func (session *Session) Delete(bean interface{}) (int64, error) { defer session.Close() } + + // handle before delete processors + for _, closure := range session.beforeDeleteClosures { + closure(bean) + } + + if processor, ok := interface{}(bean).(BeforeDeleteProcessor); ok { + processor.BeforeDelete() + } + // -- + table := session.Engine.autoMap(bean) session.Statement.RefTable = table colNames, args := buildConditions(session.Engine, table, bean, true, @@ -2174,5 +2408,25 @@ func (session *Session) Delete(bean interface{}) (int64, error) { return 0, err } + // handle after delete processors + if session.IsAutoCommit { + for _, closure := range session.afterDeleteClosures { + closure(bean) + } + if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok { + session.Engine.LogDebug(session.Statement.TableName(), " has after update processor") + processor.AfterDelete() + } + } else { + if len(session.afterDeleteClosures) > 0 { + session.afterDeleteBeans = append(session.afterDeleteBeans, bean) + } else { + if _, ok := interface{}(bean).(AfterDeleteProcessor); ok { + session.afterDeleteBeans = append(session.afterDeleteBeans, bean) + } + } + } + // -- + return res.RowsAffected() }