go 原生提供了对数据库的支持，就是 database/sql 包，对关系型的数据库进行了通用的抽象，轻量、面向行的接口，所以使用这个包还需要下载对相应的数据库驱动，比如 mysql 的驱动包 github.com/go-sql-driver/mysql，执行:

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

由于不需要调用驱动包的含糊，只需要其执行一次 init 函数，imoprt 部分往往是:

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

不引入驱动，调用 sql 包的函数的时候会收到提示:

 sql: unknown driver "mysql" (forgotten import?)  

为什么引入 mysql 的包后就可以工作了呢? 这是因为 mysql 包里的 init 函数里执行了 sql.Register 函数:

 func init() {
  sql.Register("mysql", &MySQLDriver{})
}  

查看 Register 函数的实现，会发现内部把驱动类型和驱动实例做了一个映射保存在 drivers 中，对 MySQLDriver 来说，就是 “mysql” => &MySQLDriver{}，Register 函数的第二个参数是 driver.Driver 接口对象，它只要求实现 1 个方法:

 type Driver interface { 
  Open(name string) (Conn, error)
}  

Open 函数返回一个 driver.Conn 对象，根据注释得知该 Conn 对象在同一时间只会被一个 goroutine 所占用，通过查看 MySQLDriver 的 Open 函数发现它使用了内部的 connector 对象来实现，而 connector 对象又将功能更委托给了 mysqlConn 对象，该连接对象负责和 mysql 之间交互的协议。

sql 包使用 sql.Open 来获得一个数据库操作对象 sql.DB，而这个 DB 结构体中最重要的就是 driver.Connector，它要求实现 2 个方法:

1. Connect(context.Context) (Conn, error)

2. Driver() Driver

 func getMysqlDB() *sql.DB { 
  db, _ := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=true") 
  //db, _ := sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True") 
  //db.Ping() 
  return db
}  

问题是这个 sql.Open 里的 connector 是怎么和 mysql 驱动的 connector 连接上的呢? F12 进入 sql.Open 函数，发现它会尝试从 dirvers 获取 MySQLDriver 的实例，尝试转换成 driver.DriverContext 后调用其 OpenConnector 函数，如果转换失败了也会构造一个内部的 dsnconnector 对象，调用 driver 上的 Open 方法。

而 MySQLDriver 对 Open 和 OpenConnector 都提供了实现:

 func (d MySQLDriver) Open(dsn string) (driver.Conn, error) {
  cfg, err := ParseDSN(dsn)
  if err != nil {
    return nil, err
  }
  c := &connector{
    cfg: cfg,
  }
  return c.Connect(context.Background())
}

func (d MySQLDriver) OpenConnector(dsn string) (driver.Connector, error) {
  cfg, err := ParseDSN(dsn)
  if err != nil {
    return nil, err
  }
  return &connector{
    cfg: cfg,
  }, nil
}  

sql 包依靠 Open、Register 2 个函数实现了驱动包的注入，获得 driver.Conn 对象后，主要工作就是解析 sql 查询和获得结果了(mysql 交互协议)，因为查询通常分为 2 种类型:

1. query 查询带结果，比如 select 等

2. exec 只需执行，比如 update、delete 等

具体 sql 包在调用时会尝试把 driver.Conn 对象转换成 Queryer、QueryerContext 和 Execer、ExecerContext 执行其对应的方法，不过这一切使用 sql.DB 做为中间对象来操作，在 DB 内部它对 driver.Conn 对象做了进一层带锁的包装 driverConn，在任何查询前都会使用 db.conn 内部方法里获取 driverConn，它加锁以后从 freeConn 里取出一个并标记为 inUse 在使用，否则就检测是否达到最大连接数，没有就就调用 connector 对象的 Connect 方法获得 driver.Conn 后构造一个新的 driverConn，用完了后都会调用它的 relaseConn 把连接对象重新 put 回 freeConn 列表里。至此，go sql 驱动包的加载和执行的流程都清楚了。

mysql 的 go hello 版本如下:

 func main() { 
  var str string db := getMysqlDB() 
  row := db.QueryRow("SELECT 'hello go-mysql'") 
  if row.Scan(&str) == nil {  
    fmt.Println(str) 
  }
}  

批量查询和使用预编译的查询:

 func scan() {
  db := session.GetMysqlDB()
  rows, _ := db.Query("SELECT * FROM user")
  defer rows.Close()
  // 遍历 rows
}

func single() {
  var user User
  db := session.GetMysqlDB()
  db.QueryRow("SELECT * FROM user WHERE id = 1").Scan(&user.id, &user.passport, &user.password, &user.nickname, &user.createdAt)
  fmt.Println(user)
}

func prepare() {
  db := session.GetMysqlDB()
  stmt, _ := db.Prepare("SELECT * FROM user WHERE id = ?")
  defer stmt.Close()
  rows, _ := stmt.Query(1)
  defer rows.Close()
  //
}  

怎么遍历 rows 呢? 需要使用 Next() 来判断，当遇到 io.EOF 或者 rows 被 close 会结束遍历。

 for rows.Next() { 
  var user User 
  rows.Scan(&user.id, &user.passport, &user.password, &user.nickname, &user.createdAt) 
  fmt.Println(user)
}

// 使用 rows.Error 来得到错误  

插入时使用 LastInsertId 来获取最后一行的 id:

 func main() {
  db := session.GetMysqlDB()
  stmt, _ := db.Prepare("INSERT INTO user(`passport`, `password`,`nickname`) VALUES(?, ?, ?)")
  result, _ := stmt.Exec("lisi", "abc123", "李四")
  fmt.Println(result.LastInsertId())
}  

使用 begin 和 beginTx 开启一个事务，begin 使用默认的 context.Background() 来调用 beginTx，事务会独占数据库连接，但是 Tx 对象上的方法和 sql.DB 都是一一对应，调用 commit 或者 rollback 后，Tx 对象才被 Close 掉。

 func main() {
  db := session.GetMysqlDB()
  stmt, _ := db.Prepare("INSERT INTO user(`passport`, `password`,`nickname`) VALUES(?, ?, ?)")
  result, _ := stmt.Exec("lisi", "abc123", "李四")
  fmt.Println(result.LastInsertId())
}  

NULL 字段有时候会很麻烦，处理 NULL 有两个办法:

1. 使用数据库函数 COALESCE 让可能 NULL 的字段不可能返回 NULL

2. 使用 sql.NullString、sql.NullInt32 等类型

 type NullString struct { 
  String string 
  Valid  bool // Valid is true if String is not NULL
}  

对于第二种办法，Scan 操作后需要先用 Valid 判断一下，为 true 则调用 String 或者 Value 方法，值得注意的并没有 sql.NullUint32 等类型，可以自定义 NULL 类型，实现 Scan 和 Value 方法。比如 NullInt32 的实现如下:

 // NullInt32 represents an int32 that may be null.
// NullInt32 implements the Scanner interface so
// it can be used as a scan destination, similar to NullString.
type NullInt32 struct {
    Int32 int32
    Valid bool // Valid is true if Int32 is not NULL
}

// Scan implements the Scanner interface.
func (n *NullInt32) Scan(value interface{}) error {
    if value == nil {
        n.Int32, n.Valid = 0, false
        return nil
    }
    n.Valid = true
    return convertAssign(&n.Int32, value)
}

// Value implements the driver Valuer interface.
func (n NullInt32) Value() (driver.Value, error) {
    if !n.Valid {
        return nil, nil
    }
    return int64(n.Int32), nil
}  

如你所见，上面的 Scan 的用法其实非常的不方便，实际项目里用 struct tag + orm 来做比较多，下面是使用 sqlx (go get 的例子:

 type User struct {
  ID        int       `db:"id"`
  Passport  string    `db:"passport"`
  Password  string    `db:"password"`
  Nickname  string    `db:"nickname"`
  CreatedAt time.Time `db:"create_time"`
}

func main() {
  var total int
  var user User
  var users []User
  var names []string
  db := session.GetSqlxDB()

  db.Get(&total, "SELECT COUNT(*) FROM user")
  fmt.Println(total)

  db.Get(&user, "SELECT * FROM user LIMIT 1")
  fmt.Println(user)

  db.Select(&users, "SELECT * FROM user")
  fmt.Println(users)

  db.Select(&names, "SELECT nickname FROM user")
  fmt.Println(names)

  db.QueryRowx("SELECT * FROM user LIMIT 1").StructScan(&user)
  fmt.Println(user)

  rows, _ := db.Queryx("SELECT * FROM user")
  defer rows.Close()
  for rows.Next() {
    var u User
    rows.StructScan(&u)
    fmt.Println(u)
  }
}  

除了好用的 Get、Select、StructScan，还有 MapScan、 SliceScan 分别对应 map[string]interface{} 和 []interface{}，如果需要数据库 ORM 可以关注下 。

本章节的代码