适配达梦

models/data_manage/baiinfo_data.go

@@ -1,8 +1,9 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
-	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
 )
 
@@ -13,8 +14,7 @@ type BaiinfoClassify struct {
 
 func GetBaiinfoClassify() (items []*BaiinfoClassify, err error) {
 	sql := `SELECT CONCAT(type_2,type_3) AS type_name,CONCAT(type_2,'#',type_3) type_code  FROM base_from_baiinfo_index GROUP BY CONCAT(type_2,type_3) ORDER BY CONCAT(type_2,type_3) ASC `
-	o := orm.NewOrmUsingDB("data")
-	o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
@@ -23,10 +23,9 @@ type BaiinfoFrequency struct {
 }
 
 func GetBaiinfoFrequencyByClassifyId(classifyId int) (items []*GlFrequency, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT frequency FROM base_from_baiinfo_index WHERE classify_id = ? `
 	sql += ` GROUP BY frequency ORDER BY frequency ASC `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
@@ -50,13 +49,12 @@ type BaiinfoIndex struct {
 }
 
 func GetBaiinfoIndex(condition string, pars interface{}) (items []*BaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += `ORDER BY sort ASC, base_from_baiinfo_index_id asc`
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
@@ -76,23 +74,20 @@ func GetExportBaiinfoIndex(typeCodes []string) (items []*BaiinfoExportIndex, err
 	if len(typeCodes) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *,CONCAT(type_2, "#", type_3) AS type_name FROM base_from_baiinfo_index WHERE CONCAT(type_2, "#", type_3) IN (` + utils.GetOrmInReplace(len(typeCodes)) + `) ORDER BY frequency ASC,index_code ASC`
-	_, err = o.Raw(sql, typeCodes).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, typeCodes).Find(&items).Error
 	return
 }
 
 func GetBaiinfoFrequency(classifyId int) (items []*string, err error) {
 	sql := `SELECT DISTINCT frequency FROM base_from_baiinfo_index WHERE classify_id=? ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年','年度') `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
 func GetBaiinfoFrequencyByCode(code string) (items []*string, err error) {
 	sql := `SELECT DISTINCT frequency FROM base_from_baiinfo_index WHERE index_code=? ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年','年度') `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, code).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, code).Find(&items).Error
 	return
 }
 
@@ -122,43 +117,50 @@ type BaiinfoIndexData struct {
 }
 
 func GetBaiinfoIndexData(indexCode string, startSize, pageSize int) (items []*BaiinfoIndexData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_baiinfo_data WHERE index_code=? ORDER BY data_time DESC LIMIT ?,? `
-	_, err = o.Raw(sql, indexCode, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode, startSize, pageSize).Find(&items).Error
 	return
 }
 
 func GetBaiinfoIndexDataCount(indexCode string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count  FROM base_from_baiinfo_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(1) AS count  FROM base_from_baiinfo_data WHERE index_code=? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, indexCode).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 // GetBaiinfoItemList 模糊查询Baiinfo数据库指标列表
 func GetBaiinfoItemList(keyword string) (items []*BaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := "SELECT * FROM base_from_baiinfo_index WHERE CONCAT(index_name,index_code) LIKE ? "
-	_, err = o.Raw(sql, utils.GetLikeKeyword(keyword)).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, utils.GetLikeKeyword(keyword)).Find(&items).Error
 	return
 }
 
 func GetBaiinfoIndexDataByCode(indexCode string) (items []*BaiinfoIndexData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_baiinfo_data WHERE index_code=? ORDER BY data_time DESC  `
-	_, err = o.Raw(sql, indexCode).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&items).Error
 	return
 }
 
 func GetBaiinfoDataMaxCount(classifyId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT MAX(t.num) AS count FROM (
+	sqlStr := `SELECT MAX(t.num) AS count FROM (
 				SELECT COUNT(1) AS num  FROM base_from_baiinfo_index AS a
 				INNER JOIN base_from_baiinfo_data AS b ON a.index_code=b.index_code
 				WHERE a.classify_id=?
 				GROUP BY a.base_from_baiinfo_index_id
 			)AS t `
-	err = o.Raw(sql, classifyId).QueryRow(&count)
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
@@ -171,7 +173,6 @@ func GetExportBaiinfoDataMaxCount(typeCodes []string) (items []*ExportBaiinfoDat
 	if len(typeCodes) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT
 				MAX(t.num) AS count,
 				t.type_name
@@ -190,7 +191,7 @@ func GetExportBaiinfoDataMaxCount(typeCodes []string) (items []*ExportBaiinfoDat
 				) AS t
 			GROUP BY
 				type_name `
-	_, err = o.Raw(sql, typeCodes).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, typeCodes).Find(&items).Error
 
 	return
 }
@@ -205,8 +206,7 @@ func GetExportBaiinfoIndexDataByCodes(indexCodes []string) (items []*ExportBaiin
 	if len(indexCodes) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT index_code,data_time,value FROM base_from_baiinfo_data WHERE index_code IN (` + utils.GetOrmInReplace(len(indexCodes)) + `) ORDER BY data_time DESC  `
-	_, err = o.Raw(sql, indexCodes).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes).Find(&items).Error
 	return
 }

models/data_manage/base_from_baiinfo.go

@@ -1,9 +1,10 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"time"
 )
 
@@ -34,22 +35,19 @@ type BaseFromBaiinfo struct {
 }
 
 func AddBaseFromBaiinfo(item *BaseFromBaiinfo) (lastId int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	lastId, err = o.Insert(item)
+	err = global.DbMap[utils.DbNameIndex].Create(item).Error
 	return
 }
 
 func GetBaseFromBaiinfoList() (list []*BaseFromBaiinfo, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo `
-	_, err = o.Raw(sql).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&list).Error
 	return
 }
 
 func GetBaseFromBaiinfoByBaiinfoCode(baiinfoCode string) (item *BaseFromBaiinfo, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo WHERE interface=?`
-	err = o.Raw(sql, baiinfoCode).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, baiinfoCode).First(&item).Error
 	return
 }
 
@@ -67,15 +65,14 @@ type BaseFromBaiinfoIndex struct {
 }
 
 func AddBaseFromBaiinfoIndex(item *BaseFromBaiinfoIndex) (lastId int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	lastId, err = o.Insert(item)
+	err = global.DbMap[utils.DbNameIndex].Create(item).Error
+	lastId = int64(item.BaseFromBaiinfoIndexId)
 	return
 }
 
 func GetBaseFromBaiinfoIndex() (list []*BaseFromBaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo_index `
-	_, err = o.Raw(sql).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&list).Error
 	return
 }
 
@@ -91,110 +88,108 @@ type BaseFromBaiinfoData struct {
 }
 
 func AddBaseFromBaiinfoData(item *BaseFromBaiinfoData) (lastId int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	lastId, err = o.Insert(item)
+	err = global.DbMap[utils.DbNameIndex].Create(item).Error
 	return
 }
 
 func GetBaseFromBaiinfoDataAll() (list []*BaseFromBaiinfoData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo_data `
-	_, err = o.Raw(sql).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&list).Error
 	return
 }
 
 func ModifyBaseFromBaiinfoData(baiinfoDataId int, value string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_baiinfo_data SET value=?,modify_time=NOW() WHERE baiinfo_data_id=? `
-	_, err = o.Raw(sql, value, baiinfoDataId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, value, baiinfoDataId).Error
 	return
 }
 
 func GetBaseFromBaiinfoIndexByBaiinfoCode(baiinfoCode string) (list []*BaseFromBaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_index WHERE interface=? `
-	_, err = o.Raw(sql, baiinfoCode).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, baiinfoCode).Find(&list).Error
 	return
 }
 
-func GetBaseFromBaiinfoMaxOrMinDate(indexCode string) (min_date, max_date string, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT MIN(data_time) AS min_date,MAX(data_time) AS max_date FROM base_from_baiinfo_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&min_date, &max_date)
-	return
-}
+//func GetBaseFromBaiinfoMaxOrMinDate(indexCode string) (min_date, max_date string, err error) {
+//	sql := ` SELECT MIN(data_time) AS min_date,MAX(data_time) AS max_date FROM base_from_baiinfo_data WHERE index_code=? `
+//	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Scan(&min_date, &max_date).Error
+//	return
+//}
 
 func ModifyBaseFromBaiinfoMinDateAndMaxDate(baseFromBaiinfoIndexId int, minDate, maxDate string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` UPDATE base_from_baiinfo_index SET start_date=?,end_date=?,modify_time=NOW() WHERE base_from_baiinfo_index_id=? `
-	_, err = o.Raw(sql, minDate, maxDate, baseFromBaiinfoIndexId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, minDate, maxDate, baseFromBaiinfoIndexId).Error
 	return
 }
 
 func GetBaseFromBaiinfoDataAllByIndexCode(indexCode string) (list []*BaseFromBaiinfoData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo_data WHERE index_code=? `
-	_, err = o.Raw(sql, indexCode).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&list).Error
 	return
 }
 
 func GetBaseFromBaiinfoIndexByIndexCode(indexCode string) (list *BaseFromBaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_index WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&list).Error
 	return
 }
 
 // GetBaseFromBaiinfoIndexCountByClassifyIds 获取分类下指标的个数
 func GetBaseFromBaiinfoIndexCountByClassifyIds(classifyIds []int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	num := len(classifyIds)
 	if num <= 0 {
 		return
 	}
-	sql := `SELECT COUNT(1) AS count FROM base_from_baiinfo_index WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
-	err = o.Raw(sql, classifyIds).QueryRow(&count)
+	sqlStr := `SELECT COUNT(1) AS count FROM base_from_baiinfo_index WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyIds).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 // GetBaseFromBaiinfoIndexByClassifyId 获取根据分类查询指标
 func GetBaseFromBaiinfoIndexByClassifyId(classifyId int) (list []*BaseFromBaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo_index WHERE classify_id =? ORDER BY sort ASC, base_from_baiinfo_index_id ASC `
-	_, err = o.Raw(sql, classifyId).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&list).Error
 	return
 }
 
 // GetBaiinfoIndexAll 用于分类展示
 func GetBaiinfoIndexAll() (items []*BaseFromBaiinfoClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT base_from_baiinfo_index_id, classify_id, index_name as classify_name, index_code as base_from_baiinfo_index_code
             FROM base_from_baiinfo_index ORDER BY sort ASC, base_from_baiinfo_index_id ASC `
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
 // GetBaseFromBaiinfoIndexByIndexId 根据指标id获取指标信息
 func GetBaseFromBaiinfoIndexByIndexId(indexId int) (item *BaseFromBaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo_index WHERE base_from_baiinfo_index_id=? `
-	err = o.Raw(sql, indexId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexId).First(&item).Error
 	return
 }
 
 // GetBaseFromBaiinfoIndexMaxSortByClassifyId 根据指标id获取指标信息
 func GetBaseFromBaiinfoIndexMaxSortByClassifyId(classifyId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT max(sort) FROM base_from_baiinfo_index WHERE classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&sort)
+	sqlStr := `SELECT max(sort) FROM base_from_baiinfo_index WHERE classify_id=? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		sort = 0
+	} else {
+		sort = int(totalNull.Int64)
+	}
 	return
 }
 
 // GetBaseFromBaiinfoIndexMinSortByClassifyId 获取最小不等于0的排序
 func GetBaseFromBaiinfoIndexMinSortByClassifyId(classifyId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT min(sort) FROM base_from_baiinfo_index WHERE classify_id=? and sort <> 0 `
-	err = o.Raw(sql, classifyId).QueryRow(&sort)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Scan(&sort).Error
 	return
 }
 
@@ -205,90 +200,79 @@ type BaseFromBaiinfoIndexType struct {
 
 // GetBaseFromBaiinfoIndexType 获取历史指标信息类型
 func GetBaseFromBaiinfoIndexType() (list []BaseFromBaiinfoIndexType, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT type_2, type_3 from base_from_baiinfo_index where type_2 <> "" GROUP BY type_2, type_3`
-	_, err = o.Raw(sql).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&list).Error
 	return
 }
 
 // MoveBaseFromBaiinfoIndex 移动指标分类
 func MoveBaseFromBaiinfoIndex(chartInfoId, classifyId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` UPDATE base_from_baiinfo_index
 			SET
 			  classify_id = ?, modify_time=NOW() 
 			WHERE base_from_baiinfo_index_id = ?`
-	_, err = o.Raw(sql, classifyId, chartInfoId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId, chartInfoId).Error
 	return
 }
 
 // UpdateBaseFromBaiinfoIndexByClassifyId 根据指标id更新排序
 func UpdateBaseFromBaiinfoIndexByClassifyId(classifyId, nowSort, prevIndexInfoId int, updateSort string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` update base_from_baiinfo_index set sort = ` + updateSort + ` WHERE classify_id=? AND  `
 	if prevIndexInfoId > 0 {
 		sql += ` ( sort > ? or (base_from_baiinfo_index_id > ` + fmt.Sprint(prevIndexInfoId) + ` and sort = ` + fmt.Sprint(nowSort) + `))`
 	}
-	_, err = o.Raw(sql, classifyId, nowSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId, nowSort).Error
 	return
 }
 
 // MoveUpBaiinfoIndexBySort 往上移动
 func MoveUpBaiinfoIndexBySort(classifyId, nextSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_baiinfo_index set sort = sort + 1 where classify_id=? and sort >= ? and sort< ?`
-	_, err = o.Raw(sql, classifyId, nextSort, currentSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId, nextSort, currentSort).Error
 	return
 }
 
 // MoveDownBaiinfoIndexBySort 往下移动
 func MoveDownBaiinfoIndexBySort(classifyId, prevSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_baiinfo_index set sort = sort - 1 where classify_id=? and sort <= ? and sort> ? `
-	_, err = o.Raw(sql, classifyId, prevSort, currentSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId, prevSort, currentSort).Error
 	return
 }
 
 // GetFirstBaseFromBaiinfoIndexByClassifyId 获取当前分类下，且排序数相同 的排序第一条的数据
 func GetFirstBaseFromBaiinfoIndexByClassifyId(classifyId int) (item *BaseFromBaiinfoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_index WHERE classify_id=? order by sort asc,base_from_baiinfo_index_id asc limit 1`
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).First(&item).Error
 	return
 }
 
 // Update 更新Baiinfo指标基础信息
 func (item *BaseFromBaiinfoIndex) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(item, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(item).Error
 	return
 }
 
 // DeleteBaseFromBaiinfoIndexById 根据指标id删除对应的指标、指标数据
 func DeleteBaseFromBaiinfoIndexById(baiinfoIndexId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	to, err := o.Begin()
-	if err != nil {
-		return
-	}
+	tx := global.DbMap[utils.DbNameIndex].Begin()
 	defer func() {
 		if err != nil {
-			_ = to.Rollback()
+			_ = tx.Rollback()
 		} else {
-			_ = to.Commit()
+			_ = tx.Commit()
 		}
 	}()
 
 	//删除指标
 	sql := `DELETE FROM base_from_baiinfo_index WHERE base_from_baiinfo_index_id = ? `
-	_, err = to.Raw(sql, baiinfoIndexId).Exec()
+	err = tx.Exec(sql, baiinfoIndexId).Error
 	if err != nil {
 		return
 	}
 
 	//删除指标数据
 	sql = `DELETE FROM base_from_baiinfo_data WHERE base_from_baiinfo_index_id = ? `
-	_, err = to.Raw(sql, baiinfoIndexId).Exec()
+	err = tx.Exec(sql, baiinfoIndexId).Error
 	if err != nil {
 		return
 	}

models/data_manage/base_from_baiinfo_classify.go

@@ -1,9 +1,10 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"time"
 )
 
@@ -23,16 +24,21 @@ type BaseFromBaiinfoClassify struct {
 
 // AddBaseFromBaiinfoClassify 添加SMM原始数据分类
 func AddBaseFromBaiinfoClassify(item *BaseFromBaiinfoClassify) (lastId int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	lastId, err = o.Insert(item)
+	err = global.DbMap[utils.DbNameIndex].Create(item).Error
+	lastId = int64(item.ClassifyId)
 	return
 }
 
 // GetBaseFromBaiinfoClassifyCount 获取分类名称的个数
 func GetBaseFromBaiinfoClassifyCount(classifyName string, parentId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT COUNT(1) AS count FROM base_from_baiinfo_classify WHERE classify_name=? AND parent_id=? `
-	err = o.Raw(sql, classifyName, parentId).QueryRow(&count)
+	sqlStr := `SELECT COUNT(1) AS count FROM base_from_baiinfo_classify WHERE classify_name=? AND parent_id=? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyName, parentId).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
@@ -45,25 +51,28 @@ func GetBaseFromBaiinfoClassifyCount(classifyName string, parentId int) (count i
 // @return count int
 // @return err error
 func GetBaseFromBaiinfoClassifyEnCount(classifyNameEn string, parentId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT COUNT(1) AS count FROM base_from_baiinfo_classify WHERE classify_name_en = ? AND parent_id=? `
-	err = o.Raw(sql, classifyNameEn, parentId).QueryRow(&count)
+	sqlStr := `SELECT COUNT(1) AS count FROM base_from_baiinfo_classify WHERE classify_name_en = ? AND parent_id=? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyNameEn, parentId).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 // GetBaseFromBaiinfoClassifyById 通过分类id的获取分类信息
 func GetBaseFromBaiinfoClassifyById(classifyId int) (item *BaseFromBaiinfoClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_baiinfo_classify WHERE classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).First(&item).Error
 	return
 }
 
 // EditBaseFromBaiinfoClassify 修改SMM原始数据分类
 func EditBaseFromBaiinfoClassify(classifyId int, classifyName string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_baiinfo_classify SET classify_name=?,modify_time=NOW() WHERE classify_id=? `
-	_, err = o.Raw(sql, classifyName, classifyId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyName, classifyId).Error
 	return
 }
 
@@ -75,17 +84,15 @@ func EditBaseFromBaiinfoClassify(classifyId int, classifyName string) (err error
 // @param classifyNameEn string
 // @return err error
 func EditBaseFromBaiinfoClassifyEn(classifyId int, classifyNameEn string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_baiinfo_classify SET classify_name_en = ?,modify_time=NOW() WHERE classify_id=? `
-	_, err = o.Raw(sql, classifyNameEn, classifyId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyNameEn, classifyId).Error
 	return
 }
 
 // UpdateBaseFromBaiinfoClassifySort 修改SMM原始数据分类的排序
 func UpdateBaseFromBaiinfoClassifySort(classifyId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_baiinfo_classify SET sort=classify_id, modify_time=NOW() WHERE classify_id=? `
-	_, err = o.Raw(sql, classifyId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId).Error
 	return
 }
 
@@ -128,17 +135,15 @@ type BaseFromBaiinfoClassifyItemsButton struct {
 
 // GetBaseFromBaiinfoClassifyByParentId 根据上级id获取当下的分类列表数据
 func GetBaseFromBaiinfoClassifyByParentId(parentId int) (items []*BaseFromBaiinfoClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_classify WHERE parent_id=? order by sort asc,classify_id asc`
-	_, err = o.Raw(sql, parentId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId).Find(&items).Error
 	return
 }
 
 // GetAllBaseFromBaiinfoClassify 获取所有的分类列表数据
 func GetAllBaseFromBaiinfoClassify() (items []*BaseFromBaiinfoClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_classify WHERE parent_id <> 0 order by sort asc,classify_id asc`
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
@@ -160,51 +165,52 @@ type BaseFromBaiinfoClassifySimplify struct {
 
 // GetFirstBaseFromBaiinfoClassify 获取当前分类下，且排序数相同 的排序第一条的数据
 func GetFirstBaseFromBaiinfoClassify() (item *BaseFromBaiinfoClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_baiinfo_classify order by sort asc,classify_id asc limit 1`
-	err = o.Raw(sql).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).First(&item).Error
 	return
 }
 
 // UpdateBaseFromBaiinfoClassifySortByClassifyId 根据分类id更新排序
 func UpdateBaseFromBaiinfoClassifySortByClassifyId(parentId, classifyId, nowSort int, updateSort string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` update base_from_baiinfo_classify set sort = ` + updateSort + ` WHERE parent_id=? AND sort > ? `
 	if classifyId > 0 {
 		sql += ` or ( classify_id > ` + fmt.Sprint(classifyId) + ` and sort = ` + fmt.Sprint(nowSort) + `)`
 	}
-	_, err = o.Raw(sql, parentId, nowSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, parentId, nowSort).Error
 	return
 }
 
 // MoveUpBaiinfoIndexClassifyBySort 往上移动
 func MoveUpBaiinfoIndexClassifyBySort(parentId, nextSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_baiinfo_classify set sort = sort + 1 where parent_id=? and sort >= ? and sort< ?`
-	_, err = o.Raw(sql, parentId, nextSort, currentSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, parentId, nextSort, currentSort).Error
 	return
 }
 
 // MoveDownBaiinfoIndexClassifyBySort 往下移动
 func MoveDownBaiinfoIndexClassifyBySort(parentId, prevSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_baiinfo_classify set sort = sort - 1 where parent_id=? and sort <= ? and sort> ? `
-	_, err = o.Raw(sql, parentId, prevSort, currentSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, parentId, prevSort, currentSort).Error
 	return
 }
 
 // GetBaiinfoIndexClassifyMinSort 获取最小不等于0的排序
 func GetBaiinfoIndexClassifyMinSort(parentId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `select min(sort) from base_from_baiinfo_classify where parent_id=? and sort <> 0 `
-	err = o.Raw(sql, parentId).QueryRow(&sort)
+	sqlStr := `select min(sort) from base_from_baiinfo_classify where parent_id=? and sort <> 0 `
+
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, parentId).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		sort = 0
+	} else {
+		sort = int(totalNull.Int64)
+	}
 	return
 }
 
 // Update 更新分类基础信息
 func (BaseFromBaiinfoClassify *BaseFromBaiinfoClassify) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(BaseFromBaiinfoClassify, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(BaseFromBaiinfoClassify).Error
 	return
 }
 
@@ -214,36 +220,32 @@ type AddBaiinfoClassifyResp struct {
 
 // DeleteBaiinfoClassifyByClassifyId 根据分类id删除对应的指标分类
 func DeleteBaiinfoClassifyByClassifyId(classifyIdList []int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	num := len(classifyIdList)
 	if num <= 0 {
 		return
 	}
 	//删除分类
 	sql := `DELETE FROM base_from_baiinfo_classify WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
-	_, err = o.Raw(sql, classifyIdList).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyIdList).Error
 	return
 }
 
 // AddBaiinfoClassifyMulti 批量新增SMM类别
 func AddBaiinfoClassifyMulti(list []*BaseFromBaiinfoClassify) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(1, list)
+	err = global.DbMap[utils.DbNameIndex].CreateInBatches(list, len(list)).Error
 	return
 }
 
 // InitBaiinfoClassifySort 初始化sort值
 func InitBaiinfoClassifySort() (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_baiinfo_classify 
 SET modify_time=NOW(), sort = classify_id`
-	_, err = o.Raw(sql).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql).Error
 	return
 }
 
 // InitBaiinfoIndexClassifyId 历史数据的classifyId值
 func InitBaiinfoIndexClassifyId() (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_baiinfo_index s
 LEFT JOIN (
 SELECT
@@ -254,6 +256,6 @@ FROM
 	LEFT JOIN base_from_baiinfo_classify c2 ON c1.parent_id = c2.classify_id 
 	) AS t ON CONCAT( s.type_2, s.type_3 ) = t.type_name
 	SET s.classify_id = t.classify_id, s.modify_time=NOW() where s.type_2 <>""`
-	_, err = o.Raw(sql).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql).Error
 	return
 }

models/data_manage/base_from_bloomberg_index.go

@@ -1,9 +1,10 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"strings"
 	"time"
@@ -74,12 +75,7 @@ func (m *BaseFromBloombergIndex) PrimaryId() string {
 }
 
 func (m *BaseFromBloombergIndex) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
-	if err != nil {
-		return
-	}
-	m.BaseFromBloombergIndexId = int(id)
+	err = global.DbMap[utils.DbNameIndex].Create(m).Error
 	return
 }
 
@@ -87,21 +83,18 @@ func (m *BaseFromBloombergIndex) CreateMulti(items []*BaseFromBloombergIndex) (e
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	err = global.DbMap[utils.DbNameIndex].CreateInBatches(items, len(items)).Error
 	return
 }
 
 func (m *BaseFromBloombergIndex) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(m).Error
 	return
 }
 
 func (m *BaseFromBloombergIndex) Del() (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.PrimaryId())
-	_, err = o.Raw(sql, m.BaseFromBloombergIndexId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, m.BaseFromBloombergIndexId).Error
 	return
 }
 
@@ -109,39 +102,40 @@ func (m *BaseFromBloombergIndex) MultiDel(menuIds []int) (err error) {
 	if len(menuIds) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s IN (%s)`, m.TableName(), m.PrimaryId(), utils.GetOrmInReplace(len(menuIds)))
-	_, err = o.Raw(sql, menuIds).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, menuIds).Error
 	return
 }
 
 func (m *BaseFromBloombergIndex) GetItemById(id int) (item *BaseFromBloombergIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.PrimaryId())
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, id).First(&item).Error
 	return
 }
 
 func (m *BaseFromBloombergIndex) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *BaseFromBloombergIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	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 = global.DbMap[utils.DbNameIndex].Raw(sql, pars).First(&item).Error
 	return
 }
 
 func (m *BaseFromBloombergIndex) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	sqlStr := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, pars).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 func (m *BaseFromBloombergIndex) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, limit int) (items []*BaseFromBloombergIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -154,12 +148,11 @@ func (m *BaseFromBloombergIndex) GetItemsByCondition(condition string, pars []in
 	if limit > 0 {
 		sql += fmt.Sprintf(` LIMIT %d`, limit)
 	}
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 func (m *BaseFromBloombergIndex) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*BaseFromBloombergIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -169,7 +162,7 @@ func (m *BaseFromBloombergIndex) 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 = global.DbMap[utils.DbNameIndex].Raw(sql, pars, startSize, pageSize).Find(&items).Error
 	return
 }
 
@@ -235,9 +228,8 @@ type BloombergSourceListResp struct {
 
 // UpdateEdbExist 标记已添加指标库
 func (m *BaseFromBloombergIndex) UpdateEdbExist(indexCode string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`UPDATE %s SET %s = ? WHERE %s = ? LIMIT 1`, m.TableName(), BaseFromBloombergIndexCols.EdbExist, BaseFromBloombergIndexCols.IndexCode)
-	_, err = o.Raw(sql, 1, indexCode).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, 1, indexCode).Error
 	return
 }
 

models/data_manage/base_from_business_data.go

@@ -1,9 +1,10 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"fmt"
-	"github.com/beego/beego/v2/client/orm"
 	"strings"
 	"time"
 )
@@ -66,7 +67,6 @@ type WhereParams struct {
 // @return result []BaseFromBusinessData
 // @return err error
 func (m *BaseFromBusinessData) GetAllDataList(condition string, pars []interface{}, order string) (result []*BaseFromBusinessData, err error) {
-	o := orm.NewOrmUsingDB("data")
 
 	sql := `SELECT * FROM base_from_business_data WHERE 1=1 `
 	if condition != `` {
@@ -77,7 +77,7 @@ func (m *BaseFromBusinessData) GetAllDataList(condition string, pars []interface
 		sql += ` ORDER BY ` + order
 	}
 
-	_, err = o.Raw(sql, pars).QueryRows(&result)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&result).Error
 
 	return
 }
@@ -92,7 +92,6 @@ func (m *BaseFromBusinessData) GetAllDataList(condition string, pars []interface
 // @return result []*BaseFromBusinessData
 // @return err error
 func (m *BaseFromBusinessData) GetLimitDataList(condition string, pars []interface{}, order string, size int64) (result []*BaseFromBusinessData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_business_data WHERE 1=1 `
 	if condition != `` {
 		sql += ` ` + condition
@@ -104,8 +103,7 @@ func (m *BaseFromBusinessData) GetLimitDataList(condition string, pars []interfa
 
 	sql += fmt.Sprintf(` LIMIT %d`, size)
 
-	_, err = o.Raw(sql, pars).QueryRows(&result)
-
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&result).Error
 	return
 }
 
@@ -121,7 +119,6 @@ func (m *BaseFromBusinessData) GetLimitDataList(condition string, pars []interfa
 // @return result []*BaseFromBusinessData
 // @return err error
 func (m *BaseFromBusinessData) GetPageDataList(condition []string, pars []interface{}, order string, startSize, size int64) (result []*BaseFromBusinessData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_business_data `
 	if len(condition) > 0 {
 		sql += ` WHERE ` + strings.Join(condition, " AND ")
@@ -132,8 +129,7 @@ func (m *BaseFromBusinessData) GetPageDataList(condition []string, pars []interf
 	}
 
 	sql += fmt.Sprintf(` LIMIT %d,%d`, startSize, size)
-
-	_, err = o.Raw(sql, pars).QueryRows(&result)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&result).Error
 
 	return
 }
@@ -147,13 +143,17 @@ func (m *BaseFromBusinessData) GetPageDataList(condition []string, pars []interf
 // @return count int64
 // @return err error
 func (m *BaseFromBusinessData) GetCountDataList(condition []string, pars []interface{}) (count int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT COUNT(1) FROM base_from_business_data `
+	sqlStr := `SELECT COUNT(1) FROM base_from_business_data `
 	if len(condition) > 0 {
-		sql += ` WHERE ` + strings.Join(condition, " AND ")
+		sqlStr += ` WHERE ` + strings.Join(condition, " AND ")
+	}
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, pars).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = totalNull.Int64
 	}
-	err = o.Raw(sql, pars).QueryRow(&count)
-
 	return
 }
 
@@ -165,9 +165,7 @@ func (m *BaseFromBusinessData) GetCountDataList(condition []string, pars []inter
 // @param addData interface{}
 // @return err error
 func (m *BaseFromBusinessData) InsertDataByColl(addData interface{}) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Insert(addData)
-
+	err = global.DbMap[utils.DbNameIndex].Create(addData).Error
 	return
 }
 
@@ -180,9 +178,7 @@ func (m *BaseFromBusinessData) InsertDataByColl(addData interface{}) (err error)
 // @param dataList []interface{}
 // @return err error
 func (m *BaseFromBusinessData) BatchInsertData(bulk int, dataList []interface{}) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(bulk, dataList)
-
+	err = global.DbMap[utils.DbNameIndex].CreateInBatches(dataList, bulk).Error
 	return
 }
 
@@ -195,13 +191,12 @@ func (m *BaseFromBusinessData) BatchInsertData(bulk int, dataList []interface{})
 // @param updateParams interface{}
 // @return err error
 func (m *BaseFromBusinessData) UpdateData(updateCols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, updateCols...)
-	if err != nil {
-		fmt.Println("UpdateDataByColl:Err:" + err.Error())
-		return
-	}
-
+	//_, err = o.Update(m, updateCols...)
+	//if err != nil {
+	//	fmt.Println("UpdateDataByColl:Err:" + err.Error())
+	//	return
+	//}
+	err = global.DbMap[utils.DbNameIndex].Select(updateCols).Updates(m).Error
 	return
 }
 
@@ -214,17 +209,16 @@ func (m *BaseFromBusinessData) UpdateData(updateCols []string) (err error) {
 // @return result EdbInfoMaxAndMinInfo
 // @return err error
 func (m *BaseFromBusinessData) GetEdbInfoMaxAndMinInfo(indexCode string) (result EdbInfoMaxAndMinInfo, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ``
 	sql = ` SELECT MIN(data_time) AS min_date,MAX(data_time) AS max_date,MIN(value) AS min_value,MAX(value) AS max_value FROM base_from_business_data WHERE index_code = ? `
-	err = o.Raw(sql, indexCode).QueryRow(&result)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&result).Error
 	if err != nil {
 		return
 	}
 
 	var latestValue float64
 	sql = ` SELECT value AS latest_value FROM base_from_business_data WHERE index_code = ? ORDER BY data_time DESC LIMIT 1 `
-	err = o.Raw(sql, indexCode).QueryRow(&latestValue)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Scan(&latestValue).Error
 	result.LatestValue = latestValue
 
 	return

models/data_manage/base_from_business_index.go

@@ -1,8 +1,9 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
-	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"time"
 )
@@ -75,9 +76,8 @@ type EdbBusinessSource struct {
 // @return item *EdbBusinessSource
 // @return err error
 func (m *EdbBusinessSource) GetEdbBusinessSourceItem(sourceName string) (item *EdbBusinessSource, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM edb_business_source WHERE source_name = ? `
-	err = o.Raw(sql, sourceName).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, sourceName).First(&item).Error
 	return
 }
 
@@ -89,9 +89,8 @@ func (m *EdbBusinessSource) GetEdbBusinessSourceItem(sourceName string) (item *E
 // @return items []*EdbBusinessSource
 // @return err error
 func (m *EdbBusinessSource) GetAllList() (items []*EdbBusinessSource, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM edb_business_source order by  edb_business_source_id desc `
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 
 	return
 }
@@ -106,13 +105,17 @@ func (m *EdbBusinessSource) GetAllList() (items []*EdbBusinessSource, err error)
 // @return count int
 // @return err error
 func (m *BaseFromBusinessIndex) GetListCount(condition string, pars []interface{}) (count int, err error) {
-	sql := ` select count(1) as count FROM base_from_business_index as a WHERE 1=1 `
+	sqlStr := ` select count(1) as count FROM base_from_business_index as a WHERE 1=1 `
 	if condition != "" {
-		sql += condition
+		sqlStr += condition
+	}
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, pars).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
 	}
-	o := orm.NewOrmUsingDB("data")
-	err = o.Raw(sql, pars).QueryRow(&count)
-
 	return
 }
 
@@ -133,8 +136,7 @@ func (m *BaseFromBusinessIndex) GetList(condition string, pars []interface{}, st
 		sql += condition
 	}
 	sql += ` order by a.base_from_business_index_id desc limit ?,? `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars, startSize, pageSize).Find(&items).Error
 
 	return
 }
@@ -180,8 +182,7 @@ func (m *BaseFromBusinessIndex) GetPageItemsByCondition(condition string, pars [
 		sql += ` order by ` + orderRule
 	}
 	sql += ` limit ?,? `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, utils.DATA_SOURCE_BUSINESS, pars, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, utils.DATA_SOURCE_BUSINESS, pars, startSize, pageSize).Find(&items).Error
 
 	return
 }
@@ -212,8 +213,7 @@ func (m *BaseFromBusinessIndex) GeItemsByCondition(condition string, pars []inte
 		pars = append(pars, limitSize)
 	}
 
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, utils.DATA_SOURCE_BUSINESS, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, utils.DATA_SOURCE_BUSINESS, pars).Find(&items).Error
 
 	return
 }
@@ -228,9 +228,7 @@ func (m *BaseFromBusinessIndex) GeItemsByCondition(condition string, pars []inte
 // @return err error
 func (m *BaseFromBusinessIndex) GetDetailByEdbCode(edbCode string) (item *BaseFromBusinessIndex, err error) {
 	sql := `select *  FROM base_from_business_index  WHERE index_code = ? `
-	o := orm.NewOrmUsingDB("data")
-	err = o.Raw(sql, edbCode).QueryRow(&item)
-
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, edbCode).Find(&item).Error
 	return
 }
 

models/data_manage/base_from_ccf.go

@@ -1,8 +1,9 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
-	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"time"
 )
@@ -55,20 +56,24 @@ type CCFSingleData struct {
 }
 
 func GetCCFIndex(condition string, pars interface{}) (items []*BaseFromCCFIndexList, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_ccf_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC, base_from_ccf_index_id asc`
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 func GetCCFIndexDataCount(indexCode string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count FROM base_from_ccf_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(1) AS count FROM base_from_ccf_data WHERE index_code=? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, indexCode).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
@@ -81,16 +86,14 @@ func GetCCFIndexDataCountGroup(indexCodes []string) (items []*CCFIndexDataCountG
 	if len(indexCodes) <= 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count, index_code FROM base_from_ccf_data WHERE index_code IN (` + utils.GetOrmInReplace(len(indexCodes)) + `) GROUP BY index_code`
-	_, err = o.Raw(sql, indexCodes).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes).Find(&items).Error
 	return
 }
 
 func GetCCFIndexData(indexCode string, startSize, pageSize int) (items []*BaseFromCCFData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_ccf_data WHERE index_code=? ORDER BY data_time DESC LIMIT ?,? `
-	_, err = o.Raw(sql, indexCode, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode, startSize, pageSize).Find(&items).Error
 	return
 }
 
@@ -98,9 +101,8 @@ func GetCCFIndexDataByCodes(indexCode []string) (items []*BaseFromCCFData, err e
 	if len(indexCode) <= 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_ccf_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCode)) + `) ORDER BY data_time DESC  `
-	_, err = o.Raw(sql, indexCode).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&items).Error
 	return
 }
 
@@ -124,47 +126,42 @@ type BaseFromCCFIndexSearchItem struct {
 
 // GetCCFItemList 模糊查询CCF数据库指标列表
 func GetCCFItemList(condition string) (items []*BaseFromCCFIndexSearchItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := "SELECT * FROM base_from_ccf_index WHERE 1=1"
 	if condition != "" {
 		sql += condition
 	}
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
 func GetCCFIndexDataByCode(indexCode string) (list []*BaseFromCCFData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_ccf_data WHERE index_code=? `
-	_, err = o.Raw(sql, indexCode).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&list).Error
 	return
 }
 
 func GetBaseFromCCFIndexByIndexCode(indexCode string) (list *BaseFromCCFIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_ccf_index WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&list).Error
 	return
 }
 
 func GetCCFIndexPage(condition string, pars interface{}, startSize, pageSize int) (items []*BaseFromCCFIndexList, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_ccf_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC, base_from_ccf_index_id asc LIMIT ?,?`
-	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars, startSize, pageSize).Find(&items).Error
 	return
 }
 
 func GetCCFIndexPageCount(condition string, pars interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count  FROM base_from_ccf_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Scan(&count).Error
 	return
 }
 
@@ -194,31 +191,33 @@ type BatchCheckCCFEdbReq struct {
 }
 
 func GetCCFFrequencyByClassifyId(classifyId int) (items []*GlFrequency, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT frequency FROM base_from_ccf_index WHERE classify_id = ? `
 	sql += ` GROUP BY frequency ORDER BY frequency ASC `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
 func GetCCFIndexDataByDataTime(indexCodes []string, startDate, endDate string) (items []*BaseFromCCFData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_ccf_data WHERE  index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `) and data_time >=? and data_time <? ORDER BY data_time DESC `
-	_, err = o.Raw(sql, indexCodes, startDate, endDate).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes, startDate, endDate).Find(&items).Error
 	return
 }
 
 func GetCCFIndexDataTimePageByCodes(indexCodes []string, startSize, pageSize int) (dataTimes []string, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT data_time FROM base_from_ccf_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `) GROUP BY data_time ORDER BY data_time DESC LIMIT ?,? `
-	_, err = o.Raw(sql, indexCodes, startSize, pageSize).QueryRows(&dataTimes)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes, startSize, pageSize).Find(&dataTimes).Error
 	return
 }
 
 func GetCCFIndexDataTimePageCount(indexCodes []string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(DISTINCT data_time) AS count  FROM base_from_ccf_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `)`
-	err = o.Raw(sql, indexCodes).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(DISTINCT data_time) AS count  FROM base_from_ccf_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `)`
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, indexCodes).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
@@ -227,15 +226,13 @@ func GetCCFDataDataTimeByIndexId(indexIdList []int) (items []string, err error)
 	if len(indexIdList) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT DISTINCT data_time FROM base_from_ccf_data WHERE base_from_ccf_index_id IN (` + utils.GetOrmInReplace(len(indexIdList)) + `) ORDER BY data_time DESC`
-	_, err = o.Raw(sql, indexIdList).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexIdList).Find(&items).Error
 	return
 }
 
 func GetCCFIndexDataByIndexIdAndDataTime(indexId []int, dataTimeList []string) (items []*BaseFromCCFData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_ccf_data WHERE  base_from_ccf_index_id in (` + utils.GetOrmInReplace(len(indexId)) + `) and data_time in (` + utils.GetOrmInReplace(len(dataTimeList)) + `)  `
-	_, err = o.Raw(sql, indexId, dataTimeList).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexId, dataTimeList).Find(&items).Error
 	return
 }

models/data_manage/base_from_ccf_classify.go

@@ -1,8 +1,8 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
-	"github.com/beego/beego/v2/client/orm"
 	"time"
 )
 
@@ -21,9 +21,8 @@ type BaseFromCCFClassify struct {
 
 // GetBaseFromCCFClassify 获取所有分类
 func GetBaseFromCCFClassify() (items []*BaseFromCCFClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_ccf_classify ORDER BY parent_id ASC, sort ASC, base_from_ccf_classify_id ASC`
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 

models/data_manage/base_from_changes_visitors_covid.go

@@ -1,11 +1,20 @@
 package data_manage
 
-import "github.com/beego/beego/v2/client/orm"
+import (
+	"database/sql"
+	"eta/eta_api/global"
+	"eta/eta_api/utils"
+)
 
 func GetVisitorsCovidLastDate() (last_date string, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT max(a.day) AS last_date FROM base_from_changes_visitors_covid AS a `
-	err = o.Raw(sql).QueryRow(&last_date)
+	sqlStr := ` SELECT max(a.day) AS last_date FROM base_from_changes_visitors_covid AS a `
+	var lastDateNull sql.NullString
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr).Scan(&lastDateNull).Error
+	if !lastDateNull.Valid {
+		last_date = ""
+	} else {
+		last_date = lastDateNull.String
+	}
 	return
 }
 
@@ -27,10 +36,9 @@ type BaseFromChangesVisitorsCovid struct {
 }
 
 func GetVisitorsCovidList(day string) (list []*BaseFromChangesVisitorsCovid, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_changes_visitors_covid WHERE day=? `
 
 	sql += ` ORDER BY entity ASC `
-	_, err = o.Raw(sql, day).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, day).Find(&list).Error
 	return
 }

models/data_manage/base_from_clarksons_classify.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	"eta/eta_api/global"
 	"github.com/beego/beego/v2/client/orm"
 )
 
@@ -38,20 +39,17 @@ type BaseFromClarksonsClassifyMaxSort struct {
 }
 
 func (t *BaseFromClarksonsClassify) Add() (insertId int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	insertId, err = o.Insert(t)
+	err = global.DbMap[utils.DbNameIndex].Create(t).Error
 	return
 }
 
 func (t *BaseFromClarksonsClassify) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(t, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(t).Error
 	return
 }
 
 func BatchAddClarksonsClassify(items []*BaseFromClarksonsClassify) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	err = global.DbMap[utils.DbNameIndex].CreateInBatches(items, len(items)).Error
 	return
 }
 

models/data_manage/base_from_edb_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"
 )
 
 // BaseFromEdbMapping 同花顺高频数据
 type BaseFromEdbMapping struct {
-	Id              int       `orm:"column(id);pk"`
+	Id              int       `orm:"column(id);pk" gorm:"primaryKey" `
 	BaseFromIndexId int       `description:"源指标ID"`
 	BaseIndexCode   string    `description:"源指标编码"`
 	EdbInfoId       int       `description:"指标ID"`
@@ -55,12 +55,11 @@ func (m *BaseFromEdbMapping) Cols() BaseFromEdbMappingCols {
 }
 
 func (m *BaseFromEdbMapping) Create() (err error) {
-	o := orm.NewOrmUsingDB("data")
-	id, err := o.Insert(m)
+	err = global.DbMap[utils.DbNameIndex].Create(m).Error
 	if err != nil {
 		return
 	}
-	m.Id = int(id)
+
 	return
 }
 
@@ -68,21 +67,21 @@ func (m *BaseFromEdbMapping) CreateMulti(items []*BaseFromEdbMapping) (err error
 	if len(items) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.InsertMulti(len(items), items)
+	err = global.DbMap[utils.DbNameIndex].CreateInBatches(items, utils.MultiAddNum).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(m, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(m).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) Remove() (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	_, err = o.Raw(sql, m.Id).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, m.Id).Error
+
 	return
 }
 
@@ -90,9 +89,9 @@ func (m *BaseFromEdbMapping) MultiRemove(ids []int) (err error) {
 	if len(ids) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	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 = global.DbMap[utils.DbNameIndex].Exec(sql, ids).Error
+
 	return
 }
 
@@ -100,39 +99,38 @@ func (m *BaseFromEdbMapping) RemoveByCondition(condition string, pars []interfac
 	if condition == "" {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s`, m.TableName(), condition)
-	_, err = o.Raw(sql, pars).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, pars...).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) GetItemById(id int) (item *BaseFromEdbMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.Cols().PrimaryId)
-	err = o.Raw(sql, id).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, id).First(&item).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) GetItemByCondition(condition string, pars []interface{}, orderRule string) (item *BaseFromEdbMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
 	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 = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).First(&item).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
-	err = o.Raw(sql, pars).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Scan(&count).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*BaseFromEdbMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -142,12 +140,12 @@ func (m *BaseFromEdbMapping) GetItemsByCondition(condition string, pars []interf
 		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 = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).First(&items).Error
+
 	return
 }
 
 func (m *BaseFromEdbMapping) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*BaseFromEdbMapping, err error) {
-	o := orm.NewOrmUsingDB("data")
 	fields := strings.Join(fieldArr, ",")
 	if len(fieldArr) == 0 {
 		fields = `*`
@@ -157,6 +155,9 @@ func (m *BaseFromEdbMapping) GetPageItemsByCondition(condition string, pars []in
 		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)
+	pars = append(pars, startSize)
+	pars = append(pars, pageSize)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Scan(&items).Error
+
 	return
 }

models/data_manage/chart_classify.go

@@ -5,35 +5,33 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/beego/beego/v2/client/orm"
+	"database/sql"
+	"eta/eta_api/global"
 )
 
 type ChartClassify struct {
-	ChartClassifyId     int       `orm:"column(chart_classify_id);pk"`
-	ChartClassifyName   string    `description:"分类名称"`
-	ParentId            int       `description:"父级id"`
-	HasData             int       `description:"是否含有指标数据"`
-	CreateTime          time.Time `description:"创建时间"`
-	ModifyTime          time.Time `description:"修改时间"`
-	SysUserId           int       `description:"创建人id"`
-	SysUserRealName     string    `description:"创建人姓名"`
-	Level               int       `description:"层级"`
-	UniqueCode          string    `description:"唯一编码"`
-	Sort                int       `description:"排序字段，越小越靠前，默认值：10"`
-	Source              int       `description:"1：ETA图库；2：商品价格曲线"`
-	IsJoinPermission    int       `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
-	ChartClassifyNameEn string    `description:"英文分类名称"`
-	RootId              int       `description:"顶级ID"`
+	ChartClassifyId       int       `orm:"column(chart_classify_id);pk" gorm:"primaryKey" `
+	ChartClassifyName     string    `description:"分类名称"`
+	ParentId              int       `description:"父级id"`
+	HasData               int       `description:"是否含有指标数据"`
+	CreateTime            time.Time `description:"创建时间"`
+	ModifyTime            time.Time `description:"修改时间"`
+	SysUserId             int       `description:"创建人id"`
+	SysUserRealName       string    `description:"创建人姓名"`
+	Level                 int       `description:"层级"`
+	UniqueCode            string    `description:"唯一编码"`
+	Sort                  int       `description:"排序字段，越小越靠前，默认值：10"`
+	Source                int       `description:"1：ETA图库；2：商品价格曲线"`
+	IsJoinPermission      int       `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
+	ChartClassifyNameEn   string    `description:"英文分类名称"`
+	RootId                int       `description:"顶级ID"`
+	ChartClassifyNamePath string    `description:"分类名称的完整路径，格式为：父级分类名称|当前分类名称"`
+	ChartClassifyIdPath   string    `description:"分类的完整路径，格式为：父级ID,当前ID"`
 }
 
 func AddChartClassify(item *ChartClassify) (lastId int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	lastId, err = o.Insert(item)
-	if err != nil {
-		return
-	}
-	item.ChartClassifyId = int(lastId)
-
+	err = global.DbMap[utils.DbNameIndex].Create(item).Error
+	lastId = int64(item.ChartClassifyId)
 	return
 }
 
@@ -53,9 +51,10 @@ type AddChartClassifyReq struct {
 // @return count int
 // @return err error
 func GetChartClassifyCount(chartClassifyName string, parentId, source int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT COUNT(1) AS count FROM chart_classify WHERE parent_id=? AND source = ? AND chart_classify_name=? `
-	err = o.Raw(sql, parentId, source, chartClassifyName).QueryRow(&count)
+	err = o.Raw(sql, parentId, source, chartClassifyName).Scan(&count).Error
+
 	return
 }
 
@@ -69,9 +68,10 @@ func GetChartClassifyCount(chartClassifyName string, parentId, source int) (coun
 // @return count int
 // @return err error
 func GetChartClassifyEnCount(chartClassifyNameEn string, parentId, source int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT COUNT(1) AS count FROM chart_classify WHERE parent_id=? AND source = ? AND chart_classify_name_en = ? `
-	err = o.Raw(sql, parentId, source, chartClassifyNameEn).QueryRow(&count)
+	err = o.Raw(sql, parentId, source, chartClassifyNameEn).Scan(&count).Error
+
 	return
 }
 
@@ -82,16 +82,23 @@ type EditChartClassifyReq struct {
 }
 
 func GetChartClassifyById(classifyId int) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT * FROM chart_classify WHERE chart_classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = o.Raw(sql, classifyId).First(&item).Error
 	return
 }
 
 func GetChartClassifyCountById(classifyId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT count(1) AS count FROM chart_classify WHERE chart_classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&count)
+	o := global.DbMap[utils.DbNameIndex]
+	sqlStr := `SELECT count(1) AS count FROM chart_classify WHERE chart_classify_id=? `
+	var totalNull sql.NullInt64
+	err = o.Raw(sqlStr, classifyId).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
+
 	return
 }
 
@@ -104,9 +111,8 @@ func GetChartClassifyCountById(classifyId int) (count int, err error) {
 // @param chartClassifyName string
 // @return err error
 func EditChartClassify(classifyId, source int, chartClassifyName string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE chart_classify SET chart_classify_name=?,modify_time=NOW() WHERE chart_classify_id=? AND source = ? `
-	_, err = o.Raw(sql, chartClassifyName, classifyId, source).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, chartClassifyName, classifyId, source).Error
 	return
 }
 
@@ -119,9 +125,8 @@ func EditChartClassify(classifyId, source int, chartClassifyName string) (err er
 // @param chartClassifyNameEn string
 // @return err error
 func EditChartClassifyEn(classifyId, source int, chartClassifyNameEn string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE chart_classify SET chart_classify_name_en = ?,modify_time=NOW() WHERE chart_classify_id=? AND source = ? `
-	_, err = o.Raw(sql, chartClassifyNameEn, classifyId, source).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, chartClassifyNameEn, classifyId, source).Error
 	return
 }
 
@@ -131,8 +136,7 @@ type DeleteChartClassifyReq struct {
 }
 
 func GetChartInfoCountByClassifyId(classifyId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count FROM chart_info AS a
+	sqlStr := ` SELECT COUNT(1) AS count FROM chart_info AS a
 				WHERE a.chart_classify_id IN(
 				SELECT t.chart_classify_id FROM 
 				(
@@ -144,12 +148,19 @@ func GetChartInfoCountByClassifyId(classifyId int) (count int, err error) {
 				UNION SELECT * FROM chart_classify WHERE chart_classify_id = @pid
 				)AS t
 				) `
-	err = o.Raw(sql, classifyId).QueryRow(&count)
+
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&totalNull).Error
+
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 func DeleteChartClassify(classifyId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` DELETE FROM chart_classify
 				WHERE chart_classify_id IN(
 				SELECT t.chart_classify_id FROM
@@ -162,33 +173,30 @@ func DeleteChartClassify(classifyId int) (err error) {
 				UNION SELECT * FROM chart_classify WHERE chart_classify_id = @pid
 				)AS t
 				) `
-	_, err = o.Raw(sql, classifyId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId).Error
 	return
 }
 
 // GetChartClassifyByParentId
 // @param source int 1：ETA图库；2：商品价格曲线；3：相关性图表
 func GetChartClassifyByParentId(parentId, source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE parent_id=? AND source = ? order by sort asc,chart_classify_id asc`
-	_, err = o.Raw(sql, parentId, source).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId, source).Find(&items).Error
 	return
 }
 
 // GetChartClassifyAll
 // @param source int 1：ETA图库；2：商品价格曲线；3：相关性图表
 func GetChartClassifyAll(source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE parent_id<>0 AND source = ? order by sort asc,chart_classify_id asc`
-	_, err = o.Raw(sql, source).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, source).Find(&items).Error
 	return
 }
 
 // GetChartClassifyBySource 获取图表分类列表
 func GetChartClassifyBySource(source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE source = ? ORDER BY level ASC,chart_classify_id ASC`
-	_, err = o.Raw(sql, source).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, source).Find(&items).Error
 	return
 }
 
@@ -198,22 +206,22 @@ type ChartClassifyItems struct {
 	ChartClassifyName   string
 	ChartClassifyNameEn string
 	ParentId            int
-	Level               int    `description:"层级"`
-	Sort                int    `description:"排序字段，越小越靠前，默认值：10"`
-	UniqueCode          string `description:"唯一编码"`
-	Source              int    `description:"来源id"`
-	SourceName          string `description:"来源名称"`
-	SysUserId           int    `description:"创建人id"`
-	SysUserRealName     string `description:"创建人姓名"`
-	DateType            int    `description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
-	StartDate           string `description:"自定义开始日期"`
-	EndDate             string `description:"自定义结束日期"`
-	ChartType           int    `description:"生成样式:1:曲线图,2:季节性图"`
-	Calendar            string `description:"公历/农历"`
-	SeasonStartDate     string `description:"季节性图开始日期"`
-	SeasonEndDate       string `description:"季节性图开始日期"`
-	Children            []*ChartClassifyItems
-	Button              ChartClassifyItemsButton `description:"按钮权限"`
+	Level               int                      `description:"层级"`
+	Sort                int                      `description:"排序字段，越小越靠前，默认值：10"`
+	UniqueCode          string                   `description:"唯一编码"`
+	Source              int                      `description:"来源id"`
+	SourceName          string                   `description:"来源名称"`
+	SysUserId           int                      `description:"创建人id"`
+	SysUserRealName     string                   `description:"创建人姓名"`
+	DateType            int                      `description:"日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"`
+	StartDate           string                   `description:"自定义开始日期"`
+	EndDate             string                   `description:"自定义结束日期"`
+	ChartType           int                      `description:"生成样式:1:曲线图,2:季节性图"`
+	Calendar            string                   `description:"公历/农历"`
+	SeasonStartDate     string                   `description:"季节性图开始日期"`
+	SeasonEndDate       string                   `description:"季节性图开始日期"`
+	Children            []*ChartClassifyItems    `gorm:"-"`
+	Button              ChartClassifyItemsButton `gorm:"-" description:"按钮权限"`
 	IsJoinPermission    int                      `description:"是否加入权限管控，0：不加入；1：加入；默认：0"`
 	HaveOperaAuth       bool                     `description:"是否有数据权限，默认：false"`
 	Disable             bool                     `description:"勾选是否禁用"`
@@ -244,7 +252,6 @@ type ChartClassifyDeleteCheckReq struct {
 }
 
 func GetChartClassifyCountByClassifyId(chartClassifyId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count FROM (
 			SELECT rd.*
 			FROM (SELECT * FROM chart_classify WHERE parent_id IS NOT NULL) rd,
@@ -254,17 +261,18 @@ func GetChartClassifyCountByClassifyId(chartClassifyId int) (count int, err erro
 			UNION SELECT * FROM chart_classify WHERE chart_classify_id = @pid
 			)AS t
 			WHERE t.chart_classify_id<>? `
-	err = o.Raw(sql, chartClassifyId, chartClassifyId).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, chartClassifyId, chartClassifyId).Scan(&count).Error
 	return
 }
 
 func GetChartClassifyByCondition(condition string, pars []interface{}) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT * FROM chart_classify WHERE 1=1 `
 	if condition != "" {
 		sql += condition
 	}
-	err = o.Raw(sql, pars).QueryRow(&item)
+	err = o.Raw(sql, pars...).First(&item).Error
+
 	return
 }
 
@@ -281,98 +289,102 @@ type MoveChartClassifyReq struct {
 
 // GetFirstChartClassifyByParentId 获取当前父级图表分类下的排序第一条的数据
 func GetFirstChartClassifyByParentId(parentId int) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT * FROM chart_classify WHERE parent_id=? order by sort asc,chart_classify_id asc limit 1`
-	err = o.Raw(sql, parentId).QueryRow(&item)
+	err = o.Raw(sql, parentId).First(&item).Error
+
 	return
 }
 
 // GetFirstChartClassifyByParentIdAndSource 获取当前父级图表分类下的排序第一条的数据
 func GetFirstChartClassifyByParentIdAndSource(parentId, source int) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT * FROM chart_classify WHERE parent_id=?  and source = ? order by sort asc,chart_classify_id asc limit 1`
-	err = o.Raw(sql, parentId, source).QueryRow(&item)
+	err = o.Raw(sql, parentId, source).First(&item).Error
+
 	return
 }
 
 // UpdateChartClassifySortByParentId 根据图表父类id更新排序
 func UpdateChartClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string) (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` update chart_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? `
 	if classifyId > 0 {
 		sql += ` or ( chart_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
 	}
-	_, err = o.Raw(sql, parentId, nowSort).Exec()
+	err = o.Exec(sql, parentId, nowSort).Error
+
 	return
 }
 
 // Update 更新图表分类基础信息
 func (chartClassify *ChartClassify) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(chartClassify, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(chartClassify).Error
+
 	return
 }
 
 // GetChartClassifyMaxSort 获取图表分类下最大的排序数
 func GetChartClassifyMaxSort(parentId, source int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT Max(sort) AS sort FROM chart_classify WHERE parent_id=? AND source = ? `
-	err = o.Raw(sql, parentId, source).QueryRow(&sort)
+	o := global.DbMap[utils.DbNameIndex]
+	sql := `SELECT COALESCE(MAX(sort),0) AS sort FROM chart_classify WHERE parent_id=? AND source = ? `
+	err = o.Raw(sql, parentId, source).Scan(&sort).Error
+
 	return
 }
 
 type ChartClassifyView struct {
-	ChartClassifyId   int    `orm:"column(chart_classify_id);pk"`
+	ChartClassifyId   int    `orm:"column(chart_classify_id);pk" gorm:"primaryKey" `
 	ChartClassifyName string `description:"分类名称"`
 	ParentId          int    `description:"父级id"`
 }
 
 func GetChartClassifyViewById(classifyId int) (item *ChartClassifyView, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT * FROM chart_classify WHERE chart_classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = o.Raw(sql, classifyId).First(&item).Error
 	return
 }
 
 func GetChartClassifyByParentIdFromETA(parentId int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE parent_id=? AND source = 1 order by sort asc,chart_classify_id asc`
-	_, err = o.Raw(sql, parentId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId).Find(&items).Error
 	return
 }
 
 func GetChartClassifyAllFromETA() (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE parent_id<>0 AND source = 1 order by sort asc,chart_classify_id asc`
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
 func GetChartClassifyTwo(source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE level=3 AND source = ? order by sort asc,chart_classify_id asc`
-	_, err = o.Raw(sql, source).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, source).Find(&items).Error
 	return
 }
 
 func GetChartClassifyByLevel(level, source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT * FROM chart_classify WHERE level=? AND source = ? order by sort asc,chart_classify_id asc`
-	_, err = o.Raw(sql, level, source).QueryRows(&items)
+	err = o.Raw(sql, level, source).Scan(&items).Error
+
 	return
 }
 
 func EditChartClassifySysUser(classifyId, sysUserId int, chartClassifyName string) (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `UPDATE chart_classify SET sys_user_id=?,sys_user_real_name=?,modify_time=NOW() WHERE parent_id=?  AND level=3 `
-	_, err = o.Raw(sql, sysUserId, chartClassifyName, classifyId).Exec()
+	err = o.Exec(sql, sysUserId, chartClassifyName, classifyId).Error
+
 	return
 }
 
 func GetAllChartClassifyItemsBySource(source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT * FROM chart_classify WHERE source = ? order by sort ASC,chart_classify_id ASC`
-	_, err = o.Raw(sql, source).QueryRows(&items)
+	err = o.Raw(sql, source).Scan(&items).Error
+
 	return
 }
 
@@ -384,17 +396,17 @@ func GetAllChartClassifyItemsBySource(source int) (items []*ChartClassifyItems,
 // @return item *ChartClassify
 // @return err error
 func GetCrossVarietyChartClassifyBySysUserId(sysUserId int) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT * FROM chart_classify WHERE source = ? AND sys_user_id=?`
-	err = o.Raw(sql, utils.CHART_SOURCE_CROSS_HEDGING, sysUserId).QueryRow(&item)
+	err = o.Raw(sql, utils.CHART_SOURCE_CROSS_HEDGING, sysUserId).First(&item).Error
+
 	return
 }
 
 // GetChartClassifyByParentIdAndName 根据父级ID和名称获取分类
 func GetChartClassifyByParentIdAndName(parentId int, classifyName string, classifyId int) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM chart_classify WHERE parent_id = ? AND chart_classify_name = ? AND chart_classify_id <> ? LIMIT 1`
-	err = o.Raw(sql, parentId, classifyName, classifyId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId, classifyName, classifyId).First(&item).Error
 	return
 }
 
@@ -410,9 +422,9 @@ func GetChartClassifyByIdList(classifyIdList []int) (items []*ChartClassify, err
 	if num <= 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT * FROM chart_classify WHERE chart_classify_id in (` + utils.GetOrmInReplace(num) + `) `
-	_, err = o.Raw(sql, classifyIdList).QueryRows(&items)
+	err = o.Raw(sql, classifyIdList).Find(&items).Error
 
 	return
 }
@@ -426,9 +438,10 @@ func GetChartClassifyByIdList(classifyIdList []int) (items []*ChartClassify, err
 // @return items []*ChartClassify
 // @return err error
 func GetChartClassifyBySourceAndIsJoinPermission(source, isJoinPermission int) (items []*ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := `SELECT * FROM chart_classify WHERE source = ? AND is_join_permission = ? `
-	_, err = o.Raw(sql, source, isJoinPermission).QueryRows(&items)
+	err = o.Raw(sql, source, isJoinPermission).Scan(&items).Error
+
 	return
 }
 
@@ -444,7 +457,7 @@ type ChartClassifyIdItems struct {
 }
 
 func GetChartClassifyByRootIdLevel(rootId, source int, orderStr string) (items []*ChartClassifyIdItems, err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` SELECT * FROM chart_classify WHERE root_id = ? AND source = ? `
 	if orderStr != "" {
 		sql += orderStr
@@ -452,26 +465,27 @@ func GetChartClassifyByRootIdLevel(rootId, source int, orderStr string) (items [
 		sql += ` order by level desc, sort asc, chart_classify_id asc`
 	}
 
-	_, err = o.Raw(sql, rootId, source).QueryRows(&items)
+	err = o.Raw(sql, rootId, source).Scan(&items).Error
+
 	return
 }
 
 // UpdateChartClassifySortByParentIdAndSource 根据图表父类id更新排序
 func UpdateChartClassifySortByParentIdAndSource(parentId, classifyId, nowSort int, updateSort string, source int) (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := global.DbMap[utils.DbNameIndex]
 	sql := ` update chart_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? AND source = ? `
 	if classifyId > 0 {
 		sql += ` or ( chart_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
 	}
-	_, err = o.Raw(sql, parentId, nowSort, source).Exec()
+	err = o.Exec(sql, parentId, nowSort, source).Error
+
 	return
 }
 
 // GetChartClassifyAllBySource 根据来源获取所有分类
 func GetChartClassifyAllBySource(source int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM chart_classify WHERE source = ? ORDER BY parent_id ASC, sort ASC, chart_classify_id ASC`
-	_, err = o.Raw(sql, source).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, source).Find(&items).Error
 	return
 }
 
@@ -484,19 +498,17 @@ func GetChartClassifyAllBySource(source int) (items []*ChartClassifyItems, err e
 // @return chartClassifyIdList []int
 // @return err error
 func GetChartClassifyIdListByAdminId(adminId, source int) (chartClassifyIdList []int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT chart_classify_id FROM chart_info WHERE sys_user_id = ? AND source = ?`
 
 	pars := []interface{}{adminId, source}
 	sql += ` group by chart_classify_id `
-	_, err = o.Raw(sql, pars).QueryRows(&chartClassifyIdList)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&chartClassifyIdList).Error
 
 	return
 }
 
 // GetChartClassifyAndInfoByParentId
 func GetChartClassifyAndInfoByParentId(parentId int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT
 	0 AS chart_info_id,
 	chart_classify_id,
@@ -550,13 +562,12 @@ WHERE
 ORDER BY
 	sort ASC,
 	chart_classify_id ASC`
-	_, err = o.Raw(sql, parentId, parentId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId, parentId).Find(&items).Error
 	return
 }
 
 // GetChartClassifyAndInfoByParentId
 func GetChartClassifyAndInfoByParentIdForMe(parentId, adminId int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT
 	0 AS chart_info_id,
 	chart_classify_id,
@@ -594,12 +605,11 @@ WHERE
 ORDER BY
 	sort ASC,
 	chart_classify_id ASC`
-	_, err = o.Raw(sql, parentId, parentId, adminId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId, parentId, adminId).Find(&items).Error
 	return
 }
 
 func GetChartClassifiesById(chartClassifyId int) (items []*ChartClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `
     SELECT *
     FROM chart_classify
@@ -610,6 +620,6 @@ func GetChartClassifiesById(chartClassifyId int) (items []*ChartClassifyItems, e
         FROM chart_classify
         WHERE parent_id = ?
     );`
-	_, err = o.Raw(sql, chartClassifyId, chartClassifyId, chartClassifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, chartClassifyId, chartClassifyId, chartClassifyId).Find(&items).Error
 	return
 }