1 files changed, 77 insertions, 33 deletions

diff --git a/vendor/xorm.io/xorm/session_tx.go b/vendor/xorm.io/xorm/session_tx.go
index ee3d473f95..cd23cf89c1 100644
--- a/vendor/xorm.io/xorm/session_tx.go
+++ b/vendor/xorm.io/xorm/session_tx.go
@@ -4,6 +4,12 @@
 
 package xorm
 
+import (
+	"time"
+
+	"xorm.io/xorm/log"
+)
+
 // Begin a transaction
 func (session *Session) Begin() error {
 	if session.isAutoCommit {
@@ -14,6 +20,7 @@ func (session *Session) Begin() error {
 		session.isAutoCommit = false
 		session.isCommitedOrRollbacked = false
 		session.tx = tx
+
 		session.saveLastSQL("BEGIN TRANSACTION")
 	}
 	return nil
@@ -22,10 +29,28 @@ func (session *Session) Begin() error {
 // Rollback When using transaction, you can rollback if any error
 func (session *Session) Rollback() error {
 	if !session.isAutoCommit && !session.isCommitedOrRollbacked {
-		session.saveLastSQL(session.engine.dialect.RollBackStr())
+		session.saveLastSQL("ROLL BACK")
 		session.isCommitedOrRollbacked = true
 		session.isAutoCommit = true
-		return session.tx.Rollback()
+
+		start := time.Now()
+		needSQL := session.DB().NeedLogSQL(session.ctx)
+		if needSQL {
+			session.engine.logger.BeforeSQL(log.LogContext{
+				Ctx: session.ctx,
+				SQL: "ROLL BACK",
+			})
+		}
+		err := session.tx.Rollback()
+		if needSQL {
+			session.engine.logger.AfterSQL(log.LogContext{
+				Ctx:         session.ctx,
+				SQL:         "ROLL BACK",
+				ExecuteTime: time.Now().Sub(start),
+				Err:         err,
+			})
+		}
+		return err
 	}
 	return nil
 }
@@ -36,48 +61,67 @@ func (session *Session) Commit() error {
 		session.saveLastSQL("COMMIT")
 		session.isCommitedOrRollbacked = true
 		session.isAutoCommit = true
-		var err error
-		if err = session.tx.Commit(); err == nil {
-			// handle processors after tx committed
-			closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
-				if closuresPtr != nil {
-					for _, closure := range *closuresPtr {
-						closure(bean)
-					}
+
+		start := time.Now()
+		needSQL := session.DB().NeedLogSQL(session.ctx)
+		if needSQL {
+			session.engine.logger.BeforeSQL(log.LogContext{
+				Ctx: session.ctx,
+				SQL: "COMMIT",
+			})
+		}
+		err := session.tx.Commit()
+		if needSQL {
+			session.engine.logger.AfterSQL(log.LogContext{
+				Ctx:         session.ctx,
+				SQL:         "COMMIT",
+				ExecuteTime: time.Now().Sub(start),
+				Err:         err,
+			})
+		}
+
+		if err != nil {
+			return err
+		}
+
+		// handle processors after tx committed
+		closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
+			if closuresPtr != nil {
+				for _, closure := range *closuresPtr {
+					closure(bean)
 				}
 			}
+		}
 
-			for bean, closuresPtr := range session.afterInsertBeans {
-				closureCallFunc(closuresPtr, bean)
+		for bean, closuresPtr := range session.afterInsertBeans {
+			closureCallFunc(closuresPtr, bean)
 
-				if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
-					processor.AfterInsert()
-				}
+			if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
+				processor.AfterInsert()
 			}
-			for bean, closuresPtr := range session.afterUpdateBeans {
-				closureCallFunc(closuresPtr, bean)
+		}
+		for bean, closuresPtr := range session.afterUpdateBeans {
+			closureCallFunc(closuresPtr, bean)
 
-				if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
-					processor.AfterUpdate()
-				}
+			if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
+				processor.AfterUpdate()
 			}
-			for bean, closuresPtr := range session.afterDeleteBeans {
-				closureCallFunc(closuresPtr, bean)
+		}
+		for bean, closuresPtr := range session.afterDeleteBeans {
+			closureCallFunc(closuresPtr, bean)
 
-				if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
-					processor.AfterDelete()
-				}
+			if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
+				processor.AfterDelete()
 			}
-			cleanUpFunc := func(slices *map[interface{}]*[]func(interface{})) {
-				if len(*slices) > 0 {
-					*slices = make(map[interface{}]*[]func(interface{}), 0)
-				}
+		}
+		cleanUpFunc := func(slices *map[interface{}]*[]func(interface{})) {
+			if len(*slices) > 0 {
+				*slices = make(map[interface{}]*[]func(interface{}), 0)
 			}
-			cleanUpFunc(&session.afterInsertBeans)
-			cleanUpFunc(&session.afterUpdateBeans)
-			cleanUpFunc(&session.afterDeleteBeans)
 		}
-		return err
+		cleanUpFunc(&session.afterInsertBeans)
+		cleanUpFunc(&session.afterUpdateBeans)
+		cleanUpFunc(&session.afterDeleteBeans)
 	}
 	return nil
 }