事务处理

ORM 可以简单的进行事务操作

ORM 操作事务，支持两种范式。一种通过闭包的方式，由 Beego 本身来管理事务的生命周期。

  1.     // Beego will manage the transaction's lifecycle
  2.     // if the @param task return error, the transaction will be rollback
  3.     // or the transaction will be committed
  4.     err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
  5.         // data
  6.         user := new(User)
  7.         user.Name = "test_transaction"
  9.         // insert data
  10.         // Using txOrm to execute SQL
  11.         _, e := txOrm.Insert(user)
  12.         // if e != nil the transaction will be rollback
  13.         // or it will be committed
  14.         return e
  15.     })

在这种方式里面，第一个参数是task，即该事务所有完成的动作。注意的是，如果它返回了 error，那么 Beego 会将整个事务回滚。

否则提交事务。

另外一个要注意的是，如果在task执行过程中，发生了panic，那么意味着 Beego 既不会帮你把事务回滚，也不会把事务提交。

我们推荐使用这种方式。

另外一种方式，则是传统的由开发自己手动管理事务的生命周期

  1.     o := orm.NewOrm()
  2.     to, err := o.Begin()
  3.     if err != nil {
  4.         logs.Error("start the transaction failed")
  5.         return
  6.     }
  8.     user := new(User)
  9.     user.Name = "test_transaction"
  11.     // do something with to. to is an instance of TxOrm
  13.     // insert data
  14.     // Using txOrm to execute SQL
  15.     _, err = to.Insert(user)
  17.     if err != nil {
  18.         logs.Error("execute transaction's sql fail, rollback.", err)
  19.         err = to.Rollback()
  20.         if err != nil {
  21.             logs.Error("roll back transaction failed", err)
  22.         }
  23.     } else {
  24.         err = to.Commit()
  25.         if err != nil {
  26.             logs.Error("commit transaction failed.", err)
  27.         }
  28.     }

无论使用哪种方式，都应该注意到，只有通过TxOrm执行的 SQL 才会被认为是在一个事务里面。

  1. o := orm.NewOrm()
  2. to, err := o.Begin()
  4. // outside the txn
  5. o.Insert(xxx)
  7. // inside the txn
  8. to.Insert(xxx)