Golang-Gorm-快速上手

Gorm文档

GORM文档地址

安装依赖

 go get -u "gorm.io/driver/mysql"go get -u "gorm.io/gorm"

连接数据库

默认连接方式

func main() {// 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}

想要正确的处理 time.Time ，需要带上 parseTime 参数， charset=utf8mb4可以支持表情

自定义配置连接数据库

	dsn := "root:root@tcp(127.0.0.1:3306)/learn_gorm?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.New(mysql.Config{DSN:                       dsn,   // DSN data source nameDefaultStringSize:         256,   // string 类型字段的默认长度 如果该字段是字符串并作为主键会造成索引超长DisableDatetimePrecision:  true,  // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持DontSupportRenameIndex:    true,  // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引DontSupportRenameColumn:   true,  // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列SkipInitializeWithVersion: false, // 根据当前 MySQL 版本自动配置}), &gorm.Config{ //连接的配置SkipDefaultTransaction: false, // 默认false，增删改都是事务操作来保证数据一致性，能提升一点性能NamingStrategy: schema.NamingStrategy{TablePrefix:         "",    // 如果设置了会给每个表名加前缀SingularTable:       false, // 单数表名，如果false会在表明后加sNameReplacer:        nil,   // 字符转转换器，转换字段名NoLowerCase:         false, //当设置为true时，NoLowerCase选项将禁用表名和列名的蛇形命名转换。保持表名和列名的原始大小写形式。IdentifierMaxLength: 0,     //不限制数据库标识符（如表名、列名）的最大长度。},Logger:                                   nil,  // 可以自定义日志DisableForeignKeyConstraintWhenMigrating: true, //true时，建表将不会建立物理外键，代码中我们采用逻辑外键提升数据库操作效率})

数据库连接池配置

sqlDB, err := db.DB()
// 设置最大连接数量
sqlDB.SetMaxIdleConns(10)// 连接池最多可容纳的连接数量
sqlDB.SetMaxOpenConns(100)// 连接池中连接最常生命周期
sqlDB.SetConnMaxLifetime(time.Hour)

数据库logger日志

Gorm 有一个 默认 logger 实现，默认情况下，它会打印慢 SQL 和错误， 我们可以定义自己的 logger，Logger 需要实现以下接口，它接受 context，所以可以用它来追踪日志

type Interface interface {LogMode(LogLevel) InterfaceInfo(context.Context, string, ...interface{})Warn(context.Context, string, ...interface{})Error(context.Context, string, ...interface{})Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}

_default := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), logger.Config{SlowThreshold: 200 * time.Millisecond,LogLevel:      logger.Warn,Colorful:      true,})

模型

Gorm认为约定优于配置，即通过一些默认约定来简化配置和操作数据库。它提供了许多默认行为和命名约定。
GORM中默认采用ID作为主键，结构体名的蛇形复数作为表名，字段名的蛇形作为列名字，并使用CreatedAt,UpdateAt字段追踪创建、更新时间。
例如：

type User struct {ID        uintFirstName stringLastName  stringEmail     stringCreatedAt time.TimeUpdatedAt time.Time
}
/*
据GORM的默认约定，上述结构体将映射到以下表结构：表名: users（结构体名User的蛇形复数）
列名: id（自动生成的主键列名）
列名: first_name（结构体字段FirstName的蛇形命名）
列名: last_name（结构体字段LastName的蛇形命名）
列名: email（结构体字段Email的蛇形命名）
列名: created_at（结构体字段CreatedAt的蛇形命名）
列名: updated_at（结构体字段UpdatedAt的蛇形命名）
*/

创建模型

创建模型文档地址

package modelsimport ("gorm.io/gorm"
)type User struct {gorm.ModelAvatar   string `json:"headerImg" gorm:"default:https://qmplusimg.henrongyi.top/gva_header.jpg;comment:用户头像"` // 用户头像Username string `json:"userName" gorm:"index;comment:用户登录名"`                                                  // 用户登录名Password string `json:"-"  gorm:"comment:用户登录密码"`                                                             // 用户登录密码NickName string `json:"nickName" gorm:"default:系统用户;comment:用户昵称"`                                            // 用户昵称Phone    string `json:"phone"  gorm:"comment:用户手机号"`                                                          // 用户手机号Email    string `json:"email"  gorm:"comment:用户邮箱"`                                                           // 用户邮箱Enable   int    `json:"enable" gorm:"default:1;comment:用户是否被冻结 1正常 2冻结"`                                      //用户是否被冻结 1正常 2冻结Roles    []Role `json:"Role" gorm:"many2many:user_role;"`
}
// 表名
func (User) TableName() string {return "users"
}

模型常用标签

声明 model 时，tag 是可选的，GORM 支持以下 tag： tag 名大小写不敏感，但建议使用 camelCase 风格

主键

type User struct {Username string `gorm:"primaryKey"`                                                  
}

指定列明

默认情况以蛇形结构体字段名作为列明，但我们也可以通过tag指定

type User struct {Username string `gorm:"column：name"`                                                  
}

唯一约束

不可重复字段。

type User struct {Username string `gorm:"unique"`

列数据类型

推荐使用兼容性好的通用类型，例如：所有数据库都支持 bool、int、uint、float、string、time、bytes 并且可以和其他标签一起使用，例如：not null、size, autoIncrement… 像 varbinary(8) 这样指定数据库数据类型也是支持的。在使用指定数据库数据类型时，它需要是完整的数据库数据类型，如：MEDIUMINT UNSIGNED not NULL AUTO_INCREMENT

type User struct {ID   uint   `gorm:"type:int(11)"`Name string `gorm:"type:varchar(255)"`Age  int    `gorm:"type:tinyint"`
}

默认值

type User struct {Role string `gorm:"default:user"`
}

当结构体的字段默认值是零值的时候比如 0, ‘’, false，这些字段值将不会被保存到数据库中，你可以使用指针类型或者Scanner/Valuer来避免这种情况。例如：

type User struct {gorm.ModelName stringAge  *int           `gorm:"default:18"`Active sql.NullBool `gorm:"default:true"`
}

指定字段数据类型长度大小

type User struct {Username string `gorm:"size:50"`
}

数据序列化或反序列化

type User struct {Settings map[string]interface{} `gorm:"serializer:json"`
}

serializer标签指定将Settings字段中的数据以JSON格式进行序列化和反序列化。

不能为空

type User struct {Settings map[string]interface{} `gorm:"not null"`
}

自增长

type User struct {ID uint `gorm:"primaryKey;autoIncrement"`
}

创建索引

type User struct {Email string `gorm:"index:idx_email"`Age   int    `gorm:"uniqueIndex:idx_age_country"`
}

在上述示例中，index标签创建名为idx_email的索引，uniqueIndex标签创建名为idx_age_country的唯一索引。

添加注释

type User struct {FirstName string `gorm:"comment:用户的名字"`
}

忽略字段

-标签表示忽略SecretField字段，即不进行数据库迁移和读写操作。

type User struct {SecretField string `gorm:"-"`
}

字段读写权限

<-:create表示只允许在创建时写入PasswordHash字段，->:false表示禁止读取PasswordHash字段。

type User struct {PasswordHash string `gorm:"<-:create;->:false"`
}

嵌入字段和嵌入字段列明前缀

type Address struct {City  stringState string
}type User struct {ID      uintAddress Address `gorm:"embedded;embeddedPrefix:user_"`
}

embedded标签用于指定Address字段作为嵌套字段，embeddedPrefix标签用于指定嵌入字段的列名前缀为user_。相当于如下

type User struct {ID      uintCity  stringState string
}
//建表后字段名为ID  user_city user_state

关联标签

GORM中的关联标签通常用于指定如何处理模型之间的关联。 这些标签定义了一些关系细节，比如外键，引用和约束。

标签描述
foreignKey指定连接表中用作外键的当前模型的列名。
references指示连接表的外键映射到的引用表中的列名
polymorphic定义多态类型，通常是模型名称。
polymorphicValue如果没有另行指定，则设置多态值，通常为表名。
many2many命名多对多关系中使用的连接表。
joinForeignKey标识连接表中映射回当前模型表的外键列。
joinReferences指向链接到参考模型表的连接表中的外键列
constraint为关联指定关系约束，如OnUpdate， OnDelete .

外键foreignKey

指定在关联表中使用的当前模型的列名作为外键。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字，对于如下的外键默认就是post_id

type User struct {ID       uintPostId int//foreignKey标签指定了在Post模型中使用UserID作为关联表的外键。Posts    []Post `gorm:"foreignKey:PostId"`
}type Post struct {ID     uint
}
重写外键

默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字。也就是company+id
例如：

type User struct {gorm.ModelName      stringCompanyId intCompany Company `gorm:"foreignKey:CompanyId"`
}
type Company struct {Name stringCode int `gorm:"primaryKey"`
}
// 我们创建数据
func main() {global.GVA_DB = initialize.GormMysql()if global.GVA_DB != nil {initialize.TableInit()}c := model.Company{Name: "A公司",Code: 111,}u := model.User{Name:    "张三",Company: c,}u.CreateUser()
}

结果如图所示：在这里插入图片描述
我们可以将外键名字company_id名字改了，通过如下方式

type User struct {gorm.ModelName      stringCompany_FK intCompany Company `gorm:"foreignKey:Company_FK "`
}
type Company struct {Name stringCode int `gorm:"primaryKey"`
}

在这里插入图片描述

引用references

指定在关联表中外键对应的引用表的列名。

type User struct {ID       uint//references标签指定了Post模型中UserID外键对应的引用表的列名为ID。Posts    []Post `gorm:"foreignKey:UserID;references:ID"`
}type Post struct {ID     uintUserID uint
}
重写引用

GORM 通常使用数据库表，主表（拥有者）的主键值作为外键参考。 正如上面的例子，我们使用主表Company中的主键字段ID作为外键的参考值。
但我们可以通过使用标签 references 来更改它。

type User struct {gorm.ModelName      stringCompanyId intCompany   Company `gorm:"foreignKey:CompanyId;references:Code"`
}type Company struct {gorm.ModelName stringCode int
}
// 我们创建数据
func main() {global.GVA_DB = initialize.GormMysql()if global.GVA_DB != nil {initialize.TableInit()}c := model.Company{Name: "A公司",Code: 111,}u := model.User{Name:    "张三",Company: c,}u.CreateUser()
}

可以看结果引用不再是以公司主键ID作为外键值了。在这里插入图片描述

多对多many2many

指定在多对多关系中使用的关联表。

type User struct {ID    uint//many2many标签指定了在User和Role之间使用的关联表为user_roles。Roles []Role `gorm:"many2many:user_roles;"`
}type Role struct {ID   uintName string
}

标识外键列joinForeignKey

标识在关联表中映射回当前模型的表的外键列。

type User struct {ID       uint//joinForeignKey标签指定了在关联表中映射回User模型的表的外键列为UserID。Posts    []Post `gorm:"many2many:user_posts;joinForeignKey:UserID;"`
}type Post struct {ID     uintUserID uint
}

数据库相关操作

创建表CreateTable/AutoMigrate

一般我们使用AutoMigrate去创建
方式一

	err := db.AutoMigrate(models.Permission{},models.User{},models.Role{},)

方式二

	m := db.Migrator()m.CreateTable([]interface{}{&models.Permission{},&models.User{},&models.Role{},})

两种方式没太大差别

查询表HasTable

m := db.Migrator()
//传参结构体引用
m.HasTable(&models.User{})// 返回bool值
//传参字符串，这种硬编码方式不推荐
m.HasTable("user")// 返回bool值

删除表DropTable

	m := db.Migrator()exist_table := m.HasTable(&models.User{})if exist_table {m.CreateTable(&models.User{})}else{m.DropTable(&models.User{})}

修改表名

m := db.Migrator()
err := m.RenameTable(&models.User{},"yu_user")

关联关系

一对一

在 GORM 中，“Belongs To” 和 “Has One” 是两种不同的关联关系类型，用于定义数据库表之间的关系。它们之间的区别主要在于关联关系的方向和外键的存储位置。
在 Belongs To 关系中，外键通常存储在被关联模型（子模型）中。
在 Has One 关系中，外键通常存储在拥有模型（父模型）中。

属于关系Belongs To

属于关系是一方依赖于另一方，无法独立存在。
例如，假设我们有两个模型：Author（作者）和 Book（书籍）。一个 Book 属于一个 Author，因此我们可以在 Book 模型中定义一个 author_id 字段作为外键，用于存储与其关联的 Author 的主键。
下面省略建表步骤，只关注模型

package modelimport "gorm.io/gorm"// `User` 属于 `Company`，`CompanyID` 是外键 该外键存放在被关联的模型User中。
type User struct {gorm.ModelName      stringCompanyID intCompany   Company //如果设置了User实体属于Company实体，那么GORM会自动把Company中的ID属性保存到User的CompanyID属性中。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字
}type Company struct {ID   intName stringCode string
}
func (this *User) CreateUser() {global.GVA_DB.Create(this)
}
func (this *Company) CreateCompany() {global.GVA_DB.Create(this)
}

在这里插入图片描述
然后我们创建数据

package mainimport ("fmt""relation/global""relation/initialize""relation/model"
)func main() {global.GVA_DB = initialize.GormMysql()if global.GVA_DB != nil {initialize.TableInit()}c := model.Company{Name: "A公司",Code: "AAA",}u := model.User{Name:    "张三",Company: c,}u.CreateUser()fmt.Println("数据库初始化成功")
}

观察表
在这里插入图片描述
我们并没有创建公司的数据，但是通过GORM自动关联我们可以看到公司这个表自动被创建了。

拥有Has One

拥有关系是一方包含另一方，可以独立存在。
拥有Has One表明一个模型的每个实例都包含或拥有另一个模型的一个实例。如果我们假设一个 User拥有一个 CreditCard （个人资料），我们可以在 User 模型中定义一个 CreditCard 字段作为外键，用于存储与其关联的 CreditCard 的主键。

// User 有一张 CreditCard，UserID 是外键
type User struct {gorm.ModelCreditCard CreditCard
}type CreditCard struct {gorm.ModelNumber stringUserID uint
}

一对多

不同于 has one，拥有者可以有零或多个关联模型。例如，每个 user 可以有多张 credit card。多的一方把另一方的主键作为外键。少的一方声明多的一方的数组切片类型。
一对多在多的一方存放外键

// User 有多张 CreditCard，UserID 是外键
type User struct {gorm.ModelCreditCards []CreditCard
}type CreditCard struct {gorm.ModelNumber stringUserID uint
}

查询

// 检索用户列表并预加载信用卡
func GetAll(db *gorm.DB) ([]User, error) {var users []Usererr := db.Model(&User{}).Preload("CreditCards").Find(&users).Errorreturn users, err
}

自引用

自己引用自己

type User struct {gorm.ModelName      stringManagerID *uintTeam      []User `gorm:"foreignkey:ManagerID"`
}

多对多

多对多需要中间表，在gorm中需要用关联标签，展示出关系。

// User 拥有并属于多种 language，`user_languages` 是连接表
type User struct {gorm.ModelName      stringLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName string
}

在这里插入图片描述
我们创建几个数据

	global.GVA_DB.Create([]model.User{model.User{Name: "张三",Languages: []model.Language{model.Language{Name: "英语",},model.Language{Name: "汉语",},},},model.User{Name: "李四",Languages: []model.Language{model.Language{Name: "德语",},model.Language{Name: "俄语",},},},})

观察表，在这里插入图片描述

反向引用

在上面创建表插入数据后，我们查询语言，看结果

var l []model.Language
global.GVA_DB.Select("name").Find(&l)
fmt.Println(l)

在这里插入图片描述
如果我们想查询语言关联的用户呢？

// 检索 Language 列表并预加载 User
func GetAllLanguages() ([]model.Language, error) {var languages []model.Languageerr := global.GVA_DB.Model(&model.Language{}).Preload("Users").Find(&languages).Errorreturn languages, err
}

此时会报错。
这时候我们需要反向引用，才能够在查询语言时预加载用户。那怎么反向引用呢？我们需要给Language表加上用户的引用，如下

type User struct {gorm.ModelName      stringLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName stringUsers []*User `gorm:"many2many:user_languages;"`
}

此时再执行上面的查询操作GetAllLanguages
在这里插入图片描述
就可以成功拿到结果了。
总结一下：选择哪种方式取决于具体的业务需求，如果需要在查询Language模型时方便地访问与之关联的User模型的数据，可以选择第二种方式。否则，如果只需要在查询User模型时访问与之关联的Language模型的数据，第一种方式已经足够。

重写外键

对于 many2many 关系，连接表会同时拥有两个模型的外键，例如：

type User struct {gorm.ModelLanguages []Language `gorm:"many2many:user_languages;"`
}type Language struct {gorm.ModelName string
}// 连接表：user_languages
//   foreign key: user_id, reference: users.id
//   foreign key: language_id, reference: languages.id

重写外键

type User struct {gorm.ModelName      stringLanguages []Language `gorm:"many2many:user_language;foreignKey:Refer;References:LRefer;joinForeignKey:u_id;joinReferences:p_id"`Refer     uint
}type Language struct {gorm.ModelName   stringLRefer uint
}

foreignKey:Refer：指定连接表中指向User模型的外键字段名为Refer的字段，且外键名字改为user_refer,默认是user_id(表名+主键字段名)。
joinForeignKey:UserReferID：改本表外键名。
References:UserRefer：指定连接表中指向Profile模型的外键字段名为LRefer的字段，且外键名改为language_l_refer(表名+主键字段名)。
joinReferences:ProfileRefer：改连接表外键名。
在这里插入图片描述

自定义中间表

type Person struct {ID        intName      stringAddresses []Address `gorm:"many2many:person_addresses;"`
}type Address struct {ID   uintName string
}type PersonAddress struct {PersonID  int `gorm:"primaryKey"`AddressID int `gorm:"primaryKey"`CreatedAt time.TimeDeletedAt gorm.DeletedAt
}func (PersonAddress) BeforeCreate(db *gorm.DB) error {// ...
}// 修改 Person 的 Addresses 字段的连接表为 PersonAddress
// PersonAddress 必须定义好所需的外键，否则会报错
err := db.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{})

表相关操作

排除和指定字段

通过select指定字段，如下是创建指定字段数据

	u := model.User{Name: "张三",Age:  18,}global.GVA_DB.Select("Age").Create(&u)

通过omit排除指定字段

var h model.Human
global.GVA_DB.Omit("name").Find(&h)

这样就得到了除了name字段以外的值。

增

type User struct {gorm.ModelName stringAge intBirthday time.Time
}
user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}result := db.Create(&user) // 通过数据的指针来创建user.ID             // 返回插入数据的主键
result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数

新增多条记录

方式一

users := []User{User{Name: "Jinzhu", Age: 18, Birthday: time.Now()},User{Name: "Jackson", Age: 19, Birthday: time.Now()},
}result := db.Create(&users) // 传递切片以插入多行数据u1 := model.User{Name:     "张三",Age:      18,Birthday: time.Now(),UserInfo: ui,Company:  c,}u2 := model.User{Name:     "李四",Age:      27,Birthday: time.Now(),UserInfo: ui,Company:  c,}global.GVA_DB.Create([]*model.User{&u1, &u2})result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数

方式二CreateBatchSize
使用CreateBatchSize 选项初始化GORM实例后，此后进行创建& 关联操作时所有的INSERT行为都会遵循初始化时的配置。

var users = []model.User{{Name: "jinzhu_1", Birthday: time.Now()}, {Name: "jinzhu_2", Birthday: time.Now()}, {Name: "jinzhu_10000", Birthday: time.Now()}}
global.GVA_DB.CreateInBatches(users, len(users))

在这里插入图片描述

sqlite批量插入不支持默认值

SQLite 不支持批量插入的时候使用默认值。解决方案：通过BeforeCreate钩子设置

func (p *Pet) BeforeCreate(tx *gorm.DB) (err error) {if p.Name == "" {p.Name = "cat"}
}

在这里插入图片描述

创建的声明周期钩子

GROM允许用户通过实现这些接口 BeforeSave, BeforeCreate, AfterSave, AfterCreate来自定义钩子。 这些钩子方法会在创建一条记录时被调用，关于钩子的生命周期请参阅Hooks。

func (u *User) BeforeCreate(tx *gorm.DB) (err error) {u.UUID = uuid.New()if u.Role == "admin" {return errors.New("invalid role")}return
}

如果想跳过Hooks方法，可以使用SkipHooks会话模式，例子如下

DB.Session(&gorm.Session{SkipHooks: true}).Create(&user)DB.Session(&gorm.Session{SkipHooks: true}).Create(&users)DB.Session(&gorm.Session{SkipHooks: true}).CreateInBatches(users, 100)

根据Map创建

创建记录不仅只有结构体的方式还能通过map创建，但不用的是**当使用map来创建时，钩子方法不会执行，关联不会被保存且不会回写主键。**因此最好使用结构体创记录。

db.Model(&User{}).Create([]map[string]interface{}{{"Name": "jinzhu_1", "Age": 18},{"Name": "jinzhu_2", "Age": 20},
})

关联创建

创建关联数据时，如果关联值非零，这些关联会被更新插入，并且它们的Hooks方法也会被调用。

type UserInfo struct {gorm.ModelAddress stringEmail   stringIPhone  stringUserId  uint
}
type User struct {gorm.ModelName     stringAge      int8Birthday time.TimeUserInfo  UserInfo
}ui := model.UserInfo{Address: "中国",Email:   "xxx@qq.com",IPhone:  "1234567",}u := model.User{Name:     "张三",Age:      18,Birthday: time.Now(),UserInfo: ui,}global.GVA_DB.Create(&u)

在这里插入图片描述

跳过关联更新

可以通过Select, Omit方法来跳过关联更新，示例如下：

db.Omit("UserInfo").Create(&user)// skip all associations
db.Omit(clause.Associations).Create(&user)

在这里插入图片描述

删除

改

查

preload预加载查询

模型

type UserInfo struct {gorm.ModelAddress stringEmail   stringIPhone  stringUserId  uint
}
type User struct {gorm.ModelName      stringAge       int8Birthday  time.TimeCompanyId intCompany   Company `gorm:"foreignKey:CompanyId;references:Code"`UserInfo  UserInfo
}
type Company struct {gorm.ModelName stringCode int
}

创建数据

	c := model.Company{Name: "A公司",Code: 111,}ui := model.UserInfo{Address: "中国",Email:   "xxx@qq.com",IPhone:  "1234567",}u1 := model.User{Name:     "张三",Age:      18,Birthday: time.Now(),UserInfo: ui,Company:  c,}u2 := model.User{Name:     "李四",Age:      27,Birthday: time.Now(),UserInfo: ui,Company:  c,}global.GVA_DB.Create([]*model.User{&u1, &u2})

查询

	var u model.Userglobal.GVA_DB.Select("name", "age").First(&u)fmt.Println(u)//此时查询结果

在这里插入图片描述

此时查询结果并没有关联表信息，如果需要查询关联表信息需要preload
preload查询

	var u model.Userglobal.GVA_DB.Preload("UserInfo").Preload("Company").First(&u)fmt.Println(u)

在这里插入图片描述

preload后面除了预加载的表还可以跟查询条件

	var u model.Userglobal.GVA_DB.Preload("UserInfo"，"address=中国").Preload("Company").First(&u)fmt.Println(u)//高级查询global.GVA_DB.Preload("UserInfo"，func(db *gorm.DB)*gorm.DB{return db.Joins("XXX").Where("xxx")}).Preload("Company").First(&u)

单个记录查询

GORM 提供了 First、Take、Last 方法，以便从数据库中检索单个对象。当查询数据库时它添加了 LIMIT 1 条件，且没有找到记录时，它会返回 ErrRecordNotFound 错误

// 获取第一条记录（主键升序）
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;result := db.First(&user)
result.RowsAffected // 返回找到的记录数
result.Error        // returns error or nil// 检查 ErrRecordNotFound 错误
errors.Is(result.Error, gorm.ErrRecordNotFound)

如果你想避免ErrRecordNotFound错误，你可以使用Find，比如db.Limit(1).Find(&user).对单个对象使用Find而不带limit，db.Find(&user)将会查询整个表并且只返回第一个对象，这是性能不高并且不确定的。

查询全部记录

var users_res []model.User
global.GVA_DB.Debug().Find(&users_res)
fmt.Println(users_res)
// SELECT * FROM `user` WHERE `user`.`deleted_at` IS NULLresult.RowsAffected // returns found records count, equals `len(users)`
result.Error        // returns error

条件查询

根据主键查询。

（使用字符串时，需要额外的注意来避免SQL注入）

db.First(&user, 10)
// SELECT * FROM users WHERE id = 10;
db.Find(&users, []int{1,2,3})
// SELECT * FROM users WHERE id IN (1,2,3);
字符串条件
db.Where("name = ?", "jinzhu").First(&user)
// SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;
查找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)
结构体、Map和切片条件查询
// Struct
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20;// Slice of primary keys
db.Where([]int64{20, 21, 22}).Find(&users)
// SELECT * FROM users WHERE id IN (20, 21, 22);

当使用结构体查询Gorm只会查询非零值字段（0,‘’,fasle），

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

如果查询条件中包含零值就使用Map查询

db.Where(map[string]interface{}{"Name": "jinzhu", "Age": 0}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 0;
find内联查询
// Get by primary key if it were a non-integer type
db.First(&user, "id = ?", "string_primary_key")
// SELECT * FROM users WHERE id = 'string_primary_key';
// ===如下
db.Where("id=?","string_primary_key").find(&user)// Plain SQL
db.Find(&user, "name = ?", "jinzhu")
// SELECT * FROM users WHERE name = "jinzhu";
// ===如下
db.Where("name=?","jinzhu").find(&user)db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20)
// SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;
// ===如下
db.Where("name <> ? AND age > ?","jinzhu", 20).find(&user)// Struct
db.Find(&users, User{Age: 20})
// SELECT * FROM users WHERE age = 20;
// ===如下
db.Where("age=?, 20).find(&user)// Map
db.Find(&users, map[string]interface{}{"age": 20})
// SELECT * FROM users WHERE age = 20;
Not查询DB.Not( )
db.Not("name = ?", "jinzhu").First(&user)
// SELECT * FROM users WHERE NOT name = "jinzhu" ORDER BY id LIMIT 1;// Not In
db.Not(map[string]interface{}{"name": []string{"jinzhu", "jinzhu 2"}}).Find(&users)
// SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");// Struct
db.Not(User{Name: "jinzhu", Age: 18}).First(&user)
// SELECT * FROM users WHERE name <> "jinzhu" AND age <> 18 ORDER BY id LIMIT 1;// Not In slice of primary keys
db.Not([]int64{1,2,3}).First(&user)
// SELECT * FROM users WHERE id NOT IN (1,2,3) ORDER BY id LIMIT 1;
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", Age: 18}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2", "age": 18}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);

查询记录的特定字段

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;

排序查询DB.Order( )

db.Order("age desc, name").Find(&users)
// SELECT * FROM users ORDER BY age desc, name;// Multiple orders
db.Order("age desc").Order("name").Find(&users)
// SELECT * FROM users ORDER BY age desc, name;db.Clauses(clause.OrderBy{Expression: clause.Expr{SQL: "FIELD(id,?)", Vars: []interface{}{[]int{1, 2, 3}}, WithoutParentheses: true},
}).Find(&User{})
// SELECT * FROM users ORDER BY FIELD(id,1,2,3)

偏移量limit 和offset

limit指定要检索的最大记录数 Offset指定在开始返回记录之前要跳过的记录数

db.Limit(10).Offset(5).Find(&users)
// SELECT * FROM users OFFSET 5 LIMIT 10;

去重Distinct

db.Distinct("name", "age").Order("name, age desc").Find(&results)

joins查询

type result struct {Name  stringEmail string
}db.Model(&User{}).Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&result{})
// SELECT users.name, emails.email FROM `users` left join emails on emails.user_id = users.idrows, 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)// multiple joins with parameter
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)

多态

在GORM中为一对多和多对多关系提供了多态支持。
什么是多态呢？同一类型不同表现形态。具体一点举个场景例子，有一个Human表和Animal表，还有一个tool工具表。我们想在Human和Tool表之间建立一对多或多对多关系以及Animal和tool表之间同样建立一对一或一对多关系。假设一对多，我不总不能在tool表中建立HumanId外键和AnimalId外键吧？那如果后面又加一个Alia的表需要和tool建立关系，难道要再加一个AliaId字段吗？
综上所述，我们可以在主表中添加如下关联标签

type Human struct {ID   intName stringTool []Tool`gorm:"polymorphic:Owner;"`
}
type Tool struct {ID        intName      stringOwnerID   intOwnerType string
}

然后执行下面语句添加点数据

db.Create(&Human {Name: "Human1", Tool: []Tool{{Name: "Tool1"}, {Name: "Tool2"}}})
db.Create(&model.Animal{Name: "Animal1", Tool: []model.Tool{{Name: "Tool1"}, {Name: "Tool2"}}})

观察数据库Tool
在这里插入图片描述

多态的关联标签

`gorm:"polymorphic:Owner;polymorphicValue:master"`

polymorphic：根据上面我们能看出来polymorphic字段其实就是指定多态字段的名字的。还用上面例子，我们把tool的polymorphic修改成PolymorphicOwner，并在tool中添加多态字段，看结果

type Human struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;"`
}
type Tool struct {ID                   intName                 stringPolymorphicOwnerID   intPolymorphicOwnerType string
}
type Animal struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;"`
}

在这里插入图片描述
polymorphicValue就是更改多态字段的值，我们添加如下标签看结果。

type Human struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;polymorphicValue:PhTool"`
}
type Tool struct {ID                   intName                 stringPolymorphicOwnerID   intPolymorphicOwnerType string
}
type Animal struct {ID   intName stringTool []Tool `gorm:"polymorphic:PolymorphicOwner;polymorphicValue:PhTool"`
}

在这里插入图片描述

利用Error.is判断错误

我们可以利用Error.is判断gorm报错信息，根据这个信息执行相应操作，例如

if !errors.Is(db.Where("username = ?", u.Username).First(&user).Error, gorm.ErrRecordNotFound) { // 判断用户名是否注册return userInter, errors.New("用户名已注册")
}assignErr := global.GVA_DB.Where("user_id = ? AND authority_authority_id = ?", id, authorityId).First(&system.SysUserAuthority{}).Errorif errors.Is(assignErr, gorm.ErrRecordNotFound) {return errors.New("该用户无此角色")}

事务

事务就是要么成功要么全部回滚。

开启事务

db.Transaction(func(tx *gorm.DB) error {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
})

嵌套事务

凡是调用db.Transaction的返回Error的事务内部全部回滚。

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(tx3 *gorm.DB) error {tx3.Create(&user3)return nil})return nil
})// Commit user1, user3

手动执行事务

db, _ := GLOV_DB.DB()
// 开始事务
tx := db.Begin()// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
tx.Create(...)// ...// 遇到错误时回滚事务
tx.Rollback()// 否则，提交事务
tx.Commit()

示例

func CreateAnimals(db *gorm.DB) error {//事务一旦开始，使用 tx 处理数据tx := db.Begin()defer func() {if r := recover(); r != nil {tx.Rollback()}}()if err := tx.Error; err != nil {return err}if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {tx.Rollback()return err}if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {tx.Rollback()return err}return tx.Commit().Error
}

事务保存点

有时候我们希望事务失败回滚时，不要回滚全部任务，从我们指定位置回滚，就可以使用保存点，然后回滚至保存点。
示例：

func CreateAnimals(db *gorm.DB) error {tx := db.Begin()defer func() {if r := recover(); r != nil {tx.RollbackTo("sp1")}}()if err := tx.Error; err != nil {return err}tx.Create(&user1)tx.SavePoint("sp1")tx.Create(&user2)return tx.Commit().Error
}

自定义数据类型

什么是自定义数据类型？有些类型的数据，无法直接存到数据库，例如结构体，map，这些数据不向string int等可以直接存，那怎么办呢？这就需要自定义数据类型。
自定义的数据类型必须实现 Scanner 和 Valuer 接口，以便让 GORM 知道如何将该类型接收、保存到数据库，Valuer让GORM知道如何存数据，Scanner让GORM知道如何取出来数据。
示例：

type user_info struct {Name stringAge  int
}
type User struct {gorm.ModelInfo user_info
}
db.AutoMigrate(&model.User{})

在这里插入图片描述
自定义数据类型：

type User_info struct {Name stringAge  int
}
type User struct {gorm.ModelInfo User_info
}func (this User_info) Value() (driver.Value, error) {str, err := json.Marshal(this)if err != nil {return nil, err}return string(str), nil
}
func (this *User_info) Scan(value interface{}) error {obj, ok := value.([]byte)if !ok {return errors.New("不匹配")}json.Unmarshal(obj, this)return nil
}global.GVA_DB.AutoMigrate(&model.User{})global.GVA_DB.Create(&model.User{Info: model.User_info{Name: "info_name", Age: 18},})

在这里插入图片描述
查询一下

	var u model.Userglobal.GVA_DB.Find(&u)fmt.Println(u)

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/779441.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Multisim14.0破解安装教程

Multisim14.0破解安装教程

Multisim14.0中文破解版是一款相当优秀的专业化SPICE仿真标准环境&#xff0c;Multisim14.0中文版功能强悍&#xff0c;为用户提供了所见即所得的设计环境、互动式的仿真界面、动态显示元件、具有3D效果的仿真电路、虚拟仪表、分析功能与图形显示窗口等等。Multisim破解版操作简…
阅读更多...
Docker命令及部署Java项目

Docker命令及部署Java项目

文章目录 简介Docker镜像镜像列表查找镜像拉取镜像删除镜像镜像标签 Docker容器容器启动容器查看容器停止和重启后台模式和进入强制停止容器清理停止的容器容器错误日志容器别名及操作 Docker部署Java项目 简介 Docker是一种容器化技术&#xff0c;可以帮助开发者轻松打包应用…
阅读更多...
【数据分析案列】--- 北京某平台二手房可视化数据分析

【数据分析案列】--- 北京某平台二手房可视化数据分析

一、引言 本案列基于北京某平台的二手房数据&#xff0c;通过数据可视化的方式对二手房市场进行分析。通过对获取的数据进行清冼&#xff08;至关重要&#xff09;&#xff0c;对房屋价格、面积、有无电梯等因素的可视化展示&#xff0c;我们可以深入了解北京二手房市场的特点…
阅读更多...
vue3+threejs新手从零开发卡牌游戏（十四）：调整卡组位置，添加玩家生命值HP和法力值Mana信息

vue3+threejs新手从零开发卡牌游戏（十四）：调整卡组位置，添加玩家生命值HP和法力值Mana信息

由于之前的卡组位置占了玩家信息的位置&#xff0c;所以这里将它调整到site区域&#xff1a; 修改game/site/p1.vue&#xff0c;在site右下角添加一个卡组区域&#xff1a; // 初始化己方战域 const init () > {let sitePlane scene.getObjectByName("己方战域Plan…
阅读更多...
CCSDS CONVOLUTIONAL CODING 卷积码 规范

CCSDS CONVOLUTIONAL CODING 卷积码 规范

文章目录 3 CONVOLUTIONAL CODING3.1 overview3.2 general3.2.1 ATTACHED SYNC MARKER3.2.2 DATA RANDOMIZATION3.2.3 FRAME VALIDATION3.2.4 QUANTIZATION 3.3 BASIC CONVOLUTIONAL CODE SPECIFICATION3.4 PUNCTURED CONVOLUTIONAL CODES matlab中的 comm.ConvolutionalEncode…
阅读更多...
pip永久修改镜像地址

pip永久修改镜像地址

修改命令&#xff1a; pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/ 效果&#xff1a; 会在C:\Users\PC(用户名)\AppData\Roaming\pip目录下新增或修改文件pip.ini 文件内容&#xff1a; [global] index-url https://pypi.tuna.tsinghua.e…
阅读更多...
4.模板-数组类封装

4.模板-数组类封装

文章目录 功能代码运行结果 功能 利用模板进行数组类封装&#xff0c;在代码实现过程中&#xff0c;使用了 1.operator重载&#xff0c;利用深拷贝防止浅拷贝问题&#xff1b; 2.operator[]重载&#xff0c;确保可以使用[]来仿真数组元素&#xff1b; 3.尾插法、尾删法、返回数…
阅读更多...
PyTorch深度学习

PyTorch深度学习

一、深度学习的概念 如上所示&#xff0c;人工智能包含了机器学习和深度学习&#xff0c;其中深度学习是机器学习的一种特殊的学习方法&#xff0c;人工智能的核心是深度学习 1、深度学习 深度学习需要用到大量的神经网络构建和运算模块&#xff0c;故出现了很多的深度学习框…
阅读更多...
Unity 窗口化设置

Unity 窗口化设置

在Unity中要实现窗口化&#xff0c;具体设置如下&#xff1a; 在编辑器中&#xff0c;选择File -> Build Settings。在Player Settings中&#xff0c;找到Resolution and Presentation部分。取消勾选"Fullscreen Mode"&#xff0c;并选择"Windowed"。设…
阅读更多...
数据库的横表和竖表

数据库的横表和竖表

先来看个图: 定义如下&#xff1a; 横表&#xff1a;在一行数据中包含了所有的属性&#xff0c;一行就代表了一个完整的实体 竖表&#xff1a;在一行中只存储一个实体的一个属性&#xff0c;多个行组合在一起才组成一个完整的属性适用场景&#xff1a; 横表&#xff1a;对查…
阅读更多...
（C++笔试题）选择题+编程题

（C++笔试题）选择题+编程题

个人主页&#xff1a;Lei宝啊 愿所有美好如期而遇 选择题 第一道 下面对析构函数的正确描述是&#xff08;&#xff09; A. 系统不能提供默认的析构函数B. 析构函数必须由用户定义C. 析构函数没有参数D. 析构函数可以设置默认参数 解析&#xff1a; 正确描述析构函数的…
阅读更多...
WebPack的使用及属性配、打包资源

WebPack的使用及属性配、打包资源

WebPack(静态模块打包工具)(webpack默认只识别js和json内容) WebPack的作用 把静态模块内容压缩、整合、转译等&#xff08;前端工程化&#xff09; 1️⃣把less/sass转成css代码 2️⃣把ES6降级成ES5 3️⃣支持多种模块文件类型&#xff0c;多种模块标准语法 export、export…
阅读更多...
GESP Python编程二级认证真题 2024年3月

GESP Python编程二级认证真题 2024年3月

Python 二级 2024 年 03 月 1 单选题&#xff08;每题 2 分&#xff0c;共 30 分&#xff09; 第 1 题 小杨的父母最近刚刚给他买了一块华为手表&#xff0c;他说手表上跑的是鸿蒙&#xff0c;这个鸿蒙是&#xff1f;&#xff08; &#xff09; A. 小程序 B. 计时器 C. 操作系统…
阅读更多...
Stable Diffusion之核心基础知识和网络结构解析

Stable Diffusion之核心基础知识和网络结构解析

Stable Diffusion核心基础知识和网络结构解析 一. Stable Diffusion核心基础知识1.1 Stable Diffusion模型工作流程1. 文生图(txt2img)2. 图生图3. 图像优化模块 1.2 Stable Diffusion模型核心基础原理1. 扩散模型的基本原理2. 前向扩散过程详解3. 反向扩散过程详解4. 引入Late…
阅读更多...
Java_20 元素和最小的山形三元组

Java_20 元素和最小的山形三元组

元素和最小的山形三元组 给你一个下标从 0 开始的整数数组 nums 。 如果下标三元组 (i, j, k) 满足下述全部条件&#xff0c;则认为它是一个 山形三元组 &#xff1a; i < j < knums[i] < nums[j] 且 nums[k] < nums[j] 请你找出 nums 中 元素和最小 的山形三元…
阅读更多...
【如何解决一些常见的 Composer 错误的保姆级讲解】

【如何解决一些常见的 Composer 错误的保姆级讲解】

&#x1f308;个人主页:程序员不想敲代码啊&#x1f308; &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家&#x1f3c6; &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提…
阅读更多...
ABAP AMDP 示例

ABAP AMDP 示例

AMDP 是HANA开发中的一种优化模式 按SAP的官方建议&#xff0c;在可以使用Open SQL实现需要的功能或优化目标的时候&#xff0c;不建议使用AMDP。而在需要使用Open SQL不支持的特性&#xff0c;或者是大量处理流和分析导致了数据库和应用服务器之间有重复的大量数据传输的情况…
阅读更多...
SiameseRPN原理详解（个人学习笔记）

SiameseRPN原理详解（个人学习笔记）

参考资源&#xff1a; 视觉目标跟踪SiamRPNSiameseRPN详解CVPR2018视觉目标跟踪之 SiameseRPN 目录&#xff09; 1. 模型架构1.1 Siamese Network1.2 RPN 2. 模型训练2.1 损失函数2.2 端到端训练2.3 正负样本选择 3. 跟踪阶段总结 SiamRPN是在SiamFC的基础上进行改进而得到的一…
阅读更多...
开源，微信小程序-超级计算器T3000 简介

开源，微信小程序-超级计算器T3000 简介

笔者于四年前自学微信小程序开发&#xff0c;这个超级计算器T3000就是当时的练习作品。超级计算器T3000的功能有很多&#xff0c;其中的核心技术是矩阵计算&#xff0c;使用的工具库是math.js&#xff0c;其次是复杂运算和分式运算。关于math.js的使用&#xff0c;可以参考另一…
阅读更多...
基于springboot的船舶维保管理系统

基于springboot的船舶维保管理系统

文章目录 项目介绍主要功能截图&#xff1a;部分代码展示设计总结项目获取方式 &#x1f345; 作者主页&#xff1a;超级无敌暴龙战士塔塔开 &#x1f345; 简介&#xff1a;Java领域优质创作者&#x1f3c6;、 简历模板、学习资料、面试题库【关注我&#xff0c;都给你】 &…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023