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

时间 2019-12-14

标签 xorm update 乐观更新时间 updated noautotime 繁體版

原文原文链接

更新数据使用Update方法mysql
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()git

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
*/

}