name: Transaction

sort: 7

Transaction

There are two ways to handle transaction in Beego. One is closure:

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

In this way, the first parameter is task, all DB operation should be inside the task.

If the task return error, Beego rollback the transaction.

We recommend you to use this way.

Another way is that users handle transaction manually:

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