【REST2SQL】07 GO 操作 Mysql 数据库
【REST2SQL】01RDB关系型数据库REST初设计
【REST2SQL】02 GO连接Oracle数据库
【REST2SQL】03 GO读取JSON文件
【REST2SQL】04 REST2SQL第一版Oracle版实现
【REST2SQL】06 GO 跨包接口重构代码
MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle旗下产品。MySQL是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的RDBMS (Relational Database Management System，关系数据库管理系统)应用软件之一。
MySQL是一种关系型数据库管理系统，关系数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。
MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型和大型网站的开发都选择 MySQL作为网站数据库。
1 准备工作
我的操作环境：
操作系统：Win10 x64
数据库： Ver 8.0.35 for Win64 on x86_64 (MySQL Community Server - GPL)
go:1.21.5
LiteIDE : X38.3
1.1 安装Mysql数据
登录 Mysql 官网，有Mysql社区版可以下载，官网下载显示的是32位，实际上安装包里也包括64位的，下载成功后，安装配置等这里省略5217字，我安装后就是64位的，自己脑补。
创建测试表 guci
导入部分测试数据
1.2 Mysql go驱动安装
第三方驱动下载。
go get -u github.com/go-sql-driver/mysql
//其中包含一个依赖库
go get -u filippo.io/edwards25519
众所周知的原因，可能同步失败，自己想办法或代理等一系列操作。
我这里偶尔能登录github.com网站，我从网站上手动下载下来加到开发环境中的src
2 新建一个gomysql的项目
新建一下gomysql的项目用来测试go操作mysql数据库。
2.1 go连接Mysql数据库
1 引入相关包
import (
"database/sql"
"database/sql/driver"
_ "github.com/go-sql-driver/mysql"
）
2 声明连接字符串
var ConnString string = "mysql://blma:5217@tcp(127.0.0.1:3306)/blma"
3 连接数据库
// 连接Mysql数据库
func connDB(connStr string) *sql.DB {
end := strings.Index(connStr, "://")
if end < 0 {
log.Println("连接字符串设置有误。")
panic(nil)
}
driverName := connStr[:end] // dm
connstring := connStr[end+3:]
db, err := sql.Open(driverName, connstring)
dieOnError("Can't open the driver:", err)
if err = db.Ping(); err != nil {
fmt.Println("不能连接mysql数据库：", err)
return nil
}
// fmt.Printf("connect to \"%s\" succeed.\n", connStr)
return db
}
2.2 实现CRUD
CUD比较简单，都执行execSQL操作，只是sql语句不同。
代码如下：
/* 往表插入数据 */
func insertData(insertSql string) string {
result, _ := execSQL(insertSql)
rows, err := result.RowsAffected()
dieOnError("Can't insert", err)
ret := map[string]int{
"Insert rowsAffected": int(rows),
}
jsonBytes, err := json.Marshal(ret)
dieOnError("map 转 json失败：", err)
return string(jsonBytes)
}
/* 删除表数据 */
func deleteData(deleteSql string) string {
result, _ := execSQL(deleteSql)
rows, err := result.RowsAffected()
dieOnError("Can't delete", err)
ret := map[string]int{
"Delete rowsAffected": int(rows),
}
jsonBytes, err := json.Marshal(ret)
dieOnError("map 转 json失败：", err)
return string(jsonBytes)
}
/* 修改表数据 */
func updateData(updateSql string) string {
result, _ := execSQL(updateSql)
rows, err := result.RowsAffected()
dieOnError("Can't update", err)
ret := map[string]int{
"Update rowsAffected": int(rows),
}
jsonBytes, err := json.Marshal(ret)
dieOnError("map 转 json失败：", err)
return string(jsonBytes)
// var sql =
// result, err := db.Exec(sql)
// if err != nil {
// return err
// }
// affectedRows, _ := result.RowsAffected()
// fmt.Println("updateTable succeed Affected rows:", affectedRows)
// return nil
}
// 执行SQL， execute stmt (INSERT, UPDATE, DELETE, DML, PLSQL) and return driver.Result object
func execSQL(sqls string) (result driver.Result, err error) {
//连接数据库
DB := connDB(ConnString)
//延迟关闭连接
defer DB.Close()
statement, err := DB.Prepare(sqls)
if err != nil {
fmt.Println("prepare statement failed:", err.Error())
}
defer statement.Close()
//执行SQL， execute stmt (INSERT, UPDATE, DELETE, DML) and return driver.Result object
result, err = statement.Exec()
if err != nil {
fmt.Println("Exec failed:", err.Error())
}
dieOnError("Can't execSql() ", err)
return result, err
}
2.3 动态查询有点费劲
没仔细研究Mysql的驱动，还是用达梦数据库的思路。
总体思路是先查询获取 *sql.Rows对象，从这里通过rows.Columns（）和 rows. ColumnTypes()再获取列名切片和列类型信息，第三步把列名和数据库数据类型组合在一个map[string]string里；第四步初始化列值接收变量；第五步 rows.Next() 逐行遍历返回结果集并根据数据库类型（目前只匹配的VARCHER2 和 NUMBER，遇到其它类型再匹配）转换为Go的数据类型，组成一个dataset数据集；第六步序列化并转json返回查询结果。
代码如下：
/* 查询表数据 */
func selectData(sqlSelect string) string {
// 连接数据库
DB := connDB(ConnString)
//延迟关闭连接
defer DB.Close()
// 准备查询语句
statement, err := DB.Prepare(sqlSelect)
if err != nil {
fmt.Println("prepare statement failed:", err.Error())
return ""
}
defer statement.Close()
// 1查询
rows, err := statement.Query()
if err != nil {
fmt.Println("query failed:", err.Error())
}
// 2查询的列名称切片
columns, err := rows.Columns()
if err != nil {
fmt.Println(err.Error())
return ""
}
//fmt.Println(columns)
// 3数据库列类型
cType, err := rows.ColumnTypes()
if err != nil {
log.Fatal(err)
}
//fmt.Println(cType[0].Name(), cType[0].DatabaseTypeName())
// 4列名类型map
coltyp := colType(cType)
// 5初始化列值接收变量
row := make([]sql.RawBytes, len(columns))
scanArgs := make([]interface{}, len(row))
for i := range row {
scanArgs[i] = &row[i]
}
// 查询结果数据集
var dataset []map[string]interface{} //元素为map的切片
for rows.Next() {
err := rows.Scan(scanArgs...)
if err != nil {
panic(err.Error())
}
// row
var row1 map[string]interface{} = make(map[string]interface{})
for pos, col := range row {
//fmt.Println(columns[pos], ":", string(col))
colname := columns[pos]
svalue := string(col)
//数据类型处理
value := typeConv(colname, svalue, coltyp)
row1[colname] = value
}
//fmt.Println("row1:", row1)
dataset = append(dataset, row1)
//fmt.Println()
}
if err != io.EOF {
dieOnError("Can't Next", err)
}
//切片转json
jsonBytes, err := json.Marshal(dataset)
dieOnError("slice 转 json失败：", err)
//fmt.Println(string(jsonBytes))
return string(jsonBytes)
}
// 生成列名和类型 map
func colType(cType []*sql.ColumnType) map[string]string {
var colTyp map[string]string = make(map[string]string)
for _, col := range cType {
colTyp[col.Name()] = col.DatabaseTypeName()
}
//fmt.Println(colTyp)
return colTyp
}
// 字符根据数据库类型转为go数据类型
func typeConv(colname string, svalue string, ct map[string]string) interface{} {
var ret interface{}
switch ct[colname] {
case "VARCHAR":
ret = svalue
case "DECIMAL":
if len(svalue) > 0 {
flt, err := strconv.ParseFloat(svalue, 64)
if err != nil {
fmt.Println("转换失败：", colname, svalue, err)
} else {
ret = flt
}
} else { //空串处理
ret = nil
}
default:
ret = svalue
}
return ret
}
3 全部代码及运行结果截图
全部代码：
/*该例程实现了Mysql数据库插入数据，修改数据，删除数据，数据查询等基本操作。*/
package main
// 引入相关包
import (
"database/sql"
"database/sql/driver"
"encoding/json"
"fmt"
"io"
"log"
"strconv"
"strings"
_ "github.com/go-sql-driver/mysql"
)
var ConnString string = "mysql://blma:5217@tcp(127.0.0.1:3306)/blma"
// var ConnString string = config.Conf.ConnString
func main() {
fmt.Println("\ngo 操作mysql数据库 demo")
var (
sqls string //sql语句
result string //sql执行后返回的结果
)
//显示版本号
showMysqlVersion()
// // insert 插入一行数据
sqls = `INSERT INTO kezz(p_id,s_dm,s_mc,n_zzxj) VALUES(-101,'125217','白龙马',5217);`
result = insertData(sqls)
fmt.Println(result)
// update 更新数据
sqls = "UPDATE kezz SET n_zzxj = 111 WHERE p_id = -100"
result = updateData(sqls)
fmt.Println(result)
// delete 删除数据
sqls = "delete from kezz where p_id = -109"
result = deleteData(sqls)
fmt.Println(result)
// select 查询数据
sqls = "select p_id,s_dm,s_mc,n_zzxj from kezz limit 5 "
result = selectData(sqls)
fmt.Println(result)
}
func showMysqlVersion() {
//连接数据库
db := connDB(ConnString)
var version string
err2 := db.QueryRow("SELECT VERSION()").Scan(&version)
if err2 != nil {
log.Fatal(err2)
}
fmt.Println("Mysql:", version)
}
// 连接Mysql数据库
func connDB(connStr string) *sql.DB {
end := strings.Index(connStr, "://")
if end < 0 {
log.Println("连接字符串设置有误。")
panic(nil)
}
driverName := connStr[:end] // dm
connstring := connStr[end+3:]
db, err := sql.Open(driverName, connstring)
dieOnError("Can't open the driver:", err)
if err = db.Ping(); err != nil {
fmt.Println("不能连接mysql数据库：", err)
return nil
}
// fmt.Printf("connect to \"%s\" succeed.\n", connStr)
return db
}
// 发生错误退出1
func dieOnError(msg string, err error) {
if err != nil {
log.Println(msg, err)
//os.Exit(1)
}
}
/* 往表插入数据 */
func insertData(insertSql string) string {
result, _ := execSQL(insertSql)
rows, err := result.RowsAffected()
dieOnError("Can't insert", err)
ret := map[string]int{
"Insert rowsAffected": int(rows),
}
jsonBytes, err := json.Marshal(ret)
dieOnError("map 转 json失败：", err)
return string(jsonBytes)
}
/* 删除表数据 */
func deleteData(deleteSql string) string {
result, _ := execSQL(deleteSql)
rows, err := result.RowsAffected()
dieOnError("Can't delete", err)
ret := map[string]int{
"Delete rowsAffected": int(rows),
}
jsonBytes, err := json.Marshal(ret)
dieOnError("map 转 json失败：", err)
return string(jsonBytes)
}
/* 修改表数据 */
func updateData(updateSql string) string {
result, _ := execSQL(updateSql)
rows, err := result.RowsAffected()
dieOnError("Can't update", err)
ret := map[string]int{
"Update rowsAffected": int(rows),
}
jsonBytes, err := json.Marshal(ret)
dieOnError("map 转 json失败：", err)
return string(jsonBytes)
}
// 执行SQL， execute stmt (INSERT, UPDATE, DELETE, DML, PLSQL) and return driver.Result object
func execSQL(sqls string) (result driver.Result, err error) {
//连接数据库
db := connDB(ConnString)
//延迟关闭连接
defer db.Close()
statement, err := db.Prepare(sqls)
if err != nil {
fmt.Println("prepare statement failed:", err.Error())
}
defer statement.Close()
//执行SQL， execute stmt (INSERT, UPDATE, DELETE, DML) and return driver.Result object
result, err = statement.Exec()
if err != nil {
fmt.Println("Exec failed:", err.Error())
}
dieOnError("Can't execSql() ", err)
return result, err
}
/* 查询表数据 */
func selectData(sqlSelect string) string {
// 连接数据库
db := connDB(ConnString)
//延迟关闭连接
defer db.Close()
// 准备查询语句
statement, err := db.Prepare(sqlSelect)
if err != nil {
fmt.Println("prepare statement failed:", err.Error())
return ""
}
defer statement.Close()
// 1查询
rows, err := statement.Query()
if err != nil {
fmt.Println("query failed:", err.Error())
}
// 2查询的列名称切片
columns, err := rows.Columns()
if err != nil {
fmt.Println(err.Error())
return ""
}
//fmt.Println(columns)
// 3数据库列类型
cType, err := rows.ColumnTypes()
if err != nil {
log.Fatal(err)
}
//fmt.Println(cType[0].Name(), cType[0].DatabaseTypeName())
// 4列名类型map
coltyp := colType(cType)
// 5初始化列值接收变量
row := make([]sql.RawBytes, len(columns))
scanArgs := make([]interface{}, len(row))
for i := range row {
scanArgs[i] = &row[i]
}
// 查询结果数据集
var dataset []map[string]interface{} //元素为map的切片
for rows.Next() {
err := rows.Scan(scanArgs...)
if err != nil {
panic(err.Error())
}
// row
var row1 map[string]interface{} = make(map[string]interface{})
for pos, col := range row {
//fmt.Println(columns[pos], ":", string(col))
colname := columns[pos]
svalue := string(col)
//数据类型处理
value := typeConv(colname, svalue, coltyp)
row1[colname] = value
}
//fmt.Println("row1:", row1)
dataset = append(dataset, row1)
//fmt.Println()
}
if err != io.EOF {
dieOnError("Can't Next", err)
}
//切片转json
jsonBytes, err := json.Marshal(dataset)
dieOnError("slice 转 json失败：", err)
//fmt.Println(string(jsonBytes))
return string(jsonBytes)
}
// 生成列名和类型 map
func colType(cType []*sql.ColumnType) map[string]string {
var colTyp map[string]string = make(map[string]string)
for _, col := range cType {
colTyp[col.Name()] = col.DatabaseTypeName()
}
//fmt.Println(colTyp)
return colTyp
}
// 字符根据数据库类型转为go数据类型
func typeConv(colname string, svalue string, ct map[string]string) interface{} {
var ret interface{}
switch ct[colname] {
case "VARCHAR":
ret = svalue
case "DECIMAL":
if len(svalue) > 0 {
flt, err := strconv.ParseFloat(svalue, 64)
if err != nil {
fmt.Println("转换失败：", colname, svalue, err)
} else {
ret = flt
}
} else { //空串处理
ret = nil
}
default:
ret = svalue
}
return ret
}
运行结果截图：
完