GORM 查询字段并计算和

可以使用 GORM 的原生 SQL 来实现查询字段并计算和的功能。以下是一个例子：

type User struct {
    Name  string
    Age   int
    Score int
}

var totalScore int
db.Table("users").Select("sum(score)").Where("age > ?", 18).Scan(&totalScore)

fmt.Println(totalScore) // 输出满足条件的所有用户的分数总和

这个例子中，我们首先定义了一个 `User` 结构体，表示用户的信息。然后通过 `db.Table` 方法指定要查询的表，使用 `Select` 方法选择要查询的字段以及计算函数，这里我们选择了 `sum` 函数来计算所有用户的分数总和。最后使用 `Where` 方法添加查询条件，这里我们只查询年龄大于 18 岁的用户。最后通过 `Scan` 方法将查询结果存储到 `totalScore` 变量中。

相关问题

使用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中有表a，表a中有字段b，c，d，e，f，g，如何实现根据b分页获取a记录且根据c去重

？您可以使用gorm库中的Preload()方法来加载关联模型。首先在模型中定义一个结构体，用于存储筛选条件：

type Filter struct {
    B string
    Page int
    Pagesize int
    C_map map[string]bool
}

然后在查询时使用以下代码：

var records []A
var count int64

db := orm.DB

// 定义一个空的筛选条件结构体
filter := &Filter{}

// 获取请求中的筛选条件
err = c.BindJSON(&filter)
if err != nil {
    // 返回错误信息
}

// 开始构建查询条件
q := db.Where("b = ?", filter.B)

// 判断是否有c条件，如有则拆分为数组
if filter.C != "" {
    cList := strings.Split(filter.C, ",")
    filter.C_map = make(map[string]bool)
    for _, c := range cList {
        filter.C_map[c] = true
    }
}

// 过滤c字段，仅保留有效字段
cField := "c"
if len(filter.C_map) > 0 {
    cField = fmt.Sprintf("(case %s end)", genCaseString(filter.C_map))
}
q = q.Select("a.*, " + cField)

// 计算记录总数
q.Count(&count)

// 分页查询
if filter.Page > 0 && filter.Pagesize > 0 {
    offset := (filter.Page - 1) * filter.Pagesize
    q = q.Offset(offset).Limit(filter.Pagesize)
}

// 执行查询
q.Find(&records)

// 返回结果

其中，genCaseString()函数用于生成筛选c字段时需要的case语句：

func genCaseString(m map[string]bool) string {
    var cases []string
    for k, _ := range m {
        cases = append(cases, fmt.Sprintf("when c = '%s' then true ", k))
    }
    return strings.Join(cases, "") + "else false end"
}

这样，您就可以完成根据b分页获取a记录并根据c去重的需求。