OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

perf: cdr/ue/kpi查询列表数据排序改为程序内处理，加快sql查询速度

Browse Source
This commit is contained in:
TsMask
2025-08-28 20:56:54 +08:00
parent 8cf46bfd88
commit ab46cdfa8a
8 changed files with 574 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
features/pm/kpi_c_report/controller.go
View File

@@ -3,6 +3,7 @@ package kpi_c_report
import (
"fmt"
"net/http"
"sort"
"strconv"
"strings"
@@ -131,10 +132,10 @@ func (k *KpiCReport) GetReport2FE(c *gin.Context) {
}
// order by
if sortField, sortOrder := querys.SortField, querys.SortOrder; sortField != "" && sortOrder != "" {
orderBy := fmt.Sprintf("%s %s", sortField, sortOrder)
dbg = dbg.Order(orderBy)
}
// if sortField, sortOrder := querys.SortField, querys.SortOrder; sortField != "" && sortOrder != "" {
// orderBy := fmt.Sprintf("%s %s", sortField, sortOrder)
// dbg = dbg.Order(orderBy)
// }
//err := dborm.DefaultDB().Table(tableName).Where(whereSql, params...).Find(&reports).Error
err := dbg.Find(&results).Error
@@ -143,6 +144,46 @@ func (k *KpiCReport) GetReport2FE(c *gin.Context) {
return
}
// 排序
if querys.SortField != "" {
sort.SliceStable(results, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*KpiCReport) any{
"id": func(row *KpiCReport) any { return row.ID },
"timeGroup": func(row *KpiCReport) any { return row.CreatedAt.Unix() },
"created_at": func(row *KpiCReport) any { return row.CreatedAt.Unix() },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return results[i].ID < results[j].ID
}
// 获取比较值
valI, valJ := getter(&results[i]), getter(&results[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return results[i].ID < results[j].ID
}
})
}
reports := []map[string]any{}
for _, r := range results {
report := map[string]any{

50
src/modules/network_data/repository/all_perf_kpi.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"strings"
"be.ems/lib/log"
@@ -113,19 +114,52 @@ func (r PerfKPI) SelectKPI(query model.GoldKPIQuery) []model.KpiReport {
if query.EndTime != "" {
tx = tx.Where("created_at <= ?", query.EndTime)
}
// 排序
if query.SortField == "" || query.SortField == "timeGroup" {
query.SortField = "created_at"
}
if query.SortOrder == "" {
query.SortOrder = "desc"
}
tx = tx.Order(fmt.Sprintf("%s %s", query.SortField, query.SortOrder))
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
// 排序
if query.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.KpiReport) any{
"id": func(row *model.KpiReport) any { return row.ID },
"timeGroup": func(row *model.KpiReport) any { return row.CreatedAt },
"created_at": func(row *model.KpiReport) any { return row.CreatedAt },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[query.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if query.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if query.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows
}

107
src/modules/network_data/repository/cdr_event_ims.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"strings"
dborm "be.ems/lib/core/datasource"
@@ -170,29 +171,55 @@ func (r *CDREventIMS) SelectPage(querys model.CDREventIMSQuery) map[string]any {
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s,id desc ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
rows := r.convertResultRows(results)
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventIMS) any{
"id": func(row *model.CDREventIMS) any { return row.ID },
"timestamp": func(row *model.CDREventIMS) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
// 转换实体
result["rows"] = r.convertResultRows(results)
result["rows"] = rows
return result
}
@@ -245,15 +272,6 @@ func (r CDREventIMS) SelectByPage(querys model.CDREventIMSQuery) ([]model.CDREve
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
if pageNum == 0 && pageSize > int(total) {
@@ -265,6 +283,45 @@ func (r CDREventIMS) SelectByPage(querys model.CDREventIMSQuery) ([]model.CDREve
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventIMS) any{
"id": func(row *model.CDREventIMS) any { return row.ID },
"timestamp": func(row *model.CDREventIMS) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows, total
}

49
src/modules/network_data/repository/cdr_event_sgwc.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
@@ -54,15 +55,6 @@ func (r CDREventSGWC) SelectByPage(querys model.CDREventSGWCQuery) ([]model.CDRE
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
if pageNum == 0 && pageSize > int(total) {
@@ -74,6 +66,45 @@ func (r CDREventSGWC) SelectByPage(querys model.CDREventSGWCQuery) ([]model.CDRE
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventSGWC) any{
"id": func(row *model.CDREventSGWC) any { return row.ID },
"timestamp": func(row *model.CDREventSGWC) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows, total
}

107
src/modules/network_data/repository/cdr_event_smf.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"strings"
dborm "be.ems/lib/core/datasource"
@@ -157,29 +158,55 @@ func (r *CDREventSMF) SelectPage(querys model.CDREventSMFQuery) map[string]any {
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s,id desc ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
rows := r.convertResultRows(results)
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventSMF) any{
"id": func(row *model.CDREventSMF) any { return row.ID },
"timestamp": func(row *model.CDREventSMF) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
// 转换实体
result["rows"] = r.convertResultRows(results)
result["rows"] = rows
return result
}
@@ -226,15 +253,6 @@ func (r CDREventSMF) SelectByPage(querys model.CDREventSMFQuery) ([]model.CDREve
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
if pageNum == 0 && pageSize > int(total) {
@@ -246,6 +264,45 @@ func (r CDREventSMF) SelectByPage(querys model.CDREventSMFQuery) ([]model.CDREve
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventSMF) any{
"id": func(row *model.CDREventSMF) any { return row.ID },
"timestamp": func(row *model.CDREventSMF) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows, total
}

143
src/modules/network_data/repository/cdr_event_smsc.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"strings"
dborm "be.ems/lib/core/datasource"
@@ -167,33 +168,62 @@ func (r *CDREventSMSC) SelectPage(querys model.CDREventSMSCQuery) map[string]any
// 分页
pageNum, pageSize := repo.PageNumSize(querys.PageNum, querys.PageSize)
if pageNum == 0 && pageSize > total {
pageSize = total
}
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s,id desc ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
rows := r.convertResultRows(results)
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventSMSC) any{
"id": func(row *model.CDREventSMSC) any { return row.ID },
"timestamp": func(row *model.CDREventSMSC) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
// 转换实体
result["rows"] = r.convertResultRows(results)
result["rows"] = rows
return result
}
@@ -246,15 +276,6 @@ func (r CDREventSMSC) SelectByPage(querys model.CDREventSMSCQuery) ([]model.CDRE
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
if pageNum == 0 && pageSize > int(total) {
@@ -266,6 +287,78 @@ func (r CDREventSMSC) SelectByPage(querys model.CDREventSMSCQuery) ([]model.CDRE
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// const maxPageSize = 50000
// if pageSize > maxPageSize {
// var allRows []model.CDREventSMSC
// // 保存原始查询条件
// originalTx := tx
// // 计算总批次数
// totalBatches := (pageSize + maxPageSize - 1) / maxPageSize
// for i := range totalBatches {
// var batchRows []model.CDREventSMSC
// currentOffset := pageNum*pageSize + i*maxPageSize
// currentLimit := maxPageSize
// // 最后一批可能不足maxPageSize
// if i == totalBatches-1 {
// currentLimit = pageSize - i*maxPageSize
// }
// // 执行当前批次查询
// err := originalTx.Limit(currentLimit).Offset(currentOffset).Find(&batchRows).Error
// if err != nil {
// logger.Errorf("batch query %d failed: %v", i, err)
// return nil, 0
// }
// allRows = append(allRows, batchRows...)
// }
// rows = allRows
// } else {
// tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
// err := tx.Find(&rows).Error
// if err != nil {
// logger.Errorf("query find err => %v", err.Error())
// return rows, total
// }
// }
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.CDREventSMSC) any{
"id": func(row *model.CDREventSMSC) any { return row.ID },
"timestamp": func(row *model.CDREventSMSC) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows, total
}

107
src/modules/network_data/repository/ue_event_amf.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"strings"
dborm "be.ems/lib/core/datasource"
@@ -157,29 +158,55 @@ func (r *UEEventAMF) SelectPage(querys model.UEEventAMFQuery) map[string]any {
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s,id desc ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
rows := r.convertResultRows(results)
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.UEEventAMF) any{
"id": func(row *model.UEEventAMF) any { return row.ID },
"timestamp": func(row *model.UEEventAMF) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
// 转换实体
result["rows"] = r.convertResultRows(results)
result["rows"] = rows
return result
}
@@ -224,15 +251,6 @@ func (r UEEventAMF) SelectByPage(querys model.UEEventAMFQuery) ([]model.UEEventA
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
@@ -241,6 +259,45 @@ func (r UEEventAMF) SelectByPage(querys model.UEEventAMFQuery) ([]model.UEEventA
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.UEEventAMF) any{
"id": func(row *model.UEEventAMF) any { return row.ID },
"timestamp": func(row *model.UEEventAMF) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows, total
}

108
src/modules/network_data/repository/ue_event_mme.go
View File

@@ -2,6 +2,7 @@ package repository
import (
"fmt"
"sort"
"strings"
dborm "be.ems/lib/core/datasource"
@@ -157,29 +158,56 @@ func (r *UEEventMME) SelectPage(querys model.UEEventMMEQuery) map[string]any {
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 排序
orderSql := ""
if querys.SortField != "" {
sortSql := querys.SortField
if querys.SortOrder != "" {
if querys.SortOrder == "desc" {
sortSql += " desc "
} else {
sortSql += " asc "
}
}
orderSql = fmt.Sprintf(" order by %s,id desc ", sortSql)
}
// 查询数据
querySql := r.selectSql + whereSql + orderSql + pageSql
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
rows := r.convertResultRows(results)
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.UEEventMME) any{
"id": func(row *model.UEEventMME) any { return row.ID },
"timestamp": func(row *model.UEEventMME) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
// 转换实体
result["rows"] = r.convertResultRows(results)
result["rows"] = rows
return result
}
@@ -224,15 +252,6 @@ func (r UEEventMME) SelectByPage(querys model.UEEventMMEQuery) ([]model.UEEventM
return rows, total
}
// 排序
if querys.SortField != "" {
sortField := querys.SortField
if querys.SortOrder == "desc" {
sortField = sortField + " desc"
}
tx = tx.Order(sortField)
}
// 查询数据分页
pageNum, pageSize := datasource.PageNumSize(querys.PageNum, querys.PageSize)
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
@@ -241,6 +260,45 @@ func (r UEEventMME) SelectByPage(querys model.UEEventMMEQuery) ([]model.UEEventM
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
// 排序
if querys.SortField != "" {
sort.SliceStable(rows, func(i, j int) bool {
// 支持的排序字段映射
fieldGetters := map[string]func(*model.UEEventMME) any{
"id": func(row *model.UEEventMME) any { return row.ID },
"timestamp": func(row *model.UEEventMME) any { return row.Timestamp },
// 可添加更多支持的字段
}
// 获取字段 getter 函数
getter, ok := fieldGetters[querys.SortField]
if !ok {
// 非法字段，使用默认排序（id升序）
return rows[i].ID < rows[j].ID
}
// 获取比较值
valI, valJ := getter(&rows[i]), getter(&rows[j])
// 根据字段类型进行比较
switch v := valI.(type) {
case int64:
if querys.SortOrder == "desc" {
return v > valJ.(int64)
}
return v < valJ.(int64)
case string:
if querys.SortOrder == "desc" {
return v > valJ.(string)
}
return v < valJ.(string)
default:
// 不支持的字段类型，使用默认排序
return rows[i].ID < rows[j].ID
}
})
}
return rows, total
}