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 cancellation 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 (
	
	
	
	
	
	
	
	
	
	
	
	
)

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 ( string,  driver.Driver) {
	driversMu.Lock()
	defer driversMu.Unlock()
	if  == nil {
		panic("sql: Register driver is nil")
	}
	if ,  := drivers[];  {
		panic("sql: Register called twice for driver " + )
	}
	drivers[] = 
}

func () {
	driversMu.Lock()
For tests.
	drivers = make(map[string]driver.Driver)
}
Drivers returns a sorted list of the names of the registered drivers.
func () []string {
	driversMu.RLock()
	defer driversMu.RUnlock()
	 := make([]string, 0, len(drivers))
	for  := range drivers {
		 = append(, )
	}
	sort.Strings()
	return 
}
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), )
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: , 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
)
String returns the name of the transaction isolation level.
func ( IsolationLevel) () string {
	switch  {
	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()) + ")"
	}
}

var _ fmt.Stringer = LevelDefault
TxOptions holds the transaction options to be used in DB.BeginTx.
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 ( *NullString) ( interface{}) error {
	if  == nil {
		.String, .Valid = "", false
		return nil
	}
	.Valid = true
	return convertAssign(&.String, )
}
Value implements the driver Valuer interface.
func ( NullString) () (driver.Value, error) {
	if !.Valid {
		return nil, nil
	}
	return .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 ( *NullInt64) ( interface{}) error {
	if  == nil {
		.Int64, .Valid = 0, false
		return nil
	}
	.Valid = true
	return convertAssign(&.Int64, )
}
Value implements the driver Valuer interface.
func ( NullInt64) () (driver.Value, error) {
	if !.Valid {
		return nil, nil
	}
	return .Int64, nil
}
NullInt32 represents an int32 that may be null. NullInt32 implements the Scanner interface so it can be used as a scan destination, similar to NullString.
type NullInt32 struct {
	Int32 int32
	Valid bool // Valid is true if Int32 is not NULL
}
Scan implements the Scanner interface.
func ( *NullInt32) ( interface{}) error {
	if  == nil {
		.Int32, .Valid = 0, false
		return nil
	}
	.Valid = true
	return convertAssign(&.Int32, )
}
Value implements the driver Valuer interface.
func ( NullInt32) () (driver.Value, error) {
	if !.Valid {
		return nil, nil
	}
	return int64(.Int32), 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 ( *NullFloat64) ( interface{}) error {
	if  == nil {
		.Float64, .Valid = 0, false
		return nil
	}
	.Valid = true
	return convertAssign(&.Float64, )
}
Value implements the driver Valuer interface.
func ( NullFloat64) () (driver.Value, error) {
	if !.Valid {
		return nil, nil
	}
	return .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 ( *NullBool) ( interface{}) error {
	if  == nil {
		.Bool, .Valid = false, false
		return nil
	}
	.Valid = true
	return convertAssign(&.Bool, )
}
Value implements the driver Valuer interface.
func ( NullBool) () (driver.Value, error) {
	if !.Valid {
		return nil, nil
	}
	return .Bool, nil
}
NullTime represents a time.Time that may be null. NullTime implements the Scanner interface so it can be used as a scan destination, similar to NullString.
type NullTime struct {
	Time  time.Time
	Valid bool // Valid is true if Time is not NULL
}
Scan implements the Scanner interface.
func ( *NullTime) ( interface{}) error {
	if  == nil {
		.Time, .Valid = time.Time{}, false
		return nil
	}
	.Valid = true
	return convertAssign(&.Time, )
}
Value implements the driver Valuer interface.
func ( NullTime) () (driver.Value, error) {
	if !.Valid {
		return nil, nil
	}
	return .Time, nil
}
Scanner is an interface used by Scan.
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.
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.
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.
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{}
	closed            bool
	dep               map[finalCloser]depSet
	lastPut           map[*driverConn]string // stacktrace of last conn's put; debug only
	maxIdleCount      int                    // zero means defaultMaxIdleConns; negative means 0
	maxOpen           int                    // <= 0 means unlimited
	maxLifetime       time.Duration          // maximum amount of time a connection may be reused
	maxIdleTime       time.Duration          // maximum amount of time a connection may be idle before being closed
	cleanerCh         chan struct{}
	waitCount         int64 // Total number of connections waited for.
	maxIdleClosed     int64 // Total number of connections closed due to idle count.
	maxIdleTimeClosed int64 // Total number of connections closed due to idle time.
	maxLifetimeClosed int64 // Total number of connections closed due to max connection lifetime limit.

	stop func() // stop cancels the connection opener.
}
connReuseStrategy determines how (*DB).conn returns database connections.
type connReuseStrategy uint8
alwaysNewConn forces a new connection to the database.
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
	needReset   bool // The connection session should be reset before use if true.
	closed      bool
	finalClosed bool // ci.Close has been called
	openStmt    map[*driverStmt]bool
guarded by db.mu
	inUse      bool
	returnedAt time.Time // Time the connection was created or returned.
	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 ( *driverConn) ( error) {
	.db.putConn(, , true)
}

func ( *driverConn) ( *driverStmt) {
	.Lock()
	defer .Unlock()
	delete(.openStmt, )
}

func ( *driverConn) ( time.Duration) bool {
	if  <= 0 {
		return false
	}
	return .createdAt.Add().Before(nowFunc())
}
resetSession checks if the driver connection needs the session to be reset and if required, resets it.
func ( *driverConn) ( context.Context) error {
	.Lock()
	defer .Unlock()

	if !.needReset {
		return nil
	}
	if ,  := .ci.(driver.SessionResetter);  {
		return .ResetSession()
	}
	return nil
}
validateConnection checks if the connection is valid and can still be used. It also marks the session for reset if required.
func ( *driverConn) ( bool) bool {
	.Lock()
	defer .Unlock()

	if  {
		.needReset = true
	}
	if ,  := .ci.(driver.Validator);  {
		return .IsValid()
	}
	return true
}
prepareLocked prepares the query on dc. When cg == nil the dc must keep track of the prepared statements in a pool.
func ( *driverConn) ( context.Context,  stmtConnGrabber,  string) (*driverStmt, error) {
	,  := ctxDriverPrepare(, .ci, )
	if  != nil {
		return nil, 
	}
	 := &driverStmt{Locker: , si: }
No need to manage open statements if there is a single connection grabber.
	if  != nil {
		return , 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 .openStmt == nil {
		.openStmt = make(map[*driverStmt]bool)
	}
	.openStmt[] = true
	return , nil
}
the dc.db's Mutex is held.
func ( *driverConn) () func() error {
	.Lock()
	defer .Unlock()
	if .closed {
		return func() error { return errors.New("sql: duplicate driverConn close") }
	}
	.closed = true
	return .db.removeDepLocked(, )
}

func ( *driverConn) () error {
	.Lock()
	if .closed {
		.Unlock()
		return errors.New("sql: duplicate driverConn close")
	}
	.closed = true
	.Unlock() // not defer; removeDep finalClose calls may need to lock
And now updates that require holding dc.mu.Lock.
	.db.mu.Lock()
	.dbmuClosed = true
	 := .db.removeDepLocked(, )
	.db.mu.Unlock()
	return ()
}

func ( *driverConn) () error {
	var  error
Each *driverStmt has a lock to the dc. Copy the list out of the dc before calling close on each stmt.
	var  []*driverStmt
	withLock(, func() {
		 = make([]*driverStmt, 0, len(.openStmt))
		for  := range .openStmt {
			 = append(, )
		}
		.openStmt = nil
	})
	for ,  := range  {
		.Close()
	}
	withLock(, func() {
		.finalClosed = true
		 = .ci.Close()
		.ci = nil
	})

	.db.mu.Lock()
	.db.numOpen--
	.db.maybeOpenNewConnections()
	.db.mu.Unlock()

	atomic.AddUint64(&.db.numClosed, 1)
	return 
}
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 ( *driverStmt) () error {
	.Lock()
	defer .Unlock()
	if .closed {
		return .closeErr
	}
	.closed = true
	.closeErr = .si.Close()
	return .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.
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) ( finalCloser,  interface{}) {
	.mu.Lock()
	defer .mu.Unlock()
	.addDepLocked(, )
}

func ( *DB) ( finalCloser,  interface{}) {
	if .dep == nil {
		.dep = make(map[finalCloser]depSet)
	}
	 := .dep[]
	if  == nil {
		 = make(depSet)
		.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) ( finalCloser,  interface{}) error {
	.mu.Lock()
	 := .removeDepLocked(, )
	.mu.Unlock()
	return ()
}

func ( *DB) ( finalCloser,  interface{}) func() error {

	,  := .dep[]
	if ! {
		panic(fmt.Sprintf("unpaired removeDep: no deps for %T", ))
	}

	 := len()
	delete(, )

	switch len() {
Nothing removed. Shouldn't happen.
		panic(fmt.Sprintf("unpaired removeDep: no %T dep on %T", , ))
No more dependencies.
		delete(.dep, )
		return .finalClose
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 ( dsnConnector) ( context.Context) (driver.Conn, error) {
	return .driver.Open(.dsn)
}

func ( dsnConnector) () driver.Driver {
	return .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 ( driver.Connector) *DB {
	,  := context.WithCancel(context.Background())
	 := &DB{
		connector:    ,
		openerCh:     make(chan struct{}, connectionRequestQueueSize),
		lastPut:      make(map[*driverConn]string),
		connRequests: make(map[uint64]chan connRequest),
		stop:         ,
	}

	go .connectionOpener()

	return 
}
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 (,  string) (*DB, error) {
	driversMu.RLock()
	,  := drivers[]
	driversMu.RUnlock()
	if ! {
		return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", )
	}

	if ,  := .(driver.DriverContext);  {
		,  := .OpenConnector()
		if  != nil {
			return nil, 
		}
		return OpenDB(), nil
	}

	return OpenDB(dsnConnector{dsn: , driver: }), nil
}

func ( *DB) ( context.Context,  *driverConn,  func(error)) error {
	var  error
	if ,  := .ci.(driver.Pinger);  {
		withLock(, func() {
			 = .Ping()
		})
	}
	()
	return 
}
PingContext verifies a connection to the database is still alive, establishing a connection if necessary.
func ( *DB) ( context.Context) error {
	var  *driverConn
	var  error

	for  := 0;  < maxBadConnRetries; ++ {
		,  = .conn(, cachedOrNewConn)
		if  != driver.ErrBadConn {
			break
		}
	}
	if  == driver.ErrBadConn {
		,  = .conn(, alwaysNewConn)
	}
	if  != nil {
		return 
	}

	return .pingDC(, , .releaseConn)
}
Ping verifies a connection to the database is still alive, establishing a connection if necessary.
func ( *DB) () error {
	return .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) () error {
	.mu.Lock()
	if .closed { // Make DB.Close idempotent
		.mu.Unlock()
		return nil
	}
	if .cleanerCh != nil {
		close(.cleanerCh)
	}
	var  error
	 := make([]func() error, 0, len(.freeConn))
	for ,  := range .freeConn {
		 = append(, .closeDBLocked())
	}
	.freeConn = nil
	.closed = true
	for ,  := range .connRequests {
		close()
	}
	.mu.Unlock()
	for ,  := range  {
		 := ()
		if  != nil {
			 = 
		}
	}
	.stop()
	return 
}

const defaultMaxIdleConns = 2

func ( *DB) () int {
	 := .maxIdleCount
	switch {
TODO(bradfitz): ask driver, if supported, for its default preference
		return defaultMaxIdleConns
	case  < 0:
		return 0
	default:
		return 
	}
}

func ( *DB) () time.Duration {
	if .maxIdleTime <= 0 {
		return .maxLifetime
	}
	if .maxLifetime <= 0 {
		return .maxIdleTime
	}

	 := .maxIdleTime
	if  > .maxLifetime {
		 = .maxLifetime
	}
	return 
}
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) ( int) {
	.mu.Lock()
	if  > 0 {
		.maxIdleCount =
No idle connections.
		.maxIdleCount = -1
Make sure maxIdle doesn't exceed maxOpen
	if .maxOpen > 0 && .maxIdleConnsLocked() > .maxOpen {
		.maxIdleCount = .maxOpen
	}
	var  []*driverConn
	 := len(.freeConn)
	 := .maxIdleConnsLocked()
	if  >  {
		 = .freeConn[:]
		.freeConn = .freeConn[:]
	}
	.maxIdleClosed += int64(len())
	.mu.Unlock()
	for ,  := range  {
		.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) ( int) {
	.mu.Lock()
	.maxOpen = 
	if  < 0 {
		.maxOpen = 0
	}
	 := .maxOpen > 0 && .maxIdleConnsLocked() > .maxOpen
	.mu.Unlock()
	if  {
		.SetMaxIdleConns()
	}
}
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 not closed due to a connection's age.
func ( *DB) ( time.Duration) {
	if  < 0 {
		 = 0
	}
Wake cleaner up when lifetime is shortened.
	if  > 0 &&  < .maxLifetime && .cleanerCh != nil {
		select {
		case .cleanerCh <- struct{}{}:
		default:
		}
	}
	.maxLifetime = 
	.startCleanerLocked()
	.mu.Unlock()
}
SetConnMaxIdleTime sets the maximum amount of time a connection may be idle. Expired connections may be closed lazily before reuse. If d <= 0, connections are not closed due to a connection's idle time.
func ( *DB) ( time.Duration) {
	if  < 0 {
		 = 0
	}
	.mu.Lock()
	defer .mu.Unlock()
Wake cleaner up when idle time is shortened.
	if  > 0 &&  < .maxIdleTime && .cleanerCh != nil {
		select {
		case .cleanerCh <- struct{}{}:
		default:
		}
	}
	.maxIdleTime = 
	.startCleanerLocked()
}
startCleanerLocked starts connectionCleaner if needed.
func ( *DB) () {
	if (.maxLifetime > 0 || .maxIdleTime > 0) && .numOpen > 0 && .cleanerCh == nil {
		.cleanerCh = make(chan struct{}, 1)
		go .connectionCleaner(.shortestIdleTimeLocked())
	}
}

func ( *DB) ( time.Duration) {
	const  = time.Second

	if  <  {
		 = 
	}
	 := time.NewTimer()

	for {
		select {
		case <-.C:
		case <-.cleanerCh: // maxLifetime was changed or db was closed.
		}

		.mu.Lock()

		 = .shortestIdleTimeLocked()
		if .closed || .numOpen == 0 ||  <= 0 {
			.cleanerCh = nil
			.mu.Unlock()
			return
		}

		 := .connectionCleanerRunLocked()
		.mu.Unlock()
		for ,  := range  {
			.Close()
		}

		if  <  {
			 = 
		}
		.Reset()
	}
}

func ( *DB) () ( []*driverConn) {
	if .maxLifetime > 0 {
		 := nowFunc().Add(-.maxLifetime)
		for  := 0;  < len(.freeConn); ++ {
			 := .freeConn[]
			if .createdAt.Before() {
				 = append(, )
				 := len(.freeConn) - 1
				.freeConn[] = .freeConn[]
				.freeConn[] = nil
				.freeConn = .freeConn[:]
				--
			}
		}
		.maxLifetimeClosed += int64(len())
	}

	if .maxIdleTime > 0 {
		 := nowFunc().Add(-.maxIdleTime)
		var  int64
		for  := 0;  < len(.freeConn); ++ {
			 := .freeConn[]
			if .maxIdleTime > 0 && .returnedAt.Before() {
				 = append(, )
				++
				 := len(.freeConn) - 1
				.freeConn[] = .freeConn[]
				.freeConn[] = nil
				.freeConn = .freeConn[:]
				--
			}
		}
		.maxIdleTimeClosed += 
	}
	return
}
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.
	MaxIdleTimeClosed int64         // The total number of connections closed due to SetConnMaxIdleTime.
	MaxLifetimeClosed int64         // The total number of connections closed due to SetConnMaxLifetime.
}
Stats returns database statistics.
func ( *DB) () DBStats {
	 := atomic.LoadInt64(&.waitDuration)

	.mu.Lock()
	defer .mu.Unlock()

	 := DBStats{
		MaxOpenConnections: .maxOpen,

		Idle:            len(.freeConn),
		OpenConnections: .numOpen,
		InUse:           .numOpen - len(.freeConn),

		WaitCount:         .waitCount,
		WaitDuration:      time.Duration(),
		MaxIdleClosed:     .maxIdleClosed,
		MaxIdleTimeClosed: .maxIdleTimeClosed,
		MaxLifetimeClosed: .maxLifetimeClosed,
	}
	return 
}
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) () {
	 := len(.connRequests)
	if .maxOpen > 0 {
		 := .maxOpen - .numOpen
		if  >  {
			 = 
		}
	}
	for  > 0 {
		.numOpen++ // optimistically
		--
		if .closed {
			return
		}
		.openerCh <- struct{}{}
	}
}
Runs in a separate goroutine, opens new connections when requested.
func ( *DB) ( context.Context) {
	for {
		select {
		case <-.Done():
			return
		case <-.openerCh:
			.openNewConnection()
		}
	}
}
Open one new connection
maybeOpenNewConnections 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.
	,  := .connector.Connect()
	.mu.Lock()
	defer .mu.Unlock()
	if .closed {
		if  == nil {
			.Close()
		}
		.numOpen--
		return
	}
	if  != nil {
		.numOpen--
		.putConnDBLocked(nil, )
		.maybeOpenNewConnections()
		return
	}
	 := &driverConn{
		db:         ,
		createdAt:  nowFunc(),
		returnedAt: nowFunc(),
		ci:         ,
	}
	if .putConnDBLocked(, ) {
		.addDepLocked(, )
	} else {
		.numOpen--
		.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) () uint64 {
	 := .nextRequest
	.nextRequest++
	return 
}
conn returns a newly-opened or cached *driverConn.
func ( *DB) ( context.Context,  connReuseStrategy) (*driverConn, error) {
	.mu.Lock()
	if .closed {
		.mu.Unlock()
		return nil, errDBClosed
Check if the context is expired.
	select {
	default:
	case <-.Done():
		.mu.Unlock()
		return nil, .Err()
	}
	 := .maxLifetime
Prefer a free connection, if possible.
	 := len(.freeConn)
	if  == cachedOrNewConn &&  > 0 {
		 := .freeConn[0]
		copy(.freeConn, .freeConn[1:])
		.freeConn = .freeConn[:-1]
		.inUse = true
		if .expired() {
			.maxLifetimeClosed++
			.mu.Unlock()
			.Close()
			return nil, driver.ErrBadConn
		}
		.mu.Unlock()
Reset the session if required.
		if  := .resetSession();  == driver.ErrBadConn {
			.Close()
			return nil, driver.ErrBadConn
		}

		return , 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.
Make the connRequest channel. It's buffered so that the connectionOpener doesn't block while waiting for the req to be read.
		 := make(chan connRequest, 1)
		 := .nextRequestKeyLocked()
		.connRequests[] = 
		.waitCount++
		.mu.Unlock()

		 := nowFunc()
Timeout the connection request with the context.
		select {
Remove the connection request and ensure no value has been sent on it after removing.
			.mu.Lock()
			delete(.connRequests, )
			.mu.Unlock()

			atomic.AddInt64(&.waitDuration, int64(time.Since()))

			select {
			default:
			case ,  := <-:
				if  && .conn != nil {
					.putConn(.conn, .err, false)
				}
			}
			return nil, .Err()
		case ,  := <-:
			atomic.AddInt64(&.waitDuration, int64(time.Since()))

			if ! {
				return nil, errDBClosed
Only check if the connection is expired if the strategy is cachedOrNewConns. If we require a new connection, just re-use the connection without looking at the expiry time. If it is expired, it will be checked when it is placed back into the connection pool. This prioritizes giving a valid connection to a client over the exact connection lifetime, which could expire exactly after this point anyway.
			if  == cachedOrNewConn && .err == nil && .conn.expired() {
				.mu.Lock()
				.maxLifetimeClosed++
				.mu.Unlock()
				.conn.Close()
				return nil, driver.ErrBadConn
			}
			if .conn == nil {
				return nil, .err
			}
Reset the session if required.
			if  := .conn.resetSession();  == driver.ErrBadConn {
				.conn.Close()
				return nil, driver.ErrBadConn
			}
			return .conn, .err
		}
	}

	.numOpen++ // optimistically
	.mu.Unlock()
	,  := .connector.Connect()
	if  != nil {
		.mu.Lock()
		.numOpen-- // correct for earlier optimism
		.maybeOpenNewConnections()
		.mu.Unlock()
		return nil, 
	}
	.mu.Lock()
	 := &driverConn{
		db:         ,
		createdAt:  nowFunc(),
		returnedAt: nowFunc(),
		ci:         ,
		inUse:      true,
	}
	.addDepLocked(, )
	.mu.Unlock()
	return , 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) ( *driverConn,  *driverStmt) {
	.mu.Lock()
	defer .mu.Unlock()
	if .inUse {
		.onPut = append(.onPut, func() {
			.Close()
		})
	} else {
		.Lock()
		 := .finalClosed
		.Unlock()
		if ! {
			.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) ( *driverConn,  error,  bool) {
	if  != driver.ErrBadConn {
		if !.validateConnection() {
			 = driver.ErrBadConn
		}
	}
	.mu.Lock()
	if !.inUse {
		.mu.Unlock()
		if debugGetPut {
			fmt.Printf("putConn(%v) DUPLICATE was: %s\n\nPREVIOUS was: %s", , stack(), .lastPut[])
		}
		panic("sql: connection returned that was never out")
	}

	if  != driver.ErrBadConn && .expired(.maxLifetime) {
		.maxLifetimeClosed++
		 = driver.ErrBadConn
	}
	if debugGetPut {
		.lastPut[] = stack()
	}
	.inUse = false
	.returnedAt = nowFunc()

	for ,  := range .onPut {
		()
	}
	.onPut = nil
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.
		.maybeOpenNewConnections()
		.mu.Unlock()
		.Close()
		return
	}
	if putConnHook != nil {
		putConnHook(, )
	}
	 := .putConnDBLocked(, nil)
	.mu.Unlock()

	if ! {
		.Close()
		return
	}
}
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) ( *driverConn,  error) bool {
	if .closed {
		return false
	}
	if .maxOpen > 0 && .numOpen > .maxOpen {
		return false
	}
	if  := len(.connRequests);  > 0 {
		var  chan connRequest
		var  uint64
		for ,  = range .connRequests {
			break
		}
		delete(.connRequests, ) // Remove from pending requests.
		if  == nil {
			.inUse = true
		}
		 <- connRequest{
			conn: ,
			err:  ,
		}
		return true
	} else if  == nil && !.closed {
		if .maxIdleConnsLocked() > len(.freeConn) {
			.freeConn = append(.freeConn, )
			.startCleanerLocked()
			return true
		}
		.maxIdleClosed++
	}
	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) ( context.Context,  string) (*Stmt, error) {
	var  *Stmt
	var  error
	for  := 0;  < maxBadConnRetries; ++ {
		,  = .prepare(, , cachedOrNewConn)
		if  != driver.ErrBadConn {
			break
		}
	}
	if  == driver.ErrBadConn {
		return .prepare(, , alwaysNewConn)
	}
	return , 
}
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) ( string) (*Stmt, error) {
	return .PrepareContext(context.Background(), )
}
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.
	,  := .conn(, )
	if  != nil {
		return nil, 
	}
	return .prepareDC(, , .releaseConn, nil, )
}
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) ( context.Context,  *driverConn,  func(error),  stmtConnGrabber,  string) (*Stmt, error) {
	var  *driverStmt
	var  error
	defer func() {
		()
	}()
	withLock(, func() {
		,  = .prepareLocked(, , )
	})
	if  != nil {
		return nil, 
	}
	 := &Stmt{
		db:    ,
		query: ,
		cg:    ,
		cgds:  ,
	}
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  == nil {
		.css = []connStmt{{, }}
		.lastNumClosed = atomic.LoadUint64(&.numClosed)
		.addDep(, )
	}
	return , nil
}
ExecContext executes a query without returning any rows. The args are for any placeholder parameters in the query.
func ( *DB) ( context.Context,  string,  ...interface{}) (Result, error) {
	var  Result
	var  error
	for  := 0;  < maxBadConnRetries; ++ {
		,  = .exec(, , , cachedOrNewConn)
		if  != driver.ErrBadConn {
			break
		}
	}
	if  == driver.ErrBadConn {
		return .exec(, , , alwaysNewConn)
	}
	return , 
}
Exec executes a query without returning any rows. The args are for any placeholder parameters in the query.
func ( *DB) ( string,  ...interface{}) (Result, error) {
	return .ExecContext(context.Background(), , ...)
}

func ( *DB) ( context.Context,  string,  []interface{},  connReuseStrategy) (Result, error) {
	,  := .conn(, )
	if  != nil {
		return nil, 
	}
	return .execDC(, , .releaseConn, , )
}

func ( *DB) ( context.Context,  *driverConn,  func(error),  string,  []interface{}) ( Result,  error) {
	defer func() {
		()
	}()
	,  := .ci.(driver.ExecerContext)
	var  driver.Execer
	if ! {
		,  = .ci.(driver.Execer)
	}
	if  {
		var  []driver.NamedValue
		var  driver.Result
		withLock(, func() {
			,  = driverArgsConnLocked(.ci, nil, )
			if  != nil {
				return
			}
			,  = ctxDriverExec(, , , , )
		})
		if  != driver.ErrSkip {
			if  != nil {
				return nil, 
			}
			return driverResult{, }, nil
		}
	}

	var  driver.Stmt
	withLock(, func() {
		,  = ctxDriverPrepare(, .ci, )
	})
	if  != nil {
		return nil, 
	}
	 := &driverStmt{Locker: , si: }
	defer .Close()
	return resultFromStatement(, .ci, , ...)
}
QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
func ( *DB) ( context.Context,  string,  ...interface{}) (*Rows, error) {
	var  *Rows
	var  error
	for  := 0;  < maxBadConnRetries; ++ {
		,  = .query(, , , cachedOrNewConn)
		if  != driver.ErrBadConn {
			break
		}
	}
	if  == driver.ErrBadConn {
		return .query(, , , alwaysNewConn)
	}
	return , 
}
Query executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
func ( *DB) ( string,  ...interface{}) (*Rows, error) {
	return .QueryContext(context.Background(), , ...)
}

func ( *DB) ( context.Context,  string,  []interface{},  connReuseStrategy) (*Rows, error) {
	,  := .conn(, )
	if  != nil {
		return nil, 
	}

	return .queryDC(, nil, , .releaseConn, , )
}
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) (,  context.Context,  *driverConn,  func(error),  string,  []interface{}) (*Rows, error) {
	,  := .ci.(driver.QueryerContext)
	var  driver.Queryer
	if ! {
		,  = .ci.(driver.Queryer)
	}
	if  {
		var  []driver.NamedValue
		var  driver.Rows
		var  error
		withLock(, func() {
			,  = driverArgsConnLocked(.ci, nil, )
			if  != nil {
				return
			}
			,  = ctxDriverQuery(, , , , )
		})
		if  != driver.ErrSkip {
			if  != nil {
				()
				return nil,
Note: ownership of dc passes to the *Rows, to be freed with releaseConn.
			 := &Rows{
				dc:          ,
				releaseConn: ,
				rowsi:       ,
			}
			.initContextClose(, )
			return , nil
		}
	}

	var  driver.Stmt
	var  error
	withLock(, func() {
		,  = ctxDriverPrepare(, .ci, )
	})
	if  != nil {
		()
		return nil, 
	}

	 := &driverStmt{Locker: , si: }
	,  := rowsiFromStatement(, .ci, , ...)
	if  != nil {
		.Close()
		()
		return nil, 
	}
Note: ownership of ci passes to the *Rows, to be freed with releaseConn.
	 := &Rows{
		dc:          ,
		releaseConn: ,
		rowsi:       ,
		closeStmt:   ,
	}
	.initContextClose(, )
	return , 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) ( context.Context,  string,  ...interface{}) *Row {
	,  := .QueryContext(, , ...)
	return &Row{rows: , 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) ( string,  ...interface{}) *Row {
	return .QueryRowContext(context.Background(), , ...)
}
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) ( context.Context,  *TxOptions) (*Tx, error) {
	var  *Tx
	var  error
	for  := 0;  < maxBadConnRetries; ++ {
		,  = .begin(, , cachedOrNewConn)
		if  != driver.ErrBadConn {
			break
		}
	}
	if  == driver.ErrBadConn {
		return .begin(, , alwaysNewConn)
	}
	return , 
}
Begin starts a transaction. The default isolation level is dependent on the driver.
func ( *DB) () (*Tx, error) {
	return .BeginTx(context.Background(), nil)
}

func ( *DB) ( context.Context,  *TxOptions,  connReuseStrategy) ( *Tx,  error) {
	,  := .conn(, )
	if  != nil {
		return nil, 
	}
	return .beginDC(, , .releaseConn, )
}
beginDC starts a transaction. The provided dc must be valid and ready to use.
func ( *DB) ( context.Context,  *driverConn,  func(error),  *TxOptions) ( *Tx,  error) {
	var  driver.Tx
	 := false
	withLock(, func() {
		,  := .ci.(driver.SessionResetter)
		,  := .ci.(driver.Validator)
		 =  && 
		,  = ctxDriverBegin(, , .ci)
	})
	if  != nil {
		()
		return nil, 
	}
Schedule the transaction to rollback when the context is cancelled. The cancel function in Tx will be called after done is set to true.
	,  := context.WithCancel()
	 = &Tx{
		db:                 ,
		dc:                 ,
		releaseConn:        ,
		txi:                ,
		cancel:             ,
		keepConnOnRollback: ,
		ctx:                ,
	}
	go .awaitDone()
	return , nil
}
Driver returns the database's underlying driver.
func ( *DB) () driver.Driver {
	return .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) ( context.Context) (*Conn, error) {
	var  *driverConn
	var  error
	for  := 0;  < maxBadConnRetries; ++ {
		,  = .conn(, cachedOrNewConn)
		if  != driver.ErrBadConn {
			break
		}
	}
	if  == driver.ErrBadConn {
		,  = .conn(, alwaysNewConn)
	}
	if  != nil {
		return nil, 
	}

	 := &Conn{
		db: ,
		dc: ,
	}
	return , 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
}
grabConn takes a context to implement stmtConnGrabber but the context is not used.
func ( *Conn) (context.Context) (*driverConn, releaseConn, error) {
	if atomic.LoadInt32(&.done) != 0 {
		return nil, nil, ErrConnDone
	}
	.closemu.RLock()
	return .dc, .closemuRUnlockCondReleaseConn, nil
}
PingContext verifies the connection to the database is still alive.
func ( *Conn) ( context.Context) error {
	, ,  := .grabConn()
	if  != nil {
		return 
	}
	return .db.pingDC(, , )
}
ExecContext executes a query without returning any rows. The args are for any placeholder parameters in the query.
func ( *Conn) ( context.Context,  string,  ...interface{}) (Result, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}
	return .db.execDC(, , , , )
}
QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
func ( *Conn) ( context.Context,  string,  ...interface{}) (*Rows, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}
	return .db.queryDC(, 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 ( *Conn) ( context.Context,  string,  ...interface{}) *Row {
	,  := .QueryContext(, , ...)
	return &Row{rows: , 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 ( *Conn) ( context.Context,  string) (*Stmt, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}
	return .db.prepareDC(, , , , )
}
Raw executes f exposing the underlying driver connection for the duration of f. The driverConn must not be used outside of f. Once f returns and err is nil, the Conn will continue to be usable until Conn.Close is called.
func ( *Conn) ( func( interface{}) error) ( error) {
	var  *driverConn
	var  releaseConn
grabConn takes a context to implement stmtConnGrabber, but the context is not used.
	, ,  = .grabConn(nil)
	if  != nil {
		return
	}
	 := true
	.Mutex.Lock()
	defer func() {
		.Mutex.Unlock()
If f panics fPanic will remain true. Ensure an error is passed to release so the connection may be discarded.
		if  {
			 = driver.ErrBadConn
		}
		()
	}()
	 = (.ci)
	 = false

	return
}
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 ( *Conn) ( context.Context,  *TxOptions) (*Tx, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}
	return .db.beginDC(, , , )
}
closemuRUnlockCondReleaseConn read unlocks closemu as the sql operation is done with the dc.
func ( *Conn) ( error) {
	.closemu.RUnlock()
	if  == driver.ErrBadConn {
		.close()
	}
}

func ( *Conn) () context.Context {
	return nil
}

func ( *Conn) ( error) error {
	if !atomic.CompareAndSwapInt32(&.done, 0, 1) {
		return ErrConnDone
	}
Lock around releasing the driver connection to ensure all queries have been stopped before doing so.
	.closemu.Lock()
	defer .closemu.Unlock()

	.dc.releaseConn()
	.dc = nil
	.db = nil
	return 
}
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 ( *Conn) () error {
	return .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
keepConnOnRollback is true if the driver knows how to reset the connection's session and if need be discard the connection.
	keepConnOnRollback bool
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.
Wait for either the transaction to be committed or rolled back, or for the associated context to be closed.
	<-.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. Do not discard the connection if the connection knows how to reset the session.
	 := !.keepConnOnRollback
	.rollback()
}

func ( *Tx) () bool {
	return atomic.LoadInt32(&.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 while tx is already canceled and won't be executed concurrently.
func ( *Tx) ( error) {
	.releaseConn()
	.dc = nil
	.txi = nil
}
hookTxGrabConn specifies an optional hook to be called on a successful call to (*Tx).grabConn. For tests.
var hookTxGrabConn func()

func ( *Tx) ( context.Context) (*driverConn, releaseConn, error) {
	select {
	default:
	case <-.Done():
		return nil, nil, .Err()
	}
closemu.RLock must come before the check for isDone to prevent the Tx from closing while a query is executing.
	.closemu.RLock()
	if .isDone() {
		.closemu.RUnlock()
		return nil, nil, ErrTxDone
	}
	if hookTxGrabConn != nil { // test hook
		hookTxGrabConn()
	}
	return .dc, .closemuRUnlockRelease, nil
}

func ( *Tx) () context.Context {
	return .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) (error) {
	.closemu.RUnlock()
}
Closes all Stmts prepared for this transaction.
func ( *Tx) () {
	.stmts.Lock()
	defer .stmts.Unlock()
	for ,  := range .stmts.v {
		.Close()
	}
}
Commit commits the transaction.
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 <-.ctx.Done():
		if atomic.LoadInt32(&.done) == 1 {
			return ErrTxDone
		}
		return .ctx.Err()
	}
	if !atomic.CompareAndSwapInt32(&.done, 0, 1) {
		return ErrTxDone
	}
Cancel the Tx to release any active R-closemu locks. This is safe to do because tx.done has already transitioned from 0 to 1. Hold the W-closemu lock prior to rollback to ensure no other connection has an active query.
	.cancel()
	.closemu.Lock()
	.closemu.Unlock()

	var  error
	withLock(.dc, func() {
		 = .txi.Commit()
	})
	if  != driver.ErrBadConn {
		.closePrepared()
	}
	.close()
	return 
}

var rollbackHook func()
rollback aborts the transaction and optionally forces the pool to discard the connection.
func ( *Tx) ( bool) error {
	if !atomic.CompareAndSwapInt32(&.done, 0, 1) {
		return ErrTxDone
	}

	if rollbackHook != nil {
		rollbackHook()
	}
Cancel the Tx to release any active R-closemu locks. This is safe to do because tx.done has already transitioned from 0 to 1. Hold the W-closemu lock prior to rollback to ensure no other connection has an active query.
	.cancel()
	.closemu.Lock()
	.closemu.Unlock()

	var  error
	withLock(.dc, func() {
		 = .txi.Rollback()
	})
	if  != driver.ErrBadConn {
		.closePrepared()
	}
	if  {
		 = driver.ErrBadConn
	}
	.close()
	return 
}
Rollback aborts the transaction.
func ( *Tx) () error {
	return .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) ( context.Context,  string) (*Stmt, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}

	,  := .db.prepareDC(, , , , )
	if  != nil {
		return nil, 
	}
	.stmts.Lock()
	.stmts.v = append(.stmts.v, )
	.stmts.Unlock()
	return , 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) ( string) (*Stmt, error) {
	return .PrepareContext(context.Background(), )
}
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) ( context.Context,  *Stmt) *Stmt {
	, ,  := .grabConn()
	if  != nil {
		return &Stmt{stickyErr: }
	}
	defer (nil)

	if .db != .db {
		return &Stmt{stickyErr: errors.New("sql: Tx.Stmt: statement from different database used")}
	}
	var  driver.Stmt
	var  *Stmt
	.mu.Lock()
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.
		.mu.Unlock()
		withLock(, func() {
			,  = ctxDriverPrepare(, .ci, .query)
		})
		if  != nil {
			return &Stmt{stickyErr: }
		}
	} else {
See if the statement has already been prepared on this connection, and reuse it if possible.
		for ,  := range .css {
			if .dc ==  {
				 = .ds.si
				break
			}
		}

		.mu.Unlock()

		if  == nil {
			var  *driverStmt
			withLock(, func() {
				,  = .prepareOnConnLocked(, )
			})
			if  != nil {
				return &Stmt{stickyErr: }
			}
			 = .si
		}
		 = 
	}

	 := &Stmt{
		db: .db,
		cg: ,
		cgds: &driverStmt{
			Locker: ,
			si:     ,
		},
		parentStmt: ,
		query:      .query,
	}
	if  != nil {
		.db.addDep(, )
	}
	.stmts.Lock()
	.stmts.v = append(.stmts.v, )
	.stmts.Unlock()
	return 
}
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) ( *Stmt) *Stmt {
	return .StmtContext(context.Background(), )
}
ExecContext executes a query that doesn't return rows. For example: an INSERT and UPDATE.
func ( *Tx) ( context.Context,  string,  ...interface{}) (Result, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}
	return .db.execDC(, , , , )
}
Exec executes a query that doesn't return rows. For example: an INSERT and UPDATE.
func ( *Tx) ( string,  ...interface{}) (Result, error) {
	return .ExecContext(context.Background(), , ...)
}
QueryContext executes a query that returns rows, typically a SELECT.
func ( *Tx) ( context.Context,  string,  ...interface{}) (*Rows, error) {
	, ,  := .grabConn()
	if  != nil {
		return nil, 
	}

	return .db.queryDC(, .ctx, , , , )
}
Query executes a query that returns rows, typically a SELECT.
func ( *Tx) ( string,  ...interface{}) (*Rows, error) {
	return .QueryContext(context.Background(), , ...)
}
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) ( context.Context,  string,  ...interface{}) *Row {
	,  := .QueryContext(, , ...)
	return &Row{rows: , 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) ( string,  ...interface{}) *Row {
	return .QueryRowContext(context.Background(), , ...)
}
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.
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. If a Stmt is prepared on a Tx or Conn, it will be bound to a single underlying connection forever. If the Tx or Conn closes, the Stmt will become unusable and all operations will return an error. If a Stmt is prepared on a DB, it will remain usable for the lifetime of the DB. When the Stmt needs to execute on a new underlying connection, it will prepare itself on the new connection automatically.
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 ( *Stmt) ( context.Context,  ...interface{}) (Result, error) {
	.closemu.RLock()
	defer .closemu.RUnlock()

	var  Result
	 := cachedOrNewConn
	for  := 0;  < maxBadConnRetries+1; ++ {
		if  == maxBadConnRetries {
			 = alwaysNewConn
		}
		, , ,  := .connStmt(, )
		if  != nil {
			if  == driver.ErrBadConn {
				continue
			}
			return nil, 
		}

		,  = resultFromStatement(, .ci, , ...)
		()
		if  != driver.ErrBadConn {
			return , 
		}
	}
	return nil, driver.ErrBadConn
}
Exec executes a prepared statement with the given arguments and returns a Result summarizing the effect of the statement.
func ( *Stmt) ( ...interface{}) (Result, error) {
	return .ExecContext(context.Background(), ...)
}

func ( context.Context,  driver.Conn,  *driverStmt,  ...interface{}) (Result, error) {
	.Lock()
	defer .Unlock()

	,  := driverArgsConnLocked(, , )
	if  != nil {
		return nil, 
	}

	,  := ctxDriverStmtExec(, .si, )
	if  != nil {
		return nil, 
	}
	return driverResult{.Locker, }, 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 ( *Stmt) () {
	 := len(.css)/2 + 1
	if  > 10 {
		 = 10
	}
	 := atomic.LoadUint64(&.db.numClosed)
	if -.lastNumClosed < uint64() {
		return
	}

	.db.mu.Lock()
	for  := 0;  < len(.css); ++ {
		if .css[].dc.dbmuClosed {
			.css[] = .css[len(.css)-1]
			.css = .css[:len(.css)-1]
			--
		}
	}
	.db.mu.Unlock()
	.lastNumClosed = 
}
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 ( *Stmt) ( context.Context,  connReuseStrategy) ( *driverConn,  func(error),  *driverStmt,  error) {
	if  = .stickyErr;  != nil {
		return
	}
	.mu.Lock()
	if .closed {
		.mu.Unlock()
		 = errors.New("sql: statement is closed")
		return
	}
In a transaction or connection, we always use the connection that the stmt was created on.
	if .cg != nil {
		.mu.Unlock()
		, ,  = .cg.grabConn() // blocks, waiting for the connection.
		if  != nil {
			return
		}
		return , , .cgds, nil
	}

	.removeClosedStmtLocked()
	.mu.Unlock()

	,  = .db.conn(, )
	if  != nil {
		return nil, nil, nil, 
	}

	.mu.Lock()
	for ,  := range .css {
		if .dc ==  {
			.mu.Unlock()
			return , .releaseConn, .ds, nil
		}
	}
	.mu.Unlock()
No luck; we need to prepare the statement on this connection
	withLock(, func() {
		,  = .prepareOnConnLocked(, )
	})
	if  != nil {
		.releaseConn()
		return nil, nil, nil, 
	}

	return , .releaseConn, , 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 ( *Stmt) ( context.Context,  *driverConn) (*driverStmt, error) {
	,  := .prepareLocked(, .cg, .query)
	if  != nil {
		return nil, 
	}
	 := connStmt{, }
	.mu.Lock()
	.css = append(.css, )
	.mu.Unlock()
	return .ds, nil
}
QueryContext executes a prepared query statement with the given arguments and returns the query results as a *Rows.
func ( *Stmt) ( context.Context,  ...interface{}) (*Rows, error) {
	.closemu.RLock()
	defer .closemu.RUnlock()

	var  driver.Rows
	 := cachedOrNewConn
	for  := 0;  < maxBadConnRetries+1; ++ {
		if  == maxBadConnRetries {
			 = alwaysNewConn
		}
		, , ,  := .connStmt(, )
		if  != nil {
			if  == driver.ErrBadConn {
				continue
			}
			return nil, 
		}

		,  = rowsiFromStatement(, .ci, , ...)
Note: ownership of ci passes to the *Rows, to be freed with releaseConn.
			 := &Rows{
				dc:    ,
releaseConn set below
addDep must be added before initContextClose or it could attempt to removeDep before it has been added.
			.db.addDep(, )
releaseConn must be set before initContextClose or it could release the connection before it is set.
			.releaseConn = func( error) {
				()
				.db.removeDep(, )
			}
			var  context.Context
			if .cg != nil {
				 = .cg.txCtx()
			}
			.initContextClose(, )
			return , nil
		}

		()
		if  != driver.ErrBadConn {
			return nil, 
		}
	}
	return nil, driver.ErrBadConn
}
Query executes a prepared query statement with the given arguments and returns the query results as a *Rows.
func ( *Stmt) ( ...interface{}) (*Rows, error) {
	return .QueryContext(context.Background(), ...)
}

func ( context.Context,  driver.Conn,  *driverStmt,  ...interface{}) (driver.Rows, error) {
	.Lock()
	defer .Unlock()
	,  := driverArgsConnLocked(, , )
	if  != nil {
		return nil, 
	}
	return ctxDriverStmtQuery(, .si, )
}
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 ( *Stmt) ( context.Context,  ...interface{}) *Row {
	,  := .QueryContext(, ...)
	if  != nil {
		return &Row{err: }
	}
	return &Row{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 ( *Stmt) ( ...interface{}) *Row {
	return .QueryRowContext(context.Background(), ...)
}
Close closes the statement.
func ( *Stmt) () error {
	.closemu.Lock()
	defer .closemu.Unlock()

	if .stickyErr != nil {
		return .stickyErr
	}
	.mu.Lock()
	if .closed {
		.mu.Unlock()
		return nil
	}
	.closed = true
	 := .cgds
	.cgds = nil

	.mu.Unlock()

	if .cg == nil {
		return .db.removeDep(, )
	}
If parentStmt is set, we must not close s.txds since it's stored in the css array of the parentStmt.
		return .db.removeDep(.parentStmt, )
	}
	return .Close()
}

func ( *Stmt) () error {
	.mu.Lock()
	defer .mu.Unlock()
	if .css != nil {
		for ,  := range .css {
			.db.noteUnusedDriverStatement(.dc, .ds)
			.dc.removeOpenStmt(.ds)
		}
		.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
}
lasterrOrErrLocked returns either lasterr or the provided err. rs.closemu must be read-locked.
func ( *Rows) ( error) error {
	if .lasterr != nil && .lasterr != io.EOF {
		return .lasterr
	}
	return 
}
bypassRowsAwaitDone is only used for testing. If true, it will not close the Rows automatically from the context.
var bypassRowsAwaitDone = false

func ( *Rows) (,  context.Context) {
	if .Done() == nil && ( == nil || .Done() == nil) {
		return
	}
	if bypassRowsAwaitDone {
		return
	}
	, .cancel = context.WithCancel()
	go .awaitDone(, )
}
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 ( *Rows) (,  context.Context) {
	var  <-chan struct{}
	if  != nil {
		 = .Done()
	}
	select {
	case <-.Done():
	case <-:
	}
	.close(.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 ( *Rows) () bool {
	var ,  bool
	withLock(.closemu.RLocker(), func() {
		,  = .nextLocked()
	})
	if  {
		.Close()
	}
	return 
}

func ( *Rows) () (,  bool) {
	if .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.
	.dc.Lock()
	defer .dc.Unlock()

	if .lastcols == nil {
		.lastcols = make([]driver.Value, len(.rowsi.Columns()))
	}

	.lasterr = .rowsi.Next(.lastcols)
Close the connection if there is a driver error.
		if .lasterr != io.EOF {
			return true, false
		}
		,  := .rowsi.(driver.RowsNextResultSet)
		if ! {
			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 !.HasNextResultSet() {
			 = true
		}
		return , false
	}
	return false, true
}
NextResultSet prepares the next result set for reading. It reports whether 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 ( *Rows) () bool {
	var  bool
	defer func() {
		if  {
			.Close()
		}
	}()
	.closemu.RLock()
	defer .closemu.RUnlock()

	if .closed {
		return false
	}

	.lastcols = nil
	,  := .rowsi.(driver.RowsNextResultSet)
	if ! {
		 = 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.
	.dc.Lock()
	defer .dc.Unlock()

	.lasterr = .NextResultSet()
	if .lasterr != nil {
		 = 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 ( *Rows) () error {
	.closemu.RLock()
	defer .closemu.RUnlock()
	return .lasterrOrErrLocked(nil)
}

var errRowsClosed = errors.New("sql: Rows are closed")
var errNoRows = errors.New("sql: no Rows available")
Columns returns the column names. Columns returns an error if the rows are closed.
func ( *Rows) () ([]string, error) {
	.closemu.RLock()
	defer .closemu.RUnlock()
	if .closed {
		return nil, .lasterrOrErrLocked(errRowsClosed)
	}
	if .rowsi == nil {
		return nil, .lasterrOrErrLocked(errNoRows)
	}
	.dc.Lock()
	defer .dc.Unlock()

	return .rowsi.Columns(), nil
}
ColumnTypes returns column information such as column type, length, and nullable. Some information may not be available from some drivers.
func ( *Rows) () ([]*ColumnType, error) {
	.closemu.RLock()
	defer .closemu.RUnlock()
	if .closed {
		return nil, .lasterrOrErrLocked(errRowsClosed)
	}
	if .rowsi == nil {
		return nil, .lasterrOrErrLocked(errNoRows)
	}
	.dc.Lock()
	defer .dc.Unlock()

	return rowsColumnInfoSetupConnLocked(.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 ( *ColumnType) () string {
	return .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 ( *ColumnType) () ( int64,  bool) {
	return .length, .hasLength
}
DecimalSize returns the scale and precision of a decimal type. If not applicable or if not supported ok is false.
func ( *ColumnType) () (,  int64,  bool) {
	return .precision, .scale, .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 ( *ColumnType) () reflect.Type {
	return .scanType
}
Nullable reports whether the column may be null. If a driver does not support this property ok will be false.
func ( *ColumnType) () (,  bool) {
	return .nullable, .hasNullable
}
DatabaseTypeName returns the database system name of the column type. If an empty string is returned, then 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 names include "VARCHAR", "TEXT", "NVARCHAR", "DECIMAL", "BOOL", "INT", and "BIGINT".
func ( *ColumnType) () string {
	return .databaseType
}

func ( driver.Rows) []*ColumnType {
	 := .Columns()

	 := make([]*ColumnType, len())
	for  := range  {
		 := &ColumnType{
			name: [],
		}
		[] = 

		if ,  := .(driver.RowsColumnTypeScanType);  {
			.scanType = .ColumnTypeScanType()
		} else {
			.scanType = reflect.TypeOf(new(interface{})).Elem()
		}
		if ,  := .(driver.RowsColumnTypeDatabaseTypeName);  {
			.databaseType = .ColumnTypeDatabaseTypeName()
		}
		if ,  := .(driver.RowsColumnTypeLength);  {
			.length, .hasLength = .ColumnTypeLength()
		}
		if ,  := .(driver.RowsColumnTypeNullable);  {
			.nullable, .hasNullable = .ColumnTypeNullable()
		}
		if ,  := .(driver.RowsColumnTypePrecisionScale);  {
			.precision, .scale, .hasPrecisionScale = .ColumnTypePrecisionScale()
		}
	}
	return 
}
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 *Rows (cursor value) 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. Scan can also convert a cursor returned from a query, such as "select cursor(select * from my_table) from dual", into a *Rows value that can itself be scanned from. The parent select query will close any cursor *Rows if the parent *Rows is closed. If any of the first arguments implementing Scanner returns an error, that error will be wrapped in the returned error
func ( *Rows) ( ...interface{}) error {
	.closemu.RLock()

	if .lasterr != nil && .lasterr != io.EOF {
		.closemu.RUnlock()
		return .lasterr
	}
	if .closed {
		 := .lasterrOrErrLocked(errRowsClosed)
		.closemu.RUnlock()
		return 
	}
	.closemu.RUnlock()

	if .lastcols == nil {
		return errors.New("sql: Scan called without calling Next")
	}
	if len() != len(.lastcols) {
		return fmt.Errorf("sql: expected %d destination arguments in Scan, not %d", len(.lastcols), len())
	}
	for ,  := range .lastcols {
		 := convertAssignRows([], , )
		if  != nil {
			return fmt.Errorf(`sql: Scan error on column index %d, name %q: %w`, , .rowsi.Columns()[], )
		}
	}
	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 ( *Rows) () error {
	return .close(nil)
}

func ( *Rows) ( error) error {
	.closemu.Lock()
	defer .closemu.Unlock()

	if .closed {
		return nil
	}
	.closed = true

	if .lasterr == nil {
		.lasterr = 
	}

	withLock(.dc, func() {
		 = .rowsi.Close()
	})
	if  := rowsCloseHook();  != nil {
		(, &)
	}
	if .cancel != nil {
		.cancel()
	}

	if .closeStmt != nil {
		.closeStmt.Close()
	}
	.releaseConn()
	return 
}
Row is the result of calling QueryRow to select a single row.
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 ( *Row) ( ...interface{}) error {
	if .err != nil {
		return .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 .rows.Close()
	for ,  := range  {
		if ,  := .(*RawBytes);  {
			return errors.New("sql: RawBytes isn't allowed on Row.Scan")
		}
	}

	if !.rows.Next() {
		if  := .rows.Err();  != nil {
			return 
		}
		return ErrNoRows
	}
	 := .rows.Scan(...)
	if  != nil {
		return
Make sure the query can be processed to completion with no errors.
	return .rows.Close()
}
Err provides a way for wrapping packages to check for query errors without calling Scan. Err returns the error, if any, that was encountered while running the query. If this error is not nil, this error will also be returned from Scan.
func ( *Row) () error {
	return .err
}
A Result summarizes an executed SQL command.
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 ( driverResult) () (int64, error) {
	.Lock()
	defer .Unlock()
	return .resi.LastInsertId()
}

func ( driverResult) () (int64, error) {
	.Lock()
	defer .Unlock()
	return .resi.RowsAffected()
}

func () string {
	var  [2 << 10]byte
	return string([:runtime.Stack([:], false)])
}
withLock runs while holding lk.
func ( sync.Locker,  func()) {
	.Lock()
	defer .Unlock() // in case fn panics
	()