2. 程式人生 > >使用go語言操作mysql資料庫

使用go語言操作mysql資料庫

阿新 • • 發佈：2018-11-25

1.下載並匯入資料庫驅動包

官方不提供實現，先下載第三方的實現，點選這裡檢視各種各樣的實現版本。
這裡選擇了Go-MySQL-Driver這個實現。地址是：https://github.com/go-sql-driver/mysql/。

然後按照裡面的說明下載驅動包：

$ go get github.com/go-sql-driver/mysql

最後匯入包即可：

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

2.連線至資料庫

db, err := sql.Open("mysql", "root:[email protected]
 
/uestcbook")

3.執行查詢

（1）Exec 

result, err := db.Exec(
    "INSERT INTO users (name, age) VALUES (?, ?)",
    "gopher",
    27,
)

 

（2）Query 

複製程式碼

rows, err := db.Query("SELECT name FROM users WHERE age = ?", age)
if err != nil {
    log.Fatal(err)
}
for rows.Next() {
    var name string
    if err := rows.Scan(&name); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s is %d\n", name, age)
}
if err := rows.Err(); err != nil {
    log.Fatal(err)
}

複製程式碼

 

（3）QueryRow

var age int64
row := db.QueryRow("SELECT age FROM users WHERE name = ?", name)
err := row.Scan(&age)

 

 

（4）Prepared statements 

複製程式碼

age := 27
stmt, err := db.Prepare("SELECT name FROM users WHERE age = ?")
if err != nil {
    log.Fatal(err)
}
rows, err := stmt.Query(age)
// process rows

複製程式碼

 

 

4. 事務

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

 

 

5. 各種方式效率分析

問題：db.exec和statement.exec和tx.exec的區別？

例項如下：

複製程式碼

package main

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

var db = &sql.DB{}

func init(){
    db,_ = sql.Open("mysql", "root:[email protected]/book")
} 

func main() {
    insert()
    query()
    update()
    query()
    delete()
}

func update(){
    //方式1 update
    start := time.Now()
    for i := 1001;i<=1100;i++{
        db.Exec("UPdate user set age=? where uid=? ",i,i)
    }
    end := time.Now()
    fmt.Println("方式1 update total time:",end.Sub(start).Seconds())
    
    //方式2 update
    start = time.Now()
    for i := 1101;i<=1200;i++{
        stm,_ := db.Prepare("UPdate user set age=? where uid=? ")
        stm.Exec(i,i)
        stm.Close()
    }
    end = time.Now()
    fmt.Println("方式2 update total time:",end.Sub(start).Seconds())
    
    //方式3 update
    start = time.Now()
    stm,_ := db.Prepare("UPdate user set age=? where uid=?")
    for i := 1201;i<=1300;i++{
        stm.Exec(i,i)
    }
    stm.Close()
    end = time.Now()
    fmt.Println("方式3 update total time:",end.Sub(start).Seconds())
    
    //方式4 update
    start = time.Now()
    tx,_ := db.Begin()
    for i := 1301;i<=1400;i++{
        tx.Exec("UPdate user set age=? where uid=?",i,i)
    }
    tx.Commit()
    
    end = time.Now()
    fmt.Println("方式4 update total time:",end.Sub(start).Seconds())
    
    //方式5 update
    start = time.Now()
    for i := 1401;i<=1500;i++{
        tx,_ := db.Begin()
        tx.Exec("UPdate user set age=? where uid=?",i,i)
        tx.Commit()
    }
    end = time.Now()
    fmt.Println("方式5 update total time:",end.Sub(start).Seconds())
    
}

func delete(){
    //方式1 delete
    start := time.Now()
    for i := 1001;i<=1100;i++{
        db.Exec("DELETE FROM USER WHERE uid=?",i)
    }
    end := time.Now()
    fmt.Println("方式1 delete total time:",end.Sub(start).Seconds())
    
    //方式2 delete
    start = time.Now()
    for i := 1101;i<=1200;i++{
        stm,_ := db.Prepare("DELETE FROM USER WHERE uid=?")
        stm.Exec(i)
        stm.Close()
    }
    end = time.Now()
    fmt.Println("方式2 delete total time:",end.Sub(start).Seconds())
    
    //方式3 delete
    start = time.Now()
    stm,_ := db.Prepare("DELETE FROM USER WHERE uid=?")
    for i := 1201;i<=1300;i++{
        stm.Exec(i)
    }
    stm.Close()
    end = time.Now()
    fmt.Println("方式3 delete total time:",end.Sub(start).Seconds())
    
    //方式4 delete
    start = time.Now()
    tx,_ := db.Begin()
    for i := 1301;i<=1400;i++{
        tx.Exec("DELETE FROM USER WHERE uid=?",i)
    }
    tx.Commit()
    
    end = time.Now()
    fmt.Println("方式4 delete total time:",end.Sub(start).Seconds())
    
    //方式5 delete
    start = time.Now()
    for i := 1401;i<=1500;i++{
        tx,_ := db.Begin()
        tx.Exec("DELETE FROM USER WHERE uid=?",i)
        tx.Commit()
    }
    end = time.Now()
    fmt.Println("方式5 delete total time:",end.Sub(start).Seconds())
    
}

func query(){
    
    //方式1 query
    start := time.Now()
    rows,_ := db.Query("SELECT uid,username FROM USER")
    defer rows.Close()
    for rows.Next(){
         var name string
         var id int
        if err := rows.Scan(&id,&name); err != nil {
            log.Fatal(err)
        }
        //fmt.Printf("name:%s ,id:is %d\n", name, id)
    }
    end := time.Now()
    fmt.Println("方式1 query total time:",end.Sub(start).Seconds())
    
    //方式2 query
    start = time.Now()
    stm,_ := db.Prepare("SELECT uid,username FROM USER")
    defer stm.Close()
    rows,_ = stm.Query()
    defer rows.Close()
    for rows.Next(){
         var name string
         var id int
        if err := rows.Scan(&id,&name); err != nil {
            log.Fatal(err)
        }
       // fmt.Printf("name:%s ,id:is %d\n", name, id)
    }
    end = time.Now()
    fmt.Println("方式2 query total time:",end.Sub(start).Seconds())
    
    
    //方式3 query
    start = time.Now()
    tx,_ := db.Begin()
    defer tx.Commit()
    rows,_ = tx.Query("SELECT uid,username FROM USER")
    defer rows.Close()
    for rows.Next(){
         var name string
         var id int
        if err := rows.Scan(&id,&name); err != nil {
            log.Fatal(err)
        }
        //fmt.Printf("name:%s ,id:is %d\n", name, id)
    }
    end = time.Now()
    fmt.Println("方式3 query total time:",end.Sub(start).Seconds())
}

func insert() {
    
    //方式1 insert
    //strconv,int轉string:strconv.Itoa(i)
    start := time.Now()
    for i := 1001;i<=1100;i++{
        //每次迴圈內部都會去連線池獲取一個新的連線，效率低下
        db.Exec("INSERT INTO user(uid,username,age) values(?,?,?)",i,"user"+strconv.Itoa(i),i-1000)
    }
    end := time.Now()
    fmt.Println("方式1 insert total time:",end.Sub(start).Seconds())
    
    //方式2 insert
    start = time.Now()
    for i := 1101;i<=1200;i++{
        //Prepare函式每次迴圈內部都會去連線池獲取一個新的連線，效率低下
        stm,_ := db.Prepare("INSERT INTO user(uid,username,age) values(?,?,?)")
        stm.Exec(i,"user"+strconv.Itoa(i),i-1000)
        stm.Close()
    }
    end = time.Now()
    fmt.Println("方式2 insert total time:",end.Sub(start).Seconds())
    
    //方式3 insert
    start = time.Now()
    stm,_ := db.Prepare("INSERT INTO user(uid,username,age) values(?,?,?)")
    for i := 1201;i<=1300;i++{
        //Exec內部並沒有去獲取連線，為什麼效率還是低呢？
        stm.Exec(i,"user"+strconv.Itoa(i),i-1000)
    }
    stm.Close()
    end = time.Now()
    fmt.Println("方式3 insert total time:",end.Sub(start).Seconds())
    
    //方式4 insert
    start = time.Now()
    //Begin函式內部會去獲取連線
    tx,_ := db.Begin()
    for i := 1301;i<=1400;i++{
        //每次迴圈用的都是tx內部的連線，沒有新建連線，效率高
        tx.Exec("INSERT INTO user(uid,username,age) values(?,?,?)",i,"user"+strconv.Itoa(i),i-1000)
    }
    //最後釋放tx內部的連線
    tx.Commit()
    
    end = time.Now()
    fmt.Println("方式4 insert total time:",end.Sub(start).Seconds())
    
    //方式5 insert
    start = time.Now()
    for i := 1401;i<=1500;i++{
        //Begin函式每次迴圈內部都會去連線池獲取一個新的連線，效率低下
        tx,_ := db.Begin()
        tx.Exec("INSERT INTO user(uid,username,age) values(?,?,?)",i,"user"+strconv.Itoa(i),i-1000)
        //Commit執行後連線也釋放了
        tx.Commit()
    }
    end = time.Now()
    fmt.Println("方式5 insert total time:",end.Sub(start).Seconds())
}

複製程式碼

程式輸出結果：

方式1 insert total time: 3.7952171
方式2 insert total time: 4.3162468
方式3 insert total time: 4.3392482
方式4 insert total time: 0.3970227
方式5 insert total time: 7.3894226
方式1 query total time: 0.0070004
方式2 query total time: 0.0100006
方式3 query total time: 0.0100006
方式1 update total time: 7.3394198
方式2 update total time: 7.8464488
方式3 update total time: 6.0053435
方式4 update total time: 0.6630379000000001
方式5 update total time: 4.5402597
方式1 query total time: 0.0070004
方式2 query total time: 0.0060004
方式3 query total time: 0.008000400000000001
方式1 delete total time: 3.8652211000000003
方式2 delete total time: 3.8582207
方式3 delete total time: 3.6972114
方式4 delete total time: 0.43202470000000004
方式5 delete total time: 3.7972172

 

6. 深入內部分析原因分析

（1）sql.Open("mysql", "username:[email protected]/databasename")

功能：返回一個DB物件，DB物件對於多個goroutines併發使用是安全的，DB物件內部封裝了連線池。

實現：open函式並沒有建立連線，它只是驗證引數是否合法。然後開啟一個單獨goroutines去監聽是否需要建立新的連線，當有請求建立新連線時就建立新連線。

注意：open函式應該被呼叫一次，通常是沒必要close的。

 

（2）DB.Exec()

功能：執行不返回行（row）的查詢，比如INSERT，UPDATE，DELETE

實現：DB交給內部的exec方法負責查詢。exec會首先呼叫DB內部的conn方法從連線池裡面獲得一個連線。然後檢查內部的driver.Conn實現了Execer介面沒有，如果實現了該介面，會呼叫Execer介面的Exec方法執行查詢；否則呼叫Conn介面的Prepare方法負責查詢。

 

（3）DB.Query()

功能：用於檢索（retrieval），比如SELECT

實現：DB交給內部的query方法負責查詢。query首先呼叫DB內部的conn方法從連線池裡面獲得一個連線，然後呼叫內部的queryConn方法負責查詢。

 

（4）DB.QueryRow()

功能：用於返回單行的查詢

實現：轉交給DB.Query()查詢

 

（5）db.Prepare()

功能：返回一個Stmt。Stmt物件可以執行Exec,Query,QueryRow等操作。

實現：DB交給內部的prepare方法負責查詢。prepare首先呼叫DB內部的conn方法從連線池裡面獲得一個連線，然後呼叫driverConn的prepareLocked方法負責查詢。

Stmt相關方法：

st.Exec()

st.Query()

st.QueryRow()

st.Close()

 

（6）db.Begin()

功能：開啟事務，返回Tx物件。呼叫該方法後，這個TX就和指定的連線繫結在一起了。一旦事務提交或者回滾，該事務繫結的連線就還給DB的連線池。

實現：DB交給內部的begin方法負責處理。begin首先呼叫DB內部的conn方法從連線池裡面獲得一個連線，然後呼叫Conn介面的Begin方法獲得一個TX。

TX相關方法：

//內部執行流程和上面那些差不多，只是沒有先去獲取連線的一步，因為這些操作是和TX關聯的，Tx建立的時候就和一個連線綁定了，所以這些操作內部共用一個TX內部的連線。

tx.Exec() 

tx.Query()

tx.QueryRow()

tx.Prepare()

tx.Commit()

tx.Rollback()

tx.Stmt()//用於將一個已存在的statement和tx繫結在一起。一個statement可以不和tx關聯，比如db.Prepare()返回的statement就沒有和TX關聯。

例子：

複製程式碼

  updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")

  ...

  tx, err := db.Begin()

  ...

  res, err := tx.Stmt(updateMoney).Exec(123.45, 98293203)

複製程式碼

 

 （7）原始碼中Stmt的定義

複製程式碼

// Stmt is a prepared statement. Stmt is safe for concurrent use by multiple goroutines.

type Stmt struct {

         // Immutable:

         db        *DB    // where we came from

         query     string // that created the Stmt

         stickyErr error  // if non-nil, this error is returned for all operations

 

         closemu sync.RWMutex // held exclusively during close, for read otherwise.

 

         // If in a transaction, else both nil:

         tx   *Tx

         txsi *driverStmt

 

         mu     sync.Mutex // protects the rest of the fields

         closed bool

 

         // css is a list of underlying driver statement interfaces

         // that are valid on particular connections.  This is only

         // used if tx == nil and one is found that has idle

         // connections.  If tx != nil, txsi is always used.

         css []connStmt

}

複製程式碼

 

（7）幾個主要struct的內部主要的資料結構

 

參考資料

https://github.com/golang/go/wiki/SQLInterface

https://github.com/go-sql-driver/mysql/

http://golang.org/pkg/database/sql/

相關推薦

使用go語言操作mysql資料庫

1.下載並匯入資料庫驅動包 官方不提供實現，先下載第三方的實現，點選這裡檢視各種各樣的實現版本。 這裡選擇了Go-MySQL-Driver這個實現。地址是：https://github.com/go-sql-driver/mysql/。 然後按照裡面的說明下載驅動包： $ go get

用C語言操作MySQL資料庫，進行連線、插入、修改、刪除等操作

　　很多人用到MySQL來開發一些專案，有時為了效能，我們會直接用C語言來開發相關的模組，尤其在我們的web應用中，雖然PHP、JSP等指令碼均提供了MySQL的介面，但是顯然直接使用C語言具有更好的安全性和效能，Michael以前用PHP開發的多個專案中就使用了C語言編寫的

用C語言操作mysql資料庫上傳變數

上傳變數文字內容 上傳命令：insert into table_name(list1,list2,...) values("***","***") 當上傳的值為變數時可如此執行 string a="上傳的檔案"； int id=1;//以上變數可隨意定義 char sqlstr[100];

用C語言操作MySQL資料庫

參考MYSQL的幫助文件整理 這裡歸納了C API可使用的函式，並在下一節詳細介紹了它們。請參見“C API函式描述”。 函式 描述 mysql_affected_rows() 返回上次UPDATE、DELETE或INSERT查詢更改／刪除／插入的行數。 mysql_autocommit

C語言操作MySQL資料庫的增刪改查

if( mysql_real_query(&mysql,"select * from user", (unsigned long)strlen("select * from user")))//mysql_real_query函式第一個引數是定義的MYSQL變數；第二個是SQL查詢語句；第三個是查詢語

go語言操作mysql範例（增刪查改）

    go官方僅提供了database package，database package下有兩個包sql，sql/driver。這兩個包用來定義操作資料庫的介面，這就保證了無論使用哪種資料庫，他們的操作方式都是相同的。     但go官方並沒有提供連線資料庫的drive

linux下C語言操作mysql資料庫（系統自帶版本3.23.54）

      我的上一篇blog介紹了在linux環境下如何安裝配置系統自帶的mysql資料庫，並列舉了mysql的一些簡單的操作。接下來我將介紹一下如何利用mysql提供給我們的API來訪問並操作mysql資料庫（C語言）。 首先，我們需要安裝mysql-devel-3.23

Go語言連線、操作MySQL資料庫

1、下載 github.com包 golang的”database/sql”是操作資料庫時常用的包，這個包定義了一些sql操作的介面，具體的實現還需要不同資料庫的實現，mysql比較優秀的一個驅動是：github.com/go-sql-driver/mysql，在介面、驅動

五分鐘beego框架圖文簡介講解03-go語言簡單方式操作MySQL資料庫

安裝go操作MySQL的驅動 go get -u -v github.com/go-sql-driver/mysql go簡單操作MySQL資料庫 導包 import "github.com/go-sql-driver/mysql" 連線資料庫，用sql.Open()方法,open()方法

Go語言操作Redis、MySQL

文章出處：http://www.cnblogs.com/wdliu/p/9330278.html 一、redis 簡介 redis(REmote DIctionary Server)是一個由Salvatore Sanfilippo寫key-value儲存系統，它由C語言編寫、遵守BSD協

linux下C語言程式設計操作MySQL資料庫

原文地址：http://www.2cto.com/database/201506/407827.html 在實際應用中，我們不可能在命令列登入進資料庫進行資料的查詢、插入等操作，使用者一般是使用一個介面良好的應用程式軟體來對資料進行管理。為了方便應用程式的開發，MySQ

【Go語言】連線資料庫SQLite、MySQL、Oracle

本文目錄 說明： go語言連線資料庫不像Java那麼方便，本文分別介紹了連線三種典型的資料庫的驅動以及連線方法:小型，SQLite;中型，MySQL;大型，Oracle. 1.Go連線SQLit

go語言連線mysql操作

一、安裝在windows下安裝1、goland（go IDE） 安裝位置： D:\package\goland 2、go 安裝位置 ： D:\package\go 3、GOPATH 位置： D:\package\go\workspaceD:\package\go\wor

C語言簡單操作MYSQL資料庫的增刪查詢

#include<stdio.h> #include<mysql.h> //所需標頭檔案 #include<string.h> #include<stdlib.h> MYSQL *conn_prt; //創造一個MYSQL控制代碼 MYSQL_RE

jmeter操作mysql資料庫

1、安裝mysql的驅動包 · 為了連線mysql資料庫，還需要下載"mysql-connector-java.jar",可以從MySQL官網下載 新建測試計劃，載入jar包路徑，如下： 2、建立JDBC連線，並配置好資料連線、使用者名稱、密碼（請注意連線格式） 3、

python操作MySQL資料庫心得（numpy陣列寫入資料庫）

    最近突發奇想，想把以前用Matlab實現的對高頻彩的開獎資料進行抓取並儲存到本地的專案重新用python做一遍。加上前段時間學習的MySQL，想將讀取回來的開獎資料存放到資料庫裡試試看。     廢話不多說，實操看看。 網頁下載器 這部分就

使用MySQLdb操作MySQL資料庫

#coding:utf-8 import MySQLdb # 1.連線資料庫 db = MySQLdb.connect('localhost','root','','students',charset='utf8') cur = db.cursor() # 2.插入資料 sq

nodejs（十七）操作mysql資料庫

var mysql = require('mysql') // 1. 建立連線 var connection = mysql.createConnection({ host: '192.168.94.151', user: 'root', password: 'root',

linux系統下操作mysql資料庫常見命令

一. 備份資料庫(如: test): ①可直接進入後臺即可.(MySQL的預設目錄:/var/lib/mysql ) ②輸入命令: [[email protected] mysql]# mysqldump -u root -p test>/home/bak/201

Column count doesn't match value count at row 1(Python操作MySQL資料庫時的報錯)

首先，這個錯誤的意思是，我們插入資料庫的列與資料庫中的列不是一一對應的。 當使用Python操作MySQL資料庫時，如果id是自增，或者timestamp是自動生成的時候，我們不能採用 "INSERT INTO 表名 VALUES (%s, %s, %s, %s, %s, %s,