mirror of
https://github.com/Syngnat/GoNavi.git
synced 2026-06-22 06:23:43 +08:00
0632c5242c
- 修复 OceanBase Oracle DATE 与 TIMESTAMP 的解码、展示和编辑精度丢失问题 - 修复查询结果与数据视图的行号显示、分页页数和日期列展示口径 - 打通 Oracle 与 OceanBase 会话执行链路的扫描方言透传 - 补齐 DBQuery、DataGrid temporal 和 OceanBase 结果链路回归测试
447 lines
16 KiB
Go
447 lines
16 KiB
Go
package db
|
||
|
||
import (
|
||
"encoding/binary"
|
||
"encoding/json"
|
||
"fmt"
|
||
"testing"
|
||
"time"
|
||
|
||
mssql "github.com/microsoft/go-mssqldb"
|
||
)
|
||
|
||
type duckMapLike map[any]any
|
||
|
||
func TestNormalizeQueryValueWithDBType_BitBytes(t *testing.T) {
|
||
v := normalizeQueryValueWithDBType([]byte{0x00}, "BIT")
|
||
if v != int64(0) {
|
||
t.Fatalf("BIT 0x00 期望为 0，实际=%v(%T)", v, v)
|
||
}
|
||
|
||
v = normalizeQueryValueWithDBType([]byte{0x01}, "bit")
|
||
if v != int64(1) {
|
||
t.Fatalf("BIT 0x01 期望为 1，实际=%v(%T)", v, v)
|
||
}
|
||
|
||
v = normalizeQueryValueWithDBType([]byte{0x01, 0x02}, "BIT VARYING")
|
||
if v != int64(258) {
|
||
t.Fatalf("BIT 0x0102 期望为 258，实际=%v(%T)", v, v)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_BitLargeAsString(t *testing.T) {
|
||
v := normalizeQueryValueWithDBType([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, "BIT")
|
||
if s, ok := v.(string); !ok || s != "18446744073709551615" {
|
||
t.Fatalf("BIT 0xffffffffffffffff 期望为 string(18446744073709551615)，实际=%v(%T)", v, v)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_ByteFallbacks(t *testing.T) {
|
||
v := normalizeQueryValueWithDBType([]byte("abc"), "")
|
||
if v != "abc" {
|
||
t.Fatalf("文本 []byte 期望返回 string，实际=%v(%T)", v, v)
|
||
}
|
||
|
||
v = normalizeQueryValueWithDBType([]byte{0x00}, "")
|
||
if v != int64(0) {
|
||
t.Fatalf("未知类型 0x00 期望返回 0，实际=%v(%T)", v, v)
|
||
}
|
||
|
||
v = normalizeQueryValueWithDBType([]byte{0xff}, "")
|
||
if v != "0xff" {
|
||
t.Fatalf("未知类型 0xff 期望返回 0xff，实际=%v(%T)", v, v)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_UniqueIdentifierBytes(t *testing.T) {
|
||
var guid mssql.UniqueIdentifier
|
||
if err := guid.Scan("6F9619FF-8B86-D011-B42D-00C04FC964FF"); err != nil {
|
||
t.Fatalf("构造 UniqueIdentifier 失败: %v", err)
|
||
}
|
||
|
||
rawValue, err := guid.Value()
|
||
if err != nil {
|
||
t.Fatalf("UniqueIdentifier.Value() 失败: %v", err)
|
||
}
|
||
|
||
rawBytes, ok := rawValue.([]byte)
|
||
if !ok {
|
||
t.Fatalf("期望驱动值为 []byte，实际=%T", rawValue)
|
||
}
|
||
|
||
got := normalizeQueryValueWithDBType(rawBytes, "uniqueidentifier")
|
||
if got != "6F9619FF-8B86-D011-B42D-00C04FC964FF" {
|
||
t.Fatalf("uniqueidentifier 期望展示为 GUID 文本，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_MapAnyAnyForJSON(t *testing.T) {
|
||
input := duckMapLike{
|
||
"id": int64(1),
|
||
1: "one",
|
||
true: []interface{}{duckMapLike{2: "two"}},
|
||
"bytes": []byte("ok"),
|
||
}
|
||
|
||
v := normalizeQueryValueWithDBType(input, "")
|
||
root, ok := v.(map[string]interface{})
|
||
if !ok {
|
||
t.Fatalf("期望转换为 map[string]interface{}，实际=%T", v)
|
||
}
|
||
|
||
if root["id"] != int64(1) {
|
||
t.Fatalf("id 字段异常，实际=%v(%T)", root["id"], root["id"])
|
||
}
|
||
if root["1"] != "one" {
|
||
t.Fatalf("数字 key 未被字符串化，实际=%v(%T)", root["1"], root["1"])
|
||
}
|
||
if root["bytes"] != "ok" {
|
||
t.Fatalf("嵌套 []byte 未被转换，实际=%v(%T)", root["bytes"], root["bytes"])
|
||
}
|
||
|
||
arr, ok := root["true"].([]interface{})
|
||
if !ok || len(arr) != 1 {
|
||
t.Fatalf("bool key 下的数组结构异常，实际=%v(%T)", root["true"], root["true"])
|
||
}
|
||
nested, ok := arr[0].(map[string]interface{})
|
||
if !ok {
|
||
t.Fatalf("嵌套 map 未被转换，实际=%v(%T)", arr[0], arr[0])
|
||
}
|
||
if nested["2"] != "two" {
|
||
t.Fatalf("嵌套 map 数字 key 未转换，实际=%v(%T)", nested["2"], nested["2"])
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_UnsafeIntegersAsString(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
input interface{}
|
||
want string
|
||
}{
|
||
{name: "int64 overflow", input: int64(9007199254740992), want: "9007199254740992"},
|
||
{name: "int64 underflow", input: int64(-9007199254740992), want: "-9007199254740992"},
|
||
{name: "uint64 overflow", input: uint64(9007199254740992), want: "9007199254740992"},
|
||
}
|
||
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
got := normalizeQueryValueWithDBType(tc.input, "")
|
||
if got != tc.want {
|
||
t.Fatalf("期望=%q，实际=%v(%T)", tc.want, got, got)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_SafeIntegersKeepType(t *testing.T) {
|
||
got := normalizeQueryValueWithDBType(int64(9007199254740991), "")
|
||
if _, ok := got.(int64); !ok {
|
||
t.Fatalf("安全范围 int64 应保持数字类型，实际=%v(%T)", got, got)
|
||
}
|
||
|
||
got = normalizeQueryValueWithDBType(uint64(9007199254740991), "")
|
||
if _, ok := got.(uint64); !ok {
|
||
t.Fatalf("安全范围 uint64 应保持数字类型，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_JSONNumber(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
input json.Number
|
||
wantType string
|
||
wantValue string
|
||
}{
|
||
{name: "safe integer", input: json.Number("9007199254740991"), wantType: "int64", wantValue: "9007199254740991"},
|
||
{name: "unsafe integer", input: json.Number("9007199254740992"), wantType: "string", wantValue: "9007199254740992"},
|
||
{name: "unsafe negative integer", input: json.Number("-9007199254740992"), wantType: "string", wantValue: "-9007199254740992"},
|
||
{name: "decimal", input: json.Number("12.5"), wantType: "float64", wantValue: "12.5"},
|
||
}
|
||
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
got := normalizeQueryValueWithDBType(tc.input, "")
|
||
switch tc.wantType {
|
||
case "int64":
|
||
v, ok := got.(int64)
|
||
if !ok {
|
||
t.Fatalf("期望 int64，实际=%T", got)
|
||
}
|
||
if v != 9007199254740991 {
|
||
t.Fatalf("期望值=%s，实际=%d", tc.wantValue, v)
|
||
}
|
||
case "string":
|
||
v, ok := got.(string)
|
||
if !ok {
|
||
t.Fatalf("期望 string，实际=%T", got)
|
||
}
|
||
if v != tc.wantValue {
|
||
t.Fatalf("期望值=%s，实际=%s", tc.wantValue, v)
|
||
}
|
||
case "float64":
|
||
v, ok := got.(float64)
|
||
if !ok {
|
||
t.Fatalf("期望 float64，实际=%T", got)
|
||
}
|
||
if v != 12.5 {
|
||
t.Fatalf("期望值=%s，实际=%v", tc.wantValue, v)
|
||
}
|
||
default:
|
||
t.Fatalf("未知断言类型：%s", tc.wantType)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
type customStructValue struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
func (v customStructValue) String() string {
|
||
return fmt.Sprintf("%s-%d", v.Name, v.Age)
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_StructToString(t *testing.T) {
|
||
got := normalizeQueryValueWithDBType(customStructValue{Name: "alice", Age: 18}, "")
|
||
if got != "alice-18" {
|
||
t.Fatalf("结构体应降级为可读字符串，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_TimeStructToRFC3339(t *testing.T) {
|
||
input := time.Date(2026, 3, 5, 18, 30, 15, 123456789, time.UTC)
|
||
got := normalizeQueryValueWithDBType(input, "")
|
||
text, ok := got.(string)
|
||
if !ok {
|
||
t.Fatalf("time.Time 应转为字符串，实际=%v(%T)", got, got)
|
||
}
|
||
if text != "2026-03-05T18:30:15.123456789Z" {
|
||
t.Fatalf("time.Time 规整值异常，实际=%s", text)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampString(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(string(raw), "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle 二进制 TIMESTAMP 字符串应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampStringWithPrecisionType(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(string(raw), "TIMESTAMP(6)", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle TIMESTAMP(6) 字符串应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampStringWithGenericCarrierType(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(string(raw), "VARCHAR2", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle 泛型载体类型的 TIMESTAMP 字符串应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampBytes(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle 二进制 TIMESTAMP 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampBytesWithGenericCarrierType(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "VARCHAR2", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle 泛型载体类型的 TIMESTAMP 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampBytesWithPrecisionType(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "TIMESTAMP(6)", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle TIMESTAMP(6) 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampStringWithoutTypeName(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(string(raw), "", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle 空类型名的 TIMESTAMP 字符串应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleBinaryTimestampBytesWithoutTypeName(t *testing.T) {
|
||
raw := buildOracleBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle 空类型名的 TIMESTAMP 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleMySQLEncodedTimestampString(t *testing.T) {
|
||
raw := buildMySQLBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(string(raw), "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle length-encoded TIMESTAMP 字符串应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleMySQLEncodedTimestampBytes(t *testing.T) {
|
||
raw := buildMySQLBinaryTimestamp(time.Date(2026, 6, 16, 12, 34, 56, 123456000, time.UTC))
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T12:34:56.123456Z" {
|
||
t.Fatalf("OceanBase Oracle length-encoded TIMESTAMP 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleTypeCALiveTimestampString(t *testing.T) {
|
||
raw := []byte{20, 26, 6, 16, 16, 46, 23, 96, 196, 119, 9, 6}
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(string(raw), "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T16:46:23.158844Z" {
|
||
t.Fatalf("OceanBase Oracle TYPE_CA live TIMESTAMP 字符串应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleTypeCALiveTimestampBytes(t *testing.T) {
|
||
raw := []byte{20, 26, 6, 16, 16, 46, 23, 96, 196, 119, 9, 6}
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-16T16:46:23.158844Z" {
|
||
t.Fatalf("OceanBase Oracle TYPE_CA live TIMESTAMP 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleTypeCALiveTimestampWithoutFraction(t *testing.T) {
|
||
raw := []byte{20, 26, 6, 17, 5, 0, 0, 0, 0, 0, 0, 6}
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(raw, "TYPE_CA", oceanBaseOracleScanDialect)
|
||
if got != "2026-06-17T05:00:00Z" {
|
||
t.Fatalf("OceanBase Oracle TYPE_CA 零小数 TIMESTAMP 字节值应解码为 RFC3339，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func buildOracleBinaryTimestamp(tm time.Time) []byte {
|
||
if tm.Location() != time.UTC {
|
||
tm = tm.In(time.UTC)
|
||
}
|
||
buf := []byte{
|
||
byte(tm.Year()/100 + 100),
|
||
byte(tm.Year()%100 + 100),
|
||
byte(tm.Month()),
|
||
byte(tm.Day()),
|
||
byte(tm.Hour() + 1),
|
||
byte(tm.Minute() + 1),
|
||
byte(tm.Second() + 1),
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
}
|
||
binary.BigEndian.PutUint32(buf[7:11], uint32(tm.Nanosecond()))
|
||
return buf
|
||
}
|
||
|
||
func buildMySQLBinaryTimestamp(tm time.Time) []byte {
|
||
if tm.Location() != time.UTC {
|
||
tm = tm.In(time.UTC)
|
||
}
|
||
buf := []byte{11, 0, 0, byte(tm.Month()), byte(tm.Day()), byte(tm.Hour()), byte(tm.Minute()), byte(tm.Second()), 0, 0, 0, 0}
|
||
binary.LittleEndian.PutUint16(buf[1:3], uint16(tm.Year()))
|
||
binary.LittleEndian.PutUint32(buf[8:12], uint32(tm.Nanosecond()/1000))
|
||
return buf
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_MySQLDateOnly(t *testing.T) {
|
||
input := time.Date(2025, 10, 1, 0, 0, 0, 0, time.Local)
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(input, "DATE", "mysql")
|
||
if got != "2025-10-01" {
|
||
t.Fatalf("MySQL DATE 应只展示日期，实际=%v(%T)", got, got)
|
||
}
|
||
|
||
got = normalizeQueryValueWithDBTypeAndDialect(input, "NEWDATE", "mysql")
|
||
if got != "2025-10-01" {
|
||
t.Fatalf("MySQL NEWDATE 应只展示日期，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_DatetimeKeepsTime(t *testing.T) {
|
||
input := time.Date(2025, 10, 1, 13, 14, 15, 0, time.UTC)
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(input, "DATETIME", "mysql")
|
||
if got != "2025-10-01T13:14:15Z" {
|
||
t.Fatalf("MySQL DATETIME 应保留时间，实际=%v(%T)", got, got)
|
||
}
|
||
|
||
got = normalizeQueryValueWithDBTypeAndDialect(input, "DATE", "oracle")
|
||
if got != "2025-10-01T13:14:15Z" {
|
||
t.Fatalf("Oracle DATE 应保留时间语义，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleDateMidnightDisplaysDateOnly(t *testing.T) {
|
||
input := time.Date(2025, 10, 1, 0, 0, 0, 0, time.UTC)
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(input, "DATE", oceanBaseOracleScanDialect)
|
||
if got != "2025-10-01" {
|
||
t.Fatalf("OceanBase Oracle DATE 的午夜值应只展示日期，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBTypeAndDialect_OceanBaseOracleDateKeepsNonMidnightTime(t *testing.T) {
|
||
input := time.Date(2025, 10, 1, 13, 14, 15, 0, time.UTC)
|
||
|
||
got := normalizeQueryValueWithDBTypeAndDialect(input, "DATE", oceanBaseOracleScanDialect)
|
||
if got != "2025-10-01T13:14:15Z" {
|
||
t.Fatalf("OceanBase Oracle DATE 非午夜值应保留时间，实际=%v(%T)", got, got)
|
||
}
|
||
}
|
||
|
||
func TestNormalizeQueryValueWithDBType_ZeroTemporalValues(t *testing.T) {
|
||
zero := time.Time{}
|
||
cases := []struct {
|
||
name string
|
||
dbType string
|
||
wantText string
|
||
}{
|
||
{name: "date", dbType: "DATE", wantText: "0000-00-00"},
|
||
{name: "newdate", dbType: "NEWDATE", wantText: "0000-00-00"},
|
||
{name: "datetime", dbType: "DATETIME", wantText: "0000-00-00 00:00:00"},
|
||
{name: "timestamp", dbType: "TIMESTAMP", wantText: "0000-00-00 00:00:00"},
|
||
{name: "time", dbType: "TIME", wantText: "00:00:00"},
|
||
{name: "year", dbType: "YEAR", wantText: "0000"},
|
||
{name: "unknown", dbType: "", wantText: "0000-00-00 00:00:00"},
|
||
}
|
||
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
got := normalizeQueryValueWithDBType(zero, tc.dbType)
|
||
text, ok := got.(string)
|
||
if !ok {
|
||
t.Fatalf("期望 string，实际=%v(%T)", got, got)
|
||
}
|
||
if text != tc.wantText {
|
||
t.Fatalf("dbType=%s 期望=%s，实际=%s", tc.dbType, tc.wantText, text)
|
||
}
|
||
})
|
||
}
|
||
}
|