关于golang:go-databasesql-连接的申请与释放

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)。