golang mysql

package common

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "myapp/helpers"
    "time"
)
//NewMysqlConn 创建新的mysql连接池
func NewMysqlConn(source string) *sql.DB {
    //sql.Open函数实际上是返回一个连接池对象，不是单个连接。
    //在open的时候并没有去连接数据库，只有在执行query、exce方法的时候才会去实际连接数据库。
    //在一个应用中同样的库连接只需要保存一个sql.Open之后的db对象就可以了，不需要多次open。
    db, err := sql.Open("mysql", source)
    if err != nil {
        panic(err)
    }
    db.SetMaxOpenConns(2000)             //最大连接
    db.SetMaxIdleConns(1000)             //空闲连接，也就是连接池里的数量
    db.SetConnMaxLifetime(7 * time.Hour) //设置生命周期为7小时
    return db
}

//获取返回值，获取一条
func GetResultRowOne(rows *sql.Rows) map[string]string {
    columns, _ := rows.Columns()
    scanArgs := make([]interface{}, len(columns)) // 创建一个查询字段类型的slice的键值对
    values := make([][]byte, len(columns))        // 创建一个任意字段类型的slice的键值对
    for j := range values {
        scanArgs[j] = &values[j] // 把values每个参数的地址存入scanArgs
    }
    record := make(map[string]string)
    for rows.Next() {
        //将行数据保存到record字典
        rows.Scan(scanArgs...)
        for i, v := range values {
            if v != nil {
                //fmt.Println(reflect.TypeOf(col))
                record[columns[i]] = string(v)
            }
        }
    }
    return record
}

//获取所有
func GetResultRows(rows *sql.Rows) []map[string]string {
    //返回所有列
    columns, _ := rows.Columns()
    //这里表示一行所有列的值，用[]byte表示
    vals := make([][]byte, len(columns))
    //这里表示一行填充数据
    scans := make([]interface{}, len(columns))
    //这里scans引用vals，把数据填充到[]byte里
    for k := range vals {
        scans[k] = &vals[k]
    }
    var result []map[string]string
    for rows.Next() {
        //填充数据
        rows.Scan(scans...)
        //每行数据
        row := make(map[string]string)
        //把vals中的数据复制到row中
        for k, v := range vals {
            key := columns[k]
            //这里把[]byte数据转成string
            row[key] = string(v)
        }//放入结果集
        result = append(result, row)
        
    }
    rows.Close()
    return result
}

简易使用

package main

import (
    "fmt"
    "myapp/common"
)

var m *common.MyMysql
var TestSource = "root:root@tcp(127.0.0.1:3306)/test?charset=utf8"

func main() {
    m = &common.MyMysql{
        MysqlSource: TestSource,
    }
    m.Conn()
    defer m.MysqlConn.Close()
    tInsert()
    uInfoById()
    uInfos()
    tUpdate()
    tDelete()
}

func tInsert() {
    stmt,err := m.MysqlConn.Prepare("insert zq_user set uid = ? , name = ?")
    if err != nil {
        fmt.Println(err)
    }
    res,err := stmt.Exec("u3","test2")
    if err != nil {
        fmt.Println(err)
    }
    id,_ := res.LastInsertId()
    fmt.Println("get id :" ,id)
}

func uInfoById ()  {
    row,_ := m.MysqlConn.Query("select * from zq_user where uid = ?","u1111")
    res := m.GetResultRowOne(row)
    fmt.Println(res)
    fmt.Println(res["id"],res["uid"],res["name"])
}

func uInfos() {
    rows,_ := m.MysqlConn.Query("select  * from zq_user")
    res := m.GetResultRows(rows)
    fmt.Println(res)
}

func tUpdate()  {
    stmt,_ := m.MysqlConn.Prepare("update zq_user set name = ? where uid = ?")
    res,_ := stmt.Exec("name2","u111")
    rows,_ := res.RowsAffected()
    fmt.Println("rows affected :",rows)
}

func tDelete()  {
    stmt,_ := m.MysqlConn.Prepare("delete from zq_user where uid = ? ")
    stmt.Exec("u3")
}