Merge branch 'dm' of http://8.136.199.33:3000/eta_server/eta_api into dm

models/data_manage/base_from_clarksons_classify.go

@@ -1,12 +1,12 @@
 package data_manage
 
 import (
+	"database/sql"
 	"eta/eta_api/utils"
 	"fmt"
 	"time"
 
 	"eta/eta_api/global"
-	"github.com/beego/beego/v2/client/orm"
 )
 
 // BaseFromClarksonsClassify 卓创红期原始数据分类表
@@ -55,57 +55,63 @@ func BatchAddClarksonsClassify(items []*BaseFromClarksonsClassify) (err error) {
 
 // 获取所有分类
 func GetClarksonsClassifyAll() (items []*BaseFromClarksonsClassifyItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_classify ORDER BY sort ASC, base_from_clarksons_classify_id ASC`
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
 // GetChildClarksonsClassifyListById 获取子分类列表
 func GetChildClarksonsClassifyListById(classifyId int) (items []*BaseFromClarksonsClassifyItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_classify WHERE parent_id=? `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
 // GetChildClarksonsClassifyIdsById 获取子分类的id集合
 func GetChildClarksonsClassifyIdsById(classifyId int) (items []int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT base_from_clarksons_classify_id FROM base_from_clarksons_classify WHERE parent_id=? `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
 // GetChildClarksonsClassifyMaxSortById 获取子分类最大排序
 func GetChildClarksonsClassifyMaxSortById(classifyId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT MAX(sort) AS sort FROM base_from_clarksons_classify WHERE parent_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&sort)
+	sqlStr := ` SELECT MAX(sort) AS sort FROM base_from_clarksons_classify WHERE parent_id=? `
+
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyId).Scan(&sort).Error
+	if !totalNull.Valid {
+		sort = 0
+	} else {
+		sort = int(totalNull.Int64)
+	}
 	return
 }
 
 // GetClarksonsClassifyCountById 获取分类数量
 func GetClarksonsClassifyCountById(classifyId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(*) AS count FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
+	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
 }
 
 // GetClarksonsClassifyById 通过分类id获取分类
 func GetClarksonsClassifyById(classifyId int) (item *BaseFromClarksonsClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).First(&item).Error
 	return
 }
 
 // GetClarksonsChildClassifyById 通过分类id获取子分类
 func GetClarksonsChildClassifyIdsById(classifyId int) (items []int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT base_from_clarksons_classify_id FROM base_from_clarksons_classify WHERE parent_id=? `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
@@ -114,40 +120,54 @@ func GetClarksonsClassifyListByIds(classifyIds []int) (items []*BaseFromClarkson
 	if len(classifyIds) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `)`
-	_, err = o.Raw(sql, classifyIds).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyIds).Find(&items).Error
 	return
 }
 
 // GetClarksonsClassifyCountByName 通过分类名称获取分类
 func GetClarksonsClassifyCountByName(classifyName string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(*) AS count FROM base_from_clarksons_classify WHERE 1=1`
+	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_classify WHERE 1=1`
+
+	sqlStr += ` AND classify_name=? `
 
-	sql += ` AND classify_name=? `
-	err = o.Raw(sql, classifyName).QueryRow(&count)
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyName).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 func GetBaseFromClarksonsClassifyEnCount(classifyNameEn string, parentId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT COUNT(1) AS count FROM base_from_clarksons_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_clarksons_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
 }
 
 func GetBaseFromClarksonsClassifyCount(classifyName string, parentId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT COUNT(1) AS count FROM base_from_clarksons_classify WHERE classify_name=? AND parent_id=? `
-	err = o.Raw(sql, classifyName, parentId).QueryRow(&count)
+	sqlStr := `SELECT COUNT(1) AS count FROM base_from_clarksons_classify WHERE classify_name=? AND parent_id=? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, classifyName, parentId).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 func DeleteClarksonsClassifyById(classifyId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` DELETE FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id=? `
-	_, err = o.Raw(sql, classifyId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyId).Error
 	return
 }
 
@@ -156,76 +176,73 @@ func BatchDeleteClarksonsClassifyById(classifyId []int) (err error) {
 	if len(classifyId) == 0 {
 		return
 	}
-	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_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(len(classifyId)) + `) `
-	_, err = o.Raw(sql, classifyId).Exec()
 
+	sql := ` DELETE FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(len(classifyId)) + `) `
+	err = tx.Exec(sql, classifyId).Error
 	return
 }
 
 // DeleteClarksonsClassifyByClassifyId 根据分类id删除对应的指标分类
 func DeleteClarksonsClassifyByClassifyId(classifyIdList []int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	num := len(classifyIdList)
 	if num <= 0 {
 		return
 	}
 	//删除分类
 	sql := `DELETE FROM base_from_clarksons_classify WHERE base_from_clarksons_classify_id IN (` + utils.GetOrmInReplace(num) + `) `
-	_, err = o.Raw(sql, classifyIdList).Exec()
+	err = global.DbMap[utils.DbNameIndex].Exec(sql, classifyIdList).Error
 	return
 }
 
 // GetClarksonsIndexClassifyMinSort 获取最小不等于0的排序
 func GetClarksonsIndexClassifyMinSort(parentId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT MIN(sort) FROM base_from_clarksons_classify WHERE parent_id=? AND sort <> 0 `
-	err = o.Raw(sql, parentId).QueryRow(&sort)
+	sqlStr := `SELECT MIN(sort) FROM base_from_clarksons_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
 }
 
 // MoveUpClarksonsIndexClassifyBySort 往上移动
 func MoveUpClarksonsIndexClassifyBySort(parentId, nextSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_clarksons_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
 }
 
 // MoveDownClarksonsIndexClassifyBySort 往下移动
 func MoveDownClarksonsIndexClassifyBySort(parentId, prevSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_clarksons_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
 }
 
 // UpdateClarksonsClassifySortByParentId 根据父类id更新排序
 func UpdateClarksonsClassifySortByParentId(parentId, classifyId, nowSort int, updateSort string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` update base_from_clarksons_classify set sort = ` + updateSort + ` WHERE parent_id=? and sort > ? `
 	if classifyId > 0 {
 		sql += ` or ( base_from_clarksons_classify_id > ` + fmt.Sprint(classifyId) + ` and sort= ` + fmt.Sprint(nowSort) + `)`
 	}
-	_, err = o.Raw(sql, parentId, nowSort).Exec()
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId, nowSort).Error
 	return
 }
 
 // GetFirstClarksonsClassifyByParentId 获取当前父级分类下的排序第一条的数据
 func GetFirstClarksonsClassifyByParentId(parentId int) (item *ChartClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_classify WHERE parent_id=? order by sort asc,base_from_clarksons_classify_id asc limit 1`
-	err = o.Raw(sql, parentId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, parentId).First(&item).Error
 	return
 }

models/data_manage/base_from_clarksons_data.go

@@ -1,28 +1,27 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"time"
-
-	"github.com/beego/beego/v2/client/orm"
 )
 
 type BaseFromClarksonsData struct {
-	BaseFromClarksonsDataId          int       `orm:"column(base_from_clarksons_data_id);pk"`
+	BaseFromClarksonsDataId  int       `orm:"column(base_from_clarksons_data_id);pk"`
 	BaseFromClarksonsIndexId int       `description:"指标id"`
-	IndexCode            string    `description:"指标编码"`
-	DataTime             string    `description:"数据日期"`
-	Value                float64   `description:"数据值"`
-	CreateTime           time.Time `description:"创建时间"`
-	ModifyTime           time.Time `description:"修改时间"`
-	DataTimestamp        int64     `description:"数据时间戳"`
+	IndexCode                string    `description:"指标编码"`
+	DataTime                 string    `description:"数据日期"`
+	Value                    float64   `description:"数据值"`
+	CreateTime               time.Time `description:"创建时间"`
+	ModifyTime               time.Time `description:"修改时间"`
+	DataTimestamp            int64     `description:"数据时间戳"`
 }
 
 // GetClarksonsDataByIndexId 根据指标id获取指标数据
 func GetClarksonsDataByIndexId(indexId int) (items []*BaseFromClarksonsData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_data WHERE base_from_clarksons_index_id=? ORDER BY data_time DESC`
-	_, err = o.Raw(sql, indexId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexId).Find(&items).Error
 	return
 }
 
@@ -31,30 +30,31 @@ func GetClarksonsDataDataTimeByIndexId(indexIdList []int) (items []string, err e
 	if len(indexIdList) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT DISTINCT data_time FROM base_from_clarksons_data WHERE base_from_clarksons_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 GetClarksonsIndexDataByCode(indexCode string) (items []*BaseFromClarksonsData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_clarksons_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 GetClarksonsIndexDataCount(indexCode string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(1) AS count  FROM base_from_clarksons_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(1) AS count  FROM base_from_clarksons_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
 }
 
 // GetClarksonsLastUpdateTimeLastByIndexCode 根据指标编码查询 返回ModifyTime最后一条数据
 func GetClarksonsLastUpdateTimeLastByIndexCode(indexCodes []string) (items []*BaseFromClarksonsData, err error) {
-	o := orm.NewOrmUsingDB("data")
-
 	// 构造 SQL 查询
 	sql := `SELECT t1.index_code, t1.data_time, t2.value
 			FROM (
@@ -66,7 +66,7 @@ func GetClarksonsLastUpdateTimeLastByIndexCode(indexCodes []string) (items []*Ba
 			JOIN base_from_clarksons_data AS t2 ON t1.index_code = t2.index_code AND t1.data_time = t2.data_time`
 
 	// 执行 SQL 查询
-	_, err = o.Raw(sql, indexCodes).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes).Find(&items).Error
 	if err != nil {
 		return nil, err
 	}
@@ -74,8 +74,7 @@ func GetClarksonsLastUpdateTimeLastByIndexCode(indexCodes []string) (items []*Ba
 }
 
 func GetClarksonsIndexData(indexCode string, startSize, pageSize int) (items []*BaseFromClarksonsData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_clarksons_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
 }

models/data_manage/base_from_clarksons_index.go

@@ -1,79 +1,77 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"time"
-
-	"github.com/beego/beego/v2/client/orm"
 )
 
 type BaseFromClarksonsIndex struct {
-	BaseFromClarksonsIndexId int       `orm:"pk"`
-	ClassifyId           int       `description:"指标分类id"`
-	IndexCode            string    `description:"指标编码"`
-	IndexName            string    `description:"指标名称"`
-	Unit                 string    `description:"单位"`
-	Frequency            string    `description:"频度"`
-	StartDate            string    `description:"开始日期"`
-	EndDate              string    `description:"结束日期"`
-	Sort                 int       `description:"排序"`
-	CreateTime           time.Time
-	ModifyTime           time.Time
+	BaseFromClarksonsIndexId int    `orm:"pk"`
+	ClassifyId               int    `description:"指标分类id"`
+	IndexCode                string `description:"指标编码"`
+	IndexName                string `description:"指标名称"`
+	Unit                     string `description:"单位"`
+	Frequency                string `description:"频度"`
+	StartDate                string `description:"开始日期"`
+	EndDate                  string `description:"结束日期"`
+	Sort                     int    `description:"排序"`
+	CreateTime               time.Time
+	ModifyTime               time.Time
 }
 
 type BaseFromClarksonsIndexView struct {
-	BaseFromClarksonsIndexId int     `orm:"pk"`
-	EdbInfoId            int     `description:"指标库id"`
-	ClassifyId           int     `description:"指标分类id"`
-	IndexCode            string  `description:"指标编码"`
-	IndexName            string  `description:"指标名称"`
-	UniqueCode           string  `description:"唯一code"`
-	Frequency            string  `description:"频度"`
-	Unit                 string  `description:"单位"`
-	StartDate            string  `description:"开始日期"`
-	EndDate              string  `description:"结束日期"`
-	Sort                 int     `description:"排序"`
-	LatestDate           string  `description:"最后更新时间"`
-	EdbExist             int     `description:"edb是否存在"`
-	ModifyTime           string
+	BaseFromClarksonsIndexId int    `orm:"pk"`
+	EdbInfoId                int    `description:"指标库id"`
+	ClassifyId               int    `description:"指标分类id"`
+	IndexCode                string `description:"指标编码"`
+	IndexName                string `description:"指标名称"`
+	UniqueCode               string `description:"唯一code"`
+	Frequency                string `description:"频度"`
+	Unit                     string `description:"单位"`
+	StartDate                string `description:"开始日期"`
+	EndDate                  string `description:"结束日期"`
+	Sort                     int    `description:"排序"`
+	LatestDate               string `description:"最后更新时间"`
+	EdbExist                 int    `description:"edb是否存在"`
+	ModifyTime               string
 }
 
 type BaseFromClarksonsIndexList struct {
-	BaseFromClarksonsIndexId int     `orm:"pk"`
-	IndexCode          string    // 指标编码
-	IndexName          string    // 指标名称
-	ClassifyId         int       // 分类Id
-	Unit               string    // 单位
-	Frequency          string    // 频度
-	Describe           string    // 指标描述
-	CreateTime         string // 创建时间
-	ModifyTime         string // 修改时间
-	DataList           []*BaseFromClarksonsData
-	Paging             *paging.PagingItem `description:"分页数据"`
+	BaseFromClarksonsIndexId int    `orm:"pk"`
+	IndexCode                string // 指标编码
+	IndexName                string // 指标名称
+	ClassifyId               int    // 分类Id
+	Unit                     string // 单位
+	Frequency                string // 频度
+	Describe                 string // 指标描述
+	CreateTime               string // 创建时间
+	ModifyTime               string // 修改时间
+	DataList                 []*BaseFromClarksonsData
+	Paging                   *paging.PagingItem `description:"分页数据"`
 }
+
 func (b *BaseFromClarksonsIndex) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(b, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(b).Error
 	return
 }
 
 // GetClarksonsIndexByCondition 根据条件获取克拉克森指标列表
 func GetClarksonsIndexByCondition(condition string, pars []interface{}) (items []*BaseFromClarksonsIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE 1=1 `
 
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC, base_from_clarksons_index_id ASC`
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 // GetClarksonsIndexByCondition 根据条件获取克拉克森指标列表
 func GetClarksonsIndexByConditionAndFrequency(condition, frequency string, pars []interface{}) (items []*BaseFromClarksonsIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE 1=1 `
 
 	if condition != "" {
@@ -81,48 +79,51 @@ func GetClarksonsIndexByConditionAndFrequency(condition, frequency string, pars
 	}
 	sql += ` AND frequency=?`
 	sql += ` ORDER BY sort ASC, base_from_clarksons_index_id ASC`
-	_, err = o.Raw(sql, pars, frequency).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars, frequency).Find(&items).Error
 	return
 }
 
 func GetClarksonsIndexCountByCondition(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(*) AS count FROM base_from_clarksons_index WHERE 1=1 `
+	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_index WHERE 1=1 `
 
 	if condition != "" {
-		sql += condition
+		sqlStr += condition
 	}
-	sql += ` ORDER BY sort ASC, base_from_clarksons_index_id ASC`
-	err = o.Raw(sql, pars).QueryRow(&count)
+	sqlStr += ` ORDER BY sort ASC, base_from_clarksons_index_id ASC`
+	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)
+	}
+
 	return
 }
 
 // GetClarksonsIndexAndEdbInfoByCondition 根据条件获取克拉克森index和指标库的信息
 func GetClarksonsIndexAndEdbInfoByCondition(condition string, pars []interface{}) (items []*BaseFromClarksonsIndexView, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT b.*, e.edb_info_id FROM base_from_clarksons_index AS b LEFT JOIN edb_info AS e ON b.index_code=e.edb_code AND e.source=? WHERE 1=1 `
 
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC `
-	_, err = o.Raw(sql, utils.DATA_SOURCE_SCI_HQ, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, utils.DATA_SOURCE_SCI_HQ, pars).Find(&items).Error
 	return
 }
 
 // GetClarksonsIndexByIndexCode 根据指标编码获取指标信息
 func GetClarksonsIndexByIndexCode(indexCode string) (item *BaseFromClarksonsIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&item).Error
 	return
 }
 
 // GetClarksonsIndexByIndexId 根据指标id获取指标信息
 func GetClarksonsIndexByIndexId(indexId int) (item *BaseFromClarksonsIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE base_from_clarksons_index_id=? `
-	err = o.Raw(sql, indexId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexId).First(&item).Error
 	return
 }
 
@@ -131,33 +132,36 @@ func GetClarksonsIndexListByIndexIds(indexIds []int) (items []*BaseFromClarksons
 	if len(indexIds) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE base_from_clarksons_index_id IN (` + utils.GetOrmInReplace(len(indexIds)) + `) `
-	_, err = o.Raw(sql, indexIds).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexIds).Find(&items).Error
 	return
 }
 
 // GetClarksonsIndexCountByClassifyIds 获取分类下指标的个数
 func GetClarksonsIndexCountByClassifyIds(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_clarksons_index WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
-	err = o.Raw(sql, classifyIds).QueryRow(&count)
+	sqlStr := `SELECT COUNT(1) AS count FROM base_from_clarksons_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
 }
 
 // GetClarksonsIndexByClassifyId 根据分类id获取克拉克森指标列表
 func GetClarksonsIndexByClassifyId(classifyIds []int, startSize, pageSize int) (items []*BaseFromClarksonsIndexView, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT b.*, e.edb_info_id,
 	CASE WHEN e.edb_info_id IS NULL THEN 0 ELSE 1 END AS edb_exist
 	FROM base_from_clarksons_index AS b
 	LEFT JOIN edb_info AS e ON b.index_code=e.edb_code AND e.source=101
 	WHERE b.classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `) ORDER BY b.sort ASC LIMIT ?,? `
-	_, err = o.Raw(sql, classifyIds, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyIds, startSize, pageSize).Find(&items).Error
 	return
 }
 
@@ -166,74 +170,92 @@ func GetClarksonsIndexCountByClassifyId(classifyIds []int) (count int, err error
 	if len(classifyIds) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(*) AS count FROM base_from_clarksons_index WHERE classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `) `
-	err = o.Raw(sql, classifyIds).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_index WHERE classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `) `
+
+	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
 }
 
 // GetClarksonsIndexCount 获取克拉克森指标数量
 func GetClarksonsIndexCount() (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT COUNT(*) AS count FROM base_from_clarksons_index `
-	err = o.Raw(sql).QueryRow(&count)
+	sqlStr := ` SELECT COUNT(*) AS count FROM base_from_clarksons_index `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
 func GetClarksonsIndexByPage(startSize, pageSize int) (items []*BaseFromClarksonsIndexView, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT b.*, e.edb_info_id,
 	CASE WHEN e.edb_info_id IS NULL THEN 0 ELSE 1 END AS edb_exist
 	FROM base_from_clarksons_index AS b
 	LEFT JOIN edb_info AS e ON b.index_code=e.edb_code AND e.source=101
 	ORDER BY b.modify_time DESC LIMIT ?,?`
-	_, err = o.Raw(sql, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, startSize, pageSize).Find(&items).Error
 	return
 }
 
 // GetClarksonsIndexBaseInfoByClassifyId 根据分类id获取克拉克森指标列表
 func GetClarksonsIndexBaseInfoByClassifyId(classifyId int) (items []*BaseFromClarksonsIndexView, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT base_from_clarksons_index_id, classify_id, index_code, index_name, CONCAT(classify_id, '_', base_from_clarksons_index_id) AS unique_code  FROM base_from_clarksons_index WHERE classify_id = ? ORDER BY sort ASC `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
 // GetClarksonsIndexBaseInfoByClassifyId 根据分类id获取克拉克森指标列表
 func GetClarksonsIndexBaseInfoByCondition(condition string, pars []interface{}) (items []*BaseFromClarksonsIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT base_from_clarksons_index_id, index_code, index_name  FROM base_from_clarksons_index WHERE 1=1 `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC `
-	_, err = o.Raw(sql, pars...).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Find(&items).Error
 	return
 }
 
 func GetClarksonsDataMaxCount(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT MAX(t.num) AS count FROM ( SELECT COUNT(1) AS num  FROM base_from_clarksons_index AS a INNER JOIN base_from_clarksons_data AS b ON a.index_code=b.index_code WHERE 1=1  `
+	sqlStr := `SELECT MAX(t.num) AS count FROM ( SELECT COUNT(1) AS num  FROM base_from_clarksons_index AS a INNER JOIN base_from_clarksons_data AS b ON a.index_code=b.index_code WHERE 1=1  `
 	if condition != "" {
-		sql += condition
+		sqlStr += condition
+	}
+	sqlStr += ` GROUP BY a.base_from_clarksons_index_id) AS t `
+
+	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)
 	}
-	sql += ` GROUP BY a.base_from_clarksons_index_id) AS t `
-	err = o.Raw(sql, pars).QueryRow(&count)
 	return
 }
 
 // GetClarksonsIndexMaxSortByClassifyId 根据分类id获取指标最大排序
 func GetClarksonsIndexMaxSortByClassifyId(classifyId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT MAX(sort) FROM base_from_clarksons_index WHERE classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&sort)
+	sqlStr := `SELECT MAX(sort) FROM base_from_clarksons_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
 }
 
 func GetClarksonsFrequency(classifyId int) (items []*string, err error) {
 	sql := `SELECT DISTINCT frequency FROM base_from_clarksons_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
 }
 
@@ -243,15 +265,13 @@ func GetClarksonsFrequencyByCondition(condition string, pars []interface{}) (ite
 		sql += condition
 	}
 	sql += ` ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年','年度') `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, pars...).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Find(&items).Error
 	return
 }
 
 func GetClarksonsFrequencyByCode(code string) (items []*string, err error) {
 	sql := `SELECT DISTINCT frequency FROM base_from_clarksons_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
 }
 
@@ -260,7 +280,6 @@ func GetClarksonsClassifyMaxSortByClassifyIds(classifyIds []int) (items []*BaseF
 	if len(classifyIds) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT bc.base_from_clarksons_classify_id, COALESCE(MAX(bi.sort), 0) AS max_sort FROM base_from_clarksons_classify  AS bc
 	LEFT JOIN base_from_clarksons_index AS bi
 	ON bc.base_from_clarksons_classify_id=bi.classify_id  
@@ -268,22 +287,14 @@ func GetClarksonsClassifyMaxSortByClassifyIds(classifyIds []int) (items []*BaseF
 	GROUP BY bc.base_from_clarksons_classify_id
 	`
 	// sql = ` SELECT classify_id, MAX(sort) AS max_sort FROM base_from_clarksons_index WHERE classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `) GROUP BY classify_id `
-	_, err = o.Raw(sql, classifyIds).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyIds).Find(&items).Error
 	return
 }
 
 func BatchModifyClarksonsIndexClassify(items []*BaseFromClarksonsIndex) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_clarksons_index SET classify_id=?, sort=? WHERE base_from_clarksons_index_id=? `
-	p, err := o.Raw(sql).Prepare()
-	if err != nil {
-		return
-	}
-	defer func() {
-		p.Close()
-	}()
 	for _, v := range items {
-		_, err = p.Exec(v.ClassifyId, v.Sort, v.BaseFromClarksonsIndexId)
+		err = global.DbMap[utils.DbNameIndex].Exec(sql, v.ClassifyId, v.Sort, v.BaseFromClarksonsIndexId).Error
 		if err != nil {
 			return
 		}
@@ -293,41 +304,35 @@ func BatchModifyClarksonsIndexClassify(items []*BaseFromClarksonsIndex) (err err
 
 // MoveDownClarksonsIndexBySort 往下移动
 func MoveDownClarksonsIndexBySort(classifyId, prevSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_clarksons_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
 }
 
 // MoveUpClarksonsIndexBySort 往上移动
 func MoveUpClarksonsIndexBySort(classifyId, nextSort, currentSort int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `update base_from_clarksons_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
 }
 
 func DeleteClarksonsIndexById(indexId 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_clarksons_index WHERE base_from_clarksons_index_id=? `
-	_, err = to.Raw(sql, indexId).Exec()
+	err = tx.Exec(sql, indexId).Error
 	if err != nil {
 		return
 	}
 	sql = `DELETE FROM base_from_clarksons_data WHERE base_from_clarksons_index_id=? `
-	_, err = to.Raw(sql, indexId).Exec()
+	err = tx.Exec(sql, indexId).Error
 	if err != nil {
 		return
 	}
@@ -338,25 +343,21 @@ func DeleteClarksonsIndexByIds(indexIds []int) (err error) {
 	if len(indexIds) == 0 {
 		return
 	}
-	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_clarksons_index WHERE base_from_clarksons_index_id IN (` + utils.GetOrmInReplace(len(indexIds)) + `) `
-	_, err = o.Raw(sql, indexIds).Exec()
+	err = tx.Exec(sql, indexIds).Error
 	if err != nil {
 		return
 	}
 	sql = `DELETE FROM base_from_clarksons_data WHERE base_from_clarksons_index_id IN (` + utils.GetOrmInReplace(len(indexIds)) + `) `
-	_, err = o.Raw(sql, indexIds).Exec()
+	err = tx.Exec(sql, indexIds).Error
 	if err != nil {
 		return
 	}
@@ -365,60 +366,66 @@ func DeleteClarksonsIndexByIds(indexIds []int) (err error) {
 
 // MoveClarksonsIndex 移动指标分类
 func MoveClarksonsIndex(indexId, classifyId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` UPDATE base_from_clarksons_index
 			SET
 			  classify_id = ?, modify_time=NOW() 
 			WHERE base_from_clarksons_index_id = ?`
-	_, err = o.Raw(sql, classifyId, indexId).Exec()
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId, indexId).Error
 	return
 }
 
 // GetClarksonsIndexMinSortByClassifyId 获取最小不等于0的排序
 func GetClarksonsIndexMinSortByClassifyId(classifyId int) (sort int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT min(sort) FROM base_from_clarksons_index WHERE classify_id=? and sort <> 0 `
-	err = o.Raw(sql, classifyId).QueryRow(&sort)
+	sqlStr := `SELECT min(sort) FROM base_from_clarksons_index WHERE classify_id=? and sort <> 0 `
+	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
 }
 
 // GetClarksonsIndexInfoCount 分页查询指标信息行数
 func GetClarksonsIndexInfoCount(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT count(1) FROM base_from_clarksons_index WHERE index_code not in (select edb_code from edb_info) `
+	sqlStr := ` SELECT count(1) FROM base_from_clarksons_index WHERE index_code not in (select edb_code from edb_info) `
 	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)
 	}
-	err = o.Raw(sql, pars).QueryRow(&count)
 	return
 }
 
 // GetClarksonsIndexInfoPage 分页查询指标信息
 func GetClarksonsIndexInfoPage(condition string, pars []interface{}) (items []*BaseFromRzdIndexAndData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE index_code not in (select edb_code from edb_info) `
 	if condition != "" {
 		sql += condition
 	}
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 
 }
 
 func GetClarksonsIndex(condition string, pars interface{}) (items []*BaseFromClarksonsIndexView, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_clarksons_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += `ORDER BY base_from_clarksons_index_id ASC `
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 func GetClarksonsIndexLatestDate(indexCode string) (ModifyTime string, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT modify_time FROM base_from_clarksons_data WHERE index_code=? ORDER BY modify_time DESC limit 1 `
-	err = o.Raw(sql, indexCode).QueryRow(&ModifyTime)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Scan(&ModifyTime).Error
 	return
 }

models/data_manage/base_from_eia_stero.go

@@ -1,11 +1,11 @@
 package data_manage
 
 import (
+	"database/sql"
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
-	"time"
-
-	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
+	"time"
 )
 
 // BaseFromEiaSteoIndex EiaSteo指标
@@ -87,24 +87,21 @@ type BaseFromEiaSteoDataItem struct {
 // GetEiaSteoClassifyList 获取分类列表
 func GetEiaSteoClassifyList() (items []*BaseFromEiaSteoClassifyView, err error) {
 	sql := ` SELECT * FROM base_from_eia_steo_classify  ORDER BY base_from_eia_steo_classify_id ASC `
-	o := orm.NewOrmUsingDB("data")
-	o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
 // GetEiaSteoClassifyById 根据分类id获取分类
 func GetEiaSteoClassifyById(classifyId int) (item *BaseFromEiaSteoClassify, err error) {
 	sql := ` SELECT * FROM base_from_eia_steo_classify WHERE base_from_eia_steo_classify_id=? `
-	o := orm.NewOrmUsingDB("data")
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).First(&item).Error
 	return
 }
 
 // GetChildEiaSteoClassifyById 获取子分类列表
 func GetChildEiaSteoClassifyById(classifyId int) (items []*BaseFromEiaSteoClassify, err error) {
 	sql := ` SELECT * FROM base_from_eia_steo_classify WHERE parent_id=? `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
@@ -129,16 +126,20 @@ func GetEiaSteoIndexList(condition string, pars []interface{}) (items []*BaseFro
 	sql := ` SELECT *  FROM base_from_eia_steo_index WHERE 1=1  `
 	sql += condition
 	sql += ` ORDER BY base_from_eia_steo_index_id ASC `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 // GetEiaSteoIndexDataCount 获取指标数据总数
 func GetEiaSteoIndexDataCount(indexCode string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT COUNT(1) AS count FROM base_from_eia_steo_data where index_code = ? `
-	err = o.Raw(sql, indexCode).QueryRow(&count)
+	sqlStr := `SELECT COUNT(1) AS count FROM base_from_eia_steo_data where index_code = ? `
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, indexCode).Scan(&count).Error
+	if !totalNull.Valid {
+		count = 0
+	} else {
+		count = int(totalNull.Int64)
+	}
 	return
 }
 
@@ -146,16 +147,14 @@ func GetEiaSteoIndexDataCount(indexCode string) (count int, err error) {
 func GetEiaSteoIndexDataList(indexCode string, startSize, pageSize int) (items []*BaseFromEiaSteoDataItem, err error) {
 	//sql := ` SELECT *  FROM mb_index_main_data WHERE INDEX_CODE=? ORDER BY DATA_DATE DESC,PUBLISH_TIME DESC LIMIT ?,?`
 	sql := ` SELECT * FROM base_from_eia_steo_data AS a WHERE index_code=? ORDER BY data_time DESC LIMIT ?,? `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, indexCode, startSize, pageSize).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode, startSize, pageSize).Find(&items).Error
 	return
 }
 
 // GetEiaSteoItemList 模糊查询EiaSteo数据库指标列表
 func GetEiaSteoItemList(keyword string) (items []*BaseFromEiaSteoIndexItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := "SELECT * FROM base_from_eia_steo_index WHERE index_name LIKE ?  OR index_code like ?"
-	_, err = o.Raw(sql, utils.GetLikeKeyword(keyword), utils.GetLikeKeyword(keyword)).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, utils.GetLikeKeyword(keyword), utils.GetLikeKeyword(keyword)).Find(&items).Error
 	return
 }
 
@@ -167,16 +166,14 @@ func GetEiaSteoDateList(indexCodeList []string) (items []*BaseFromEiaSteoDataIte
 	}
 
 	sql := ` SELECT data_time FROM base_from_eia_steo_data WHERE index_code IN(` + utils.GetOrmInReplace(num) + `)  GROUP BY data_time ORDER BY data_time DESC `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, indexCodeList).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodeList).Find(&items).Error
 
 	return
 }
 
 // GetBaseFromEiaSteoIndexByCode 根据指标code获取指标信息
 func GetBaseFromEiaSteoIndexByCode(indexCode string) (item *BaseFromEiaSteoIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_eia_steo_index WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&item).Error
 	return
 }

models/data_manage/base_from_fenwei.go

@@ -1,8 +1,8 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
-	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"time"
 )
@@ -92,20 +92,18 @@ type BaseFromFenWeiIndexPage struct {
 }
 
 func GetFenweiIndex(condition string, pars interface{}) (items []*BaseFromFenweiIndexList, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_fenwei_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC, fenwei_index_id asc`
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 func GetFenweiIndexDataCount(indexCode string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count FROM base_from_fenwei_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Scan(&count).Error
 	return
 }
 
@@ -118,16 +116,14 @@ func GetFenweiIndexDataCountGroup(indexCodes []string) (items []*FenweiIndexData
 	if len(indexCodes) <= 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count, index_code FROM base_from_fenwei_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 GetFenweiIndexData(indexCode string, startSize, pageSize int) (items []*BaseFromFenweiData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_fenwei_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
 }
 
@@ -135,9 +131,8 @@ func GetFenweiIndexDataByCodes(indexCode []string) (items []*BaseFromFenweiData,
 	if len(indexCode) <= 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_fenwei_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
 }
 
@@ -161,26 +156,23 @@ type BaseFromFenweiIndexSearchItem struct {
 
 // GetFenweiItemList 模糊查询汾渭数据库指标列表
 func GetFenweiItemList(condition string) (items []*BaseFromFenweiIndexSearchItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := "SELECT * FROM base_from_fenwei_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 GetFenweiIndexDataByCode(indexCode string) (list []*BaseFromFenweiData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_fenwei_data WHERE index_code=? `
-	_, err = o.Raw(sql, indexCode).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&list).Error
 	return
 }
 
 func GetBaseFromFenweiIndexByIndexCode(indexCode string) (list *BaseFromFenweiIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_fenwei_index WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&list).Error
 	return
 }
 
@@ -197,11 +189,10 @@ func GetFenWeiIndexFrequency(classifyId int) (items []*string, err error) {
 
 	sql += ` ORDER BY FIELD(frequency, '日度', '周度', '月度', '季度', '半年度', '年度')`
 
-	o := orm.NewOrmUsingDB("data")
 	if classifyId > 0 {
-		_, err = o.Raw(sql, classifyId).QueryRows(&items)
+		err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	} else {
-		_, err = o.Raw(sql).QueryRows(&items)
+		err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	}
 
 	return items, err
@@ -209,8 +200,6 @@ func GetFenWeiIndexFrequency(classifyId int) (items []*string, err error) {
 
 // GetFenWeiIndexByCodeAndClassify 根据指标编码和分类查询 indexCode非必传
 func GetFenWeiIndexByCodeAndClassify(indexCode string, classifyId int, frequency *string) (items []*BaseFromFenweiIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
-
 	// SQL 查询语句
 	sql := `SELECT a.index_code, a.index_name, a.frequency, a.unit, MAX(b.modify_time) AS modify_time
 			FROM base_from_fenwei_index AS a
@@ -237,7 +226,7 @@ func GetFenWeiIndexByCodeAndClassify(indexCode string, classifyId int, frequency
 
 	sql += ` GROUP BY a.index_code, a.index_name, a.frequency, a.unit`
 
-	_, err = o.Raw(sql, params...).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, params...).Find(&items).Error
 	if err != nil {
 		return nil, err
 	}
@@ -247,55 +236,49 @@ func GetFenWeiIndexByCodeAndClassify(indexCode string, classifyId int, frequency
 // GetBaseFromFenWeiDataByIndexCode 根据指标编码查询
 func GetBaseFromFenWeiDataByIndexCode(indexCode string) (items []*BaseFromFenweiData, err error) {
 	sql := `SELECT * FROM base_from_fenwei_data WHERE index_code=? ORDER BY data_time desc`
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, indexCode).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Find(&items).Error
 	return
 }
 
 // GetFenWeiDataListByIndexCodes 根据指标编码查询
 func GetFenWeiDataListByIndexCodes(IndexCodes string) (items []string, err error) {
 	sql := ` SELECT data_time FROM base_from_fenwei_data WHERE index_code IN(` + IndexCodes + `)  GROUP BY data_time DESC `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
 // GetFenWeiIndexInfoPage 分页查询指标信息
 func GetFenWeiIndexInfoPage(condition string, pars []interface{}) (items []*BaseFromFenweiIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_fenwei_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY fenwei_index_id asc`
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 
 }
 
 // GetFenWeiIndexInfoCount 查询指标信息总数
 func GetFenWeiIndexInfoCount(condition string, pars []interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count FROM base_from_fenwei_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
 }
 
 // GetFenWeiDataLastModifyTime 获取指标数据最新更新时间
 func GetFenWeiDataLastModifyTime(indexCode string) (lastModifyTime string, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT MAX(modify_time) AS last_modify_time FROM base_from_fenwei_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&lastModifyTime)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Scan(&lastModifyTime).Error
 	return
 }
 
 // GetFenWeiDataLastModifyTimeList 查询指标数据最新更新时间
 func GetFenWeiDataLastModifyTimeList(indexCodes []string) (items []*BaseFromFenweiData, err error) {
 	sql := ` SELECT MAX(modify_time) AS modify_time, index_code FROM base_from_fenwei_data WHERE index_code IN(` + utils.GetOrmInReplace(len(indexCodes)) + `) GROUP BY index_code `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, indexCodes).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes).Find(&items).Error
 	return
 }

models/data_manage/base_from_fenwei_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 BaseFromFenweiClassify struct {
 
 // GetBaseFromFenweiClassify 获取所有分类
 func GetBaseFromFenweiClassify() (items []*BaseFromFenweiClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_fenwei_classify ORDER BY parent_id ASC, sort ASC, classify_id ASC`
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
@@ -56,10 +55,9 @@ func (y *BaseFromFenweiClassify) Format2Item(origin *BaseFromFenweiClassify) (it
 
 // GetFenweiClassifyItemByClassifyId 根据分类id查询分类信息
 func GetFenweiClassifyItemByClassifyId(classifyId int) (item *BaseFromFenweiClassifyItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_fenwei_classify WHERE classify_id = ?`
 	var origin BaseFromFenweiClassify
-	err = o.Raw(sql, classifyId).QueryRow(&origin)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).First(&origin).Error
 	if err != nil {
 		return
 	}

models/data_manage/base_from_gpr_risk.go

@@ -4,7 +4,8 @@ import (
 	"eta/eta_api/utils"
 	"time"
 
-	"github.com/beego/beego/v2/client/orm"
+	"database/sql"
+	"eta/eta_api/global"
 	"github.com/rdlucklib/rdluck_tools/paging"
 )
 
@@ -70,69 +71,61 @@ type GprRiskSingleData struct {
 }
 
 func GetGprRiskIndexByClassifyId(classifyId int) (items []*BaseFromGprRiskIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT base_from_gpr_risk_index_id, classify_id, index_code, index_name FROM base_from_gpr_risk_index WHERE classify_id=? ORDER BY sort ASC, base_from_gpr_risk_index_id ASC `
-	_, err = o.Raw(sql, classifyId).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&items).Error
 	return
 }
 
 func GetGprRiskIndex(condition string, pars interface{}) (items []*BaseFromGprRiskIndexList, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC, base_from_gpr_risk_index_id asc`
-	_, err = o.Raw(sql, pars).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars).Find(&items).Error
 	return
 }
 
 func GetGprRiskIndexPage(condition string, pars interface{}, startSize, pageSize int) (items []*BaseFromGprRiskIndexList, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_index WHERE 1=1  `
 	if condition != "" {
 		sql += condition
 	}
 	sql += ` ORDER BY sort ASC, base_from_gpr_risk_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 GetGprRiskIndexPageCount(condition string, pars interface{}) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count  FROM base_from_gpr_risk_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
 }
 
 func GetGprRiskIndexDataCount(indexCode string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(1) AS count  FROM base_from_gpr_risk_data WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).Scan(&count).Error
 	return
 }
 
 func GetGprRiskIndexDataByDataTime(indexCodes []string, startDate, endDate string) (items []*BaseFromGprRiskData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_gpr_risk_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 GetGprRiskIndexDataTimePageByCodes(indexCodes []string, startSize, pageSize int) (dataTimes []string, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT data_time FROM base_from_gpr_risk_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 GetGprRiskIndexDataTimePageCount(indexCodes []string) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT COUNT(DISTINCT data_time) AS count  FROM base_from_gpr_risk_data WHERE index_code in (` + utils.GetOrmInReplace(len(indexCodes)) + `) `
-	err = o.Raw(sql, indexCodes).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCodes).Scan(&count).Error
 	return
 }
 
@@ -140,15 +133,13 @@ func GetGprRiskIndexDataByCodes(indexCode []string) (items []*BaseFromGprRiskDat
 	if len(indexCode) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT *  FROM base_from_gpr_risk_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
 }
 
 // GetGprRiskByConditionAndFrequency 根据条件获取涌益咨询指标列表
 func GetGprRiskByConditionAndFrequency(condition, frequency string, pars []interface{}) (items []*BaseFromGprRiskIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_index WHERE 1=1 `
 
 	if condition != "" {
@@ -156,7 +147,7 @@ func GetGprRiskByConditionAndFrequency(condition, frequency string, pars []inter
 	}
 	sql += ` AND frequency=?`
 	sql += ` ORDER BY sort ASC, base_from_gpr_risk_index_id ASC`
-	_, err = o.Raw(sql, pars, frequency).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars, frequency).Find(&items).Error
 	return
 }
 
@@ -166,8 +157,7 @@ func GetGprRiskFrequencyByCondition(condition string, pars []interface{}) (items
 		sql += condition
 	}
 	sql += ` ORDER BY FIELD(frequency,'日度','周度','旬度','月度','季度','半年度','年度') `
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Raw(sql, pars...).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, pars...).Find(&items).Error
 	return
 }
 
@@ -176,9 +166,8 @@ func GetGprRiskDataDataTimeByIndexId(indexIdList []int) (items []string, err err
 	if len(indexIdList) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT DISTINCT data_time FROM base_from_gpr_risk_data WHERE base_from_gpr_risk_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
 }
 
@@ -213,33 +202,35 @@ type BatchCheckGprRiskEdbReq struct {
 
 // GetGprRiskItemList 模糊查询GprRisk数据库指标列表
 func GetGprRiskItemList(condition string) (items []*BaseFromGprRiskIndexSearchItem, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := "SELECT * FROM base_from_gpr_risk_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 GetGprRiskIndexDataByCode(indexCode string, pageIndex, pageSize int) (list []*BaseFromGprRiskData, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_gpr_risk_data WHERE index_code=? order by data_time desc limit ?,?`
-	_, err = o.Raw(sql, indexCode, pageIndex, pageSize).QueryRows(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode, pageIndex, pageSize).Find(&list).Error
 	return
 }
 
 func GetGprRiskIndexDataTotalByCode(indexCode string) (total int64, err error) {
-	o := orm.NewOrmUsingDB("data")
-	sql := `SELECT count(*) FROM base_from_gpr_risk_data WHERE index_code=?`
-	err = o.Raw(sql, indexCode).QueryRow(&total)
+	sqlStr := `SELECT count(*) FROM base_from_gpr_risk_data WHERE index_code=?`
+	var totalNull sql.NullInt64
+	err = global.DbMap[utils.DbNameIndex].Raw(sqlStr, indexCode).Scan(&totalNull).Error
+	if !totalNull.Valid {
+		total = 0
+	} else {
+		total = totalNull.Int64
+	}
 	return
 }
 
 func GetBaseFromGprRiskIndexByIndexCode(indexCode string) (list *BaseFromGprRiskIndex, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_index WHERE index_code=? `
-	err = o.Raw(sql, indexCode).QueryRow(&list)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, indexCode).First(&list).Error
 	return
 }
 
@@ -250,8 +241,7 @@ type BaseFromGprRiskIndexType struct {
 
 // Update 更新GprRisk指标基础信息
 func (item *BaseFromGprRiskIndex) 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
 }
 
@@ -272,9 +262,8 @@ type GprRiskIndexSource2EdbReq struct {
 }
 
 func GetGprRiskFrequencyByClassifyId(classifyId int) (items []*GlFrequency, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT frequency FROM base_from_gpr_risk_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
 }

models/data_manage/base_from_gpr_risk_classify.go

@@ -1,10 +1,9 @@
 package data_manage
 
 import (
+	"eta/eta_api/global"
 	"eta/eta_api/utils"
 	"time"
-
-	"github.com/beego/beego/v2/client/orm"
 )
 
 // BaseFromUsdaFasClassify UsdaFas原始数据分类表
@@ -22,17 +21,15 @@ type BaseFromGprRiskClassify struct {
 
 // GetBaseFromGprRiskClassifyCount 获取分类名称的个数
 func GetBaseFromGprRiskClassifyCount(classifyName string, parentId int) (count int, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT COUNT(1) AS count FROM base_from_gpr_risk_classify WHERE classify_name=? AND parent_id=? `
-	err = o.Raw(sql, classifyName, parentId).QueryRow(&count)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyName, parentId).Scan(&count).Error
 	return
 }
 
 // GetBaseFromGprRiskClassifyById 通过分类id的获取分类信息
 func GetBaseFromGprRiskClassifyById(classifyId int) (item *BaseFromGprRiskClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_gpr_risk_classify WHERE classify_id=? `
-	err = o.Raw(sql, classifyId).QueryRow(&item)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyId).Find(&item).Error
 	return
 }
 
@@ -41,25 +38,22 @@ func GetBaseFromGprRiskClassifyByIds(classifyIds []int) (items []*BaseFromGprRis
 	if len(classifyIds) == 0 {
 		return
 	}
-	o := orm.NewOrmUsingDB("data")
 	sql := `SELECT * FROM base_from_gpr_risk_classify WHERE classify_id IN (` + utils.GetOrmInReplace(len(classifyIds)) + `) `
-	_, err = o.Raw(sql, classifyIds).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql, classifyIds).Find(&items).Error
 	return
 }
 
 // EditBaseFromGprRiskClassify 修改GprRisk原始数据分类
 func EditBaseFromGprRiskClassify(classifyId int, classifyName string) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_gpr_risk_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
 }
 
 // UpdateBaseFromGprRiskClassifySort 修改GprRisk原始数据分类的排序
 func UpdateBaseFromGprRiskClassifySort(classifyId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := `UPDATE base_from_gpr_risk_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
 }
 
@@ -99,17 +93,15 @@ type BaseFromGprRiskClassifyItemsButton struct {
 
 // GetBaseFromGprRiskClassifyByParentId 根据上级id获取当下的分类列表数据
 func GetBaseFromGprRiskClassifyByParentId(parentId int) (items []*BaseFromGprRiskClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_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
 }
 
 // GetAllBaseFromGprRiskClassify 获取所有的分类列表数据
 func GetAllBaseFromGprRiskClassify() (items []*BaseFromGprRiskClassifyItems, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_classify order by parent_id asc, sort asc,classify_id asc`
-	_, err = o.Raw(sql).QueryRows(&items)
+	err = global.DbMap[utils.DbNameIndex].Raw(sql).Find(&items).Error
 	return
 }
 
@@ -131,16 +123,14 @@ type BaseFromGprRiskClassifySimplify struct {
 
 // GetFirstBaseFromGprRiskClassify 获取当前分类下，且排序数相同 的排序第一条的数据
 func GetFirstBaseFromGprRiskClassify() (item *BaseFromGprRiskClassify, err error) {
-	o := orm.NewOrmUsingDB("data")
 	sql := ` SELECT * FROM base_from_gpr_risk_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
 }
 
 // Update 更新分类基础信息
 func (BaseFromGprRiskClassify *BaseFromGprRiskClassify) Update(cols []string) (err error) {
-	o := orm.NewOrmUsingDB("data")
-	_, err = o.Update(BaseFromGprRiskClassify, cols...)
+	err = global.DbMap[utils.DbNameIndex].Select(cols).Updates(BaseFromGprRiskClassify).Error
 	return
 }