Golang Gorm 一对多 preload预加载

已于 2023-09-21 19:36:52 修改
阅读量2.1k 收藏 1
点赞数
分类专栏： Golang Gorm 文章标签： golang
于 2023-08-26 09:38:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34556414/article/details/132507882
版权

预加载示例  preload + find/take

 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);



// 预加载Orders、Profile、Role多个关联属性  ps: 预加载字段，必须是User的属性
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
	var u []User
	db.Debug().Preload("Articles").Find(&u)
	fmt.Println(u)

[1.486ms] [rows:7] SELECT * FROM `article` WHERE `article`.`user_id` IN (1,2,3)

[2.644ms] [rows:3] SELECT * FROM `user`
[{1 lucas [{1 golang 1} {2 k8s 1}]} {2 yanzi [{3 golang 2} {4 k8s 2}]} {3 test [{5 redis 3} {6 cherry 3} {7 marry 3}]}]

	var u User
	db.Debug().Where("name = ?", "lucas").Find(&u)
	fmt.Printf("%#v\n", u)

	db.Debug().Preload("Articles").Find(&u)
	fmt.Printf("%#v\n", u)

	var a Article
	db.Debug().Take(&a, 8)
	fmt.Printf("%#v\n", a)

	db.Debug().Preload("User").Find(&a)
	fmt.Printf("%#v\n", a)

[1.306ms] [rows:4] SELECT * FROM `article` WHERE `article`.`user_id` = 1

[3.628ms] [rows:1] SELECT * FROM `user` WHERE `user`.`id` = 1
main.User{ID:1, Name:"lucas", Articles:[]main.Article{main.Article{ID:1, Title:"k8s", UserID:1, User:main.User{ID:0, Name:"", Arti
cles:[]main.Article(nil)}}, main.Article{ID:2, Title:"golang", UserID:1, User:main.User{ID:0, Name:"", Articles:[]main.Article(nil
)}}, main.Article{ID:9, Title:"c", UserID:1, User:main.User{ID:0, Name:"", Articles:[]main.Article(nil)}}, main.Article{ID:10, Tit
le:"ruby", UserID:1, User:main.User{ID:0, Name:"", Articles:[]main.Article(nil)}}}}


[1.667ms] [rows:1] SELECT * FROM `article` WHERE `article`.`id` = 8 LIMIT 1
main.Article{ID:8, Title:"c++", UserID:3, User:main.User{ID:0, Name:"", Articles:[]main.Article(nil)}}


[1.124ms] [rows:1] SELECT * FROM `user` WHERE `user`.`id` = 3


[3.090ms] [rows:1] SELECT * FROM `article` WHERE `article`.`id` = 8
main.Article{ID:8, Title:"c++", UserID:3, User:main.User{ID:3, Name:"jerry", Articles:[]main.Article(nil)}}

preload的原理

其实很简单，你要preload user表的数据，gorm就提前把这张表全部取出来，然后再执行First或Find这样的方法去查询主数据，最后把两种数据通过外键关联一一对应起来。

其实preload也就是做了两次查询。

	var u User
	db.Debug().Preload("Articles").Take(&u, "name = ?", "test")
	fmt.Println(u)


[2.007ms] [rows:3] SELECT * FROM `article` WHERE `article`.`user_id` = 3

[3.056ms] [rows:1] SELECT * FROM `user` WHERE name = 'test' LIMIT 1
{3 test [{5 redis 3} {6 cherry 3} {7 marry 3}]}

带条件预加载  只想展示某些

 

	var u User
	db.Debug().Where("name = ?", "lucas").Find(&u)

	db.Debug().Preload("Articles", "id = ?", 2).Find(&u)
	fmt.Println(u)

{1 lucas [{2 golang 1 {0  []}}]}

嵌套预加载

	var a Article
	db.Debug().Take(&a, 8)
	db.Debug().Preload("User.Articles").Find(&a)
	fmt.Printf("%#v\n", a)

[4.840ms] [rows:1] SELECT * FROM `article` WHERE `article`.`id` = 8
main.Article{ID:8, Title:"c++", UserID:3, User:main.User{ID:3, Name:"jerry", Articles:[]main.Article{main.Article{ID:8, Title:"c++", UserID:3, User:m
ain.User{ID:0, Name:"", Articles:[]main.Article(nil)}}}}}

级联删除

	var u User
	
	db.Debug().Where("name = ?", "lisa").Find(&u)
	db.Debug().Select("Articles").Delete(&u)

[0.748ms] [rows:1] SELECT * FROM `user` WHERE name = 'lisa'
[2.106ms] [rows:1] DELETE FROM `article` WHERE `article`.`user_id` = 4
[6.887ms] [rows:1] DELETE FROM `user` WHERE `user`.`id` = 4

清除外键关系   Association + Delete、Clean

 有了preload，那么user就可以通过.点出来。

	db.Debug().Preload("Articles").Take(&u, 1
	)
	fmt.Println(u)


[4.167ms] [rows:1] SELECT * FROM `user` WHERE `user`.`id` = 1 LIMIT 1
{1 lucas [{1 k8s 1 {0  []}} {2 golang 1 {0  []}} {9 c 1 {0  []}} {10 ruby 1 {0  []}}]}
	var u User
	db.Take(&u, 2)
	db.Model(&u).Association("Articles").Find(&u.Articles)
	db.Debug().Model(&u).Association("Articles").Delete(&u.Articles)

[4.128ms] [rows:2] UPDATE `article` SET `user_id`=NULL WHERE `article`.`user_id` = 2 AND `article`.`id` IN (3,7)

mysql> select * from user;
+----+-------+
| id | name  |
+----+-------+
|  2 | yanzi |
|  3 | lucas |
|  4 | yanzi |
+----+-------+
3 rows in set (0.00 sec)

mysql> select * from article;
+----+--------+---------+
| id | title  | user_id |
+----+--------+---------+
|  1 | golang |    NULL |
|  2 | k8s    |    NULL |
|  3 | c#     |       2 |
|  4 | golang |       3 |
|  5 | k8s    |       3 |
|  6 | c#     |       4 |
|  7 | oracle |       2 |
+----+--------+---------+
7 rows in set (0.00 sec)

#修改之后

mysql> select * from user;
+----+-------+
| id | name  |
+----+-------+
|  2 | yanzi |
|  3 | lucas |
|  4 | yanzi |
+----+-------+

mysql> select * from article;
+----+--------+---------+
| id | title  | user_id |
+----+--------+---------+
|  1 | golang |    NULL |
|  2 | k8s    |    NULL |
|  3 | c#     |    NULL |
|  4 | golang |       3 |
|  5 | k8s    |       3 |
|  6 | c#     |       4 |
|  7 | oracle |    NULL |
+----+--------+---------+

  清空关联关系示例：先清空关联关系，再删除

	var u User
	db.Take(&u, 1)
	db.Debug().Model(&u).Association("Articles").Clear()

[11.177ms] [rows:2] UPDATE `article` SET `user_id`=NULL WHERE `article`.`user_id` = 1



mysql> select * from user;
+----+-------+
| id | name  |
+----+-------+
|  1 | lucas |
|  2 | yanzi |
|  3 | lucas |
|  4 | yanzi |
+----+-------+

mysql> select * from article;
+----+--------+---------+
| id | title  | user_id |
+----+--------+---------+
|  1 | golang |    NULL |
|  2 | k8s    |    NULL |
|  3 | c#     |       2 |
|  4 | golang |       3 |
|  5 | k8s    |       3 |
|  6 | c#     |       4 |
|  7 | oracle |       2 |
+----+--------+---------+


db.Debug().Delete(&u)
[9.960ms] [rows:1] DELETE FROM `user` WHERE `user`.`id` = 1


mysql> select * from user;
+----+-------+
| id | name  |
+----+-------+
|  2 | yanzi |
|  3 | lucas |
|  4 | yanzi |
+----+-------+

mysql> select * from article;
+----+--------+---------+
| id | title  | user_id |
+----+--------+---------+
|  1 | golang |    NULL |
|  2 | k8s    |    NULL |
|  3 | c#     |       2 |
|  4 | golang |       3 |
|  5 | k8s    |       3 |
|  6 | c#     |       4 |
|  7 | oracle |       2 |
+----+--------+---------+
Gorm Preload()方法——在GoLang中处理MySQL一对多关系
Liing0的博客
09-05 7305
使用Gorm 预加载方法处理一对多关系高能预警正文数据结构体初始化表 & 创建数据可视化查看一下在main函数中加入并执行控制台输出后记 高能预警 本文的绝大部分内容来自于 Gorm官方文档，默认读者了解Gorm库 本文基于Gorm v2版本，敬请读者朋友们对应食用~ 正文 我们在后台处理数据库一对多的关系时，当然希望“多”的这部分部分数据乖乖的存放在数组中。在Gorm库中已经为我们提供了预加载（Preload()方法）来解决这个问题，本文将带领大家快速上手。请君继续阅读。 数据结构体 这
GORM框架中的预加载功能Preload详解
技术卷的博客
10-23 1535
在使用 GORM 进行数据库操作时，Preload 是一种非常有用的功能，它用于预加载与某个模型相关联的其他模型。本文介绍了Preload 的适用性以及使用Preload前后的性能变化。
[Go实战]go-gorm的预加载 preload或related方法使用场景
热门推荐
学生董格
07-11 2万+
特殊说明： gorm官方文档对foreign key 有这么一句话：To define a belongs to relationship, the foreign key must exists, default foreign key uses owner’s type name plus its primary key（要定义属于关系，外键必须存在，默认外键使用所有者的类型名及其主键）也就...
GORM框架中的预加载（Preloading）和连接查询（Joins）
qq_63644576的博客
05-09 2144
在GORM中，Preload和Joins是两种非常强大的多表查询方法。Preload适用于Eager Loading场景，而Joins则提供了更多的灵活性来处理复杂的连接条件。根据具体的业务需求和数据模型，我们可以选择最合适的方法来优化数据库查询的性能和可读性。在实际应用中，我们还需要注意SQL注入的风险，特别是在使用Joins进行原始SQL连接查询时。始终使用参数化查询可以有效地防止SQL注入攻击。此外，随着业务的发展和数据模型的复杂化，我们可能需要编写更复杂的查询来满足新的需求。
gorm使用preload解决一对多关系
weixin_38707040的博客
10-16 1万+
package main import ( "fmt" _ "github.com/go-sql-driver/mysql" "github.com/jinzhu/gorm" ) var DB *gorm.DB type MaintenanceOrder struct { OrderId string `gorm:"type:varchar(50);null"` //订单编号...
gorm 结构体 预加载
weixin_34117522的博客
05-24 325
结构体构建 type PlansApproval struct { ID uint Plans_Id int //plans编号 UpdateUser int //更新者 Approval string //批示内容 Record_date time.Time CreateUser int ...
gorm 自定义预加载 preload加条件
疯狂的鸭血
07-21 1728
gorm 自定义预加载 preload加条件 // 首页活动模块区域分类表模型 type LabelType struct { Model Id int `json:"id";gorm:"primary_key"` MallId int `json:"mall_id"` Status int `json:"-"` Name string `json:"name"` Weigh
golang Gorm框架
CADN_F的博客
12-26 1128
全功能 ORM关联 (Has One，Has Many，Belongs To，Many To Many，多态，单表继承)Create，Save，Update，Delete，Find 中钩子方法支持 Preload、Joins 的预加载事务，嵌套事务，Save Point，Rollback To Saved PointContext，预编译模式，DryRun 模式。
gorm关联一对多关系golang
疯狂的鸭血
05-11 2592
user_topic表里的id，关联topic_image表里的topicID, //用户在发表话题动态的时候，同时发了多张照片， //查询的时候需要从topic_image表查出用户此条动态发布的所有照片。 //是这样子的一对多关系 1.model字段部分（加外键关联外键） type UserTopic struct { ID int64 `gorm:"primary_key" json:"id"` UserID int64 `json
关于GORM中的Preload
qq_38978882的博客
09-24 2582
type User struct { Id int `gorm:"primary_key"` Username string Email string Mobile string CreateTime string UpdateTime string } type Team struct { Id int Name string // 名称 Member string // 成员 } type Somet
GORM 预加载和自引用
qq_49723651的博客
04-21 2903
GORM 预加载和自引用 文章目录GORM 预加载和自引用预加载从传统的外键约束说起ORM数据库预加载自引用 预加载 从传统的外键约束说起 在传统的数据库设计中，如果我们想创建一个主表和从表，得在创建从表语句的时候添加外键约束（一般在创建的时候添加）。 [CONSTRAINT] [外键约束名称] FOREIGN KEY(外键字段名) REFERENCES 主表名(主键字段名) 比如现在有一个部门表和一个员工表，他们之间是一对多关系，部门表是主表，员工表是从表。那么在创建员工表的时候，我们得为它添加上外键
关于gorm的preload方法笔记
weixin_50071922的博客
10-08 1329
gorm预加载
golang gorm三个表关联Preload的写法
____
04-15 3647
需求 三个表 article,article_user,user article和article_user 是一对多 article_user 和 user 是一对一 查询一条 article的记录的时候，需要同时将 user的数据也带过来 { "id": 1, "article_users": [ { "id": 100, "user_id": 10, "user": { "id": 10, "user_name": "X
关于gorm的preload方法笔记说明
dorlolo的博客
05-27 7709
gorm的preload预加载笔记假设有以下三张表的结构体常规预加载多级预加载preload的原理 假设有以下三张表的结构体 homePage 主页表结构体 type HomePage struct { global.GVA_MODEL UserId uint `json:"userId" gorm:"column:user_id;comment:'用户id'"` Desc string `json:"desc" form:"desc" gorm:"column:
Go语言之GORM框架(四)——预加载，关联标签与多态关联，自定义数据类型与事务(完结篇)
qq_73924465的博客
05-30 1703
", 18)foreignKeyreferences在GORM中允许我们去使用自定义的数据类型，但是我们必须要实现Scanner与Value接口，以便让GORM知道如何接收并保存该类型到数据库中。= nil {fmt.Println("数据库连接失败,err:", err)returnif err!= nil {
gorm学习笔记（11）-gorm一对多关系，以及一对多关系中的预加载和关系操作
logiee的博客
08-17 2480
gorm一对多关系，以及一对多关系下的预加载操作，和实体操作
gorm Preload 坑啊
Go的全部
10-31 812
gorm Preload坑
【GoLang】《GORM实战》第三篇：关联与预加载
浩瀚宇宙的一粒尘埃
11-23 3971
文章目录关联分类重写外键、引用多态关联外键约束关联操作自动添加关联关联模式查询关联添加关联替换关联删除关联级联删除清空关联关联计数批量处理数据预加载Preload带条件的预加载预加载全部自定义预加载 SQL嵌套预加载Joins预加载 关联 分类 belongs to：会与另一个模型建立了一对一的连接。 这种模型的每一个实例都“属于”另一个模型的一个实例。比如：一个学员属于一个门派 has one：与另一个模型建立一对一的关联，但它和一对一关系有些许不同。 这种关联表明一个模型的每个实例都包含或拥有另一个模
gorm Preload与Joins带条件查询--闭坑指南与示例
dorlolo的博客
11-09 7737
1. Preload 1.1 Preload 带条件查询 2 Joins 2.1 Joins 带条件查询 2.2 Joins 模糊查询 2.3 使Joins支持一对多关系的查询 2.4 Joins方法的错误示范
golang gorm使用
最新发布
03-12
<think>嗯，用户想了解如何在Golang中使用GORM。首先，我需要确定用户对GORM的了解程度。可能他们已经有Golang的基础，现在想学习ORM库来操作数据库。GORM是一个流行的ORM工具，支持多种数据库，比如MySQL、PostgreSQL等。 首先，我应该从安装开始讲起，用户需要知道如何用go get安装GORM和对应的数据库驱动。比如，安装GORM和MySQL驱动的话，命令是go get gorm.io/gorm和go get gorm.io/driver/mysql。 接下来是连接数据库的步骤。需要提供一个DSN，例如用户名、密码、地址、端口、数据库名等。这里要注意处理可能的错误，比如数据库连接失败的情况，所以需要检查错误并处理。 然后是定义模型结构体。GORM使用结构体来映射数据库表，默认情况下，表名是结构体名的复数形式，但也可以通过TableName()方法自定义。模型中的字段对应表的列，可以使用gorm标签来指定主键、自增等属性。比如定义一个User结构体，包含ID、Name、Email等字段，ID作为主键且自增。 接下来是基本的CRUD操作。创建记录使用Create方法，需要注意指针传递和错误处理。查询的话，可以使用First、Find等方法，First是获取第一条记录，按主键排序。更新操作使用Updates方法，可以部分更新或全量更新，这里要提醒用户注意Select和Omit的使用。删除操作使用Delete，可以是软删除或硬删除，取决于模型是否有DeletedAt字段。 然后是高级查询部分，比如条件查询、预加载关联、事务处理。条件查询可以用Where方法，预加载关联用Preload避免N+1查询问题。事务的话，使用Transaction方法，确保原子性。 关联关系处理可能比较复杂，比如一对一、一对多、多对多。这里需要举例说明，比如用户有多个文章，用HasMany关联，文章属于用户，用BelongsTo关联。多对多的话，需要中间表，用Many2Many标签。 最后是注意事项，比如关闭调试模式、避免全表更新、使用连接池。这些是实际开发中容易遇到的问题，需要提醒用户注意。 总结一下，回答的结构应该是先介绍GORM，然后安装、连接数据库、定义模型，CRUD操作，高级查询，关联处理，注意事项。这样用户能逐步学习如何使用GORM，同时避免常见错误。需要确保示例代码正确，符合GORM的最新语法，比如使用gorm.Open的格式，以及正确的标签写法。另外，要提醒用户处理错误，避免程序崩溃。可能用户在使用过程中会遇到问题，比如表名不对，字段未正确映射，事务处理不当等，所以注意事项部分要强调这些点。</think>以下为Golang GORM的使用介绍，分为基础操作和进阶技巧两部分： 📌 基础篇 1️⃣ 安装与连接 ```go go get gorm.io/gorm go get gorm.io/driver/mysql // 以MySQL为例 // 连接数据库 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{}) if err != nil { panic("数据库连接失败") } ``` 2️⃣ 模型定义 ```go type User struct { ID uint `gorm:"primaryKey;autoIncrement"` Name string `gorm:"type:varchar(100);not null"` Email string `gorm:"uniqueIndex"` CreatedAt time.Time } // 自定义表名 func (User) TableName() string { return "sys_user" } ``` 3️⃣ CRUD操作 ```go // 创建 user := User{Name: "张三", Email: "zhangsan@example.com"} result := db.Create(&user) // 查询 var findUser User db.First(&findUser, "name = ?", "张三") // 更新 db.Model(&user).Updates(User{Name: "李四"}) // 删除 db.Delete(&user) ``` 🚀 进阶技巧 1️⃣ 关联查询 ```go // 预加载关联数据 db.Preload("Orders").Find(&users) // 一对多关联定义 type User struct { ID uint Orders []Order `gorm:"foreignKey:UserID"` } type Order struct { UserID uint // ...其他字段 } ``` 2️⃣ 事务处理 ```go db.Transaction(func(tx *gorm.DB) error { if err := tx.Create(&user).Error; err != nil { return err } if err := tx.Create(&order).Error; err != nil { return err } return nil }) ``` 3️⃣ 复杂查询 ```go // 条件组合 db.Where("age > ?", 18). Order("created_at desc"). Limit(10). Find(&users) // 原生SQL db.Raw("SELECT * FROM users WHERE age > ?", 18).Scan(&result) ``` ⚠️ 注意事项 1. 生产环境关闭Debug模式： ```go db, err := gorm.Open(..., &gorm.Config{ Logger: logger.Default.LogMode(logger.Silent) }) ``` 2. 批量操作时建议分批次处理： ```go db.CreateInBatches(users, 100) ``` 3. 使用连接池配置： ```go sqlDB, _ := db.DB() sqlDB.SetMaxOpenConns(100) sqlDB.SetMaxIdleConns(10) ``` 建议结合官方文档（https://gorm.io/zh_CN/docs/）进行实践，实际开发中注意错误处理和日志记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值