转成gorm

models/data_manage/factor_edb_series.go

@@ -2,9 +2,9 @@ package data_manage
 
 import (
 	"encoding/json"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
@@ -17,7 +17,7 @@ const (
 
 // FactorEdbSeries 因子指标系列表
 type FactorEdbSeries struct {
-	FactorEdbSeriesId int       `orm:"column(factor_edb_series_id);pk"`
+	FactorEdbSeriesId int       `gorm:"column:factor_edb_series_id;primaryKey"`
 	SeriesName        string    `description:"系列名称"`
 	EdbInfoType       int       `description:"关联指标类型：0-普通指标；1-预测指标"`
 	CalculateStep     string    `description:"计算步骤-JSON"`
@@ -53,12 +53,8 @@ func (m *FactorEdbSeries) Cols() FactorEdbSeriesCols {
 }
 
 func (m *FactorEdbSeries) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.FactorEdbSeriesId = int(id)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Create(m).Error
 	return
 }
 
@@ -66,21 +62,21 @@ func (m *FactorEdbSeries) CreateMulti(items []*FactorEdbSeries) (err error) {
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.CreateInBatches(items, utils.MultiAddNum).Error
 	return
 }
 
 func (m *FactorEdbSeries) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Model(m).Select(cols).Updates(m).Error
 	return
 }
 
 func (m *FactorEdbSeries) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.FactorEdbSeriesId).Exec()
+	err = o.Exec(sql, m.FactorEdbSeriesId).Error
 	return
 }
 
@@ -88,9 +84,9 @@ func (m *FactorEdbSeries) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
-	_, err = o.Raw(sql, ids).Exec()
+	err = o.Exec(sql, ids).Error
 	return
 }
 
@@ -98,39 +94,39 @@ func (m *FactorEdbSeries) RemoveByCondition(condition string, pars []interface{}
 	if condition == "" {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
-	_, err = o.Raw(sql, pars).Exec()
+	err = o.Exec(sql, pars...).Error
 	return
 }
 
 func (m *FactorEdbSeries) GetItemById(id int) (item *FactorEdbSeries, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
 func (m *FactorEdbSeries) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeries, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	order := ``
 	if orderRule != "" {
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
 	return
 }
 
 func (m *FactorEdbSeries) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = o.Raw(sql, pars...).Scan(&count).Error
 	return
 }
 
 func (m *FactorEdbSeries) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeries, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -140,12 +136,12 @@ func (m *FactorEdbSeries) GetItemsByCondition(condition string, pars []interface
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = o.Raw(sql, pars...).Find(&items).Error
 	return
 }
 
 func (m *FactorEdbSeries) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeries, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -155,7 +151,7 @@ func (m *FactorEdbSeries) GetPageItemsByCondition(condition string, pars []inter
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
 	return
 }
 
@@ -200,10 +196,10 @@ func (m *FactorEdbSeries) CreateSeriesAndMapping(item *FactorEdbSeries, mappings
 		err = fmt.Errorf("series is nil")
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	tx, e := o.Begin()
-	if e != nil {
-		err = fmt.Errorf("orm begin err: %v", e)
+	o := global.DbMap[utils.DbNameIndex]
+	tx := o.Begin()
+	if err = tx.Error; err != nil {
+		err = fmt.Errorf("orm begin err: %v", err)
 		return
 	}
 	defer func() {
@@ -214,21 +210,22 @@ func (m *FactorEdbSeries) CreateSeriesAndMapping(item *FactorEdbSeries, mappings
 		_ = tx.Commit()
 	}()
 
-	id, e := tx.Insert(item)
-	if e != nil {
-		err = fmt.Errorf("insert series err: %v", e)
+	// 创建系列
+	err = tx.Create(item).Error
+	if err != nil {
+		err = fmt.Errorf("insert series err: %v", err)
 		return
 	}
-	seriesId = int(id)
-	item.FactorEdbSeriesId = seriesId
+	seriesId = item.FactorEdbSeriesId
 
+	// 批量创建映射
 	if len(mappings) > 0 {
 		for _, v := range mappings {
 			v.FactorEdbSeriesId = seriesId
 		}
-		_, e = tx.InsertMulti(200, mappings)
-		if e != nil {
-			err = fmt.Errorf("insert multi mapping err: %v", e)
+		err = tx.CreateInBatches(mappings, utils.MultiAddNum).Error
+		if err != nil {
+			err = fmt.Errorf("insert multi mapping err: %v", err)
 			return
 		}
 	}
@@ -241,10 +238,10 @@ func (m *FactorEdbSeries) EditSeriesAndMapping(item *FactorEdbSeries, mappings [
 		err = fmt.Errorf("series is nil")
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	tx, e := o.Begin()
-	if e != nil {
-		err = fmt.Errorf("orm begin err: %v", e)
+	o := global.DbMap[utils.DbNameIndex]
+	tx := o.Begin()
+	if err = tx.Error; err != nil {
+		err = fmt.Errorf("orm begin err: %v", err)
 		return
 	}
 	defer func() {
@@ -255,31 +252,31 @@ func (m *FactorEdbSeries) EditSeriesAndMapping(item *FactorEdbSeries, mappings [
 		_ = tx.Commit()
 	}()
 
-	_, e = tx.Update(item, updateCols...)
-	if e != nil {
-		err = fmt.Errorf("update series err: %v", e)
+	// 更新系列
+	err = tx.Model(item).Select(updateCols).Updates(item).Error
+	if err != nil {
+		err = fmt.Errorf("update series err: %v", err)
 		return
 	}
-
-	// 清除原指标关联
 	mappingOb := new(FactorEdbSeriesMapping)
 	cond := fmt.Sprintf("%s = ?", mappingOb.Cols().FactorEdbSeriesId)
 	pars := make([]interface{}, 0)
 	pars = append(pars, item.FactorEdbSeriesId)
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, mappingOb.TableName(), cond)
-	_, e = tx.Raw(sql, pars).Exec()
-	if e != nil {
-		err = fmt.Errorf("remove mapping err: %v", e)
+	err = tx.Exec(sql, pars...).Error
+	if err != nil {
+		err = fmt.Errorf("remove mapping err: %v", err)
 		return
 	}
 
+	// 批量创建新映射
 	if len(mappings) > 0 {
 		for _, v := range mappings {
 			v.FactorEdbSeriesId = item.FactorEdbSeriesId
 		}
-		_, e = tx.InsertMulti(200, mappings)
-		if e != nil {
-			err = fmt.Errorf("insert multi mapping err: %v", e)
+		err = tx.CreateInBatches(mappings, utils.MultiAddNum).Error
+		if err != nil {
+			err = fmt.Errorf("insert multi mapping err: %v", err)
 			return
 		}
 	}
@@ -362,10 +359,10 @@ func (a FactorEdbSeriesCorrelationMatrixOrder) Less(i, j int) bool {
 
 // RemoveSeriesAndMappingByFactorEdbSeriesId 删除系列和指标关联
 func (m *FactorEdbSeries) RemoveSeriesAndMappingByFactorEdbSeriesId(factorEdbSeriesChartMapping *FactorEdbSeriesChartMapping) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	tx, e := o.Begin()
-	if e != nil {
-		err = fmt.Errorf("orm begin err: %v", e)
+	o := global.DbMap[utils.DbNameIndex]
+	tx := o.Begin()
+	if err = tx.Error; err != nil {
+		err = fmt.Errorf("orm begin err: %v", err)
 		return
 	}
 	defer func() {
@@ -375,6 +372,7 @@ func (m *FactorEdbSeries) RemoveSeriesAndMappingByFactorEdbSeriesId(factorEdbSer
 		}
 		_ = tx.Commit()
 	}()
+	
 	factorEdbSeriesId := factorEdbSeriesChartMapping.FactorEdbSeriesId
 	err = factorEdbSeriesChartMapping.Remove()
 	if err != nil {
@@ -388,35 +386,30 @@ func (m *FactorEdbSeries) RemoveSeriesAndMappingByFactorEdbSeriesId(factorEdbSer
 	// 清除原指标关联
 	seriesOb := new(FactorEdbSeries)
 	cond := fmt.Sprintf("%s = ?", seriesOb.Cols().PrimaryId)
-	pars := make([]interface{}, 0)
-	pars = append(pars, factorEdbSeriesId)
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, seriesOb.TableName(), cond)
-	_, e = tx.Raw(sql, pars).Exec()
-	if e != nil {
-		err = fmt.Errorf("remove FactorEdbSeries err: %v", e)
+	err = tx.Exec(sql, factorEdbSeriesId).Error
+	if err != nil {
+		err = fmt.Errorf("remove FactorEdbSeries err: %v", err)
 		return
 	}
 
 	// 清除原指标关联
 	mappingOb := new(FactorEdbSeriesMapping)
 	cond1 := fmt.Sprintf("%s = ?", mappingOb.Cols().FactorEdbSeriesId)
-	pars1 := make([]interface{}, 0)
-	pars1 = append(pars1, factorEdbSeriesId)
 	sql = fmt.Sprintf(`DELETE FROM %s WHERE %s`, mappingOb.TableName(), cond1)
-	_, e = tx.Raw(sql, pars1).Exec()
-	if e != nil {
-		err = fmt.Errorf("remove mapping err: %v", e)
+	err = tx.Exec(sql, factorEdbSeriesId).Error
+	if err != nil {
+		err = fmt.Errorf("remove mapping err: %v", err)
 		return
 	}
+
+	// 删除原指标数据
 	dataOb := new(FactorEdbSeriesCalculateDataQjjs)
-	//删除原指标数据
 	cond2 := fmt.Sprintf("%s = ?", dataOb.Cols().FactorEdbSeriesId)
-	pars2 := make([]interface{}, 0)
-	pars2 = append(pars2, factorEdbSeriesId)
 	sql = fmt.Sprintf(`DELETE FROM %s WHERE %s`, dataOb.TableName(), cond2)
-	_, e = tx.Raw(sql, pars2).Exec()
-	if e != nil {
-		err = fmt.Errorf("remove mapping err: %v", e)
+	err = tx.Exec(sql, factorEdbSeriesId).Error
+	if err != nil {
+		err = fmt.Errorf("remove mapping err: %v", err)
 		return
 	}
 	return

models/data_manage/factor_edb_series_calculate_data.go

@@ -1,16 +1,16 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
 
 // FactorEdbSeriesCalculateData 因子指标系列-指标计算数据表
 type FactorEdbSeriesCalculateData struct {
-	FactorEdbSeriesCalculateDataId int       `orm:"column(factor_edb_series_calculate_data_id);pk"`
+	FactorEdbSeriesCalculateDataId int       `gorm:"column:factor_edb_series_calculate_data_id;primaryKey"`
 	FactorEdbSeriesId              int       `description:"因子指标系列ID"`
 	EdbInfoId                      int       `description:"指标ID"`
 	EdbCode                        string    `description:"指标编码"`
@@ -51,85 +51,91 @@ func (m *FactorEdbSeriesCalculateData) Cols() FactorEdbSeriesCalculateDataCols {
 	}
 }
 
+// Create 创建单个记录
 func (m *FactorEdbSeriesCalculateData) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.FactorEdbSeriesCalculateDataId = int(id)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Create(m).Error
 	return
 }
 
+// CreateMulti 批量创建记录
 func (m *FactorEdbSeriesCalculateData) CreateMulti(items []*FactorEdbSeriesCalculateData) (err error) {
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(500, items)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.CreateInBatches(items, utils.MultiAddNum).Error
 	return
 }
 
+// Update 更新指定字段
 func (m *FactorEdbSeriesCalculateData) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Model(m).Select(cols).Updates(m).Error
 	return
 }
 
+// Remove 删除单个记录
 func (m *FactorEdbSeriesCalculateData) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.FactorEdbSeriesCalculateDataId).Exec()
+	err = o.Exec(sql, m.FactorEdbSeriesCalculateDataId).Error
 	return
 }
 
+// MultiRemove 批量删除记录
 func (m *FactorEdbSeriesCalculateData) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
-	_, err = o.Raw(sql, ids).Exec()
+	err = o.Exec(sql, ids).Error
 	return
 }
 
+// RemoveByCondition 按条件删除记录
 func (m *FactorEdbSeriesCalculateData) RemoveByCondition(condition string, pars []interface{}) (err error) {
 	if condition == "" {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
-	_, err = o.Raw(sql, pars).Exec()
+	err = o.Exec(sql, pars...).Error
 	return
 }
 
+// GetItemById 根据ID获取单个记录
 func (m *FactorEdbSeriesCalculateData) GetItemById(id int) (item *FactorEdbSeriesCalculateData, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
+// GetItemByCondition 根据条件获取单个记录
 func (m *FactorEdbSeriesCalculateData) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeriesCalculateData, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	order := ``
 	if orderRule != "" {
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
 	return
 }
 
+// GetCountByCondition 根据条件获取记录数量
 func (m *FactorEdbSeriesCalculateData) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = o.Raw(sql, pars...).Scan(&count).Error
 	return
 }
 
+// GetItemsByCondition 根据条件获取多条记录
 func (m *FactorEdbSeriesCalculateData) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeriesCalculateData, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -139,12 +145,13 @@ func (m *FactorEdbSeriesCalculateData) GetItemsByCondition(condition string, par
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = o.Raw(sql, pars...).Find(&items).Error
 	return
 }
 
+// GetPageItemsByCondition 根据条件分页获取记录
 func (m *FactorEdbSeriesCalculateData) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeriesCalculateData, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -154,7 +161,7 @@ func (m *FactorEdbSeriesCalculateData) GetPageItemsByCondition(condition string,
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
 	return
 }
 
@@ -174,6 +181,8 @@ func (m *FactorEdbSeriesCalculateData) Format2Item() (item *FactorEdbSeriesCalcu
 	item.FactorEdbSeriesId = m.FactorEdbSeriesId
 	item.EdbInfoId = m.EdbInfoId
 	item.EdbCode = m.EdbCode
+	item.DataTime = m.DataTime.Format(utils.FormatDate)
+	item.Value = m.Value
 	return
 }
 

models/data_manage/factor_edb_series_calculate_data_qjjs.go

@@ -1,16 +1,16 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
 
 // FactorEdbSeriesCalculateDataQjjs 因子指标系列-区间计算数据表
 type FactorEdbSeriesCalculateDataQjjs struct {
-	FactorEdbSeriesCalculateDataId int       `orm:"column(factor_edb_series_calculate_data_id);pk"`
+	FactorEdbSeriesCalculateDataId int       `gorm:"column:factor_edb_series_calculate_data_id;primaryKey"`
 	FactorEdbSeriesId              int       `description:"因子指标系列ID"`
 	EdbInfoId                      int       `description:"指标ID"`
 	EdbCode                        string    `description:"指标编码"`
@@ -51,85 +51,91 @@ func (m *FactorEdbSeriesCalculateDataQjjs) Cols() FactorEdbSeriesCalculateDataQj
 	}
 }
 
+// Create 创建单个记录
 func (m *FactorEdbSeriesCalculateDataQjjs) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.FactorEdbSeriesCalculateDataId = int(id)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Create(m).Error
 	return
 }
 
+// CreateMulti 批量创建记录
 func (m *FactorEdbSeriesCalculateDataQjjs) CreateMulti(items []*FactorEdbSeriesCalculateDataQjjs) (err error) {
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(500, items)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.CreateInBatches(items, utils.MultiAddNum).Error
 	return
 }
 
+// Update 更新指定字段
 func (m *FactorEdbSeriesCalculateDataQjjs) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Model(m).Select(cols).Updates(m).Error
 	return
 }
 
+// Remove 删除单个记录
 func (m *FactorEdbSeriesCalculateDataQjjs) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.FactorEdbSeriesCalculateDataId).Exec()
+	err = o.Exec(sql, m.FactorEdbSeriesCalculateDataId).Error
 	return
 }
 
+// MultiRemove 批量删除记录
 func (m *FactorEdbSeriesCalculateDataQjjs) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
-	_, err = o.Raw(sql, ids).Exec()
+	err = o.Exec(sql, ids).Error
 	return
 }
 
+// RemoveByCondition 按条件删除记录
 func (m *FactorEdbSeriesCalculateDataQjjs) RemoveByCondition(condition string, pars []interface{}) (err error) {
 	if condition == "" {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
-	_, err = o.Raw(sql, pars).Exec()
+	err = o.Exec(sql, pars...).Error
 	return
 }
 
+// GetItemById 根据ID获取单个记录
 func (m *FactorEdbSeriesCalculateDataQjjs) GetItemById(id int) (item *FactorEdbSeriesCalculateDataQjjs, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
+// GetItemByCondition 根据条件获取单个记录
 func (m *FactorEdbSeriesCalculateDataQjjs) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeriesCalculateDataQjjs, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	order := ``
 	if orderRule != "" {
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
 	return
 }
 
+// GetCountByCondition 根据条件获取记录数量
 func (m *FactorEdbSeriesCalculateDataQjjs) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = o.Raw(sql, pars...).Scan(&count).Error
 	return
 }
 
+// GetItemsByCondition 根据条件获取多条记录
 func (m *FactorEdbSeriesCalculateDataQjjs) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeriesCalculateDataQjjs, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -139,12 +145,13 @@ func (m *FactorEdbSeriesCalculateDataQjjs) GetItemsByCondition(condition string,
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = o.Raw(sql, pars...).Find(&items).Error
 	return
 }
 
+// GetPageItemsByCondition 根据条件分页获取记录
 func (m *FactorEdbSeriesCalculateDataQjjs) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeriesCalculateDataQjjs, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -154,7 +161,7 @@ func (m *FactorEdbSeriesCalculateDataQjjs) GetPageItemsByCondition(condition str
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
 	return
 }
 
@@ -189,22 +196,23 @@ func TransEdbSeriesCalculateDataQjjs2EdbDataList(items []*FactorEdbSeriesCalcula
 	return
 }
 
+// GetEdbDataList 获取Edb数据列表
 func (m *FactorEdbSeriesCalculateDataQjjs) GetEdbDataList(seriesId int, edbInfoId int, startDate, endDate string) (list []*EdbDataList, err error) {
 	var pars []interface{}
-	sql := `SELECT factor_edb_series_calculate_data_id as edb_data_id  ,edb_info_id,data_time,value,data_timestamp FROM %s WHERE edb_info_id=? and factor_edb_series_id=? `
+	sql := `SELECT factor_edb_series_calculate_data_id as edb_data_id, edb_info_id, data_time, value, data_timestamp FROM %s WHERE edb_info_id=? AND factor_edb_series_id=? `
 	pars = append(pars, edbInfoId, seriesId)
 	if startDate != "" {
-		sql += ` AND data_time>=? `
+		sql += ` AND data_time >= ? `
 		pars = append(pars, startDate)
 	}
 	if endDate != "" {
-		sql += ` AND data_time<=? `
+		sql += ` AND data_time <= ? `
 		pars = append(pars, endDate)
 	}
 
 	sql += ` ORDER BY data_time ASC `
 	sql = fmt.Sprintf(sql, m.TableName())
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, pars).QueryRows(&list)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Raw(sql, pars...).Find(&list).Error
 	return
 }

models/data_manage/factor_edb_series_calculate_func.go

@@ -1,16 +1,16 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
 
 // FactorEdbSeriesCalculateFunc 多因子系列-计算方式表
 type FactorEdbSeriesCalculateFunc struct {
-	FactorEdbSeriesCalculateFuncId int       `orm:"column(factor_edb_series_calculate_func_id);pk"`
+	FactorEdbSeriesCalculateFuncId int       `gorm:"column:factor_edb_series_calculate_func_id;primaryKey"`
 	CalculateName                  string    `description:"计算方式名称"`
 	Source                         int       `description:"计算方式来源"`
 	EdbInfoType                    int       `description:"指标计算类型：0-普通指标；1-预测指标"`
@@ -42,75 +42,80 @@ func (m *FactorEdbSeriesCalculateFunc) Cols() FactorEdbSeriesCalculateFuncCols {
 	}
 }
 
+// Create 创建单个记录
 func (m *FactorEdbSeriesCalculateFunc) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.FactorEdbSeriesCalculateFuncId = int(id)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Create(m).Error
 	return
 }
 
+// CreateMulti 批量创建记录
 func (m *FactorEdbSeriesCalculateFunc) CreateMulti(items []*FactorEdbSeriesCalculateFunc) (err error) {
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.CreateInBatches(items, utils.MultiAddNum).Error
 	return
 }
 
+// Update 更新指定字段
 func (m *FactorEdbSeriesCalculateFunc) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Model(m).Select(cols).Updates(m).Error
 	return
 }
 
+// Remove 删除单个记录
 func (m *FactorEdbSeriesCalculateFunc) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.FactorEdbSeriesCalculateFuncId).Exec()
+	err = o.Exec(sql, m.FactorEdbSeriesCalculateFuncId).Error
 	return
 }
 
+// MultiRemove 批量删除记录
 func (m *FactorEdbSeriesCalculateFunc) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
-	_, err = o.Raw(sql, ids).Exec()
+	err = o.Exec(sql, ids).Error
 	return
 }
 
+// GetItemById 根据ID获取单个记录
 func (m *FactorEdbSeriesCalculateFunc) GetItemById(id int) (item *FactorEdbSeriesCalculateFunc, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
+// GetItemByCondition 根据条件获取单个记录
 func (m *FactorEdbSeriesCalculateFunc) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeriesCalculateFunc, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	order := ``
 	if orderRule != "" {
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
 	return
 }
 
+// GetCountByCondition 根据条件获取记录数量
 func (m *FactorEdbSeriesCalculateFunc) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = o.Raw(sql, pars...).Scan(&count).Error
 	return
 }
 
+// GetItemsByCondition 根据条件获取多条记录
 func (m *FactorEdbSeriesCalculateFunc) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeriesCalculateFunc, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -120,12 +125,13 @@ func (m *FactorEdbSeriesCalculateFunc) GetItemsByCondition(condition string, par
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = o.Raw(sql, pars...).Find(&items).Error
 	return
 }
 
+// GetPageItemsByCondition 根据条件分页获取记录
 func (m *FactorEdbSeriesCalculateFunc) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeriesCalculateFunc, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -135,7 +141,7 @@ func (m *FactorEdbSeriesCalculateFunc) GetPageItemsByCondition(condition string,
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
 	return
 }
 

models/data_manage/factor_edb_series_chart_mapping.go

@@ -1,9 +1,9 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
@@ -15,7 +15,7 @@ const (
 
 // FactorEdbSeriesChartMapping 因子指标系列-图表关联
 type FactorEdbSeriesChartMapping struct {
-	FactorEdbSeriesChartMappingId int       `orm:"column(factor_edb_series_chart_mapping_id);pk"`
+	FactorEdbSeriesChartMappingId int       `gorm:"column:factor_edb_series_chart_mapping_id;primaryKey"`
 	ChartInfoId                   int       `description:"图表ID"`
 	Source                        int       `description:"图表来源, 同chart_info表source"`
 	CalculateType                 int       `description:"计算方式: 1-相关性"`
@@ -62,92 +62,99 @@ func (m *FactorEdbSeriesChartMapping) Cols() MultipleFactorSeriesChartMappingCol
 	}
 }
 
+// Create 创建单个记录
 func (m *FactorEdbSeriesChartMapping) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.FactorEdbSeriesChartMappingId = int(id)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Create(m).Error
 	return
 }
 
+// CreateMulti 批量创建记录
 func (m *FactorEdbSeriesChartMapping) CreateMulti(items []*FactorEdbSeriesChartMapping) (err error) {
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.CreateInBatches(items, utils.MultiAddNum).Error
 	return
 }
 
+// Update 更新指定字段
 func (m *FactorEdbSeriesChartMapping) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Model(m).Select(cols).Updates(m).Error
 	return
 }
 
+// Remove 删除单个记录
 func (m *FactorEdbSeriesChartMapping) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.FactorEdbSeriesChartMappingId).Exec()
+	err = o.Exec(sql, m.FactorEdbSeriesChartMappingId).Error
 	return
 }
 
+// MultiRemove 批量删除记录
 func (m *FactorEdbSeriesChartMapping) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
-	_, err = o.Raw(sql, ids).Exec()
+	err = o.Exec(sql, ids).Error
 	return
 }
 
+// RemoveByCondition 按条件删除记录
 func (m *FactorEdbSeriesChartMapping) RemoveByCondition(condition string, pars []interface{}) (err error) {
 	if condition == "" {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
-	_, err = o.Raw(sql, pars).Exec()
+	err = o.Exec(sql, pars...).Error
 	return
 }
 
+// GetItemById 根据ID获取单个记录
 func (m *FactorEdbSeriesChartMapping) GetItemById(id int) (item *FactorEdbSeriesChartMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
+// GetItemByChartInfoId 根据ChartInfoId获取单个记录
 func (m *FactorEdbSeriesChartMapping) GetItemByChartInfoId(id int) (item *FactorEdbSeriesChartMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().ChartInfoId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
+// GetItemByCondition 根据条件获取单个记录
 func (m *FactorEdbSeriesChartMapping) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeriesChartMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	order := ``
 	if orderRule != "" {
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
 	return
 }
 
+// GetCountByCondition 根据条件获取记录数量
 func (m *FactorEdbSeriesChartMapping) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = o.Raw(sql, pars...).Scan(&count).Error
 	return
 }
 
+// GetItemsByCondition 根据条件获取多条记录
 func (m *FactorEdbSeriesChartMapping) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeriesChartMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -157,12 +164,13 @@ func (m *FactorEdbSeriesChartMapping) GetItemsByCondition(condition string, pars
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = o.Raw(sql, pars...).Find(&items).Error
 	return
 }
 
+// GetPageItemsByCondition 根据条件分页获取记录
 func (m *FactorEdbSeriesChartMapping) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeriesChartMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -172,24 +180,24 @@ func (m *FactorEdbSeriesChartMapping) GetPageItemsByCondition(condition string,
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
 	return
 }
 
 // GetDistinctSeriesIdByChartId 获取图表关联的系列ID
 func (m *FactorEdbSeriesChartMapping) GetDistinctSeriesIdByChartId(chartId int) (seriesIds []int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT DISTINCT %s FROM %s WHERE %s = ?`, m.Cols().FactorEdbSeriesId, m.TableName(), m.Cols().ChartInfoId)
-	_, err = o.Raw(sql, chartId).QueryRows(&seriesIds)
+	err = o.Raw(sql, chartId).Find(&seriesIds).Error
 	return
 }
 
-// ClearAndCreateMapping 新增图表关联
+// ClearAndCreateMapping 清除并创建映射
 func (m *FactorEdbSeriesChartMapping) ClearAndCreateMapping(seriesIds []int, mappings []*FactorEdbSeriesChartMapping) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	tx, e := o.Begin()
-	if e != nil {
-		err = fmt.Errorf("orm begin err: %v", e)
+	o := global.DbMap[utils.DbNameIndex]
+	tx := o.Begin()
+	if err = tx.Error; err != nil {
+		err = fmt.Errorf("gorm begin err: %v", err)
 		return
 	}
 	defer func() {
@@ -202,17 +210,20 @@ func (m *FactorEdbSeriesChartMapping) ClearAndCreateMapping(seriesIds []int, map
 
 	if len(seriesIds) > 0 {
 		sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s) AND %s = 0`, m.TableName(), m.Cols().FactorEdbSeriesId, utils.GetOrmInReplace(len(seriesIds)), m.Cols().ChartInfoId)
-		_, e = tx.Raw(sql, seriesIds).Exec()
-		if e != nil {
-			err = fmt.Errorf("remove chart mapping err: %v", e)
+		err = tx.Exec(sql, seriesIds).Error
+		if err != nil {
+			err = fmt.Errorf("remove chart mapping err: %v", err)
 			return
 		}
 	}
 
 	if len(mappings) > 0 {
-		_, e = tx.InsertMulti(200, mappings)
-		if e != nil {
-			err = fmt.Errorf("insert multi mapping err: %v", e)
+		for _, v := range mappings {
+			v.FactorEdbSeriesId = 0 // 这里需要根据实际逻辑调整
+		}
+		err = tx.CreateInBatches(mappings, utils.MultiAddNum).Error
+		if err != nil {
+			err = fmt.Errorf("insert multi mapping err: %v", err)
 			return
 		}
 	}

models/data_manage/factor_edb_series_mapping.go

@@ -1,16 +1,16 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
 
 // FactorEdbSeriesMapping 因子指标系列-指标关联表
 type FactorEdbSeriesMapping struct {
-	FactorEdbSeriesMappingId int       `orm:"column(factor_edb_series_mapping_id);pk"`
+	FactorEdbSeriesMappingId int       `gorm:"column:factor_edb_series_mapping_id;primaryKey"`
 	FactorEdbSeriesId        int       `description:"因子指标系列ID"`
 	EdbInfoId                int       `description:"指标ID"`
 	EdbCode                  string    `description:"指标编码"`
@@ -42,85 +42,91 @@ func (m *FactorEdbSeriesMapping) Cols() FactorEdbSeriesMappingCols {
 	}
 }
 
+// Create 创建单个记录
 func (m *FactorEdbSeriesMapping) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.FactorEdbSeriesMappingId = int(id)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Create(m).Error
 	return
 }
 
+// CreateMulti 批量创建记录
 func (m *FactorEdbSeriesMapping) CreateMulti(items []*FactorEdbSeriesMapping) (err error) {
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.CreateInBatches(items, utils.MultiAddNum).Error
 	return
 }
 
+// Update 更新指定字段
 func (m *FactorEdbSeriesMapping) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	o := global.DbMap[utils.DbNameIndex]
+	err = o.Model(m).Select(cols).Updates(m).Error
 	return
 }
 
+// Remove 删除单个记录
 func (m *FactorEdbSeriesMapping) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.FactorEdbSeriesMappingId).Exec()
+	err = o.Exec(sql, m.FactorEdbSeriesMappingId).Error
 	return
 }
 
+// MultiRemove 批量删除记录
 func (m *FactorEdbSeriesMapping) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.Cols().PrimaryId, utils.GetOrmInReplace(len(ids)))
-	_, err = o.Raw(sql, ids).Exec()
+	err = o.Exec(sql, ids).Error
 	return
 }
 
+// RemoveByCondition 按条件删除记录
 func (m *FactorEdbSeriesMapping) RemoveByCondition(condition string, pars []interface{}) (err error) {
 	if condition == "" {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
-	_, err = o.Raw(sql, pars).Exec()
+	err = o.Exec(sql, pars...).Error
 	return
 }
 
+// GetItemById 根据ID获取单个记录
 func (m *FactorEdbSeriesMapping) GetItemById(id int) (item *FactorEdbSeriesMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = o.Raw(sql, id).First(&item).Error
 	return
 }
 
+// GetItemByCondition 根据条件获取单个记录
 func (m *FactorEdbSeriesMapping) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *FactorEdbSeriesMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	order := ``
 	if orderRule != "" {
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s %s LIMIT 1`, m.TableName(), condition, order)
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
 	return
 }
 
+// GetCountByCondition 根据条件获取记录数量
 func (m *FactorEdbSeriesMapping) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = o.Raw(sql, pars...).Scan(&count).Error
 	return
 }
 
+// GetItemsByCondition 根据条件获取多条记录
 func (m *FactorEdbSeriesMapping) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*FactorEdbSeriesMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -130,12 +136,13 @@ func (m *FactorEdbSeriesMapping) GetItemsByCondition(condition string, pars []in
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = o.Raw(sql, pars...).Find(&items).Error
 	return
 }
 
+// GetPageItemsByCondition 根据条件分页获取记录
 func (m *FactorEdbSeriesMapping) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*FactorEdbSeriesMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -145,7 +152,7 @@ func (m *FactorEdbSeriesMapping) GetPageItemsByCondition(condition string, pars
 		order = ` ORDER BY ` + orderRule
 	}
 	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
 	return
 }
 
@@ -158,6 +165,7 @@ type FactorEdbSeriesMappingItem struct {
 	EdbNameEn string `description:"指标名称-英文"`
 }
 
+// Format2Item 格式化为展示用的结构体
 func (m *FactorEdbSeriesMapping) Format2Item() (item *FactorEdbSeriesMappingItem) {
 	item = new(FactorEdbSeriesMappingItem)
 	item.SeriesId = m.FactorEdbSeriesId
@@ -166,9 +174,10 @@ func (m *FactorEdbSeriesMapping) Format2Item() (item *FactorEdbSeriesMappingItem
 	return
 }
 
+// GetItemBySeriesId 根据系列ID获取关联的映射
 func (m *FactorEdbSeriesMapping) GetItemBySeriesId(seriesId int) (items []*FactorEdbSeriesMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().FactorEdbSeriesId)
-	_, err = o.Raw(sql, seriesId).QueryRows(&items)
+	err = o.Raw(sql, seriesId).Find(&items).Error
 	return
 }