apache mysql go_golang学习之旅：使用go语言操作mysql数据库

最新推荐文章于 2024-03-08 21:56:48 发布
最新推荐文章于 2024-03-08 21:56:48 发布
阅读量120 收藏
点赞数
文章标签： apache mysql go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_29541589/article/details/113373788
版权

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:root@/uestcbook")

3.执行查询

(1)Exec

result, err := db.Exec(

"INSERT INTO users (name, age) VALUES (?, ?)",

"gopher",

27,

)

(2)Query

48304ba5e6f9fe08f3fa1abda7d326ab.png

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)

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

(3)QueryRow

var age int64

row := db.QueryRow("SELECT age FROM users WHERE name = ?", name)

err := row.Scan(&age)

(4)Prepared statements

48304ba5e6f9fe08f3fa1abda7d326ab.png

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

48304ba5e6f9fe08f3fa1abda7d326ab.png

4. 事务

tx, err := db.Begin()

if err != nil {

log.Fatal(err)

}

5. 各种方式效率分析

问题：db.exec和statement.exec和tx.exec的区别？

实例如下：

48304ba5e6f9fe08f3fa1abda7d326ab.png

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())

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

程序输出结果：

方式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: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关联。

例子：

48304ba5e6f9fe08f3fa1abda7d326ab.png

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

...

tx, err := db.Begin()

...

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

48304ba5e6f9fe08f3fa1abda7d326ab.png

(7)源码中Stmt的定义

48304ba5e6f9fe08f3fa1abda7d326ab.png

// 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

}

48304ba5e6f9fe08f3fa1abda7d326ab.png

(7)几个主要struct的内部主要的数据结构

db9a3c3f99278cefcb29c2f0a074bbac.png

参考资料

王小度
关注
golang mysql escape_关于golang使用mysql以及docker的一些坑-Go语言中文社区
weixin_42566072的博客
01-21 401
grant 普通数据用户，查询、插入、更新、删除 数据库中所有表数据的权利。grant select on testdb.* to common_user@’%’grant insert on testdb.* to common_user@’%’grant update on testdb.* to common_user@’%’grant delete on testdb.* to commo...
golang mysql并发_golang: orm mysql 连接池
weixin_39612877的博客
01-19 321
go配置mysql连接池max-connections=100001.ab 发起并发请求测试-c: 并发量100-n: 总请求量300➜ ~ ab -c 100 -n 300 "http://localhost:8080/pool"This is ApacheBench, Version 2.3 Copyright 1996 Adam Twiss, Zeus Technology Ltd, ht...
apache mysql go_golang实现MySQL预处理的方法
weixin_36116008的博客
01-26 146
golang实现MySQL预处理的方法发布时间：2020-07-03 09:42:28来源：亿速云阅读：149作者：Leah这篇文章运用简单易懂的例子给大家介绍golang实现MySQL预处理的方法，代码非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。预处理预处理是 MySQL 为了防止客户端频繁请求的一种技术，是对相同处理语句进行预先加载在 MySQL 中，将操作变量数据用占位符来...
Apache Thrift Golang 实践
Stefan的博客
04-23 477
Apache Thrift Golang 实践
ApacheCN Golang 译文集 20211025 更新
龙哥盟
10-26 669
Go 云原生编程 零、前言 一、现代微服务架构 二、使用 RESTAPI 构建微服务 三、保护微服务 四、使用消息队列的异步微服务架构 五、使用 React 构建前端 六、在容器中部署应用 七、AWS I——基础知识、AWS Go SDK 和 EC2 八、AWS II——S3、SQS、API 网关和 DynamoDB 九、持续交付 十、监视应用 十一、迁移 十二、从这里到哪里去？ Go 分布式计算 零、前言 一、Go 开发环境 二、理解 Goroutines 三、通道和信息 四、RESTful W.
使用Apache Kafka的Golang实践指南
最新发布
csjds的专栏
03-08 1545
通过将这两种技术结合起来，您可以快速构建下一代云原生世界的实时应用程序。所以，今天就开始用Golang和Kafka构建您的流处理管道吧！
Golang使用Apache PLC4X连接modbus
yinjl123456的博客
09-22 1305
工业的可编程逻辑控制器（PLC）大多采用大量不兼容的协议进行通信，因此和外界（IT/互联网）的交互变得很困难。PLC4X 项目致力于提供一组统一的 API，通过这些 API 实现能与大多数 PLC 进行通信的驱动程序（通过各种 PLC 的原生通信协议）。Apache PLC4X 是一个工业物联网通用协议适配器，PLC4X 是一组库，用于使用各种协议与工业可编程逻辑控制器 (PLC) 进行通信，但这些协议具有共享的 API。
golang odbc mysql_golang使用odbc链接hive
weixin_33258222的博客
01-20 444
golang使用odbc链接hive安装odbcyum install unixODBCyum install unixODBC-devel## mysql driver requireyum install mysql-connector-odbc## hive driver require## https://cwiki.apache.org/confluence/display/Hive/H...
golang mysql web_Golang-Web(连接Mysql)
weixin_34761438的博客
02-23 294
Golang-Web(连接Mysql)Golang-Web(连接Mysql)一.驱动包简介驱动包:任何编程语言想要连接数据库必须由数据库生产厂商提供了统一数据库调用而开发的内容Golang的MySQL驱动包可以在github中下载到http://github.com/go-sql-driver/mysql二.go getgo get命令可以远程下载指定内容,支持gitgithub要求下载内容必须通...
leetcode分类-learning-golang::memo:Go学习之路
06-30
Golang 知识清单 基础 变量 常量 类型 函数 包 数组 切片 指针 结构 方法 接口 协程 信道 缓冲区 选择 互斥锁 延迟 错误 异常 恢复 text image compress container crypto encoding unicode io net sync bytes os ...
如何通过Apache运行GO语言的WEB应用
weixin_34334744的博客
08-29 707
为什么80%的码农都做不了架构师？>>> ...
Golang适合高并发场景的原因分析
热门推荐
蝈蝈俊.net
06-01 8万+
典型的两个现实案例： 我们先看两个用Go做消息推送的案例实际处理能力。 360消息推送的数据： 16台机器，标配：24个硬件线程，64GB内存 Linux Kernel 2.6.32 x86_64 单机80万并发连接，load 0.2~0.4，CPU 总使用率 7%~10%，内存占用20GB (res) 目前接入的产品约1280万在线用户 2分钟一次GC，停顿2
Caddy，一个用Go实现的Web Server | 比Apache速度快，比Nginx有个性
YunWisdom
08-05 4765
Caddy，一个用Go实现的Web Server | 比Apache速度快，比Nginx有个性 作者介绍 Tony Bai：C程序员，供职于国内某大型软件公司。喜技术，爱钻研；热爱开源，曾先后贡献了lcut、cbehave、buildc等多个工具框架；喜好写博客，写博九年，仍孜孜不倦。 个人blog：http://tonybai.com/ 正文 这是一个Web Server的...
Golang 项目部署实战
GeekDavis 的博客
03-03 1万+
一直认为不懂部署的开发工程师不是好的开发工程师，以下以一些实例讲解自己在项目中的 Golang 后端部署的情况。 一般部署脚本应该具有构建、启动、停止、回滚已经查看记录日志等功能，以下分别将这些功能以单个脚本的形式给出，当然也可以写成Makefile 的形式。 单个部署脚本的形式，在一个目录下建立如下文件： bin # 目录，用于存放每次 build 之后存放的二进制文件 app.log #...
go beego在apache服务器上域名配置 --小丑
Yan 小铁匠
03-20 1115
1. apache 配置 Apache还要加载两个模块： 在/etc/httpd/conf/httpd.conf 配置 LoadModule proxy_module modules/mod_proxy.so LoadModule proxy_http_module modules/mod_proxy_http.so 2. 然后添加端口号 NameVirtualHost *:80 <Vi...
GoLang之搭建Web服务器
delphiwcdj的专栏
02-05 1万+
2014-02-05 wcdj 0 摘要 之前总结过如何使用Perl搭建Web服务《Web服务器的实现（最小的Perl Web服务器）》。本文介绍如何使用GoLang搭建Web服务，Go语言提供了一个完善的net/http包，通过这个http包可以很方便搭建一个可以运行的Web服务，同时使用这个包能很简单地对Web的路由，静态文件，模板，Cookie等数据进行设置和操作。
Go Web应用部署到Apache的配置
weixin_33928137的博客
01-15 649
2019独角兽企业重金招聘Python工程师标准>>> ...
Beego官方教程：Go语言Web开发指南
"Beego官方学习参考资料v2.pdf" 是一份关于Go语言Web开发框架Beego的详细教程，由刘东城整理。这份PDF涵盖了从基础到进阶的各种主题，适合Go开发者学习如何使用Beego构建Web应用。 1. **Beego简介** Beego是一个用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值