Golang操作MySQL

最新推荐文章于 2024-02-14 23:44:26 发布
最新推荐文章于 2024-02-14 23:44:26 发布
阅读量374 收藏 1
点赞数 1
分类专栏： Mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36867807/article/details/115206604
版权
1.连接

Go语言中的database/sql包提供了保证SQL或类SQL数据库的泛用接口，并不提供具体的数据库驱动。使用database/sql包时必须注入（至少）一个数据库驱动。

我们常用的数据库基本上都有完整的第三方实现。

1.下载依赖
go get -u github.com/go-sql-driver/mysql

func Open(driverName, dataSourceName string) (*DB, error)

Open打开一个dirverName指定的数据库，dataSourceName指定数据源，一般至少包括数据库文件名和其它连接必要的信息。

import (
	"database/sql"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
   // DSN:Data Source Name
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname"     //user填数据库用户名，password填数据库密码，daname填要连接的数据库名
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		panic(err)
	}
	defer db.Close()  // 注意这行代码要写在上面err判断的下面
}

sql包内置的Open方法，第一个参数传入数据库类型名，实际上github引入的sql驱动包中init ()函数注册了，我们才能使用。在这里插入图片描述
第二个参数传入数据库相关的信息，只进行格式校验，不进行数据校验。

返回了一个DB数据库对象。db.Ping()可进行链接，验证数据库配置是否正确。在这里插入图片描述

2.初始化连接

Open函数可能只是验证其参数格式是否正确，实际上并不创建与数据库的连接。如果要检查数据源的名称是否真实有效，应该调用Ping方法。

返回的DB对象可以安全地被多个goroutine并发使用，并且维护其自己的空闲连接池。因此，Open函数应该仅被调用一次，很少需要关闭这个DB对象。

// 定义一个全局对象db
var db *sql.DB

// 定义一个初始化数据库的函数
func initDB() (err error) {
	// DSN:Data Source Name
		dsn := "root:123456@tcp(127.0.0.1:3306)/test"
	// 不会校验账号密码是否正确
	// 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
	db, err = sql.Open("mysql", dsn)
	if err != nil {
		return err
	}
	// 尝试与数据库建立连接（校验dsn是否正确）
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil
}

func main() {
	err := initDB() // 调用输出化数据库的函数
	if err != nil {
		fmt.Printf("init db failed,err:%v\n", err)
		return
	}
}

其中sql.DB是表示连接的数据库对象（结构体实例），它保存了连接数据库相关的所有信息。它内部维护着一个具有零到多个底层连接的连接池，它可以安全地被多个goroutine同时使用。

3.SetMaxOpenConns

SetMaxOpenConns设置与数据库建立连接的最大数目。 如果n大于0且小于最大闲置连接数，会将最大闲置连接数减小到匹配最大开启连接数的限制。 如果n<=0，不会限制最大开启连接数，默认为0（无限制）。

2.CURD
1.建库建表

先在MySQL中创建一个名为test的数据库

CREATE DATABASE test;

进入该数据库:

use test;

执行以下命令创建一张用于测试的数据表：

CREATE TABLE `user` (
    `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
    `name` VARCHAR(20) DEFAULT '',
    `age` INT(11) DEFAULT '0',
    PRIMARY KEY(`id`)
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;
2.查询

为了方便查询，我们事先定义好一个结构体来存储user表的数据。

type user struct {
	id   int
	age  int
	name string
}

单行查询

单行查询db.QueryRow()执行一次查询，并期望返回最多一行结果（即Row）。QueryRow总是返回非nil的值，直到返回值的Scan方法被调用时，才会返回被延迟的错误。（如：未找到结果）

func (db *DB) QueryRow(query string, args ...interface{}) *Row

数据库信息如下：在这里插入图片描述
查询代码：

func query(param int )  {
   var u user
   //1.写SQL语句
   sqlStr := "select id,name ,age from user where id=?"
   //执行SQL,查询单行数据,根据sql语句的顺序赋值
   rowObj  :=db.QueryRow(sqlStr,param)
   err :=rowObj.Scan(&u.id,&u.name,&u.age)           
   if err != nil {
      fmt.Printf("query failed,err:%v\n", err)
      return
   }
   fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}

多行查询

多行查询db.Query()执行一次查询，返回多行结果（即Rows），一般用于执行select命令。参数args表示query中的占位参数。

func (db *DB) Query(query string, args ...interface{}) (*Rows, error)

具体示例代码：

// 查询多条数据示例
func queryMultiRowDemo() {
	sqlStr := "select id, name, age from user where id > ?"
	rows, err := db.Query(sqlStr, 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return
	}
	// 非常重要：关闭rows释放持有的数据库链接
	defer rows.Close()

	// 循环读取结果集中的数据
	for rows.Next() {                    
		var u user
		err := rows.Scan(&u.id, &u.name, &u.age)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return
		}
		fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
	}
}
3.插入数据

插入、更新和删除操作都使用Exec方法。

func (db *DB) Exec(query string, args ...interface{}) (Result, error)

Exec执行一次命令（包括查询、删除、更新、插入等），返回的Result是对已执行的SQL命令的总结。参数args表示query中的占位参数。

具体插入数据示例代码如下：

func Insert(name string, age int)  {
   sqlStr := `insert into user(name,age) values(?,?)`
   ret,err:=db3.Exec(sqlStr,name,age)
   if err != nil {
      fmt.Printf("insert failed, err:%v\n", err)
      return
   } 
   Id, err := ret.LastInsertId()                 新插入数据的id
   if err != nil {
      fmt.Printf("get lastinsert ID failed, err:%v\n", err)
      return
   }
   fmt.Printf("insert success, the id is %d.\n", Id)
}

在这里插入图片描述
插入时 ， ret.LastInsertId() 返回插入行号

更新，删除时，ret.RowsAffected() 返回影响的行数

3.更新数据
func update(id int,name string ,age int)  {
   sqlStr := `update user set name=?,age=? where id=? `
   ret ,err :=db3.Exec(sqlStr,name,age,id)
   if err != nil {
      fmt.Printf("update failed, err:%v\n", err)
      return
   }
   n, err :=ret.RowsAffected()                         // 操作影响的行数
   if err != nil {
      fmt.Printf("ret.RowsAffected( failed, err:%v\n", err)
      return
   }
   fmt.Printf("update success, Affected roes is %d.\n", n)
}
4.删除数据
func Delete(id int)  {
   sqlStr := `delete from user where id=?`
   ret ,err :=db3.Exec(sqlStr,id)
   if err != nil {
      fmt.Printf("Delete failed, err:%v\n", err)
      return
   }
   n, err :=ret.RowsAffected()						// 操作影响的行数
   if err != nil {
      fmt.Printf("ret.RowsAffected( failed, err:%v\n", err)
      return
   }
   fmt.Printf("Delete success, Affected roes is %d.\n", n)
}
3.Mysql预处理

什么是预处理？

普通SQL语句执行过程：

  1. 客户端对SQL语句进行占位符替换得到完整的SQL语句。
  2. 客户端发送完整SQL语句到MySQL服务端
  3. MySQL服务端执行完整的SQL语句并将结果返回给客户端。

预处理执行过程：

  1. 把SQL语句分成两部分，命令部分与数据部分。
  2. 先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理。
  3. 然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换。
  4. MySQL服务端执行完整的SQL语句并将结果返回给客户端。

为什么要预处理？

  1. 优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。
  2. 避免SQL注入问题。
1.Go实现MySQL预处理

database/sql中使用下面的Prepare方法来实现预处理操作。

func (db *DB) Prepare(query string) (*Stmt, error)

Prepare方法会先将sql语句发送给MySQL服务端，返回一个准备好的状态用于之后的查询和命令。返回值可以同时执行多个查询和命令。

查询操作的预处理示例代码如下：

func prepareQueryDemo()  {
   sqlStr := "select id, name, age from user where id > ?"
   stmt, err := db.Prepare(sqlStr)
   if err != nil {
      fmt.Printf("prepare failed, err:%v\n", err)
      return
   }
   defer stmt.Close()
   rows, err := stmt.Query(0)
   if err != nil {
      fmt.Printf("query failed, err:%v\n", err)
      return
   }
   defer rows.Close()
   for rows.Next(){
      var u user
      err := rows.Scan(&u.id, &u.name, &u.age)
      if err != nil {
         fmt.Printf("scan failed, err:%v\n", err)
         return
      }
      fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
   }
}

插入、更新和删除操作的预处理十分类似，这里以插入操作的预处理为例：

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

var db *sql.DB

func prepareInsertDemo()  {
   sqlStr := `insert into user(name,age) values(?,?)`
   stmt ,err := db.Prepare(sqlStr)                           //返回对象
   if err != nil {
      fmt.Printf("prepare failed, err:%v\n", err)
      return
   }
   start := time.Now()
   for i:=0;i<300 ;i++  {
      _, err := stmt.Exec("guo",i)
      if err != nil {
         fmt.Printf("insert failed, err:%v\n", err)
         return
      }
   }
   fmt.Println(time.Since(start))                           //404.6629ms
}

func main()  {
   var err error
   db, err = mysqlInit.InitDB()
   if err != nil {
      fmt.Printf("connected mysql failed, err:%v\n", err)
      return
   }
   prepareInsertDemo()
}

对比原生的每次执行SQL语句

func prepareInsertDemo()  {
   sqlStr := `insert into user(name,age) values(?,?)`
   start := time.Now()
   for i:=0;i<300 ;i++  {
      _, err := db.Exec(sqlStr,"guo",i)
      if err != nil {
         fmt.Printf("insert failed, err:%v\n", err)           
         return
      }
   }
   fmt.Println(time.Since(start))                    //435.3734ms
}

时间上效率高了一点

2.Go实现MySQL事务

什么是事务？

事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元)，同时这个完整的业务需要执行多次的DML(insert、update、delete)语句共同联合完成。A转账给B，这里面就需要执行两次update操作。

在MySQL中只有使用了Innodb数据库引擎的数据库或表才支持事务。事务处理可以用来维护数据库的完整性，保证成批的SQL语句要么全部执行，要么全部不执行。

1.事务相关方法

Go语言中使用以下三个方法实现MySQL中的事务操作。 开始事务

func (db *DB) Begin() (*Tx, error)

提交事务

func (tx *Tx) Commit() error

回滚事务

func (tx *Tx) Rollback() error
2.事务示例

下面的代码演示了一个简单的事务操作，该事物操作能够确保两次更新操作要么同时成功要么同时失败，不会存在中间状态。

import (
   "database/sql"
   "fmt"
   _ "github.com/go-sql-driver/mysql"
   "test/mysql/test/mysqlInit"
)
var db *sql.DB

// 事务操作示例
func transactionDemo() {
   tx, err := db.Begin() // 开启事务
   if err != nil {
      if tx != nil {
         tx.Rollback() // 回滚
      }
      fmt.Printf("begin trans failed, err:%v\n", err)
      return
   }
   sqlStr1 := "Update user set age=age+2 where id=?"
   ret1, err := tx.Exec(sqlStr1, 1)
   if err != nil {
      tx.Rollback() // 回滚
      fmt.Printf("exec sql1 failed, err:%v\n", err)
      return
   }
   affRow1, err := ret1.RowsAffected()
   if err != nil || affRow1 ==0 {
      tx.Rollback() // 回滚
      fmt.Printf("exec ret1.RowsAffected() failed, err:%v\n", err)
      return
   }

   sqlStr2 := "Update user set age=age-2 where id=?"
   ret2, err := tx.Exec(sqlStr2, 3)
   if err != nil {
      tx.Rollback() // 回滚
      fmt.Printf("exec sql2 failed, err:%v\n", err)
      return
   }
   affRow2, err := ret2.RowsAffected()
   if err != nil || affRow2 ==0 {
      tx.Rollback() // 回滚
      fmt.Printf("exec ret1.RowsAffected() failed, err:%v\n", err)
      return
   }

   fmt.Println(affRow1, affRow2)
   if affRow1 == 1 && affRow2 == 1 {
      fmt.Println("事务提交啦...")
      tx.Commit() // 提交事务
   } else {
      tx.Rollback()
      fmt.Println("事务回滚啦...")
   }

   fmt.Println("exec trans success!")
}


func main()  {
   var err error
   db, err = mysqlInit.InitDB()
   if err != nil {
      fmt.Printf("connected mysql failed, err:%v\n", err)
      return
   }
   transactionDemo()
}
3.SQL注入

我们任何时候都不应该自己拼接SQL语句！

这里我们演示一个自行拼接SQL语句的示例，编写一个根据name字段查询user表的函数如下：

package main

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

type User struct {
   id   int
   name string
   age  int
}
var db *sql.DB

func InjectDemo(name string)  {
   sqlStr := fmt.Sprintf("select id, name, age from user where name='%s'", name)
   
   fmt.Printf("SQL:%s\n", sqlStr)
   // select id, name, age from user where name='xxx' or 1=1#'
   
   rows,err :=db.Query(sqlStr)
   if err != nil {
      fmt.Printf("query failed, err:%v\n", err)
      return
   }
   defer rows.Close() //千万记得放回连接池
   for rows.Next(){
      var u User
      err := rows.Scan(&u.id,&u.name,&u.age)
      if err != nil {
         fmt.Printf("scan failed, err:%v\n", err)
         return
      }
      fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
   }
}

func main()  {
   var err error
   db ,err = mysqlInit.InitDB()             //工具包下载驱动
   if err != nil {
      fmt.Printf("query failed, err:%v\n", err)
      return
   }
   InjectDemo("xxx' or 1=1#")
}

select id, name, age from user where name=’ ’ //等待用户输入name

然后输入 xxx’ or 1=1#

成为select id, name, age from user where name=‘xxx’ or 1=1# ’

恶意拼接，查询不到xxx这个name,而后1=1 恒成立。 #代表注释，后面的内容无效。 造成整个数据库全部输出

清秋-
关注
专栏目录
Go语言学习笔记—golang操作MySQL数据库
qq_39280718的博客
08-05 2049
golang操作MySQL数据库
Golang 操作Mysql个人总结
HuAnGsx1n的博客
05-08 667
Golang 操作Mysql总结 前言： 此文写在刚起步学习Golang，目前刚看到Go/mysql 这一块，初步使用后，发现了一些小坑，记录一下，以免日后再次在这一块踩坑了。学习文章参考于Go语言学习之路|李文周的博客，这一篇博客写的非常好，十分适合初步学习Go或者刚转型Go的朋友进行学习。 本地环境 本地计算机环境的GOPATH为 E:\GoProjects，可以在Goland的settin...
go 语言 mysql_Go语言操作mysql数据库简单例子
weixin_42129797的博客
01-18 77
package mainimport ("database/sql"_ "github.com/go-sql-driver/mysql""log""time")/*create table t(id int primary key auto_increment,name varchar(20) not null,ts timestamp);*/func insert(db *sql.DB) {st...
GO-操作数据库
逍遥云恋
04-06 709
第 4 章：操作数据库 Go 语言中的 database/sql 包定义了对数据库的一系列操作。database/sql/driver包定义了应被数据库驱动实现的接口，这些接口会被 sql 包使用。但是 Go 语言没有提供任何官方的数据库驱动，所以我们需要导入第三方的数据库驱动。不过我们连接数据库之后对数据库操作的大部分代码都使用 sql 包。 4.1 获取数据库连接 创建一个 db.go 文件...
Go语言操作数据库
weixin_45151033的博客
09-16 2462
Go语言操作数据库
go 操作数据库
lucky404的博客
07-12 926
go 操作数据库需要下载各个数据库的驱动下面以关系型数据库mysql 和非关系型数据库redis 为例子讲解一下go 如何与数据库交互 下载数据库驱动 mysql : go get github.com/go-sql-driver/mysql redis: go get github.com/garyburd/redigo/redis 连接mysql 代码demo packa...
在golang中操作mysql数据库的实现代码
12-16
前言 Golang 提供了database/sql包用于对SQL数据库的访问, 作为操作数据库的入口对象sql.DB, 主要为我们提供了两个重要的功能: •sql.DB 通过数据库驱动为我们提供管理底层数据库连接的打开和...Golang操作mysql数据库
golang mysql 事务_golang 操作mysql示例（增、删、改、查、事务）
weixin_42361026的博客
01-19 651
准备go的系统包里是没有数据库驱动的，首先先从git上下载mysql包，golang下载资源包相当方便，打开命令行，输入命令：go get -u github.com/go-sql-driver/mysql (使用git命令下载资源包，需要先安装git，没安装git的同学可以手动下载后放入src目录下)。!下载完成会在GOPATH下的src里多了资源包下载完成后，在项目里import mysql包...
golang实现mysql数据库备份的操作方法
09-09
在本文中，我们将深入探讨如何使用Golang实现MySQL数据库的备份操作。首先，我们需要了解为什么要进行数据库备份，特别是在处理视图及其依赖关系时所遇到的问题。Navicat作为一款常用的MySQL可视化工具，虽然强大，...
Go操作数据库
littlexiaoshuishui的博客
06-01 848
go提供了一些标准库让我们和数据库交互， database/sql是golang的标准库之一，它提供了一系列接口方法，用于访问关系数据库。 不同的数据库驱动，需要去实现各种方法 func main(){ db,err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/htadmin") } 此时会报错，说mysql 驱动不存在。安装mysql驱动 go get github.com/go-sql-driver/mysql --------
golang学习之旅：使用go语言操作mysql数据库
weixin_30881367的博客
05-06 432
1.下载并导入数据库驱动包 官方不提供实现，先下载第三方的实现，点击这里查看各种各样的实现版本。这里选择了Go-MySQL-Driver这个实现。地址是：https://github.com/go-sql-driver/mysql/。 然后按照里面的说明下载驱动包： $ go get github.com/go-sql-driver/mysql 最后导入包即可： import "data...
Golang数据库操作
霁云的专栏
01-02 6234
Golang对于数据库操作的基本支持
Go语言中使用MySql数据库
a616735104的博客
12-06 170
Go语言中使用MySql数据库 1、MySQL驱动 Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: https://github.com/Go-SQL-Driver/MySQL 支持database/sql，全部采用go写。 https://github.com/ziutek/mymy...
Go语言常见数据库操作
最新发布
qq_63730529的博客
02-14 1067
客户端对SQL语句进行占位符替换得到完整的SQL语句。客户端发送完整SQL语句到MySQL服务端MySQL服务端执行完整的SQL语句并将结果返回给客户端。把SQL语句分成两部分，命令部分与数据部分。先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理。然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换。MySQL服务端执行完整的SQL语句并将结果返回给客户端。
Go数据库操作：使用Go访问和操作数据库
程序员光剑
01-28 1154
1.背景介绍 1. 背景介绍 Go数据库操作是一项重要的技能，它涉及到Go语言与数据库之间的交互。Go语言是一种现代编程语言，它具有高性能、简洁的语法和强大的并发能力。数据库是存储和管理数据的系统，它在现代应用中扮演着关键角色。 在本文中，我们将讨论如何使用Go语言访问和操作数据库。我们将涵盖Go数据库操作的核心概念、算法原理、最佳实践以及实际应用场景。 2. 核心概念与联系 在Go数据...
go数据库操作
Linux痞子
06-06 1123
package mainimport ( "database/sql" _ "github.com/go-sql-driver/mysql" )func main() { /* //打开数据库 db, err := sql.Open("mysql", "root:12
Go语言的数据库操作：MySQL和Redis
程序员光剑
01-25 658
1.背景介绍 1. 背景介绍 Go语言(Golang)是Google开发的一种静态类型、垃圾回收的编程语言。Go语言的设计目标是简单、高效、可扩展和易于使用。Go语言的标准库提供了对数据库操作的支持，包括MySQL和Redis等。 MySQL是一种关系型数据库管理系统，是最受欢迎的开源关系型数据库之一。Redis是一种高性能的键值存储系统，是NoSQL数据库的一种。Go语言的数据库操作可以通...
Go——数据库的基本操作
庄小焱
01-04 2460
摘要 本博文主要是介绍go对数据库的基本的操作。这里以mysql为例子。介绍的数据库的连接与断开。数据的增删改查的相关基础操作。 一、安装依赖 go官方没有实现Mysql的数据库驱动，database/sql包提供了保证SQL或类SQL数据库的泛用接口，并不提供具体的数据库驱动。本文章实用的数据库驱动是Go MysqlDriver。安装依赖code： go get -u github.com/go-sql-driver/mysql 二、数据库的连接 package main impor.
golang操作MySQL Binlog
06-01
如果你想使用Golang操作MySQL Binlog，可以使用Go-MySQL-Binlog库。它是一个纯Go语言实现的MySQL binlog解析库，可以用来替代MySQL官方的binlog解析工具。 使用Go-MySQL-Binlog库，你可以监听MySQL服务器上的binlog...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值