Go语言database/sql包动态获取查询结果列类型教程

package main

import (
    "database/sql"
    "fmt"
    "log"
    "reflect"
    _ "github.com/mattn/go-sqlite3" // 导入SQLite驱动
)

// ColumnData 结构体用于存储单列的动态信息
type ColumnData struct {
    Name  string      `json:"columnName"`
    Value interface{} `json:"value"`
    Type  string      `json:"type"` // Go语言类型名称
}

func main() {
    // 1. 连接数据库 (使用SQLite作为示例)
    db, err := sql.Open("sqlite3", ":memory:")
    if err != nil {
        log.Fatalf("无法连接到数据库: %v", err)
    }
    defer db.Close()

    // 2. 创建表并插入示例数据
    sqlStmt := `
    CREATE TABLE users (
        id INTEGER NOT NULL PRIMARY KEY,
        name TEXT,
        age INTEGER,
        balance REAL,
        created_at DATETIME,
        description TEXT
    );
    INSERT INTO users(id, name, age, balance, created_at, description) VALUES(1, 'Alice', 30, 100.50, '2023-01-01 10:00:00', 'Admin user');
    INSERT INTO users(id, name, age, balance, created_at, description) VALUES(2, 'Bob', 25, 200.75, '2023-01-02 11:00:00', NULL);
    `
    _, err = db.Exec(sqlStmt)
    if err != nil {
        log.Fatalf("执行初始化SQL失败: %v", err)
    }

    // 3. 执行查询
    rows, err := db.Query("SELECT id, name, age, balance, created_at, description FROM users")
    if err != nil {
        log.Fatalf("执行查询失败: %v", err)
    }
    defer rows.Close()

    // 4. 获取列的元数据
    columnTypes, err := rows.ColumnTypes()
    if err != nil {
        log.Fatalf("获取列类型失败: %v", err)
    }

    columnNames := make([]string, len(columnTypes))
    for i, ct := range columnTypes {
        columnNames[i] = ct.Name()
        fmt.Printf("列 %d: 名称=%s, 数据库类型=%s, Go扫描类型=%v, 可空=%v\n",
            i+1, ct.Name(), ct.DatabaseTypeName(), ct.ScanType(), ct.Nullable())
    }
    fmt.Println("--------------------------")

    // 5. 准备动态扫描的变量
    // scanArgs 用于 rows.Scan()，它需要指向变量的指针
    // values 用于存储实际的Go值，它也是指针，但之后我们会解引用
    values := make([]interface{}, len(columnTypes))
    scanArgs := make([]interface{}, len(columnTypes))

    for i, ct := range columnTypes {
        scanType := ct.ScanType()
        if scanType == nil {
            // 如果驱动没有提供ScanType，或者对于某些特殊类型，可以设置一个默认的Go类型，
            // 例如 []byte 来处理未知类型或二进制数据。
            log.Printf("警告: 列 '%s' 没有明确的 ScanType，使用 []byte 作为回退。", ct.Name())
            scanType = reflect.TypeOf([]byte{})
        }

        // 创建一个指向该Go类型的指针，并将其存储在 values 和 scanArgs 中
        values[i] = reflect.New(scanType).Interface()
        scanArgs[i] = values[i]
    }

    // 6. 遍历结果集并动态扫描
    allRowsData := make([][]ColumnData, 0)
    rowCounter := 0
    for rows.Next() {
        rowCounter++
        err = rows.Scan(scanArgs...) // 将数据扫描到动态创建的指针中
        if err != nil {
            log.Fatalf("扫描行数据失败: %v", err)
        }

        rowData := make([]ColumnData, len(columnNames))
        for i, colName := range columnNames {
            // 解引用指针以获取实际值
            val := reflect.ValueOf(values[i]).Elem().Interface()
            goType := reflect.TypeOf(val).String()

            // 处理 sql.Null* 类型，如果它们是可空的
            switch v := val.(type) {
            case sql.NullString:
                if v.Valid {
                    val = v.String
                } else {
                    val = nil
                }
                goType = "string" // 实际存储的Go类型
            case sql.NullInt64:
                if v.Valid {
                    val = v.Int64
                } else {
                    val = nil
                }
                goType = "int64"
            case sql.NullFloat64:
                if v.Valid {
                    val = v.Float64
                } else {
                    val = nil
                }
                goType = "float64"
            case sql.NullBool:
                if v.Valid {
                    val = v.Bool
                } else {
                    val = nil
                }
                goType = "bool"
            // 可以根据需要添加更多 sql.Null* 类型的处理
            }

            rowData[i] = ColumnData{
                Name:  colName,
                Value: val,
                Type:  goType,
            }
        }
        allRowsData = append(allRowsData, rowData)
    }

    if err = rows.Err(); err != nil {
        log.Fatalf("遍历行时发生错误: %v", err)
    }

    // 7. 打印或处理结果
    fmt.Println("\n--- 动态查询结果 ---")
    for i, row := range allRowsData {
        fmt.Printf("行 %d:\n", i+1)
        for _, col := range row {
            fmt.Printf("  { ColumnName: \"%s\", Value: %v, Type: %s }\n", col.Name, col.Value, col.Type)
        }
    }
}