gorm是一个使用Go语言编写的ORM框架。它文档齐全，对开发者友好，支持主流数据库。

1.GORM入门

1.1安装

  1. go get -u github.com/jinzhu/gorm

1.2数据库驱动

连接不同的数据库都需要导入对应数据的驱动程序，GORM已经贴心的为我们包装了一些驱动程序

  1. import _ "github.com/jinzhu/gorm/dialects/mysql"
  2. // import _ "github.com/jinzhu/gorm/dialects/postgres"
  3. // import _ "github.com/jinzhu/gorm/dialects/sqlite"
  4. // import _ "github.com/jinzhu/gorm/dialects/mssql"

1.3连接MySQL

  1. import (
  2.     "github.com/jinzhu/gorm"
  3.     _ "github.com/jinzhu/gorm/dialects/mysql"
  4. )
  6. func main() {
  7.     db, _ := gorm.Open("mysql", "root:123456@(localhost)/dbname?charset=utf8mb4&parseTime=True&loc=Local")
  8.     defer db.Close()
  9. }

2.GORM操作MySQL

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/jinzhu/gorm"
  6.     _ "github.com/jinzhu/gorm/dialects/mysql"
  7. )
  8. //User用户信息
  9. type User struct {
  10.     ID uint
  11.     Name string
  12.     Age string
  13. }
  14. func main() {
  15.     db, err := gorm.Open("mysql", "root:123456@(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True&loc=Local")
  16.     if err != nil {
  17.         panic(err)
  18.     }
  19.     defer db.Close()
  20.     db.AutoMigrate(&User{}) // 自动迁移
  21.     u1 := User{
  22.         ID:   1,
  23.         Name: "cheng",
  24.         Age:  "18",
  25.     }
  26.     u2 := User{
  27.         ID:   2,
  28.         Name: "song",
  29.         Age:  "20",
  30.     }
  31.     // 创建记录
  32.     db.Create(&u1)
  33.     db.Create(&u2)
  34.     //查询第一条记录
  35.     user1 := new(User)
  36.     db.First(user1)
  37.     fmt.Println(*user1)   //{1 cheng 18}
  38.     //查询
  39.     var user2 User
  40.     db.Find(&user2,"name=?","cheng")
  41.     fmt.Println(user2)   //{1 cheng 18}
  43.     //更新
  44.     db.Model(&u1).Update("name","jiacheng")
  45.     //删除
  46.     db.Delete(&u2)
  47. }

3.GORM Model

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

  1. type Model struct {
  2.     ID uint `gorm:"primary:key"`
  3.     CreateAt time.Time
  4.     UpdateAt time.Time
  5.     DeleteAt *time.Time
  6. }

你可以将它嵌入到你自己的模型中：

  1. type User struct {
  2.     gorm.Model
  3.     Name string
  4. }
  1. // 不使用gorm.Model
  2. // 自行定义模型
  3. type User struct {
  4.   ID   int
  5.   Name string
  6. }

3.1模型定义示例

  1. type User struct {
  2.     gorm.Model
  3.     Name string
  4.     Age sql.NullInt64
  5.     Birthday *time.Time
  6.     Email string `gorm:"type:varchar(100);unique_index"`  
  7.     Role string `gorm:"size:255"`  //设置字段大小为255
  8.     MemberNumber *string `gorm:"unique,not null"` //唯一且不为空
  9.     Num int `gorm:"ATUO_INCREMENT"`  //设置num为自增类型
  10.     Address string `gorm:"index:addr"`  //给address字段创建名为addr的索引
  11.     IgnoreMe int `gorm:"-"`  //忽略本字段
  13. }

3.2结构体标记（tags）

结构体标记（Tag） 描述
Column 指定列名
Type 指定列数据类型
Size 指定列大小, 默认值255
PRIMARY_KEY 将列指定为主键
UNIQUE 将列指定为唯一
DEFAULT 指定列默认值
PRECISION 指定列精度
NOT NULL 将列指定为非 NULL
AUTO_INCREMENT 指定列是否为自增类型
INDEX 创建具有或不带名称的索引, 如果多个索引同名则创建复合索引
UNIQUE_INDEX 和 INDEX 类似，只不过创建的是唯一索引
EMBEDDED 将结构设置为嵌入
EMBEDDED_PREFIX 设置嵌入结构的前缀
- 忽略此字段

3.3关联相关标记（tags）

结构体标记（Tag） 描述
MANY2MANY 指定连接表
FOREIGNKEY 设置外键
ASSOCIATION_FOREIGNKEY 设置关联外键
POLYMORPHIC 指定多态类型
POLYMORPHIC_VALUE 指定多态值
JOINTABLE_FOREIGNKEY 指定连接表的外键
ASSOCIATION_JOINTABLE_FOREIGNKEY 指定连接表的关联外键
SAVE_ASSOCIATIONS 是否自动完成 save 的相关操作
ASSOCIATION_AUTOUPDATE 是否自动完成 update 的相关操作
ASSOCIATION_AUTOCREATE 是否自动完成 create 的相关操作
ASSOCIATION_SAVE_REFERENCE 是否自动完成引用的 save 的相关操作
PRELOAD 是否自动完成预加载的相关操作

4.GORM约定

4.1主键（Primary Key）

  1. type User struct {
  2.     ID string   // 名为`ID`的字段会默认作为表的主键
  3.     Name string
  4. }
  1. type Student struct {
  2.     StudentID int64 `gorm:"primary_key"`  //StudentID为主键
  3.     Name string
  4. }

4.2表名（Table Name）

  1. type User struct {}   //默认表名是 `users`
  2. func (User) TableName() string {
  3.     return "profiles"
  4. }
  1. type User struct {
  2.     ID uint
  3.     Name string
  4.     Age string
  5. }  //默认表名是 `users`
  6. //func (User) TableName() string {
  7. //    return "profiles"
  8. //}
  10. func main() {
  11.     db, _ := gorm.Open("mysql", "root:123456@(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True&loc=Local")
  12.     // 禁用默认表名的复数形式，如果置为 true，则 `User` 的默认表名是 `user`
  13.     db.SingularTable(true)  
  14.     db.AutoMigrate(&User{}) // 自动迁移
  15. }
  1. db.Table("userInfo").CreateTable(&User{})
  1. var UserInfo []User
  2. db.Table("userinfo").Find(&UserInfo)  // SELECT * FROM userinfo;
  3. fmt.Println(UserInfo)
  1. db.Table("userinfo").Delete(&UserInfo,"name=?","cheng")
  2. //DELETE FROM userinfo WHERE name = 'cheng';

4.3列名（Column Name）

  1. type UserInfo struct {
  2.     ID uint
  3.     Name string
  4.     Birthday time.Time
  5.     CreateAt time.Time
  6. }
  1. type Person struct {
  2.     ID int64 `gorm:"column:Person_id"`
  3.     Birthday time.Time `gorm:"column:day"`
  4.     Age int64 `gorm:"Column:age"`
  5. }

4.4时间戳跟踪

CreatedAt

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

  2. type UserInfo struct {
  3.     ID uint
  4.     CreatedAt time.Time
  5. }
  7. func main() {
  8.     db, _ := gorm.Open("mysql", "root:123456@(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True&loc=Local")
  9.     db.AutoMigrate(&UserInfo{}) // 自动迁移
  10.     user := UserInfo{
  11.         ID:       1,
  12.     }
  13.     db.Create(&user)
  14. }
  1. db.Model(&user).Update("CreatedAt",time.Now())

UpdatedAt

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

  1. type UserInfo struct {
  2.     ID uint
  3.     CreatedAt time.Time
  4.     UpdatedAt time.Time
  5. }
  7. func main() {
  8.     db, _ := gorm.Open("mysql", "root:123456@(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True&loc=Local")
  9.     db.AutoMigrate(&UserInfo{}) // 自动迁移
  10.     u1 := UserInfo{
  11.         ID:       1,
  12.     }
  13.     u2 := UserInfo{
  14.         ID:       2,
  15.     }
  16.     db.Create(&u1)
  17.     db.Save(&u2)  //`UpdatedAt`将会是当前时间
  18. }
  1. db.Model(&user).Update("name", "jiacheng") // `UpdatedAt`将会是当前时间

DeletedAt

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

  1. package main
  3. import (
  4.     "github.com/jinzhu/gorm"
  5.     "time"
  6.     _ "github.com/jinzhu/gorm/dialects/mysql"
  7. )
  9. type UserInfo struct {
  10.     ID uint
  11.     CreatedAt time.Time
  12.     UpdatedAt time.Time
  13.     DeletedAt time.Time
  14. }
  16. func main() {
  17.     db, _ := gorm.Open("mysql", "root:123456@(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True&loc=Local")
  18.     //db.AutoMigrate(&UserInfo{}) // 自动迁移
  19.     db.Delete(&UserInfo{},"id=?","1")
  20. }