xorm - Update,乐观锁，更新时间updated，NoAutoTime()

• 更新数据使用update方法

• update方法的第一个参数为需要更新的内容,可以为一个结构体指针或者一个map[string]interface{}类型。
  • 当传入的为结构体指针时，只有非nil和非0的field才会被作为更新的字段，也就是说结构体至少要有一个字段被赋予非0值
  • 当传入的为map类型时，key为数据库column的名字，value为要更新的内容。
• update方法将返回两个参数:
  • 第一个为更新的记录数，需要注意的是 sqlite 数据库返回的是根据更新条件查询的记录数而不是真正受更新的记录数。
• 如果需要更新一个值为0，有两种选择：
  • 通过添加cols函数指定需要更新结构体中的哪些值，未指定的将不更新，指定了的即使为0也会更新。
  • 通过传入map[string]interface{}来进行更新，但这时需要额外指定更新到哪个表，因为通过map是无法自动检测更新哪个表的。

package main

import (
  "fmt"
  _ "github.com/go-sql-driver/mysql"
  "github.com/go-xorm/xorm"
  "log"
  "time"
)

var engine *xorm.engine

type user struct {
  name      string    `xorm:"varchar(25) 'name'"`
  id        int       `xorm:"pk 'id' autoincr"`
  money     int       `xorm:" 'money' "`
  age       int       `xorm:"age"`
  createdat time.time `xorm:"created"`
}

func main() {
  var err error
  engine, err = xorm.newengine("mysql", "root:123456@/test")
  if err != nil {
      log.fatal(err)
      return
  }
  //创建表和插入数据
/*    err = engine.createtables(user{})
  if err != nil {
      log.fatal(err)
      return
  }

  u := make([]user, 3)
  u[0].name = "u0"
  u[0].money = 1
  u[0].age = 1
  u[1].name = "u1"
  u[1].money = 2
  u[1].age = 1
  u[2].name = "u2"
  u[2].money = 3
  u[2].age = 1

  _, err = engine.insert(u)
  if err != nil {
      log.fatal(err)
      return
  }*/


  u1 := new(user)
  u1.money = 2
  affected, err := engine.id(1).update(u1)
  if err != nil {
      log.fatal(err)
  }
  fmt.println("第一个参数为结构体指针，结构体中更新的数据不是0值时，受影响的行数:", affected)


  u2 := new(user)
  u2.money = 0
  affected, err = engine.id(1).cols("money").update(u2)
  if err != nil {
      log.fatal(err)
  }
  fmt.println("第一个参数为结构体指针，结构体中更新的数据是0值，cols函数指定需要更新结构体中的哪些值时，受影响的行数:", affected)

  affected, err = engine.table(new(user)).id(2).update(map[string]interface{}{"age":0})
  fmt.println("第一个参数为map，0值，受影响的行数:", affected)

  u3 := new(user)
  u3.money = 0
  affected, err = engine.id(1).update(u3)
  if err != nil {
      log.fatal(err)
  }
  fmt.println("第一个参数为结构体指针，结构体中更新的数据是0值时，受影响的行数:", affected)


/*
    如果传入的数据和数据库原有的数据相同时上面第一个方法受影响的行数就是0行,不同时上面第一个方法受影响的行数就是1行,输出：
      第一个参数为结构体指针，结构体中更新的数据不是0值时，受影响的行数: 1
      第一个参数为结构体指针，结构体中更新的数据是0值，cols函数指定需要更新结构体中的哪些值时，受影响的行数: 1
    第一个参数为map，0值，受影响的行数: 1
      2019/05/28 11:51:35 no content found to be updated
*/

}

• 乐观锁/更新时间update/不自动更新时间noautotime()

  package main
  
  import (
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "github.com/go-xorm/xorm"
    "log"
    "time"
  )
  
  var engine *xorm.engine
  
  type user struct {
    name      string    `xorm:"varchar(25) 'name'"`
    id        int       `xorm:"pk 'id' autoincr"`
    version   int       `xorm:"version"`
    updatedat time.time `xorm:"updated"`
  }
  
  func main() {
    var err error
    engine, err = xorm.newengine("mysql", "root:123456@/test")
    if err != nil {
        log.fatal(err)
        return
    }
    //创建表和插入数据
  /*    err = engine.createtables(user{})
    if err != nil {
        log.fatal(err)
        return
    }
  
    u := make([]user, 3)
    u[0].name = "u0"
    u[1].name = "u1"
    u[2].name = "u2"
  
    _, err = engine.insert(u)
    if err != nil {
        log.fatal(err)
        return
    }*/
  
    /*
        要使用乐观锁，需要使用version标记
        在insert时，version标记的字段将会被设置为1，在update时，update的内容必须包含version原来的值。
    */
  
        var user user
        has, err := engine.id(1).get(&user)
        if err != nil {
            log.fatal(err)
            return
        }
        if has {
            fmt.println("乐观锁，初始的username:", user.name, "  初始的version:", user.version, "更新时间：", user.updatedat)
        }
  
        user.name = "version2name"
        affected, err := engine.id(1).update(&user)
        if err != nil {
            log.fatal(err)
            return
        }
        fmt.println("乐观锁，改变了的数据库记录数:", affected, "  改变后的username:", user.name,
            "  改变后的version:", user.version, "更新时间：", user.updatedat)
  
        /*
      更新时间updated可以让您在记录插入或每次记录更新时自动更新数据库中的标记字段为当前时间，
        需要在xorm标记中使用updated标记，对应的字段可以为time.time或者自定义的time.time或者int,int64等int类型。
        在insert(), insertone(), update()方法被调用时，updated标记的字段将会被自动更新为当前时间
        */
  
        var user1 user
        has, err = engine.id(2).get(&user1)
        if err != nil {
            log.fatal(err)
            return
        }
        if has {
            fmt.println("更新时间updated，初始的username:", user1.name, "  初始的version:", user1.version, "更新时间：", user1.updatedat)
        }
        affected, err = engine.id(2).update(&user1)
        if err != nil {
            log.fatal(err)
            return
        }
        fmt.println("更新时间updated，改变了的数据库记录数:", affected, "  改变后的username:", user1.name,
            "  改变后的version:", user1.version, "更新时间：", user1.updatedat)
  
  
    /*  如果你希望临时不自动插入时间，则可以组合noautotime()方法：
        engine.noautotime().insert(&user)
        这个在从一张表拷贝字段到另一张表时比较有用。
    */
  
        var user2 user
        has, err = engine.id(3).get(&user2)
        if err != nil {
            log.fatal(err)
            return
        }
        if has {
            fmt.println("临时不自动插入时间，初始的username:", user2.name, "  初始的version:", user2.version, "更新时间：", user2.updatedat)
        }
        affected, err = engine.id(3).noautotime().update(&user2)
        if err != nil {
            log.fatal(err)
            return
        }
        fmt.println("临时不自动插入时间，改变了的数据库记录数:", affected, "  改变后的username:", user2.name,
            "  改变后的version:", user2.version, "更新时间：", user2.updatedat)
  
  
  /*输出：
    乐观锁，初始的username: version2name   初始的version: 2 更新时间： 2019-05-28 14:41:24 +0800 cst
    乐观锁，改变了的数据库记录数: 1   改变后的username: version2name   改变后的version: 3 更新时间： 2019-05-28 14:44:02.386965 +0800 cst
    更新时间updated，初始的username: u1   初始的version: 2 更新时间： 2019-05-28 14:41:24 +0800 cst
    更新时间updated，改变了的数据库记录数: 1   改变后的username: u1   改变后的version: 3 更新时间： 2019-05-28 14:44:02.395314 +0800 cst
    临时不自动插入时间，初始的username: u2   初始的version: 2 更新时间： 2019-05-28 14:41:24 +0800 cst
    临时不自动插入时间，改变了的数据库记录数: 1   改变后的username: u2   改变后的version: 3 更新时间： 2019-05-28 14:41:24 +0800 cst
  */
  
  }