Go database/sql 中自定义 []byte 类型扫描异常及解决方案

type Votes []byte

func Vote(username string) (isSucceed bool) {
    // ... 数据库连接和错误处理 ...

    // 1. 从数据库查询 votes
    stmt, err := db.Prepare(`SELECT votes FROM users WHERE username = ?`)
    // ... 错误处理 ...
    res := stmt.QueryRow(username)
    stmt.Close()

    var votes Votes
    res.Scan(&votes) // 假设这里从数据库读取到 "0000"
    fmt.Println(string(votes)) // 输出: 0000

    // 2. 对 votes 进行业务逻辑修改
    // 假设 votes.add 方法将 "0000" 修改为 "1000"
    isSucceed = votes.add(VoteType(0), 1)
    fmt.Println(string(votes)) // 输出: 1000

    if isSucceed {
        // 3. 准备更新数据库
        stmt, err = db.Prepare(`UPDATE users SET votes = ? WHERE username = ?`)
        // ... 错误处理 ...

        // 此时，votes 的值可能已经悄然改变！
        fmt.Println(string(votes)) // 预期输出: 1000，但实际可能输出乱码或空值
        _, _ = stmt.Exec(votes, username) // 使用了错误的值
        stmt.Close()
    }
    return
}

package main

import "fmt"

// 定义一个自定义的字节切片类型别名
type BYTES []byte

// 模拟 sql.Rows.Scan 内部可能进行的类型检查
// 它会尝试将传入的 interface{} 转换为 *[]byte
func testScanTarget(v interface{}) {
    // 尝试将 v 断言为 *[]byte 类型
    b, ok := v.(*[]byte)
    fmt.Printf("Is *[]byte? %v, Value: %v\n", ok, b)
}

func main() {
    p := BYTES("hello")
    fmt.Printf("Original BYTES value: %s, Type: %T\n", p, p)

    fmt.Println("\n--- 场景一：直接传递 &p ---")
    // 此时 &p 的类型是 *BYTES，而不是 *[]byte
    testScanTarget(&p) // 输出: Is *[]byte? false, Value: <nil>
    fmt.Printf("After test (p): %s\n", p) // p 的值未受影响，因为 testScanTarget 内部未成功赋值

    fmt.Println("\n--- 场景二：显式类型转换后传递 ---")
    // 将 &p 显式转换为 *[]byte 类型后再传递
    testScanTarget((*[]byte)(&p)) // 输出: Is *[]byte? true, Value: &[104 101 108 108 111]
    fmt.Printf("After test (p): %s\n", p) // p 的值未受影响，因为 testScanTarget 内部未成功赋值
}

Original BYTES value: hello, Type: main.BYTES

--- 场景一：直接传递 &p ---
Is *[]byte? false, Value: <nil>
After test (p): hello

--- 场景二：显式类型转换后传递 ---
Is *[]byte? true, Value: &[104 101 108 108 111]
After test (p): hello

res.Scan(&votes)

err = res.Scan((*[]byte)(&votes)) // 显式类型断言
// 务必检查 Scan 返回的错误
if err != nil {
    // 处理错误
    log.Fatal(err)
}

func Vote(_type, did int, username string) (isSucceed bool) {
    db := lib.OpenDb()
    defer db.Close()

    stmt, err := db.Prepare(`SELECT votes FROM users WHERE username = ?`)
    lib.CheckErr(err)

    res := stmt.QueryRow(username)
    stmt.Close()

    var votes Votes
    // 修正点：显式类型转换，确保 Scan 正确识别目标类型
    err = res.Scan((*[]byte)(&votes))
    lib.CheckErr(err) // 务必检查 Scan 返回的错误

    fmt.Println(votes)      // output: [48 48 48 48]
    fmt.Println(string(votes)) // output: 0000

    isSucceed = votes.add(VoteType(_type), 1)
    fmt.Println(votes)      // output: [49 48 48 48]
    fmt.Println(string(votes)) // output: 1000

    if isSucceed {
        // Update user votes
        stmt, err := db.Prepare(`UPDATE users SET votes = ? WHERE username = ?`)
        lib.CheckErr(err)

        // 此时，votes 的值将是正确的 [49 48 48 48]
        fmt.Println(votes)      // output: [49 48 48 48]
        fmt.Println(string(votes)) // output: 1000
        _, _ = stmt.Exec(votes, username) // 现在 votes 的值是正确的
        stmt.Close()

        // Insert the vote data
        stmt, err = db.Prepare(`INSERT votes SET did = ?, username = ?, date = ?`)
        lib.CheckErr(err)

        today := time.Now()
        _, _ = stmt.Exec(did, username, today)
        stmt.Close()
    }

    return
}