查询任意表

package main

import (
    "database/sql"
    "fmt"
    "gitee.com/ha666/gen_models/utils"
    "gitee.com/ha666/golibs"
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "log"
    "os"
)

var (
    adb *sqlx.DB
    err error
)

func main() {
    initADB()
    columns, err := GetColumnInfos("adb", "t_node")
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    if len(columns) <= 0 {
        fmt.Println("没有找到列信息")
        return
    }
    fmt.Println(len(columns))
    for i, v := range columns {
        fmt.Printf("%d\t%s\t\t\t%s\n", i, v.ColumnName, v.DataType)
    }
    collections, err := Get(1003)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Println(len(collections))
    for _, v := range collections {
        fmt.Printf("%T\t%v\n", v.Item1, v.Item1)
        fmt.Printf("%T\t%v\n", v.Item2, v.Item2)
        fmt.Printf("%T\t%v\n", v.Item3, v.Item3)
        fmt.Printf("%T\t%v\n", v.Item4, v.Item4)
        fmt.Printf("%T\t%v\n", v.Item5, v.Item5)
        fmt.Printf("%T\t%v\n", v.Item6, v.Item6)
        fmt.Printf("%T\t%v\n", v.Item7, v.Item7)
        fmt.Printf("%T\t%v\n", v.Item8, v.Item8)
        fmt.Printf("%T\t%v\n", v.Item9, v.Item9)
        fmt.Printf("%T\t%v\n", v.Item10, v.Item10)
    }
}

func Get(id int) (collections []Collection, err error) {
    rows, err := adb.Queryx("select id,groupId,name,server_address,created_at,updated_at,deleted_at from t_node where id=?", id)
    defer rows.Close()
    if err != nil {
        return collections, err
    }
    collections, err = _RowsToArray(rows)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Println(len(collections))
    for i, v := range collections {
        {
            v.Item3 = string(v.Item3.([]uint8))
            v.Item3 = golibs.SubString(v.Item3.(string), 0, 3)
            collections[i].Item3 = v.Item3
        }
        {
            v.Item4 = string(v.Item4.([]uint8))
            v.Item4 = golibs.SubString(v.Item4.(string), 0, 15)
            collections[i].Item4 = v.Item4
        }
    }
    return collections, nil
}

type Collection struct {
    Item1  interface{}
    Item2  interface{}
    Item3  interface{}
    Item4  interface{}
    Item5  interface{}
    Item6  interface{}
    Item7  interface{}
    Item8  interface{}
    Item9  interface{}
    Item10 interface{}
    Item11 interface{}
    Item12 interface{}
    Item13 interface{}
    Item14 interface{}
    Item15 interface{}
    Item16 interface{}
    Item17 interface{}
    Item18 interface{}
    Item19 interface{}
}

var tableColumnCount = 7

func _RowsToArray(rows *sqlx.Rows) (collections []Collection, err error) {
    for rows.Next() {
        a := Collection{}
        switch tableColumnCount {
        case 1:
            err = rows.Scan(&a.Item1)
        case 2:
            err = rows.Scan(&a.Item1, &a.Item2)
        case 3:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3)
        case 4:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4)
        case 5:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4, &a.Item5)
        case 6:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4, &a.Item5, &a.Item6)
        case 7:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4, &a.Item5, &a.Item6, &a.Item7)
        case 8:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4, &a.Item5, &a.Item6, &a.Item7, &a.Item8)
        case 9:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4, &a.Item5, &a.Item6, &a.Item7, &a.Item8, &a.Item9)
        case 10:
            err = rows.Scan(&a.Item1, &a.Item2, &a.Item3, &a.Item4, &a.Item5, &a.Item6, &a.Item7, &a.Item8, &a.Item9, &a.Item10)
        }
        if err != nil {
            return collections, err
        }
        collections = append(collections, a)
    }
    return collections, err
}

func initADB() {
    adb, err = sqlx.Open("mysql", "root:1234567890@tcp(127.0.0.1:3306)/adb?charset=utf8&parseTime=true&loc=Local")
    if err != nil {
        log.Fatalf("【initADB.NewEngine】ex:%s\n", err.Error())
        os.Exit(0)
        return
    }
    err = adb.Ping()
    if err != nil {
        log.Fatalf("【initADB.Ping】ex:%s\n", err.Error())
        os.Exit(0)
        return
    }
    adb.SetMaxIdleConns(2)
    adb.SetMaxOpenConns(10)
}

type ColumnInfo struct {
    ColumnName      string
    ColumnNameCase  string
    OrdinalPosition int
    IsNullAble      string
    DataType        string
    ColumnType      string
    ColumnKey       string
    Extra           string
    ColumnComment   string
}

func GetColumnInfos(database_name, table_name string) (column_infos []ColumnInfo, err error) {
    rows, err := adb.Query("SELECT COLUMN_NAME,ORDINAL_POSITION,IS_NULLABLE,DATA_TYPE,COLUMN_TYPE,COLUMN_KEY,EXTRA,COLUMN_COMMENT FROM information_schema.`COLUMNS` WHERE TABLE_SCHEMA=? AND TABLE_NAME=?;", database_name, table_name)
    defer rows.Close()
    if err != nil {
        return column_infos, err
    }
    return _ColumnInfoRowsToArray(rows)
}

func _ColumnInfoRowsToArray(rows *sql.Rows) (models []ColumnInfo, err error) {
    for rows.Next() {
        model := ColumnInfo{}
        err = rows.Scan(&model.ColumnName, &model.OrdinalPosition, &model.IsNullAble, &model.DataType, &model.ColumnType, &model.ColumnKey, &model.Extra, &model.ColumnComment)
        if err != nil {
            return models, err
        }
        model.ColumnNameCase = model.ColumnName
        utils.ToBigHump(&model.ColumnNameCase)
        models = append(models, model)
    }
    return models, err
}