Go中SQL查询结果扫描到自定义[]byte类型的陷阱与解决方案

type Votes []byte

// 假设 votes 是一个 Votes 类型的变量
var votes Votes
res.Scan(&votes) // 问题所在

package main

import "fmt"

// 自定义类型 BYTES，是 []byte 的别名
type BYTES []byte

// test 函数尝试将传入的 interface{} 断言为 *[]byte
func test(v interface{}) {
    b, ok := v.(*[]byte)
    fmt.Printf("断言结果: %v, 成功? %t\n", b, ok)
}

func main() {
    p := BYTES("hello")
    fmt.Println("传入 &p (类型 *BYTES):")
    test(&p) // 尝试将 *BYTES 断言为 *[]byte

    fmt.Println("\n传入 (*[]byte)(&p) (类型 *[]byte):")
    test((*[]byte)(&p)) // 显式将 *BYTES 转换为 *[]byte
}

传入 &p (类型 *BYTES):
断言结果: <nil>, 成功? false

传入 (*[]byte)(&p) (类型 *[]byte):
断言结果: &[104 101 108 108 111], 成功? true

package main

import (
    "database/sql"
    "fmt"
    "time"

    _ "github.com/go-sql-driver/mysql" // 导入MySQL驱动
)

// 假设 Votes 类型定义如前
type Votes []byte
type VoteType int

const VOTE_MAX = 9 // 示例常量

// add 方法用于修改 Votes 值
func (this *Votes) add(_type VoteType, num int) (isSucceed bool) {
    // 确保切片有足够的长度，避免越界
    if len(*this) <= int(_type) {
        // 根据需要扩展切片或返回错误
        return false
    }

    if (*this)[_type] > VOTE_MAX-1 { // beyond
        isSucceed = false
    } else {
        (*this)[_type] += byte(num) // 直接修改字节
        isSucceed = true
    }
    return
}

// 模拟数据库连接和错误检查
func OpenDb() *sql.DB {
    // 实际应用中请替换为你的数据库连接字符串
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/testdb")
    if err != nil {
        panic(err)
    }
    return db
}

func CheckErr(err error) {
    if err != nil {
        panic(err)
    }
}

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

    // 1. 查询 votes 值
    stmt, err := db.Prepare(`SELECT votes FROM users WHERE username = ?`)
    CheckErr(err)
    defer stmt.Close() // 确保语句关闭

    var votes Votes
    // 关键修复：使用显式类型转换
    res := stmt.QueryRow(username)
    err = res.Scan((*[]byte)(&votes)) // 将 &votes 显式转换为 *[]byte
    CheckErr(err)

    fmt.Printf("初始 votes (字节): %v\n", votes) // output: [48 48 48 48]
    fmt.Printf("初始 votes (字符串): %s\n", string(votes)) // output: 0000

    // 2. 修改 votes 值
    isSucceed = votes.add(VoteType(_type), 1)
    fmt.Printf("修改后 votes (字节): %v\n", votes) // output: [49 48 48 48]
    fmt.Printf("修改后 votes (字符串): %s\n", string(votes)) // output: 1000

    if isSucceed {
        // 3. 更新用户 votes
        stmtUpdate, err := db.Prepare(`UPDATE users SET votes = ? WHERE username = ?`)
        CheckErr(err)
        defer stmtUpdate.Close() // 确保语句关闭

        // 此时 votes 变量是正确的，可以直接使用
        fmt.Printf("更新前 votes (字节): %v\n", votes) // output: [49 48 48 48]
        fmt.Printf("更新前 votes (字符串): %s\n", string(votes)) // output: 1000

        _, err = stmtUpdate.Exec(votes, username) // 直接传递 Votes 类型
        CheckErr(err)

        // 4. 插入投票数据
        stmtInsert, err := db.Prepare(`INSERT INTO votes (did, username, date) VALUES (?, ?, ?)`)
        CheckErr(err)
        defer stmtInsert.Close() // 确保语句关闭

        today := time.Now()
        _, err = stmtInsert.Exec(did, username, today)
        CheckErr(err)
    }

    return
}

func main() {
    // 假设数据库中有一条记录: username="testuser", votes="0000"
    // 运行前请确保数据库和表已设置
    // CREATE TABLE users (username VARCHAR(255) PRIMARY KEY, votes VARCHAR(4));
    // INSERT INTO users (username, votes) VALUES ('testuser', '0000');
    // CREATE TABLE votes (id INT AUTO_INCREMENT PRIMARY KEY, did INT, username VARCHAR(255), date DATETIME);

    // 示例调用
    Vote(0, 1001, "testuser")
}

package main

import (
    "database/sql"
    "fmt"
    "time"
    _ "github.com/go-sql-driver/mysql"
)

// Votes 类型实现 sql.Scanner 接口
type Votes []byte

// Scan 方法实现 sql.Scanner 接口
func (v *Votes) Scan(value interface{}) error {
    if value == nil {
        *v = nil
        return nil
    }
    // 根据数据库返回的实际类型进行处理
    switch data := value.(type) {
    case []byte:
        *v = append((*v)[:0], data...) // 复制数据，避免直接引用导致外部修改
    case string:
        *v = append((*v)[:0], []byte(data)...)
    // 其他可能的类型转换
    default:
        return fmt.Errorf("Votes.Scan: 无法处理类型 %T", value)
    }
    return nil
}

// Value 方法实现 driver.Valuer 接口，用于写入数据库
func (v Votes) Value() (driver.Value, error) {
    if v == nil {
        return nil, nil
    }
    return string(v), nil // 假设存入数据库为字符串
}

type VoteType int

const VOTE_MAX = 9

func (this *Votes) add(_type VoteType, num int) (isSucceed bool) {
    if len(*this) <= int(_type) {
        return false
    }

    if (*this)[_type] > VOTE_MAX-1 {
        isSucceed = false
    } else {
        (*this)[_type] += byte(num)
        isSucceed = true
    }
    return
}

// OpenDb 和 CheckErr 函数同上

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

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

    var votes Votes
    res := stmt.QueryRow(username)
    err = res.Scan(&votes) // 直接扫描，因为 Votes 实现了 sql.Scanner
    CheckErr(err)

    fmt.Printf("初始 votes (字节): %v\n", votes)
    fmt.Printf("初始 votes (字符串): %s\n", string(votes))

    isSucceed = votes.add(VoteType(_type), 1)
    fmt.Printf("修改后 votes (字节): %v\n", votes)
    fmt.Printf("修改后 votes (字符串): %s\n", string(votes))

    if isSucceed {
        stmtUpdate, err := db.Prepare(`UPDATE users SET votes = ? WHERE username = ?`)
        CheckErr(err)
        defer stmtUpdate.Close()

        fmt.Printf("更新前 votes (字节): %v\n", votes)
        fmt.Printf("更新前 votes (字符串): %s\n", string(votes))

        _, err = stmtUpdate.Exec(votes, username) // 直接传递 Votes 类型
        CheckErr(err)

        stmtInsert, err := db.Prepare(`INSERT INTO votes (did, username, date) VALUES (?, ?, ?)`)
        CheckErr(err)
        defer stmtInsert.Close()

        today := time.Now()
        _, err = stmtInsert.Exec(did, username, today)
        CheckErr(err)
    }
    return
}

func main() {
    // 示例调用
    VoteWithScanner(0, 1001, "testuser")
}