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