GORM 把结构体数据传入另一个结构体的结构体切片字段里
时间: 2023-11-08 14:06:28 浏览: 32
假设我们有一个结构体 `Student`,其中包含学生的一些基本信息:
```go
type Student struct {
ID int
Name string
Age int
}
```
我们还有一个结构体 `Class`,其中包含班级的一些信息,以及一个 `Students` 字段,用于存储学生信息:
```go
type Class struct {
ID int
Name string
Students []Student
}
```
现在我们想把一些学生信息传入 `Class` 结构体的 `Students` 字段里,假设我们已经有了一个学生切片 `students []Student`,我们可以创建一个 `Class` 实例,然后把 `students` 切片赋值给 `Class` 的 `Students` 字段即可:
```go
class := Class{
ID: 1,
Name: "Class 1",
}
students := []Student{
{ID: 1, Name: "Tom", Age: 18},
{ID: 2, Name: "Jerry", Age: 19},
{ID: 3, Name: "Alice", Age: 20},
}
class.Students = students
```
这样就把 `students` 切片中的学生信息赋值给了 `class` 实例的 `Students` 字段。
相关问题
使用GORM框架分页查询5张表里label字段值为1的数据,并存在切片结构体里
假设5张表的结构体分别为:Table1、Table2、Table3、Table4、Table5,且它们都有一个名为“label”的字段,可以按照以下步骤进行分页查询:
1. 创建一个结构体用于存储查询结果,假设该结构体为:
```go
type Result struct {
Table string
Data interface{}
}
```
2. 创建一个切片用于存储查询结果,假设该切片为:
```go
var results []Result
```
3. 创建一个 GORM 的 DB 对象,这里假设已经成功连接数据库并创建了 GORM 的 DB 对象:
```go
db, err := gorm.Open(driverName, dataSourceName)
if err != nil {
panic(err)
}
defer db.Close()
```
4. 分别从每张表中查询数据并存入切片中:
```go
// 设置每页显示的记录数
pageSize := 10
// 从 Table1 表中查询数据并存入切片中
var table1Data []Table1
table1Query := db.Where("label = ?", 1).Limit(pageSize).Find(&table1Data)
if table1Query.Error != nil && !errors.Is(table1Query.Error, gorm.ErrRecordNotFound) {
panic(table1Query.Error)
}
results = append(results, Result{
Table: "Table1",
Data: table1Data,
})
// 从 Table2 表中查询数据并存入切片中
var table2Data []Table2
table2Query := db.Where("label = ?", 1).Limit(pageSize).Find(&table2Data)
if table2Query.Error != nil && !errors.Is(table2Query.Error, gorm.ErrRecordNotFound) {
panic(table2Query.Error)
}
results = append(results, Result{
Table: "Table2",
Data: table2Data,
})
// 从 Table3 表中查询数据并存入切片中
var table3Data []Table3
table3Query := db.Where("label = ?", 1).Limit(pageSize).Find(&table3Data)
if table3Query.Error != nil && !errors.Is(table3Query.Error, gorm.ErrRecordNotFound) {
panic(table3Query.Error)
}
results = append(results, Result{
Table: "Table3",
Data: table3Data,
})
// 从 Table4 表中查询数据并存入切片中
var table4Data []Table4
table4Query := db.Where("label = ?", 1).Limit(pageSize).Find(&table4Data)
if table4Query.Error != nil && !errors.Is(table4Query.Error, gorm.ErrRecordNotFound) {
panic(table4Query.Error)
}
results = append(results, Result{
Table: "Table4",
Data: table4Data,
})
// 从 Table5 表中查询数据并存入切片中
var table5Data []Table5
table5Query := db.Where("label = ?", 1).Limit(pageSize).Find(&table5Data)
if table5Query.Error != nil && !errors.Is(table5Query.Error, gorm.ErrRecordNotFound) {
panic(table5Query.Error)
}
results = append(results, Result{
Table: "Table5",
Data: table5Data,
})
```
5. 返回查询结果:
```go
return results
```
以上代码将按照每张表分别查询数据,并将查询结果存入一个切片中返回。如果需要实现分页功能,只需根据需要设置每页显示的记录数和当前页数即可。
使用GORM框架分页查询5张表里label字段值为1的数据,并存在total结构体里
假设5张表的结构体分别为Table1、Table2、Table3、Table4和Table5,label字段的类型为int,可以按照以下步骤进行分页查询:
1. 创建一个total结构体,包含所有5张表中label字段值为1的记录总数:
```go
type Total struct {
Count int64 `json:"count"`
}
```
2. 在每张表的结构体中添加一个方法,用于返回该表中label字段值为1的记录总数:
```go
func (t *Table1) CountLabel1(db *gorm.DB) (int64, error) {
var count int64
err := db.Model(&Table1{}).Where("label = ?", 1).Count(&count).Error
if err != nil {
return 0, err
}
return count, nil
}
// 同样地,在Table2、Table3、Table4和Table5的结构体中也添加类似的方法
```
3. 在分页查询的API中,依次调用每张表的CountLabel1方法,将返回的记录总数求和,得到所有5张表中label字段值为1的记录总数:
```go
func GetLabel1Data(db *gorm.DB, page int, size int) ([]interface{}, *Total, error) {
var (
data []interface{}
total Total
)
// 计算每张表中label字段值为1的记录总数
count1, err := (&Table1{}).CountLabel1(db)
if err != nil {
return nil, nil, err
}
count2, err := (&Table2{}).CountLabel1(db)
if err != nil {
return nil, nil, err
}
count3, err := (&Table3{}).CountLabel1(db)
if err != nil {
return nil, nil, err
}
count4, err := (&Table4{}).CountLabel1(db)
if err != nil {
return nil, nil, err
}
count5, err := (&Table5{}).CountLabel1(db)
if err != nil {
return nil, nil, err
}
// 计算所有5张表中label字段值为1的记录总数
total.Count = count1 + count2 + count3 + count4 + count5
// 分页查询每张表中label字段值为1的数据,并将数据合并到一个切片中
err = db.Where("label = ?", 1).Offset((page - 1) * size).Limit(size).Find(&data, &Table1{}).Error
if err != nil {
return nil, nil, err
}
err = db.Where("label = ?", 1).Offset((page - 1) * size).Limit(size).Find(&data, &Table2{}).Error
if err != nil {
return nil, nil, err
}
err = db.Where("label = ?", 1).Offset((page - 1) * size).Limit(size).Find(&data, &Table3{}).Error
if err != nil {
return nil, nil, err
}
err = db.Where("label = ?", 1).Offset((page - 1) * size).Limit(size).Find(&data, &Table4{}).Error
if err != nil {
return nil, nil, err
}
err = db.Where("label = ?", 1).Offset((page - 1) * size).Limit(size).Find(&data, &Table5{}).Error
if err != nil {
return nil, nil, err
}
return data, &total, nil
}
```
4. 在调用GetLabel1Data函数时,传入需要查询的页码和每页记录数即可:
```go
data, total, err := GetLabel1Data(db, 1, 10)
if err != nil {
// 处理错误
}
fmt.Println(total.Count) // 打印所有5张表中label字段值为1的记录总数
fmt.Println(data) // 打印第1页每张表中label字段值为1的数据
```