Go语言数据库编程实战：从连接到CRUD，轻松搞定数据操作！

数据库是现代应用开发的核心组件之一，而Go语言凭借其高效、简洁的特性，成为越来越多开发者的首选。无论是构建Web应用、微服务还是数据处理工具，掌握Go语言与数据库的交互技能都至关重要。本文将带您从零开始，逐步深入Go语言数据库编程的世界，涵盖从数据库连接到CRUD操作的完整流程。通过清晰的代码示例和详细的讲解，您将学会如何高效地操作SQL Server、MySQL等常见数据库，并掌握在实际项目中应用这些技能的方法。

本文系统介绍了Go语言中数据库编程的核心技术。首先，详细讲解了如何连接数据库，包括加载驱动、使用sql.Open()建立连接以及管理连接池。接着，深入探讨了CRUD操作的实现方法，包括单行查询、多行查询、数据插入、更新和删除。通过丰富的代码示例，本文展示了如何操作SQL Server和MySQL数据库，并提供了常见问题的解决方案。此外，文章还涵盖了事务处理、连接池优化等高级主题，帮助开发者进一步提升数据库操作的效率与可靠性。无论是初学者还是有经验的开发者，都能从本文中获得实用的知识与技巧。

一、Go 数据库编程之连接数据库

准备连接到数据库

• 要想连接到 SQL 数据库，首先需要加载目标数据库的驱动，驱动里面包含着于该数据库交互的逻辑。
• sql.Open()
• 数据库驱动的名称
• 数据源名称
• 得到一个指向 sql.DB 这个 struct 的指针
• sql.DB 是用来操作数据库的，它代表了0个或者多个底层连接的池，这些连接由sql 包来维护，sql 包会自动的创建和释放这些连接
• 它对于多个 goroutine 并发的使用是安全的

package main

import (
  "context"
  "database/sql"
  "fmt"
  "log"

  _ "github.com/denisenkom/go-mssqldb"
)

var db *sql.DB

const (
  server = "xxxx.database.windows.net"
  port = 1433
  user = "xxxxx"
  password = "xxxxx"
  database = "go-db"
)

func main() {
  connStr := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=%s;",
                        server, user, password, port, database)

  db, err := sql.Open("sqlserver", connStr)
  if err != nil {
    log.Fataln(err.Error())
  }

  ctx := context.Background()

  err = db.PingContext(ctx)
  if err != nil {
    log.Fataln(err.Error())
  }

  fmt.Println("Connected!")
}

Note

• Open() 函数并不会连接数据库，甚至不会验证其参数。它只是把后续连接到数据库所必需的 structs 给设置好了
• 而真正的连接是在被需要的时候才进行懒设置的
• sql.DB 不需要进行关闭（当然你想关闭也是可以的）
• 它就是用来处理数据库的，而不是实际的连接
• 这个抽象包含了数据库连接的池，而且会对此进行维护
• 在使用 sql.DB 的时候，可以定义它的全局变量进行使用，也可以将它传递到函数/方法里。

如何获得驱动

• 正常的做法是使用 sql.Register() 函数、数据库驱动的名称和一个实现了 driver.Driver 接口的 struct，来注册数据库的驱动。例如：
• sql.Register("sqlserver", &drv{})
• 但是我们之前的例子却没写这句话，为什么？
• 因为 Sql Server 的驱动，是在这个包被引入的时候进行了自我注册

驱动自动注册

• 当 go-mssqldb 包被引入的时候，它的 init 函数将会运行并进行自我注册（在 Go 语言里，每个包的 init 函数都会在自动的调用）
• 在引入 go-mssqldb 包的时候，把该包的名设置为下划线 _，这是因为我们不直接使用数据库驱动（只需要它的”副作用“），我们只使用 database/sql
• 这样，如果未来升级驱动，也无需改变代码
• Go 语言没有提供官方的数据库驱动，所有的数据库驱动都是第三方驱动，但是它们都遵循 sql.driver 包里面定义的接口

安装数据库驱动

• 这是安装 Microsoft SQL Server 数据库驱动的例子：
• go get github.com/denisenkom/go-mssqldb

func(*DB) PingContext

• 上例中的 db.PingContext() 函数是用来验证与数据库的连接是否仍然有效，如有必要则建立一个连接。
• 这个函数需要一个 Context （上下文）类型的参数，这种类型可以携带截止时间、取消信号和其它请求范围的值，并且可以横跨 API 边界和进程。
• 上例中，创建 context 使用的是 context.Background() 函数。该函数返回一个非 nil 的空 Context。它不会被取消，它没有值，没有截止时间。
• 它通常用在 main 函数、初始化或测试中，作为传入请求的顶级 Context。

Exercises

• 使用 PostgreSQL 建立数据库，使用 Go 语言进行连接，并 Ping 一下。
• 使用 SQLite 建立数据库，使用 Go 语言进行连接，并 Ping 一下。

连接MySQL

https://github.com/go-sql-driver/mysql

go get -u github.com/go-sql-driver/mysql

创建目录

```~/Code/go via 🐹 v1.20.3 via 🅒 base ➜ mcd go_sql_demo

Code/go/go_sql_demo via 🐹 v1.20.3 via 🅒 base ➜ go mod init go_sql_demo go: creating new go.mod: module go_sql_demo

Code/go/go_sql_demo via 🐹 v1.20.3 via 🅒 base ➜ c

Code/go/go_sql_demo via 🐹 v1.20.3 via 🅒 base ➜

main.go

```go
package main

import (
 "database/sql"
 "fmt"

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

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

// 定义一个初始化数据库的函数
func initDB() (err error) {
 // DSN:Data Source Name
 dsn := "root:12345678@tcp(127.0.0.1:3306)/db_xuanke?charset=utf8mb4&parseTime=True"
 // 不会校验账号密码是否正确
 // 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在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
 }
 fmt.Println("connect to database")
}

二、CRUD

查询

• sql.DB 类型上用于查询的方法有：
• Query
• QueryRow
• QueryContext
• QueryRowContext

Query

• 返回的类型是：type Rows struct {}
• Rows 的方法：
• func (rs *Rows) Close() error
• func (rs *Rows) ColumnTypes() ([]*ColumnType, error)
• func (rs *Rows) Columns() ([]string, error)
• func (rs *Rows) Err() error
• func (rs *Rows) Next() bool
• func (rs *Rows) NextResultSet() bool
• func (rs *Rows) Scan(dest ...interface{}) error

QueryRow

• 返回类型是：type Row struct {}
• Row 的方法有：
• func (r *Row) Err() error
• func (r *Row) Scan(dest ...interface{}) error

https://pkg.go.dev/database/sql@go1.20.4

services.go 文件

package main

func getOne(id int) (a app, err error) {
  a = app{}
  log.Println(db == nil)
  err = db.QueryRow("SELECT Id, Name, Status, Level, [Order] FROM dbo.App WHERE Id=@Id",     sql.Named("Id", id)).Scan(
    &a.ID, &a.name, &a.status, &a.level, &a.order)
  return
}

func getMany(id int) (apps []app, err error) {
  rows, err = db.Query("SELECT Id, Name, Status, Level, [Order] FROM dbo.App WHERE Id>@Id",     sql.Named("Id", id))
  for rows.Next() {
    a := app{}
    err = rows.Scan(&a.ID, &a.name, &a.status, &a.level, &a.order)
    if err != nil {
      log.Fatalln(err.Error())
    }
    apps = append(apps, a)
  }
  return
}

models.go 文件

package main

type app struct {
  ID int
  name string
  status int
  level int
  order int
}

main.go 文件

package main

import (
  "context"
  "database/sql"
  "fmt"
  "log"

  _ "github.com/denisenkom/go-mssqldb"
)

var db *sql.DB

const (
  server = "xxxx.database.windows.net"
  port = 1433
  user = "xxxxx"
  password = "xxxxx"
  database = "go-db"
)

func main() {
  connStr := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=%s;",
                        server, user, password, port, database)

  var err error
  db, err = sql.Open("sqlserver", connStr)
  if err != nil {
    log.Fataln(err.Error())
  }

  ctx := context.Background()

  err = db.PingContext(ctx)
  if err != nil {
    log.Fataln(err.Error())
  }

  fmt.Println("Connected!")

  log.Println(db == nil)
  // 查询一笔
  one, err := getOne(103)
  if err != nil {
    log.Fatal(err.Error())
  }
  fmt.Println(one)

  apps, err := getMany(103)
  if err != nil {
    log.Fatalln(err.Error())
  }

  fmt.Println(apps)
}

更新

• sql.DB 类型上用于更新（执行命令）的方法有：
• Exec
• ExecContext

services.go 文件

func (a *app) Update() (err error) {
  _, err = db.Exec("UPDATE dbo.App SET Name=@Name, [Order]=@Order WHERE Id=@Id",
        sql.Named("Name", a.name), sql.Named("Order", a.order), sql.Named("Id", a.ID))
  if err != nil {
    log.Fatalln(err.Error())
  }
  return
}

main.go 文件

a, _ := getOne(103)
fmt.Println(a)
a.name += " 1234"
a.order++

err = a.Update()
if err != nil {
  log.Fatalln(err.Error())
}
a1, _ := getOne(103)
fmt.Println(a1)

删除

services.go 文件

func (a *app) Delete() (err error) {
  _, err = db.Exec("DELETE FROM dbo.App WHERE Id=@Id", sql.Named("Id", a.ID))
  if err != nil {
    log.Fatalln(err.Error())
  }
  return
}

其它

• Ping
• PingContext
• Prepare
• PrepareContext
• Transactions
• Begin
• Begin Tx

services.go 文件

func (a *app) Insert() (err error) {
  statement := `INSERT INTO dbo.App
  (Name, NickName, Status, Level, [Order], Pinyin) 
  VALUES (@Name, 'Nick', &Status, @Level, @Order, '...');
  SELEÇT isNull(SCOPE_IDENTITY(), -1);`
  stmt, err := db.Prepare(statement)
  if err ！= nil {
    log.Fatalln(err.Error())
  }
  defer stmt.Close()
  err = stmt.QueryRow(
    sql.Named("Name", a.name), sql.Named("Status", a.status), 
    sql.Named("Level", a.level),
    sql.Named("Order", a.order)).Scan(&a.ID)

  if err != nil {
    log.Fatalln(err.Error())
  }

  return
}

main.go 文件

a := app {
  name: "Test",
  order: 1123,
  level: 10,
  status: 1,
}

err = a.Insert()
if err != nil {
  log.Fatalln(err.Error())
}

one, _ := getOne(a.ID)
fmt.Println(one)

三、MySQL CRUD 实践

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

mysql> create database sql_test;
Query OK, 1 row affected (0.01 sec)

mysql> use sql_test;
Database changed
mysql> 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;
Query OK, 0 rows affected, 2 warnings (0.02 sec)

mysql> show tables;
+--------------------+
| Tables_in_sql_test |
+--------------------+
| user               |
+--------------------+
1 row in set (0.01 sec)

mysql>

main.go 文件

package main

import (
 "database/sql"
 "fmt"

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

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

// 定义一个初始化数据库的函数
func initDB() (err error) {
 // DSN:Data Source Name
 dsn := "root:12345678@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parseTime=True"
 // 不会校验账号密码是否正确
 // 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在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
 }
 fmt.Println("connect to database")

 // one, err := queryRowDemo(1)
 // if err != nil {
 //  log.Fatal(err.Error())
 // }
 // fmt.Println(one)

 // u := user{
 //  name: "小乔1",
 //  age:  13,
 //  id:   0,
 // }
 // err = u.insertRowDemo()
 // if err != nil {
 //  log.Fatalln(err.Error())
 // }

 // u, _ := queryRowDemo(1)
 // fmt.Println("u:", u)
 // u.name = "貂蝉"
 // u.age = 16

 // err = u.updateRowDemo()
 // if err != nil {
 //  log.Fatalln(err.Error())
 // }

 // u1, _ := queryRowDemo(1)
 // fmt.Println("u1:", u1)

 last_row, _ := queryMultiRowDemo(0)
 fmt.Println("last_row:", last_row)

 // var u = new(user)
 // u.id = 3
 // err = u.deleteRowDemo()
 // if err != nil {
 //  log.Fatalln(err.Error())
 // }
}

services.go 文件

package main

import (
 "fmt"
)

// 查询单条数据示例
func queryRowDemo(id int) (u user, err error) {
 sqlStr := "select id, name, age from user where id=?"
 // 非常重要：确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
 err = db.QueryRow(sqlStr, id).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)
 return
}

// 查询多条数据示例
func queryMultiRowDemo(id int) (u user, err error) {
 sqlStr := "select id, name, age from user where id > ?"
 rows, err := db.Query(sqlStr, id)
 if err != nil {
  fmt.Printf("query failed, err:%v\n", err)
  return
 }
 // 非常重要：关闭rows释放持有的数据库链接
 defer rows.Close()
 // 循环读取结果集中的数据
 for rows.Next() {
  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)
 }
 return
}

// 插入数据
func (u *user) insertRowDemo() (err error) {
 sqlStr := "insert into user(name, age) values (?,?)"
 ret, err := db.Exec(sqlStr, u.name, u.age)
 if err != nil {
  fmt.Printf("insert failed, err:%v\n", err)
  return
 }
 theID, 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", theID)
 return
}

// 更新数据
func (u *user) updateRowDemo() (err error) {
 sqlStr := "update user set age=? where id = ?"
 ret, err := db.Exec(sqlStr, u.age, u.id)
 if err != nil {
  fmt.Printf("update failed, err:%v\n", err)
  return
 }
 n, err := ret.RowsAffected() // 操作影响的行数
 if err != nil {
  fmt.Printf("get RowsAffected failed, err:%v\n", err)
  return
 }
 fmt.Printf("update success, affected rows:%d\n", n)
 return
}

// 删除数据
func (u *user) deleteRowDemo() (err error) {
 sqlStr := "delete from user where id = ?"
 ret, err := db.Exec(sqlStr, u.id)
 if err != nil {
  fmt.Printf("delete failed, err:%v\n", err)
  return
 }
 n, err := ret.RowsAffected() // 操作影响的行数
 if err != nil {
  fmt.Printf("get RowsAffected failed, err:%v\n", err)
  return
 }
 fmt.Printf("delete success, affected rows:%d\n", n)
 return
}

models.go 文件

package main

type user struct {
 id   int
 age  int
 name string
}

运行

Code/go/go_sql_demo via 🐹 v1.20.3 via 🅒 base 
➜ go build . && ./go_sql_demo
connect to database
id:1 name:小乔 age:16
id:2 name:小乔 age:12
last_row: {2 12 小乔}

Code/go/go_sql_demo via 🐹 v1.20.3 via 🅒 base took 3.3s 
➜ 

总结

通过本文的学习，您已经掌握了Go语言中数据库编程的核心技能，包括如何连接数据库、执行CRUD操作以及管理连接池。无论是操作SQL Server还是MySQL，本文提供的代码示例和详细讲解都能帮助您快速上手。此外，文章还介绍了事务处理、连接池优化等高级技术，为您在实际项目中应对复杂场景提供了有力支持。希望本文能成为您Go语言数据库编程的实用指南，助您在开发中更加得心应手。