使用go语言数据库
1.下载并导入数据库驱动包(注意配置环境变量、数据库、go、以及ENV)
这里选择了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" import
我们在写Go代码的时候经常用到import这个命令用来导入包文件,而我们经常看到的方式参考如下:
import(
"fmt"
)
然后我们代码里面可以通过如下的方式调用
fmt.Println("hello world")
上面这个fmt是Go语言的标准库,其实是去goroot下去加载该模块,当然Go的import还支持如下两种方式来加载自己
写的模块: 1. 相对路径
import “./model” //当前文件同一目录的model目录,但是不建议这种方式来import
2. 绝对路径
import “shorturl/model” //加载gopath/src/shorturl/model模块
上面展示了一些import常用的几种方式,但是还有一些特殊的import,让很多新手很费解,下面我们来一一讲解一下
到底是怎么一回事
1. 点操作
我们有时候会看到如下的方式导入包
import(
. "fmt"
)
这个点操作的含义就是这个包导入之后在你调用这个包的函数时,你可以省略前缀的包名,也就是前面你调
用的fmt.Println("hello world")可以省略的写成Println("hello world")
2. 别名操作
别名操作顾名思义我们可以把包命名成另一个我们用起来容易记忆的名字
import(
f "fmt"
)
别名操作的话调用包函数时前缀变成了我们的前缀,即f.Println("hello world")
3. _操作
这个操作经常是让很多人费解的一个操作符,请看下面这个import
import (
"database/sql"
_ "github.com/ziutek/mymysql/godrv"
)
_操作其实是引入该包,而不直接使用包里面的函数,而是调用了该包里面的init函数。 2.连接至数据库
db, err := sql.Open("mysql", "root:root@/uestcbook")
(1)sql.Open("mysql", "username:pwd@/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关联。
几个主要struct的内部主要的数据结构
(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:root@/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())
}
之前关于golang操作数据库的博客:
Go实战–go语言操作sqlite数据库(The way to go)
Go实战–golang中使用redis(redigo和go-redis/redis)
导入包
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
连接数据库
db, err := sql.Open("mysql", "root:wangshubo@/test?charset=utf8")
checkErr(err)
插入数据
stmt, err := db.Prepare("INSERT user_info SET id=?,name=?")
checkErr(err)
res, err := stmt.Exec(1, "wangshubo")
checkErr(err)
更新数据
stmt, err = db.Prepare("update user_info set name=? where id=?")
checkErr(err)
res, err = stmt.Exec("astaxieupdate", id)
checkErr(err)
查询
rows, err := db.Query("SELECT * FROM user_info")
checkErr(err)
删除
stmt, err = db.Prepare("delete from user_info where id=?")
checkErr(err)
res, err = stmt.Exec(id)
checkErr(err)
最新文章
- 适应laytpl 渲染模板数据
- SILVERLIGHT 应急卫生模拟演练项目之childwindow
- 因GIT默认忽略.dll文件导致的Visual Studio项目通过Bamboo编译失败
- 怎么获取iOS的私有API
- 几道华为经典C语言面试题
- Notes of the scrum meeting(11/2)
- Bootstrap_表单_表单提示信息
- http的无状态无连接到底是什么含义
- alert执行顺序
- NullpointerException处理
- SpringMVC 控制器默认支持GET和POST两种方式
- c#动态加载卸载DLL
- Java基础差,需要怎么补
- Kettle 中转换(transformation)的执行过程
- Jquery----属性的利用
- arcgis创建渔网
- linux下的一些操作命令
- linux 线程的同步 一 (互斥量和信号量)
- 关于margin:-10000px;padding:10000px;的理解
- HDU 4500 小Q系列故事——屌丝的逆袭
热门文章
- springboot aop的execution 表达式详解
- 【Python】博客信息爬取-微信消息自动发送
- phpstorm webstorm 常用快捷键总结
- 字符串匹配的 KMP算法
- 《Linux.Shell编程从入门到精通》读书笔记
- redis操作封装类
- Solve Error: ";errcode";: 85005, ";errmsg";: ";appid not bind weapp hint";
- memoization提升递归效率
- mysql日志分类
- python全栈开发 * 34知识点汇总 * 180719