go學習筆記：gorm基本使用

關於gorm的使用，官網非常詳細推薦大家有時間仔細看 https://gorm.io/zh_CN/docs/conventions.html， 我這里只是演示日常的使用增刪改查：

創建數據：

新建一個gormdemo的數據庫，然后執行下面的sql語句，就會建立一個animals的表，里面還有一些測試數據

CREATE TABLE `animals` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(255) DEFAULT 'galeone',
  `age` INT(10) UNSIGNED DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=MYISAM AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of animals
-- ----------------------------
INSERT INTO `animals` VALUES ('1', 'demo-test', '20');
INSERT INTO `animals` VALUES ('2', 'galeone', '30');
INSERT INTO `animals` VALUES ('3', 'demotest', '30');
INSERT INTO `animals` VALUES ('4', 'jim', '90');
INSERT INTO `animals` VALUES ('5', 'jimmy', '10');
INSERT INTO `animals` VALUES ('6', 'jim', '23');
INSERT INTO `animals` VALUES ('7', 'test3', '27');

我們常規就是插入，修改，刪除，還有事務以及FOR UPDATE排它鎖：

package main

import (
   "fmt"

   "github.com/jinzhu/gorm"
   _ "github.com/jinzhu/gorm/dialects/mysql"
)

type Animal struct {
   ID   int64
   Name string
   Age  int64
}

func main() {
   db, err := gorm.Open("mysql", "root:root@(localhost)/gormdemo?charset=utf8&parseTime=true&loc=Local")
   if err != nil {
      fmt.Println("connect db error: ", err)
   }
   defer db.Close()
   init_data(db)
   query_test(db)
   err=update_test(db)
   if err!=nil{
      fmt.Println(err)
   }
   err=delet_test(db)
   if err!=nil{
      fmt.Println(err)
   }
   err=trans_test(db)
   if err!=nil{
      fmt.Println(err)
   }
}
func init_data(db *gorm.DB)  {
   sql:=`DROP TABLE IF EXISTS animals ;`
   db.Exec(sql)
   sql=`
      CREATE TABLE animals (
        id BIGINT(20) NOT NULL AUTO_INCREMENT,
        NAME VARCHAR(255) DEFAULT 'galeone',
        age INT(10) UNSIGNED DEFAULT '0',
        PRIMARY KEY (id)
      ) ENGINE=INNODB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;`
   db.Exec(sql)
   sql=`
      INSERT INTO animals SELECT '1', 'demo-test', '20'
      UNION ALL SELECT '2', 'galeone', '30'
      UNION ALL SELECT '3', 'demotest', '30'
      UNION ALL SELECT '4', 'jim', '90'
      UNION ALL SELECT'5', 'jimmy', '10'
      UNION ALL SELECT '6', 'jim', '23'
      UNION ALL SELECT '7', 'test3', '27'
      `
   db.Exec(sql)
}
func create_test(db * gorm.DB)(error) {
   animal := Animal{Name: "demo-test", Age: 20}
   db.Create(&animal)
   return nil
}
func query_test(db *gorm.DB)(error)  {
   //根據主鍵查詢第一條記錄
   var animal Animal
   db.First(&animal)
   fmt.Println(animal)

   //根據主鍵查詢最后一條記錄
   var animal2 Animal
   db.Last(&animal2)
   fmt.Println(animal2)

   //指定某條記錄（僅當主鍵為整型時可用）
   var animal3 Animal
   db.First(&animal3, 2)
   fmt.Println(animal3)

   //where條件
   //符合條件的第一條記錄
   var animal4 Animal
   db.Where("name = ?", "demo-test").First(&animal4)
   fmt.Println("where : ", animal4, animal4.ID, animal4.Name, animal4.Age)

   //符合條件的所有記錄
   var animals5 []Animal
   db.Where("name = ?", "galeone").Find(&animals5)
   fmt.Println(animals5)
   for k, v := range animals5 {
      fmt.Println("k:", k, "ID:", v.ID, "Name:", v.Name, "Age:", v.Age)
   }

   //IN
   var animals6 []Animal
   db.Where("name IN (?)", []string{"demo-test", "demotest2"}).Find(&animals6)
   fmt.Println(animals6)

   //LIKE
   var animals7 []Animal
   db.Where("name like ?", "%jim%").Find(&animals7)
   fmt.Println(animals7)

   //AND
   var animals8 []Animal
   db.Where("name = ? AND age >= ?", "jim", "24").Find(&animals8)
   fmt.Println(animals8)

   //總數
   var count int
   var animals9 []Animal
   db.Where("name = ?", "galeone").Or("name = ?", "jim").Find(&animals9).Count(&count)
   fmt.Println(animals9)
   fmt.Println(count)

   //Scan, 原生查詢
   var animals10 []Animal
   db.Raw("SELECT id, name, age From Animals WHERE name = ? AND age = ? ", "galeone", "30").Scan(&animals10)
   fmt.Println("Scan: ", animals10)

   //原生查詢，select all
   var animals11 []Animal
   rows, _ := db.Raw("SELECT id,name FROM Animals").Rows()
   //注意：上面的 select id,name 后面不能寫成 * 代替，不然出來的結果都是默認0值
   //像這樣結果： ALL:  [{0  0} {0  0} {0  0} {0  0} {0  0} {0  0} {0  0}]
   //Scan 后面是什么字段，select 后面就緊跟什么字段
   for rows.Next() {
      var result Animal
      rows.Scan(&result.ID, &result.Name)
      animals11 = append(animals11, result)
   }
   fmt.Println("ALL: ", animals11)
   //output:ALL:  [{1 demo-test 0} {2 galeone 0} {3 demotest2 0} {4 galeone 0} {5 galeone 0} {6 jim 0} {7 jimmy 0}]

   //select 查詢
   var animal12 Animal
   db.Select("name,age").Find(&animal12) //只查詢name，age字段，相當於select name,age from user
   fmt.Println("select: ", animal12)
//map 結構
    animals13:=map[int64]Animal{}
   var animals14 []Animal
   db.Raw("SELECT id, name, age From Animals WHERE id>5").Find(&animals14)
   for _,v:= range  animals14{
      animals13[v.ID]=v
   }
   fmt.Println(animals13)
   return nil
}

func update_test(db *gorm.DB)(err error){
   //根據條件更新字段值,
   //后面加Debug()，運行時，可以打印出sql
   err=db.Debug().Model(&Animal{}).Where("id = ? ", 5).Update("name", "jimupdate").Error
   if err!=nil{
      return err
   }
   //UPDATE `animals` SET `name` = 'jimupdate'  WHERE (id = 4)

   //另外一種寫法： 根據條件更新
   var animal Animal
   animal = Animal{ID: 3}
   err=db.Debug().Model(animal).Update("name", "demotest2update").Error
   if err!=nil{
      return err
   }
   // db.Debug().Model(&animal).Update("name", "demotest2update") // 這種寫法也可以
   //UPDATE `animals` SET `name` = 'demotest2update'  WHERE `animals`.`id` = 3

   /// 多個條件更新
   err=db.Model(&Animal{}).Where("id = ? AND age = ?", 4, 90).Update("name", "jimupdate3").Error
   if err!=nil{
      return err
   }
   //UPDATE `animals` SET `name` = 'jimupdate2'  WHERE (id = 4 AND age = 45)

   /// 更新多個值
   err=db.Debug().Model(&Animal{}).Where("id = ?", 6).Update(Animal{Name: "jim", Age: 90}).Error
   if err!=nil{
      return err
   }
   // UPDATE `animals` SET `age` = 90, `name` = 'jim'  WHERE (id = 4)

   animal2 := Animal{ID: 7}
   err=db.Debug().Model(&animal2).Update(map[string]interface{}{"name": "jimm", "age": 27}).Error
   //UPDATE `animals` SET `age` = 100, `name` = 'jimm'  WHERE `animals`.`id` = 5
   return nil
}

func delet_test(db *gorm.DB)(err error)  {
   err=db.Debug().Where("id = ?", 7).Delete(&Animal{}).Error
   if err!=nil{
      return err
   }
   // DELETE FROM `animals`  WHERE (id = 13)
   err=db.Debug().Delete(&Animal{}, "id = ? AND age = ?", 6, 90).Error
   //DELETE FROM `animals`  WHERE (id = 14 AND age = 10)
   return err
}
func trans_test(db *gorm.DB)(wrong error)  {
   tx:=db.Begin()
   defer func() {
      if err:=recover(); err!=nil{
         tx.Rollback()
         if val,ok:=err.(error); ok{
            wrong=val
         }
      } else{
         err:=tx.Commit().Error
         if err !=nil{
            tx.Rollback()
            wrong=err
         }
      }
   }()

   an:= Animal{Name: "gavin", Age: 35}
   err:=tx.Create(&an).Error
   if err!=nil{
      panic(err)
   }
   err=tx.Exec("UPDATE animals SET age=40 WHERE id=1").Error
   if err!=nil{
      panic(err)
   }
   trans_test2(tx)
   return nil
}
func trans_test2(db *gorm.DB)  {
   var animals1 Animal
   //err:=db.Set("gorm:query_option", "FOR UPDATE").Table("animals").Select("id, `NAME`,Age").Where("ID=?",2).Find(&animals1).Error
   err:=db.Set("gorm:query_option", "FOR UPDATE").First(&animals1,2).Error
   if err!=nil{
      fmt.Println(err)
      panic(err)
   }
   animals1.Name=animals1.Name +"_ gavin update"
   err=db.Set("gorm:query_option", "FOR UPDATE").Table("animals").Where("ID=?",2).Update(&animals1).Error
   if err!=nil{
      fmt.Println(err)
      panic(err)
   }
}