使用GORM框架查询5张表里label字段值为1的数据

假设有5张表分别为table1、table2、table3、table4、table5，每张表都有label字段，那么可以使用GORM框架进行如下查询：

db.Table("table1").Where("label = ?", 1).Find(&result1)
db.Table("table2").Where("label = ?", 1).Find(&result2)
db.Table("table3").Where("label = ?", 1).Find(&result3)
db.Table("table4").Where("label = ?", 1).Find(&result4)
db.Table("table5").Where("label = ?", 1).Find(&result5)

其中，result1、result2、result3、result4、result5 分别表示查询结果存储的变量。

相关问题

使用GORM框架分页查询5张表里label字段值为1的数据，并存在total结构体里

假设5张表的结构体分别为Table1、Table2、Table3、Table4和Table5，label字段的类型为int，可以按照以下步骤进行分页查询：

1. 创建一个total结构体，包含所有5张表中label字段值为1的记录总数：

type Total struct {
    Count int64 `json:"count"`
}

2. 在每张表的结构体中添加一个方法，用于返回该表中label字段值为1的记录总数：

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的记录总数：

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函数时，传入需要查询的页码和每页记录数即可：

data, total, err := GetLabel1Data(db, 1, 10)
if err != nil {
    // 处理错误
}
fmt.Println(total.Count) // 打印所有5张表中label字段值为1的记录总数
fmt.Println(data) // 打印第1页每张表中label字段值为1的数据

使用GORM框架分页查询5张表里label字段值为1的数据，并存在切片结构体里

假设5张表的结构体分别为：Table1、Table2、Table3、Table4、Table5，且它们都有一个名为“label”的字段，可以按照以下步骤进行分页查询：

1. 创建一个结构体用于存储查询结果，假设该结构体为：

type Result struct {
    Table string
    Data  interface{}
}

2. 创建一个切片用于存储查询结果，假设该切片为：

var results []Result

3. 创建一个 GORM 的 DB 对象，这里假设已经成功连接数据库并创建了 GORM 的 DB 对象：

db, err := gorm.Open(driverName, dataSourceName)
if err != nil {
    panic(err)
}
defer db.Close()

4. 分别从每张表中查询数据并存入切片中：

// 设置每页显示的记录数
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. 返回查询结果：

return results

以上代码将按照每张表分别查询数据，并将查询结果存入一个切片中返回。如果需要实现分页功能，只需根据需要设置每页显示的记录数和当前页数即可。