Golang Gorm 一对多 preload预加载

已于 2023-09-21 19:36:52 修改
阅读量1.5k 收藏 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 |
+----+--------+---------+
富士康质检员张全蛋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang gorm三个表关联Preload的写法
____
04-15 3474
需求 三个表 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加条件
疯狂的鸭血
07-21 1574
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
[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（要定义属于关系，外键必须存在，默认外键使用所有者的类型名及其主键）也就...
Go语言之GORM框架(四)——预加载，关联标签与多态关联，自定义数据类型与事务(完结篇)
最新发布
qq_73924465的博客
05-30 1248
", 18)foreignKeyreferences在GORM中允许我们去使用自定义的数据类型，但是我们必须要实现Scanner与Value接口，以便让GORM知道如何接收并保存该类型到数据库中。= nil {fmt.Println("数据库连接失败,err:", err)returnif err!= nil {
GORM框架中的预加载（Preloading）和连接查询（Joins）
qq_63644576的博客
05-09 1173
在GORM中，Preload和Joins是两种非常强大的多表查询方法。Preload适用于Eager Loading场景，而Joins则提供了更多的灵活性来处理复杂的连接条件。根据具体的业务需求和数据模型，我们可以选择最合适的方法来优化数据库查询的性能和可读性。在实际应用中，我们还需要注意SQL注入的风险，特别是在使用Joins进行原始SQL连接查询时。始终使用参数化查询可以有效地防止SQL注入攻击。此外，随着业务的发展和数据模型的复杂化，我们可能需要编写更复杂的查询来满足新的需求。
Gorm Preload()方法——在GoLang中处理MySQL一对多关系
Liing0的博客
09-05 6449
使用Gorm 预加载方法处理一对多关系高能预警正文数据结构体初始化表 & 创建数据可视化查看一下在main函数中加入并执行控制台输出后记 高能预警 本文的绝大部分内容来自于 Gorm官方文档，默认读者了解Gorm库 本文基于Gorm v2版本，敬请读者朋友们对应食用~ 正文 我们在后台处理数据库一对多的关系时，当然希望“多”的这部分部分数据乖乖的存放在数组中。在Gorm库中已经为我们提供了预加载（Preload()方法）来解决这个问题，本文将带领大家快速上手。请君继续阅读。 数据结构体 这
关于GORM中的Preload
qq_38978882的博客
09-24 2497
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 结构体 预加载
weixin_34117522的博客
05-24 290
结构体构建 type PlansApproval struct { ID uint Plans_Id int //plans编号 UpdateUser int //更新者 Approval string //批示内容 Record_date time.Time CreateUser int ...
golang Gorm框架
CADN_F的博客
12-26 994
全功能 ORM关联 (Has One，Has Many，Belongs To，Many To Many，多态，单表继承)Create，Save，Update，Delete，Find 中钩子方法支持 Preload、Joins 的预加载事务，嵌套事务，Save Point，Rollback To Saved PointContext，预编译模式，DryRun 模式。
golang gorm结构标签
xuemeilu的博客
05-19 593
文章目录标签列表常用标签关联标签例子说明 标签列表 常用标签 标签 说明 Column 指定列的名称 Type 指定列的类型 Size 指定列的大小，默认是 255 PRIMARY_KEY 指定一个列作为主键 UNIQUE 指定一个唯一的列 DEFAULT 指定一个列的默认值 PRECISION 指定列的数据的精度 NOT NULL 指定列的数据不为空 AUTO_INCREMENT 指定一个列的数据是否自增 INDEX 创建带或不带名称的索引，同名创建复合
gorm关联一对多关系golang
疯狂的鸭血
05-11 2539
user_topic表里的id，关联topic_image表里的topicID, //用户在发表话题动态的时候，同时发了多张照片， //查询的时候需要从topic_image表查出用户此条动态发布的所有照片。 //是这样子的一对多关系 1.model字段部分（加外键关联外键） type UserTopic struct { ID int64 `gorm:"primary_key" json:"id"` UserID int64 `json
golang-gorm:golang与gorm练习
03-12
可以使用`Association`方法处理一对多、多对一等关联关系。例如，给用户分配一篇文章： ```go db.Model(&user).Association("Posts").Append(&post) ``` 10. **事务（Transactions）** GORM提供事务处理，确保...
GORM 预加载和自引用
qq_49723651的博客
04-21 2684
GORM 预加载和自引用 文章目录GORM 预加载和自引用预加载从传统的外键约束说起ORM数据库预加载自引用 预加载 从传统的外键约束说起 在传统的数据库设计中，如果我们想创建一个主表和从表，得在创建从表语句的时候添加外键约束（一般在创建的时候添加）。 [CONSTRAINT] [外键约束名称] FOREIGN KEY(外键字段名) REFERENCES 主表名(主键字段名) 比如现在有一个部门表和一个员工表，他们之间是一对多关系，部门表是主表，员工表是从表。那么在创建员工表的时候，我们得为它添加上外键
关于gorm的preload方法笔记说明
dorlolo的博客
05-27 7463
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:
关于gorm的preload方法笔记
weixin_50071922的博客
10-08 964
gorm预加载
gorm Preload与Joins带条件查询--闭坑指南与示例
dorlolo的博客
11-09 6135
1. Preload 1.1 Preload 带条件查询 2 Joins 2.1 Joins 带条件查询 2.2 Joins 模糊查询 2.3 使Joins支持一对多关系的查询 2.4 Joins方法的错误示范
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"` //订单编号...
【GoLang】《GORM实战》第三篇：关联与预加载
浩瀚宇宙的一粒尘埃
11-23 3631
文章目录关联分类重写外键、引用多态关联外键约束关联操作自动添加关联关联模式查询关联添加关联替换关联删除关联级联删除清空关联关联计数批量处理数据预加载Preload带条件的预加载预加载全部自定义预加载 SQL嵌套预加载Joins预加载 关联 分类 belongs to：会与另一个模型建立了一对一的连接。 这种模型的每一个实例都“属于”另一个模型的一个实例。比如：一个学员属于一个门派 has one：与另一个模型建立一对一的关联，但它和一对一关系有些许不同。 这种关联表明一个模型的每个实例都包含或拥有另一个模
golang gorm mysql 递归查询单表
12-03
以下是使用Golang GORM进行MySQL递归查询单表的示例代码： ```go package main import ( "fmt" "github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/mysql" ) type Category struct { ID int Name string ParentID int Children []Category `gorm:"foreignkey:ParentID"` } func main() { db, err := gorm.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database?charset=utf8mb4&parseTime=True&loc=Local") if err != nil { panic(err) } defer db.Close() var categories []Category db.Where("parent_id = ?", 0).Preload("Children").Find(&categories) for _, category := range categories { fmt.Println(category.Name) for _, child := range category.Children { fmt.Println(" ", child.Name) } } } ``` 在这个示例中，我们定义了一个Category结构体，其中包含ID、Name、ParentID和Children字段。Children字段是一个Category类型的切片，用于存储子类别。在结构体中，我们使用了GORM的foreignkey标记来指定ParentID字段是外键，Children字段是通过ParentID字段与Category表关联的。 在main函数中，我们首先使用GORM的Open函数打开MySQL数据库连接。然后，我们定义了一个categories切片，用于存储查询结果。我们使用GORM的Where函数指定ParentID为0，即查询所有顶级类别。然后，我们使用GORM的Preload函数预加载Children字段，以便在查询结果中包含子类别。最后，我们使用GORM的Find函数执行查询，并将结果存储在categories切片中。 最后，我们遍历categories切片，并打印每个类别及其子类别的名称。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值