Go語言之操作數據庫CRUD

package main

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

// 定義一個全局對象db
var db *sql.DB
//定義結構體
type User struct {
    Id   int
    Name string
    Age  int
}

//初始化數據庫
func InitDB() (err error) {
    //連接數據庫
    dsn := "root:root@tcp(127.0.0.1:3306)/db3"
    db, err = sql.Open("mysql", dsn)
    //錯誤處理
    if err != nil {
        return err
    }
    //檢驗dsn是否正確
    err = db.Ping()
    if err != nil {
        return err
    }
    return nil
}

//數據庫單行查詢
func queryRowDemo() {
    //創建User對象
    var u User
    //sql語句
    sqlStr := "select * from user where id=?"
    //調用QueryRow方法返回查詢的一行，后邊調用的scan方法是將查詢出來的行放入指定的參數中
    err := db.QueryRow(sqlStr, 1).Scan(&u.Id, &u.Name, &u.Age)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(u.Id, u.Name, u.Age)
}

//查詢多行
/*
查詢多行和查詢單行的不同之處是調用方法query並返回多行
然后通過for循環調用scan方法吧每一行循環遍歷出來
*/
func queryDemo() {
    //sql語句
    sqlStr := "select * from user"
    //調用方法
    rows, err := db.Query(sqlStr)
    //錯誤處理
    if err != nil {
        fmt.Println(err)
    }
    //關閉rows釋放持有的數據庫鏈接
    defer rows.Close()
    //使用for循環進行結果的讀取
    for rows.Next() {
        var u User
        err := rows.Scan(&u.Id, &u.Name, &u.Age)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Printf("id:%d name:%s age:%d\n", u.Id, u.Name, u.Age)
    }
}

//插入數據
func InsertDemo() {
    //sql語句
    sqlStr := "insert into user(name,age) value(?,?)"
    //Exec執行一次命令（包括查詢、刪除、更新、插入等），返回的Result是對已執行的SQL命令的總結。參數args表示query中的占位參數
    ret, err := db.Exec(sqlStr, "趙六", 30)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(ret)
    // 新插入數據的id是theID
    theID, err := ret.LastInsertId()
    if err != nil {
        fmt.Printf("get lastinsert ID failed, err:%v\n", err)
        return
    }
    fmt.Printf("insert success, the id is %d.\n", theID)
}

//更新數據
func UpdateDemo() {
    sqlStr := "update user set age=? where id =?"
    ret, err := db.Exec(sqlStr, 39, 3)
    if err != nil {
        fmt.Printf("update failed, err:%v\n", err)
        return
    }
    n, err := ret.RowsAffected() // 操作影響的行數
    if err != nil {
        fmt.Printf("get RowsAffected failed, err:%v\n", err)
        return
    }
    fmt.Printf("update success, affected rows:%d\n", n)
}

//刪除數據
func DeleteDemo() {
    sqlStr := "delete from user where id=?"
    ret, err := db.Exec(sqlStr, 4)
    if err != nil {
        fmt.Println(err)
        return
    }
    n, err := ret.RowsAffected()
    if err != nil {
        fmt.Printf("get RowsAffected failed, err:%v\n", err)
        return
    }
    fmt.Printf("delete success, affected rows:%d\n", n)

}
func main() {
    //調用初始化函數
    err := InitDB()
    if err != nil {
        fmt.Println(err)
    }
    //調用函數
    //queryRowDemo()
    //queryDemo()
    //InsertDemo()
    //UpdateDemo()
    //DeleteDemo()
}

 sql預處理：

優化MySQL服務器重復執行SQL的方法，可以提升服務器性能，提前讓服務器編譯，一次編譯多次執行，節省后續編譯的成本。

避免SQL注入問題。

查詢的sql預處理代碼：

//預處理
func prepareSql() {
    var u User
    sqlStr := "select * from user"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer stmt.Close()
    rows, err := stmt.Query()
    if err != nil {
        fmt.Println(err)
        return
    }
    defer rows.Close()
    for rows.Next() {
        err := rows.Scan(&u.Id, &u.Name, &u.Age)
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Println(u.Id, u.Name, u.Age)
    }
}

事務：

　　比如，我們去銀行轉賬，操作可以分為下面兩個環節：(1)從第一個賬戶划出款項。  (2)將款項存入第二個賬戶。  

　　在這個過程中，兩個環節是關聯的。第一個賬戶划出款項必須保證正確的存入第二個賬戶，如果第二個環節沒有完成，整個的過程都應該取消，否則就會發生丟失款項的問題。整個交易過程，可以看作是一個事物，成功則全部成功，失敗則需要全部撤消，這樣可以避免當操作的中間環節出現問題時，產生數據不一致的問題。

事務的特性：

原子性	一個事務（transaction）中的所有操作，要么全部完成，要么全部不完成，不會結束在中間某個環節。事務在執行過程中發生錯誤，會被回滾（Rollback）到事務開始前的狀態，就像這個事務從來沒有執行過一樣。
一致性	在事務開始之前和事務結束以后，數據庫的完整性沒有被破壞。這表示寫入的資料必須完全符合所有的預設規則，這包含資料的精確度、串聯性以及后續數據庫可以自發性地完成預定的工作。
隔離性	數據庫允許多個並發事務同時對其數據進行讀寫和修改的能力，隔離性可以防止多個事務並發執行時由於交叉執行而導致數據的不一致。事務隔離分為不同級別，包括讀未提交（Read uncommitted）、讀提交（read committed）、可重復讀（repeatable read）和串行化（Serializable）。
持久性	事務處理結束后，對數據的修改就是永久的，即便系統故障也不會丟失。

舉例：

func transactionDemo() {
    //事務分為 開始事務 提交事務和回滾事務
    //開始事務 當開始一個事務后需要用事務進行操作
    tx, err := db.Begin()
    //出錯了 如果有錯誤就需要進行事務的回滾
    if err != nil {
        if tx != nil {
            tx.Rollback()
        }
        return
    }

    sqlStr := "update user set age=100 where id=?"
    _, err = tx.Exec(sqlStr, 1)
    if err != nil {
        fmt.Println(err)
        tx.Rollback()
        return
    }

    sqlStr1 := "update user set age=101 where id=?"
    _, err = tx.Exec(sqlStr1, 2)
    if err != nil {
        fmt.Println(err)
        tx.Rollback()
        return
    }
    //事務提交
    err=tx.Commit()
    if err!=nil{
        tx.Rollback()
        return
    }

}