从GoFrame ORM支持数据库嵌套事务。需要注意的是，数据库服务往往并不支持嵌套事务，而是依靠ORM组件层通过Transaction Save Point特性实现的。相关方法：

  1. // Begin starts a nested transaction procedure. 
  2. func (tx *TX) Begin() error
  4. // Commit commits current transaction.
  5. // Note that it releases previous saved transaction point if it's in a nested transaction procedure,
  6. // or else it commits the hole transaction.
  7. func (tx *TX) Commit() error
  9. // Rollback aborts current transaction.
  10. // Note that it aborts current transaction if it's in a nested transaction procedure,
  11. // or else it aborts the hole transaction.
  12. func (tx *TX) Rollback() error
  14. // SavePoint performs `SAVEPOINT xxx` SQL statement that saves transaction at current point.
  15. // The parameter `point` specifies the point name that will be saved to server.
  16. func (tx *TX) SavePoint(point string) error
  18. // RollbackTo performs `ROLLBACK TO SAVEPOINT xxx` SQL statement that rollbacks to specified saved transaction.
  19. // The parameter `point` specifies the point name that was saved previously.
  20. func (tx *TX) RollbackTo(point string) error
  22. // Transaction wraps the transaction logic using function `f`.
  23. // It rollbacks the transaction and returns the error from function `f` if
  24. // it returns non-nil error. It commits the transaction and returns nil if
  25. // function `f` returns nil.
  26. //
  27. // Note that, you should not Commit or Rollback the transaction in function `f`
  28. // as it is automatically handled by this function.
  29. func (tx *TX) Transaction(ctx context.Context, f func(ctx context.Context, tx *TX) error) (err error)

同样的，我们推荐使用Transaction闭包方法来实现嵌套事务操作。为了保证文档的完整性，因此我们这里仍然从最基本的事务操作方法开始来介绍嵌套事务操作。

一、示例SQL

一个简单的示例SQL，包含两个字段id和name：

  1. CREATE TABLE `user` (
  2.   `id` int(10) unsigned NOT NULL COMMENT '用户ID',
  3.   `name` varchar(45) NOT NULL COMMENT '用户名称',
  4.   PRIMARY KEY (`id`)
  5. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

二、常规操作

  1. tx, err := db.Begin()
  2. if err != nil {
  3.     panic(err)
  4. }
  5. if err = tx.Begin(); err != nil {
  6.     panic(err)
  7. }
  8. _, err = tx.Model(table).Data(g.Map{"id": 1, "name": "john"}).Insert()
  9. if err = tx.Rollback(); err != nil {
  10.     panic(err)
  11. }
  12. _, err = tx.Model(table).Data(g.Map{"id": 2, "name": "smith"}).Insert()
  13. if err = tx.Commit(); err != nil {
  14.     panic(err)
  15. }

1、db.Begin与tx.Begin

可以看到，在我们的嵌套事务中出现了db.Begin和tx.Begin两种事务开启方式，两者有什么区别呢？db.Begin是在数据库服务上真正开启一个事务操作，并返回一个事务操作对象tx，随后所有的事务操作都是通过该tx事务对象来操作管理。tx.Begin表示在当前事务操作中开启嵌套事务，默认情况下会对嵌套事务的SavePoint采用自动命名，命名格式为transactionN，其中的N表示嵌套的层级数量，如果您看到日志中出现SAVEPOINT `transaction1` 表示当前嵌套层级为2（从0开始计算）。

2、更详细的日志

goframe的ORM拥有相当完善的日志记录机制，如果您打开SQL日志，那么将会看到以下日志信息，展示了整个数据库请求的详细执行流程：

  1. 2021-05-22 21:12:10.776 [DEBU] [  4 ms] [default] [txid:1] BEGIN
  2. 2021-05-22 21:12:10.776 [DEBU] [  0 ms] [default] [txid:1] SAVEPOINT `transaction0`
  3. 2021-05-22 21:12:10.789 [DEBU] [ 13 ms] [default] [txid:1] SHOW FULL COLUMNS FROM `user`
  4. 2021-05-22 21:12:10.790 [DEBU] [  1 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(1,'john') 
  5. 2021-05-22 21:12:10.791 [DEBU] [  1 ms] [default] [txid:1] ROLLBACK TO SAVEPOINT `transaction0`
  6. 2021-05-22 21:12:10.791 [DEBU] [  0 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(2,'smith') 
  7. 2021-05-22 21:12:10.792 [DEBU] [  1 ms] [default] [txid:1] COMMIT

其中的[txid:1]表示ORM组件记录的事务ID，多个真实的事务同时操作时，每个事务的ID将会不同。在同一个真实事务下的嵌套事务的事务ID是一样的。

执行后查询数据库结果：

  1. mysql> select * from `user`;
  2. +----+-------+
  3. | id | name  |
  4. +----+-------+
  5. |  2 | smith |
  6. +----+-------+
  7. 1 row in set (0.00 sec)

可以看到第一个操作被成功回滚，只有第二个操作执行并提交成功。

三、闭包操作(推荐)

我们也可以通过闭包操作来实现嵌套事务，同样也是通过Transaction方法实现。

  1. db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  2.     // Nested transaction 1.
  3.     if err := tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  4.         _, err := tx.Model(table).Ctx(ctx).Data(g.Map{"id": 1, "name": "john"}).Insert()
  5.         return err
  6.     }); err != nil {
  7.         return err
  8.     }
  9.     // Nested transaction 2, panic.
  10.     if err := tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  11.         _, err := tx.Model(table).Ctx(ctx).Data(g.Map{"id": 2, "name": "smith"}).Insert()
  12.         // Create a panic that can make this transaction rollback automatically.
  13.         panic("error")
  14.         return err
  15.     }); err != nil {
  16.         return err
  17.     }
  18.     return nil
  19. })

嵌套事务的闭包嵌套中也可以不使用其中的tx对象，而是直接使用db对象或者dao包，这种方式更常见一些。特别是在方法层级调用时，使得对于开发者来说并不用关心tx对象的传递，也并不用关心当前事务是否需要嵌套执行，一切都由组件自动维护，极大减少开发者的心智负担。但是务必记得将ctx上下文变量层层传递下去哦。例如：

  1. db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  2.     // Nested transaction 1.
  3.     if err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  4.         _, err := db.Model(table).Ctx(ctx).Data(g.Map{"id": 1, "name": "john"}).Insert()
  5.         return err
  6.     }); err != nil {
  7.         return err
  8.     }
  9.     // Nested transaction 2, panic.
  10.     if err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  11.         _, err := db.Model(table).Ctx(ctx).Data(g.Map{"id": 2, "name": "smith"}).Insert()
  12.         // Create a panic that can make this transaction rollback automatically.
  13.         panic("error")
  14.         return err
  15.     }); err != nil {
  16.         return err
  17.     }
  18.     return nil
  19. })

如果您打开SQL日志，那么执行后将会看到以下日志信息，展示了整个数据库请求的详细执行流程：

  1. 2021-05-22 21:18:46.672 [DEBU] [  2 ms] [default] [txid:1] BEGIN
  2. 2021-05-22 21:18:46.672 [DEBU] [  0 ms] [default] [txid:1] SAVEPOINT `transaction0`
  3. 2021-05-22 21:18:46.673 [DEBU] [  0 ms] [default] [txid:1] SHOW FULL COLUMNS FROM `user`
  4. 2021-05-22 21:18:46.674 [DEBU] [  0 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(1,'john') 
  5. 2021-05-22 21:18:46.674 [DEBU] [  0 ms] [default] [txid:1] RELEASE SAVEPOINT `transaction0`
  6. 2021-05-22 21:18:46.675 [DEBU] [  1 ms] [default] [txid:1] SAVEPOINT `transaction0`
  7. 2021-05-22 21:18:46.675 [DEBU] [  0 ms] [default] [txid:1] INSERT INTO `user`(`name`,`id`) VALUES('smith',2) 
  8. 2021-05-22 21:18:46.675 [DEBU] [  0 ms] [default] [txid:1] ROLLBACK TO SAVEPOINT `transaction0`
  9. 2021-05-22 21:18:46.676 [DEBU] [  1 ms] [default] [txid:1] ROLLBACK

假如ctx上下文变量没有层层传递下去，那么嵌套事务将会失败，我们来看一个错误的例子：

  1. db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  2.     // Nested transaction 1.
  3.     if err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  4.         _, err := db.Model(table).Ctx(ctx).Data(g.Map{"id": 1, "name": "john"}).Insert()
  5.         return err
  6.     }); err != nil {
  7.         return err
  8.     }
  9.     // Nested transaction 2, panic.
  10.     if err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  11.         _, err := db.Model(table).Data(g.Map{"id": 2, "name": "smith"}).Insert()
  12.         // Create a panic that can make this transaction rollback automatically.
  13.         panic("error")
  14.         return err
  15.     }); err != nil {
  16.         return err
  17.     }
  18.     return nil
  19. })

打开SQL执行日志，执行后，您将会看到以下日志内容：

  1. 2021-05-22 21:29:38.841 [DEBU] [  3 ms] [default] [txid:1] BEGIN
  2. 2021-05-22 21:29:38.842 [DEBU] [  1 ms] [default] [txid:1] SAVEPOINT `transaction0`
  3. 2021-05-22 21:29:38.843 [DEBU] [  1 ms] [default] [txid:1] SHOW FULL COLUMNS FROM `user`
  4. 2021-05-22 21:29:38.845 [DEBU] [  2 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(1,'john') 
  5. 2021-05-22 21:29:38.845 [DEBU] [  0 ms] [default] [txid:1] RELEASE SAVEPOINT `transaction0`
  6. 2021-05-22 21:29:38.846 [DEBU] [  1 ms] [default] [txid:1] SAVEPOINT `transaction0`
  7. 2021-05-22 21:29:38.847 [DEBU] [  1 ms] [default] INSERT INTO `user`(`id`,`name`) VALUES(2,'smith') 
  8. 2021-05-22 21:29:38.848 [DEBU] [  0 ms] [default] [txid:1] ROLLBACK TO SAVEPOINT `transaction0`
  9. 2021-05-22 21:29:38.848 [DEBU] [  0 ms] [default] [txid:1] ROLLBACK

可以看到，第二条INSERT操作INSERT INTO `user`(`id`,`name`) VALUES(2,'smith') 没有事务ID打印，表示没有使用到事务，那么该操作将会被真正提交到数据库执行，并不能被回滚。

四、SavePoint/RollbackTo

开发者也可以灵活使用Transaction Save Point特性，并实现自定义的SavePoint命名以及指定Point回滚操作。

  1. tx, err := db.Begin()
  2. if err != nil {
  3.     panic(err)
  4. }
  5. defer func() {
  6.     if err := recover(); err != nil {
  7.         _ = tx.Rollback()
  8.     }
  9. }()
  10. if _, err = tx.Model(table).Data(g.Map{"id": 1, "name": "john"}).Insert(); err != nil {
  11.     panic(err)
  12. }
  13. if err = tx.SavePoint("MyPoint"); err != nil {
  14.     panic(err)
  15. }
  16. if _, err = tx.Model(table).Data(g.Map{"id": 2, "name": "smith"}).Insert(); err != nil {
  17.     panic(err)
  18. }
  19. if _, err = tx.Model(table).Data(g.Map{"id": 3, "name": "green"}).Insert(); err != nil {
  20.     panic(err)
  21. }
  22. if err = tx.RollbackTo("MyPoint"); err != nil {
  23.     panic(err)
  24. }
  25. if err = tx.Commit(); err != nil {
  26.     panic(err)
  27. }

如果您打开SQL日志，那么将会看到以下日志信息，展示了整个数据库请求的详细执行流程：

  1. 2021-05-22 21:38:51.992 [DEBU] [  3 ms] [default] [txid:1] BEGIN
  2. 2021-05-22 21:38:52.002 [DEBU] [  9 ms] [default] [txid:1] SHOW FULL COLUMNS FROM `user`
  3. 2021-05-22 21:38:52.002 [DEBU] [  0 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(1,'john') 
  4. 2021-05-22 21:38:52.003 [DEBU] [  1 ms] [default] [txid:1] SAVEPOINT `MyPoint`
  5. 2021-05-22 21:38:52.004 [DEBU] [  1 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(2,'smith') 
  6. 2021-05-22 21:38:52.005 [DEBU] [  1 ms] [default] [txid:1] INSERT INTO `user`(`id`,`name`) VALUES(3,'green') 
  7. 2021-05-22 21:38:52.006 [DEBU] [  0 ms] [default] [txid:1] ROLLBACK TO SAVEPOINT `MyPoint`
  8. 2021-05-22 21:38:52.006 [DEBU] [  0 ms] [default] [txid:1] COMMIT

执行后查询数据库结果：

  1. mysql> select * from `user`;
  2. +----+------+
  3. | id | name |
  4. +----+------+
  5. |  1 | john |
  6. +----+------+
  7. 1 row in set (0.00 sec)

可以看到，通过在第一个Insert操作后保存了一个SavePoint名称MyPoint，随后的几次操作都通过RollbackTo方法被回滚掉了，因此只有第一次Insert操作被成功提交执行。

五、嵌套事务在工程中的参考示例

为了简化示例，我们还是使用用户模块相关的示例，例如用户注册，通过事务操作保存用户基本信息(user)、详细信息(user_detail)两个表，任一个表操作失败整个注册操作都将失败。为展示嵌套事务效果，我们将用户基本信息管理和用户详细信息管理划分为了两个dao对象。

假如我们的项目按照goframe标准项目工程化分为三层api-service-dao，那么我们的嵌套事务操作可能是这样的。

controller

  1. // 用户注册HTTP接口
  2. func (*cUser) Signup(r *ghttp.Request) {
  3.     // ....
  4.     service.User().Signup(r.Context(), userServiceSignupReq)
  5.     // ...
  6. }

承接HTTP请求，并且将Context上下文边变量传递给后续的流程。

service

  1. // 用户注册业务逻辑处理
  2. func (*userService) Signup(ctx context.Context, r *model.UserServiceSignupReq) {
  3.     // ....
  4.     dao.User.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  5.         err := dao.User.Ctx(ctx).Save(r.UserInfo)
  6.         if err != nil {
  7.             return err
  8.         }
  9.         err := dao.UserDetail.Ctx(ctx).Save(r.UserDetail)
  10.         if err != nil {
  11.             return err
  12.         }
  13.         return nil
  14.     })
  15.     // ...
  16. }

可以看到，内部的user表和user_detail表使用了嵌套事务来统一执行事务操作。注意在闭包内部需要通过Ctx方法将上下文变量传递给下一层级。假如在闭包中存在对其他service对象的调用，那么也需要将ctx变量传递过去，例如：

  1. func (*userService) Signup(ctx context.Context, r *model.UserServiceSignupReq) {
  2.     // ....
  3.     dao.User.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) (err error) {
  4.         if err = dao.User.Ctx(ctx).Save(r.UserInfo); err != nil {
  5.             return err
  6.         }
  7.         if err = dao.UserDetail.Ctx(ctx).Save(r.UserDetail); err != nil {
  8.             return err
  9.         }
  10.         if err = service.XXXA().Call(ctx, ...); err != nil {
  11.             return err
  12.         }
  13.         if err = service.XXXB().Call(ctx, ...); err != nil {
  14.             return err
  15.         }
  16.         if err = service.XXXC().Call(ctx, ...); err != nil {
  17.             return err
  18.         }
  19.         // ...
  20.         return nil
  21.     })
  22.     // ...
  23. }

dao

dao层的代码由goframe cli工具全自动化生成及维护即可。