GORM 一对多关系 HasMany

已于 2023-11-30 16:46:42 修改
阅读量434 收藏 9
点赞数 9
分类专栏： GORM 文章标签： 学习 笔记 数据库 sql golang
于 2023-11-27 23:44:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingsill/article/details/134657310
版权

文章目录

一对多关系 Has Many部分

官方文档
has many 与另一个模型建立了一对多的连接。 不同于 has one，拥有者可以有零或多个关联模型。

老板与员工
女神和舔狗
老师和学生
班级与学生
用户与文章…

  例如，您的应用包含 user 和 article 模型，且每个 user 可以有多篇 article。

声明

  user为主表，由于一对多，在user结构中增加article切片；
  article表为副表，在其中加入外键关联，即主表名+ID，再加入user结构体、

// User 用户表 一个用户可以有多篇文章
type User struct {
	ID       uint   `gorm:"size:4"`
	Name     string `gorm:"size:8"`
	Articles []Article
}

// Article 文章表 一篇文章属于一个用户
type Article struct {
	ID     uint   `gorm:"size:4"`
	Title  string `gorm:"size:16"`
	UserID uint   `gorm:"size:4"`
	User   User
}
//使用automigrate进行表的迁移
DB.AutoMigrate(&User{}, &Article{})

  默认的外键名是拥有者的类型名加上其主键字段名，这里外键名称就是关联表名+ID，不加备注不可以随便更改，会报错；且外键类型要和主表关联的字段类型一直，这里都为unit，size：4
可以得到建立的表的关系如图：

在这里插入图片描述

重写外键关联

  想要使用另一个字段作为外键，您可以使用 foreignKey 标签自定义它：

//重写外键关联----------------------------
//gorm的foreignKey备注写在对应的两个表的关联上
type User1 struct {
	ID       uint       `gorm:"size:4"`
	Name     string     `gorm:"size:8"`
	Articles []Article1 `gorm:"foreignKey:UID"`
}

type Article1 struct {
	ID    uint   `gorm:"size:4"`
	Title string `gorm:"size:16"`
	UID   uint   `gorm:"size:4"`
	User  User1  `gorm:"foreignKey:UID"`
}

关联外键的数据类型仍需一致，但是字段名不再受限制

重写引用

这里博主大失败，最后也没有搞出来，希望过路大神解答
这里贴官方文档

  GORM 通常使用拥有者的主键作为外键的值。 对于上面的例子，它是 User 的 ID 字段。
  为 user 添加 credit card 时，GORM 会将 user 的 ID 字段保存到 credit card 的 UserID 字段。
  同样的，您也可以使用标签 references 来更改它，例如：

//重写引用----------------------------
//备注写在对应的两个表的关联上

type User2 struct {
	ID       uint       `gorm:"size:4"`
	Name     string     `gorm:"size:8"`
	Articles []Article2 `gorm:"foreignKey:UserName;references:Name"`
}

type Article2 struct {
	ID       uint   `gorm:"size:4"`
	Title    string `gorm:"size:16"`
	UserName string `gorm:"size:8"`
	User     User2  `gorm:"references:Name"`
}

报错信息

Error 1170 (42000): BLOB/TEXT column ‘company_id’ used in key specification without a key length

一对多的添加

//创建用户的同时创建文章，并将两者关联
DB.Save(&User{
	Name: "wang2",
	Articles: []Article{
		{Title: "golang"},
		{Title: "python"},
	},
})

//这里save、create方法都可以
//创建文章，关联已有用户
//1.直接传入关联外键部分
DB.Save(&Article{Title: "easyGo", UserID: 2})

//2.查询过后传入对应结构体中
var user User
DB.Take(&user, 1)                           //查询已有用户
DB.Save(&Article{Title: "c++", User: user}) //将关联部分的User结构体传入

外键添加

常规方法

// 常规方法
//常规方法-----------------------将id为8的文章和id为2的用户绑定
//现有用户，这里id=2
var user User
DB.Take(&user, 2)

//现有文章，id=8，未设置用户
var article Article
DB.Take(&article, 8)

//方法1.给现有用户绑定文章
user.Articles = []Article{article}//[{8 c语言 2 {0  []}}]
DB.Save(&user)

//方法2.给现有文章关联用户
article.User = user //{2 wang2 []}
DB.Save(&article)

append方法

association方法中为关联二表的部分，这里为articels和User

//append方法--------将id为8的文章和id为2的用户绑定
var user User
DB.Take(&user, 2)
var article Article
DB.Take(&article, 8)
//1.用户绑定文章
//model在选表的同时也在选择对象
//DB.Model(&User{ID: 2}).Association("Articles").Append(&article)
DB.Model(&user).Association("Articles").Append(&article)
//2.文章关联用户
DB.Model(&article).Association("User").Append(&user)

前文user、article定义部分

查询、预加载

  GORM 可以通过 Preload 预加载 has many 关联的记录，查看 预加载 获取详情
  预加载的名字就是外键关联的属性名，大小写、复数形式敏感

//查询 不加载，无法查看
var userList []User
DB.Find(&userList)
fmt.Println(userList) 
//[{1 wang []} {2 wang2 []}]

user = User{}
//查询 预加载
DB.Preload("Articles").Take(&user, 1)
fmt.Println(user) 
//{1 wang [{1 golang 1 {0  []}} {2 python 1 {0  []}} {5 c++ 1 {0  []}}]}

嵌套预加载

//嵌套预加载 结构体中内容再展示一层
DB.Preload("Articles.User").Take(&user, 1)
fmt.Println(user)
//{1 wang [{1 golang 1 {1 wang []}} {2 python 1 {1 wang []}} {5 c++ 1 {1 wang []}}]}

查询文章，显示用户，并且显示用户关联的所有文章

带条件的预加载

//带条件的预加载
//这里只预加载id=1的文章
DB.Preload("Articles", "id=?", 1).Take(&user) //
fmt.Println(user)//{1 wang [{1 golang 1 {0  []}}]}

自定义预加载等更深入内容请查看官方文档

删除

级联删除

删除用户，与用户相关的文章也清除

//级联删除
user = User{}
DB.Preload("Articles").Take(&user, 1)
DB.Select("Articles").Delete(&user)

清楚外键关系

将与用户关联的文章，外键设置为null；删除用户
用户作为主表中数据无法直接删除

// 将id=2的用户的文章与其断开关系,并将用户删除
user = User{}
DB.Preload("Articles").Take(&user, 2)
DB.Model(&user).Association("Articles").Delete(&user.Articles)
DB.Delete(&user)

所有代码集合：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

var DB *gorm.DB

func init() {
	username := "root"
	password := "123456"
	host := "127.0.0.1"
	port := 3306
	Dbname := "gorm"
	timeout := "10s"

	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=%s", username, password, host, port, Dbname, timeout)
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: logger.Default.LogMode(logger.Info),
	})
	if err != nil {
		fmt.Println("连接数据库失败, error=", err)
		return
	}
	DB = db
	fmt.Println("数据库连接成功")
}

//表结构关联-----------------------
// User 用户表 一个用户可以有多篇文章

type User struct {
	ID       uint   `gorm:"size:4"`
	Name     string `gorm:"size:8"`
	Articles []Article
}

// Article 文章表 一篇文章属于一个用户
type Article struct {
	ID     uint   `gorm:"size:4"`
	Title  string `gorm:"size:16"`
	UserID uint   `gorm:"size:4"`
	User   User
}

//重写外键关联----------------------------
//gorm的foreignKey备注写在对应的两个表的关联上
//
//type User1 struct {
//	ID       uint       `gorm:"size:4"`
//	Name     string     `gorm:"size:8"`
//	Articles []Article1 `gorm:"foreignKey:UID"`
//}
//
//type Article1 struct {
//	ID    uint   `gorm:"size:4"`
//	Title string `gorm:"size:16"`
//	UID   uint   `gorm:"size:4"`
//	User  User1  `gorm:"foreignKey:UID"`
//}

//重写引用----------------------------
//备注写在对应的两个表的关联上

//type User2 struct {
//	ID       uint       `gorm:"size:4"`
//	Name     string     `gorm:"size:8"`
//	Articles []Article2 `gorm:"foreignKey:UserName;references:Name"`
//}
//
//type Article2 struct {
//	ID       uint   `gorm:"size:4"`
//	Title    string `gorm:"size:16"`
//	UserName string `gorm:"size:8"`
//	User     User2  `gorm:"references:Name"`
//}

func main() {
	//DB.AutoMigrate(&User{}, &Article{})
	//DB.AutoMigrate(&User1{}, &Article1{})
	//DB.AutoMigrate(&User2{}, &Article2{})

	创建用户的同时创建文章，并将两者关联
	//DB.Save(&User{
	//	Name: "wang2",
	//	Articles: []Article{
	//		{Title: "golang"},
	//		{Title: "python"},
	//	},
	//})

	创建文章，关联已有用户
	1.直接传入关联外键部分
	//DB.Save(&Article{Title: "easyGo", UserID: 2})
	//
	2.查询过后传入对应结构体中
	//var user User
	//DB.Take(&user, 1)                           //查询已有用户
	//DB.Save(&Article{Title: "c++", User: user}) //将关联部分的User结构体传入

	//外键添加
	//常规方法-----------------------将id为8的文章和id为2的用户绑定
	//现有用户，这里id=2
	//var user User
	//DB.Take(&user, 2)

	//现有文章，id=8，未设置用户
	//var article Article
	//DB.Take(&article, 8)

	//方法1.给现有用户绑定文章
	//user.Articles = []Article{article}//[{8 c语言 2 {0  []}}]
	//DB.Save(&user)

	//方法2.给现有文章关联用户
	//article.User = user //{2 wang2 []}
	//DB.Save(&article)
	//-------------------------------------
	//append方法--------将id为8的文章和id为2的用户绑定
	var user User
	DB.Take(&user, 2)
	var article Article
	DB.Take(&article, 8)
	//1.用户绑定文章
	//model在选表的同时也在选择对象
	//DB.Model(&User{ID: 2}).Association("Articles").Append(&article)
	DB.Model(&user).Association("Articles").Append(&article)
	//2.文章关联用户
	DB.Model(&article).Association("User").Append(&user)

	//查询 不加载，无法查看
	var userList []User
	DB.Find(&userList)
	fmt.Println(userList) //[{1 wang []} {2 wang2 []}]

	user = User{}
	//查询 预加载
	DB.Preload("Articles").Take(&user, 1)
	fmt.Println(user) //{1 wang [{1 golang 1 {0  []}} {2 python 1 {0  []}} {5 c++ 1 {0  []}}]}

	user = User{}
	//嵌套预加载 结构体中内容再展示一层
	DB.Preload("Articles.User").Take(&user, 1)
	fmt.Println(user)
	//{1 wang [{1 golang 1 {1 wang []}} {2 python 1 {1 wang []}} {5 c++ 1 {1 wang []}}]}

	user = User{}
	//带条件的预加载
	//这里只预加载id=1的文章
	DB.Preload("Articles", "id=?", 1).Take(&user) //
	fmt.Println(user)
	//{1 wang [{1 golang 1 {0  []}}]}

	// 将id=2的用户的文章与其断开关系,并将用户删除
	user = User{}
	DB.Preload("Articles").Take(&user, 2)
	DB.Model(&user).Association("Articles").Delete(&user.Articles)
	DB.Delete(&user)

	//级联删除
	user = User{}
	DB.Preload("Articles").Take(&user, 1)
	DB.Select("Articles").Delete(&user)
}
鳄梨阿龙
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gorm关联一对多关系golang
12-14
user_topic表里的id，关联topic_image表里的topicID, //用户在发表话题动态的时候，同时发了多张照片， //查询的时候需要从topic_image表查出用户此条动态发布的所有照片。 //是这样子的一对多关系 1.model字段部分（加外键关联外键） type UserTopic struct { ID int64 `gorm:"primary_key" json:"id"` UserID int64 `json:"user_id"` TopicImgURL string
Gorm中HasMany
sunriseYJP的博客
11-10 437
GormHasMany关系
ORM框架Gorm-Has Many
我都不会的博客
04-01 1095
一对多关联 定义用户结构体和地址结构体 type User struct { gorm.Model Name string Age int Active bool Addresss []Address } type Address struct { gorm.Model Name string Code string UserID uint } 初始化数据库 var db *gorm.DB func init() { dsn := "root:root
【GORM】模型关系-HasMany关系
js010111的博客
08-08 469
GORM hasMany关联
Golang gorm 关联关系 一对多
小楼一夜听春雨，深巷明朝卖杏花
04-19 1495
has many关联就是创建和另一个模型的一对多关系（数据库里面是一对多，然后struct里面也是一对多）例如， 例如每一个用户都拥有多张信用卡，这样就是生活中一个简单的一对多关系在设计表的时候不可能将所有的信息都放在一个表里面，那么表就会非常非常的宽。这样字段就会非常的多，性能就会受到影响。在设计的时候这里其实就可以设置为两张表。一个是用户的详情表和信用卡的详情表，用户表里面加上卡的id和他做一个关联，那么这就是一对多的关系。
Golang Gorm 一对多关系 表结构的建立
小楼一夜听春雨，深巷明朝卖杏花
08-24 814
在创建的时候先将没有依赖的创建。表名称+ID就是外键。外键要和关联的外键的数据类型要保持一致。
Golang Gorm 一对多的添加
小楼一夜听春雨，深巷明朝卖杏花
08-28 832
一对多的添加有两种情况，一种是添加用户的时候，一起创建文章。其次是创建文章关联已经存在的用户。最后一种就是关联已有用户。
gorm 一对多关系 以及预加载的用法
清风
05-15 988
gorm 一对多关系 以及预加载的用法一对多关系的介绍预加载Preload预加载不使用预加载使用预加载使用链式预加载条件预加载Joins 预加载 一对多关系的介绍 这里女神表里面有多个舔狗，就是一对多has many关系 并且舔狗表里面包含Info信息表，是has one关系 type GirlGOD struct { gorm.Model Name string Dog []Dog } type Dog struct { gorm.Model Name string GirlGo
go gorm一对多has many
weixin_43632687的博客
08-22 469
go 一对多
gorm-optimistic:这是一个基于GORM的乐观锁插件
03-14
这是一个基于的乐观锁插件。 快速开始 func BenchmarkUpdateWithOptimistic ( b * testing. B ) { dsn := "root:abc123@/test?charset=utf8&parseTime=True&loc=Local" db , err := gorm . Open ( mysql . Open ( ...
gorm：Golang的绝佳ORM库，旨在对开发人员友好
02-04
关联（具有一个，具有多个，属于，一对多，多态性，单表继承） 挂钩（创建/保存/更新/删除/查找之前/之后） 预先加载Preload ， Joins 事务，嵌套事务，保存点，回滚到保存点 上下文，准备语句模式，DryRun模式 ...
golang gorm 操作mysql及gorm基本用法
09-09
golang 官方的那个操作mysql的有点麻烦所以就使用了gorm，下面就gorm的使用做下简单介绍，感兴趣的朋友跟随小编一起看看吧
gorm-bulk-insert:使用gorm实现BulkInsert
05-29
Gorm Bulk Insert是一个使用实现批量插入/更新Gorm Bulk Insert的库。 目的 保存批量记录 安装 $ go get github.com/sunary/gorm-bulk-insert 这个库依赖于 gorm，除非你已经安装了 gorm，否则下面的命令也是必要的...
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1035
介绍了Java泛型中的重要知识点——通配泛型及其应用。
限流的学习
weixin_43675252的博客
05-01 429
限流算法：滑动窗口算法滑动日志算法漏桶算法令牌桶算法。
Spring Cloud学习笔记（Hystrix）：execute，queue，observe，toObservable样例和特性
sinat_38393872的博客
04-29 740
这是本人学习的总结，主要学习资料如下马士兵教育。
场景文本检测&识别学习 day08（无监督的Loss Function、代理任务、特征金字塔）
丿罗小黑的博客
05-03 419
无监督的Loss Function（无监督的目标函数） 根据有无标签，可以将模型的学习方法分为：无监督、有监督两种。而自监督是无监督的一种 无监督的目标函数可以分为以下几种： 生成式网络的做法，衡量模型的输出和固定的目标之间的差距，主要考虑输入数据是怎么分布的，即 “给定Y，如何生成X”。如auto-encoder：输入一张干扰过的图，通过编码器-解码器，然后得出一张还原后的图，通过对比原图和生成的还原后的图之间的差异 判别式网络的做法，衡量模型的输出和固定的目标之间的差异，主要考虑输入和输出的映射关系
哈夫曼树学习
最新发布
2301_77523055的博客
05-06 499
给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，则称这样的二叉树为最优二叉树，也称为哈夫曼树。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
gorm 一对多 多对多
06-10
GORM是一个Go语言的ORM库，支持很多数据库，包括MySQL、PostgreSQL、SQLite等等。 在GORM中，一对多关系可以通过定义结构体中的slice来实现。例如，一个班级有多个学生，班级和学生之间就是一对多关系。可以这样定义： ```go type Class struct { gorm.Model Name string Students []Student } type Student struct { gorm.Model Name string ClassID uint } ``` 在上面的代码中，`Class`结构体中有一个`Students`字段，类型为`[]Student`，表示班级中有多个学生。而`Student`结构体中有一个`ClassID`字段，类型为`uint`，表示学生属于哪个班级。通过这种方式，就可以实现一对多关系。 多对多关系也可以通过定义结构体中的slice来实现。例如，一个学生可以选择多个课程，一个课程也可以被多个学生选择，学生和课程之间就是多对多关系。可以这样定义： ```go type Student struct { gorm.Model Name string Courses []Course `gorm:"many2many:student_courses;"` } type Course struct { gorm.Model Name string Students []Student `gorm:"many2many:student_courses;"` } ``` 在上面的代码中，`Student`结构体中有一个`Courses`字段，类型为`[]Course`，表示学生选择了哪些课程。而`Course`结构体中有一个`Students`字段，类型为`[]Student`，表示选择了该课程的学生。需要注意的是，在结构体的`gorm`标签中，需要指定`many2many`关系的表名，这里是`student_courses`。 以上就是在GORM中实现一对多和多对多关系的方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值