Golang如何动态从数据库表中检索并比较数据列值

在Golang中动态从数据库表中检索并比较数据列值，可以使用database/sql包结合反射（reflect）来实现。以下是一个示例代码，展示如何动态获取表中的列值并进行比较：

package main

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

func main() {
    // 连接数据库
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    // 查询数据
    rows, err := db.Query("SELECT * FROM your_table")
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()

    // 获取列信息
    columns, err := rows.Columns()
    if err != nil {
        panic(err.Error())
    }

    // 创建动态存储结构
    values := make([]interface{}, len(columns))
    valuePtrs := make([]interface{}, len(columns))
    for i := range values {
        valuePtrs[i] = &values[i]
    }

    // 遍历结果集
    for rows.Next() {
        err = rows.Scan(valuePtrs...)
        if err != nil {
            panic(err.Error())
        }

        // 动态处理每一列的值
        for i, col := range columns {
            val := values[i]
            fmt.Printf("Column: %s, Value: %v, Type: %v\n", col, val, reflect.TypeOf(val))

            // 示例：比较列值
            switch v := val.(type) {
            case []byte:
                strVal := string(v)
                if strVal == "passsd" || strVal == "paaswd.cpy" {
                    fmt.Printf("Found special value: %s\n", strVal)
                }
            case string:
                if v == "ABC" || v == "DEF" {
                    fmt.Printf("Found special value: %s\n", v)
                }
            }
        }
    }
}

如果需要更灵活的动态比较，可以进一步封装：

func compareDynamicValues(values map[string]interface{}, targets []string) bool {
    for _, val := range values {
        switch v := val.(type) {
        case []byte:
            strVal := string(v)
            for _, target := range targets {
                if strVal == target {
                    return true
                }
            }
        case string:
            for _, target := range targets {
                if v == target {
                    return true
                }
            }
        }
    }
    return false
}

// 使用示例
func processRows(rows *sql.Rows, columns []string) {
    values := make([]interface{}, len(columns))
    valuePtrs := make([]interface{}, len(columns))
    for i := range values {
        valuePtrs[i] = &values[i]
    }

    for rows.Next() {
        rows.Scan(valuePtrs...)
        
        // 转换为map便于处理
        rowData := make(map[string]interface{})
        for i, col := range columns {
            rowData[col] = values[i]
        }

        // 动态比较
        targets := []string{"passsd", "paaswd.cpy", "ABC", "DEF"}
        if compareDynamicValues(rowData, targets) {
            fmt.Println("Found matching row:", rowData)
        }
    }
}

对于需要处理多种数据类型的场景：

func getColumnValueAsString(val interface{}) string {
    switch v := val.(type) {
    case []byte:
        return string(v)
    case string:
        return v
    case int64:
        return fmt.Sprintf("%d", v)
    case float64:
        return fmt.Sprintf("%f", v)
    case bool:
        return fmt.Sprintf("%t", v)
    case nil:
        return ""
    default:
        return fmt.Sprintf("%v", v)
    }
}

// 使用示例
func findMatchingColumns(rows *sql.Rows, columns []string, searchValues []string) {
    values := make([]interface{}, len(columns))
    valuePtrs := make([]interface{}, len(columns))
    for i := range values {
        valuePtrs[i] = &values[i]
    }

    for rows.Next() {
        rows.Scan(valuePtrs...)
        
        for i, col := range columns {
            strVal := getColumnValueAsString(values[i])
            for _, searchVal := range searchValues {
                if strVal == searchVal {
                    fmt.Printf("Match found - Column: %s, Value: %s\n", col, strVal)
                }
            }
        }
    }
}

这些代码展示了如何动态地从数据库表中检索列值，并进行灵活的比较操作。通过使用interface{}类型和反射，可以处理不同数据类型的列值，并实现动态的存储和比较逻辑。