golang Gorm框架讲解
目录
- 1.gorm介绍
- 1.1介绍
- 1.2安装
- 2.使用
- 2.1创建表
- 2.2.添加数据
- 2.3.查询数据
- 2.4更新数据
- 2.5删除数据
- 2.6执行原生sql
- 3.一对一
- 3.1创建表
- 3.2多态关联
- 3.3外键约束
- 4.一对多
- 5.多对多
- 6.获取多表数据
1.gorm介绍
1.1介绍
全功能 ORM 关联 (Has One，Has Many，Belongs To，Many To Many，多态，单表继承) Create，Save，Update，Delete，Find 中钩子方法 支持 Preload、Joins 的预加载 事务，嵌套事务，Save Point，Rollback To Saved Point Context，预编译模式，DryRun 模式 批量插入，FindInBatches，Find/Create with Map，使用 SQL 表达式、Context Valuer 进行 CRUD SQL 构建器，Upsert，数据库锁，Optimizer/Index/Comment Hint，命名参数，子查询 复合主键，索引，约束 Auto Migration 自定义 Logger 灵活的可扩展插件 API：Database Resolver（多数据库，读写分离）、Prometheus… 每个特性都经过了测试的重重考验 开发者友好
1.2安装
go get -u gorm.io/gorm go get -u gorm.io/driver/sqlite
2.使用
2.1创建表
package main
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
//模型结构
type Student struct {
Id int
Name string
Age int
}
type User struct {
gorm.Model
Name string `gorm:"type:varchar(20);not null"`
Telephone string `gorm:"varchar(110;not null;unique"`
Password string `gorm:"size:255;not null"`
}
func main() {
//使用dsn连接到数据库，grom自带的数据库池
//账号:密码@连接方式(ip地址:端口号)/数据库？语言方式，时区（未设置时区的话采用8小时制度）
dsn := "root:mysql@tcp(127.0.0.1:3306)/gotest?charset=utf8mb4&parseTime=True&loc=Local"
conn, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) //使用mysq连接数据库，第二个参数可以增加更多的配置(可有可无)
if err != nil {
fmt.Println(err)
}
conn.AutoMigrate(&Student{}) //创建表?判断是否表结构存在
}
//多表创建
db.AutoMigrate(&Company{}, &Worker{})
2.2.添加数据
stu := &Student{
Id: 3,
Name: "li333",
Age: 30,
}
res := conn.Create(stu) //向数据库中插入数据 ，它的返回值只有一个类型，没有error类型
//注：如果上面写成stu := Student{...}，则这里写成Create(&stu)
if res.Error != nil { //判断是否插入数据出错
fmt.Println(res.Error)
}
2.3.查询数据
var student Student
//查询First查询一条
conn.First(&student)
fmt.Println(student)
fmt.Println(student.Id)
//条件查询
res := conn.First(&student, "name=? and id=?", "yang", 1)
fmt.Println(res)
//查询所有 Find
var stu []Student
conn.Table("students").Find(&stu)
for _, v := range stu {
fmt.Println(v.Name)
}
// IN
var students []Student
conn.Table("students").Where("name IN ?", []string{"abc", "bili"}).Find(&students)
fmt.Println(students)
// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)
// AND
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
// Time
db.Where("updated_at > ?", time.Date(2022,05,20,0,0,0,0,&time.Location{})).Find(&users)
// BETWEEN
db.Where("created_at BETWEEN ? AND ?", time.Date(2022,05,20,0,0,0,0,&time.Location{}), time.Now()).Find(&users)
2.4更新数据
//更新数据
conn.Table("students").Where("id=?", 1).Update("name", "ttt")
conn.Table("students").Where("id=?", 2).Updates(&Student{Name: "bili", Age: 10})
//按主键更新，传入结构体对象，根据对应主键更新相应内容
dbConn.Table("user").Save(&user1)
2.5删除数据
conn.Table("students").Where("id=?", 1).Delete(&Student{})
2.6执行原生sql
conn.Raw("select * from students where id=?", 3).Scan(&student)
fmt.Println(student)
db.Exec("DROP TABLE users")
db.Exec("UPDATE orders SET shipped_at=? WHERE id IN ?", time.Now(), []int64{1,2,3})
3.一对一
3.1创建表
package main
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
type User struct {
gorm.Model
CreditCard CreditCard
Name string
}
type CreditCard struct {
gorm.Model
Number string
UserID uint
}
func main() {
//使用dsn连接到数据库，grom自带的数据库池
//账号:密码@连接方式(ip地址:端口号)/数据库？语言方式，时区（未设置时区的话采用8小时制度）
dsn := "root:mysql@tcp(127.0.0.1:3306)/crow?charset=utf8mb4&parseTime=True&loc=Local"
conn, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) //使用mysq连接数据库，第二个参数可以增加更多的配置(可有可无)
if err != nil {
fmt.Println(err)
}
conn.AutoMigrate(&User{})
conn.AutoMigrate(&CreditCard{})
//创建表?判断是否表结构存在
user := &User{
Name: "李四",
}
conn.Create(user)
card := &CreditCard{
Number: "123",
UserID: 1,
}
conn.Create(card)
}
3.2多态关联
//多态关联
//GORM 为 has one 和 has many 提供了多态关联支持，它会将拥有者实体的表名、主键值都保存到多态类型的字段中。
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
}
db.Create(&Dog{Name: "dog1", Toy: Toy{Name: "toy1"}})
// INSERT INTO `dogs` (`name`) VALUES ("dog1")
// INSERT INTO `toys` (`name`,`owner_id`,`owner_type`) VALUES ("toy1","1","dogs")
3.3外键约束
你可以通过为标签 constraint 配置 OnUpdate、OnDelete 实现外键约束，在使用 GORM 进行迁移时它会被创建，例如：
type User struct {
gorm.Model
Name string
CompanyID int
Company Company `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}
type Company struct {
ID int
Name string
}
4.一对多
Has Many
has many 与另一个模型建立了一对多的连接。 不同于 has one，拥有者可以有零或多个关联模型。
例如，您的应用包含 user 和 credit card 模型，且每个 user 可以有多张 credit card。
// User 有多张 CreditCard，UserID 是外键
type User struct {
gorm.Model
CreditCards []CreditCard
}
type CreditCard struct {
gorm.Model
Number string
UserID uint
}
package main
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
type User struct {
gorm.Model
MemberNumber string `gorm:"varchar(110;not null;unique"`
CreditCards []CreditCard `gorm:"foreignKey:UserNumber;references:MemberNumber"`
Name string
}
type CreditCard struct {
gorm.Model
Number string
UserNumber string `gorm:"varchar(110;not null;unique"`
}
func main() {
//使用dsn连接到数据库，grom自带的数据库池
//账号:密码@连接方式(ip地址:端口号)/数据库？语言方式，时区（未设置时区的话采用8小时制度）
dsn := "root:mysql@tcp(127.0.0.1:3306)/crow?charset=utf8mb4&parseTime=True&loc=Local"
conn, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) //使用mysq连接数据库，第二个参数可以增加更多的配置(可有可无)
if err != nil {
fmt.Println(err)
}
conn.AutoMigrate(&User{}, &CreditCard{})
user := User{
Name: "ttt3",
MemberNumber: "1003",
}
conn.Create(&user)
card := CreditCard{
Number: "111",
UserNumber: user.MemberNumber,
}
conn.Create(&card)
}
5.多对多
Many To Many
Many to Many 会在两个 model 中添加一张连接表。
例如，您的应用包含了 user 和 language，且一个 user 可以说多种 language，多个 user 也可以说一种 language。
// User 拥有并属于多种 language，`user_languages` 是连接表
type User struct {
gorm.Model
Languages []Language `gorm:"many2many:user_languages;"`
}
type Language struct {
gorm.Model
Name string
}
当使用 GORM 的 AutoMigrate 为 User 创建表时，GORM 会自动创建连接表
反向引用
// User 拥有并属于多种 language，`user_languages` 是连接表
type User struct {
gorm.Model
Languages []*Language `gorm:"many2many:user_languages;"`
}
type Language struct {
gorm.Model
Name string
Users []*User `gorm:"many2many:user_languages;"`
}
重写外键
对于 many2many 关系，连接表会同时拥有两个模型的外键，例如：
type User struct {
gorm.Model
Languages []Language `gorm:"many2many:user_languages;"`
}
type Language struct {
gorm.Model
Name string
}
// Join Table: user_languages
// foreign key: user_id, reference: users.id
// foreign key: language_id, reference: languages.id
若要重写它们，可以使用标签 foreignKey、reference、joinforeignKey、joinReferences。当然，您不需要使用全部的标签，你可以仅使用其中的一个重写部分的外键、引用。
type User struct {
gorm.Model
Profiles []Profile `gorm:"many2many:user_profiles;foreignKey:Refer;joinForeignKey:UserReferID;References:UserRefer;JoinReferences:UserRefer"`
Refer uint
}
type Profile struct {
gorm.Model
Name string
UserRefer uint
}
// 会创建连接表：user_profiles
// foreign key: user_refer_id, reference: users.refer
// foreign key: profile_refer, reference: profiles.user_refer
自引用 Many2Many
自引用 many2many 关系
type User struct {
gorm.Model
Friends []*User `gorm:"many2many:user_friends"`
}
// 会创建连接表：user_friends
// foreign key: user_id, reference: users.id
// foreign key: friend_id, reference: users.id
6.获取多表数据
预加载
GORM 允许在 Preload 的其它 SQL 中直接加载关系，例如：
type User struct {
gorm.Model
Username string
Orders []Order
}
type Order struct {
gorm.Model
UserID uint
Price float64
}
// 查找 user 时预加载相关 Order
db.Preload("Orders").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4);
db.Preload("Orders").Preload("Profile").Preload("Role").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
// SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
// SELECT * FROM roles WHERE id IN (4,5,6); // belongs to
Joins 预加载
Preload 在一个单独查询中加载关联数据。而 Join Preload 会使用 inner join 加载关联数据，例如：
db.Joins("Company").Joins("Manager").Joins("Account").First(&user, 1)
db.Joins("Company").Joins("Manager").Joins("Account").First(&user, "users.name = ?", "jinzhu")
db.Joins("Company").Joins("Manager").Joins("Account").Find(&users, "users.id IN ?", []int{1,2,3,4,5})
注意
Join Preload适用于一对一的关系，例如：has one,belongs to
预加载全部
与创建、更新时使用 Select 类似，clause.Associations 也可以和 Preload 一起使用，它可以用来 预加载 全部关联，例如：
type User struct {
gorm.Model
Name string
CompanyID uint
Company Company
Role Role
}
db.Preload(clause.Associations).Find(&users)
带条件的预加载
GORM 允许带条件的 Preload 关联，类似于内联条件
// 带条件的预加载 Order
db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4) AND state NOT IN ('cancelled');
db.Where("state = ?", "active").Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
// SELECT * FROM users WHERE state = 'active';
// SELECT * FROM orders WHERE user_id IN (1,2) AND state NOT IN ('cancelled');
自定义预加载 SQL
您可以通过 func(db *gorm.DB) *gorm.DB 实现自定义预加载 SQL，例如：
db.Preload("Orders", func(db *gorm.DB) *gorm.DB {
return db.Order("orders.amount DESC")
}).Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4) order by orders.amount DESC;
嵌套预加载
GORM 支持嵌套预加载，例如：
db.Preload("Orders.OrderItems.Product").Preload("CreditCard").Find(&users)
// 自定义预加载 `Orders` 的条件
// 这样，GORM 就不会加载不匹配的 order 记录
db.Preload("Orders", "state = ?", "paid").Preload("Orders.OrderItems").Find(&users)
到此这篇关于golang Gorm框架的文章就介绍到这了,更多相关golang Gorm框架内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
golang-gorm自动建表问题
目录 golang-gorm自动建表 定义结构体 定义变化的表名 实现interface 执行sql 判断是否有无 GORM概述 概述 快速入门 总结 golang-gorm自动建表 定义结构体 设置主键.自增.和独立索引 联合索引用addindex type User struct { //通过在字段后面的标签说明,定义golang字段和表字段的关系 //例如 `gorm:"column:username"` 标签说明含义是: Mysql表的列名(字段名)为usern
-
详解如何利用GORM实现MySQL事务
目录 前言 禁用默认事务 自动事务 手动事务 嵌套事务 SavePoint.RollbackTo 小结 前言 为了确保数据一致性,在项目中会经常用到事务处理,回滚操作还是比较常见的需求:事务处理可以用来维护数据库的完整性,保证成批的sql语句要么全部都执行,要么全不执行,对于MySQL事务相信大家应该都不陌生,这篇文章主要总结一下在Go语言中Gorm是如何实现事务的:感兴趣的小伙伴们可以参考借鉴,希望对大家能有所帮助. 禁用默认事务 gorm事务默认是开启的.为了确保数据一致性,Gorm会在事务
-
golang gorm 结构体的表字段缺省值设置方式
我就废话不多说了,大家还是直接看代码吧~ type Animal struct { ID int64 Name string `gorm:"default:'galeone'"` Age int64 } 把 name 设置上缺省值 galeone 了. 补充:Golang 巧用构造函数设置结构体的默认值 看代码吧~ package main import "fmt" type s1 struct { ID string s2 s2 s3 s3 } type s2 s
-
golang Gorm框架讲解
目录 1.gorm介绍 1.1介绍 1.2安装 2.使用 2.1创建表 2.2.添加数据 2.3.查询数据 2.4更新数据 2.5删除数据 2.6执行原生sql 3.一对一 3.1创建表 3.2多态关联 3.3外键约束 4.一对多 5.多对多 6.获取多表数据 1.gorm介绍 1.1介绍 全功能 ORM 关联 (Has One,Has Many,Belongs To,Many To Many,多态,单表继承) Create,Save,Update,Delete,Find 中钩子方法 支持 Pr
-
golang gorm框架数据库的连接操作示例
目录 1. 连接数据库 1.1 MySQL 1.2 PostgreSQL 1.3 Sqlite3 1.4 不支持的数据库 2. 迁移 2.1. 自动迁移 2.2. 检查表是否存在 2.3. 创建表 2.4. 删除表 2.5. 修改列 2.6. 删除列 2.7. 添加外键 2.8. 索引 1. 连接数据库 要连接到数据库首先要导入驱动程序.例如 import _ "github.com/go-sql-driver/mysql" 为了方便记住导入路径,GORM包装了一些驱动. import
-
Golang爬虫框架 colly的使用
目录 项目特性 安装colly 实例 colly 的配置 colly页面爬取和解析 colly框架重构爬虫 Golang爬虫框架 colly 简介 colly是一个采用Go语言编写的Web爬虫框架,旨在提供一个能够些任何爬虫/采集器/蜘蛛的简介模板,通过Colly.你可以轻松的从网站提取结构化数据,然后进行数据挖掘,处理或归档 项目特性 清晰明了的API 速度快(每个内核上的请求数大于1K) 管理每个域的请求延迟和最大并发数 自动cookie和会话处理 同步/异步/ 并行抓取 高速缓存 自动处理
-
golang gorm 操作mysql及gorm基本用法
golang 官方的那个操作mysql的有点麻烦所以就使用了gorm,下面就gorm的使用做下简单介绍 下载gorm: go get -u github.com/jinzhu/gorm 在项目中引入gorm: import ( "github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/mysql" ) 定义db连接信息 func DbConn(MyUser, Password, Host, Db stri
-
详解Golang Iris框架的基本使用
Iris介绍 编写一次并在任何地方以最小的机器功率运行,如Android.ios.Linux和Windows等.它支持Google Go,只需一个可执行的服务即可在所有平台. Iris以简单而强大的api而闻名. 除了Iris为您提供的低级访问权限. Iris同样擅长MVC. 它是唯一一个拥有MVC架构模式丰富支持的Go Web框架,性能成本接近于零. Iris为您提供构建面向服务的应用程序的结构. 用Iris构建微服务很容易. 1. Iris框架 1.1 Golang框架 Golang常用
-
golang gorm 计算字段和获取sum()值的实现
计算表lb_ytt_user_money_log 中,字段money的和 代码如下: var total_money []int sqlstr := `select SUM(money) as total_money from lb_ytt_user_money_log where user_id = ? and l_type = 1 and status=1 and (create_time> ? and create_time <= ?)` Db.Raw(sqlstr, userID, b
-
golang gorm多条件筛选查询操作
案例: 查看陌陌的动态,依次可以按照发布时间,性别,城市进行筛选 如图进行筛选 gorm链式操作 Method Chaining,Gorm 实现了链式操作接口,所以你可以把代码写成这样: // 创建一个查询 tx := db.Where("name = ?", "jinzhu") // 添加更多条件 if someCondition { tx = tx.Where("age = ?", 20) } else { tx = tx.Where(&qu
-
Golang Gin框架实现文件下载功能的示例代码
目录 Layui框架实现文件上传 Gin框架获取前端上传的文件 Gin框架的文件下载 Layui框架实现文件上传 基本的思路就是随便创建一个元素,然后使用layui的upload组件对创建的元素进行渲染,详见代码 <!DOCTYPE html> <html lang="en"> <head> <script src="jquery-3.5.0.min.js" type="text/javascript"&
-
golang beego框架路由ORM增删改查完整案例
目录 程序运行前加载 路由设置 高级路由设置 beego-ORM初始化 安装ORM+导包 定义结构体 beego支持的数据库 连接数据库 注册数据库表 生成表 完整案例 ORM增删改查 插入 查询 更新 删除 案例 注册 案例2 程序运行前加载 1.导包前面加下划线,运行前加载 2.把要加载的写在init函数里面 路由设置 路由的作用:根据不同的请求指定不同的控制器 路由函数: beego.Router("/path",&controller.MainController{})
-
golang gorm的Callbacks事务回滚对象操作示例
目录 1. Callbacks 1.1. 创建对象 1.2. 更新对象 1.3. 删除对象 1.4. 查询对象 1.5. 回调示例 1. Callbacks 您可以将回调方法定义为模型结构的指针,在创建,更新,查询,删除时将被调用,如果任何回调返回错误,gorm将停止未来操作并回滚所有更改. 1.1. 创建对象 创建过程中可用的回调 // begin transaction 开始事物 BeforeSave BeforeCreate // save before associations 保存前关