Source file src/database/sql/sql.go

Documentation: database/sql

  // Copyright 2011 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // Package sql provides a generic interface around SQL (or SQL-like)
  // databases.
  //
  // The sql package must be used in conjunction with a database driver.
  // See https://golang.org/s/sqldrivers for a list of drivers.
  //
  // Drivers that do not support context cancelation will not return until
  // after the query is completed.
  //
  // For usage examples, see the wiki page at
  // https://golang.org/s/sqlwiki.
  package sql
  
  import (
  	"context"
  	"database/sql/driver"
  	"errors"
  	"fmt"
  	"io"
  	"reflect"
  	"runtime"
  	"sort"
  	"strconv"
  	"sync"
  	"sync/atomic"
  	"time"
  )
  
  var (
  	driversMu sync.RWMutex
  	drivers   = make(map[string]driver.Driver)
  )
  
  // nowFunc returns the current time; it's overridden in tests.
  var nowFunc = time.Now
  
  // Register makes a database driver available by the provided name.
  // If Register is called twice with the same name or if driver is nil,
  // it panics.
  func Register(name string, driver driver.Driver) {
  	driversMu.Lock()
  	defer driversMu.Unlock()
  	if driver == nil {
  		panic("sql: Register driver is nil")
  	}
  	if _, dup := drivers[name]; dup {
  		panic("sql: Register called twice for driver " + name)
  	}
  	drivers[name] = driver
  }
  
  func unregisterAllDrivers() {
  	driversMu.Lock()
  	defer driversMu.Unlock()
  	// For tests.
  	drivers = make(map[string]driver.Driver)
  }
  
  // Drivers returns a sorted list of the names of the registered drivers.
  func Drivers() []string {
  	driversMu.RLock()
  	defer driversMu.RUnlock()
  	var list []string
  	for name := range drivers {
  		list = append(list, name)
  	}
  	sort.Strings(list)
  	return list
  }
  
  // A NamedArg is a named argument. NamedArg values may be used as
  // arguments to Query or Exec and bind to the corresponding named
  // parameter in the SQL statement.
  //
  // For a more concise way to create NamedArg values, see
  // the Named function.
  type NamedArg struct {
  	_Named_Fields_Required struct{}
  
  	// Name is the name of the parameter placeholder.
  	//
  	// If empty, the ordinal position in the argument list will be
  	// used.
  	//
  	// Name must omit any symbol prefix.
  	Name string
  
  	// Value is the value of the parameter.
  	// It may be assigned the same value types as the query
  	// arguments.
  	Value interface{}
  }
  
  // Named provides a more concise way to create NamedArg values.
  //
  // Example usage:
  //
  //     db.ExecContext(ctx, `
  //         delete from Invoice
  //         where
  //             TimeCreated < @end
  //             and TimeCreated >= @start;`,
  //         sql.Named("start", startTime),
  //         sql.Named("end", endTime),
  //     )
  func Named(name string, value interface{}) NamedArg {
  	// This method exists because the go1compat promise
  	// doesn't guarantee that structs don't grow more fields,
  	// so unkeyed struct literals are a vet error. Thus, we don't
  	// want to allow sql.NamedArg{name, value}.
  	return NamedArg{Name: name, Value: value}
  }
  
  // IsolationLevel is the transaction isolation level used in TxOptions.
  type IsolationLevel int
  
  // Various isolation levels that drivers may support in BeginTx.
  // If a driver does not support a given isolation level an error may be returned.
  //
  // See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.
  const (
  	LevelDefault IsolationLevel = iota
  	LevelReadUncommitted
  	LevelReadCommitted
  	LevelWriteCommitted
  	LevelRepeatableRead
  	LevelSnapshot
  	LevelSerializable
  	LevelLinearizable
  )
  
  func (i IsolationLevel) String() string {
  	switch i {
  	case LevelDefault:
  		return "Default"
  	case LevelReadUncommitted:
  		return "Read Uncommitted"
  	case LevelReadCommitted:
  		return "Read Committed"
  	case LevelWriteCommitted:
  		return "Write Committed"
  	case LevelRepeatableRead:
  		return "Repeatable Read"
  	case LevelSnapshot:
  		return "Snapshot"
  	case LevelSerializable:
  		return "Serializable"
  	case LevelLinearizable:
  		return "Linearizable"
  	default:
  		return "IsolationLevel(" + strconv.Itoa(int(i)) + ")"
  	}
  }
  
  var _ fmt.Stringer = LevelDefault
  
  // TxOptions holds the transaction options to be used in DB.BeginTx.
  type TxOptions struct {
  	// Isolation is the transaction isolation level.
  	// If zero, the driver or database's default level is used.
  	Isolation IsolationLevel
  	ReadOnly  bool
  }
  
  // RawBytes is a byte slice that holds a reference to memory owned by
  // the database itself. After a Scan into a RawBytes, the slice is only
  // valid until the next call to Next, Scan, or Close.
  type RawBytes []byte
  
  // NullString represents a string that may be null.
  // NullString implements the Scanner interface so
  // it can be used as a scan destination:
  //
  //  var s NullString
  //  err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&s)
  //  ...
  //  if s.Valid {
  //     // use s.String
  //  } else {
  //     // NULL value
  //  }
  //
  type NullString struct {
  	String string
  	Valid  bool // Valid is true if String is not NULL
  }
  
  // Scan implements the Scanner interface.
  func (ns *NullString) Scan(value interface{}) error {
  	if value == nil {
  		ns.String, ns.Valid = "", false
  		return nil
  	}
  	ns.Valid = true
  	return convertAssign(&ns.String, value)
  }
  
  // Value implements the driver Valuer interface.
  func (ns NullString) Value() (driver.Value, error) {
  	if !ns.Valid {
  		return nil, nil
  	}
  	return ns.String, nil
  }
  
  // NullInt64 represents an int64 that may be null.
  // NullInt64 implements the Scanner interface so
  // it can be used as a scan destination, similar to NullString.
  type NullInt64 struct {
  	Int64 int64
  	Valid bool // Valid is true if Int64 is not NULL
  }
  
  // Scan implements the Scanner interface.
  func (n *NullInt64) Scan(value interface{}) error {
  	if value == nil {
  		n.Int64, n.Valid = 0, false
  		return nil
  	}
  	n.Valid = true
  	return convertAssign(&n.Int64, value)
  }
  
  // Value implements the driver Valuer interface.
  func (n NullInt64) Value() (driver.Value, error) {
  	if !n.Valid {
  		return nil, nil
  	}
  	return n.Int64, nil
  }
  
  // NullFloat64 represents a float64 that may be null.
  // NullFloat64 implements the Scanner interface so
  // it can be used as a scan destination, similar to NullString.
  type NullFloat64 struct {
  	Float64 float64
  	Valid   bool // Valid is true if Float64 is not NULL
  }
  
  // Scan implements the Scanner interface.
  func (n *NullFloat64) Scan(value interface{}) error {
  	if value == nil {
  		n.Float64, n.Valid = 0, false
  		return nil
  	}
  	n.Valid = true
  	return convertAssign(&n.Float64, value)
  }
  
  // Value implements the driver Valuer interface.
  func (n NullFloat64) Value() (driver.Value, error) {
  	if !n.Valid {
  		return nil, nil
  	}
  	return n.Float64, nil
  }
  
  // NullBool represents a bool that may be null.
  // NullBool implements the Scanner interface so
  // it can be used as a scan destination, similar to NullString.
  type NullBool struct {
  	Bool  bool
  	Valid bool // Valid is true if Bool is not NULL
  }
  
  // Scan implements the Scanner interface.
  func (n *NullBool) Scan(value interface{}) error {
  	if value == nil {
  		n.Bool, n.Valid = false, false
  		return nil
  	}
  	n.Valid = true
  	return convertAssign(&n.Bool, value)
  }
  
  // Value implements the driver Valuer interface.
  func (n NullBool) Value() (driver.Value, error) {
  	if !n.Valid {
  		return nil, nil
  	}
  	return n.Bool, nil
  }
  
  // Scanner is an interface used by Scan.
  type Scanner interface {
  	// Scan assigns a value from a database driver.
  	//
  	// The src value will be of one of the following types:
  	//
  	//    int64
  	//    float64
  	//    bool
  	//    []byte
  	//    string
  	//    time.Time
  	//    nil - for NULL values
  	//
  	// An error should be returned if the value cannot be stored
  	// without loss of information.
  	//
  	// Reference types such as []byte are only valid until the next call to Scan
  	// and should not be retained. Their underlying memory is owned by the driver.
  	// If retention is necessary, copy their values before the next call to Scan.
  	Scan(src interface{}) error
  }
  
  // Out may be used to retrieve OUTPUT value parameters from stored procedures.
  //
  // Not all drivers and databases support OUTPUT value parameters.
  //
  // Example usage:
  //
  //   var outArg string
  //   _, err := db.ExecContext(ctx, "ProcName", sql.Named("Arg1", sql.Out{Dest: &outArg}))
  type Out struct {
  	_Named_Fields_Required struct{}
  
  	// Dest is a pointer to the value that will be set to the result of the
  	// stored procedure's OUTPUT parameter.
  	Dest interface{}
  
  	// In is whether the parameter is an INOUT parameter. If so, the input value to the stored
  	// procedure is the dereferenced value of Dest's pointer, which is then replaced with
  	// the output value.
  	In bool
  }
  
  // ErrNoRows is returned by Scan when QueryRow doesn't return a
  // row. In such a case, QueryRow returns a placeholder *Row value that
  // defers this error until a Scan.
  var ErrNoRows = errors.New("sql: no rows in result set")
  
  // DB is a database handle representing a pool of zero or more
  // underlying connections. It's safe for concurrent use by multiple
  // goroutines.
  //
  // The sql package creates and frees connections automatically; it
  // also maintains a free pool of idle connections. If the database has
  // a concept of per-connection state, such state can be reliably observed
  // within a transaction (Tx) or connection (Conn). Once DB.Begin is called, the
  // returned Tx is bound to a single connection. Once Commit or
  // Rollback is called on the transaction, that transaction's
  // connection is returned to DB's idle connection pool. The pool size
  // can be controlled with SetMaxIdleConns.
  type DB struct {
  	// Atomic access only. At top of struct to prevent mis-alignment
  	// on 32-bit platforms. Of type time.Duration.
  	waitDuration int64 // Total time waited for new connections.
  
  	connector driver.Connector
  	// numClosed is an atomic counter which represents a total number of
  	// closed connections. Stmt.openStmt checks it before cleaning closed
  	// connections in Stmt.css.
  	numClosed uint64
  
  	mu           sync.Mutex // protects following fields
  	freeConn     []*driverConn
  	connRequests map[uint64]chan connRequest
  	nextRequest  uint64 // Next key to use in connRequests.
  	numOpen      int    // number of opened and pending open connections
  	// Used to signal the need for new connections
  	// a goroutine running connectionOpener() reads on this chan and
  	// maybeOpenNewConnections sends on the chan (one send per needed connection)
  	// It is closed during db.Close(). The close tells the connectionOpener
  	// goroutine to exit.
  	openerCh          chan struct{}
  	resetterCh        chan *driverConn
  	closed            bool
  	dep               map[finalCloser]depSet
  	lastPut           map[*driverConn]string // stacktrace of last conn's put; debug only
  	maxIdle           int                    // zero means defaultMaxIdleConns; negative means 0
  	maxOpen           int                    // <= 0 means unlimited
  	maxLifetime       time.Duration          // maximum amount of time a connection may be reused
  	cleanerCh         chan struct{}
  	waitCount         int64 // Total number of connections waited for.
  	maxIdleClosed     int64 // Total number of connections closed due to idle.
  	maxLifetimeClosed int64 // Total number of connections closed due to max free limit.
  
  	stop func() // stop cancels the connection opener and the session resetter.
  }
  
  // connReuseStrategy determines how (*DB).conn returns database connections.
  type connReuseStrategy uint8
  
  const (
  	// alwaysNewConn forces a new connection to the database.
  	alwaysNewConn connReuseStrategy = iota
  	// cachedOrNewConn returns a cached connection, if available, else waits
  	// for one to become available (if MaxOpenConns has been reached) or
  	// creates a new database connection.
  	cachedOrNewConn
  )
  
  // driverConn wraps a driver.Conn with a mutex, to
  // be held during all calls into the Conn. (including any calls onto
  // interfaces returned via that Conn, such as calls on Tx, Stmt,
  // Result, Rows)
  type driverConn struct {
  	db        *DB
  	createdAt time.Time
  
  	sync.Mutex  // guards following
  	ci          driver.Conn
  	closed      bool
  	finalClosed bool // ci.Close has been called
  	openStmt    map[*driverStmt]bool
  	lastErr     error // lastError captures the result of the session resetter.
  
  	// guarded by db.mu
  	inUse      bool
  	onPut      []func() // code (with db.mu held) run when conn is next returned
  	dbmuClosed bool     // same as closed, but guarded by db.mu, for removeClosedStmtLocked
  }
  
  func (dc *driverConn) releaseConn(err error) {
  	dc.db.putConn(dc, err, true)
  }
  
  func (dc *driverConn) removeOpenStmt(ds *driverStmt) {
  	dc.Lock()
  	defer dc.Unlock()
  	delete(dc.openStmt, ds)
  }
  
  func (dc *driverConn) expired(timeout time.Duration) bool {
  	if timeout <= 0 {
  		return false
  	}
  	return dc.createdAt.Add(timeout).Before(nowFunc())
  }
  
  // prepareLocked prepares the query on dc. When cg == nil the dc must keep track of
  // the prepared statements in a pool.
  func (dc *driverConn) prepareLocked(ctx context.Context, cg stmtConnGrabber, query string) (*driverStmt, error) {
  	si, err := ctxDriverPrepare(ctx, dc.ci, query)
  	if err != nil {
  		return nil, err
  	}
  	ds := &driverStmt{Locker: dc, si: si}
  
  	// No need to manage open statements if there is a single connection grabber.
  	if cg != nil {
  		return ds, nil
  	}
  
  	// Track each driverConn's open statements, so we can close them
  	// before closing the conn.
  	//
  	// Wrap all driver.Stmt is *driverStmt to ensure they are only closed once.
  	if dc.openStmt == nil {
  		dc.openStmt = make(map[*driverStmt]bool)
  	}
  	dc.openStmt[ds] = true
  	return ds, nil
  }
  
  // resetSession resets the connection session and sets the lastErr
  // that is checked before returning the connection to another query.
  //
  // resetSession assumes that the embedded mutex is locked when the connection
  // was returned to the pool. This unlocks the mutex.
  func (dc *driverConn) resetSession(ctx context.Context) {
  	defer dc.Unlock() // In case of panic.
  	if dc.closed {    // Check if the database has been closed.
  		return
  	}
  	dc.lastErr = dc.ci.(driver.SessionResetter).ResetSession(ctx)
  }
  
  // the dc.db's Mutex is held.
  func (dc *driverConn) closeDBLocked() func() error {
  	dc.Lock()
  	defer dc.Unlock()
  	if dc.closed {
  		return func() error { return errors.New("sql: duplicate driverConn close") }
  	}
  	dc.closed = true
  	return dc.db.removeDepLocked(dc, dc)
  }
  
  func (dc *driverConn) Close() error {
  	dc.Lock()
  	if dc.closed {
  		dc.Unlock()
  		return errors.New("sql: duplicate driverConn close")
  	}
  	dc.closed = true
  	dc.Unlock() // not defer; removeDep finalClose calls may need to lock
  
  	// And now updates that require holding dc.mu.Lock.
  	dc.db.mu.Lock()
  	dc.dbmuClosed = true
  	fn := dc.db.removeDepLocked(dc, dc)
  	dc.db.mu.Unlock()
  	return fn()
  }
  
  func (dc *driverConn) finalClose() error {
  	var err error
  
  	// Each *driverStmt has a lock to the dc. Copy the list out of the dc
  	// before calling close on each stmt.
  	var openStmt []*driverStmt
  	withLock(dc, func() {
  		openStmt = make([]*driverStmt, 0, len(dc.openStmt))
  		for ds := range dc.openStmt {
  			openStmt = append(openStmt, ds)
  		}
  		dc.openStmt = nil
  	})
  	for _, ds := range openStmt {
  		ds.Close()
  	}
  	withLock(dc, func() {
  		dc.finalClosed = true
  		err = dc.ci.Close()
  		dc.ci = nil
  	})
  
  	dc.db.mu.Lock()
  	dc.db.numOpen--
  	dc.db.maybeOpenNewConnections()
  	dc.db.mu.Unlock()
  
  	atomic.AddUint64(&dc.db.numClosed, 1)
  	return err
  }
  
  // driverStmt associates a driver.Stmt with the
  // *driverConn from which it came, so the driverConn's lock can be
  // held during calls.
  type driverStmt struct {
  	sync.Locker // the *driverConn
  	si          driver.Stmt
  	closed      bool
  	closeErr    error // return value of previous Close call
  }
  
  // Close ensures driver.Stmt is only closed once and always returns the same
  // result.
  func (ds *driverStmt) Close() error {
  	ds.Lock()
  	defer ds.Unlock()
  	if ds.closed {
  		return ds.closeErr
  	}
  	ds.closed = true
  	ds.closeErr = ds.si.Close()
  	return ds.closeErr
  }
  
  // depSet is a finalCloser's outstanding dependencies
  type depSet map[interface{}]bool // set of true bools
  
  // The finalCloser interface is used by (*DB).addDep and related
  // dependency reference counting.
  type finalCloser interface {
  	// finalClose is called when the reference count of an object
  	// goes to zero. (*DB).mu is not held while calling it.
  	finalClose() error
  }
  
  // addDep notes that x now depends on dep, and x's finalClose won't be
  // called until all of x's dependencies are removed with removeDep.
  func (db *DB) addDep(x finalCloser, dep interface{}) {
  	//println(fmt.Sprintf("addDep(%T %p, %T %p)", x, x, dep, dep))
  	db.mu.Lock()
  	defer db.mu.Unlock()
  	db.addDepLocked(x, dep)
  }
  
  func (db *DB) addDepLocked(x finalCloser, dep interface{}) {
  	if db.dep == nil {
  		db.dep = make(map[finalCloser]depSet)
  	}
  	xdep := db.dep[x]
  	if xdep == nil {
  		xdep = make(depSet)
  		db.dep[x] = xdep
  	}
  	xdep[dep] = true
  }
  
  // removeDep notes that x no longer depends on dep.
  // If x still has dependencies, nil is returned.
  // If x no longer has any dependencies, its finalClose method will be
  // called and its error value will be returned.
  func (db *DB) removeDep(x finalCloser, dep interface{}) error {
  	db.mu.Lock()
  	fn := db.removeDepLocked(x, dep)
  	db.mu.Unlock()
  	return fn()
  }
  
  func (db *DB) removeDepLocked(x finalCloser, dep interface{}) func() error {
  	//println(fmt.Sprintf("removeDep(%T %p, %T %p)", x, x, dep, dep))
  
  	xdep, ok := db.dep[x]
  	if !ok {
  		panic(fmt.Sprintf("unpaired removeDep: no deps for %T", x))
  	}
  
  	l0 := len(xdep)
  	delete(xdep, dep)
  
  	switch len(xdep) {
  	case l0:
  		// Nothing removed. Shouldn't happen.
  		panic(fmt.Sprintf("unpaired removeDep: no %T dep on %T", dep, x))
  	case 0:
  		// No more dependencies.
  		delete(db.dep, x)
  		return x.finalClose
  	default:
  		// Dependencies remain.
  		return func() error { return nil }
  	}
  }
  
  // This is the size of the connectionOpener request chan (DB.openerCh).
  // This value should be larger than the maximum typical value
  // used for db.maxOpen. If maxOpen is significantly larger than
  // connectionRequestQueueSize then it is possible for ALL calls into the *DB
  // to block until the connectionOpener can satisfy the backlog of requests.
  var connectionRequestQueueSize = 1000000
  
  type dsnConnector struct {
  	dsn    string
  	driver driver.Driver
  }
  
  func (t dsnConnector) Connect(_ context.Context) (driver.Conn, error) {
  	return t.driver.Open(t.dsn)
  }
  
  func (t dsnConnector) Driver() driver.Driver {
  	return t.driver
  }
  
  // OpenDB opens a database using a Connector, allowing drivers to
  // bypass a string based data source name.
  //
  // Most users will open a database via a driver-specific connection
  // helper function that returns a *DB. No database drivers are included
  // in the Go standard library. See https://golang.org/s/sqldrivers for
  // a list of third-party drivers.
  //
  // OpenDB may just validate its arguments without creating a connection
  // to the database. To verify that the data source name is valid, call
  // Ping.
  //
  // The returned DB is safe for concurrent use by multiple goroutines
  // and maintains its own pool of idle connections. Thus, the OpenDB
  // function should be called just once. It is rarely necessary to
  // close a 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)
  	go db.connectionResetter(ctx)
  
  	return db
  }
  
  // Open opens a database specified by its database driver name and a
  // driver-specific data source name, usually consisting of at least a
  // database name and connection information.
  //
  // Most users will open a database via a driver-specific connection
  // helper function that returns a *DB. No database drivers are included
  // in the Go standard library. See https://golang.org/s/sqldrivers for
  // a list of third-party drivers.
  //
  // Open may just validate its arguments without creating a connection
  // to the database. To verify that the data source name is valid, call
  // Ping.
  //
  // The returned DB is safe for concurrent use by multiple goroutines
  // and maintains its own pool of idle connections. Thus, the Open
  // function should be called just once. It is rarely necessary to
  // close a DB.
  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
  }
  
  func (db *DB) pingDC(ctx context.Context, dc *driverConn, release func(error)) error {
  	var err error
  	if pinger, ok := dc.ci.(driver.Pinger); ok {
  		withLock(dc, func() {
  			err = pinger.Ping(ctx)
  		})
  	}
  	release(err)
  	return err
  }
  
  // PingContext verifies a connection to the database is still alive,
  // establishing a connection if necessary.
  func (db *DB) PingContext(ctx context.Context) error {
  	var dc *driverConn
  	var err error
  
  	for i := 0; i < maxBadConnRetries; i++ {
  		dc, err = db.conn(ctx, cachedOrNewConn)
  		if err != driver.ErrBadConn {
  			break
  		}
  	}
  	if err == driver.ErrBadConn {
  		dc, err = db.conn(ctx, alwaysNewConn)
  	}
  	if err != nil {
  		return err
  	}
  
  	return db.pingDC(ctx, dc, dc.releaseConn)
  }
  
  // Ping verifies a connection to the database is still alive,
  // establishing a connection if necessary.
  func (db *DB) Ping() error {
  	return db.PingContext(context.Background())
  }
  
  // Close closes the database and prevents new queries from starting.
  // Close then waits for all queries that have started processing on the server
  // to finish.
  //
  // It is rare to Close a DB, as the DB handle is meant to be
  // long-lived and shared between many goroutines.
  func (db *DB) Close() error {
  	db.mu.Lock()
  	if db.closed { // Make DB.Close idempotent
  		db.mu.Unlock()
  		return nil
  	}
  	if db.cleanerCh != nil {
  		close(db.cleanerCh)
  	}
  	var err error
  	fns := make([]func() error, 0, len(db.freeConn))
  	for _, dc := range db.freeConn {
  		fns = append(fns, dc.closeDBLocked())
  	}
  	db.freeConn = nil
  	db.closed = true
  	for _, req := range db.connRequests {
  		close(req)
  	}
  	db.mu.Unlock()
  	for _, fn := range fns {
  		err1 := fn()
  		if err1 != nil {
  			err = err1
  		}
  	}
  	db.stop()
  	return err
  }
  
  const defaultMaxIdleConns = 2
  
  func (db *DB) maxIdleConnsLocked() int {
  	n := db.maxIdle
  	switch {
  	case n == 0:
  		// TODO(bradfitz): ask driver, if supported, for its default preference
  		return defaultMaxIdleConns
  	case n < 0:
  		return 0
  	default:
  		return n
  	}
  }
  
  // SetMaxIdleConns sets the maximum number of connections in the idle
  // connection pool.
  //
  // If MaxOpenConns is greater than 0 but less than the new MaxIdleConns,
  // then the new MaxIdleConns will be reduced to match the MaxOpenConns limit.
  //
  // If n <= 0, no idle connections are retained.
  //
  // The default max idle connections is currently 2. This may change in
  // a future release.
  func (db *DB) SetMaxIdleConns(n int) {
  	db.mu.Lock()
  	if n > 0 {
  		db.maxIdle = n
  	} else {
  		// No idle connections.
  		db.maxIdle = -1
  	}
  	// Make sure maxIdle doesn't exceed maxOpen
  	if db.maxOpen > 0 && db.maxIdleConnsLocked() > db.maxOpen {
  		db.maxIdle = db.maxOpen
  	}
  	var closing []*driverConn
  	idleCount := len(db.freeConn)
  	maxIdle := db.maxIdleConnsLocked()
  	if idleCount > maxIdle {
  		closing = db.freeConn[maxIdle:]
  		db.freeConn = db.freeConn[:maxIdle]
  	}
  	db.maxIdleClosed += int64(len(closing))
  	db.mu.Unlock()
  	for _, c := range closing {
  		c.Close()
  	}
  }
  
  // SetMaxOpenConns sets the maximum number of open connections to the database.
  //
  // If MaxIdleConns is greater than 0 and the new MaxOpenConns is less than
  // MaxIdleConns, then MaxIdleConns will be reduced to match the new
  // MaxOpenConns limit.
  //
  // If n <= 0, then there is no limit on the number of open connections.
  // The default is 0 (unlimited).
  func (db *DB) SetMaxOpenConns(n int) {
  	db.mu.Lock()
  	db.maxOpen = n
  	if n < 0 {
  		db.maxOpen = 0
  	}
  	syncMaxIdle := db.maxOpen > 0 && db.maxIdleConnsLocked() > db.maxOpen
  	db.mu.Unlock()
  	if syncMaxIdle {
  		db.SetMaxIdleConns(n)
  	}
  }
  
  // SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
  //
  // Expired connections may be closed lazily before reuse.
  //
  // If d <= 0, connections are reused forever.
  func (db *DB) SetConnMaxLifetime(d time.Duration) {
  	if d < 0 {
  		d = 0
  	}
  	db.mu.Lock()
  	// wake cleaner up when lifetime is shortened.
  	if d > 0 && d < db.maxLifetime && db.cleanerCh != nil {
  		select {
  		case db.cleanerCh <- struct{}{}:
  		default:
  		}
  	}
  	db.maxLifetime = d
  	db.startCleanerLocked()
  	db.mu.Unlock()
  }
  
  // startCleanerLocked starts connectionCleaner if needed.
  func (db *DB) startCleanerLocked() {
  	if db.maxLifetime > 0 && db.numOpen > 0 && db.cleanerCh == nil {
  		db.cleanerCh = make(chan struct{}, 1)
  		go db.connectionCleaner(db.maxLifetime)
  	}
  }
  
  func (db *DB) connectionCleaner(d time.Duration) {
  	const minInterval = time.Second
  
  	if d < minInterval {
  		d = minInterval
  	}
  	t := time.NewTimer(d)
  
  	for {
  		select {
  		case <-t.C:
  		case <-db.cleanerCh: // maxLifetime was changed or db was closed.
  		}
  
  		db.mu.Lock()
  		d = db.maxLifetime
  		if db.closed || db.numOpen == 0 || d <= 0 {
  			db.cleanerCh = nil
  			db.mu.Unlock()
  			return
  		}
  
  		expiredSince := nowFunc().Add(-d)
  		var closing []*driverConn
  		for i := 0; i < len(db.freeConn); i++ {
  			c := db.freeConn[i]
  			if c.createdAt.Before(expiredSince) {
  				closing = append(closing, c)
  				last := len(db.freeConn) - 1
  				db.freeConn[i] = db.freeConn[last]
  				db.freeConn[last] = nil
  				db.freeConn = db.freeConn[:last]
  				i--
  			}
  		}
  		db.maxLifetimeClosed += int64(len(closing))
  		db.mu.Unlock()
  
  		for _, c := range closing {
  			c.Close()
  		}
  
  		if d < minInterval {
  			d = minInterval
  		}
  		t.Reset(d)
  	}
  }
  
  // DBStats contains database statistics.
  type DBStats struct {
  	MaxOpenConnections int // Maximum number of open connections to the database.
  
  	// Pool Status
  	OpenConnections int // The number of established connections both in use and idle.
  	InUse           int // The number of connections currently in use.
  	Idle            int // The number of idle connections.
  
  	// Counters
  	WaitCount         int64         // The total number of connections waited for.
  	WaitDuration      time.Duration // The total time blocked waiting for a new connection.
  	MaxIdleClosed     int64         // The total number of connections closed due to SetMaxIdleConns.
  	MaxLifetimeClosed int64         // The total number of connections closed due to SetConnMaxLifetime.
  }
  
  // Stats returns database statistics.
  func (db *DB) Stats() DBStats {
  	wait := atomic.LoadInt64(&db.waitDuration)
  
  	db.mu.Lock()
  	defer db.mu.Unlock()
  
  	stats := DBStats{
  		MaxOpenConnections: db.maxOpen,
  
  		Idle:            len(db.freeConn),
  		OpenConnections: db.numOpen,
  		InUse:           db.numOpen - len(db.freeConn),
  
  		WaitCount:         db.waitCount,
  		WaitDuration:      time.Duration(wait),
  		MaxIdleClosed:     db.maxIdleClosed,
  		MaxLifetimeClosed: db.maxLifetimeClosed,
  	}
  	return stats
  }
  
  // Assumes db.mu is locked.
  // If there are connRequests and the connection limit hasn't been reached,
  // then tell the connectionOpener to open new connections.
  func (db *DB) maybeOpenNewConnections() {
  	numRequests := len(db.connRequests)
  	if db.maxOpen > 0 {
  		numCanOpen := db.maxOpen - db.numOpen
  		if numRequests > numCanOpen {
  			numRequests = numCanOpen
  		}
  	}
  	for numRequests > 0 {
  		db.numOpen++ // optimistically
  		numRequests--
  		if db.closed {
  			return
  		}
  		db.openerCh <- struct{}{}
  	}
  }
  
  // Runs in a separate goroutine, opens new connections when requested.
  func (db *DB) connectionOpener(ctx context.Context) {
  	for {
  		select {
  		case <-ctx.Done():
  			return
  		case <-db.openerCh:
  			db.openNewConnection(ctx)
  		}
  	}
  }
  
  // connectionResetter runs in a separate goroutine to reset connections async
  // to exported API.
  func (db *DB) connectionResetter(ctx context.Context) {
  	for {
  		select {
  		case <-ctx.Done():
  			close(db.resetterCh)
  			for dc := range db.resetterCh {
  				dc.Unlock()
  			}
  			return
  		case dc := <-db.resetterCh:
  			dc.resetSession(ctx)
  		}
  	}
  }
  
  // Open one new connection
  func (db *DB) openNewConnection(ctx context.Context) {
  	// maybeOpenNewConnctions has already executed db.numOpen++ before it sent
  	// on db.openerCh. This function must execute db.numOpen-- if the
  	// connection fails or is closed before returning.
  	ci, err := db.connector.Connect(ctx)
  	db.mu.Lock()
  	defer db.mu.Unlock()
  	if db.closed {
  		if err == nil {
  			ci.Close()
  		}
  		db.numOpen--
  		return
  	}
  	if err != nil {
  		db.numOpen--
  		db.putConnDBLocked(nil, err)
  		db.maybeOpenNewConnections()
  		return
  	}
  	dc := &driverConn{
  		db:        db,
  		createdAt: nowFunc(),
  		ci:        ci,
  	}
  	if db.putConnDBLocked(dc, err) {
  		db.addDepLocked(dc, dc)
  	} else {
  		db.numOpen--
  		ci.Close()
  	}
  }
  
  // connRequest represents one request for a new connection
  // When there are no idle connections available, DB.conn will create
  // a new connRequest and put it on the db.connRequests list.
  type connRequest struct {
  	conn *driverConn
  	err  error
  }
  
  var errDBClosed = errors.New("sql: database is closed")
  
  // nextRequestKeyLocked returns the next connection request key.
  // It is assumed that nextRequest will not overflow.
  func (db *DB) nextRequestKeyLocked() uint64 {
  	next := db.nextRequest
  	db.nextRequest++
  	return next
  }
  
  // conn returns a newly-opened or cached *driverConn.
  func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
  	db.mu.Lock()
  	if db.closed {
  		db.mu.Unlock()
  		return nil, errDBClosed
  	}
  	// Check if the context is expired.
  	select {
  	default:
  	case <-ctx.Done():
  		db.mu.Unlock()
  		return nil, ctx.Err()
  	}
  	lifetime := db.maxLifetime
  
  	// Prefer a free connection, if possible.
  	numFree := len(db.freeConn)
  	if strategy == cachedOrNewConn && numFree > 0 {
  		conn := db.freeConn[0]
  		copy(db.freeConn, db.freeConn[1:])
  		db.freeConn = db.freeConn[:numFree-1]
  		conn.inUse = true
  		db.mu.Unlock()
  		if conn.expired(lifetime) {
  			conn.Close()
  			return nil, driver.ErrBadConn
  		}
  		// Lock around reading lastErr to ensure the session resetter finished.
  		conn.Lock()
  		err := conn.lastErr
  		conn.Unlock()
  		if err == driver.ErrBadConn {
  			conn.Close()
  			return nil, driver.ErrBadConn
  		}
  		return conn, nil
  	}
  
  	// Out of free connections or we were asked not to use one. If we're not
  	// allowed to open any more connections, make a request and wait.
  	if db.maxOpen > 0 && db.numOpen >= db.maxOpen {
  		// Make the connRequest channel. It's buffered so that the
  		// connectionOpener doesn't block while waiting for the req to be read.
  		req := make(chan connRequest, 1)
  		reqKey := db.nextRequestKeyLocked()
  		db.connRequests[reqKey] = req
  		db.waitCount++
  		db.mu.Unlock()
  
  		waitStart := time.Now()
  
  		// Timeout the connection request with the context.
  		select {
  		case <-ctx.Done():
  			// Remove the connection request and ensure no value has been sent
  			// on it after removing.
  			db.mu.Lock()
  			delete(db.connRequests, reqKey)
  			db.mu.Unlock()
  
  			atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))
  
  			select {
  			default:
  			case ret, ok := <-req:
  				if ok && ret.conn != nil {
  					db.putConn(ret.conn, ret.err, false)
  				}
  			}
  			return nil, ctx.Err()
  		case ret, ok := <-req:
  			atomic.AddInt64(&db.waitDuration, int64(time.Since(waitStart)))
  
  			if !ok {
  				return nil, errDBClosed
  			}
  			if ret.err == nil && ret.conn.expired(lifetime) {
  				ret.conn.Close()
  				return nil, driver.ErrBadConn
  			}
  			if ret.conn == nil {
  				return nil, ret.err
  			}
  			// Lock around reading lastErr to ensure the session resetter finished.
  			ret.conn.Lock()
  			err := ret.conn.lastErr
  			ret.conn.Unlock()
  			if err == driver.ErrBadConn {
  				ret.conn.Close()
  				return nil, driver.ErrBadConn
  			}
  			return ret.conn, ret.err
  		}
  	}
  
  	db.numOpen++ // optimistically
  	db.mu.Unlock()
  	ci, err := db.connector.Connect(ctx)
  	if err != nil {
  		db.mu.Lock()
  		db.numOpen-- // correct for earlier optimism
  		db.maybeOpenNewConnections()
  		db.mu.Unlock()
  		return nil, err
  	}
  	db.mu.Lock()
  	dc := &driverConn{
  		db:        db,
  		createdAt: nowFunc(),
  		ci:        ci,
  		inUse:     true,
  	}
  	db.addDepLocked(dc, dc)
  	db.mu.Unlock()
  	return dc, nil
  }
  
  // putConnHook is a hook for testing.
  var putConnHook func(*DB, *driverConn)
  
  // noteUnusedDriverStatement notes that ds is no longer used and should
  // be closed whenever possible (when c is next not in use), unless c is
  // already closed.
  func (db *DB) noteUnusedDriverStatement(c *driverConn, ds *driverStmt) {
  	db.mu.Lock()
  	defer db.mu.Unlock()
  	if c.inUse {
  		c.onPut = append(c.onPut, func() {
  			ds.Close()
  		})
  	} else {
  		c.Lock()
  		fc := c.finalClosed
  		c.Unlock()
  		if !fc {
  			ds.Close()
  		}
  	}
  }
  
  // debugGetPut determines whether getConn & putConn calls' stack traces
  // are returned for more verbose crashes.
  const debugGetPut = false
  
  // 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) {
  	db.mu.Lock()
  	if !dc.inUse {
  		if debugGetPut {
  			fmt.Printf("putConn(%v) DUPLICATE was: %s\n\nPREVIOUS was: %s", dc, stack(), db.lastPut[dc])
  		}
  		panic("sql: connection returned that was never out")
  	}
  	if debugGetPut {
  		db.lastPut[dc] = stack()
  	}
  	dc.inUse = false
  
  	for _, fn := range dc.onPut {
  		fn()
  	}
  	dc.onPut = nil
  
  	if err == driver.ErrBadConn {
  		// Don't reuse bad connections.
  		// Since the conn is considered bad and is being discarded, treat it
  		// as closed. Don't decrement the open count here, finalClose will
  		// take care of that.
  		db.maybeOpenNewConnections()
  		db.mu.Unlock()
  		dc.Close()
  		return
  	}
  	if putConnHook != nil {
  		putConnHook(db, dc)
  	}
  	if db.closed {
  		// Connections do not need to be reset if they will be closed.
  		// Prevents writing to resetterCh after the DB has closed.
  		resetSession = false
  	}
  	if resetSession {
  		if _, resetSession = dc.ci.(driver.SessionResetter); resetSession {
  			// Lock the driverConn here so it isn't released until
  			// the connection is reset.
  			// The lock must be taken before the connection is put into
  			// the pool to prevent it from being taken out before it is reset.
  			dc.Lock()
  		}
  	}
  	added := db.putConnDBLocked(dc, nil)
  	db.mu.Unlock()
  
  	if !added {
  		if resetSession {
  			dc.Unlock()
  		}
  		dc.Close()
  		return
  	}
  	if !resetSession {
  		return
  	}
  	select {
  	default:
  		// If the resetterCh is blocking then mark the connection
  		// as bad and continue on.
  		dc.lastErr = driver.ErrBadConn
  		dc.Unlock()
  	case db.resetterCh <- dc:
  	}
  }
  
  // Satisfy a connRequest or put the driverConn in the idle pool and return true
  // or return false.
  // putConnDBLocked will satisfy a connRequest if there is one, or it will
  // return the *driverConn to the freeConn list if err == nil and the idle
  // connection limit will not be exceeded.
  // If err != nil, the value of dc is ignored.
  // If err == nil, then dc must not equal nil.
  // If a connRequest was fulfilled or the *driverConn was placed in the
  // freeConn list, then true is returned, otherwise false is returned.
  func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
  	if db.closed {
  		return false
  	}
  	if db.maxOpen > 0 && db.numOpen > db.maxOpen {
  		return false
  	}
  	if c := len(db.connRequests); c > 0 {
  		var req chan connRequest
  		var reqKey uint64
  		for reqKey, req = range db.connRequests {
  			break
  		}
  		delete(db.connRequests, reqKey) // Remove from pending requests.
  		if err == nil {
  			dc.inUse = true
  		}
  		req <- connRequest{
  			conn: dc,
  			err:  err,
  		}
  		return true
  	} else if err == nil && !db.closed && db.maxIdleConnsLocked() > len(db.freeConn) {
  		db.freeConn = append(db.freeConn, dc)
  		db.maxIdleClosed++
  		db.startCleanerLocked()
  		return true
  	}
  	return false
  }
  
  // maxBadConnRetries is the number of maximum retries if the driver returns
  // driver.ErrBadConn to signal a broken connection before forcing a new
  // connection to be opened.
  const maxBadConnRetries = 2
  
  // PrepareContext creates a prepared statement for later queries or executions.
  // Multiple queries or executions may be run concurrently from the
  // returned statement.
  // The caller must call the statement's Close method
  // when the statement is no longer needed.
  //
  // The provided context is used for the preparation of the statement, not for the
  // execution of the statement.
  func (db *DB) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
  	var stmt *Stmt
  	var err error
  	for i := 0; i < maxBadConnRetries; i++ {
  		stmt, err = db.prepare(ctx, query, cachedOrNewConn)
  		if err != driver.ErrBadConn {
  			break
  		}
  	}
  	if err == driver.ErrBadConn {
  		return db.prepare(ctx, query, alwaysNewConn)
  	}
  	return stmt, err
  }
  
  // Prepare creates a prepared statement for later queries or executions.
  // Multiple queries or executions may be run concurrently from the
  // returned statement.
  // The caller must call the statement's Close method
  // when the statement is no longer needed.
  func (db *DB) Prepare(query string) (*Stmt, error) {
  	return db.PrepareContext(context.Background(), query)
  }
  
  func (db *DB) prepare(ctx context.Context, query string, strategy connReuseStrategy) (*Stmt, error) {
  	// TODO: check if db.driver supports an optional
  	// driver.Preparer interface and call that instead, if so,
  	// otherwise we make a prepared statement that's bound
  	// to a connection, and to execute this prepared statement
  	// we either need to use this connection (if it's free), else
  	// get a new connection + re-prepare + execute on that one.
  	dc, err := db.conn(ctx, strategy)
  	if err != nil {
  		return nil, err
  	}
  	return db.prepareDC(ctx, dc, dc.releaseConn, nil, query)
  }
  
  // prepareDC prepares a query on the driverConn and calls release before
  // returning. When cg == nil it implies that a connection pool is used, and
  // when cg != nil only a single driver connection is used.
  func (db *DB) prepareDC(ctx context.Context, dc *driverConn, release func(error), cg stmtConnGrabber, query string) (*Stmt, error) {
  	var ds *driverStmt
  	var err error
  	defer func() {
  		release(err)
  	}()
  	withLock(dc, func() {
  		ds, err = dc.prepareLocked(ctx, cg, query)
  	})
  	if err != nil {
  		return nil, err
  	}
  	stmt := &Stmt{
  		db:    db,
  		query: query,
  		cg:    cg,
  		cgds:  ds,
  	}
  
  	// When cg == nil this statement will need to keep track of various
  	// connections they are prepared on and record the stmt dependency on
  	// the DB.
  	if cg == nil {
  		stmt.css = []connStmt{{dc, ds}}
  		stmt.lastNumClosed = atomic.LoadUint64(&db.numClosed)
  		db.addDep(stmt, stmt)
  	}
  	return stmt, nil
  }
  
  // ExecContext executes a query without returning any rows.
  // The args are for any placeholder parameters in the query.
  func (db *DB) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error) {
  	var res Result
  	var err error
  	for i := 0; i < maxBadConnRetries; i++ {
  		res, err = db.exec(ctx, query, args, cachedOrNewConn)
  		if err != driver.ErrBadConn {
  			break
  		}
  	}
  	if err == driver.ErrBadConn {
  		return db.exec(ctx, query, args, alwaysNewConn)
  	}
  	return res, err
  }
  
  // Exec executes a query without returning any rows.
  // The args are for any placeholder parameters in the query.
  func (db *DB) Exec(query string, args ...interface{}) (Result, error) {
  	return db.ExecContext(context.Background(), query, args...)
  }
  
  func (db *DB) exec(ctx context.Context, query string, args []interface{}, strategy connReuseStrategy) (Result, error) {
  	dc, err := db.conn(ctx, strategy)
  	if err != nil {
  		return nil, err
  	}
  	return db.execDC(ctx, dc, dc.releaseConn, query, args)
  }
  
  func (db *DB) execDC(ctx context.Context, dc *driverConn, release func(error), query string, args []interface{}) (res Result, err error) {
  	defer func() {
  		release(err)
  	}()
  	execerCtx, ok := dc.ci.(driver.ExecerContext)
  	var execer driver.Execer
  	if !ok {
  		execer, ok = dc.ci.(driver.Execer)
  	}
  	if ok {
  		var nvdargs []driver.NamedValue
  		var resi driver.Result
  		withLock(dc, func() {
  			nvdargs, err = driverArgsConnLocked(dc.ci, nil, args)
  			if err != nil {
  				return
  			}
  			resi, err = ctxDriverExec(ctx, execerCtx, execer, query, nvdargs)
  		})
  		if err != driver.ErrSkip {
  			if err != nil {
  				return nil, err
  			}
  			return driverResult{dc, resi}, nil
  		}
  	}
  
  	var si driver.Stmt
  	withLock(dc, func() {
  		si, err = ctxDriverPrepare(ctx, dc.ci, query)
  	})
  	if err != nil {
  		return nil, err
  	}
  	ds := &driverStmt{Locker: dc, si: si}
  	defer ds.Close()
  	return resultFromStatement(ctx, dc.ci, ds, args...)
  }
  
  // QueryContext executes a query that returns rows, typically a SELECT.
  // The args are for any placeholder parameters in the query.
  func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) {
  	var rows *Rows
  	var err error
  	for i := 0; i < maxBadConnRetries; i++ {
  		rows, err = db.query(ctx, query, args, cachedOrNewConn)
  		if err != driver.ErrBadConn {
  			break
  		}
  	}
  	if err == driver.ErrBadConn {
  		return db.query(ctx, query, args, alwaysNewConn)
  	}
  	return rows, err
  }
  
  // Query executes a query that returns rows, typically a SELECT.
  // The args are for any placeholder parameters in the query.
  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)
  	if err != nil {
  		return nil, err
  	}
  
  	return db.queryDC(ctx, nil, dc, dc.releaseConn, query, args)
  }
  
  // queryDC executes a query on the given connection.
  // The connection gets released by the releaseConn function.
  // The ctx context is from a query method and the txctx context is from an
  // optional transaction context.
  func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []interface{}) (*Rows, error) {
  	queryerCtx, ok := dc.ci.(driver.QueryerContext)
  	var queryer driver.Queryer
  	if !ok {
  		queryer, ok = dc.ci.(driver.Queryer)
  	}
  	if ok {
  		var nvdargs []driver.NamedValue
  		var rowsi driver.Rows
  		var err error
  		withLock(dc, func() {
  			nvdargs, err = driverArgsConnLocked(dc.ci, nil, args)
  			if err != nil {
  				return
  			}
  			rowsi, err = ctxDriverQuery(ctx, queryerCtx, queryer, query, nvdargs)
  		})
  		if err != driver.ErrSkip {
  			if err != nil {
  				releaseConn(err)
  				return nil, err
  			}
  			// Note: ownership of dc passes to the *Rows, to be freed
  			// with releaseConn.
  			rows := &Rows{
  				dc:          dc,
  				releaseConn: releaseConn,
  				rowsi:       rowsi,
  			}
  			rows.initContextClose(ctx, txctx)
  			return rows, nil
  		}
  	}
  
  	var si driver.Stmt
  	var err error
  	withLock(dc, func() {
  		si, err = ctxDriverPrepare(ctx, dc.ci, query)
  	})
  	if err != nil {
  		releaseConn(err)
  		return nil, err
  	}
  
  	ds := &driverStmt{Locker: dc, si: si}
  	rowsi, err := rowsiFromStatement(ctx, dc.ci, ds, args...)
  	if err != nil {
  		ds.Close()
  		releaseConn(err)
  		return nil, err
  	}
  
  	// Note: ownership of ci passes to the *Rows, to be freed
  	// with releaseConn.
  	rows := &Rows{
  		dc:          dc,
  		releaseConn: releaseConn,
  		rowsi:       rowsi,
  		closeStmt:   ds,
  	}
  	rows.initContextClose(ctx, txctx)
  	return rows, nil
  }
  
  // QueryRowContext executes a query that is expected to return at most one row.
  // QueryRowContext always returns a non-nil value. Errors are deferred until
  // Row's Scan method is called.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row {
  	rows, err := db.QueryContext(ctx, query, args...)
  	return &Row{rows: rows, err: err}
  }
  
  // QueryRow executes a query that is expected to return at most one row.
  // QueryRow always returns a non-nil value. Errors are deferred until
  // Row's Scan method is called.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  func (db *DB) QueryRow(query string, args ...interface{}) *Row {
  	return db.QueryRowContext(context.Background(), query, args...)
  }
  
  // BeginTx starts a transaction.
  //
  // The provided context is used until the transaction is committed or rolled back.
  // If the context is canceled, the sql package will roll back
  // the transaction. Tx.Commit will return an error if the context provided to
  // BeginTx is canceled.
  //
  // The provided TxOptions is optional and may be nil if defaults should be used.
  // If a non-default isolation level is used that the driver doesn't support,
  // an error will be returned.
  func (db *DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) {
  	var tx *Tx
  	var err error
  	for i := 0; i < maxBadConnRetries; i++ {
  		tx, err = db.begin(ctx, opts, cachedOrNewConn)
  		if err != driver.ErrBadConn {
  			break
  		}
  	}
  	if err == driver.ErrBadConn {
  		return db.begin(ctx, opts, alwaysNewConn)
  	}
  	return tx, err
  }
  
  // Begin starts a transaction. The default isolation level is dependent on
  // the driver.
  func (db *DB) Begin() (*Tx, error) {
  	return db.BeginTx(context.Background(), nil)
  }
  
  func (db *DB) begin(ctx context.Context, opts *TxOptions, strategy connReuseStrategy) (tx *Tx, err error) {
  	dc, err := db.conn(ctx, strategy)
  	if err != nil {
  		return nil, err
  	}
  	return db.beginDC(ctx, dc, dc.releaseConn, opts)
  }
  
  // beginDC starts a transaction. The provided dc must be valid and ready to use.
  func (db *DB) beginDC(ctx context.Context, dc *driverConn, release func(error), opts *TxOptions) (tx *Tx, err error) {
  	var txi driver.Tx
  	withLock(dc, func() {
  		txi, err = ctxDriverBegin(ctx, opts, dc.ci)
  	})
  	if err != nil {
  		release(err)
  		return nil, err
  	}
  
  	// Schedule the transaction to rollback when the context is cancelled.
  	// The cancel function in Tx will be called after done is set to true.
  	ctx, cancel := context.WithCancel(ctx)
  	tx = &Tx{
  		db:          db,
  		dc:          dc,
  		releaseConn: release,
  		txi:         txi,
  		cancel:      cancel,
  		ctx:         ctx,
  	}
  	go tx.awaitDone()
  	return tx, nil
  }
  
  // Driver returns the database's underlying driver.
  func (db *DB) Driver() driver.Driver {
  	return db.connector.Driver()
  }
  
  // ErrConnDone is returned by any operation that is performed on a connection
  // that has already been returned to the connection pool.
  var ErrConnDone = errors.New("sql: connection is already closed")
  
  // Conn returns a single connection by either opening a new connection
  // or returning an existing connection from the connection pool. Conn will
  // block until either a connection is returned or ctx is canceled.
  // Queries run on the same Conn will be run in the same database session.
  //
  // Every Conn must be returned to the database pool after use by
  // calling Conn.Close.
  func (db *DB) Conn(ctx context.Context) (*Conn, error) {
  	var dc *driverConn
  	var err error
  	for i := 0; i < maxBadConnRetries; i++ {
  		dc, err = db.conn(ctx, cachedOrNewConn)
  		if err != driver.ErrBadConn {
  			break
  		}
  	}
  	if err == driver.ErrBadConn {
  		dc, err = db.conn(ctx, cachedOrNewConn)
  	}
  	if err != nil {
  		return nil, err
  	}
  
  	conn := &Conn{
  		db: db,
  		dc: dc,
  	}
  	return conn, nil
  }
  
  type releaseConn func(error)
  
  // Conn represents a single database connection rather than a pool of database
  // connections. Prefer running queries from DB unless there is a specific
  // need for a continuous single database connection.
  //
  // A Conn must call Close to return the connection to the database pool
  // and may do so concurrently with a running query.
  //
  // After a call to Close, all operations on the
  // connection fail with ErrConnDone.
  type Conn struct {
  	db *DB
  
  	// closemu prevents the connection from closing while there
  	// is an active query. It is held for read during queries
  	// and exclusively during close.
  	closemu sync.RWMutex
  
  	// dc is owned until close, at which point
  	// it's returned to the connection pool.
  	dc *driverConn
  
  	// done transitions from 0 to 1 exactly once, on close.
  	// Once done, all operations fail with ErrConnDone.
  	// Use atomic operations on value when checking value.
  	done int32
  }
  
  func (c *Conn) grabConn(context.Context) (*driverConn, releaseConn, error) {
  	if atomic.LoadInt32(&c.done) != 0 {
  		return nil, nil, ErrConnDone
  	}
  	c.closemu.RLock()
  	return c.dc, c.closemuRUnlockCondReleaseConn, nil
  }
  
  // PingContext verifies the connection to the database is still alive.
  func (c *Conn) PingContext(ctx context.Context) error {
  	dc, release, err := c.grabConn(ctx)
  	if err != nil {
  		return err
  	}
  	return c.db.pingDC(ctx, dc, release)
  }
  
  // ExecContext executes a query without returning any rows.
  // The args are for any placeholder parameters in the query.
  func (c *Conn) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error) {
  	dc, release, err := c.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  	return c.db.execDC(ctx, dc, release, query, args)
  }
  
  // QueryContext executes a query that returns rows, typically a SELECT.
  // The args are for any placeholder parameters in the query.
  func (c *Conn) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) {
  	dc, release, err := c.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  	return c.db.queryDC(ctx, nil, dc, release, query, args)
  }
  
  // QueryRowContext executes a query that is expected to return at most one row.
  // QueryRowContext always returns a non-nil value. Errors are deferred until
  // Row's Scan method is called.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  func (c *Conn) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row {
  	rows, err := c.QueryContext(ctx, query, args...)
  	return &Row{rows: rows, err: err}
  }
  
  // PrepareContext creates a prepared statement for later queries or executions.
  // Multiple queries or executions may be run concurrently from the
  // returned statement.
  // The caller must call the statement's Close method
  // when the statement is no longer needed.
  //
  // The provided context is used for the preparation of the statement, not for the
  // execution of the statement.
  func (c *Conn) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
  	dc, release, err := c.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  	return c.db.prepareDC(ctx, dc, release, c, query)
  }
  
  // BeginTx starts a transaction.
  //
  // The provided context is used until the transaction is committed or rolled back.
  // If the context is canceled, the sql package will roll back
  // the transaction. Tx.Commit will return an error if the context provided to
  // BeginTx is canceled.
  //
  // The provided TxOptions is optional and may be nil if defaults should be used.
  // If a non-default isolation level is used that the driver doesn't support,
  // an error will be returned.
  func (c *Conn) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) {
  	dc, release, err := c.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  	return c.db.beginDC(ctx, dc, release, opts)
  }
  
  // closemuRUnlockCondReleaseConn read unlocks closemu
  // as the sql operation is done with the dc.
  func (c *Conn) closemuRUnlockCondReleaseConn(err error) {
  	c.closemu.RUnlock()
  	if err == driver.ErrBadConn {
  		c.close(err)
  	}
  }
  
  func (c *Conn) txCtx() context.Context {
  	return nil
  }
  
  func (c *Conn) close(err error) error {
  	if !atomic.CompareAndSwapInt32(&c.done, 0, 1) {
  		return ErrConnDone
  	}
  
  	// Lock around releasing the driver connection
  	// to ensure all queries have been stopped before doing so.
  	c.closemu.Lock()
  	defer c.closemu.Unlock()
  
  	c.dc.releaseConn(err)
  	c.dc = nil
  	c.db = nil
  	return err
  }
  
  // Close returns the connection to the connection pool.
  // All operations after a Close will return with ErrConnDone.
  // Close is safe to call concurrently with other operations and will
  // block until all other operations finish. It may be useful to first
  // cancel any used context and then call close directly after.
  func (c *Conn) Close() error {
  	return c.close(nil)
  }
  
  // Tx is an in-progress database transaction.
  //
  // A transaction must end with a call to Commit or Rollback.
  //
  // After a call to Commit or Rollback, all operations on the
  // transaction fail with ErrTxDone.
  //
  // The statements prepared for a transaction by calling
  // the transaction's Prepare or Stmt methods are closed
  // by the call to Commit or Rollback.
  type Tx struct {
  	db *DB
  
  	// closemu prevents the transaction from closing while there
  	// is an active query. It is held for read during queries
  	// and exclusively during close.
  	closemu sync.RWMutex
  
  	// dc is owned exclusively until Commit or Rollback, at which point
  	// it's returned with putConn.
  	dc  *driverConn
  	txi driver.Tx
  
  	// releaseConn is called once the Tx is closed to release
  	// any held driverConn back to the pool.
  	releaseConn func(error)
  
  	// done transitions from 0 to 1 exactly once, on Commit
  	// or Rollback. once done, all operations fail with
  	// ErrTxDone.
  	// Use atomic operations on value when checking value.
  	done int32
  
  	// All Stmts prepared for this transaction. These will be closed after the
  	// transaction has been committed or rolled back.
  	stmts struct {
  		sync.Mutex
  		v []*Stmt
  	}
  
  	// cancel is called after done transitions from 0 to 1.
  	cancel func()
  
  	// ctx lives for the life of the transaction.
  	ctx context.Context
  }
  
  // awaitDone blocks until the context in Tx is canceled and rolls back
  // the transaction if it's not already done.
  func (tx *Tx) awaitDone() {
  	// Wait for either the transaction to be committed or rolled
  	// back, or for the associated context to be closed.
  	<-tx.ctx.Done()
  
  	// Discard and close the connection used to ensure the
  	// transaction is closed and the resources are released.  This
  	// rollback does nothing if the transaction has already been
  	// committed or rolled back.
  	tx.rollback(true)
  }
  
  func (tx *Tx) isDone() bool {
  	return atomic.LoadInt32(&tx.done) != 0
  }
  
  // ErrTxDone is returned by any operation that is performed on a transaction
  // that has already been committed or rolled back.
  var ErrTxDone = errors.New("sql: transaction has already been committed or rolled back")
  
  // close returns the connection to the pool and
  // must only be called by Tx.rollback or Tx.Commit.
  func (tx *Tx) close(err error) {
  	tx.cancel()
  
  	tx.closemu.Lock()
  	defer tx.closemu.Unlock()
  
  	tx.releaseConn(err)
  	tx.dc = nil
  	tx.txi = nil
  }
  
  // hookTxGrabConn specifies an optional hook to be called on
  // a successful call to (*Tx).grabConn. For tests.
  var hookTxGrabConn func()
  
  func (tx *Tx) grabConn(ctx context.Context) (*driverConn, releaseConn, error) {
  	select {
  	default:
  	case <-ctx.Done():
  		return nil, nil, ctx.Err()
  	}
  
  	// closeme.RLock must come before the check for isDone to prevent the Tx from
  	// closing while a query is executing.
  	tx.closemu.RLock()
  	if tx.isDone() {
  		tx.closemu.RUnlock()
  		return nil, nil, ErrTxDone
  	}
  	if hookTxGrabConn != nil { // test hook
  		hookTxGrabConn()
  	}
  	return tx.dc, tx.closemuRUnlockRelease, nil
  }
  
  func (tx *Tx) txCtx() context.Context {
  	return tx.ctx
  }
  
  // closemuRUnlockRelease is used as a func(error) method value in
  // ExecContext and QueryContext. Unlocking in the releaseConn keeps
  // the driver conn from being returned to the connection pool until
  // the Rows has been closed.
  func (tx *Tx) closemuRUnlockRelease(error) {
  	tx.closemu.RUnlock()
  }
  
  // Closes all Stmts prepared for this transaction.
  func (tx *Tx) closePrepared() {
  	tx.stmts.Lock()
  	defer tx.stmts.Unlock()
  	for _, stmt := range tx.stmts.v {
  		stmt.Close()
  	}
  }
  
  // Commit commits the transaction.
  func (tx *Tx) Commit() error {
  	// Check context first to avoid transaction leak.
  	// If put it behind tx.done CompareAndSwap statement, we can't ensure
  	// the consistency between tx.done and the real COMMIT operation.
  	select {
  	default:
  	case <-tx.ctx.Done():
  		if atomic.LoadInt32(&tx.done) == 1 {
  			return ErrTxDone
  		}
  		return tx.ctx.Err()
  	}
  	if !atomic.CompareAndSwapInt32(&tx.done, 0, 1) {
  		return ErrTxDone
  	}
  	var err error
  	withLock(tx.dc, func() {
  		err = tx.txi.Commit()
  	})
  	if err != driver.ErrBadConn {
  		tx.closePrepared()
  	}
  	tx.close(err)
  	return err
  }
  
  // rollback aborts the transaction and optionally forces the pool to discard
  // the connection.
  func (tx *Tx) rollback(discardConn bool) error {
  	if !atomic.CompareAndSwapInt32(&tx.done, 0, 1) {
  		return ErrTxDone
  	}
  	var err error
  	withLock(tx.dc, func() {
  		err = tx.txi.Rollback()
  	})
  	if err != driver.ErrBadConn {
  		tx.closePrepared()
  	}
  	if discardConn {
  		err = driver.ErrBadConn
  	}
  	tx.close(err)
  	return err
  }
  
  // Rollback aborts the transaction.
  func (tx *Tx) Rollback() error {
  	return tx.rollback(false)
  }
  
  // PrepareContext creates a prepared statement for use within a transaction.
  //
  // The returned statement operates within the transaction and will be closed
  // when the transaction has been committed or rolled back.
  //
  // To use an existing prepared statement on this transaction, see Tx.Stmt.
  //
  // The provided context will be used for the preparation of the context, not
  // for the execution of the returned statement. The returned statement
  // will run in the transaction context.
  func (tx *Tx) PrepareContext(ctx context.Context, query string) (*Stmt, error) {
  	dc, release, err := tx.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  
  	stmt, err := tx.db.prepareDC(ctx, dc, release, tx, query)
  	if err != nil {
  		return nil, err
  	}
  	tx.stmts.Lock()
  	tx.stmts.v = append(tx.stmts.v, stmt)
  	tx.stmts.Unlock()
  	return stmt, nil
  }
  
  // Prepare creates a prepared statement for use within a transaction.
  //
  // The returned statement operates within the transaction and can no longer
  // be used once the transaction has been committed or rolled back.
  //
  // To use an existing prepared statement on this transaction, see Tx.Stmt.
  func (tx *Tx) Prepare(query string) (*Stmt, error) {
  	return tx.PrepareContext(context.Background(), query)
  }
  
  // StmtContext returns a transaction-specific prepared statement from
  // an existing statement.
  //
  // Example:
  //  updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")
  //  ...
  //  tx, err := db.Begin()
  //  ...
  //  res, err := tx.StmtContext(ctx, updateMoney).Exec(123.45, 98293203)
  //
  // The provided context is used for the preparation of the statement, not for the
  // execution of the statement.
  //
  // The returned statement operates within the transaction and will be closed
  // when the transaction has been committed or rolled back.
  func (tx *Tx) StmtContext(ctx context.Context, stmt *Stmt) *Stmt {
  	dc, release, err := tx.grabConn(ctx)
  	if err != nil {
  		return &Stmt{stickyErr: err}
  	}
  	defer release(nil)
  
  	if tx.db != stmt.db {
  		return &Stmt{stickyErr: errors.New("sql: Tx.Stmt: statement from different database used")}
  	}
  	var si driver.Stmt
  	var parentStmt *Stmt
  	stmt.mu.Lock()
  	if stmt.closed || stmt.cg != nil {
  		// If the statement has been closed or already belongs to a
  		// transaction, we can't reuse it in this connection.
  		// Since tx.StmtContext should never need to be called with a
  		// Stmt already belonging to tx, we ignore this edge case and
  		// re-prepare the statement in this case. No need to add
  		// code-complexity for this.
  		stmt.mu.Unlock()
  		withLock(dc, func() {
  			si, err = ctxDriverPrepare(ctx, dc.ci, stmt.query)
  		})
  		if err != nil {
  			return &Stmt{stickyErr: err}
  		}
  	} else {
  		stmt.removeClosedStmtLocked()
  		// See if the statement has already been prepared on this connection,
  		// and reuse it if possible.
  		for _, v := range stmt.css {
  			if v.dc == dc {
  				si = v.ds.si
  				break
  			}
  		}
  
  		stmt.mu.Unlock()
  
  		if si == nil {
  			var ds *driverStmt
  			withLock(dc, func() {
  				ds, err = stmt.prepareOnConnLocked(ctx, dc)
  			})
  			if err != nil {
  				return &Stmt{stickyErr: err}
  			}
  			si = ds.si
  		}
  		parentStmt = stmt
  	}
  
  	txs := &Stmt{
  		db: tx.db,
  		cg: tx,
  		cgds: &driverStmt{
  			Locker: dc,
  			si:     si,
  		},
  		parentStmt: parentStmt,
  		query:      stmt.query,
  	}
  	if parentStmt != nil {
  		tx.db.addDep(parentStmt, txs)
  	}
  	tx.stmts.Lock()
  	tx.stmts.v = append(tx.stmts.v, txs)
  	tx.stmts.Unlock()
  	return txs
  }
  
  // Stmt returns a transaction-specific prepared statement from
  // an existing statement.
  //
  // Example:
  //  updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")
  //  ...
  //  tx, err := db.Begin()
  //  ...
  //  res, err := tx.Stmt(updateMoney).Exec(123.45, 98293203)
  //
  // The returned statement operates within the transaction and will be closed
  // when the transaction has been committed or rolled back.
  func (tx *Tx) Stmt(stmt *Stmt) *Stmt {
  	return tx.StmtContext(context.Background(), stmt)
  }
  
  // ExecContext executes a query that doesn't return rows.
  // For example: an INSERT and UPDATE.
  func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error) {
  	dc, release, err := tx.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  	return tx.db.execDC(ctx, dc, release, query, args)
  }
  
  // Exec executes a query that doesn't return rows.
  // For example: an INSERT and UPDATE.
  func (tx *Tx) Exec(query string, args ...interface{}) (Result, error) {
  	return tx.ExecContext(context.Background(), query, args...)
  }
  
  // QueryContext executes a query that returns rows, typically a SELECT.
  func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) {
  	dc, release, err := tx.grabConn(ctx)
  	if err != nil {
  		return nil, err
  	}
  
  	return tx.db.queryDC(ctx, tx.ctx, dc, release, query, args)
  }
  
  // Query executes a query that returns rows, typically a SELECT.
  func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error) {
  	return tx.QueryContext(context.Background(), query, args...)
  }
  
  // QueryRowContext executes a query that is expected to return at most one row.
  // QueryRowContext always returns a non-nil value. Errors are deferred until
  // Row's Scan method is called.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row {
  	rows, err := tx.QueryContext(ctx, query, args...)
  	return &Row{rows: rows, err: err}
  }
  
  // QueryRow executes a query that is expected to return at most one row.
  // QueryRow always returns a non-nil value. Errors are deferred until
  // Row's Scan method is called.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  func (tx *Tx) QueryRow(query string, args ...interface{}) *Row {
  	return tx.QueryRowContext(context.Background(), query, args...)
  }
  
  // connStmt is a prepared statement on a particular connection.
  type connStmt struct {
  	dc *driverConn
  	ds *driverStmt
  }
  
  // stmtConnGrabber represents a Tx or Conn that will return the underlying
  // driverConn and release function.
  type stmtConnGrabber interface {
  	// grabConn returns the driverConn and the associated release function
  	// that must be called when the operation completes.
  	grabConn(context.Context) (*driverConn, releaseConn, error)
  
  	// txCtx returns the transaction context if available.
  	// The returned context should be selected on along with
  	// any query context when awaiting a cancel.
  	txCtx() context.Context
  }
  
  var (
  	_ stmtConnGrabber = &Tx{}
  	_ stmtConnGrabber = &Conn{}
  )
  
  // Stmt is a prepared statement.
  // A Stmt is safe for concurrent use by multiple goroutines.
  type Stmt struct {
  	// Immutable:
  	db        *DB    // where we came from
  	query     string // that created the Stmt
  	stickyErr error  // if non-nil, this error is returned for all operations
  
  	closemu sync.RWMutex // held exclusively during close, for read otherwise.
  
  	// If Stmt is prepared on a Tx or Conn then cg is present and will
  	// only ever grab a connection from cg.
  	// If cg is nil then the Stmt must grab an arbitrary connection
  	// from db and determine if it must prepare the stmt again by
  	// inspecting css.
  	cg   stmtConnGrabber
  	cgds *driverStmt
  
  	// parentStmt is set when a transaction-specific statement
  	// is requested from an identical statement prepared on the same
  	// conn. parentStmt is used to track the dependency of this statement
  	// on its originating ("parent") statement so that parentStmt may
  	// be closed by the user without them having to know whether or not
  	// any transactions are still using it.
  	parentStmt *Stmt
  
  	mu     sync.Mutex // protects the rest of the fields
  	closed bool
  
  	// css is a list of underlying driver statement interfaces
  	// that are valid on particular connections. This is only
  	// used if cg == nil and one is found that has idle
  	// connections. If cg != nil, cgds is always used.
  	css []connStmt
  
  	// lastNumClosed is copied from db.numClosed when Stmt is created
  	// without tx and closed connections in css are removed.
  	lastNumClosed uint64
  }
  
  // ExecContext executes a prepared statement with the given arguments and
  // returns a Result summarizing the effect of the statement.
  func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (Result, error) {
  	s.closemu.RLock()
  	defer s.closemu.RUnlock()
  
  	var res Result
  	strategy := cachedOrNewConn
  	for i := 0; i < maxBadConnRetries+1; i++ {
  		if i == maxBadConnRetries {
  			strategy = alwaysNewConn
  		}
  		dc, releaseConn, ds, err := s.connStmt(ctx, strategy)
  		if err != nil {
  			if err == driver.ErrBadConn {
  				continue
  			}
  			return nil, err
  		}
  
  		res, err = resultFromStatement(ctx, dc.ci, ds, args...)
  		releaseConn(err)
  		if err != driver.ErrBadConn {
  			return res, err
  		}
  	}
  	return nil, driver.ErrBadConn
  }
  
  // Exec executes a prepared statement with the given arguments and
  // returns a Result summarizing the effect of the statement.
  func (s *Stmt) Exec(args ...interface{}) (Result, error) {
  	return s.ExecContext(context.Background(), args...)
  }
  
  func resultFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...interface{}) (Result, error) {
  	ds.Lock()
  	defer ds.Unlock()
  
  	dargs, err := driverArgsConnLocked(ci, ds, args)
  	if err != nil {
  		return nil, err
  	}
  
  	resi, err := ctxDriverStmtExec(ctx, ds.si, dargs)
  	if err != nil {
  		return nil, err
  	}
  	return driverResult{ds.Locker, resi}, nil
  }
  
  // removeClosedStmtLocked removes closed conns in s.css.
  //
  // To avoid lock contention on DB.mu, we do it only when
  // s.db.numClosed - s.lastNum is large enough.
  func (s *Stmt) removeClosedStmtLocked() {
  	t := len(s.css)/2 + 1
  	if t > 10 {
  		t = 10
  	}
  	dbClosed := atomic.LoadUint64(&s.db.numClosed)
  	if dbClosed-s.lastNumClosed < uint64(t) {
  		return
  	}
  
  	s.db.mu.Lock()
  	for i := 0; i < len(s.css); i++ {
  		if s.css[i].dc.dbmuClosed {
  			s.css[i] = s.css[len(s.css)-1]
  			s.css = s.css[:len(s.css)-1]
  			i--
  		}
  	}
  	s.db.mu.Unlock()
  	s.lastNumClosed = dbClosed
  }
  
  // connStmt returns a free driver connection on which to execute the
  // statement, a function to call to release the connection, and a
  // statement bound to that connection.
  func (s *Stmt) connStmt(ctx context.Context, strategy connReuseStrategy) (dc *driverConn, releaseConn func(error), ds *driverStmt, err error) {
  	if err = s.stickyErr; err != nil {
  		return
  	}
  	s.mu.Lock()
  	if s.closed {
  		s.mu.Unlock()
  		err = errors.New("sql: statement is closed")
  		return
  	}
  
  	// In a transaction or connection, we always use the connection that the
  	// stmt was created on.
  	if s.cg != nil {
  		s.mu.Unlock()
  		dc, releaseConn, err = s.cg.grabConn(ctx) // blocks, waiting for the connection.
  		if err != nil {
  			return
  		}
  		return dc, releaseConn, s.cgds, nil
  	}
  
  	s.removeClosedStmtLocked()
  	s.mu.Unlock()
  
  	dc, err = s.db.conn(ctx, strategy)
  	if err != nil {
  		return nil, nil, nil, err
  	}
  
  	s.mu.Lock()
  	for _, v := range s.css {
  		if v.dc == dc {
  			s.mu.Unlock()
  			return dc, dc.releaseConn, v.ds, nil
  		}
  	}
  	s.mu.Unlock()
  
  	// No luck; we need to prepare the statement on this connection
  	withLock(dc, func() {
  		ds, err = s.prepareOnConnLocked(ctx, dc)
  	})
  	if err != nil {
  		dc.releaseConn(err)
  		return nil, nil, nil, err
  	}
  
  	return dc, dc.releaseConn, ds, nil
  }
  
  // prepareOnConnLocked prepares the query in Stmt s on dc and adds it to the list of
  // open connStmt on the statement. It assumes the caller is holding the lock on dc.
  func (s *Stmt) prepareOnConnLocked(ctx context.Context, dc *driverConn) (*driverStmt, error) {
  	si, err := dc.prepareLocked(ctx, s.cg, s.query)
  	if err != nil {
  		return nil, err
  	}
  	cs := connStmt{dc, si}
  	s.mu.Lock()
  	s.css = append(s.css, cs)
  	s.mu.Unlock()
  	return cs.ds, nil
  }
  
  // QueryContext executes a prepared query statement with the given arguments
  // and returns the query results as a *Rows.
  func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, error) {
  	s.closemu.RLock()
  	defer s.closemu.RUnlock()
  
  	var rowsi driver.Rows
  	strategy := cachedOrNewConn
  	for i := 0; i < maxBadConnRetries+1; i++ {
  		if i == maxBadConnRetries {
  			strategy = alwaysNewConn
  		}
  		dc, releaseConn, ds, err := s.connStmt(ctx, strategy)
  		if err != nil {
  			if err == driver.ErrBadConn {
  				continue
  			}
  			return nil, err
  		}
  
  		rowsi, err = rowsiFromStatement(ctx, dc.ci, ds, args...)
  		if err == nil {
  			// Note: ownership of ci passes to the *Rows, to be freed
  			// with releaseConn.
  			rows := &Rows{
  				dc:    dc,
  				rowsi: rowsi,
  				// releaseConn set below
  			}
  			// addDep must be added before initContextClose or it could attempt
  			// to removeDep before it has been added.
  			s.db.addDep(s, rows)
  
  			// releaseConn must be set before initContextClose or it could
  			// release the connection before it is set.
  			rows.releaseConn = func(err error) {
  				releaseConn(err)
  				s.db.removeDep(s, rows)
  			}
  			var txctx context.Context
  			if s.cg != nil {
  				txctx = s.cg.txCtx()
  			}
  			rows.initContextClose(ctx, txctx)
  			return rows, nil
  		}
  
  		releaseConn(err)
  		if err != driver.ErrBadConn {
  			return nil, err
  		}
  	}
  	return nil, driver.ErrBadConn
  }
  
  // Query executes a prepared query statement with the given arguments
  // and returns the query results as a *Rows.
  func (s *Stmt) Query(args ...interface{}) (*Rows, error) {
  	return s.QueryContext(context.Background(), args...)
  }
  
  func rowsiFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...interface{}) (driver.Rows, error) {
  	ds.Lock()
  	defer ds.Unlock()
  	dargs, err := driverArgsConnLocked(ci, ds, args)
  	if err != nil {
  		return nil, err
  	}
  	return ctxDriverStmtQuery(ctx, ds.si, dargs)
  }
  
  // QueryRowContext executes a prepared query statement with the given arguments.
  // If an error occurs during the execution of the statement, that error will
  // be returned by a call to Scan on the returned *Row, which is always non-nil.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *Row {
  	rows, err := s.QueryContext(ctx, args...)
  	if err != nil {
  		return &Row{err: err}
  	}
  	return &Row{rows: rows}
  }
  
  // QueryRow executes a prepared query statement with the given arguments.
  // If an error occurs during the execution of the statement, that error will
  // be returned by a call to Scan on the returned *Row, which is always non-nil.
  // If the query selects no rows, the *Row's Scan will return ErrNoRows.
  // Otherwise, the *Row's Scan scans the first selected row and discards
  // the rest.
  //
  // Example usage:
  //
  //  var name string
  //  err := nameByUseridStmt.QueryRow(id).Scan(&name)
  func (s *Stmt) QueryRow(args ...interface{}) *Row {
  	return s.QueryRowContext(context.Background(), args...)
  }
  
  // Close closes the statement.
  func (s *Stmt) Close() error {
  	s.closemu.Lock()
  	defer s.closemu.Unlock()
  
  	if s.stickyErr != nil {
  		return s.stickyErr
  	}
  	s.mu.Lock()
  	if s.closed {
  		s.mu.Unlock()
  		return nil
  	}
  	s.closed = true
  	txds := s.cgds
  	s.cgds = nil
  
  	s.mu.Unlock()
  
  	if s.cg == nil {
  		return s.db.removeDep(s, s)
  	}
  
  	if s.parentStmt != nil {
  		// If parentStmt is set, we must not close s.txds since it's stored
  		// in the css array of the parentStmt.
  		return s.db.removeDep(s.parentStmt, s)
  	}
  	return txds.Close()
  }
  
  func (s *Stmt) finalClose() error {
  	s.mu.Lock()
  	defer s.mu.Unlock()
  	if s.css != nil {
  		for _, v := range s.css {
  			s.db.noteUnusedDriverStatement(v.dc, v.ds)
  			v.dc.removeOpenStmt(v.ds)
  		}
  		s.css = nil
  	}
  	return nil
  }
  
  // Rows is the result of a query. Its cursor starts before the first row
  // of the result set. Use Next to advance from row to row.
  type Rows struct {
  	dc          *driverConn // owned; must call releaseConn when closed to release
  	releaseConn func(error)
  	rowsi       driver.Rows
  	cancel      func()      // called when Rows is closed, may be nil.
  	closeStmt   *driverStmt // if non-nil, statement to Close on close
  
  	// closemu prevents Rows from closing while there
  	// is an active streaming result. It is held for read during non-close operations
  	// and exclusively during close.
  	//
  	// closemu guards lasterr and closed.
  	closemu sync.RWMutex
  	closed  bool
  	lasterr error // non-nil only if closed is true
  
  	// lastcols is only used in Scan, Next, and NextResultSet which are expected
  	// not to be called concurrently.
  	lastcols []driver.Value
  }
  
  func (rs *Rows) initContextClose(ctx, txctx context.Context) {
  	if ctx.Done() == nil && (txctx == nil || txctx.Done() == nil) {
  		return
  	}
  	ctx, rs.cancel = context.WithCancel(ctx)
  	go rs.awaitDone(ctx, txctx)
  }
  
  // awaitDone blocks until either ctx or txctx is canceled. The ctx is provided
  // from the query context and is canceled when the query Rows is closed.
  // If the query was issued in a transaction, the transaction's context
  // is also provided in txctx to ensure Rows is closed if the Tx is closed.
  func (rs *Rows) awaitDone(ctx, txctx context.Context) {
  	var txctxDone <-chan struct{}
  	if txctx != nil {
  		txctxDone = txctx.Done()
  	}
  	select {
  	case <-ctx.Done():
  	case <-txctxDone:
  	}
  	rs.close(ctx.Err())
  }
  
  // Next prepares the next result row for reading with the Scan method. It
  // returns true on success, or false if there is no next result row or an error
  // happened while preparing it. Err should be consulted to distinguish between
  // the two cases.
  //
  // Every call to Scan, even the first one, must be preceded by a call to 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) nextLocked() (doClose, ok bool) {
  	if rs.closed {
  		return false, false
  	}
  
  	// Lock the driver connection before calling the driver interface
  	// rowsi to prevent a Tx from rolling back the connection at the same time.
  	rs.dc.Lock()
  	defer rs.dc.Unlock()
  
  	if rs.lastcols == nil {
  		rs.lastcols = make([]driver.Value, len(rs.rowsi.Columns()))
  	}
  
  	rs.lasterr = rs.rowsi.Next(rs.lastcols)
  	if rs.lasterr != nil {
  		// Close the connection if there is a driver error.
  		if rs.lasterr != io.EOF {
  			return true, false
  		}
  		nextResultSet, ok := rs.rowsi.(driver.RowsNextResultSet)
  		if !ok {
  			return true, false
  		}
  		// The driver is at the end of the current result set.
  		// Test to see if there is another result set after the current one.
  		// Only close Rows if there is no further result sets to read.
  		if !nextResultSet.HasNextResultSet() {
  			doClose = true
  		}
  		return doClose, false
  	}
  	return false, true
  }
  
  // NextResultSet prepares the next result set for reading. It returns true if
  // there is further result sets, or false if there is no further result set
  // or if there is an error advancing to it. The Err method should be consulted
  // to distinguish between the two cases.
  //
  // After calling NextResultSet, the Next method should always be called before
  // scanning. If there are further result sets they may not have rows in the result
  // set.
  func (rs *Rows) NextResultSet() bool {
  	var doClose bool
  	defer func() {
  		if doClose {
  			rs.Close()
  		}
  	}()
  	rs.closemu.RLock()
  	defer rs.closemu.RUnlock()
  
  	if rs.closed {
  		return false
  	}
  
  	rs.lastcols = nil
  	nextResultSet, ok := rs.rowsi.(driver.RowsNextResultSet)
  	if !ok {
  		doClose = true
  		return false
  	}
  
  	// Lock the driver connection before calling the driver interface
  	// rowsi to prevent a Tx from rolling back the connection at the same time.
  	rs.dc.Lock()
  	defer rs.dc.Unlock()
  
  	rs.lasterr = nextResultSet.NextResultSet()
  	if rs.lasterr != nil {
  		doClose = true
  		return false
  	}
  	return true
  }
  
  // Err returns the error, if any, that was encountered during iteration.
  // Err may be called after an explicit or implicit Close.
  func (rs *Rows) Err() error {
  	rs.closemu.RLock()
  	defer rs.closemu.RUnlock()
  	if rs.lasterr == io.EOF {
  		return nil
  	}
  	return rs.lasterr
  }
  
  // Columns returns the column names.
  // Columns returns an error if the rows are closed, or if the rows
  // are from QueryRow and there was a deferred error.
  func (rs *Rows) Columns() ([]string, error) {
  	rs.closemu.RLock()
  	defer rs.closemu.RUnlock()
  	if rs.closed {
  		return nil, errors.New("sql: Rows are closed")
  	}
  	if rs.rowsi == nil {
  		return nil, errors.New("sql: no Rows available")
  	}
  	rs.dc.Lock()
  	defer rs.dc.Unlock()
  
  	return rs.rowsi.Columns(), nil
  }
  
  // ColumnTypes returns column information such as column type, length,
  // and nullable. Some information may not be available from some drivers.
  func (rs *Rows) ColumnTypes() ([]*ColumnType, error) {
  	rs.closemu.RLock()
  	defer rs.closemu.RUnlock()
  	if rs.closed {
  		return nil, errors.New("sql: Rows are closed")
  	}
  	if rs.rowsi == nil {
  		return nil, errors.New("sql: no Rows available")
  	}
  	rs.dc.Lock()
  	defer rs.dc.Unlock()
  
  	return rowsColumnInfoSetupConnLocked(rs.rowsi), nil
  }
  
  // ColumnType contains the name and type of a column.
  type ColumnType struct {
  	name string
  
  	hasNullable       bool
  	hasLength         bool
  	hasPrecisionScale bool
  
  	nullable     bool
  	length       int64
  	databaseType string
  	precision    int64
  	scale        int64
  	scanType     reflect.Type
  }
  
  // Name returns the name or alias of the column.
  func (ci *ColumnType) Name() string {
  	return ci.name
  }
  
  // Length returns the column type length for variable length column types such
  // as text and binary field types. If the type length is unbounded the value will
  // be math.MaxInt64 (any database limits will still apply).
  // If the column type is not variable length, such as an int, or if not supported
  // by the driver ok is false.
  func (ci *ColumnType) Length() (length int64, ok bool) {
  	return ci.length, ci.hasLength
  }
  
  // DecimalSize returns the scale and precision of a decimal type.
  // If not applicable or if not supported ok is false.
  func (ci *ColumnType) DecimalSize() (precision, scale int64, ok bool) {
  	return ci.precision, ci.scale, ci.hasPrecisionScale
  }
  
  // ScanType returns a Go type suitable for scanning into using Rows.Scan.
  // If a driver does not support this property ScanType will return
  // the type of an empty interface.
  func (ci *ColumnType) ScanType() reflect.Type {
  	return ci.scanType
  }
  
  // Nullable returns whether the column may be null.
  // If a driver does not support this property ok will be false.
  func (ci *ColumnType) Nullable() (nullable, ok bool) {
  	return ci.nullable, ci.hasNullable
  }
  
  // DatabaseTypeName returns the database system name of the column type. If an empty
  // string is returned the driver type name is not supported.
  // Consult your driver documentation for a list of driver data types. Length specifiers
  // are not included.
  // Common type include "VARCHAR", "TEXT", "NVARCHAR", "DECIMAL", "BOOL", "INT", "BIGINT".
  func (ci *ColumnType) DatabaseTypeName() string {
  	return ci.databaseType
  }
  
  func rowsColumnInfoSetupConnLocked(rowsi driver.Rows) []*ColumnType {
  	names := rowsi.Columns()
  
  	list := make([]*ColumnType, len(names))
  	for i := range list {
  		ci := &ColumnType{
  			name: names[i],
  		}
  		list[i] = ci
  
  		if prop, ok := rowsi.(driver.RowsColumnTypeScanType); ok {
  			ci.scanType = prop.ColumnTypeScanType(i)
  		} else {
  			ci.scanType = reflect.TypeOf(new(interface{})).Elem()
  		}
  		if prop, ok := rowsi.(driver.RowsColumnTypeDatabaseTypeName); ok {
  			ci.databaseType = prop.ColumnTypeDatabaseTypeName(i)
  		}
  		if prop, ok := rowsi.(driver.RowsColumnTypeLength); ok {
  			ci.length, ci.hasLength = prop.ColumnTypeLength(i)
  		}
  		if prop, ok := rowsi.(driver.RowsColumnTypeNullable); ok {
  			ci.nullable, ci.hasNullable = prop.ColumnTypeNullable(i)
  		}
  		if prop, ok := rowsi.(driver.RowsColumnTypePrecisionScale); ok {
  			ci.precision, ci.scale, ci.hasPrecisionScale = prop.ColumnTypePrecisionScale(i)
  		}
  	}
  	return list
  }
  
  // Scan copies the columns in the current row into the values pointed
  // at by dest. The number of values in dest must be the same as the
  // number of columns in Rows.
  //
  // Scan converts columns read from the database into the following
  // common Go types and special types provided by the sql package:
  //
  //    *string
  //    *[]byte
  //    *int, *int8, *int16, *int32, *int64
  //    *uint, *uint8, *uint16, *uint32, *uint64
  //    *bool
  //    *float32, *float64
  //    *interface{}
  //    *RawBytes
  //    any type implementing Scanner (see Scanner docs)
  //
  // In the most simple case, if the type of the value from the source
  // column is an integer, bool or string type T and dest is of type *T,
  // Scan simply assigns the value through the pointer.
  //
  // Scan also converts between string and numeric types, as long as no
  // information would be lost. While Scan stringifies all numbers
  // scanned from numeric database columns into *string, scans into
  // numeric types are checked for overflow. For example, a float64 with
  // value 300 or a string with value "300" can scan into a uint16, but
  // not into a uint8, though float64(255) or "255" can scan into a
  // uint8. One exception is that scans of some float64 numbers to
  // strings may lose information when stringifying. In general, scan
  // floating point columns into *float64.
  //
  // If a dest argument has type *[]byte, Scan saves in that argument a
  // copy of the corresponding data. The copy is owned by the caller and
  // can be modified and held indefinitely. The copy can be avoided by
  // using an argument of type *RawBytes instead; see the documentation
  // for RawBytes for restrictions on its use.
  //
  // If an argument has type *interface{}, Scan copies the value
  // provided by the underlying driver without conversion. When scanning
  // from a source value of type []byte to *interface{}, a copy of the
  // slice is made and the caller owns the result.
  //
  // Source values of type time.Time may be scanned into values of type
  // *time.Time, *interface{}, *string, or *[]byte. When converting to
  // the latter two, time.RFC3339Nano is used.
  //
  // Source values of type bool may be scanned into types *bool,
  // *interface{}, *string, *[]byte, or *RawBytes.
  //
  // For scanning into *bool, the source may be true, false, 1, 0, or
  // string inputs parseable by strconv.ParseBool.
  func (rs *Rows) Scan(dest ...interface{}) error {
  	rs.closemu.RLock()
  
  	if rs.lasterr != nil && rs.lasterr != io.EOF {
  		rs.closemu.RUnlock()
  		return rs.lasterr
  	}
  	if rs.closed {
  		rs.closemu.RUnlock()
  		return errors.New("sql: Rows are closed")
  	}
  	rs.closemu.RUnlock()
  
  	if rs.lastcols == nil {
  		return errors.New("sql: Scan called without calling Next")
  	}
  	if len(dest) != len(rs.lastcols) {
  		return fmt.Errorf("sql: expected %d destination arguments in Scan, not %d", len(rs.lastcols), len(dest))
  	}
  	for i, sv := range rs.lastcols {
  		err := convertAssign(dest[i], sv)
  		if err != nil {
  			return fmt.Errorf(`sql: Scan error on column index %d, name %q: %v`, i, rs.rowsi.Columns()[i], err)
  		}
  	}
  	return nil
  }
  
  // rowsCloseHook returns a function so tests may install the
  // hook through a test only mutex.
  var rowsCloseHook = func() func(*Rows, *error) { return nil }
  
  // Close closes the Rows, preventing further enumeration. If Next is called
  // and returns false and there are no further result sets,
  // the Rows are closed automatically and it will suffice to check the
  // result of Err. Close is idempotent and does not affect the result of Err.
  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
  
  	if rs.lasterr == nil {
  		rs.lasterr = err
  	}
  
  	withLock(rs.dc, func() {
  		err = rs.rowsi.Close()
  	})
  	if fn := rowsCloseHook(); fn != nil {
  		fn(rs, &err)
  	}
  	if rs.cancel != nil {
  		rs.cancel()
  	}
  
  	if rs.closeStmt != nil {
  		rs.closeStmt.Close()
  	}
  	rs.releaseConn(err)
  	return err
  }
  
  // Row is the result of calling QueryRow to select a single row.
  type Row struct {
  	// One of these two will be non-nil:
  	err  error // deferred error for easy chaining
  	rows *Rows
  }
  
  // Scan copies the columns from the matched row into the values
  // pointed at by dest. See the documentation on Rows.Scan for details.
  // If more than one row matches the query,
  // Scan uses the first row and discards the rest. If no row matches
  // the query, Scan returns ErrNoRows.
  func (r *Row) Scan(dest ...interface{}) error {
  	if r.err != nil {
  		return r.err
  	}
  
  	// TODO(bradfitz): for now we need to defensively clone all
  	// []byte that the driver returned (not permitting
  	// *RawBytes in Rows.Scan), since we're about to close
  	// the Rows in our defer, when we return from this function.
  	// the contract with the driver.Next(...) interface is that it
  	// can return slices into read-only temporary memory that's
  	// only valid until the next Scan/Close. But the TODO is that
  	// for a lot of drivers, this copy will be unnecessary. We
  	// should provide an optional interface for drivers to
  	// implement to say, "don't worry, the []bytes that I return
  	// from Next will not be modified again." (for instance, if
  	// they were obtained from the network anyway) But for now we
  	// don't care.
  	defer r.rows.Close()
  	for _, dp := range dest {
  		if _, ok := dp.(*RawBytes); ok {
  			return errors.New("sql: RawBytes isn't allowed on Row.Scan")
  		}
  	}
  
  	if !r.rows.Next() {
  		if err := r.rows.Err(); err != nil {
  			return err
  		}
  		return ErrNoRows
  	}
  	err := r.rows.Scan(dest...)
  	if err != nil {
  		return err
  	}
  	// Make sure the query can be processed to completion with no errors.
  	return r.rows.Close()
  }
  
  // A Result summarizes an executed SQL command.
  type Result interface {
  	// LastInsertId returns the integer generated by the database
  	// in response to a command. Typically this will be from an
  	// "auto increment" column when inserting a new row. Not all
  	// databases support this feature, and the syntax of such
  	// statements varies.
  	LastInsertId() (int64, error)
  
  	// RowsAffected returns the number of rows affected by an
  	// update, insert, or delete. Not every database or database
  	// driver may support this.
  	RowsAffected() (int64, error)
  }
  
  type driverResult struct {
  	sync.Locker // the *driverConn
  	resi        driver.Result
  }
  
  func (dr driverResult) LastInsertId() (int64, error) {
  	dr.Lock()
  	defer dr.Unlock()
  	return dr.resi.LastInsertId()
  }
  
  func (dr driverResult) RowsAffected() (int64, error) {
  	dr.Lock()
  	defer dr.Unlock()
  	return dr.resi.RowsAffected()
  }
  
  func stack() string {
  	var buf [2 << 10]byte
  	return string(buf[:runtime.Stack(buf[:], false)])
  }
  
  // withLock runs while holding lk.
  func withLock(lk sync.Locker, fn func()) {
  	lk.Lock()
  	defer lk.Unlock() // in case fn panics
  	fn()
  }
  

View as plain text