Golang 访问Mysql数据库实现增删改查 - 《Golang 学习笔记》

查询
做个比较
插入
- 修改
删除
- 完整的代码实例

数据库访问需要用到标准库database/sql和mysql的驱动”github.com/go-sql-driver/mysql”。这两个包都需要引用。mysql的驱动因为只是需要它的init()初始化，所以需要采用下划线的方式。

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

在访问数据库前，我们先在MySql里建好表并预先插入一些数据以便测试程序。请在Mysql里执行下面的SQL脚本。

-- ----------------------------
-- Table structure for announcement
-- ----------------------------
DROP TABLE IF EXISTS `announcement`;
CREATE TABLE `announcement` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `imgUrl` varchar(128) COLLATE utf8_unicode_ci DEFAULT NULL,
  `detailUrl` varchar(128) COLLATE utf8_unicode_ci DEFAULT NULL,
  `createDate` varchar(10) COLLATE utf8_unicode_ci DEFAULT NULL,
  `state` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
-- ----------------------------
-- Records of announcement
-- ----------------------------
INSERT INTO `announcement` VALUES ('1', '/visitshop/img/ann/ann1.jpg', null, '2016-07-20', '0');
INSERT INTO `announcement` VALUES ('2', '/visitshop//img/ann/ann1.jpg', null, '2016-07-20', '0');
INSERT INTO `announcement` VALUES ('3', '/visitshop//img/ann/ann1.jpg', null, '2016-07-20', '0');
INSERT INTO `announcement` VALUES ('4', '/visitshop//img/ann/ann1.jpg', null, '2016-07-20', '0');

我们将在主函数里调用增删该查函数。先预设这四种操作的函数名

query()    //查询
query2()  //查询
insert()    //插入
update()  //修改
remove()  //删除

然后分别实现这几个函数。

查询

首先是query()查询函数。
要想访问数据库，首先要打开数据库链接。这就需要用到database/sql Open函数。

db, err := sql.Open("mysql", "root:@/shopvisit")

我们的数据库链接是这个样子的。为了简化操作，我的数据库用户 root 是没有密码的。而正常的数据库链接应该是这个样子的

db, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/shopvisit")

这个连接说明数据库用户root的密码是123456，使用tcp协议，数据库ip地址是127.0.0.1，使用3306端口作为通讯端口。当前使用的库名是shopvisit。
当然链接数据库的方式其实是有好几种的

user@unix(/path/to/socket)/dbname?charset=utf8
user:password@tcp(localhost:5555)/dbname?charset=utf8
user:password@/dbname
user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname

既然有了数据库连接的语句，就要有错误检查。而错误检查会比较频繁的出现，所以写一个函数来直接处理它。

func check(err error) {
    if err != nil{
        fmt.Println(err)
        panic(err)
    }
}

这样每当需要对错误进程检查的时候，就执行check(err)。
当db链接数据库正常之后，我们就可以执行sql查询语句了。

rows, err := db.Query("SELECT * FROM shopvisit.announcement")
check(err)

然后用for循环遍历返回的结果。

for rows.Next() {

在循环体内，我们先取得记录的列(字段)，把列名参数的值和列地址关联。

columns, _ := rows.Columns()
scanArgs := make([]interface{}, len(columns))
values := make([]interface{}, len(columns))
for i := range values {
    scanArgs[i] = &values[i]
}

再把数据保存到record字典中

//将数据保存到 record 字典
err = rows.Scan(scanArgs...)
record := make(map[string]string)
for i, col := range values {
    if col != nil {
        record[columns[i]] = string(col.([]byte))
    }
}

打印记录fmt.Println(record)之后，一定要记得释放资源

rows.Close()

query()完整代码

func query() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    rows, err := db.Query("SELECT * FROM shopvisit.announcement")
    check(err)
    for rows.Next() {
        columns, _ := rows.Columns()
        scanArgs := make([]interface{}, len(columns))
        values := make([]interface{}, len(columns))
        for i := range values {
            scanArgs[i] = &values[i]
        }
        //将数据保存到 record 字典
        err = rows.Scan(scanArgs...)
        record := make(map[string]string)
        for i, col := range values {
            if col != nil {
                record[columns[i]] = string(col.([]byte))
            }
        }
        fmt.Println(record)
    }
    rows.Close()
}

在main函数中，注释掉其他函数，只留下query(),运行看结果。多运行几次，比较每次运行结果。

第一次运行
map[state:0 id:1 imgUrl:/visitshop/img/ann/ann1.jpg createDate:2016-07-20]
map[id:2 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]
map[id:3 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]
map[createDate:2016-07-20 state:0 id:4 imgUrl:/visitshop//img/ann/ann1.jpg]
第二次运行
map[id:1 imgUrl:/visitshop/img/ann/ann1.jpg createDate:2016-07-20 state:0]
map[id:2 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]
map[id:3 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]
map[id:4 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]
第三次运行
map[createDate:2016-07-20 state:0 id:1 imgUrl:/visitshop/img/ann/ann1.jpg]
map[id:2 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]
map[imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0 id:3]
map[id:4 imgUrl:/visitshop//img/ann/ann1.jpg createDate:2016-07-20 state:0]

为什么每次都不一样呢？这是因为我们使用了 map 字典来保存列。map 是无序的，所以每次都是随机的显示顺序。
这显然不符合我们一般的结果需要，那么，我们来编写 query2()。
仍然是链接数据库的语句作为开端，再跟着是查询语句。

db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/shopvisit?charset=utf8")
check(err)
rows, err := db.Query("SELECT id,imgUrl,createDate,state FROM announcement")
check(err)

既然已经查询无错了，那么直接for循环记录结果

for rows.Next(){
    var id int
    var state int
    var imgUrl string
    var createDate string
    //注意这里的Scan括号中的参数顺序，和 SELECT 的字段顺序要保持一致。
    if err := rows.Scan(&id,&imgUrl,&createDate,&state); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s id is %d on %s with state %d\n", imgUrl, id, createDate, state)
}

每一次循环的时候，我们都可以按照我们想要的顺序，取得所有的字段值。唯一需要注意的是，rows.Scan的参数顺序，需要和select语句的字段保持顺序一致。这里主要指的是数据类型。参数名可以不同。

做个比较

db.Query("SELECT id,imgUrl,createDate,state FROM announcement")
rows.Scan(&id,&imgUrl,&createDate,&state);

&符号是取变量的地址，注意观察变量的数据类型和select后面参数的数据类型必须是一致的。声明变量时的顺序无所谓，Scan调用变量时的顺序要注意select参数的顺序一致。

var id int
var state int
var imgUrl string
var createDate string

然后可以按照你想要的顺序打印输出

fmt.Printf("%s id is %d on %s with state %d\n", imgUrl, id, createDate, state)

query2()完整代码

func query() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    rows, err := db.Query("SELECT * FROM shopvisit.announcement")
    check(err)
    for rows.Next() {
        columns, _ := rows.Columns()
        scanArgs := make([]interface{}, len(columns))
        values := make([]interface{}, len(columns))
        for i := range values {
            scanArgs[i] = &values[i]
        }
        //将数据保存到 record 字典
        err = rows.Scan(scanArgs...)
        record := make(map[string]string)
        for i, col := range values {
            if col != nil {
                record[columns[i]] = string(col.([]byte))
            }
        }
        fmt.Println(record)
    }
    rows.Close()
}
func query2()  {
    fmt.Println("Query2")
    db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/shopvisit?charset=utf8")
    check(err)
    rows, err := db.Query("SELECT id,imgUrl,createDate,state FROM announcement")
    check(err)
    for rows.Next(){
        var id int
        var state int
        var imgUrl string
        var createDate string
        //注意这里的Scan括号中的参数顺序，和 SELECT 的字段顺序要保持一致。
        if err := rows.Scan(&id,&imgUrl,&createDate,&state); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%s id is %d on %s with state %d\n", imgUrl, id, createDate, state)
    }
    if err := rows.Err(); err != nil {
        log.Fatal(err)
    }
    rows.Close()
}

修改main函数中的当前可执行函数query2()，运行结果如下：

Query2
/visitshop/img/ann/ann1.jpg id is 1 on 2016-07-20 with state 0
/visitshop//img/ann/ann1.jpg id is 2 on 2016-07-20 with state 0
/visitshop//img/ann/ann1.jpg id is 3 on 2016-07-20 with state 0
/visitshop//img/ann/ann1.jpg id is 4 on 2016-07-20 with state 0

插入

插入数据insert()函数，链接数据库还是一样的，而db调用的函数改为Prepare。执行的sql语句需要这样写

stmt, err := db.Prepare(`INSERT announcement (imgUrl, detailUrl, createDate, state) VALUES (?, ?, ?, ?)`)
check(err)

插入的值，必须按照sql顺序来插入

res, err := stmt.Exec("/visitshop/img/ann/cofox1.png",nil,"2017-09-06",0)
check(err)

返回刚插入的这条记录的id

id, err := res.LastInsertId()
check(err)

insert()完整带代码

func insert()  {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    stmt, err := db.Prepare(`INSERT announcement (imgUrl, detailUrl, createDate, state) VALUES (?, ?, ?, ?)`)
    check(err)
    res, err := stmt.Exec("/visitshop/img/ann/cofox1.png",nil,"2017-09-06",0)
    check(err)
    id, err := res.LastInsertId()
    check(err)
    fmt.Println(id)
    stmt.Close()
}

修改

修改函数和插入函数结构类似，sql语句不同

stmt, err := db.Prepare("UPDATE announcement set imgUrl=?, detailUrl=?, createDate=?, state=? WHERE id=?")
check(err)

那么参数语句也要增加个id值(注意id参数是你要修改的那条记录的id)

res, err := stmt.Exec("/visitshop/img/ann/cofox2.png", nil, "2017-09-05", 1, 7)
check(err)

修改的结果返回语句就也调用了不同的函数res.RowsAffected

num, err := res.RowsAffected()
check(err)

完整的修改函数代码

func update() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    stmt, err := db.Prepare("UPDATE announcement set imgUrl=?, detailUrl=?, createDate=?, state=? WHERE id=?")
    check(err)
    res, err := stmt.Exec("/visitshop/img/ann/cofox2.png", nil, "2017-09-05", 1, 7)
    check(err)
    num, err := res.RowsAffected()
    check(err)
    fmt.Println(num)
    stmt.Close()
}

删除

删除函数的代码与修改函数的代码比较起来就只有sql语句好参数的差别了，其他的完全一样。

完整的删除函数的代码

func remove() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    stmt, err := db.Prepare("DELETE FROM announcement WHERE id=?")
    check(err)
    res, err := stmt.Exec(7)
    check(err)
    num, err := res.RowsAffected()
    check(err)
    fmt.Println(num)
    stmt.Close()
}

完整的代码实例

package main
import (
    "database/sql"
    _"github.com/go-sql-driver/mysql"
    "fmt"
    "log"
)
func main() {
    query()
    //query2()
    //insert()
    //update()
    //remove()
}
//查询数据
func query() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    rows, err := db.Query("SELECT * FROM shopvisit.announcement")
    check(err)
    for rows.Next() {
        columns, _ := rows.Columns()
        scanArgs := make([]interface{}, len(columns))
        values := make([]interface{}, len(columns))
        for i := range values {
            scanArgs[i] = &values[i]
        }
        //将数据保存到 record 字典
        err = rows.Scan(scanArgs...)
        record := make(map[string]string)
        for i, col := range values {
            if col != nil {
                record[columns[i]] = string(col.([]byte))
            }
        }
        fmt.Println(record)
    }
    rows.Close()
}
func query2()  {
    fmt.Println("Query2")
    db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/shopvisit?charset=utf8")
    check(err)
    rows, err := db.Query("SELECT id,imgUrl,createDate,state FROM announcement")
    check(err)
    for rows.Next(){
        var id int
        var state int
        var imgUrl string
        var createDate string
        //注意这里的Scan括号中的参数顺序，和 SELECT 的字段顺序要保持一致。
        if err := rows.Scan(&id,&imgUrl,&createDate,&state); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%s id is %d on %s with state %d\n", imgUrl, id, createDate, state)
    }
    if err := rows.Err(); err != nil {
        log.Fatal(err)
    }
    rows.Close()
}
//插入数据
func insert()  {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    stmt, err := db.Prepare(`INSERT announcement (imgUrl, detailUrl, createDate, state) VALUES (?, ?, ?, ?)`)
    check(err)
    res, err := stmt.Exec("/visitshop/img/ann/cofox1.png",nil,"2017-09-06",0)
    check(err)
    id, err := res.LastInsertId()
    check(err)
    fmt.Println(id)
    stmt.Close()
}
//修改数据
func update() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    stmt, err := db.Prepare("UPDATE announcement set imgUrl=?, detailUrl=?, createDate=?, state=? WHERE id=?")
    check(err)
    res, err := stmt.Exec("/visitshop/img/ann/cofox2.png", nil, "2017-09-05", 1, 7)
    check(err)
    num, err := res.RowsAffected()
    check(err)
    fmt.Println(num)
    stmt.Close()
}
//删除数据
func remove() {
    db, err := sql.Open("mysql", "root:@/shopvisit")
    check(err)
    stmt, err := db.Prepare("DELETE FROM announcement WHERE id=?")
    check(err)
    res, err := stmt.Exec(7)
    check(err)
    num, err := res.RowsAffected()
    check(err)
    fmt.Println(num)
    stmt.Close()
}
func check(err error) {
    if err != nil{
        fmt.Println(err)
        panic(err)
    }
}

Golang 访问Mysql数据库实现增删改查 - 图1