关于golang:GORM中文文档

原文连贯： https://blog.csdn.net/u010525...

装置

go get -u github.com/jinzhu/gorm

import (  "github.com/jinzhu/gorm"  _ "github.com/jinzhu/gorm/dialects/sqlite")type Product struct {  gorm.Model    // gorm.Model 帮咱们定义好了一些字段，如：ID、created_at等等  Code string  Price uint}func main() {  db, err := gorm.Open("sqlite3", "test.db")  if err != nil {    panic("failed to connect database")  }  defer db.Close()  //主动查看 Product 构造是否变动，变动则进行迁徙  db.AutoMigrate(&Product{})  // 增  db.Create(&Product{Code: "L1212", Price: 1000})  // 查  var product Product  db.First(&product, 1) // 找到id为1的产品  db.First(&product, "code = ?", "L1212") // 找出 code 为 l1212 的产品  // 改 - 更新产品的价格为 2000  db.Model(&product).Update("Price", 2000)  // 删 - 删除产品  db.Delete(&product)}

模型定义

模型个别都是一般的 Golang 的构造体，Go 的根本数据类型，或者指针。sql.Scanner 和 driver.Valuer，同时也反对接口。

例子：

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"` // 设置 memberNumber 字段惟一且不为空  Num          int     `gorm:"AUTO_INCREMENT"` // 设置 Num字段自增  Address      string  `gorm:"index:addr"` // 给Address 创立一个名字是  `addr`的索引  IgnoreMe     int     `gorm:"-"` //疏忽这个字段}

构造标签

标签是申明模型时可选的标记。GORM 反对以下标记：

反对的构造标签

标签	阐明
Column	指定列的名称
Type	指定列的类型
Size	指定列的大小，默认是 255
PRIMARY_KEY	指定一个列作为主键
UNIQUE	指定一个惟一的列
DEFAULT	指定一个列的默认值
PRECISION	指定列的数据的精度
NOT NULL	指定列的数据不为空
AUTO_INCREMENT	指定一个列的数据是否自增
INDEX	创立带或不带名称的索引，同名创立复合索引
UNIQUE_INDEX	相似索引，创立一个惟一的索引
EMBEDDED	将 struct 设置为 embedded
EMBEDDED_PREFIX	设置嵌入式构造的前缀名称
-	疏忽这些字段

关联的构造标签

无关详细信息，请查看「关联」局部

标签	阐明
MANY2MANY	指定连贯表名称
FOREIGNKEY	指定外键
ASSOCIATION_FOREIGNKEY	指定关联外键
POLYMORPHIC	指定多态类型
POLYMORPHIC_VALUE	指定多态的值
JOINTABLE_FOREIGNKEY	指定连贯表的外键
ASSOCIATION_JOINTABLE_FOREIGNKEY	指定连贯表的关联外键
SAVE_ASSOCIATIONS	是否主动保留关联
ASSOCIATION_AUTOUPDATE	是否自动更新关联
ASSOCIATION_AUTOCREATE	是否主动创立关联
ASSOCIATION_SAVE_REFERENCE	是否主动保留援用的关联

约定gorm.Model

gorm.Model 是一个蕴含一些根本字段的构造体，蕴含的字段有 ID，CreatedAt， UpdatedAt， DeletedAt。

你能够用它来嵌入到你的模型中，或者也能够组合他它来建设本人的模型。

// gorm.Model 定义type Model struct {  ID        uint `gorm:"primary_key"`  CreatedAt time.Time  UpdatedAt time.Time  DeletedAt *time.Time}// 将字段 `ID`, `CreatedAt`, `UpdatedAt`, `DeletedAt` 注入到 `User` 模型中type User struct {  gorm.Model  Name string}// 不应用 gorm.Model 模型type User struct {  ID   int  Name string}

ID 作为主键

GORM 默认应用 ID 作为主键名。

type User struct {  ID   string // 字段名 `ID` 将被作为默认的主键名}// 设置字段 `AnimalID` 为默认主键type Animal struct {  AnimalID int64 `gorm:"primary_key"`  Name     string  Age      int64}

复数表名

表名是构造体名称的复数模式

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)

指定表名

// 用 `User` 构造体创立 `delete_users` 表db.Table("deleted_users").CreateTable(&User{})var deleted_users []Userdb.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';

批改默认表名

你能够通过定义 DefaultTableNameHandler 字段来对表名应用任何规定。

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

蛇形列名

列名是字段名的蛇形小写（小写字母加下划线）模式

type User struct {  ID        uint      // 字段名是 `id`  Name      string    // 字段名是 `name`  Birthday  time.Time // 字段名是 `birthday`  CreatedAt time.Time // 字段名是 `created_at`}// 重写列名type Animal struct {    AnimalId    int64     `gorm:"column:beast_id"`         // 设置列名为 `beast_id`    Birthday    time.Time `gorm:"column:day_of_the_beast"` // 设置列名为 `day_of_the_beast`    Age         int64     `gorm:"column:age_of_the_beast"` // 设置列名为 `age_of_the_beast`}

工夫戳跟踪

CreatedAt

对于有 CreatedAt 字段的模型，它将被设置为首次创立记录的以后工夫。

db.Create(&user) // 将设置 `CreatedAt` 为以后工夫// 你能够应用 `Update` 办法来更改默认工夫db.Model(&user).Update("CreatedAt", time.Now())

UpdatedAt

对于有 UpdatedAt 字段的模型，它将被设置为记录更新时的以后工夫。

db.Save(&user) // 将设置 `UpdatedAt` 为以后工夫db.Model(&user).Update("name", "jinzhu") // 将设置 `UpdatedAt` 为以后工夫

DeletedAt

对于有 DeletedAt 字段的模型，当删除它们的实例时，它们并没有被从数据库中删除，只是将 DeletedAt 字段设置为以后工夫。参考软删除（Soft Delete）。

连贯数据库
为了连贯数据库，你首先要导入数据库驱动程序。例如：

import _ "github.com/go-sql-driver/mysql"

GORM 曾经蕴含了一些驱动程序，为了不便的去记住它们的导入门路，你能够像上面这样导入 mysql 驱动程序

import _ "github.com/jinzhu/gorm/dialects/mysql"// import _ "github.com/jinzhu/gorm/dialects/postgres"// import _ "github.com/jinzhu/gorm/dialects/sqlite"// import _ "github.com/jinzhu/gorm/dialects/mssql"

反对的数据库

MySQL

留神：为了正确的解决 time.Time ，你须要蕴含 parseTime 作为参数。

import (  "github.com/jinzhu/gorm"  _ "github.com/jinzhu/gorm/dialects/mysql")func main() {  db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")  defer db.Close()}

PostgreSQL

import (  "github.com/jinzhu/gorm"  _ "github.com/jinzhu/gorm/dialects/postgres")func main() {  db, err := gorm.Open("postgres", "host=myhost port=myport user=gorm dbname=gorm password=mypassword")  defer db.Close()}

Sqlite3

import (  "github.com/jinzhu/gorm"  _ "github.com/jinzhu/gorm/dialects/sqlite")func main() {  db, err := gorm.Open("sqlite3", "/tmp/gorm.db")  defer db.Close()}

SQL Server

import (  "github.com/jinzhu/gorm"  _ "github.com/jinzhu/gorm/dialects/mssql")func main() {  db, err := gorm.Open("mssql", "sqlserver://username:password@localhost:1433?database=dbname")  defer db.Close()}

不反对的数据库
GORM 官网反对以上四种数据库，你能够为不反对的数据库编写反对，参考 [GORM Dialects].(https://github.com/jinzhu/gor...)

增删改查API

创立记录

user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}db.NewRecord(user) // => 返回 `true` ，因为主键为空db.Create(&user)db.NewRecord(user) // => 在 `user` 之后创立返回 `false

默认值

你能够通过标签定义字段的默认值，例如：

type Animal struct {    ID   int64    Name string `gorm:"default:'galeone'"`    Age  int64}

而后 SQL 会排除那些没有值或者有零值的字段，在记录插入数据库之后，gorm 将从数据库中加载这些字段的值。（数据库中为null的字段从默认值中加载）

var animal = Animal{Age: 99, Name: ""}db.Create(&animal)// INSERT INTO animals("age") values('99');// SELECT name from animals WHERE ID=111; // 返回的主键是 111// animal.Name => 'galeone'

留神所有蕴含零值的字段，像 0，''，false 或者其余的零值不会被保留到数据库中，但会应用这个字段的默认值。你应该思考应用指针类型或者其余的值来防止这种状况:

// Use pointer valuetype User struct {  gorm.Model  Name string  Age  *int `gorm:"default:18"`}// Use scanner/valuertype User struct {  gorm.Model  Name string  Age  sql.NullInt64 `gorm:"default:18"`}

在钩子中设置字段值

如果你想在 BeforeCreate 函数中更新字段的值，应该应用 scope.SetColumn，例如：

func (user *User) BeforeCreate(scope *gorm.Scope) error {  scope.SetColumn("ID", uuid.New())  return nil}

创立额定选项

// 为插入 SQL 语句增加额定选项db.Set("gorm:insert_option", "ON CONFLICT").Create(&product)// INSERT INTO products (name, code) VALUES ("name", "code") ON CONFLICT;

查问

// 获取第一条记录，按主键排序db.First(&user) SELECT * FROM users ORDER BY id LIMIT 1;// 获取一条记录，不指定排序db.Take(&user) SELECT * FROM users LIMIT 1;// 获取最初一条记录，按主键排序db.Last(&user) SELECT * FROM users ORDER BY id DESC LIMIT 1;var users []User// 获取所有的记录db.Find(&users) SELECT * FROM users;// 通过主键进行查问 (仅实用于主键是数字类型)db.First(&user, 10) SELECT * FROM users WHERE id = 10;

Where

原生sql/ 获取第一条匹配的记录db.Where("name = ?", "jinzhu").First(&user) SELECT * FROM users WHERE name = 'jinzhu' limit 1;// 获取所有匹配的记录db.Where("name = ?", "jinzhu").Find(&users) SELECT * FROM users WHERE name = 'jinzhu';// <>db.Where("name <> ?", "jinzhu").Find(&users)// INdb.Where("name in (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)// LIKEdb.Where("name LIKE ?", "%jin%").Find(&users)// ANDdb.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)// Timedb.Where("updated_at > ?", lastWeek).Find(&users)// BETWEENdb.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)

Struct & Map

// Structdb.Where(&User{Name: "jinzhu", Age: 20}).First(&user) SELECT * FROM users WHERE name = "jinzhu" AND age = 20 LIMIT 1;// Mapdb.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users) SELECT * FROM users WHERE name = "jinzhu" AND age = 20;

// 多主键 slice 查问db.Where([]int64{20, 21, 22}).Find(&users) SELECT * FROM users WHERE id IN (20, 21, 22);

留神：当通过 struct 进行查问的时候，GORM 将会查问这些字段的非零值，意味着你的字段蕴含 0， ''， false 或者其余零值 , 将不会呈现在查问语句中，例如:

db.Where(&User{Name: "jinzhu", Age: 0}).Find(&users) SELECT * FROM users WHERE name = "jinzhu";

你能够思考实用指针类型或者 scanner/valuer 来防止这种状况。

// 应用指针类型type User struct {  gorm.Model  Name string  Age  *int}// 应用 scanner/valuertype User struct {  gorm.Model  Name string  Age  sql.NullInt64}

Not

和 Where 查问相似:

db.Not("name", "jinzhu").First(&user) SELECT * FROM users WHERE name <> "jinzhu" LIMIT 1;// 不蕴含db.Not("name", []string{"jinzhu", "jinzhu 2"}).Find(&users) SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");//不在主键 slice 中db.Not([]int64{1,2,3}).First(&user) SELECT * FROM users WHERE id NOT IN (1,2,3);db.Not([]int64{}).First(&user) SELECT * FROM users ORDER BY ID LIMIT 1;// 原生 SQLdb.Not("name = ?", "jinzhu").First(&user) SELECT * FROM users WHERE NOT(name = "jinzhu");// Structdb.Not(User{Name: "jinzhu"}).First(&user) SELECT * FROM users WHERE name <> "jinzhu";

Or

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users) SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';// Structdb.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2"}).Find(&users) SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';// Mapdb.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2"}).Find(&users) SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';

行内条件查问

和 Where 查问相似。

须要留神的是，当应用链式调用传入行内条件查问时，这些查问不会被传参给后续的两头办法。

// 通过主键进行查问 (仅实用于主键是数字类型)db.First(&user, 23) SELECT * FROM users WHERE id = 23 LIMIT 1;// 非数字类型的主键查问db.First(&user, "id = ?", "string_primary_key") SELECT * FROM users WHERE id = 'string_primary_key' LIMIT 1;// 原生 SQLdb.Find(&user, "name = ?", "jinzhu") SELECT * FROM users WHERE name = "jinzhu";db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20) SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;// Structdb.Find(&users, User{Age: 20}) SELECT * FROM users WHERE age = 20;// Mapdb.Find(&users, map[string]interface{}{"age": 20}) SELECT * FROM users WHERE age = 20;

额定的查问选项

// 为查问 SQL 增加额定的选项db.Set("gorm:query_option", "FOR UPDATE").First(&user, 10) SELECT * FROM users WHERE id = 10 FOR UPDATE;

FirstOrInit

获取第一条匹配的记录，或者通过给定的条件下初始一条新的记录（仅实用与于 struct 和 map 条件）。

// 未查问到db.FirstOrInit(&user, User{Name: "non_existing"}) user -> User{Name: "non_existing"}// 查问到db.Where(User{Name: "Jinzhu"}).FirstOrInit(&user) user -> User{Id: 111, Name: "Jinzhu", Age: 20}db.FirstOrInit(&user, map[string]interface{}{"name": "jinzhu"}) user -> User{Id: 111, Name: "Jinzhu", Age: 20}

Attrs

如果未找到记录，则应用参数初始化 struct

// 未查问到db.Where(User{Name: "non_existing"}).Attrs(User{Age: 20}).FirstOrInit(&user) SELECT * FROM USERS WHERE name = 'non_existing'; user -> User{Name: "non_existing", Age: 20}db.Where(User{Name: "non_existing"}).Attrs("age", 20).FirstOrInit(&user) SELECT * FROM USERS WHERE name = 'non_existing'; user -> User{Name: "non_existing", Age: 20}// 查问到db.Where(User{Name: "Jinzhu"}).Attrs(User{Age: 30}).FirstOrInit(&user) SELECT * FROM USERS WHERE name = jinzhu'; user -> User{Id: 111, Name: "Jinzhu", Age: 20}

Assign

无论是否查问到数据，都将参数赋值给 struct

// 未查问到db.Where(User{Name: "non_existing"}).Assign(User{Age: 20}).FirstOrInit(&user) user -> User{Name: "non_existing", Age: 20}// 查问到db.Where(User{Name: "Jinzhu"}).Assign(User{Age: 30}).FirstOrInit(&user) SELECT * FROM USERS WHERE name = jinzhu'; user -> User{Id: 111, Name: "Jinzhu", Age: 30}

FirstOrCreate

获取第一条匹配的记录，或者通过给定的条件创立一条记录（仅实用与于 struct 和 map 条件）。

// 未查问到db.FirstOrCreate(&user, User{Name: "non_existing"}) INSERT INTO "users" (name) VALUES ("non_existing"); user -> User{Id: 112, Name: "non_existing"}// 查问到db.Where(User{Name: "Jinzhu"}).FirstOrCreate(&user) user -> User{Id: 111, Name: "Jinzhu"}

注：Attrs和Assign用法相似。
这里留神辨别FirstOrCreate和FirstOrInit的区别：
FirstOrCreate的创立或更新会触发callback，而FirstOrInit不会。
源码见下图

高级查问

子查问

应用 *gorm.expr 进行子查问

db.Where("amount > ?", DB.Table("orders").Select("AVG(amount)").Where("state = ?", "paid").QueryExpr()).Find(&orders)// SELECT * FROM "orders"  WHERE "orders"."deleted_at" IS NULL AND (amount > (SELECT AVG(amount) FROM "orders"  WHERE (state = 'paid')));

查问字段

指定要从数据库检索的字段，默认状况下，将抉择所有字段。

db.Select("name, age").Find(&users) SELECT name, age FROM users;db.Select([]string{"name", "age"}).Find(&users) SELECT name, age FROM users;db.Table("users").Select("COALESCE(age,?)", 42).Rows() SELECT COALESCE(age,'42') FROM users;

Order

应用 Order 从数据库查问记录时，当第二个参数设置为 true 时，将会笼罩之前的定义条件。

db.Order("age desc, name").Find(&users) SELECT * FROM users ORDER BY age desc, name;// 多个排序条件db.Order("age desc").Order("name").Find(&users) SELECT * FROM users ORDER BY age desc, name;// 从新排序db.Order("age desc").Find(&users1).Order("age", true).Find(&users2) SELECT * FROM users ORDER BY age desc; (users1) SELECT * FROM users ORDER BY age; (users2)

Limit

指定要查问的最大记录数，用 -1 勾销 LIMIT 限度条件

db.Limit(3).Find(&users) SELECT * FROM users LIMIT 3;// 用 -1 勾销 LIMIT 限度条件db.Limit(10).Find(&users1).Limit(-1).Find(&users2) SELECT * FROM users LIMIT 10; (users1) SELECT * FROM users; (users2)

Offset

指定在开始返回记录之前要跳过的记录数。

db.Offset(3).Find(&users) SELECT * FROM users OFFSET 3;// 用 -1 勾销 OFFSET 限度条件db.Offset(10).Find(&users1).Offset(-1).Find(&users2) SELECT * FROM users OFFSET 10; (users1) SELECT * FROM users; (users2)

Count

获取模型记录数

db.Where("name = ?", "jinzhu").Or("name = ?", "jinzhu 2").Find(&users).Count(&count) SELECT * from USERS WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (users) SELECT count(*) FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (count)db.Model(&User{}).Where("name = ?", "jinzhu").Count(&count) SELECT count(*) FROM users WHERE name = 'jinzhu'; (count)db.Table("deleted_users").Count(&count) SELECT count(*) FROM deleted_users;

留神：在查问链中应用 Count 时，必须放在最初一个地位，因为它会笼罩 SELECT 查问条件。

分组查问Group 和 Having

rows, err := db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Rows()for rows.Next() {    ...}rows, err := db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Having("sum(amount) > ?", 100).Rows()for rows.Next() {    ...}type Result struct {    Date  time.Time    Total int64}db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Having("sum(amount) > ?", 100).Scan(&results)

指定关联条件Joins

rows, err := db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Rows()for rows.Next() {    ...}db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)// 多个关联查问db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Joins("JOIN credit_cards ON credit_cards.user_id = users.id").Where("credit_cards.number = ?", "411111111111").Find(&user)

Pluck

应用 Pluck 从模型中查问单个列作为汇合。如果想查问多个列，应该应用 Scan 代替。

var ages []int64db.Find(&users).Pluck("age", &ages)var names []stringdb.Model(&User{}).Pluck("name", &names)db.Table("deleted_users").Pluck("name", &names)// Requesting more than one column? Do it like this:db.Select("name, age").Scan(&users)

Scan

将 Scan 查问后果放入另一个构造体中。

type Result struct {    Name string    Age  int}var result Resultdb.Table("users").Select("name, age").Where("name = ?", 3).Scan(&result)// Raw SQLdb.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

注：Scan和Find的区别？
我的了解是Find用于和模型自身的struct；而Scan能够是内部自定义的构造体。

更新

更新所有字段
Save 办法在执行 SQL 更新操作时将蕴含所有字段，即便这些字段没有被批改。

db.First(&user)user.Name = "jinzhu 2"user.Age = 100db.Save(&user) UPDATE users SET name='jinzhu 2', age=100, birthday='2016-01-01', updated_at = '2013-11-17 21:34:10' WHERE id=111;

只更新指定的字段

如果你只想更新曾经批改了的字段，能够应用 Update，Updates 办法。

留神：当应用构造体更新的时候, GORM 只会更新那些非空的字段：

// 如果单个属性被更改了，更新它db.Model(&user).Update("name", "hello") UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;// 应用组合条件更新单个属性db.Model(&user).Where("active = ?", true).Update("name", "hello") UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111 AND active=true;// 应用 `map` 更新多个属性，只会更新那些被更改了的字段db.Model(&user).Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false}) UPDATE users SET name='hello', age=18, actived=false, updated_at='2013-11-17 21:34:10' WHERE id=111;// 应用 `struct` 更新多个属性，只会更新那些被批改了的和非空的字段db.Model(&user).Updates(User{Name: "hello", Age: 18}) UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;// 正告： 当应用构造体更新的时候, GORM 只会更新那些非空的字段// 例如上面的更新，没有货色会被更新，因为像 "", 0, false 是这些字段类型的空值db.Model(&user).Updates(User{Name: "", Age: 0, Actived: false})

只选/只排除更新的字段

如果你在执行更新操作是只想更新或者疏忽某些字段，能够应用 Select，Omit 办法。

db.Model(&user).Select("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false}) UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;db.Model(&user).Omit("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false}) UPDATE users SET age=18, actived=false, updated_at='2013-11-17 21:34:10' WHERE id=111;

更新列钩子办法

下面的更新操作更新时会执行模型的 BeforeUpdate 和 AfterUpdate 办法，来更新 UpdatedAt 工夫戳，并且保留他的关联。如果你不想执行这些操作，能够应用 UpdateColumn，UpdateColumns 办法。
注：上面的办法不会触发钩子函数：

// Update single attribute, similar with `Update`db.Model(&user).UpdateColumn("name", "hello") UPDATE users SET name='hello' WHERE id = 111;// Update multiple attributes, similar with `Updates`db.Model(&user).UpdateColumns(User{Name: "hello", Age: 18}) UPDATE users SET name='hello', age=18 WHERE id = 111;

批量更新

批量更新时，钩子函数不会执行

db.Table("users").Where("id IN (?)", []int{10, 11}).Updates(map[string]interface{}{"name": "hello", "age": 18}) UPDATE users SET name='hello', age=18 WHERE id IN (10, 11);// 应用构造体更新将只实用于非零值，或者应用 map[string]interface{}db.Model(User{}).Updates(User{Name: "hello", Age: 18}) UPDATE users SET name='hello', age=18;// 应用 `RowsAffected` 获取更新影响的记录数db.Model(User{}).Updates(User{Name: "hello", Age: 18}).RowsAffected带有表达式的 SQL 更新DB.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100)) UPDATE "products" SET "price" = price * '2' + '100', "updated_at" = '2013-11-17 21:34:10' WHERE "id" = '2';DB.Model(&product).Updates(map[string]interface{}{"price": gorm.Expr("price * ? + ?", 2, 100)}) UPDATE "products" SET "price" = price * '2' + '100', "updated_at" = '2013-11-17 21:34:10' WHERE "id" = '2';DB.Model(&product).UpdateColumn("quantity", gorm.Expr("quantity - ?", 1)) UPDATE "products" SET "quantity" = quantity - 1 WHERE "id" = '2';DB.Model(&product).Where("quantity > 1").UpdateColumn("quantity", gorm.Expr("quantity - ?", 1)) UPDATE "products" SET "quantity" = quantity - 1 WHERE "id" = '2' AND quantity > 1;

在钩子函数中更新值

如果你想应用 BeforeUpdate、BeforeSave 钩子函数批改更新的值，能够应用 scope.SetColumn 办法，例如：

func (user *User) BeforeSave(scope *gorm.Scope) (err error) {  if pw, err := bcrypt.GenerateFromPassword(user.Password, 0); err == nil {    scope.SetColumn("EncryptedPassword", pw)  }}

额定的更新选项

OPTION是干啥的？？？

// 在更新 SQL 语句中增加额定的 SQL 选项db.Model(&user).Set("gorm:update_option", "OPTION (OPTIMIZE FOR UNKNOWN)").Update("name", "hello") UPDATE users SET name='hello', updated_at = '2013-11-17 21:34:10' WHERE id=111 OPTION (OPTIMIZE FOR UNKNOWN);

删除

正告：当删除一条记录的时候，你须要确定这条记录的主键有值，GORM 会应用主键来删除这条记录。如果主键字段为空，GORM 会删除模型中所有的记录。

// 删除一条存在的记录，删除前最好确保email主键非空db.Delete(&email) DELETE from emails where id=10;// 为删除 SQL 语句增加额定选项db.Set("gorm:delete_option", "OPTION (OPTIMIZE FOR UNKNOWN)").Delete(&email) DELETE from emails where id=10 OPTION (OPTIMIZE FOR UNKNOWN);

批量删除
删除所有匹配的记录

db.Where("email LIKE ?", "%jinzhu%").Delete(Email{}) DELETE from emails where email LIKE "%jinzhu%";db.Delete(Email{}, "email LIKE ?", "%jinzhu%") DELETE from emails where email LIKE "%jinzhu%";

软删除

如果模型中有 DeletedAt 字段，它将主动领有软删除的能力！当执行删除操作时，数据并不会永恒的从数据库中删除，而是将 DeletedAt 的值更新为以后工夫。
即：软删除时其实执行的是UPDATE语句。

db.Delete(&user) UPDATE users SET deleted_at="2013-10-29 10:23" WHERE id = 111;// 批量删除db.Where("age = ?", 20).Delete(&User{}) UPDATE users SET deleted_at="2013-10-29 10:23" WHERE age = 20;// 在查问记录时，软删除记录会被疏忽db.Where("age = 20").Find(&user) SELECT * FROM users WHERE age = 20 AND deleted_at IS NULL;// 应用 Unscoped 办法查找软删除记录db.Unscoped().Where("age = 20").Find(&users) SELECT * FROM users WHERE age = 20;// 应用 Unscoped 办法永恒删除记录db.Unscoped().Delete(&order) DELETE FROM orders WHERE id=10;

关联关系

Belongs To属于

belongs to 关联建设一个和另一个模型的一对一连贯，使得模型申明每个实例都「属于」另一个模型的一个实例。

例如，如果你的利用蕴含了用户和用户材料，并且每一个用户材料只调配给一个用户

type User struct {  gorm.Model  Name string}// `Profile` 属于 `User`， `UserID` 是外键type Profile struct {  gorm.Model  UserID int  User   User  Name   string}

外键

为了定义从属关系，外键是必须存在的，默认的外键应用所有者类型名称加上其主键。

像下面的例子，为了申明一个模型属于 User，它的外键应该为 UserID。

GORM 提供了一个定制外键的办法，例如:

type User struct {    gorm.Model    Name string}type Profile struct {    gorm.Model  Name      string  User      User `gorm:"foreignkey:UserRefer"` // 应用 UserRefer 作为外键 >> 给Profile调配User时，将user.id赋给UserRefer  UserRefer string}

关联外键

对于从属关系， GORM 通常应用所有者的主键作为外键值，在下面的例子中，就是 User 的 ID。

当你调配一个材料给一个用户， GORM 将保留用户表的 ID 值到用户材料表的 UserID 字段里。

你能够通过扭转标签 association_foreignkey 来扭转它，例如：

type User struct {    gorm.Model  Refer int    Name string}type Profile struct {    gorm.Model  Name      string  User      User `gorm:"association_foreignkey:Refer"` // use Refer 作为关联外键  UserRefer string}

注：关联外键和外键的区别：关联外键没必要是关联对象的主键；
gorm tag中的foreignkey，是指本对象中与关联对象主键绝对应的字段；association_foreignkey是值本对象和关联对象产生关联的关系字段，该字段肯定存在于关联对象中，指定后，在本对象中应存在名为“关联对象名 + 关联字段名”的字段。

Has One

has one 关联也是与另一个模型建设一对一的连贯，但语义（和后果）有些不同。此关联示意模型的每个实例蕴含或领有另一个模型的一个实例。

例如，如果你的应用程序蕴含用户和信用卡，并且每个用户只能有一张信用卡。

// 用户有一个信用卡，CredtCardID 外键type User struct {    gorm.Model    CreditCard   CreditCard  CreditCardID uint}type CreditCard struct {    gorm.Model    Number   string}

外键

对于一对一关系，一个外键字段也必须存在，所有者将保留主键到模型关联的字段里。

这个字段的名字通常由 belongs to model 的类型加上它的 primary key 产生的，就下面的例子而言，它就是 CreditCardID

当你给用户一个信用卡，它将保留一个信用卡的 ID 到 CreditCardID 字段中。

如果你想应用另一个字段来保留这个关系，你能够通过应用标签 foreignkey 来扭转它，例如：

type User struct {  gorm.Model  CreditCard CreditCard `gorm:"foreignkey:CardRefer"`  CardRefer uint}type CreditCard struct {    gorm.Model    Number string}

关联外键

通常，所有者会保留 belogns to model 的主键到外键，你能够改为保留其余字段，就像上面的例子应用 Number 。

type User struct {  gorm.Model  CreditCard CreditCard `gorm:"association_foreignkey:Number"`  CardRefer uint   // CardNumber string // ??}type CreditCard struct {    gorm.Model    Number string}

多态关联

反对多态的一对多和一对一关联。

 type Cat struct {    ID    int    Name  string    Toy   Toy `gorm:"polymorphic:Owner;"`  }  type Dog struct {    ID   int    Name string    Toy  Toy `gorm:"polymorphic:Owner;"`  }  type Toy struct {    ID        int    Name      string    OwnerID   int    OwnerType string  }

留神：多态属于和多对多是明确的不反对并将会抛出谬误。

应用一对一

你能够通过 Related 找到 has one 关联。

var card CreditCarddb.Model(&user).Related(&card, "CreditCard") SELECT * FROM credit_cards WHERE user_id = 123; // 123 是用户表的主键// CreditCard  是用户表的字段名，这意味着获取用户的信用卡关系并写入变量 card。// 像下面的例子，如果字段名和变量类型名一样，它就能够省略， 像：db.Model(&user).Related(&card)

一对多 Has Many

has many 关联就是创立和另一个模型的一对多关系，不像 has one，所有者能够领有 0 个或多个模型实例。

例如，如果你的利用蕴含用户和信用卡，并且每一个用户都领有多张信用卡。

// 用户有多张信用卡，UserID 是外键type User struct {    gorm.Model    CreditCards []CreditCard}type CreditCard struct {    gorm.Model    Number   string    UserID  uint}

外键

为了定义一对多关系，外键是必须存在的，默认外键的名字是所有者类型的名字加上它的主键。

就像下面的例子，为了定义一个属于 User 的模型，外键就应该为 UserID。

应用其余的字段名作为外键，你能够通过 foreignkey 来定制它，例如:

type User struct {    gorm.Model    CreditCards []CreditCard `gorm:"foreignkey:UserRefer"`}type CreditCard struct {    gorm.Model    Number    string      UserRefer uint}

外键关联

GORM 通常应用所有者的主键作为外键的值，在下面的例子中，它就是 User 的 ID。

当你调配信用卡给一个用户， GORM 将保留用户 ID 到信用卡表的 UserID 字段中。

你能通过 association_foreignkey 来扭转它，例如:

type User struct {    gorm.Model  MemberNumber string    CreditCards  []CreditCard `gorm:"foreignkey:UserMemberNumber;association_foreignkey:MemberNumber"`}type CreditCard struct {    gorm.Model    Number           string  UserMemberNumber string}

多态关联

反对多态的一对多和一对一关联。

type Cat struct {    ID    int    Name  string    Toy   []Toy `gorm:"polymorphic:Owner;"`  }  type Dog struct {    ID   int    Name string    Toy  []Toy `gorm:"polymorphic:Owner;"`  }  type Toy struct {    ID        int    Name      string    OwnerID   int    OwnerType string  }

应用一对多

你能够通过 Related 找到 has many 关联关系。

db.Model(&user).Related(&emails) SELECT * FROM emails WHERE user_id = 111; // 111 是用户表的主键

多对多 Many To Many

多对多为两个模型减少了一个两头表。

例如，如果你的利用蕴含用户和语言，一个用户会说多种语言，并且很多用户会说一种特定的语言。

装置

模型定义

构造标签

反对的构造标签

关联的构造标签

约定gorm.Model

ID 作为主键

复数表名

指定表名

批改默认表名

蛇形列名

工夫戳跟踪

CreatedAt

UpdatedAt

DeletedAt

反对的数据库

MySQL

PostgreSQL

Sqlite3

SQL Server

增删改查API

创立记录

默认值

在钩子中设置字段值

创立额定选项

查问

Where

Struct & Map

Not

Or

行内条件查问

额定的查问选项

FirstOrInit

Attrs

Assign

FirstOrCreate

高级查问

子查问

查问字段

Order

Limit

Offset

Count

分组查问Group 和 Having

指定关联条件Joins

Pluck

Scan

更新

只更新指定的字段

只选/只排除 更新的字段

更新列钩子办法

批量更新

在钩子函数中更新值

额定的更新选项

删除

软删除

关联关系

Belongs To属于

外键

关联外键

Has One

外键

关联外键

多态关联

应用一对一

一对多 Has Many

外键

外键关联

多态关联

应用一对多

多对多 Many To Many

只选/只排除更新的字段