Go语言(Golang)数据库编程

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

创建目录

➜ 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

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/[email protected]

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 
➜ 

热门相关:首席的独宠新娘   战神   战神   学霸女神超给力