database/sql 是 go 自带的操作 sql 的库，它保护了 sql 的连接池，包含连贯的申请和开释。
连接池
datebase/sql 保护了连接池，其配置：
db.SetMaxIdleConns(10) // 设置闲暇连接池中的最大 idle 连接数
db.SetMaxOpenConns(100) // 设置数据库连贯最大关上数
db.SetConnMaxLifetime(time.Hour) // 设置可重用连贯的最长工夫操作 MySQL 的示例程序：
import (
"database/sql"
_ "github.com/go-sql-driver/mysql"
)
func main() {db, _ := db.Open("mysql", "root:rootroot@/dqm?charset=utf8&parseTime=True&loc=Local")
defer db.Close()
db.SetMaxOpenConns(10)
if err := db.Ping(); err != nil {fmt.Println("connect to MySQL failed, err:", err)
return
}
rows, err := db.Query("select * from test where name ='jackie'limit 10")
if err != nil {fmt.Println("query error")
}
defer rows.Close()
for rows.Next() {fmt.Println("close")
}
row, _ := db.Query("select * from test")
fmt.Println(row, rows)
}db.Open(“mysql”, dsn)并不会真正连贯 MySQL，也不会校验数据库用户名 / 明码，仅校验了 dsn 格局。
只有在 Ping()或者理论的 Query()操作时才会建设连贯。
故我的项目中个别在 InitDB()时，除了 Open()，还要 Ping()以确认连贯 OK。
应用 MySQL
database/sql 用于操作数据库的 CRUD，当操作 mysql 时应用驱动：
import (_ "github.com/go-sql-driver/mysql") 它会主动注册 mysql 的驱动：
//github.com/go-sql-driver/mysql/driver.go
func init() {sql.Register("mysql", &MySQLDriver{})
}源码剖析：
初始化 DB
// Open may just validate its arguments without creating a connection
// to the database. To verify that the data source name is valid, call
// Ping.
func Open(driverName, dataSourceName string) (*DB, error) {driversMu.RLock()
driveri, ok := drivers[driverName]
driversMu.RUnlock()
if !ok {return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
}
if driverCtx, ok := driveri.(driver.DriverContext); ok {connector, err := driverCtx.OpenConnector(dataSourceName)
if err != nil {return nil, err}
return OpenDB(connector), nil
}
return OpenDB(dsnConnector{dsn: dataSourceName, driver: driveri}), nil
}初始化 DB 仅结构了 DB 的构造，并没有创立真正的连贯：
func OpenDB(c driver.Connector) *DB {ctx, cancel := context.WithCancel(context.Background())
db := &DB{
connector: c,
openerCh: make(chan struct{}, connectionRequestQueueSize),
resetterCh: make(chan *driverConn, 50),
lastPut: make(map[*driverConn]string),
connRequests: make(map[uint64]chan connRequest),
stop: cancel,
}
go db.connectionOpener(ctx) //goroutine 用于创立连贯
go db.connectionResetter(ctx) //goroutine 用于重置 session
return db
}获取连贯
获取连贯都是在具体的 sql 被执行的时候，如 Query、Exec；
func (db *DB) Query(query string, args ...interface{}) (*Rows, error) {return db.QueryContext(context.Background(), query, args...)
}
func (db *DB) query(ctx context.Context, query string, args []interface{}, strategy connReuseStrategy) (*Rows, error) {dc, err := db.conn(ctx, strategy) // 在这里获取连贯：创立新的 或 应用 cache 的
if err != nil {return nil, err}
// 传入 dc.releaseConn，query 结束后回调该函数
return db.queryDC(ctx, nil, dc, dc.releaseConn, query, args)
}通过 db.conn()获取连贯，先尝试从 freeConn 中拿，拿到就返回；否则看是否超过 maxConn，没超就创立，否则进队列期待：
func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
......
// 尝试从连接池中拿
numFree := len(db.freeConn)
if strategy == cachedOrNewConn && numFree > 0 {conn := db.freeConn[0]
...
return conn, nil
}
// 如果超过最大连接数，要阻塞期待
if db.maxOpen > 0 && db.numOpen >= db.maxOpen {......}
// 创立一个新的连贯
db.numOpen++ // optimistically
ci, err := db.connector.Connect(ctx)
dc := &driverConn{
db: db,
createdAt: nowFunc(),
ci: ci,
inUse: true,
}
db.addDepLocked(dc, dc)
return dc, nil
}开释连贯
开释连贯在 query 的 db.releaseConn 进行，开释连贯理论是将连贯放入连接池 db.freeConn：
func (dc *driverConn) releaseConn(err error) {dc.db.putConn(dc, err, true)
}
// putConn adds a connection to the db's free pool.
// err is optionally the last error that occurred on this connection.
func (db *DB) putConn(dc *driverConn, err error, resetSession bool) {
......
added := db.putConnDBLocked(dc, nil)
......
}
// Satisfy a connRequest or put the driverConn in the idle pool and return true
// or return false.
func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
......
db.freeConn = append(db.freeConn, dc)
......
}查问时连贯的开释
query 的后果返回到 Rows 构造中，同时它把 releaseConn 传递给 Row；
func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []interface{}) (*Rows, error) {
......
rows := &Rows{
dc: dc,
releaseConn: releaseConn, // 传递 relaseConn 函数
rowsi: rowsi,
}
rows.initContextClose(ctx, txctx)
return rows, nil
......
}而在 Rows.Next()函数中：
func (rs *Rows) Next() bool {
var doClose, ok bool
withLock(rs.closemu.RLocker(), func() {doClose, ok = rs.nextLocked()
})
if doClose { // 发现没有记录了，就开释连贯
rs.Close()}
return ok
}
func (rs *Rows) Close() error {return rs.close(nil)
}
func (rs *Rows) close(err error) error {rs.closemu.Lock()
defer rs.closemu.Unlock()
if rs.closed {return nil}
rs.closed = true // 置敞开标记位
......
rs.releaseConn(err) // 开释连贯
return err
}也就是说，用 Rows.Next()来开释连贯；然而，如果在应用时没有遍历到最初，它不会主动开释连贯。
倡议最好 应用 defer rows.Close()手动确认敞开 ，从代码能够看出，rows.Close() 是可重入的(置 closed 标记位，下次调用间接 return)。