Transaction

More API refer Orm 增删改查

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

Either way, it should be noted that only SQL executed via TxOrm will be considered to be within a transaction.

  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)

Of course, QuerySeter and QueryM2Mer, RawSeter derived from TxOrm are also considered to be inside the transaction.

The methods related to transactions are:

  1.     Begin() (TxOrmer, error)
  2.     BeginWithCtx(ctx context.Context) (TxOrmer, error)
  3.     BeginWithOpts(opts *sql.TxOptions) (TxOrmer, error)
  4.     BeginWithCtxAndOpts(ctx context.Context, opts *sql.TxOptions) (TxOrmer, error)
  6.     // Beego closure
  7.     DoTx(task func(ctx context.Context, txOrm TxOrmer) error) error
  8.     DoTxWithCtx(ctx context.Context, task func(ctx context.Context, txOrm TxOrmer) error) error
  9.     DoTxWithOpts(opts *sql.TxOptions, task func(ctx context.Context, txOrm TxOrmer) error) error
  10.     DoTxWithCtxAndOpts(ctx context.Context, opts *sql.TxOptions, task func(ctx context.Context, txOrm TxOrmer) error) error