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)