refactor(app): 优化 URL 处理和 JSON 解析逻辑
- 更新应用程序处理程序中的 URL 赋值逻辑，确保静态文件使用原始路径 - 修改缓存数据库的 JSON 解析方法，使用 JsonToObj 函数替代 json.Unmarshal，提升代码可读性和性能 - 在 Map 和 Slice 类型中新增获取四舍五入浮点数的方法，增强数据处理能力 - 在 Obj 类型中添加四舍五入功能，支持精度控制 - 改进数据库查询结果的处理逻辑，确保数据类型的准确性和一致性 - 优化日志格式设置，增强日志信息的可读性
This commit is contained in:
+177
-14
@@ -4,7 +4,9 @@ import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"math"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
. "code.hoteas.com/golang/hotime/common"
|
||||
@@ -358,34 +360,195 @@ func (that *HoTimeDB) expandArrayPlaceholder(query string, args []interface{}) (
|
||||
return result.String(), newArgs
|
||||
}
|
||||
|
||||
const (
|
||||
dbTypeUnknown = iota
|
||||
dbTypeInteger
|
||||
dbTypeFloat
|
||||
dbTypeDecimal
|
||||
)
|
||||
|
||||
// classifyDBType 将数据库类型名分类，覆盖 MySQL/SQLite/PostgreSQL
|
||||
func classifyDBType(typeName string) int {
|
||||
t := strings.ToUpper(strings.TrimSpace(typeName))
|
||||
t = strings.TrimSuffix(strings.TrimSuffix(t, " UNSIGNED"), " SIGNED")
|
||||
t = strings.TrimSpace(t)
|
||||
base := t
|
||||
if idx := strings.IndexByte(t, '('); idx > 0 {
|
||||
base = t[:idx]
|
||||
}
|
||||
switch base {
|
||||
case "INT", "INTEGER", "BIGINT", "TINYINT", "SMALLINT", "MEDIUMINT",
|
||||
"INT2", "INT4", "INT8",
|
||||
"SERIAL", "BIGSERIAL", "SMALLSERIAL",
|
||||
"YEAR", "BOOL", "BOOLEAN", "OID":
|
||||
return dbTypeInteger
|
||||
case "DECIMAL", "NUMERIC", "NEWDECIMAL":
|
||||
return dbTypeDecimal
|
||||
case "FLOAT", "DOUBLE", "REAL", "FLOAT4", "FLOAT8", "DOUBLE PRECISION":
|
||||
return dbTypeFloat
|
||||
}
|
||||
if strings.Contains(base, "INT") {
|
||||
return dbTypeInteger
|
||||
}
|
||||
if strings.Contains(base, "DECIMAL") || strings.Contains(base, "NUMERIC") {
|
||||
return dbTypeDecimal
|
||||
}
|
||||
if strings.Contains(base, "DOUBLE") || strings.Contains(base, "FLOAT") {
|
||||
return dbTypeFloat
|
||||
}
|
||||
return dbTypeUnknown
|
||||
}
|
||||
|
||||
// getDecimalScale 提取 DECIMAL/NUMERIC 精度，失败返回 -1
|
||||
func getDecimalScale(colType *sql.ColumnType, typeName string) int {
|
||||
_, scale, ok := colType.DecimalSize()
|
||||
if ok && scale >= 0 {
|
||||
return int(scale)
|
||||
}
|
||||
// SQLite 不支持 DecimalSize，从类型名解析 "DECIMAL(10,2)" → 2
|
||||
upper := strings.ToUpper(typeName)
|
||||
if idx := strings.Index(upper, ","); idx > 0 {
|
||||
rest := upper[idx+1:]
|
||||
if end := strings.IndexByte(rest, ')'); end > 0 {
|
||||
if s, err := strconv.Atoi(strings.TrimSpace(rest[:end])); err == nil {
|
||||
return s
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// getFloatScale 提取 FLOAT/DOUBLE 显式精度，无显式精度返回 -1 表示不截断
|
||||
func getFloatScale(colType *sql.ColumnType, typeName string) int {
|
||||
_, scale, ok := colType.DecimalSize()
|
||||
if ok && scale > 0 && scale < 20 {
|
||||
return int(scale)
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// fixFloatValue 对 float64 值做类型感知精度修正
|
||||
func fixFloatValue(f float64, category int, scale int) interface{} {
|
||||
if math.IsNaN(f) || math.IsInf(f, 0) {
|
||||
return float64(0)
|
||||
}
|
||||
switch category {
|
||||
case dbTypeInteger:
|
||||
return int64(math.Round(f))
|
||||
case dbTypeDecimal:
|
||||
return roundFloat(f, scale)
|
||||
case dbTypeFloat:
|
||||
return roundFloat(f, scale)
|
||||
default:
|
||||
return f
|
||||
}
|
||||
}
|
||||
|
||||
// roundFloat 使用 strconv 精确舍入，避免 f*pow 中间值产生精度误差
|
||||
func roundFloat(f float64, scale int) interface{} {
|
||||
if math.IsNaN(f) || math.IsInf(f, 0) {
|
||||
return float64(0)
|
||||
}
|
||||
if scale == 0 {
|
||||
// DECIMAL(10,0) 明确是整数
|
||||
return math.Round(f)
|
||||
}
|
||||
if scale < 0 {
|
||||
// 精度未知，不修正，原样返回
|
||||
return f
|
||||
}
|
||||
s := strconv.FormatFloat(f, 'f', scale, 64)
|
||||
v, err := strconv.ParseFloat(s, 64)
|
||||
if err != nil {
|
||||
return f
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// convertBytes 对 []byte 类型的列做类型感知解析
|
||||
// MySQL 文本协议和 PG 的 DECIMAL/NUMERIC 以 []byte 返回，需要按列类型解析为正确 Go 类型
|
||||
func convertBytes(raw []byte, category int, scale int) interface{} {
|
||||
s := string(raw)
|
||||
switch category {
|
||||
case dbTypeInteger:
|
||||
if n, err := strconv.ParseInt(s, 10, 64); err == nil {
|
||||
return n
|
||||
}
|
||||
if f, err := strconv.ParseFloat(s, 64); err == nil {
|
||||
return int64(math.Round(f))
|
||||
}
|
||||
return s
|
||||
case dbTypeDecimal:
|
||||
if f, err := strconv.ParseFloat(s, 64); err == nil {
|
||||
return roundFloat(f, scale)
|
||||
}
|
||||
return s
|
||||
case dbTypeFloat:
|
||||
if f, err := strconv.ParseFloat(s, 64); err == nil {
|
||||
return roundFloat(f, scale)
|
||||
}
|
||||
return s
|
||||
default:
|
||||
return s
|
||||
}
|
||||
}
|
||||
|
||||
// Row 数据库数据解析
|
||||
func (that *HoTimeDB) Row(resl *sql.Rows) []Map {
|
||||
defer resl.Close()
|
||||
|
||||
dest := make([]Map, 0)
|
||||
strs, _ := resl.Columns()
|
||||
colTypes, _ := resl.ColumnTypes()
|
||||
|
||||
for i := 0; resl.Next(); i++ {
|
||||
lis := make(Map, 0)
|
||||
a := make([]interface{}, len(strs))
|
||||
colCount := len(strs)
|
||||
categories := make([]int, colCount)
|
||||
scales := make([]int, colCount)
|
||||
if colTypes != nil {
|
||||
for j := 0; j < len(colTypes) && j < colCount; j++ {
|
||||
typeName := colTypes[j].DatabaseTypeName()
|
||||
categories[j] = classifyDBType(typeName)
|
||||
switch categories[j] {
|
||||
case dbTypeDecimal:
|
||||
scales[j] = getDecimalScale(colTypes[j], typeName)
|
||||
case dbTypeFloat:
|
||||
scales[j] = getFloatScale(colTypes[j], typeName)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
b := make([]interface{}, len(a))
|
||||
for j := 0; j < len(a); j++ {
|
||||
for resl.Next() {
|
||||
lis := make(Map, colCount)
|
||||
a := make([]interface{}, colCount)
|
||||
b := make([]interface{}, colCount)
|
||||
for j := 0; j < colCount; j++ {
|
||||
b[j] = &a[j]
|
||||
}
|
||||
err := resl.Scan(b...)
|
||||
if err != nil {
|
||||
if err := resl.Scan(b...); err != nil {
|
||||
that.LastErr.SetError(err)
|
||||
return nil
|
||||
}
|
||||
for j := 0; j < len(a); j++ {
|
||||
if a[j] != nil && reflect.ValueOf(a[j]).Type().String() == "[]uint8" {
|
||||
lis[strs[j]] = string(a[j].([]byte))
|
||||
} else {
|
||||
lis[strs[j]] = a[j] // 取实际类型
|
||||
for j := 0; j < colCount; j++ {
|
||||
val := a[j]
|
||||
if val == nil {
|
||||
lis[strs[j]] = nil
|
||||
continue
|
||||
}
|
||||
switch v := val.(type) {
|
||||
case []byte:
|
||||
lis[strs[j]] = convertBytes(v, categories[j], scales[j])
|
||||
case float64:
|
||||
lis[strs[j]] = fixFloatValue(v, categories[j], scales[j])
|
||||
case float32:
|
||||
lis[strs[j]] = fixFloatValue(float64(v), categories[j], scales[j])
|
||||
default:
|
||||
lis[strs[j]] = val
|
||||
}
|
||||
}
|
||||
|
||||
dest = append(dest, lis)
|
||||
}
|
||||
|
||||
if err := resl.Err(); err != nil {
|
||||
that.LastErr.SetError(err)
|
||||
}
|
||||
return dest
|
||||
}
|
||||
|
||||
+245
@@ -0,0 +1,245 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"math"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// ─────────────────────────────────────────────
|
||||
// classifyDBType
|
||||
// ─────────────────────────────────────────────
|
||||
func TestClassifyDBType(t *testing.T) {
|
||||
cases := []struct {
|
||||
typeName string
|
||||
want int
|
||||
}{
|
||||
// MySQL 整数类型
|
||||
{"INT", dbTypeInteger},
|
||||
{"TINYINT", dbTypeInteger},
|
||||
{"SMALLINT", dbTypeInteger},
|
||||
{"MEDIUMINT", dbTypeInteger},
|
||||
{"BIGINT", dbTypeInteger},
|
||||
{"INT UNSIGNED", dbTypeInteger},
|
||||
{"BIGINT UNSIGNED", dbTypeInteger},
|
||||
{"TINYINT(1)", dbTypeInteger},
|
||||
{"YEAR", dbTypeInteger},
|
||||
{"BOOL", dbTypeInteger},
|
||||
{"BOOLEAN", dbTypeInteger},
|
||||
|
||||
// PostgreSQL 整数类型
|
||||
{"INT2", dbTypeInteger},
|
||||
{"INT4", dbTypeInteger},
|
||||
{"INT8", dbTypeInteger},
|
||||
{"SERIAL", dbTypeInteger},
|
||||
{"BIGSERIAL", dbTypeInteger},
|
||||
{"SMALLSERIAL", dbTypeInteger},
|
||||
{"OID", dbTypeInteger},
|
||||
|
||||
// DECIMAL / NUMERIC
|
||||
{"DECIMAL", dbTypeDecimal},
|
||||
{"DECIMAL(10,2)", dbTypeDecimal},
|
||||
{"NUMERIC", dbTypeDecimal},
|
||||
{"NUMERIC(8,4)", dbTypeDecimal},
|
||||
{"NEWDECIMAL", dbTypeDecimal},
|
||||
|
||||
// FLOAT / DOUBLE
|
||||
{"FLOAT", dbTypeFloat},
|
||||
{"DOUBLE", dbTypeFloat},
|
||||
{"REAL", dbTypeFloat},
|
||||
{"FLOAT4", dbTypeFloat},
|
||||
{"FLOAT8", dbTypeFloat},
|
||||
{"DOUBLE PRECISION", dbTypeFloat},
|
||||
|
||||
// 未知类型
|
||||
{"VARCHAR", dbTypeUnknown},
|
||||
{"TEXT", dbTypeUnknown},
|
||||
{"DATETIME", dbTypeUnknown},
|
||||
{"TIMESTAMP", dbTypeUnknown},
|
||||
{"BLOB", dbTypeUnknown},
|
||||
{"", dbTypeUnknown},
|
||||
}
|
||||
|
||||
for _, c := range cases {
|
||||
t.Run(c.typeName, func(t *testing.T) {
|
||||
got := classifyDBType(c.typeName)
|
||||
if got != c.want {
|
||||
t.Errorf("classifyDBType(%q) = %d, want %d", c.typeName, got, c.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// ─────────────────────────────────────────────
|
||||
// fixFloatValue
|
||||
// ─────────────────────────────────────────────
|
||||
func TestFixFloatValue(t *testing.T) {
|
||||
t.Run("integer category: round to int64", func(t *testing.T) {
|
||||
// 这是核心场景：float64 精度噪声导致整数变为 1.9999...
|
||||
got := fixFloatValue(1.9999999999999998, dbTypeInteger, 0)
|
||||
if got != int64(2) {
|
||||
t.Errorf("got %v (%T), want int64(2)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("integer category: 2.0000000000001 rounds to 2", func(t *testing.T) {
|
||||
got := fixFloatValue(2.0000000000001, dbTypeInteger, 0)
|
||||
if got != int64(2) {
|
||||
t.Errorf("got %v (%T), want int64(2)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decimal category: scale=2 roundtrip precision", func(t *testing.T) {
|
||||
got := fixFloatValue(1.1999999999999999, dbTypeDecimal, 2)
|
||||
f, ok := got.(float64)
|
||||
if !ok {
|
||||
t.Fatalf("expected float64, got %T", got)
|
||||
}
|
||||
if f != 1.2 {
|
||||
t.Errorf("got %v, want 1.2", f)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decimal category: scale=2, 1.20000000001 -> 1.2", func(t *testing.T) {
|
||||
got := fixFloatValue(1.20000000001, dbTypeDecimal, 2)
|
||||
f := got.(float64)
|
||||
if f != 1.2 {
|
||||
t.Errorf("got %v, want 1.2", f)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decimal category: scale=-1 (unknown), no modification", func(t *testing.T) {
|
||||
got := fixFloatValue(1.23456789, dbTypeDecimal, -1)
|
||||
if got != 1.23456789 {
|
||||
t.Errorf("got %v, want 1.23456789", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decimal category: scale=0, round to whole number", func(t *testing.T) {
|
||||
got := fixFloatValue(2.7, dbTypeDecimal, 0)
|
||||
if got != float64(3) {
|
||||
t.Errorf("got %v (%T), want float64(3)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("float category: scale=-1 no modification", func(t *testing.T) {
|
||||
got := fixFloatValue(3.14159265, dbTypeFloat, -1)
|
||||
if got != 3.14159265 {
|
||||
t.Errorf("got %v, want 3.14159265", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unknown category: passthrough", func(t *testing.T) {
|
||||
got := fixFloatValue(99.9, dbTypeUnknown, -1)
|
||||
if got != 99.9 {
|
||||
t.Errorf("got %v, want 99.9", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("NaN -> 0", func(t *testing.T) {
|
||||
got := fixFloatValue(math.NaN(), dbTypeInteger, 0)
|
||||
if got != float64(0) {
|
||||
t.Errorf("got %v, want 0", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("+Inf -> 0", func(t *testing.T) {
|
||||
got := fixFloatValue(math.Inf(1), dbTypeDecimal, 2)
|
||||
if got != float64(0) {
|
||||
t.Errorf("got %v, want 0", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// ─────────────────────────────────────────────
|
||||
// roundFloat
|
||||
// ─────────────────────────────────────────────
|
||||
func TestRoundFloat(t *testing.T) {
|
||||
t.Run("scale=2: 1.19999... -> 1.2", func(t *testing.T) {
|
||||
got := roundFloat(1.1999999999999999, 2)
|
||||
if got != float64(1.2) {
|
||||
t.Errorf("got %v, want 1.2", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("scale=2: 1.20000...1 -> 1.2", func(t *testing.T) {
|
||||
got := roundFloat(1.20000000001, 2)
|
||||
if got != float64(1.2) {
|
||||
t.Errorf("got %v, want 1.2", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("scale=0: round to integer float", func(t *testing.T) {
|
||||
got := roundFloat(2.5, 0)
|
||||
if got != float64(3) {
|
||||
t.Errorf("got %v, want 3.0", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("scale=-1: passthrough unchanged", func(t *testing.T) {
|
||||
got := roundFloat(1.23456789, -1)
|
||||
if got != 1.23456789 {
|
||||
t.Errorf("got %v, want 1.23456789", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("NaN -> 0", func(t *testing.T) {
|
||||
got := roundFloat(math.NaN(), 2)
|
||||
if got != float64(0) {
|
||||
t.Errorf("got %v, want 0", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// ─────────────────────────────────────────────
|
||||
// convertBytes
|
||||
// ─────────────────────────────────────────────
|
||||
func TestConvertBytes(t *testing.T) {
|
||||
t.Run("integer category: '2' -> int64(2)", func(t *testing.T) {
|
||||
got := convertBytes([]byte("2"), dbTypeInteger, 0)
|
||||
if got != int64(2) {
|
||||
t.Errorf("got %v (%T), want int64(2)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("integer category: '2.00' -> int64(2)", func(t *testing.T) {
|
||||
got := convertBytes([]byte("2.00"), dbTypeInteger, 0)
|
||||
if got != int64(2) {
|
||||
t.Errorf("got %v (%T), want int64(2)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decimal category: '1.20' scale=2 -> float64(1.2)", func(t *testing.T) {
|
||||
got := convertBytes([]byte("1.20"), dbTypeDecimal, 2)
|
||||
if got != float64(1.2) {
|
||||
t.Errorf("got %v (%T), want float64(1.2)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("decimal category: '0.00' scale=2 -> float64(0)", func(t *testing.T) {
|
||||
got := convertBytes([]byte("0.00"), dbTypeDecimal, 2)
|
||||
if got != float64(0) {
|
||||
t.Errorf("got %v (%T), want float64(0)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("float category: '3.14' scale=-1 -> float64(3.14)", func(t *testing.T) {
|
||||
got := convertBytes([]byte("3.14"), dbTypeFloat, -1)
|
||||
if got != float64(3.14) {
|
||||
t.Errorf("got %v (%T), want float64(3.14)", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("unknown category: passthrough as string", func(t *testing.T) {
|
||||
got := convertBytes([]byte("hello"), dbTypeUnknown, 0)
|
||||
if got != "hello" {
|
||||
t.Errorf("got %v (%T), want 'hello'", got, got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("integer category: invalid bytes -> string fallback", func(t *testing.T) {
|
||||
got := convertBytes([]byte("abc"), dbTypeInteger, 0)
|
||||
if got != "abc" {
|
||||
t.Errorf("got %v (%T), want 'abc'", got, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user