Gorm Model 定义-阿里云开发者社区

Gorm Model 定义

使用 ORM 工具，通常需要在代码中定义模型（Models）与数据库中的数据表进行映射，在 GORM 中模型（Models）通常是正常的结构体、基本的 go 类型或他们的指针，同时也支持 sql.Scanner 与 driver.Valuer 接口（interfaces）

gorm.Model

为了方便模型，GORM 内置一个 gorm.Model 结构体。gorm.Model 是包含了一个 ID , CreateAt, UpdateAt, DeletedAt 四个字段的 Golang 结构体

// gorm.Model 定义
type Model struct {
  ID        uint `gorm:"primary_key"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt *time.Time
}

模型定义示例

type User struct {
  gorm.Model ////内嵌模型
  Name         string
  Age          sql.NullInt64 ////零值类型
  Birthday     *time.Time
  Email        string  `gorm:"type:varchar(100);unique_index"`  //字符串类型，唯一索引
  Role         string  `gorm:"size:255"` // 设置字段大小为255
  MemberNumber *string `gorm:"unique;not null"` // 设置（member number）唯一并且不为空
  Num          int     `gorm:"AUTO_INCREMENT"` // 设置 num 为自增类型
  Address      string  `gorm:"index:addr"` // 给address字段创建名为addr的索引
  IgnoreMe     int     `gorm:"-"` // 忽略本字段
}

结构体标记（tags）

使用结构体声明模型时，标记（tags）是可选项。gorm支持以下标记:

支持结构体标记（Struct tags）

主键、表名、列名的约定

主键（Primary Key）

Gorm 默认使用名为 ID 的字段作为表的主键

type User struct {
  ID   string // 名为`ID`的字段会默认作为表的主键
  Name string
}
// 使用`AnimalID`作为主键
type Animal struct {
  AnimalID int64 `gorm:"primary_key"`
  Name     string
  Age      int64
}

表名（Table Name）

表名默认就是结构体名称的复数，例如

type User struct {} // 默认表名是 `users`
// 将 User 的表名设置为 `profiles`
func (User) TableName() string {
  return "profiles"
}
func (u User) TableName() string {
  if u.Role == "admin" {
    return "admin_users"
  } else {
    return "users"
  }
}
// 禁用默认表名的复数形式，如果置为 true，则 `User` 的默认表名是 `user`
db.SingularTable(true)

也可以通过 Table() 指定表名

// 使用User结构体创建名为`deleted_users`的表
db.Table("deleted_users").CreateTable(&User{})
var deleted_users []User
db.Table("deleted_users").Find(&deleted_users)
//// SELECT * FROM deleted_users;
db.Table("deleted_users").Where("name = ?", "jinzhu").Delete()
//// DELETE FROM deleted_users WHERE name = 'jinzhu';

GORM还支持更改默认表名称规则：

gorm.DefaultTableNameHandler = func (db *gorm.DB, defaultTableName string) string  {
  return "prefix_" + defaultTableName;
}

列名

列名由字段名称进行下划线分割生成

type User struct {
  ID        uint      // column name is `id`
  Name      string    // column name is `name`
  Birthday  time.Time // column name is `birthday`
  CreatedAt time.Time // column name is `created_at`
}

用结构体 tag 指定列名

type Animal struct {
  AnimalId    int64     `gorm:"column:beast_id"`         // set column name to `beast_id`
  Birthday    time.Time `gorm:"column:day_of_the_beast"` // set column name to `day_of_the_beast`
  Age         int64     `gorm:"column:age_of_the_beast"` // set column name to `age_of_the_beast`
}

时间戳跟踪

CreatedAt

如果模型有 CreatedAt字段，该字段的值将会是初次创建记录的时间

db.Create(&user) // `CreatedAt`将会是当前时间
// 可以使用`Update`方法来改变`CreateAt`的值
db.Model(&user).Update("CreatedAt", time.Now())

UpdatedAt

如果模型有UpdatedAt字段，该字段的值将会是每次更新记录的时间。

db.Save(&user) // `UpdatedAt`将会是当前时间
db.Model(&user).Update("name", "jinzhu") // `UpdatedAt`将会是当前时间

DeletedAt

如果模型有DeletedAt字段，调用Delete删除该记录时，将会设置DeletedAt字段为当前时间，而不是直接将记录从数据库中删除。

建表语句

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');

查询语句

package main
import (
 "fmt"
 "github.com/jinzhu/gorm"
 _ "github.com/jinzhu/gorm/dialects/mysql"
)
type Animal struct {
 ID   int64
 Name string
 Age  int64
}
var db *gorm.DB
func init() {
 database, err := gorm.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test?charset=utf8")
 if err != nil {
  fmt.Println("连接数据库失败", err)
  return
 }
 db = database
 //defer database.Close()
}
//https://gorm.io/zh_CN/docs/query.html
func main() {
 defer db.Close()
 //根据逐渐查询第一条记录
 var animal Animal
 db.First(&animal)
 fmt.Println("ani", 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 = ?", "demotest2").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)
 // db.Select([]string{"name", "age"}).Find(&animal12)
 // fmt.Println("select2: ", animal12)
}

更新语句

package main
import (
 "fmt"
 "github.com/jinzhu/gorm"
 _ "github.com/jinzhu/gorm/dialects/mysql"
)
type Animal struct {
 ID   int64
 Name string
 Age  int64
}
var db *gorm.DB
func init() {
 database, err := gorm.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test?charset=utf8")
 if err != nil {
  fmt.Println("连接数据库失败", err)
  return
 }
 db = database
 //defer database.Close()
}
func main() {
 defer db.Close()
 ///根据一个条件更新
 //根据条件更新字段值,
 //后面加Debug()，运行时，可以打印出sql
 db.Debug().Model(&Animal{}).Where("id = ? ", 4).Update("name", "jimupdate")
 //UPDATE `animals` SET `name` = 'jimupdate'  WHERE (id = 4)
 //另外一种写法： 根据条件更新
 var animal Animal
 animal = Animal{ID: 3}
 db.Debug().Model(animal).Update("name", "demotest2update")
 // db.Debug().Model(&animal).Update("name", "demotest2update") // 这种写法也可以
 //UPDATE `animals` SET `name` = 'demotest2update'  WHERE `animals`.`id` = 3
 /// 多个条件更新
 db.Model(&Animal{}).Where("id = ? AND age = ?", 4, 45).Update("name", "jimupdate3")
 //UPDATE `animals` SET `name` = 'jimupdate2'  WHERE (id = 4 AND age = 45)
 /// 更新多个值
 db.Debug().Model(&Animal{}).Where("id = ?", 4).Update(Animal{Name: "jim", Age: 90})
 // UPDATE `animals` SET `age` = 90, `name` = 'jim'  WHERE (id = 4)
 animal2 := Animal{ID: 5}
 db.Debug().Model(&animal2).Update(map[string]interface{}{"name": "jimm", "age": 100})
 //UPDATE `animals` SET `age` = 100, `name` = 'jimm'  WHERE `animals`.`id` = 5
}

删除

package main
import (
 "fmt"
 "github.com/jinzhu/gorm"
 _ "github.com/jinzhu/gorm/dialects/mysql"
)
type Animal struct {
 ID   int64
 Name string
 Age  int64
}
var db *gorm.DB
func init() {
 database, err := gorm.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test?charset=utf8")
 if err != nil {
  fmt.Println("连接数据库失败", err)
  return
 }
 db = database
 //defer database.Close()
}
func main() {
 defer db.Close()
 db.Debug().Where("id = ?", 13).Delete(&Animal{})
 // DELETE FROM `animals`  WHERE (id = 13)
 db.Debug().Delete(&Animal{}, "id = ? AND age = ?", 14, 10)
 //DELETE FROM `animals`  WHERE (id = 14 AND age = 10)
}

Gorm Model 定义