golang實現mysql資料庫備份

zhoutk發表於2018-07-02
GolangMySql資料庫

背景

navicat是mysql視覺化工具中最棒的，但是，在處理檢視的匯入匯出方面，它是按照檢視名稱的字母順序來處理的，若檢視存在依賴，在匯入過程中就會報錯。前面已經用python寫了一個，但在使用過程中，遇到\xfffd編碼，python的pymysql會直接崩潰。發現golang沒有這個問題，正好用go重寫，來熟悉golang。

一些關鍵點

  1. map & json，在處理主鍵與外來鍵資訊時，需要用到json資料結構來儲存中間結果，因為要靈活處理，在golang中只能用map[string]interface{}來處理。
  2. interface{} 相當於java中的object，能接受任意資料型別，方便但在使用時要做到心中有數，不然一旦資料型別不匹配，程式就會崩潰。
  3. \xfffd ，utf8中的佔位符，超出範圍的utf8mb4入庫後，會被儲存為\xfffd，資料匯出時，需要過濾掉。

  4. goroutine， golang的併發支援很獨特，我們的工具支援多個庫同時備份，很容易使用goroutine來實現並行。

    程式碼解析

    按功能模組對核心程式碼進行說明

    main.go，併發、命令列引數

    使用命令列引數，接受一個引數，來指定備份的內容 package common

    type OpFlag struct {
Tables bool            //表結構
Datum bool             //表結構和資料
Views bool             //檢視
Funcs bool             //函式與儲存過程
}

    main.go，程式入口，處理命令列引數

    if len(os.Args) > 1 {
    flag = common.OpFlag{
        Tables: false,
        Datum: false,
        Views: false,
        Funcs: false,
    }
    switch os.Args[1] {          //接受一個引數
    case "table":
        flag.Tables = true       //根據引數設定標識量
    case "data":
        flag.Tables = true
        flag.Datum = true
    case "views":
        flag.Views = true
    case "funcs":
        flag.Funcs = true
    default:                    //引數不正確，報錯退出
        log.Fatal("You arg must be in : table, data, views or funcs.")
    }
}else{                        //無引數，預設匯出所有
    flag = common.OpFlag{
        Tables: true,
        Datum: true,
        Views: true,
        Funcs: true,
    }
}
err := backUp.Export(flag)  根據引數進行資料庫備份

    Export.go

    備份主流程，根據configs.json生成goroutine來備份資料庫，並等待完成。

    var configs interface{}
fr, err := os.Open("./configs.json")
if err != nil {
    return err
}
decoder := json.NewDecoder(fr)                 //解析配置檔案
err = decoder.Decode(&configs)
confs := configs.(map[string]interface{})
workDir := confs["workDir"].(string)
ch := make(chan string)                       //通道變數
for key, value := range confs {
    if strings.HasPrefix(key, "db_") {
        dbConf := value.(map[string]interface{})
        dbConn := common.DbConnFields{      //資料庫相應配置
            DbHost:    dbConf["db_host"].(string),
            DbPort:    int(dbConf["db_port"].(float64)),
            DbUser:    dbConf["db_user"].(string),
            DbPass:    dbConf["db_pass"].(string),
            DbName:    dbConf["db_name"].(string),
            DbCharset: dbConf["db_charset"].(string),
        }
        if dbConf["file_alias"] != nil {    //生成sql備份檔案的命名
            dbConn.FileAlias = dbConf["file_alias"].(string)
        }
        go ExportOne(dbConn, workDir, ch, flag)  //建立協程
    }
}
for key := range confs {                        //阻塞主程式，待所有協程完成工作
    if strings.HasPrefix(key, "db_") {
        fmt.Print( <- ch )
    }
}
return nil

    你需要編寫如下的配置檔案來描述你要備份的資料庫：

    {
"db_name1": {
    "db_host": "192.168.1.8",
    "db_port": 3306,
    "db_user": "root",
    "db_pass": "123456",
    "db_name": "name1",
    "db_charset": "utf8mb4",
    "file_alias": "file name1"
},
"db_name2": {
    "db_host": "localhost",
    "db_port": 3306,
    "db_user": "root",
    "db_pass": "123456",
    "db_name": "name2",
    "db_charset": "utf8mb4"
},
"database_dialect": "mysql",
"workDir": "/home/zhoutk/gocodes/goTools/"
}

    ExportOne.go

    備份一個資料庫

    fileName ：= fields.FileAlias
setSqlHeader(fields, fileName)            //設定匯出檔案說明

if flag.Tables {                        //如果表設定為真，匯出表結構
    err := exportTables(fileName, fields, flag)   //具體演算法請參照原始碼
    if err != nil {
        ch <- fmt.Sprintln("Error: ", fields.DbName, "\t export tables throw, \t", err)
        return
    }
}

if flag.Views {                       //如果檢視設定為真，匯出檢視
    err := exportViews(fileName, fields)//具體演算法請參照原始碼，或python演算法
    if err != nil {
        ch <- fmt.Sprintln("Error: ", fields.DbName, "\t export views throw, \t", err)
        return
    }
}

if flag.Funcs {                //如果函式設定為真，匯出函式和儲存過程
    err := exportFuncs(fileName, fields)//具體演算法請參照原始碼
    if err != nil {
        ch <- fmt.Sprintln("Error: ", fields.DbName, "\t export funcs throw, \t", err)
        return
    }
}
//匯出工作完成，向通道輸入資訊
ch <- fmt.Sprintln("Export ", fields.DbName, "\t success at \t", time.Now().Format("2006-01-02 15:04:05"))

    MysqlDao.go

    資料庫查詢通用封裝,此工具只使用了ExecuteWithDbConn。靈活的使用map與interface{}，將結果轉化為鍵值物件返回。

    func ExecuteWithDbConn(sql string, values []interface{}, fields common.DbConnFields) (map[string]interface{}, error)  {
rs := make(map[string]interface{})
dao, err := mysql.Open("mysql", fields.DbUser + ":"+fields.DbPass+"@tcp("+fields.DbHost+":"+
    strconv.Itoa(fields.DbPort)+")/"+fields.DbName+"?charset="+fields.DbCharset)
defer dao.Close()
if err != nil {
    rs["code"] = 204
    return rs, err
}
stmt, err := dao.Prepare(sql)
if err != nil {
    rs["code"] = 204
    return rs, err
}
rows, err := stmt.Query(values...)
if err != nil {
    rs["code"] = 204
    return rs, err
}

columns, err := rows.Columns()       //取出欄位名稱
vs := make([]mysql.RawBytes, len(columns))
scans := make([]interface{}, len(columns))

for i := range vs {                 //預設取值地址
    scans[i] = &vs[i]
}

var result []map[string]interface{}
for rows.Next() {
    _ = rows.Scan(scans...)        //塡入一列值
    each := make(map[string]interface{})

    for i, col := range vs {
        if col != nil {
            each[columns[i]] = FilterHolder(string(col)) //過濾/xfffd
        }else{
            each[columns[i]] = nil
        }
    }

    result = append(result, each)
}
rs["code"] = 200
//data, _ := json.Marshal(result)
rs["rows"] = result
return rs, err
}

    專案地址

    https://github.com/zhoutk/goTools

    使用方法

git clone https://github.com/zhoutk/goTools
cd goTools
go get
go run main.go

go buid main.go
./main                  #export all things of database
./main table            #export tables
./main data             #export tables & data
./main views            #export views
./main funcs            #export funcs & stored procedures

小結

熟悉了golang語言，瞭解了一種全新的併發程式設計模式，給自己生成了一個方便的工具。

相關文章