理解Go sql.Rows.Scan与自定义字节切片类型：避免意外值变更

package main

import "fmt"

type BYTES []byte

func test(v interface{}) {
    // 尝试将接口值断言为 *[]byte
    b, ok := v.(*[]byte) 
    fmt.Printf("断言为 *[]byte: %v, 成功: %t\n", b, ok)
}

func main() {
    p := BYTES("hello")

    // 1. 直接传入 &p (类型是 *BYTES)
    fmt.Println("--- 传入 &p ---")
    test(&p) 
    // 输出：断言为 *[]byte: <nil>, 成功: false
    // 解释：&p 的类型是 *BYTES，不能直接断言为 *[]byte

    // 2. 传入 (*[]byte)(&p) (类型是 *[]byte)
    fmt.Println("--- 传入 (*[]byte)(&p) ---")
    test((*[]byte)(&p)) 
    // 输出：断言为 *[]byte: &[104 101 108 108 111], 成功: true
    // 解释：通过显式类型转换，我们将 *BYTES 转换为 *[]byte，使其符合断言期望
}

var votes Votes
res.Scan(&votes) // 问题所在

var votes Votes
res.Scan((*[]byte)(&votes)) // 显式类型转换

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)
    defer stmt.Close() // 确保stmt被关闭

    res := stmt.QueryRow(username)

    var votes Votes
    // 修正：进行显式类型转换
    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)
        defer stmt.Close() // 确保stmt被关闭

        // 在Exec时，votes类型为Votes，Go-SQL-Driver/MySQL驱动通常能正确处理自定义[]byte类型
        // 如果遇到问题，也可以考虑在此处进行类型转换：stmt.Exec([]byte(votes), username)
        _, err = stmt.Exec(votes, username) 
        lib.CheckErr(err) // 检查Exec的错误

        // Insert the vote data
        stmt, err = db.Prepare(`INSERT votes SET did = ?, username = ?, date = ?`)
        lib.CheckErr(err)
        defer stmt.Close() // 确保stmt被关闭

        today := time.Now()
        _, err = stmt.Exec(did, username, today)
        lib.CheckErr(err) // 检查Exec的错误
    }

    return
}

package main

import (
    "database/sql/driver"
    "fmt"
    "time" // 假设Vote函数中用到
)

// Votes 类型定义
type Votes []byte

// VoteType 类型定义
type VoteType int

const VOTE_MAX = 5 // 示例常量

// add 方法定义
func (this *Votes) add(_type VoteType, num int) (isSucceed bool) {
    if int(_type) >= len(*this) { // 检查索引是否越界
        // 扩展切片以容纳新类型，或者返回失败
        // 这里简单处理为失败
        return false
    }
    if (*this)[_type] > VOTE_MAX-1 { // beyond
        isSucceed = false
    } else {
        (*this)[_type]++
        isSucceed = true
    }
    return
}

// 实现 sql.Scanner 接口
func (v *Votes) Scan(src interface{}) error {
    if src == nil {
        *v = nil // 数据库值为 NULL 时，将 Votes 设置为 nil
        return nil
    }
    switch s := src.(type) {
    case []byte:
        *v = s // 直接赋值字节切片
    case string:
        *v = []byte(s) // 如果数据库返回字符串，转换为字节切片
    default:
        return fmt.Errorf("unsupported type for Votes.Scan: %T", src)
    }
    return nil
}

// 实现 driver.Valuer 接口
func (v Votes) Value() (driver.Value, error) {
    if v == nil {
        return nil, nil // Go nil 对应数据库 NULL
    }
    return []byte(v), nil // 将 Votes 转换为 []byte，数据库驱动可以直接处理
}

// 示例：如何使用（不连接数据库，仅展示接口功能）
func main() {
    var myVotes Votes

    // 模拟从数据库读取 []byte("0000")
    // 调用 Scan 方法时，无需显式类型转换，因为 Votes 类型本身就实现了 Scanner 接口
    err := myVotes.Scan([]byte("0000"))
    if err != nil {
        fmt.Println("Scan error:", err)
        return
    }
    fmt.Println("Scanned Votes:", string(myVotes)) // Output: Scanned Votes: 0000

    // 模拟修改 Votes 值
    myVotes.add(VoteType(0), 1) // 假设 VoteType(0) 对应第一个字节
    fmt.Println("Modified Votes:", string(myVotes)) // Output: Modified Votes: 1000

    // 模拟写入数据库
    // 调用 Value 方法时，也无需显式类型转换
    val, err := myVotes.Value()
    if err != nil {
        fmt.Println("Value error:", err)
        return
    }
    fmt.Printf("Valued Votes for DB: %v (type: %T)\n", val, val) 
    // Output: Valued Votes for DB: [49 48 48 48] (type: []uint8)
}