implementation of before/after processors

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

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

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

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
 }
@@ -1334,6 +1455,17 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		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 {
 				fieldValue := reflect.Indirect(reflect.ValueOf(elemValue)).FieldByName(col.FieldName)
@@ -1410,6 +1542,28 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		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()
 }