golang mysql操作

golang數據類型和mysql數據類型的對應

 

 

 

 

Golang 提供了database/sql包用於對SQL數據庫的訪問, 作為操作數據庫的入口對象sql.DB, 主要為我們提供了兩個重要的功能:

• sql.DB 通過數據庫驅動為我們提供管理底層數據庫連接的打開和關閉操作.
• sql.DB 為我們管理數據庫連接池

需要注意的是，sql.DB表示操作數據庫的抽象訪問接口,而非一個數據庫連接對象;它可以根據driver打開關閉數據庫連接，管理連接池。正在使用的連接被標記為繁忙，用完后回到連接池等待下次使用。所以，如果你沒有把連接釋放回連接池，會導致過多連接使系統資源耗盡。

操作mysql

1.導入mysql數據庫驅動

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

 

 

通常來說, 不應該直接使用驅動所提供的方法, 而是應該使用 sql.DB, 因此在導入 mysql 驅動時, 這里使用了匿名導入的方式(在包路徑前添加 _), 當導入了一個數據庫驅動后, 此驅動會自行初始化並注冊自己到Golang的database/sql上下文中, 因此我們就可以通過 database/sql 包提供的方法訪問數據庫了.

2.連接數據庫

type DbWorker struct {
    //mysql data source name
    Dsn string 
}

func main() {
    dbw := DbWorker{
        Dsn: "user:password@tcp(127.0.0.1:3306)/test",
    }    
    db, err := sql.Open("mysql",
        dbw.Dsn)
    if err != nil {
        panic(err)
        return
    }
    defer db.Close()
}

 格式

 db, err := sql.Open("mysql", "user:password@tcp(localhost:5555)/dbname?charset=utf8")

 

通過調用sql.Open函數返回一個sql.DB指針; sql.Open函數原型如下:

func Open(driverName, dataSourceName string) (*DB, error)

 

• driverName: 使用的驅動名. 這個名字其實就是數據庫驅動注冊到 database/sql 時所使用的名字.
• dataSourceName: 數據庫連接信息，這個連接包含了數據庫的用戶名, 密碼, 數據庫主機以及需要連接的數據庫名等信息.

1. sql.Open並不會立即建立一個數據庫的網絡連接, 也不會對數據庫鏈接參數的合法性做檢驗, 它僅僅是初始化一個sql.DB對象. 當真正進行第一次數據庫查詢操作時, 此時才會真正建立網絡連接;
2. sql.DB表示操作數據庫的抽象接口的對象，但不是所謂的數據庫連接對象，sql.DB對象只有當需要使用時才會創建連接，如果想立即驗證連接，需要用Ping()方法;
3. sql.Open返回的sql.DB對象是協程並發安全的.
4. sql.DB的設計就是用來作為長連接使用的。不要頻繁Open, Close。比較好的做法是，為每個不同的datastore建一個DB對象，保持這些對象Open。如果需要短連接，那么把DB作為參數傳入function，而不要在function中Open, Close。

3.數據庫基本操作

數據庫查詢的一般步驟如下:

1. 調用 db.Query 執行 SQL 語句, 此方法會返回一個 Rows 作為查詢的結果
2. 通過 rows.Next() 迭代查詢數據.
3. 通過 rows.Scan() 讀取每一行的值
4. 調用 db.Close() 關閉查詢

現有user數據庫表如下:

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT '',
  `age` int(11) DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4

 

 

MySQL 5.5 之前， UTF8 編碼只支持1-3個字節,從MYSQL5.5開始，可支持4個字節UTF編碼utf8mb4，一個字符最多能有4字節，utf8mb4兼容utf8，所以能支持更多的字符集;關於emoji表情的話mysql的utf8是不支持，需要修改設置為utf8mb4，才能支持。

查詢數據

 

 

func (dbw *DbWorker) QueryData() {
    dbw.QueryDataPre()
    rows, err := dbw.Db.Query(`SELECT * From user where age >= 20 AND age < 30`)
    defer rows.Close()
    if err != nil {
        fmt.Printf("insert data error: %v\n", err)
        return
    }
    for rows.Next() {
        rows.Scan(&dbw.UserInfo.Id, &dbw.UserInfo.Name, &dbw.UserInfo.Age)
        if err != nil {
            fmt.Printf(err.Error())
            continue
        }
        if !dbw.UserInfo.Name.Valid {
            dbw.UserInfo.Name.String = ""
        }
        if !dbw.UserInfo.Age.Valid {
            dbw.UserInfo.Age.Int64 = 0
        }
        fmt.Println("get data, id: ", dbw.UserInfo.Id, " name: ", dbw.UserInfo.Name.String, " age: ", int(dbw.UserInfo.Age.Int64))
    }

    err = rows.Err()
    if err != nil {
        fmt.Printf(err.Error())
    }
}

 

1. rows.Scan 參數的順序很重要, 需要和查詢的結果的column對應. 例如 “SELECT * From user where age >=20 AND age < 30” 查詢的行的 column 順序是 “id, name, age” 和插入操作順序相同, 因此 rows.Scan 也需要按照此順序 rows.Scan(&id, &name, &age), 不然會造成數據讀取的錯位.
2. 因為golang是強類型語言，所以查詢數據時先定義數據類型，但是查詢數據庫中的數據存在三種可能:存在值，存在零值，未賦值NULL 三種狀態, 因為可以將待查詢的數據類型定義為sql.Nullxxx類型，可以通過判斷Valid值來判斷查詢到的值是否為賦值狀態還是未賦值NULL狀態.
3. 每次db.Query操作后, 都建議調用rows.Close(). 因為 db.Query() 會從數據庫連接池中獲取一個連接, 這個底層連接在結果集(rows)未關閉前會被標記為處於繁忙狀態。當遍歷讀到最后一條記錄時，會發生一個內部EOF錯誤，自動調用rows.Close(),但如果提前退出循環，rows不會關閉，連接不會回到連接池中，連接也不會關閉, 則此連接會一直被占用. 因此通常我們使用 defer rows.Close() 來確保數據庫連接可以正確放回到連接池中; 不過閱讀源碼發現rows.Close()操作是冪等操作，即一個冪等操作的特點是其任意多次執行所產生的影響均與一次執行的影響相同, 所以即便對已關閉的rows再執行close()也沒關系.

單行查詢

var name string
err = db.QueryRow("select name from user where id = ?", 1).Scan(&name)
if err != nil {
    log.Fatal(err)
}
fmt.Println(name)

 

 

1. err在Scan后才產生，上述鏈式寫法是對的
2. 需要注意Scan()中變量和順序要和前面Query語句中的順序一致，否則查出的數據會映射不一致.

插入數據

func (dbw *DbWorker) insertData() {
    ret, err := dbw.Db.Exec(`INSERT INTO user (name, age) VALUES ("xys", 23)`)
    if err != nil {
        fmt.Printf("insert data error: %v\n", err)
        return
    }
    if LastInsertId, err := ret.LastInsertId(); nil == err {
        fmt.Println("LastInsertId:", LastInsertId)
    }
    if RowsAffected, err := ret.RowsAffected(); nil == err {
        fmt.Println("RowsAffected:", RowsAffected)
    }
}

 

 

通過db.Exec()插入數據，通過返回的err可知插入失敗的原因，通過返回的ret可以進一步查詢本次插入數據影響的行數RowsAffected和最后插入的Id(如果數據庫支持查詢最后插入Id).

github完整代碼示例

4.預編譯語句(Prepared Statement)
預編譯語句(PreparedStatement)提供了諸多好處, 因此我們在開發中盡量使用它. 下面列出了使用預編譯語句所提供的功能:

• PreparedStatement 可以實現自定義參數的查詢
• PreparedStatement 通常來說, 比手動拼接字符串 SQL 語句高效.
• PreparedStatement 可以防止SQL注入攻擊

一般用Prepared Statements和Exec()完成INSERT, UPDATE, DELETE操作。

下面是將上述案例用Prepared Statement 修改之后的完整代碼

package main

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

type DbWorker struct {
    Dsn      string
    Db       *sql.DB
    UserInfo userTB
}
type userTB struct {
    Id   int
    Name sql.NullString
    Age  sql.NullInt64
}

func main() {
    var err error
    dbw := DbWorker{
        Dsn: "root:123456@tcp(localhost:3306)/sqlx_db?charset=utf8mb4",
    }
    dbw.Db, err = sql.Open("mysql", dbw.Dsn)
    if err != nil {
        panic(err)
        return
    }
    defer dbw.Db.Close()

    dbw.insertData()
    dbw.queryData()
}

func (dbw *DbWorker) insertData() {
    stmt, _ := dbw.Db.Prepare(`INSERT INTO user (name, age) VALUES (?, ?)`)
    defer stmt.Close()

 ret, err := stmt.Exec("xys", 23)
    if err != nil {
        fmt.Printf("insert data error: %v\n", err)
        return
    }
    if LastInsertId, err := ret.LastInsertId(); nil == err {
        fmt.Println("LastInsertId:", LastInsertId)
    }
    if RowsAffected, err := ret.RowsAffected(); nil == err {
        fmt.Println("RowsAffected:", RowsAffected)
    }
}

func (dbw *DbWorker) QueryDataPre() {
    dbw.UserInfo = userTB{}
}
func (dbw *DbWorker) queryData() {
    stmt, _ := dbw.Db.Prepare(`SELECT * From user where age >= ? AND age < ?`)
    defer stmt.Close()

    dbw.QueryDataPre()

    rows, err := stmt.Query(20, 30)
    defer rows.Close()
    if err != nil {
        fmt.Printf("insert data error: %v\n", err)
        return
    }
    for rows.Next() {
        rows.Scan(&dbw.UserInfo.Id, &dbw.UserInfo.Name, &dbw.UserInfo.Age)
        if err != nil {
            fmt.Printf(err.Error())
            continue
        }
        if !dbw.UserInfo.Name.Valid {
            dbw.UserInfo.Name.String = ""
        }
        if !dbw.UserInfo.Age.Valid {
            dbw.UserInfo.Age.Int64 = 0
        }
        fmt.Println("get data, id: ", dbw.UserInfo.Id, " name: ", dbw.UserInfo.Name.String, " age: ", int(dbw.UserInfo.Age.Int64))
    }

    err = rows.Err()
    if err != nil {
        fmt.Printf(err.Error())
    }
}

db.Prepare()返回的statement使用完之后需要手動關閉，即defer stmt.Close()

 

 mysql.go 

package dbs

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

var MysqlDb *sql.DB
var MysqlDbErr error

const (
    USER_NAME = "root"
    PASS_WORD = "root"
    HOST      = "localhost"
    PORT      = "3306"
    DATABASE  = "demo"
    CHARSET   = "utf8"
)

// 初始化鏈接
func init() {

    dbDSN := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s", USER_NAME, PASS_WORD, HOST, PORT, DATABASE, CHARSET)

    // 打開連接失敗
    MysqlDb, MysqlDbErr = sql.Open("mysql", dbDSN)
    //defer MysqlDb.Close();
    if MysqlDbErr != nil {
        log.Println("dbDSN: " + dbDSN)
        panic("數據源配置不正確: " + MysqlDbErr.Error())
    }

    // 最大連接數
    MysqlDb.SetMaxOpenConns(100)
    // 閑置連接數
    MysqlDb.SetMaxIdleConns(20)
    // 最大連接周期
    MysqlDb.SetConnMaxLifetime(100*time.Second)

    if MysqlDbErr = MysqlDb.Ping(); nil != MysqlDbErr {
        panic("數據庫鏈接失敗: " + MysqlDbErr.Error())
    }

}

增刪改查

package dbs

import (
    "fmt"
)

// 用戶表結構體
type User struct {
    Id int64 `db:"id"`
    Name string  `db:"name"`
    Age int `db:"age"`
}

// 查詢數據，指定字段名
func StructQueryField() {

    user := new(User)
    row := MysqlDb.QueryRow("select id, name, age from users where id=?",1)
    if err :=row.Scan(&user.Id,&user.Name,&user.Age); err != nil{
        fmt.Printf("scan failed, err:%v",err)
        return
    }
    fmt.Println(user.Id,user.Name,user.Age)
}

// 查詢數據，取所有字段
func StructQueryAllField() {

    // 通過切片存儲
    users := make([]User, 0)
    rows, _:= MysqlDb.Query("SELECT * FROM `users` limit ?",100)
    // 遍歷
    var user User
    for  rows.Next(){
        rows.Scan(&user.Id, &user.Name, &user.Age)
        users=append(users,user)
    }

    fmt.Println(users)

}

// 插入數據
func StructInsert() {

    ret,_ := MysqlDb.Exec("insert INTO users(name,age) values(?,?)","小紅",23)

    //插入數據的主鍵id
    lastInsertID,_ := ret.LastInsertId()
    fmt.Println("LastInsertID:",lastInsertID)

    //影響行數
    rowsaffected,_ := ret.RowsAffected()
    fmt.Println("RowsAffected:",rowsaffected)

}

// 更新數據
func StructUpdate() {

    ret,_ := MysqlDb.Exec("UPDATE users set age=? where id=?","100",1)
    upd_nums,_ := ret.RowsAffected()

    fmt.Println("RowsAffected:",upd_nums)
}

// 刪除數據
func StructDel() {

    ret,_ := MysqlDb.Exec("delete from users where id=?",1)
    del_nums,_ := ret.RowsAffected()

    fmt.Println("RowsAffected:",del_nums)
}


// 事務處理,結合預處理
func StructTx() {

    //事務處理
    tx, _ := MysqlDb.Begin();


    // 新增
    userAddPre, _ := MysqlDb.Prepare("insert into users(name, age) values(?, ?)");
    addRet, _ := userAddPre.Exec("zhaoliu", 15);
    ins_nums, _ := addRet.RowsAffected();


    // 更新
    userUpdatePre1, _ := tx.Exec("update users set name = 'zhansan'  where name=?", "張三");
    upd_nums1, _ := userUpdatePre1.RowsAffected();
    userUpdatePre2, _ := tx.Exec("update users set name = 'lisi'  where name=?", "李四");
    upd_nums2, _ := userUpdatePre2.RowsAffected();

    fmt.Println(ins_nums);
    fmt.Println(upd_nums1);
    fmt.Println(upd_nums2);

    if ins_nums > 0 && upd_nums1 > 0 && upd_nums2 > 0 {
        tx.Commit();
    }else{
        tx.Rollback();
    }

}

// 查詢數據，指定字段名,不采用結構體
func RawQueryField() {

    rows, _ := MysqlDb.Query("select id,name from users");
    if rows == nil {
        return
    }
    id := 0;
    name := "";
    fmt.Println(rows)
    fmt.Println(rows)
    for rows.Next() {
        rows.Scan(&id, &name);
        fmt.Println(id, name);
    }
}

// 查詢數據,取所有字段,不采用結構體
func RawQueryAllField() {

    //查詢數據，取所有字段
    rows2, _ := MysqlDb.Query("select * from users");

    //返回所有列
    cols, _ := rows2.Columns();

    //這里表示一行所有列的值，用[]byte表示
    vals := make([][]byte, len(cols));

    //這里表示一行填充數據
    scans := make([]interface{}, len(cols));
    //這里scans引用vals，把數據填充到[]byte里
    for k, _ := range vals {
        scans[k] = &vals[k];
    }

    i := 0;
    result := make(map[int]map[string]string);
    for rows2.Next() {
        //填充數據
        rows2.Scan(scans...);
        //每行數據
        row := make(map[string]string);
        //把vals中的數據復制到row中
        for k, v := range vals {
            key := cols[k];
            //這里把[]byte數據轉成string
            row[key] = string(v);
        }
        //放入結果集
        result[i] = row;
        i++;
    }
    fmt.Println(result);
}

入口調用測試

package main
import "go_mysql/dbs"

func main() {

    dbs.StructInsert()
    dbs.StructUpdate()
    dbs.StructQueryField()
    dbs.StructQueryAllField()
    dbs.StructDel()
    dbs.StructTx()
    dbs.RawQueryField()
    dbs.RawQueryAllField()
}

結構

├── dbs
│   ├── mysql.go 連接mysql
│   └── user.go  user表操作
├── go.mod
├── go.sum
├── main.go 入口文件
├── Makefile
└── vendor

 

 

查詢

    var name string
    var age int
    rows, err := db.Query("select name,age from user where id = ? ", 1)
    if err != nil {
        fmt.Println(err)
    }
    defer rows.Close()

    for rows.Next() {
        err := rows.Scan(&name, &age)
        if err != nil {
            fmt.Println(err)
        }
    }

    err = rows.Err()
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println("name:", url, "age:", description)

增刪改

stmt, err := db.Prepare("insert into user(name,age)values(?,?)")
if err != nil {
    log.Println(err)
}

rs, err := stmt.Exec("go-test", 12)
if err != nil {
    log.Println(err)
}
//我們可以獲得插入的id
id, err := rs.LastInsertId()
//可以獲得影響行數
affect, err := rs.RowsAffected()

 

 

 

 https://blog.csdn.net/qq_16763983/article/details/105332916

 

https://zhuanlan.zhihu.com/p/305152125