简介
引入 gorm 包
引入数据库驱动
连接数据库
数据库基本操作
SQL 语句直接操作数据库
GORM 方式操作数据库
1.判断某个表是否存在
2.删除表
3.修改表
Gorm 对数据库进行 CURD
查询 ★★★
Or条件
内联条件
排序
总数
扫描
下面我们在来看看这个删除操作
事务 Transaction

简介

GORM 是 Go 的一个极好的 ORM（Object Relational Mapping） 对象关系映射框架。

引入 gorm 包

import "github.com/jinzhu/gorm"

引入数据库驱动

//假如我们使用的是 mysql :
import _ "github.com/jinzhu/gorm/dialects/mysql"

连接数据库

package main

import (
    "fmt"

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

var DB *gorm.DB //后续用于操作数据库
func init() {
    //配置MySQL连接参数
    username := "root"       //账号
    password := "lyz"        //密码
    host := "43.138.224.118" //数据库地址，可以是Ip或者域名
    port := 3306             //数据库端口
    Dbname := "gorm"         //数据库名

    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)

    db, err := gorm.Open("mysql", dsn)
    if err != nil {
        panic("连接数据库失败, error=" + err.Error())
    }
    DB = db
}
func main() {

}

数据库基本操作

SQL 语句直接操作数据库

再进行操作MySQL数据库之前，劳烦各位铁子再先将数据库给建好，连接好数库后输入以下命令当然再这里博主的数据库名字就叫做gorm：

create database gorm;

假设我们需要再数据库里面键一张表，那么对应的建表的SQL语句为：

CREATE TABLE `users` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `username` varchar(30) NOT NULL COMMENT '账号',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `createtime` bigint(20) NOT NULL DEFAULT 0 COMMENT '创建时间',
   PRIMARY KEY (`id`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4

GORM 方式操作数据库

那么应用 GORM 定义表，它是这样的：

//定义User模型，绑定users表，ORM库操作数据库，
// 需要定义一个struct类型和MYSQL表进行绑定或者叫映射，struct字段和MYSQL表字段一一对应
type User struct {
    ID int64 // 主键

    //通过在字段后面的标签说明，定义golang字段和表字段的关系
    //例如 `gorm:"column:username"` 标签说明含义是: Mysql表的列名（字段名)为username
    Username string `gorm:"column:username"`
    Password string `gorm:"column:password"`

    //创建时间，时间戳
    CreateTime int64 `gorm:"column:createtime"`
}

当然这里需要说明一下，在这个 Gorm 当中默认是将ID字段做为主键，所以上面没显示如何指定某个字段为主键。

下面我们用Gorm 继续定义一张表，然后去数据库里面看一下这个情况是如何的：

package main

import (
    "fmt"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB //后续用于操作数据库

//User表 首先需要定义User模型，绑定users表，ORM库操作数据库，

// 需要定义一个 struct类型 和 MYSQL表 进行 绑定或者叫映射 ，struct字段和MYSQL表字段一一对应
type User struct {
    ID int64 // 主键
    //通过在字段后面的标签说明，定义golang字段和表字段的关系
    //例如 `gorm:"column:username"` 标签说明含义是: Mysql表的列名（字段名)为username
    Username string `gorm:"column:username"`
    Password string `gorm:"column:password"`
    //创建时间，时间戳
    CreateTime int64 `gorm:"column:createtime"`
}

func init() {
    //配置MySQL连接参数
    username := "root"       //账号
    password := "lyz"        //密码
    host := "43.138.224.118" //数据库地址，可以是Ip或者域名
    port := 3306             //数据库端口
    Dbname := "gorm"         //数据库名

    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)

    db, err := gorm.Open("mysql", dsn)
    if err != nil {
        panic("连接数据库失败, error=" + err.Error())
    }
    DB = db
}

func main() {
    //创建表
    DB.AutoMigrate(&User{}) //在这里传指针的原因是指针占用的空间少
}

AutoMigrate 用于自动迁移你的 schema，保持 schema 是最新的。该 API 会自动创建表、缺失的外键、约束、列和索引。
如果大小、精度、是否为空可以更改，则 AutoMigrate 会改变列的类型。
出于保护数据的目的，它不会删除未使用的列。
下面我们去数据库里面看看这个表是什么样子的
gorm - 图1

我们发现表的名字后面多了一个s，这也是这个Gorm的风格。

如果我们想要这个定义成我们想要的名字，有两种方法：
方法一：我们只需要给这个结构体添加一个 TableName()，对应如下：

func(u *User) TableName() string{
    return "user"//你希望他的名字是什么就填什么
}

方法二：使用下面的函数进行处理：

// 禁用默认表名的复数形式，如果置为 true，则 `User` 的默认表名是 `user`
DB.SingularTable(true)

当然Gorm还提供了自动默认的建表风格，我们可以将这个默认的表名前面或者后面添加一些字符也是可以的

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

除了上面这种方式来建表，还有这种方式也可以来建表。

DB.Table("USER").CreateTable(&User{})

除了建表当然还有判断某个表是否存在，删除表等操作，一起来看看吧感受gorm的强大之处

1.判断某个表是否存在

//第1种方法：
// 检查模型是否存在
db.HasTable(&User{})

//第2种方法：
// 检查表是否存在
db.HasTable("users")

2.删除表

// 删除表
//第1种方法：
db.DropTable(&User{})
//第2种方法：
db.DropTable("users")//

3.修改表

// 修改列(修改字段类型)
db.Model(&User{}).ModifyColumn("description", "text")

// 删除列
db.Model(&User{}).DropColumn("description")

下面说一下这个gorm当中结构体标签和数据库是怎么对应起来的：
gorm - 图2
关联相关标签（tags）
gorm - 图3

下面举几个例子来演示一下这个结构体tag标签在gorm当中的用法：
1。模型定义默认情况下，GORM 会使用 ID 作为表的主键。

type User struct {
  ID   string // 默认情况下，名为 `ID` 的字段会作为表的主键
  Name string
}

如果你当前的表主键不是 id 字段，那么你可以通过 primaryKey标签将其它字段设为主键：

// 将 `UUID` 设为主键
type Animal struct {
  ID     int64
  UUID   string `gorm:"primaryKey"`
  Name   string
  Age    int64
}

当然也可以有复合主键。

type Product struct {
  ID           string `gorm:"primaryKey"`
  LanguageCode string `gorm:"primaryKey"`
  Code         string
  Name         string
}

注意：默认情况下，整型(例如：int64 int32 int8 …) primaryKey 启用 autoIncrement ，要禁用它，铁子们需要为整型字段关闭 autoIncrement

type Product struct {
  CategoryID uint64 `gorm:"primaryKey;autoIncrement:false"`
  TypeID     uint64 `gorm:"primaryKey;autoIncrement:false"`
}

使用 GORM 通过在 struct 上定义自定义的 gorm 标签来实现自动化创建表的功能：

type User struct {
    Name string  `gorm:"size:255"`         //string默认长度255,size重设长度
    Age int `gorm:"column:my_age"`         //设置列名为my_age
    Num int  `gorm:"AUTO_INCREMENT"`     //自增
    IgnoreMe int `gorm:"-"`             //忽略字段
    Email string `gorm:"type:varchar(100);unique_index"` //type设置sql类型，unique_index为该列设置唯一索引
    Address string `gorm:"not null;unique"`              //非空
    No string `gorm:"index:idx_no"`                      //创建索引并命名，如果有其他同名索引，则创建组合索引
    Remark string `gorm:"default:''"`                      //默认值
}

定义好 struct模型之后，通过上面的建表语句就可以将我们定义的结构体和数据库中的表对应起来。

下面我们说一下这个默认模型：
GORM 定义一个 gorm.Model 结构体，其包括字段 ID、CreatedAt、UpdatedAt、DeletedAt。其结构如下：

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

如果铁子们觉得上面这几个字段名都是我们想要的，那么完全可以在铁子你的模型中直接引入(有人叫：内嵌)它：

type User struct {
    gorm.Model    //直接内嵌 gorm.Model结构体

    //然后下面继续扩展自己需要的：
    Id    int64  `json:"id"`
    Name  string `json:"name"`
    Age   int32  `json:"age"`
    Sex   int8   `json:"sex"`
    Phone string `json:"phone"`
}

最后我们看看关于 User数据库最高级别的默认操作：时间戳。

例如：我们建的User表又增加了 CreatedAt，UpdatedAt，DeletedAt 这三个字段。

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

db.Create(&User) // `CreatedAt`字段将会是当前时间

// 可以使用`Update`方法来改变`CreateAt`的值
db.Model(&User).Update("CreatedAt", time.Now())

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

db.Save(&User) // `UpdatedAt`将会是当前时间

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

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

Gorm 对数据库进行 CURD

CRUD 通常指数据库的增删改查操作。

SofTool.CN Notes:
C Create 创建
D Delete 删除
U Update 更新，也就是修改
R Read 读，也就是 Query 查询

本文详细介绍了如何使用 GORM 实现创建、查询、更新和删除操作。

本文中的 DB 变量为 *gorm.DB 对象。

下面我们从这个最简单的开始，往数据库里面插入一条数据：

package main

import (
    "fmt"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB //后续用于操作数据库

type User struct {
    ID   int64
    Name string `gorm:"default:'小王子'"` //我们不填的默认值
    Age  int64
}

func (u *User) TableName() string {
    return "user" //你希望他的名字是什么就填什么
}

func init() {
    //配置MySQL连接参数
    username := "root"       //账号
    password := "lyz"        //密码
    host := "43.138.224.118" //数据库地址，可以是Ip或者域名
    port := 3306             //数据库端口
    Dbname := "gorm"         //数据库名
    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)
    db, err := gorm.Open("mysql", dsn)
    if err != nil {
        panic("连接数据库失败, error=" + err.Error())
    }
    DB = db
}

func main() {
    DB.AutoMigrate(&User{})

    //?
    user := User{Name: "ksy", Age: 18}
    DB.NewRecord(user) // 主键为空返回`true`
    DB.Create(&user)   // 创建`user`，向数据库插入一条数据
    DB.NewRecord(user) // 创建`user`后返回`false`
}

gorm - 图4
我们发现这个数据库里面的数据确实是我们设置的。
当然我们也可以选择性的插入这个字段。
1.选择性插入值

func main() {
    user := User{ID: 2, Name: "kuangsiyuan", Age: 12}
    DB.Select("id", "name").Create(&user)
}

对应数据库情况。
gorm - 图5
2.忽略字段

func main() {
    user := User{ID: 3, Name: "kuangsiyuan", Age: 12}
    DB.Omit("name").Create(&user)
}

gorm - 图6
我们发现确实这个Name字段使用了默认值，也就是忽略了它。

3.使用 Map创建

DB.Model(&User{}).Create(map[string]interface{}{
  "Name": "jinzhu", "Age": 18,
})

// batch insert from `[]map[string]interface{}{}`
//批量插入
DB.Model(&User{}).Create([]map[string]interface{}{
  {"Name": "jinzhu_1", "Age": 18},
  {"Name": "jinzhu_2", "Age": 20},
})

最后说一下这个默认值这里有一个小小的坑：通过tag定义字段的默认值，在创建记录时候生成的 SQL 语句会排除没有值或值为零值的字段。在将记录插入到数据库后，Gorm会从数据库加载那些字段的默认值。
什么意思呢？下面我们来使用一个例子解释一下

func main() {
    user:=User{ID: 4,Name: "",Age: 20}
    DB.Create(&user)
}

在这里我们插入的这个值为这个””，我们想要他插入的值是这个但是结果真的是我们想要的吗？我们执行一下然后再去数据库里面查看
gorm - 图7
我们发现他使用的是这个默认值，但是如果我们就是想要插入这个””字符串这个时候该怎么办了？此时可以考虑使用指针或实现 Scanner/Valuer接口，比如：
使用指针

// 使用指针
type User struct {
  ID   int64
  Name *string `gorm:"default:'小王子'"`
  Age  int64
}
user := User{Name: new(string), Age: 18))}
db.Create(&user)  // 此时数据库中该条记录name字段的值就是''

在这里给出伪代码，就不一个一个实验了铁子们可以下来实验一下。

2.使用Scanner/Valuer接口方式实现零值存入数据库

// 使用 Scanner/Valuer
type User struct {
    ID int64
    Name sql.NullString `gorm:"default:'小王子'"` // sql.NullString 实现了Scanner/Valuer接口
    Age  int64
}
user := User{Name: sql.NullString{"", true}, Age:18}
db.Create(&user)  // 此时数据库中该条记录name字段的值就是''

当然我们也可以使用这个 原生的sql语句 来进行这个插入操作

    DB.Exec("insert into users (username,password,createtime) values (?,?,?)", user.Username, user.Password, user.CreateTime)

查询 ★★★

下面我们来看看这个查询数据的操作：

// 根据主键查询第一条记录
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;

// 查询所有的记录 这里users定义的是数组 users[]
db.Find(&users)
 //相当于: SELECT * FROM users;

// 查询指定的某条记录(仅当主键为整型时可用)
db.First(&user, 10)
 //相当于: SELECT * FROM users WHERE id = 10;

下面我们演示一个就可以了，这些都比较容易懂。

func main() {
     var user User
     DB.First(&user)//注意需要传递指针否则无法赋值
     fmt.Printf("the user is %#v",user)
}

func main() {
    var user User
    DB.First(&user) //注意需要传递指针否则无法赋值
    fmt.Printf("the user is %#v\n", user)
    var users = make([]*User, 10)
    DB.Find(&users)
    fmt.Printf("the users is %#v\n", users)
}

当 First、Last、Take 方法找不到记录时，GORM 会返回 ErrRecordNotFound 错误，可以通过对比 gorm.ErrRecordNotFound 进行判断，或者使用 Find 和 Limit 的组合进行查询。

db.Limit(1).Find(&user)

下面我们看看这个 Where 条件的 SQL查询

// Get first matched record
db.Where("name = ?", "jinzhu").First(&user)
 //相当于: SELECT * FROM users WHERE name = 'jinzhu' limit 1;

// Get all matched records
db.Where("name = ?", "jinzhu").Find(&users)
 //相当于: SELECT * FROM users WHERE name = 'jinzhu';

// <>
db.Where("name <> ?", "jinzhu").Find(&users)
 //相当于: SELECT * FROM users WHERE name <> 'jinzhu';

// IN
db.Where("name IN (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)
 //相当于: SELECT * FROM users WHERE name in ('jinzhu','jinzhu 2');

// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)
 //相当于: SELECT * FROM users WHERE name LIKE '%jin%';

// AND
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
 //相当于: SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;

// Time
db.Where("updated_at > ?", lastWeek).Find(&users)
 //相当于: SELECT * FROM users WHERE updated_at > '2000-01-01 00:00:00';

// BETWEEN
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
 //相当于: SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

这个非常的容易懂，同样博主也只演示一下：


func main() {
    var user User

    DB.Where("id=?", 1).First(&user)

    fmt.Printf("the user is %v", user)
}

当然我们可以选择性返回某些字段的值


func main() {
    var user User

    DB.Debug().Select("id,name").Where("id=?", 2).First(&user)

    fmt.Printf("the user is %#v", user)

}

这个Debug可以将这个sql语句给打印出来，方便我们进行dbug。

下面我们看看几个特殊的 Struct & Map 查询：

// Struct
db.Where(&User{Name: "ksy", Age: 20}).First(&user)
 //相当于: SELECT * FROM users WHERE name = "ksy" AND age = 20 LIMIT 1;

// Map
db.Where(map[string]interface{}{"name": "ksy", "age": 20}).Find(&users)
 //相当于: SELECT * FROM users WHERE name = "ksy" AND age = 20;

// 主键的切片
db.Where([]int64{20, 21, 22}).Find(&users)
 //相当于: SELECT * FROM users WHERE id IN (20, 21, 22)

提示：当通过结构体进行查询时，GORM将会只通过非零值字段查询，这意味着如果你的字段值为0，‘’，false或者其他零值时，将不会被用于构建查询条件，这个地方很多铁子可能就会踩这个坑。
我们可以使用指针或实现 Scanner/Valuer 接口来避免这个问题，和那个插入是一样的在这里就不演示了

Or条件

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
 //相当于: SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';

// Struct
db.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2"}).Find(&users)
 //相当于: SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';

// Map
db.Where("name = 'ksy'").Or(map[string]interface{}{"name": "ksy 2"}).Find(&users)
 //相当于: SELECT * FROM users WHERE name = 'ksy' OR name = 'ksy 2';

内联条件

// 根据主键获取记录 (只适用于整形主键)
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;

// Plain SQL
db.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;

// Struct
db.Find(&users, User{Age: 20})
 //相当于: SELECT * FROM users WHERE age = 20;

// Map
db.Find(&users, map[string]interface{}{"age": 20})
 //相当于: SELECT * FROM users WHERE age = 20;

下面我们在看看这个如果未找到，赋给它指定的值：

// 未找到
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}

下面我们看几个这个高级查询来看看
首先第一个字查询

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

排序

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)

总数

Count，该 model 能获取的记录总数。

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;

db.Table("deleted_users").Select("count(distinct(name))").Count(&count)
 SELECT count( distinct(name) ) FROM deleted_users; (count)

扫描

type Result struct {
  Name string
  Age  int
}

var result Result
db.Table("users").Select("name, age").Where("name = ?", "Antonio").Scan(&result)

var results []Result
db.Table("users").Select("name, age").Where("id > ?", 0).Scan(&results)

// 原生 SQL
db.Raw("SELECT name, age FROM users WHERE name = ?", "Antonio").Scan(&result)

查询看完了之后我们来看看这个更新
Save()默认会更新该对象的所有字段，即使你没有赋值。

db.First(&user)

user.Name = "七米"
user.Age = 99
db.Save(&user)

如果你只希望更新指定字段，可以使用Update或者Updates

// 更新单个属性，如果它有变化
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, "active": false})
 UPDATE users SET name='hello', age=18, active=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;

// 警告：当使用 struct 更新时，GORM只会更新那些非零值的字段
// 对于下面的操作，不会发生任何更新，"", 0, false 都是其类型的零值
db.Model(&user).Updates(User{Name: "", Age: 0, Active: false})

如果想要选定字段更新

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

下面我们在来看看这个删除操作

警告删除记录时，请确保主键字段有值，GORM 会通过主键去删除记录，如果主键为空，GORM 会删除该 model 的所有记录。

// 删除现有记录
db.Delete(&email)
 DELETE from emails where id=10;

// 为删除 SQL 添加额外的 SQL 操作
db.Set("gorm:delete_option", "OPTION (OPTIMIZE FOR UNKNOWN)").Delete(&email)
 DELETE from emails where id=10 OPTION (OPTIMIZE FOR UNKNOWN);

注意如果有这个DeleteAt字段那么是这个软删除，如果我们想要真正的删除，我们需要这个使用Unscope

// Unscoped 方法可以物理删除记录
DB.Unscoped().Delete(&order)
 DELETE FROM orders WHERE id=10;

事务 Transaction

1.自动事务

db.Transaction(func(tx *gorm.DB) error {
  // 在事务中执行一些 db 操作（从这里开始，铁子们应该使用 'tx' 而不是 'db'）
  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
    // 返回任何错误都会回滚事务
    return err
  }
  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
    return err
  }
  // 返回 nil 提交事务
  return nil
})

2.嵌套事务
GORM 支持嵌套事务，您可以回滚较大事务内执行的一部分操作，例如：

db.Transaction(func(tx *gorm.DB) error {
  tx.Create(&user1)

  tx.Transaction(func(tx2 *gorm.DB) error {
    tx2.Create(&user2)
    return errors.New("rollback user2") // Rollback user2
  })

  tx.Transaction(func(tx2 *gorm.DB) error {
    tx2.Create(&user3)
    return nil
  })

  return nil
})

3.手动事务

// 开始事务
tx := db.Begin()

// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
tx.Create(...)

// ...

// 遇到错误时回滚事务
tx.Rollback()

// 否则，提交事务
tx.Commit()

来源:
作者：一个山里的少年
链接：https://blog.csdn.net/qq_56999918/article/details/129113156

gorm

简介