Source file src/database/sql/sql_test.go

Documentation: database/sql

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package sql
     6  
     7  import (
     8  	"context"
     9  	"database/sql/driver"
    10  	"errors"
    11  	"fmt"
    12  	"math/rand"
    13  	"reflect"
    14  	"runtime"
    15  	"strings"
    16  	"sync"
    17  	"sync/atomic"
    18  	"testing"
    19  	"time"
    20  )
    21  
    22  func init() {
    23  	type dbConn struct {
    24  		db *DB
    25  		c  *driverConn
    26  	}
    27  	freedFrom := make(map[dbConn]string)
    28  	var mu sync.Mutex
    29  	getFreedFrom := func(c dbConn) string {
    30  		mu.Lock()
    31  		defer mu.Unlock()
    32  		return freedFrom[c]
    33  	}
    34  	setFreedFrom := func(c dbConn, s string) {
    35  		mu.Lock()
    36  		defer mu.Unlock()
    37  		freedFrom[c] = s
    38  	}
    39  	putConnHook = func(db *DB, c *driverConn) {
    40  		idx := -1
    41  		for i, v := range db.freeConn {
    42  			if v == c {
    43  				idx = i
    44  				break
    45  			}
    46  		}
    47  		if idx >= 0 {
    48  			// print before panic, as panic may get lost due to conflicting panic
    49  			// (all goroutines asleep) elsewhere, since we might not unlock
    50  			// the mutex in freeConn here.
    51  			println("double free of conn. conflicts are:\nA) " + getFreedFrom(dbConn{db, c}) + "\n\nand\nB) " + stack())
    52  			panic("double free of conn.")
    53  		}
    54  		setFreedFrom(dbConn{db, c}, stack())
    55  	}
    56  }
    57  
    58  const fakeDBName = "foo"
    59  
    60  var chrisBirthday = time.Unix(123456789, 0)
    61  
    62  func newTestDB(t testing.TB, name string) *DB {
    63  	return newTestDBConnector(t, &fakeConnector{name: fakeDBName}, name)
    64  }
    65  
    66  func newTestDBConnector(t testing.TB, fc *fakeConnector, name string) *DB {
    67  	fc.name = fakeDBName
    68  	db := OpenDB(fc)
    69  	if _, err := db.Exec("WIPE"); err != nil {
    70  		t.Fatalf("exec wipe: %v", err)
    71  	}
    72  	if name == "people" {
    73  		exec(t, db, "CREATE|people|name=string,age=int32,photo=blob,dead=bool,bdate=datetime")
    74  		exec(t, db, "INSERT|people|name=Alice,age=?,photo=APHOTO", 1)
    75  		exec(t, db, "INSERT|people|name=Bob,age=?,photo=BPHOTO", 2)
    76  		exec(t, db, "INSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?", 3, chrisBirthday)
    77  	}
    78  	if name == "magicquery" {
    79  		// Magic table name and column, known by fakedb_test.go.
    80  		exec(t, db, "CREATE|magicquery|op=string,millis=int32")
    81  		exec(t, db, "INSERT|magicquery|op=sleep,millis=10")
    82  	}
    83  	if name == "tx_status" {
    84  		// Magic table name and column, known by fakedb_test.go.
    85  		exec(t, db, "CREATE|tx_status|tx_status=string")
    86  		exec(t, db, "INSERT|tx_status|tx_status=invalid")
    87  	}
    88  	return db
    89  }
    90  
    91  func TestOpenDB(t *testing.T) {
    92  	db := OpenDB(dsnConnector{dsn: fakeDBName, driver: fdriver})
    93  	if db.Driver() != fdriver {
    94  		t.Fatalf("OpenDB should return the driver of the Connector")
    95  	}
    96  }
    97  
    98  func TestDriverPanic(t *testing.T) {
    99  	// Test that if driver panics, database/sql does not deadlock.
   100  	db, err := Open("test", fakeDBName)
   101  	if err != nil {
   102  		t.Fatalf("Open: %v", err)
   103  	}
   104  	expectPanic := func(name string, f func()) {
   105  		defer func() {
   106  			err := recover()
   107  			if err == nil {
   108  				t.Fatalf("%s did not panic", name)
   109  			}
   110  		}()
   111  		f()
   112  	}
   113  
   114  	expectPanic("Exec Exec", func() { db.Exec("PANIC|Exec|WIPE") })
   115  	exec(t, db, "WIPE") // check not deadlocked
   116  	expectPanic("Exec NumInput", func() { db.Exec("PANIC|NumInput|WIPE") })
   117  	exec(t, db, "WIPE") // check not deadlocked
   118  	expectPanic("Exec Close", func() { db.Exec("PANIC|Close|WIPE") })
   119  	exec(t, db, "WIPE")             // check not deadlocked
   120  	exec(t, db, "PANIC|Query|WIPE") // should run successfully: Exec does not call Query
   121  	exec(t, db, "WIPE")             // check not deadlocked
   122  
   123  	exec(t, db, "CREATE|people|name=string,age=int32,photo=blob,dead=bool,bdate=datetime")
   124  
   125  	expectPanic("Query Query", func() { db.Query("PANIC|Query|SELECT|people|age,name|") })
   126  	expectPanic("Query NumInput", func() { db.Query("PANIC|NumInput|SELECT|people|age,name|") })
   127  	expectPanic("Query Close", func() {
   128  		rows, err := db.Query("PANIC|Close|SELECT|people|age,name|")
   129  		if err != nil {
   130  			t.Fatal(err)
   131  		}
   132  		rows.Close()
   133  	})
   134  	db.Query("PANIC|Exec|SELECT|people|age,name|") // should run successfully: Query does not call Exec
   135  	exec(t, db, "WIPE")                            // check not deadlocked
   136  }
   137  
   138  func exec(t testing.TB, db *DB, query string, args ...interface{}) {
   139  	t.Helper()
   140  	_, err := db.Exec(query, args...)
   141  	if err != nil {
   142  		t.Fatalf("Exec of %q: %v", query, err)
   143  	}
   144  }
   145  
   146  func closeDB(t testing.TB, db *DB) {
   147  	if e := recover(); e != nil {
   148  		fmt.Printf("Panic: %v\n", e)
   149  		panic(e)
   150  	}
   151  	defer setHookpostCloseConn(nil)
   152  	setHookpostCloseConn(func(_ *fakeConn, err error) {
   153  		if err != nil {
   154  			t.Errorf("Error closing fakeConn: %v", err)
   155  		}
   156  	})
   157  	db.mu.Lock()
   158  	for i, dc := range db.freeConn {
   159  		if n := len(dc.openStmt); n > 0 {
   160  			// Just a sanity check. This is legal in
   161  			// general, but if we make the tests clean up
   162  			// their statements first, then we can safely
   163  			// verify this is always zero here, and any
   164  			// other value is a leak.
   165  			t.Errorf("while closing db, freeConn %d/%d had %d open stmts; want 0", i, len(db.freeConn), n)
   166  		}
   167  	}
   168  	db.mu.Unlock()
   169  
   170  	err := db.Close()
   171  	if err != nil {
   172  		t.Fatalf("error closing DB: %v", err)
   173  	}
   174  
   175  	var numOpen int
   176  	if !waitCondition(5*time.Second, 5*time.Millisecond, func() bool {
   177  		numOpen = db.numOpenConns()
   178  		return numOpen == 0
   179  	}) {
   180  		t.Fatalf("%d connections still open after closing DB", numOpen)
   181  	}
   182  }
   183  
   184  // numPrepares assumes that db has exactly 1 idle conn and returns
   185  // its count of calls to Prepare
   186  func numPrepares(t *testing.T, db *DB) int {
   187  	if n := len(db.freeConn); n != 1 {
   188  		t.Fatalf("free conns = %d; want 1", n)
   189  	}
   190  	return db.freeConn[0].ci.(*fakeConn).numPrepare
   191  }
   192  
   193  func (db *DB) numDeps() int {
   194  	db.mu.Lock()
   195  	defer db.mu.Unlock()
   196  	return len(db.dep)
   197  }
   198  
   199  // Dependencies are closed via a goroutine, so this polls waiting for
   200  // numDeps to fall to want, waiting up to d.
   201  func (db *DB) numDepsPollUntil(want int, d time.Duration) int {
   202  	deadline := time.Now().Add(d)
   203  	for {
   204  		n := db.numDeps()
   205  		if n <= want || time.Now().After(deadline) {
   206  			return n
   207  		}
   208  		time.Sleep(50 * time.Millisecond)
   209  	}
   210  }
   211  
   212  func (db *DB) numFreeConns() int {
   213  	db.mu.Lock()
   214  	defer db.mu.Unlock()
   215  	return len(db.freeConn)
   216  }
   217  
   218  func (db *DB) numOpenConns() int {
   219  	db.mu.Lock()
   220  	defer db.mu.Unlock()
   221  	return db.numOpen
   222  }
   223  
   224  // clearAllConns closes all connections in db.
   225  func (db *DB) clearAllConns(t *testing.T) {
   226  	db.SetMaxIdleConns(0)
   227  
   228  	if g, w := db.numFreeConns(), 0; g != w {
   229  		t.Errorf("free conns = %d; want %d", g, w)
   230  	}
   231  
   232  	if n := db.numDepsPollUntil(0, time.Second); n > 0 {
   233  		t.Errorf("number of dependencies = %d; expected 0", n)
   234  		db.dumpDeps(t)
   235  	}
   236  }
   237  
   238  func (db *DB) dumpDeps(t *testing.T) {
   239  	for fc := range db.dep {
   240  		db.dumpDep(t, 0, fc, map[finalCloser]bool{})
   241  	}
   242  }
   243  
   244  func (db *DB) dumpDep(t *testing.T, depth int, dep finalCloser, seen map[finalCloser]bool) {
   245  	seen[dep] = true
   246  	indent := strings.Repeat("  ", depth)
   247  	ds := db.dep[dep]
   248  	for k := range ds {
   249  		t.Logf("%s%T (%p) waiting for -> %T (%p)", indent, dep, dep, k, k)
   250  		if fc, ok := k.(finalCloser); ok {
   251  			if !seen[fc] {
   252  				db.dumpDep(t, depth+1, fc, seen)
   253  			}
   254  		}
   255  	}
   256  }
   257  
   258  func TestQuery(t *testing.T) {
   259  	db := newTestDB(t, "people")
   260  	defer closeDB(t, db)
   261  	prepares0 := numPrepares(t, db)
   262  	rows, err := db.Query("SELECT|people|age,name|")
   263  	if err != nil {
   264  		t.Fatalf("Query: %v", err)
   265  	}
   266  	type row struct {
   267  		age  int
   268  		name string
   269  	}
   270  	got := []row{}
   271  	for rows.Next() {
   272  		var r row
   273  		err = rows.Scan(&r.age, &r.name)
   274  		if err != nil {
   275  			t.Fatalf("Scan: %v", err)
   276  		}
   277  		got = append(got, r)
   278  	}
   279  	err = rows.Err()
   280  	if err != nil {
   281  		t.Fatalf("Err: %v", err)
   282  	}
   283  	want := []row{
   284  		{age: 1, name: "Alice"},
   285  		{age: 2, name: "Bob"},
   286  		{age: 3, name: "Chris"},
   287  	}
   288  	if !reflect.DeepEqual(got, want) {
   289  		t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)
   290  	}
   291  
   292  	// And verify that the final rows.Next() call, which hit EOF,
   293  	// also closed the rows connection.
   294  	if n := db.numFreeConns(); n != 1 {
   295  		t.Fatalf("free conns after query hitting EOF = %d; want 1", n)
   296  	}
   297  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
   298  		t.Errorf("executed %d Prepare statements; want 1", prepares)
   299  	}
   300  }
   301  
   302  // TestQueryContext tests canceling the context while scanning the rows.
   303  func TestQueryContext(t *testing.T) {
   304  	db := newTestDB(t, "people")
   305  	defer closeDB(t, db)
   306  	prepares0 := numPrepares(t, db)
   307  
   308  	ctx, cancel := context.WithCancel(context.Background())
   309  	defer cancel()
   310  
   311  	rows, err := db.QueryContext(ctx, "SELECT|people|age,name|")
   312  	if err != nil {
   313  		t.Fatalf("Query: %v", err)
   314  	}
   315  	type row struct {
   316  		age  int
   317  		name string
   318  	}
   319  	got := []row{}
   320  	index := 0
   321  	for rows.Next() {
   322  		if index == 2 {
   323  			cancel()
   324  			waitForRowsClose(t, rows, 5*time.Second)
   325  		}
   326  		var r row
   327  		err = rows.Scan(&r.age, &r.name)
   328  		if err != nil {
   329  			if index == 2 {
   330  				break
   331  			}
   332  			t.Fatalf("Scan: %v", err)
   333  		}
   334  		if index == 2 && err != context.Canceled {
   335  			t.Fatalf("Scan: %v; want context.Canceled", err)
   336  		}
   337  		got = append(got, r)
   338  		index++
   339  	}
   340  	select {
   341  	case <-ctx.Done():
   342  		if err := ctx.Err(); err != context.Canceled {
   343  			t.Fatalf("context err = %v; want context.Canceled", err)
   344  		}
   345  	default:
   346  		t.Fatalf("context err = nil; want context.Canceled")
   347  	}
   348  	want := []row{
   349  		{age: 1, name: "Alice"},
   350  		{age: 2, name: "Bob"},
   351  	}
   352  	if !reflect.DeepEqual(got, want) {
   353  		t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)
   354  	}
   355  
   356  	// And verify that the final rows.Next() call, which hit EOF,
   357  	// also closed the rows connection.
   358  	waitForRowsClose(t, rows, 5*time.Second)
   359  	waitForFree(t, db, 5*time.Second, 1)
   360  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
   361  		t.Errorf("executed %d Prepare statements; want 1", prepares)
   362  	}
   363  }
   364  
   365  func waitCondition(waitFor, checkEvery time.Duration, fn func() bool) bool {
   366  	deadline := time.Now().Add(waitFor)
   367  	for time.Now().Before(deadline) {
   368  		if fn() {
   369  			return true
   370  		}
   371  		time.Sleep(checkEvery)
   372  	}
   373  	return false
   374  }
   375  
   376  // waitForFree checks db.numFreeConns until either it equals want or
   377  // the maxWait time elapses.
   378  func waitForFree(t *testing.T, db *DB, maxWait time.Duration, want int) {
   379  	var numFree int
   380  	if !waitCondition(maxWait, 5*time.Millisecond, func() bool {
   381  		numFree = db.numFreeConns()
   382  		return numFree == want
   383  	}) {
   384  		t.Fatalf("free conns after hitting EOF = %d; want %d", numFree, want)
   385  	}
   386  }
   387  
   388  func waitForRowsClose(t *testing.T, rows *Rows, maxWait time.Duration) {
   389  	if !waitCondition(maxWait, 5*time.Millisecond, func() bool {
   390  		rows.closemu.RLock()
   391  		defer rows.closemu.RUnlock()
   392  		return rows.closed
   393  	}) {
   394  		t.Fatal("failed to close rows")
   395  	}
   396  }
   397  
   398  // TestQueryContextWait ensures that rows and all internal statements are closed when
   399  // a query context is closed during execution.
   400  func TestQueryContextWait(t *testing.T) {
   401  	db := newTestDB(t, "people")
   402  	defer closeDB(t, db)
   403  	prepares0 := numPrepares(t, db)
   404  
   405  	// TODO(kardianos): convert this from using a timeout to using an explicit
   406  	// cancel when the query signals that it is "executing" the query.
   407  	ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
   408  	defer cancel()
   409  
   410  	// This will trigger the *fakeConn.Prepare method which will take time
   411  	// performing the query. The ctxDriverPrepare func will check the context
   412  	// after this and close the rows and return an error.
   413  	_, err := db.QueryContext(ctx, "WAIT|1s|SELECT|people|age,name|")
   414  	if err != context.DeadlineExceeded {
   415  		t.Fatalf("expected QueryContext to error with context deadline exceeded but returned %v", err)
   416  	}
   417  
   418  	// Verify closed rows connection after error condition.
   419  	waitForFree(t, db, 5*time.Second, 1)
   420  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
   421  		// TODO(kardianos): if the context timeouts before the db.QueryContext
   422  		// executes this check may fail. After adjusting how the context
   423  		// is canceled above revert this back to a Fatal error.
   424  		t.Logf("executed %d Prepare statements; want 1", prepares)
   425  	}
   426  }
   427  
   428  // TestTxContextWait tests the transaction behavior when the tx context is canceled
   429  // during execution of the query.
   430  func TestTxContextWait(t *testing.T) {
   431  	db := newTestDB(t, "people")
   432  	defer closeDB(t, db)
   433  
   434  	ctx, cancel := context.WithCancel(context.Background())
   435  
   436  	tx, err := db.BeginTx(ctx, nil)
   437  	if err != nil {
   438  		t.Fatal(err)
   439  	}
   440  	tx.keepConnOnRollback = false
   441  
   442  	go func() {
   443  		time.Sleep(15 * time.Millisecond)
   444  		cancel()
   445  	}()
   446  	// This will trigger the *fakeConn.Prepare method which will take time
   447  	// performing the query. The ctxDriverPrepare func will check the context
   448  	// after this and close the rows and return an error.
   449  	_, err = tx.QueryContext(ctx, "WAIT|1s|SELECT|people|age,name|")
   450  	if err != context.Canceled {
   451  		t.Fatalf("expected QueryContext to error with context canceled but returned %v", err)
   452  	}
   453  
   454  	waitForFree(t, db, 5*time.Second, 0)
   455  }
   456  
   457  // TestTxContextWaitNoDiscard is the same as TestTxContextWait, but should not discard
   458  // the final connection.
   459  func TestTxContextWaitNoDiscard(t *testing.T) {
   460  	db := newTestDB(t, "people")
   461  	defer closeDB(t, db)
   462  
   463  	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Millisecond)
   464  	defer cancel()
   465  
   466  	tx, err := db.BeginTx(ctx, nil)
   467  	if err != nil {
   468  		// Guard against the context being canceled before BeginTx completes.
   469  		if err == context.DeadlineExceeded {
   470  			t.Skip("tx context canceled prior to first use")
   471  		}
   472  		t.Fatal(err)
   473  	}
   474  
   475  	// This will trigger the *fakeConn.Prepare method which will take time
   476  	// performing the query. The ctxDriverPrepare func will check the context
   477  	// after this and close the rows and return an error.
   478  	_, err = tx.QueryContext(ctx, "WAIT|1s|SELECT|people|age,name|")
   479  	if err != context.DeadlineExceeded {
   480  		t.Fatalf("expected QueryContext to error with context deadline exceeded but returned %v", err)
   481  	}
   482  
   483  	waitForFree(t, db, 5*time.Second, 1)
   484  }
   485  
   486  // TestUnsupportedOptions checks that the database fails when a driver that
   487  // doesn't implement ConnBeginTx is used with non-default options and an
   488  // un-cancellable context.
   489  func TestUnsupportedOptions(t *testing.T) {
   490  	db := newTestDB(t, "people")
   491  	defer closeDB(t, db)
   492  	_, err := db.BeginTx(context.Background(), &TxOptions{
   493  		Isolation: LevelSerializable, ReadOnly: true,
   494  	})
   495  	if err == nil {
   496  		t.Fatal("expected error when using unsupported options, got nil")
   497  	}
   498  }
   499  
   500  func TestMultiResultSetQuery(t *testing.T) {
   501  	db := newTestDB(t, "people")
   502  	defer closeDB(t, db)
   503  	prepares0 := numPrepares(t, db)
   504  	rows, err := db.Query("SELECT|people|age,name|;SELECT|people|name|")
   505  	if err != nil {
   506  		t.Fatalf("Query: %v", err)
   507  	}
   508  	type row1 struct {
   509  		age  int
   510  		name string
   511  	}
   512  	type row2 struct {
   513  		name string
   514  	}
   515  	got1 := []row1{}
   516  	for rows.Next() {
   517  		var r row1
   518  		err = rows.Scan(&r.age, &r.name)
   519  		if err != nil {
   520  			t.Fatalf("Scan: %v", err)
   521  		}
   522  		got1 = append(got1, r)
   523  	}
   524  	err = rows.Err()
   525  	if err != nil {
   526  		t.Fatalf("Err: %v", err)
   527  	}
   528  	want1 := []row1{
   529  		{age: 1, name: "Alice"},
   530  		{age: 2, name: "Bob"},
   531  		{age: 3, name: "Chris"},
   532  	}
   533  	if !reflect.DeepEqual(got1, want1) {
   534  		t.Errorf("mismatch.\n got1: %#v\nwant: %#v", got1, want1)
   535  	}
   536  
   537  	if !rows.NextResultSet() {
   538  		t.Errorf("expected another result set")
   539  	}
   540  
   541  	got2 := []row2{}
   542  	for rows.Next() {
   543  		var r row2
   544  		err = rows.Scan(&r.name)
   545  		if err != nil {
   546  			t.Fatalf("Scan: %v", err)
   547  		}
   548  		got2 = append(got2, r)
   549  	}
   550  	err = rows.Err()
   551  	if err != nil {
   552  		t.Fatalf("Err: %v", err)
   553  	}
   554  	want2 := []row2{
   555  		{name: "Alice"},
   556  		{name: "Bob"},
   557  		{name: "Chris"},
   558  	}
   559  	if !reflect.DeepEqual(got2, want2) {
   560  		t.Errorf("mismatch.\n got: %#v\nwant: %#v", got2, want2)
   561  	}
   562  	if rows.NextResultSet() {
   563  		t.Errorf("expected no more result sets")
   564  	}
   565  
   566  	// And verify that the final rows.Next() call, which hit EOF,
   567  	// also closed the rows connection.
   568  	waitForFree(t, db, 5*time.Second, 1)
   569  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
   570  		t.Errorf("executed %d Prepare statements; want 1", prepares)
   571  	}
   572  }
   573  
   574  func TestQueryNamedArg(t *testing.T) {
   575  	db := newTestDB(t, "people")
   576  	defer closeDB(t, db)
   577  	prepares0 := numPrepares(t, db)
   578  	rows, err := db.Query(
   579  		// Ensure the name and age parameters only match on placeholder name, not position.
   580  		"SELECT|people|age,name|name=?name,age=?age",
   581  		Named("age", 2),
   582  		Named("name", "Bob"),
   583  	)
   584  	if err != nil {
   585  		t.Fatalf("Query: %v", err)
   586  	}
   587  	type row struct {
   588  		age  int
   589  		name string
   590  	}
   591  	got := []row{}
   592  	for rows.Next() {
   593  		var r row
   594  		err = rows.Scan(&r.age, &r.name)
   595  		if err != nil {
   596  			t.Fatalf("Scan: %v", err)
   597  		}
   598  		got = append(got, r)
   599  	}
   600  	err = rows.Err()
   601  	if err != nil {
   602  		t.Fatalf("Err: %v", err)
   603  	}
   604  	want := []row{
   605  		{age: 2, name: "Bob"},
   606  	}
   607  	if !reflect.DeepEqual(got, want) {
   608  		t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)
   609  	}
   610  
   611  	// And verify that the final rows.Next() call, which hit EOF,
   612  	// also closed the rows connection.
   613  	if n := db.numFreeConns(); n != 1 {
   614  		t.Fatalf("free conns after query hitting EOF = %d; want 1", n)
   615  	}
   616  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
   617  		t.Errorf("executed %d Prepare statements; want 1", prepares)
   618  	}
   619  }
   620  
   621  func TestPoolExhaustOnCancel(t *testing.T) {
   622  	if testing.Short() {
   623  		t.Skip("long test")
   624  	}
   625  
   626  	max := 3
   627  	var saturate, saturateDone sync.WaitGroup
   628  	saturate.Add(max)
   629  	saturateDone.Add(max)
   630  
   631  	donePing := make(chan bool)
   632  	state := 0
   633  
   634  	// waiter will be called for all queries, including
   635  	// initial setup queries. The state is only assigned when
   636  	// no queries are made.
   637  	//
   638  	// Only allow the first batch of queries to finish once the
   639  	// second batch of Ping queries have finished.
   640  	waiter := func(ctx context.Context) {
   641  		switch state {
   642  		case 0:
   643  			// Nothing. Initial database setup.
   644  		case 1:
   645  			saturate.Done()
   646  			select {
   647  			case <-ctx.Done():
   648  			case <-donePing:
   649  			}
   650  		case 2:
   651  		}
   652  	}
   653  	db := newTestDBConnector(t, &fakeConnector{waiter: waiter}, "people")
   654  	defer closeDB(t, db)
   655  
   656  	db.SetMaxOpenConns(max)
   657  
   658  	// First saturate the connection pool.
   659  	// Then start new requests for a connection that is canceled after it is requested.
   660  
   661  	state = 1
   662  	for i := 0; i < max; i++ {
   663  		go func() {
   664  			rows, err := db.Query("SELECT|people|name,photo|")
   665  			if err != nil {
   666  				t.Errorf("Query: %v", err)
   667  				return
   668  			}
   669  			rows.Close()
   670  			saturateDone.Done()
   671  		}()
   672  	}
   673  
   674  	saturate.Wait()
   675  	if t.Failed() {
   676  		t.FailNow()
   677  	}
   678  	state = 2
   679  
   680  	// Now cancel the request while it is waiting.
   681  	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
   682  	defer cancel()
   683  
   684  	for i := 0; i < max; i++ {
   685  		ctxReq, cancelReq := context.WithCancel(ctx)
   686  		go func() {
   687  			time.Sleep(100 * time.Millisecond)
   688  			cancelReq()
   689  		}()
   690  		err := db.PingContext(ctxReq)
   691  		if err != context.Canceled {
   692  			t.Fatalf("PingContext (Exhaust): %v", err)
   693  		}
   694  	}
   695  	close(donePing)
   696  	saturateDone.Wait()
   697  
   698  	// Now try to open a normal connection.
   699  	err := db.PingContext(ctx)
   700  	if err != nil {
   701  		t.Fatalf("PingContext (Normal): %v", err)
   702  	}
   703  }
   704  
   705  func TestRowsColumns(t *testing.T) {
   706  	db := newTestDB(t, "people")
   707  	defer closeDB(t, db)
   708  	rows, err := db.Query("SELECT|people|age,name|")
   709  	if err != nil {
   710  		t.Fatalf("Query: %v", err)
   711  	}
   712  	cols, err := rows.Columns()
   713  	if err != nil {
   714  		t.Fatalf("Columns: %v", err)
   715  	}
   716  	want := []string{"age", "name"}
   717  	if !reflect.DeepEqual(cols, want) {
   718  		t.Errorf("got %#v; want %#v", cols, want)
   719  	}
   720  	if err := rows.Close(); err != nil {
   721  		t.Errorf("error closing rows: %s", err)
   722  	}
   723  }
   724  
   725  func TestRowsColumnTypes(t *testing.T) {
   726  	db := newTestDB(t, "people")
   727  	defer closeDB(t, db)
   728  	rows, err := db.Query("SELECT|people|age,name|")
   729  	if err != nil {
   730  		t.Fatalf("Query: %v", err)
   731  	}
   732  	tt, err := rows.ColumnTypes()
   733  	if err != nil {
   734  		t.Fatalf("ColumnTypes: %v", err)
   735  	}
   736  
   737  	types := make([]reflect.Type, len(tt))
   738  	for i, tp := range tt {
   739  		st := tp.ScanType()
   740  		if st == nil {
   741  			t.Errorf("scantype is null for column %q", tp.Name())
   742  			continue
   743  		}
   744  		types[i] = st
   745  	}
   746  	values := make([]interface{}, len(tt))
   747  	for i := range values {
   748  		values[i] = reflect.New(types[i]).Interface()
   749  	}
   750  	ct := 0
   751  	for rows.Next() {
   752  		err = rows.Scan(values...)
   753  		if err != nil {
   754  			t.Fatalf("failed to scan values in %v", err)
   755  		}
   756  		if ct == 1 {
   757  			if age := *values[0].(*int32); age != 2 {
   758  				t.Errorf("Expected 2, got %v", age)
   759  			}
   760  			if name := *values[1].(*string); name != "Bob" {
   761  				t.Errorf("Expected Bob, got %v", name)
   762  			}
   763  		}
   764  		ct++
   765  	}
   766  	if ct != 3 {
   767  		t.Errorf("expected 3 rows, got %d", ct)
   768  	}
   769  
   770  	if err := rows.Close(); err != nil {
   771  		t.Errorf("error closing rows: %s", err)
   772  	}
   773  }
   774  
   775  func TestQueryRow(t *testing.T) {
   776  	db := newTestDB(t, "people")
   777  	defer closeDB(t, db)
   778  	var name string
   779  	var age int
   780  	var birthday time.Time
   781  
   782  	err := db.QueryRow("SELECT|people|age,name|age=?", 3).Scan(&age)
   783  	if err == nil || !strings.Contains(err.Error(), "expected 2 destination arguments") {
   784  		t.Errorf("expected error from wrong number of arguments; actually got: %v", err)
   785  	}
   786  
   787  	err = db.QueryRow("SELECT|people|bdate|age=?", 3).Scan(&birthday)
   788  	if err != nil || !birthday.Equal(chrisBirthday) {
   789  		t.Errorf("chris birthday = %v, err = %v; want %v", birthday, err, chrisBirthday)
   790  	}
   791  
   792  	err = db.QueryRow("SELECT|people|age,name|age=?", 2).Scan(&age, &name)
   793  	if err != nil {
   794  		t.Fatalf("age QueryRow+Scan: %v", err)
   795  	}
   796  	if name != "Bob" {
   797  		t.Errorf("expected name Bob, got %q", name)
   798  	}
   799  	if age != 2 {
   800  		t.Errorf("expected age 2, got %d", age)
   801  	}
   802  
   803  	err = db.QueryRow("SELECT|people|age,name|name=?", "Alice").Scan(&age, &name)
   804  	if err != nil {
   805  		t.Fatalf("name QueryRow+Scan: %v", err)
   806  	}
   807  	if name != "Alice" {
   808  		t.Errorf("expected name Alice, got %q", name)
   809  	}
   810  	if age != 1 {
   811  		t.Errorf("expected age 1, got %d", age)
   812  	}
   813  
   814  	var photo []byte
   815  	err = db.QueryRow("SELECT|people|photo|name=?", "Alice").Scan(&photo)
   816  	if err != nil {
   817  		t.Fatalf("photo QueryRow+Scan: %v", err)
   818  	}
   819  	want := []byte("APHOTO")
   820  	if !reflect.DeepEqual(photo, want) {
   821  		t.Errorf("photo = %q; want %q", photo, want)
   822  	}
   823  }
   824  
   825  func TestRowErr(t *testing.T) {
   826  	db := newTestDB(t, "people")
   827  
   828  	err := db.QueryRowContext(context.Background(), "SELECT|people|bdate|age=?", 3).Err()
   829  	if err != nil {
   830  		t.Errorf("Unexpected err = %v; want %v", err, nil)
   831  	}
   832  
   833  	ctx, cancel := context.WithCancel(context.Background())
   834  	cancel()
   835  
   836  	err = db.QueryRowContext(ctx, "SELECT|people|bdate|age=?", 3).Err()
   837  	exp := "context canceled"
   838  	if err == nil || !strings.Contains(err.Error(), exp) {
   839  		t.Errorf("Expected err = %v; got %v", exp, err)
   840  	}
   841  }
   842  
   843  func TestTxRollbackCommitErr(t *testing.T) {
   844  	db := newTestDB(t, "people")
   845  	defer closeDB(t, db)
   846  
   847  	tx, err := db.Begin()
   848  	if err != nil {
   849  		t.Fatal(err)
   850  	}
   851  	err = tx.Rollback()
   852  	if err != nil {
   853  		t.Errorf("expected nil error from Rollback; got %v", err)
   854  	}
   855  	err = tx.Commit()
   856  	if err != ErrTxDone {
   857  		t.Errorf("expected %q from Commit; got %q", ErrTxDone, err)
   858  	}
   859  
   860  	tx, err = db.Begin()
   861  	if err != nil {
   862  		t.Fatal(err)
   863  	}
   864  	err = tx.Commit()
   865  	if err != nil {
   866  		t.Errorf("expected nil error from Commit; got %v", err)
   867  	}
   868  	err = tx.Rollback()
   869  	if err != ErrTxDone {
   870  		t.Errorf("expected %q from Rollback; got %q", ErrTxDone, err)
   871  	}
   872  }
   873  
   874  func TestStatementErrorAfterClose(t *testing.T) {
   875  	db := newTestDB(t, "people")
   876  	defer closeDB(t, db)
   877  	stmt, err := db.Prepare("SELECT|people|age|name=?")
   878  	if err != nil {
   879  		t.Fatalf("Prepare: %v", err)
   880  	}
   881  	err = stmt.Close()
   882  	if err != nil {
   883  		t.Fatalf("Close: %v", err)
   884  	}
   885  	var name string
   886  	err = stmt.QueryRow("foo").Scan(&name)
   887  	if err == nil {
   888  		t.Errorf("expected error from QueryRow.Scan after Stmt.Close")
   889  	}
   890  }
   891  
   892  func TestStatementQueryRow(t *testing.T) {
   893  	db := newTestDB(t, "people")
   894  	defer closeDB(t, db)
   895  	stmt, err := db.Prepare("SELECT|people|age|name=?")
   896  	if err != nil {
   897  		t.Fatalf("Prepare: %v", err)
   898  	}
   899  	defer stmt.Close()
   900  	var age int
   901  	for n, tt := range []struct {
   902  		name string
   903  		want int
   904  	}{
   905  		{"Alice", 1},
   906  		{"Bob", 2},
   907  		{"Chris", 3},
   908  	} {
   909  		if err := stmt.QueryRow(tt.name).Scan(&age); err != nil {
   910  			t.Errorf("%d: on %q, QueryRow/Scan: %v", n, tt.name, err)
   911  		} else if age != tt.want {
   912  			t.Errorf("%d: age=%d, want %d", n, age, tt.want)
   913  		}
   914  	}
   915  }
   916  
   917  type stubDriverStmt struct {
   918  	err error
   919  }
   920  
   921  func (s stubDriverStmt) Close() error {
   922  	return s.err
   923  }
   924  
   925  func (s stubDriverStmt) NumInput() int {
   926  	return -1
   927  }
   928  
   929  func (s stubDriverStmt) Exec(args []driver.Value) (driver.Result, error) {
   930  	return nil, nil
   931  }
   932  
   933  func (s stubDriverStmt) Query(args []driver.Value) (driver.Rows, error) {
   934  	return nil, nil
   935  }
   936  
   937  // golang.org/issue/12798
   938  func TestStatementClose(t *testing.T) {
   939  	want := errors.New("STMT ERROR")
   940  
   941  	tests := []struct {
   942  		stmt *Stmt
   943  		msg  string
   944  	}{
   945  		{&Stmt{stickyErr: want}, "stickyErr not propagated"},
   946  		{&Stmt{cg: &Tx{}, cgds: &driverStmt{Locker: &sync.Mutex{}, si: stubDriverStmt{want}}}, "driverStmt.Close() error not propagated"},
   947  	}
   948  	for _, test := range tests {
   949  		if err := test.stmt.Close(); err != want {
   950  			t.Errorf("%s. Got stmt.Close() = %v, want = %v", test.msg, err, want)
   951  		}
   952  	}
   953  }
   954  
   955  // golang.org/issue/3734
   956  func TestStatementQueryRowConcurrent(t *testing.T) {
   957  	db := newTestDB(t, "people")
   958  	defer closeDB(t, db)
   959  	stmt, err := db.Prepare("SELECT|people|age|name=?")
   960  	if err != nil {
   961  		t.Fatalf("Prepare: %v", err)
   962  	}
   963  	defer stmt.Close()
   964  
   965  	const n = 10
   966  	ch := make(chan error, n)
   967  	for i := 0; i < n; i++ {
   968  		go func() {
   969  			var age int
   970  			err := stmt.QueryRow("Alice").Scan(&age)
   971  			if err == nil && age != 1 {
   972  				err = fmt.Errorf("unexpected age %d", age)
   973  			}
   974  			ch <- err
   975  		}()
   976  	}
   977  	for i := 0; i < n; i++ {
   978  		if err := <-ch; err != nil {
   979  			t.Error(err)
   980  		}
   981  	}
   982  }
   983  
   984  // just a test of fakedb itself
   985  func TestBogusPreboundParameters(t *testing.T) {
   986  	db := newTestDB(t, "foo")
   987  	defer closeDB(t, db)
   988  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
   989  	_, err := db.Prepare("INSERT|t1|name=?,age=bogusconversion")
   990  	if err == nil {
   991  		t.Fatalf("expected error")
   992  	}
   993  	if err.Error() != `fakedb: invalid conversion to int32 from "bogusconversion"` {
   994  		t.Errorf("unexpected error: %v", err)
   995  	}
   996  }
   997  
   998  func TestExec(t *testing.T) {
   999  	db := newTestDB(t, "foo")
  1000  	defer closeDB(t, db)
  1001  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  1002  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1003  	if err != nil {
  1004  		t.Errorf("Stmt, err = %v, %v", stmt, err)
  1005  	}
  1006  	defer stmt.Close()
  1007  
  1008  	type execTest struct {
  1009  		args    []interface{}
  1010  		wantErr string
  1011  	}
  1012  	execTests := []execTest{
  1013  		// Okay:
  1014  		{[]interface{}{"Brad", 31}, ""},
  1015  		{[]interface{}{"Brad", int64(31)}, ""},
  1016  		{[]interface{}{"Bob", "32"}, ""},
  1017  		{[]interface{}{7, 9}, ""},
  1018  
  1019  		// Invalid conversions:
  1020  		{[]interface{}{"Brad", int64(0xFFFFFFFF)}, "sql: converting argument $2 type: sql/driver: value 4294967295 overflows int32"},
  1021  		{[]interface{}{"Brad", "strconv fail"}, `sql: converting argument $2 type: sql/driver: value "strconv fail" can't be converted to int32`},
  1022  
  1023  		// Wrong number of args:
  1024  		{[]interface{}{}, "sql: expected 2 arguments, got 0"},
  1025  		{[]interface{}{1, 2, 3}, "sql: expected 2 arguments, got 3"},
  1026  	}
  1027  	for n, et := range execTests {
  1028  		_, err := stmt.Exec(et.args...)
  1029  		errStr := ""
  1030  		if err != nil {
  1031  			errStr = err.Error()
  1032  		}
  1033  		if errStr != et.wantErr {
  1034  			t.Errorf("stmt.Execute #%d: for %v, got error %q, want error %q",
  1035  				n, et.args, errStr, et.wantErr)
  1036  		}
  1037  	}
  1038  }
  1039  
  1040  func TestTxPrepare(t *testing.T) {
  1041  	db := newTestDB(t, "")
  1042  	defer closeDB(t, db)
  1043  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  1044  	tx, err := db.Begin()
  1045  	if err != nil {
  1046  		t.Fatalf("Begin = %v", err)
  1047  	}
  1048  	stmt, err := tx.Prepare("INSERT|t1|name=?,age=?")
  1049  	if err != nil {
  1050  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1051  	}
  1052  	defer stmt.Close()
  1053  	_, err = stmt.Exec("Bobby", 7)
  1054  	if err != nil {
  1055  		t.Fatalf("Exec = %v", err)
  1056  	}
  1057  	err = tx.Commit()
  1058  	if err != nil {
  1059  		t.Fatalf("Commit = %v", err)
  1060  	}
  1061  	// Commit() should have closed the statement
  1062  	if !stmt.closed {
  1063  		t.Fatal("Stmt not closed after Commit")
  1064  	}
  1065  }
  1066  
  1067  func TestTxStmt(t *testing.T) {
  1068  	db := newTestDB(t, "")
  1069  	defer closeDB(t, db)
  1070  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  1071  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1072  	if err != nil {
  1073  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1074  	}
  1075  	defer stmt.Close()
  1076  	tx, err := db.Begin()
  1077  	if err != nil {
  1078  		t.Fatalf("Begin = %v", err)
  1079  	}
  1080  	txs := tx.Stmt(stmt)
  1081  	defer txs.Close()
  1082  	_, err = txs.Exec("Bobby", 7)
  1083  	if err != nil {
  1084  		t.Fatalf("Exec = %v", err)
  1085  	}
  1086  	err = tx.Commit()
  1087  	if err != nil {
  1088  		t.Fatalf("Commit = %v", err)
  1089  	}
  1090  	// Commit() should have closed the statement
  1091  	if !txs.closed {
  1092  		t.Fatal("Stmt not closed after Commit")
  1093  	}
  1094  }
  1095  
  1096  func TestTxStmtPreparedOnce(t *testing.T) {
  1097  	db := newTestDB(t, "")
  1098  	defer closeDB(t, db)
  1099  	exec(t, db, "CREATE|t1|name=string,age=int32")
  1100  
  1101  	prepares0 := numPrepares(t, db)
  1102  
  1103  	// db.Prepare increments numPrepares.
  1104  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1105  	if err != nil {
  1106  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1107  	}
  1108  	defer stmt.Close()
  1109  
  1110  	tx, err := db.Begin()
  1111  	if err != nil {
  1112  		t.Fatalf("Begin = %v", err)
  1113  	}
  1114  
  1115  	txs1 := tx.Stmt(stmt)
  1116  	txs2 := tx.Stmt(stmt)
  1117  
  1118  	_, err = txs1.Exec("Go", 7)
  1119  	if err != nil {
  1120  		t.Fatalf("Exec = %v", err)
  1121  	}
  1122  	txs1.Close()
  1123  
  1124  	_, err = txs2.Exec("Gopher", 8)
  1125  	if err != nil {
  1126  		t.Fatalf("Exec = %v", err)
  1127  	}
  1128  	txs2.Close()
  1129  
  1130  	err = tx.Commit()
  1131  	if err != nil {
  1132  		t.Fatalf("Commit = %v", err)
  1133  	}
  1134  
  1135  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
  1136  		t.Errorf("executed %d Prepare statements; want 1", prepares)
  1137  	}
  1138  }
  1139  
  1140  func TestTxStmtClosedRePrepares(t *testing.T) {
  1141  	db := newTestDB(t, "")
  1142  	defer closeDB(t, db)
  1143  	exec(t, db, "CREATE|t1|name=string,age=int32")
  1144  
  1145  	prepares0 := numPrepares(t, db)
  1146  
  1147  	// db.Prepare increments numPrepares.
  1148  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1149  	if err != nil {
  1150  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1151  	}
  1152  	tx, err := db.Begin()
  1153  	if err != nil {
  1154  		t.Fatalf("Begin = %v", err)
  1155  	}
  1156  	err = stmt.Close()
  1157  	if err != nil {
  1158  		t.Fatalf("stmt.Close() = %v", err)
  1159  	}
  1160  	// tx.Stmt increments numPrepares because stmt is closed.
  1161  	txs := tx.Stmt(stmt)
  1162  	if txs.stickyErr != nil {
  1163  		t.Fatal(txs.stickyErr)
  1164  	}
  1165  	if txs.parentStmt != nil {
  1166  		t.Fatal("expected nil parentStmt")
  1167  	}
  1168  	_, err = txs.Exec(`Eric`, 82)
  1169  	if err != nil {
  1170  		t.Fatalf("txs.Exec = %v", err)
  1171  	}
  1172  
  1173  	err = txs.Close()
  1174  	if err != nil {
  1175  		t.Fatalf("txs.Close = %v", err)
  1176  	}
  1177  
  1178  	tx.Rollback()
  1179  
  1180  	if prepares := numPrepares(t, db) - prepares0; prepares != 2 {
  1181  		t.Errorf("executed %d Prepare statements; want 2", prepares)
  1182  	}
  1183  }
  1184  
  1185  func TestParentStmtOutlivesTxStmt(t *testing.T) {
  1186  	db := newTestDB(t, "")
  1187  	defer closeDB(t, db)
  1188  	exec(t, db, "CREATE|t1|name=string,age=int32")
  1189  
  1190  	// Make sure everything happens on the same connection.
  1191  	db.SetMaxOpenConns(1)
  1192  
  1193  	prepares0 := numPrepares(t, db)
  1194  
  1195  	// db.Prepare increments numPrepares.
  1196  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1197  	if err != nil {
  1198  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1199  	}
  1200  	defer stmt.Close()
  1201  	tx, err := db.Begin()
  1202  	if err != nil {
  1203  		t.Fatalf("Begin = %v", err)
  1204  	}
  1205  	txs := tx.Stmt(stmt)
  1206  	if len(stmt.css) != 1 {
  1207  		t.Fatalf("len(stmt.css) = %v; want 1", len(stmt.css))
  1208  	}
  1209  	err = txs.Close()
  1210  	if err != nil {
  1211  		t.Fatalf("txs.Close() = %v", err)
  1212  	}
  1213  	err = tx.Rollback()
  1214  	if err != nil {
  1215  		t.Fatalf("tx.Rollback() = %v", err)
  1216  	}
  1217  	// txs must not be valid.
  1218  	_, err = txs.Exec("Suzan", 30)
  1219  	if err == nil {
  1220  		t.Fatalf("txs.Exec(), expected err")
  1221  	}
  1222  	// Stmt must still be valid.
  1223  	_, err = stmt.Exec("Janina", 25)
  1224  	if err != nil {
  1225  		t.Fatalf("stmt.Exec() = %v", err)
  1226  	}
  1227  
  1228  	if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
  1229  		t.Errorf("executed %d Prepare statements; want 1", prepares)
  1230  	}
  1231  }
  1232  
  1233  // Test that tx.Stmt called with a statement already
  1234  // associated with tx as argument re-prepares the same
  1235  // statement again.
  1236  func TestTxStmtFromTxStmtRePrepares(t *testing.T) {
  1237  	db := newTestDB(t, "")
  1238  	defer closeDB(t, db)
  1239  	exec(t, db, "CREATE|t1|name=string,age=int32")
  1240  	prepares0 := numPrepares(t, db)
  1241  	// db.Prepare increments numPrepares.
  1242  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1243  	if err != nil {
  1244  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1245  	}
  1246  	defer stmt.Close()
  1247  
  1248  	tx, err := db.Begin()
  1249  	if err != nil {
  1250  		t.Fatalf("Begin = %v", err)
  1251  	}
  1252  	txs1 := tx.Stmt(stmt)
  1253  
  1254  	// tx.Stmt(txs1) increments numPrepares because txs1 already
  1255  	// belongs to a transaction (albeit the same transaction).
  1256  	txs2 := tx.Stmt(txs1)
  1257  	if txs2.stickyErr != nil {
  1258  		t.Fatal(txs2.stickyErr)
  1259  	}
  1260  	if txs2.parentStmt != nil {
  1261  		t.Fatal("expected nil parentStmt")
  1262  	}
  1263  	_, err = txs2.Exec(`Eric`, 82)
  1264  	if err != nil {
  1265  		t.Fatal(err)
  1266  	}
  1267  
  1268  	err = txs1.Close()
  1269  	if err != nil {
  1270  		t.Fatalf("txs1.Close = %v", err)
  1271  	}
  1272  	err = txs2.Close()
  1273  	if err != nil {
  1274  		t.Fatalf("txs1.Close = %v", err)
  1275  	}
  1276  	err = tx.Rollback()
  1277  	if err != nil {
  1278  		t.Fatalf("tx.Rollback = %v", err)
  1279  	}
  1280  
  1281  	if prepares := numPrepares(t, db) - prepares0; prepares != 2 {
  1282  		t.Errorf("executed %d Prepare statements; want 2", prepares)
  1283  	}
  1284  }
  1285  
  1286  // Issue: https://golang.org/issue/2784
  1287  // This test didn't fail before because we got lucky with the fakedb driver.
  1288  // It was failing, and now not, in github.com/bradfitz/go-sql-test
  1289  func TestTxQuery(t *testing.T) {
  1290  	db := newTestDB(t, "")
  1291  	defer closeDB(t, db)
  1292  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  1293  	exec(t, db, "INSERT|t1|name=Alice")
  1294  
  1295  	tx, err := db.Begin()
  1296  	if err != nil {
  1297  		t.Fatal(err)
  1298  	}
  1299  	defer tx.Rollback()
  1300  
  1301  	r, err := tx.Query("SELECT|t1|name|")
  1302  	if err != nil {
  1303  		t.Fatal(err)
  1304  	}
  1305  	defer r.Close()
  1306  
  1307  	if !r.Next() {
  1308  		if r.Err() != nil {
  1309  			t.Fatal(r.Err())
  1310  		}
  1311  		t.Fatal("expected one row")
  1312  	}
  1313  
  1314  	var x string
  1315  	err = r.Scan(&x)
  1316  	if err != nil {
  1317  		t.Fatal(err)
  1318  	}
  1319  }
  1320  
  1321  func TestTxQueryInvalid(t *testing.T) {
  1322  	db := newTestDB(t, "")
  1323  	defer closeDB(t, db)
  1324  
  1325  	tx, err := db.Begin()
  1326  	if err != nil {
  1327  		t.Fatal(err)
  1328  	}
  1329  	defer tx.Rollback()
  1330  
  1331  	_, err = tx.Query("SELECT|t1|name|")
  1332  	if err == nil {
  1333  		t.Fatal("Error expected")
  1334  	}
  1335  }
  1336  
  1337  // Tests fix for issue 4433, that retries in Begin happen when
  1338  // conn.Begin() returns ErrBadConn
  1339  func TestTxErrBadConn(t *testing.T) {
  1340  	db, err := Open("test", fakeDBName+";badConn")
  1341  	if err != nil {
  1342  		t.Fatalf("Open: %v", err)
  1343  	}
  1344  	if _, err := db.Exec("WIPE"); err != nil {
  1345  		t.Fatalf("exec wipe: %v", err)
  1346  	}
  1347  	defer closeDB(t, db)
  1348  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  1349  	stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
  1350  	if err != nil {
  1351  		t.Fatalf("Stmt, err = %v, %v", stmt, err)
  1352  	}
  1353  	defer stmt.Close()
  1354  	tx, err := db.Begin()
  1355  	if err != nil {
  1356  		t.Fatalf("Begin = %v", err)
  1357  	}
  1358  	txs := tx.Stmt(stmt)
  1359  	defer txs.Close()
  1360  	_, err = txs.Exec("Bobby", 7)
  1361  	if err != nil {
  1362  		t.Fatalf("Exec = %v", err)
  1363  	}
  1364  	err = tx.Commit()
  1365  	if err != nil {
  1366  		t.Fatalf("Commit = %v", err)
  1367  	}
  1368  }
  1369  
  1370  func TestConnQuery(t *testing.T) {
  1371  	db := newTestDB(t, "people")
  1372  	defer closeDB(t, db)
  1373  
  1374  	ctx, cancel := context.WithCancel(context.Background())
  1375  	defer cancel()
  1376  	conn, err := db.Conn(ctx)
  1377  	if err != nil {
  1378  		t.Fatal(err)
  1379  	}
  1380  	conn.dc.ci.(*fakeConn).skipDirtySession = true
  1381  	defer conn.Close()
  1382  
  1383  	var name string
  1384  	err = conn.QueryRowContext(ctx, "SELECT|people|name|age=?", 3).Scan(&name)
  1385  	if err != nil {
  1386  		t.Fatal(err)
  1387  	}
  1388  	if name != "Chris" {
  1389  		t.Fatalf("unexpected result, got %q want Chris", name)
  1390  	}
  1391  
  1392  	err = conn.PingContext(ctx)
  1393  	if err != nil {
  1394  		t.Fatal(err)
  1395  	}
  1396  }
  1397  
  1398  func TestConnRaw(t *testing.T) {
  1399  	db := newTestDB(t, "people")
  1400  	defer closeDB(t, db)
  1401  
  1402  	ctx, cancel := context.WithCancel(context.Background())
  1403  	defer cancel()
  1404  	conn, err := db.Conn(ctx)
  1405  	if err != nil {
  1406  		t.Fatal(err)
  1407  	}
  1408  	conn.dc.ci.(*fakeConn).skipDirtySession = true
  1409  	defer conn.Close()
  1410  
  1411  	sawFunc := false
  1412  	err = conn.Raw(func(dc interface{}) error {
  1413  		sawFunc = true
  1414  		if _, ok := dc.(*fakeConn); !ok {
  1415  			return fmt.Errorf("got %T want *fakeConn", dc)
  1416  		}
  1417  		return nil
  1418  	})
  1419  	if err != nil {
  1420  		t.Fatal(err)
  1421  	}
  1422  	if !sawFunc {
  1423  		t.Fatal("Raw func not called")
  1424  	}
  1425  
  1426  	func() {
  1427  		defer func() {
  1428  			x := recover()
  1429  			if x == nil {
  1430  				t.Fatal("expected panic")
  1431  			}
  1432  			conn.closemu.Lock()
  1433  			closed := conn.dc == nil
  1434  			conn.closemu.Unlock()
  1435  			if !closed {
  1436  				t.Fatal("expected connection to be closed after panic")
  1437  			}
  1438  		}()
  1439  		err = conn.Raw(func(dc interface{}) error {
  1440  			panic("Conn.Raw panic should return an error")
  1441  		})
  1442  		t.Fatal("expected panic from Raw func")
  1443  	}()
  1444  }
  1445  
  1446  func TestCursorFake(t *testing.T) {
  1447  	db := newTestDB(t, "people")
  1448  	defer closeDB(t, db)
  1449  
  1450  	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
  1451  	defer cancel()
  1452  
  1453  	exec(t, db, "CREATE|peoplecursor|list=table")
  1454  	exec(t, db, "INSERT|peoplecursor|list=people!name!age")
  1455  
  1456  	rows, err := db.QueryContext(ctx, `SELECT|peoplecursor|list|`)
  1457  	if err != nil {
  1458  		t.Fatal(err)
  1459  	}
  1460  	defer rows.Close()
  1461  
  1462  	if !rows.Next() {
  1463  		t.Fatal("no rows")
  1464  	}
  1465  	var cursor = &Rows{}
  1466  	err = rows.Scan(cursor)
  1467  	if err != nil {
  1468  		t.Fatal(err)
  1469  	}
  1470  	defer cursor.Close()
  1471  
  1472  	const expectedRows = 3
  1473  	var currentRow int64
  1474  
  1475  	var n int64
  1476  	var s string
  1477  	for cursor.Next() {
  1478  		currentRow++
  1479  		err = cursor.Scan(&s, &n)
  1480  		if err != nil {
  1481  			t.Fatal(err)
  1482  		}
  1483  		if n != currentRow {
  1484  			t.Errorf("expected number(Age)=%d, got %d", currentRow, n)
  1485  		}
  1486  	}
  1487  	if currentRow != expectedRows {
  1488  		t.Errorf("expected %d rows, got %d rows", expectedRows, currentRow)
  1489  	}
  1490  }
  1491  
  1492  func TestInvalidNilValues(t *testing.T) {
  1493  	var date1 time.Time
  1494  	var date2 int
  1495  
  1496  	tests := []struct {
  1497  		name          string
  1498  		input         interface{}
  1499  		expectedError string
  1500  	}{
  1501  		{
  1502  			name:          "time.Time",
  1503  			input:         &date1,
  1504  			expectedError: `sql: Scan error on column index 0, name "bdate": unsupported Scan, storing driver.Value type <nil> into type *time.Time`,
  1505  		},
  1506  		{
  1507  			name:          "int",
  1508  			input:         &date2,
  1509  			expectedError: `sql: Scan error on column index 0, name "bdate": converting NULL to int is unsupported`,
  1510  		},
  1511  	}
  1512  
  1513  	for _, tt := range tests {
  1514  		t.Run(tt.name, func(t *testing.T) {
  1515  			db := newTestDB(t, "people")
  1516  			defer closeDB(t, db)
  1517  
  1518  			ctx, cancel := context.WithCancel(context.Background())
  1519  			defer cancel()
  1520  			conn, err := db.Conn(ctx)
  1521  			if err != nil {
  1522  				t.Fatal(err)
  1523  			}
  1524  			conn.dc.ci.(*fakeConn).skipDirtySession = true
  1525  			defer conn.Close()
  1526  
  1527  			err = conn.QueryRowContext(ctx, "SELECT|people|bdate|age=?", 1).Scan(tt.input)
  1528  			if err == nil {
  1529  				t.Fatal("expected error when querying nil column, but succeeded")
  1530  			}
  1531  			if err.Error() != tt.expectedError {
  1532  				t.Fatalf("Expected error: %s\nReceived: %s", tt.expectedError, err.Error())
  1533  			}
  1534  
  1535  			err = conn.PingContext(ctx)
  1536  			if err != nil {
  1537  				t.Fatal(err)
  1538  			}
  1539  		})
  1540  	}
  1541  }
  1542  
  1543  func TestConnTx(t *testing.T) {
  1544  	db := newTestDB(t, "people")
  1545  	defer closeDB(t, db)
  1546  
  1547  	ctx, cancel := context.WithCancel(context.Background())
  1548  	defer cancel()
  1549  	conn, err := db.Conn(ctx)
  1550  	if err != nil {
  1551  		t.Fatal(err)
  1552  	}
  1553  	conn.dc.ci.(*fakeConn).skipDirtySession = true
  1554  	defer conn.Close()
  1555  
  1556  	tx, err := conn.BeginTx(ctx, nil)
  1557  	if err != nil {
  1558  		t.Fatal(err)
  1559  	}
  1560  	insertName, insertAge := "Nancy", 33
  1561  	_, err = tx.ExecContext(ctx, "INSERT|people|name=?,age=?,photo=APHOTO", insertName, insertAge)
  1562  	if err != nil {
  1563  		t.Fatal(err)
  1564  	}
  1565  	err = tx.Commit()
  1566  	if err != nil {
  1567  		t.Fatal(err)
  1568  	}
  1569  
  1570  	var selectName string
  1571  	err = conn.QueryRowContext(ctx, "SELECT|people|name|age=?", insertAge).Scan(&selectName)
  1572  	if err != nil {
  1573  		t.Fatal(err)
  1574  	}
  1575  	if selectName != insertName {
  1576  		t.Fatalf("got %q want %q", selectName, insertName)
  1577  	}
  1578  }
  1579  
  1580  // TestConnIsValid verifies that a database connection that should be discarded,
  1581  // is actually discarded and does not re-enter the connection pool.
  1582  // If the IsValid method from *fakeConn is removed, this test will fail.
  1583  func TestConnIsValid(t *testing.T) {
  1584  	db := newTestDB(t, "people")
  1585  	defer closeDB(t, db)
  1586  
  1587  	db.SetMaxOpenConns(1)
  1588  
  1589  	ctx := context.Background()
  1590  
  1591  	c, err := db.Conn(ctx)
  1592  	if err != nil {
  1593  		t.Fatal(err)
  1594  	}
  1595  
  1596  	err = c.Raw(func(raw interface{}) error {
  1597  		dc := raw.(*fakeConn)
  1598  		dc.stickyBad = true
  1599  		return nil
  1600  	})
  1601  	if err != nil {
  1602  		t.Fatal(err)
  1603  	}
  1604  	c.Close()
  1605  
  1606  	if len(db.freeConn) > 0 && db.freeConn[0].ci.(*fakeConn).stickyBad {
  1607  		t.Fatal("bad connection returned to pool; expected bad connection to be discarded")
  1608  	}
  1609  }
  1610  
  1611  // Tests fix for issue 2542, that we release a lock when querying on
  1612  // a closed connection.
  1613  func TestIssue2542Deadlock(t *testing.T) {
  1614  	db := newTestDB(t, "people")
  1615  	closeDB(t, db)
  1616  	for i := 0; i < 2; i++ {
  1617  		_, err := db.Query("SELECT|people|age,name|")
  1618  		if err == nil {
  1619  			t.Fatalf("expected error")
  1620  		}
  1621  	}
  1622  }
  1623  
  1624  // From golang.org/issue/3865
  1625  func TestCloseStmtBeforeRows(t *testing.T) {
  1626  	db := newTestDB(t, "people")
  1627  	defer closeDB(t, db)
  1628  
  1629  	s, err := db.Prepare("SELECT|people|name|")
  1630  	if err != nil {
  1631  		t.Fatal(err)
  1632  	}
  1633  
  1634  	r, err := s.Query()
  1635  	if err != nil {
  1636  		s.Close()
  1637  		t.Fatal(err)
  1638  	}
  1639  
  1640  	err = s.Close()
  1641  	if err != nil {
  1642  		t.Fatal(err)
  1643  	}
  1644  
  1645  	r.Close()
  1646  }
  1647  
  1648  // Tests fix for issue 2788, that we bind nil to a []byte if the
  1649  // value in the column is sql null
  1650  func TestNullByteSlice(t *testing.T) {
  1651  	db := newTestDB(t, "")
  1652  	defer closeDB(t, db)
  1653  	exec(t, db, "CREATE|t|id=int32,name=nullstring")
  1654  	exec(t, db, "INSERT|t|id=10,name=?", nil)
  1655  
  1656  	var name []byte
  1657  
  1658  	err := db.QueryRow("SELECT|t|name|id=?", 10).Scan(&name)
  1659  	if err != nil {
  1660  		t.Fatal(err)
  1661  	}
  1662  	if name != nil {
  1663  		t.Fatalf("name []byte should be nil for null column value, got: %#v", name)
  1664  	}
  1665  
  1666  	exec(t, db, "INSERT|t|id=11,name=?", "bob")
  1667  	err = db.QueryRow("SELECT|t|name|id=?", 11).Scan(&name)
  1668  	if err != nil {
  1669  		t.Fatal(err)
  1670  	}
  1671  	if string(name) != "bob" {
  1672  		t.Fatalf("name []byte should be bob, got: %q", string(name))
  1673  	}
  1674  }
  1675  
  1676  func TestPointerParamsAndScans(t *testing.T) {
  1677  	db := newTestDB(t, "")
  1678  	defer closeDB(t, db)
  1679  	exec(t, db, "CREATE|t|id=int32,name=nullstring")
  1680  
  1681  	bob := "bob"
  1682  	var name *string
  1683  
  1684  	name = &bob
  1685  	exec(t, db, "INSERT|t|id=10,name=?", name)
  1686  	name = nil
  1687  	exec(t, db, "INSERT|t|id=20,name=?", name)
  1688  
  1689  	err := db.QueryRow("SELECT|t|name|id=?", 10).Scan(&name)
  1690  	if err != nil {
  1691  		t.Fatalf("querying id 10: %v", err)
  1692  	}
  1693  	if name == nil {
  1694  		t.Errorf("id 10's name = nil; want bob")
  1695  	} else if *name != "bob" {
  1696  		t.Errorf("id 10's name = %q; want bob", *name)
  1697  	}
  1698  
  1699  	err = db.QueryRow("SELECT|t|name|id=?", 20).Scan(&name)
  1700  	if err != nil {
  1701  		t.Fatalf("querying id 20: %v", err)
  1702  	}
  1703  	if name != nil {
  1704  		t.Errorf("id 20 = %q; want nil", *name)
  1705  	}
  1706  }
  1707  
  1708  func TestQueryRowClosingStmt(t *testing.T) {
  1709  	db := newTestDB(t, "people")
  1710  	defer closeDB(t, db)
  1711  	var name string
  1712  	var age int
  1713  	err := db.QueryRow("SELECT|people|age,name|age=?", 3).Scan(&age, &name)
  1714  	if err != nil {
  1715  		t.Fatal(err)
  1716  	}
  1717  	if len(db.freeConn) != 1 {
  1718  		t.Fatalf("expected 1 free conn")
  1719  	}
  1720  	fakeConn := db.freeConn[0].ci.(*fakeConn)
  1721  	if made, closed := fakeConn.stmtsMade, fakeConn.stmtsClosed; made != closed {
  1722  		t.Errorf("statement close mismatch: made %d, closed %d", made, closed)
  1723  	}
  1724  }
  1725  
  1726  var atomicRowsCloseHook atomic.Value // of func(*Rows, *error)
  1727  
  1728  func init() {
  1729  	rowsCloseHook = func() func(*Rows, *error) {
  1730  		fn, _ := atomicRowsCloseHook.Load().(func(*Rows, *error))
  1731  		return fn
  1732  	}
  1733  }
  1734  
  1735  func setRowsCloseHook(fn func(*Rows, *error)) {
  1736  	if fn == nil {
  1737  		// Can't change an atomic.Value back to nil, so set it to this
  1738  		// no-op func instead.
  1739  		fn = func(*Rows, *error) {}
  1740  	}
  1741  	atomicRowsCloseHook.Store(fn)
  1742  }
  1743  
  1744  // Test issue 6651
  1745  func TestIssue6651(t *testing.T) {
  1746  	db := newTestDB(t, "people")
  1747  	defer closeDB(t, db)
  1748  
  1749  	var v string
  1750  
  1751  	want := "error in rows.Next"
  1752  	rowsCursorNextHook = func(dest []driver.Value) error {
  1753  		return fmt.Errorf(want)
  1754  	}
  1755  	defer func() { rowsCursorNextHook = nil }()
  1756  
  1757  	err := db.QueryRow("SELECT|people|name|").Scan(&v)
  1758  	if err == nil || err.Error() != want {
  1759  		t.Errorf("error = %q; want %q", err, want)
  1760  	}
  1761  	rowsCursorNextHook = nil
  1762  
  1763  	want = "error in rows.Close"
  1764  	setRowsCloseHook(func(rows *Rows, err *error) {
  1765  		*err = fmt.Errorf(want)
  1766  	})
  1767  	defer setRowsCloseHook(nil)
  1768  	err = db.QueryRow("SELECT|people|name|").Scan(&v)
  1769  	if err == nil || err.Error() != want {
  1770  		t.Errorf("error = %q; want %q", err, want)
  1771  	}
  1772  }
  1773  
  1774  type nullTestRow struct {
  1775  	nullParam    interface{}
  1776  	notNullParam interface{}
  1777  	scanNullVal  interface{}
  1778  }
  1779  
  1780  type nullTestSpec struct {
  1781  	nullType    string
  1782  	notNullType string
  1783  	rows        [6]nullTestRow
  1784  }
  1785  
  1786  func TestNullStringParam(t *testing.T) {
  1787  	spec := nullTestSpec{"nullstring", "string", [6]nullTestRow{
  1788  		{NullString{"aqua", true}, "", NullString{"aqua", true}},
  1789  		{NullString{"brown", false}, "", NullString{"", false}},
  1790  		{"chartreuse", "", NullString{"chartreuse", true}},
  1791  		{NullString{"darkred", true}, "", NullString{"darkred", true}},
  1792  		{NullString{"eel", false}, "", NullString{"", false}},
  1793  		{"foo", NullString{"black", false}, nil},
  1794  	}}
  1795  	nullTestRun(t, spec)
  1796  }
  1797  
  1798  func TestNullInt64Param(t *testing.T) {
  1799  	spec := nullTestSpec{"nullint64", "int64", [6]nullTestRow{
  1800  		{NullInt64{31, true}, 1, NullInt64{31, true}},
  1801  		{NullInt64{-22, false}, 1, NullInt64{0, false}},
  1802  		{22, 1, NullInt64{22, true}},
  1803  		{NullInt64{33, true}, 1, NullInt64{33, true}},
  1804  		{NullInt64{222, false}, 1, NullInt64{0, false}},
  1805  		{0, NullInt64{31, false}, nil},
  1806  	}}
  1807  	nullTestRun(t, spec)
  1808  }
  1809  
  1810  func TestNullInt32Param(t *testing.T) {
  1811  	spec := nullTestSpec{"nullint32", "int32", [6]nullTestRow{
  1812  		{NullInt32{31, true}, 1, NullInt32{31, true}},
  1813  		{NullInt32{-22, false}, 1, NullInt32{0, false}},
  1814  		{22, 1, NullInt32{22, true}},
  1815  		{NullInt32{33, true}, 1, NullInt32{33, true}},
  1816  		{NullInt32{222, false}, 1, NullInt32{0, false}},
  1817  		{0, NullInt32{31, false}, nil},
  1818  	}}
  1819  	nullTestRun(t, spec)
  1820  }
  1821  
  1822  func TestNullInt16Param(t *testing.T) {
  1823  	spec := nullTestSpec{"nullint16", "int16", [6]nullTestRow{
  1824  		{NullInt16{31, true}, 1, NullInt16{31, true}},
  1825  		{NullInt16{-22, false}, 1, NullInt16{0, false}},
  1826  		{22, 1, NullInt16{22, true}},
  1827  		{NullInt16{33, true}, 1, NullInt16{33, true}},
  1828  		{NullInt16{222, false}, 1, NullInt16{0, false}},
  1829  		{0, NullInt16{31, false}, nil},
  1830  	}}
  1831  	nullTestRun(t, spec)
  1832  }
  1833  
  1834  func TestNullByteParam(t *testing.T) {
  1835  	spec := nullTestSpec{"nullbyte", "byte", [6]nullTestRow{
  1836  		{NullByte{31, true}, 1, NullByte{31, true}},
  1837  		{NullByte{0, false}, 1, NullByte{0, false}},
  1838  		{22, 1, NullByte{22, true}},
  1839  		{NullByte{33, true}, 1, NullByte{33, true}},
  1840  		{NullByte{222, false}, 1, NullByte{0, false}},
  1841  		{0, NullByte{31, false}, nil},
  1842  	}}
  1843  	nullTestRun(t, spec)
  1844  }
  1845  
  1846  func TestNullFloat64Param(t *testing.T) {
  1847  	spec := nullTestSpec{"nullfloat64", "float64", [6]nullTestRow{
  1848  		{NullFloat64{31.2, true}, 1, NullFloat64{31.2, true}},
  1849  		{NullFloat64{13.1, false}, 1, NullFloat64{0, false}},
  1850  		{-22.9, 1, NullFloat64{-22.9, true}},
  1851  		{NullFloat64{33.81, true}, 1, NullFloat64{33.81, true}},
  1852  		{NullFloat64{222, false}, 1, NullFloat64{0, false}},
  1853  		{10, NullFloat64{31.2, false}, nil},
  1854  	}}
  1855  	nullTestRun(t, spec)
  1856  }
  1857  
  1858  func TestNullBoolParam(t *testing.T) {
  1859  	spec := nullTestSpec{"nullbool", "bool", [6]nullTestRow{
  1860  		{NullBool{false, true}, true, NullBool{false, true}},
  1861  		{NullBool{true, false}, false, NullBool{false, false}},
  1862  		{true, true, NullBool{true, true}},
  1863  		{NullBool{true, true}, false, NullBool{true, true}},
  1864  		{NullBool{true, false}, true, NullBool{false, false}},
  1865  		{true, NullBool{true, false}, nil},
  1866  	}}
  1867  	nullTestRun(t, spec)
  1868  }
  1869  
  1870  func TestNullTimeParam(t *testing.T) {
  1871  	t0 := time.Time{}
  1872  	t1 := time.Date(2000, 1, 1, 8, 9, 10, 11, time.UTC)
  1873  	t2 := time.Date(2010, 1, 1, 8, 9, 10, 11, time.UTC)
  1874  	spec := nullTestSpec{"nulldatetime", "datetime", [6]nullTestRow{
  1875  		{NullTime{t1, true}, t2, NullTime{t1, true}},
  1876  		{NullTime{t1, false}, t2, NullTime{t0, false}},
  1877  		{t1, t2, NullTime{t1, true}},
  1878  		{NullTime{t1, true}, t2, NullTime{t1, true}},
  1879  		{NullTime{t1, false}, t2, NullTime{t0, false}},
  1880  		{t2, NullTime{t1, false}, nil},
  1881  	}}
  1882  	nullTestRun(t, spec)
  1883  }
  1884  
  1885  func nullTestRun(t *testing.T, spec nullTestSpec) {
  1886  	db := newTestDB(t, "")
  1887  	defer closeDB(t, db)
  1888  	exec(t, db, fmt.Sprintf("CREATE|t|id=int32,name=string,nullf=%s,notnullf=%s", spec.nullType, spec.notNullType))
  1889  
  1890  	// Inserts with db.Exec:
  1891  	exec(t, db, "INSERT|t|id=?,name=?,nullf=?,notnullf=?", 1, "alice", spec.rows[0].nullParam, spec.rows[0].notNullParam)
  1892  	exec(t, db, "INSERT|t|id=?,name=?,nullf=?,notnullf=?", 2, "bob", spec.rows[1].nullParam, spec.rows[1].notNullParam)
  1893  
  1894  	// Inserts with a prepared statement:
  1895  	stmt, err := db.Prepare("INSERT|t|id=?,name=?,nullf=?,notnullf=?")
  1896  	if err != nil {
  1897  		t.Fatalf("prepare: %v", err)
  1898  	}
  1899  	defer stmt.Close()
  1900  	if _, err := stmt.Exec(3, "chris", spec.rows[2].nullParam, spec.rows[2].notNullParam); err != nil {
  1901  		t.Errorf("exec insert chris: %v", err)
  1902  	}
  1903  	if _, err := stmt.Exec(4, "dave", spec.rows[3].nullParam, spec.rows[3].notNullParam); err != nil {
  1904  		t.Errorf("exec insert dave: %v", err)
  1905  	}
  1906  	if _, err := stmt.Exec(5, "eleanor", spec.rows[4].nullParam, spec.rows[4].notNullParam); err != nil {
  1907  		t.Errorf("exec insert eleanor: %v", err)
  1908  	}
  1909  
  1910  	// Can't put null val into non-null col
  1911  	if _, err := stmt.Exec(6, "bob", spec.rows[5].nullParam, spec.rows[5].notNullParam); err == nil {
  1912  		t.Errorf("expected error inserting nil val with prepared statement Exec")
  1913  	}
  1914  
  1915  	_, err = db.Exec("INSERT|t|id=?,name=?,nullf=?", 999, nil, nil)
  1916  	if err == nil {
  1917  		// TODO: this test fails, but it's just because
  1918  		// fakeConn implements the optional Execer interface,
  1919  		// so arguably this is the correct behavior. But
  1920  		// maybe I should flesh out the fakeConn.Exec
  1921  		// implementation so this properly fails.
  1922  		// t.Errorf("expected error inserting nil name with Exec")
  1923  	}
  1924  
  1925  	paramtype := reflect.TypeOf(spec.rows[0].nullParam)
  1926  	bindVal := reflect.New(paramtype).Interface()
  1927  
  1928  	for i := 0; i < 5; i++ {
  1929  		id := i + 1
  1930  		if err := db.QueryRow("SELECT|t|nullf|id=?", id).Scan(bindVal); err != nil {
  1931  			t.Errorf("id=%d Scan: %v", id, err)
  1932  		}
  1933  		bindValDeref := reflect.ValueOf(bindVal).Elem().Interface()
  1934  		if !reflect.DeepEqual(bindValDeref, spec.rows[i].scanNullVal) {
  1935  			t.Errorf("id=%d got %#v, want %#v", id, bindValDeref, spec.rows[i].scanNullVal)
  1936  		}
  1937  	}
  1938  }
  1939  
  1940  // golang.org/issue/4859
  1941  func TestQueryRowNilScanDest(t *testing.T) {
  1942  	db := newTestDB(t, "people")
  1943  	defer closeDB(t, db)
  1944  	var name *string // nil pointer
  1945  	err := db.QueryRow("SELECT|people|name|").Scan(name)
  1946  	want := `sql: Scan error on column index 0, name "name": destination pointer is nil`
  1947  	if err == nil || err.Error() != want {
  1948  		t.Errorf("error = %q; want %q", err.Error(), want)
  1949  	}
  1950  }
  1951  
  1952  func TestIssue4902(t *testing.T) {
  1953  	db := newTestDB(t, "people")
  1954  	defer closeDB(t, db)
  1955  
  1956  	driver := db.Driver().(*fakeDriver)
  1957  	opens0 := driver.openCount
  1958  
  1959  	var stmt *Stmt
  1960  	var err error
  1961  	for i := 0; i < 10; i++ {
  1962  		stmt, err = db.Prepare("SELECT|people|name|")
  1963  		if err != nil {
  1964  			t.Fatal(err)
  1965  		}
  1966  		err = stmt.Close()
  1967  		if err != nil {
  1968  			t.Fatal(err)
  1969  		}
  1970  	}
  1971  
  1972  	opens := driver.openCount - opens0
  1973  	if opens > 1 {
  1974  		t.Errorf("opens = %d; want <= 1", opens)
  1975  		t.Logf("db = %#v", db)
  1976  		t.Logf("driver = %#v", driver)
  1977  		t.Logf("stmt = %#v", stmt)
  1978  	}
  1979  }
  1980  
  1981  // Issue 3857
  1982  // This used to deadlock.
  1983  func TestSimultaneousQueries(t *testing.T) {
  1984  	db := newTestDB(t, "people")
  1985  	defer closeDB(t, db)
  1986  
  1987  	tx, err := db.Begin()
  1988  	if err != nil {
  1989  		t.Fatal(err)
  1990  	}
  1991  	defer tx.Rollback()
  1992  
  1993  	r1, err := tx.Query("SELECT|people|name|")
  1994  	if err != nil {
  1995  		t.Fatal(err)
  1996  	}
  1997  	defer r1.Close()
  1998  
  1999  	r2, err := tx.Query("SELECT|people|name|")
  2000  	if err != nil {
  2001  		t.Fatal(err)
  2002  	}
  2003  	defer r2.Close()
  2004  }
  2005  
  2006  func TestMaxIdleConns(t *testing.T) {
  2007  	db := newTestDB(t, "people")
  2008  	defer closeDB(t, db)
  2009  
  2010  	tx, err := db.Begin()
  2011  	if err != nil {
  2012  		t.Fatal(err)
  2013  	}
  2014  	tx.Commit()
  2015  	if got := len(db.freeConn); got != 1 {
  2016  		t.Errorf("freeConns = %d; want 1", got)
  2017  	}
  2018  
  2019  	db.SetMaxIdleConns(0)
  2020  
  2021  	if got := len(db.freeConn); got != 0 {
  2022  		t.Errorf("freeConns after set to zero = %d; want 0", got)
  2023  	}
  2024  
  2025  	tx, err = db.Begin()
  2026  	if err != nil {
  2027  		t.Fatal(err)
  2028  	}
  2029  	tx.Commit()
  2030  	if got := len(db.freeConn); got != 0 {
  2031  		t.Errorf("freeConns = %d; want 0", got)
  2032  	}
  2033  }
  2034  
  2035  func TestMaxOpenConns(t *testing.T) {
  2036  	if testing.Short() {
  2037  		t.Skip("skipping in short mode")
  2038  	}
  2039  	defer setHookpostCloseConn(nil)
  2040  	setHookpostCloseConn(func(_ *fakeConn, err error) {
  2041  		if err != nil {
  2042  			t.Errorf("Error closing fakeConn: %v", err)
  2043  		}
  2044  	})
  2045  
  2046  	db := newTestDB(t, "magicquery")
  2047  	defer closeDB(t, db)
  2048  
  2049  	driver := db.Driver().(*fakeDriver)
  2050  
  2051  	// Force the number of open connections to 0 so we can get an accurate
  2052  	// count for the test
  2053  	db.clearAllConns(t)
  2054  
  2055  	driver.mu.Lock()
  2056  	opens0 := driver.openCount
  2057  	closes0 := driver.closeCount
  2058  	driver.mu.Unlock()
  2059  
  2060  	db.SetMaxIdleConns(10)
  2061  	db.SetMaxOpenConns(10)
  2062  
  2063  	stmt, err := db.Prepare("SELECT|magicquery|op|op=?,millis=?")
  2064  	if err != nil {
  2065  		t.Fatal(err)
  2066  	}
  2067  
  2068  	// Start 50 parallel slow queries.
  2069  	const (
  2070  		nquery      = 50
  2071  		sleepMillis = 25
  2072  		nbatch      = 2
  2073  	)
  2074  	var wg sync.WaitGroup
  2075  	for batch := 0; batch < nbatch; batch++ {
  2076  		for i := 0; i < nquery; i++ {
  2077  			wg.Add(1)
  2078  			go func() {
  2079  				defer wg.Done()
  2080  				var op string
  2081  				if err := stmt.QueryRow("sleep", sleepMillis).Scan(&op); err != nil && err != ErrNoRows {
  2082  					t.Error(err)
  2083  				}
  2084  			}()
  2085  		}
  2086  		// Sleep for twice the expected length of time for the
  2087  		// batch of 50 queries above to finish before starting
  2088  		// the next round.
  2089  		time.Sleep(2 * sleepMillis * time.Millisecond)
  2090  	}
  2091  	wg.Wait()
  2092  
  2093  	if g, w := db.numFreeConns(), 10; g != w {
  2094  		t.Errorf("free conns = %d; want %d", g, w)
  2095  	}
  2096  
  2097  	if n := db.numDepsPollUntil(20, time.Second); n > 20 {
  2098  		t.Errorf("number of dependencies = %d; expected <= 20", n)
  2099  		db.dumpDeps(t)
  2100  	}
  2101  
  2102  	driver.mu.Lock()
  2103  	opens := driver.openCount - opens0
  2104  	closes := driver.closeCount - closes0
  2105  	driver.mu.Unlock()
  2106  
  2107  	if opens > 10 {
  2108  		t.Logf("open calls = %d", opens)
  2109  		t.Logf("close calls = %d", closes)
  2110  		t.Errorf("db connections opened = %d; want <= 10", opens)
  2111  		db.dumpDeps(t)
  2112  	}
  2113  
  2114  	if err := stmt.Close(); err != nil {
  2115  		t.Fatal(err)
  2116  	}
  2117  
  2118  	if g, w := db.numFreeConns(), 10; g != w {
  2119  		t.Errorf("free conns = %d; want %d", g, w)
  2120  	}
  2121  
  2122  	if n := db.numDepsPollUntil(10, time.Second); n > 10 {
  2123  		t.Errorf("number of dependencies = %d; expected <= 10", n)
  2124  		db.dumpDeps(t)
  2125  	}
  2126  
  2127  	db.SetMaxOpenConns(5)
  2128  
  2129  	if g, w := db.numFreeConns(), 5; g != w {
  2130  		t.Errorf("free conns = %d; want %d", g, w)
  2131  	}
  2132  
  2133  	if n := db.numDepsPollUntil(5, time.Second); n > 5 {
  2134  		t.Errorf("number of dependencies = %d; expected 0", n)
  2135  		db.dumpDeps(t)
  2136  	}
  2137  
  2138  	db.SetMaxOpenConns(0)
  2139  
  2140  	if g, w := db.numFreeConns(), 5; g != w {
  2141  		t.Errorf("free conns = %d; want %d", g, w)
  2142  	}
  2143  
  2144  	if n := db.numDepsPollUntil(5, time.Second); n > 5 {
  2145  		t.Errorf("number of dependencies = %d; expected 0", n)
  2146  		db.dumpDeps(t)
  2147  	}
  2148  
  2149  	db.clearAllConns(t)
  2150  }
  2151  
  2152  // Issue 9453: tests that SetMaxOpenConns can be lowered at runtime
  2153  // and affects the subsequent release of connections.
  2154  func TestMaxOpenConnsOnBusy(t *testing.T) {
  2155  	defer setHookpostCloseConn(nil)
  2156  	setHookpostCloseConn(func(_ *fakeConn, err error) {
  2157  		if err != nil {
  2158  			t.Errorf("Error closing fakeConn: %v", err)
  2159  		}
  2160  	})
  2161  
  2162  	db := newTestDB(t, "magicquery")
  2163  	defer closeDB(t, db)
  2164  
  2165  	db.SetMaxOpenConns(3)
  2166  
  2167  	ctx := context.Background()
  2168  
  2169  	conn0, err := db.conn(ctx, cachedOrNewConn)
  2170  	if err != nil {
  2171  		t.Fatalf("db open conn fail: %v", err)
  2172  	}
  2173  
  2174  	conn1, err := db.conn(ctx, cachedOrNewConn)
  2175  	if err != nil {
  2176  		t.Fatalf("db open conn fail: %v", err)
  2177  	}
  2178  
  2179  	conn2, err := db.conn(ctx, cachedOrNewConn)
  2180  	if err != nil {
  2181  		t.Fatalf("db open conn fail: %v", err)
  2182  	}
  2183  
  2184  	if g, w := db.numOpen, 3; g != w {
  2185  		t.Errorf("free conns = %d; want %d", g, w)
  2186  	}
  2187  
  2188  	db.SetMaxOpenConns(2)
  2189  	if g, w := db.numOpen, 3; g != w {
  2190  		t.Errorf("free conns = %d; want %d", g, w)
  2191  	}
  2192  
  2193  	conn0.releaseConn(nil)
  2194  	conn1.releaseConn(nil)
  2195  	if g, w := db.numOpen, 2; g != w {
  2196  		t.Errorf("free conns = %d; want %d", g, w)
  2197  	}
  2198  
  2199  	conn2.releaseConn(nil)
  2200  	if g, w := db.numOpen, 2; g != w {
  2201  		t.Errorf("free conns = %d; want %d", g, w)
  2202  	}
  2203  }
  2204  
  2205  // Issue 10886: tests that all connection attempts return when more than
  2206  // DB.maxOpen connections are in flight and the first DB.maxOpen fail.
  2207  func TestPendingConnsAfterErr(t *testing.T) {
  2208  	const (
  2209  		maxOpen = 2
  2210  		tryOpen = maxOpen*2 + 2
  2211  	)
  2212  
  2213  	// No queries will be run.
  2214  	db, err := Open("test", fakeDBName)
  2215  	if err != nil {
  2216  		t.Fatalf("Open: %v", err)
  2217  	}
  2218  	defer closeDB(t, db)
  2219  	defer func() {
  2220  		for k, v := range db.lastPut {
  2221  			t.Logf("%p: %v", k, v)
  2222  		}
  2223  	}()
  2224  
  2225  	db.SetMaxOpenConns(maxOpen)
  2226  	db.SetMaxIdleConns(0)
  2227  
  2228  	errOffline := errors.New("db offline")
  2229  
  2230  	defer func() { setHookOpenErr(nil) }()
  2231  
  2232  	errs := make(chan error, tryOpen)
  2233  
  2234  	var opening sync.WaitGroup
  2235  	opening.Add(tryOpen)
  2236  
  2237  	setHookOpenErr(func() error {
  2238  		// Wait for all connections to enqueue.
  2239  		opening.Wait()
  2240  		return errOffline
  2241  	})
  2242  
  2243  	for i := 0; i < tryOpen; i++ {
  2244  		go func() {
  2245  			opening.Done() // signal one connection is in flight
  2246  			_, err := db.Exec("will never run")
  2247  			errs <- err
  2248  		}()
  2249  	}
  2250  
  2251  	opening.Wait() // wait for all workers to begin running
  2252  
  2253  	const timeout = 5 * time.Second
  2254  	to := time.NewTimer(timeout)
  2255  	defer to.Stop()
  2256  
  2257  	// check that all connections fail without deadlock
  2258  	for i := 0; i < tryOpen; i++ {
  2259  		select {
  2260  		case err := <-errs:
  2261  			if got, want := err, errOffline; got != want {
  2262  				t.Errorf("unexpected err: got %v, want %v", got, want)
  2263  			}
  2264  		case <-to.C:
  2265  			t.Fatalf("orphaned connection request(s), still waiting after %v", timeout)
  2266  		}
  2267  	}
  2268  
  2269  	// Wait a reasonable time for the database to close all connections.
  2270  	tick := time.NewTicker(3 * time.Millisecond)
  2271  	defer tick.Stop()
  2272  	for {
  2273  		select {
  2274  		case <-tick.C:
  2275  			db.mu.Lock()
  2276  			if db.numOpen == 0 {
  2277  				db.mu.Unlock()
  2278  				return
  2279  			}
  2280  			db.mu.Unlock()
  2281  		case <-to.C:
  2282  			// Closing the database will check for numOpen and fail the test.
  2283  			return
  2284  		}
  2285  	}
  2286  }
  2287  
  2288  func TestSingleOpenConn(t *testing.T) {
  2289  	db := newTestDB(t, "people")
  2290  	defer closeDB(t, db)
  2291  
  2292  	db.SetMaxOpenConns(1)
  2293  
  2294  	rows, err := db.Query("SELECT|people|name|")
  2295  	if err != nil {
  2296  		t.Fatal(err)
  2297  	}
  2298  	if err = rows.Close(); err != nil {
  2299  		t.Fatal(err)
  2300  	}
  2301  	// shouldn't deadlock
  2302  	rows, err = db.Query("SELECT|people|name|")
  2303  	if err != nil {
  2304  		t.Fatal(err)
  2305  	}
  2306  	if err = rows.Close(); err != nil {
  2307  		t.Fatal(err)
  2308  	}
  2309  }
  2310  
  2311  func TestStats(t *testing.T) {
  2312  	db := newTestDB(t, "people")
  2313  	stats := db.Stats()
  2314  	if got := stats.OpenConnections; got != 1 {
  2315  		t.Errorf("stats.OpenConnections = %d; want 1", got)
  2316  	}
  2317  
  2318  	tx, err := db.Begin()
  2319  	if err != nil {
  2320  		t.Fatal(err)
  2321  	}
  2322  	tx.Commit()
  2323  
  2324  	closeDB(t, db)
  2325  	stats = db.Stats()
  2326  	if got := stats.OpenConnections; got != 0 {
  2327  		t.Errorf("stats.OpenConnections = %d; want 0", got)
  2328  	}
  2329  }
  2330  
  2331  func TestConnMaxLifetime(t *testing.T) {
  2332  	t0 := time.Unix(1000000, 0)
  2333  	offset := time.Duration(0)
  2334  
  2335  	nowFunc = func() time.Time { return t0.Add(offset) }
  2336  	defer func() { nowFunc = time.Now }()
  2337  
  2338  	db := newTestDB(t, "magicquery")
  2339  	defer closeDB(t, db)
  2340  
  2341  	driver := db.Driver().(*fakeDriver)
  2342  
  2343  	// Force the number of open connections to 0 so we can get an accurate
  2344  	// count for the test
  2345  	db.clearAllConns(t)
  2346  
  2347  	driver.mu.Lock()
  2348  	opens0 := driver.openCount
  2349  	closes0 := driver.closeCount
  2350  	driver.mu.Unlock()
  2351  
  2352  	db.SetMaxIdleConns(10)
  2353  	db.SetMaxOpenConns(10)
  2354  
  2355  	tx, err := db.Begin()
  2356  	if err != nil {
  2357  		t.Fatal(err)
  2358  	}
  2359  
  2360  	offset = time.Second
  2361  	tx2, err := db.Begin()
  2362  	if err != nil {
  2363  		t.Fatal(err)
  2364  	}
  2365  
  2366  	tx.Commit()
  2367  	tx2.Commit()
  2368  
  2369  	driver.mu.Lock()
  2370  	opens := driver.openCount - opens0
  2371  	closes := driver.closeCount - closes0
  2372  	driver.mu.Unlock()
  2373  
  2374  	if opens != 2 {
  2375  		t.Errorf("opens = %d; want 2", opens)
  2376  	}
  2377  	if closes != 0 {
  2378  		t.Errorf("closes = %d; want 0", closes)
  2379  	}
  2380  	if g, w := db.numFreeConns(), 2; g != w {
  2381  		t.Errorf("free conns = %d; want %d", g, w)
  2382  	}
  2383  
  2384  	// Expire first conn
  2385  	offset = 11 * time.Second
  2386  	db.SetConnMaxLifetime(10 * time.Second)
  2387  	if err != nil {
  2388  		t.Fatal(err)
  2389  	}
  2390  
  2391  	tx, err = db.Begin()
  2392  	if err != nil {
  2393  		t.Fatal(err)
  2394  	}
  2395  	tx2, err = db.Begin()
  2396  	if err != nil {
  2397  		t.Fatal(err)
  2398  	}
  2399  	tx.Commit()
  2400  	tx2.Commit()
  2401  
  2402  	driver.mu.Lock()
  2403  	opens = driver.openCount - opens0
  2404  	closes = driver.closeCount - closes0
  2405  	driver.mu.Unlock()
  2406  
  2407  	if opens != 3 {
  2408  		t.Errorf("opens = %d; want 3", opens)
  2409  	}
  2410  	if closes != 1 {
  2411  		t.Errorf("closes = %d; want 1", closes)
  2412  	}
  2413  }
  2414  
  2415  // golang.org/issue/5323
  2416  func TestStmtCloseDeps(t *testing.T) {
  2417  	if testing.Short() {
  2418  		t.Skip("skipping in short mode")
  2419  	}
  2420  	defer setHookpostCloseConn(nil)
  2421  	setHookpostCloseConn(func(_ *fakeConn, err error) {
  2422  		if err != nil {
  2423  			t.Errorf("Error closing fakeConn: %v", err)
  2424  		}
  2425  	})
  2426  
  2427  	db := newTestDB(t, "magicquery")
  2428  	defer closeDB(t, db)
  2429  
  2430  	driver := db.Driver().(*fakeDriver)
  2431  
  2432  	driver.mu.Lock()
  2433  	opens0 := driver.openCount
  2434  	closes0 := driver.closeCount
  2435  	driver.mu.Unlock()
  2436  	openDelta0 := opens0 - closes0
  2437  
  2438  	stmt, err := db.Prepare("SELECT|magicquery|op|op=?,millis=?")
  2439  	if err != nil {
  2440  		t.Fatal(err)
  2441  	}
  2442  
  2443  	// Start 50 parallel slow queries.
  2444  	const (
  2445  		nquery      = 50
  2446  		sleepMillis = 25
  2447  		nbatch      = 2
  2448  	)
  2449  	var wg sync.WaitGroup
  2450  	for batch := 0; batch < nbatch; batch++ {
  2451  		for i := 0; i < nquery; i++ {
  2452  			wg.Add(1)
  2453  			go func() {
  2454  				defer wg.Done()
  2455  				var op string
  2456  				if err := stmt.QueryRow("sleep", sleepMillis).Scan(&op); err != nil && err != ErrNoRows {
  2457  					t.Error(err)
  2458  				}
  2459  			}()
  2460  		}
  2461  		// Sleep for twice the expected length of time for the
  2462  		// batch of 50 queries above to finish before starting
  2463  		// the next round.
  2464  		time.Sleep(2 * sleepMillis * time.Millisecond)
  2465  	}
  2466  	wg.Wait()
  2467  
  2468  	if g, w := db.numFreeConns(), 2; g != w {
  2469  		t.Errorf("free conns = %d; want %d", g, w)
  2470  	}
  2471  
  2472  	if n := db.numDepsPollUntil(4, time.Second); n > 4 {
  2473  		t.Errorf("number of dependencies = %d; expected <= 4", n)
  2474  		db.dumpDeps(t)
  2475  	}
  2476  
  2477  	driver.mu.Lock()
  2478  	opens := driver.openCount - opens0
  2479  	closes := driver.closeCount - closes0
  2480  	openDelta := (driver.openCount - driver.closeCount) - openDelta0
  2481  	driver.mu.Unlock()
  2482  
  2483  	if openDelta > 2 {
  2484  		t.Logf("open calls = %d", opens)
  2485  		t.Logf("close calls = %d", closes)
  2486  		t.Logf("open delta = %d", openDelta)
  2487  		t.Errorf("db connections opened = %d; want <= 2", openDelta)
  2488  		db.dumpDeps(t)
  2489  	}
  2490  
  2491  	if !waitCondition(5*time.Second, 5*time.Millisecond, func() bool {
  2492  		return len(stmt.css) <= nquery
  2493  	}) {
  2494  		t.Errorf("len(stmt.css) = %d; want <= %d", len(stmt.css), nquery)
  2495  	}
  2496  
  2497  	if err := stmt.Close(); err != nil {
  2498  		t.Fatal(err)
  2499  	}
  2500  
  2501  	if g, w := db.numFreeConns(), 2; g != w {
  2502  		t.Errorf("free conns = %d; want %d", g, w)
  2503  	}
  2504  
  2505  	if n := db.numDepsPollUntil(2, time.Second); n > 2 {
  2506  		t.Errorf("number of dependencies = %d; expected <= 2", n)
  2507  		db.dumpDeps(t)
  2508  	}
  2509  
  2510  	db.clearAllConns(t)
  2511  }
  2512  
  2513  // golang.org/issue/5046
  2514  func TestCloseConnBeforeStmts(t *testing.T) {
  2515  	db := newTestDB(t, "people")
  2516  	defer closeDB(t, db)
  2517  
  2518  	defer setHookpostCloseConn(nil)
  2519  	setHookpostCloseConn(func(_ *fakeConn, err error) {
  2520  		if err != nil {
  2521  			t.Errorf("Error closing fakeConn: %v; from %s", err, stack())
  2522  			db.dumpDeps(t)
  2523  			t.Errorf("DB = %#v", db)
  2524  		}
  2525  	})
  2526  
  2527  	stmt, err := db.Prepare("SELECT|people|name|")
  2528  	if err != nil {
  2529  		t.Fatal(err)
  2530  	}
  2531  
  2532  	if len(db.freeConn) != 1 {
  2533  		t.Fatalf("expected 1 freeConn; got %d", len(db.freeConn))
  2534  	}
  2535  	dc := db.freeConn[0]
  2536  	if dc.closed {
  2537  		t.Errorf("conn shouldn't be closed")
  2538  	}
  2539  
  2540  	if n := len(dc.openStmt); n != 1 {
  2541  		t.Errorf("driverConn num openStmt = %d; want 1", n)
  2542  	}
  2543  	err = db.Close()
  2544  	if err != nil {
  2545  		t.Errorf("db Close = %v", err)
  2546  	}
  2547  	if !dc.closed {
  2548  		t.Errorf("after db.Close, driverConn should be closed")
  2549  	}
  2550  	if n := len(dc.openStmt); n != 0 {
  2551  		t.Errorf("driverConn num openStmt = %d; want 0", n)
  2552  	}
  2553  
  2554  	err = stmt.Close()
  2555  	if err != nil {
  2556  		t.Errorf("Stmt close = %v", err)
  2557  	}
  2558  
  2559  	if !dc.closed {
  2560  		t.Errorf("conn should be closed")
  2561  	}
  2562  	if dc.ci != nil {
  2563  		t.Errorf("after Stmt Close, driverConn's Conn interface should be nil")
  2564  	}
  2565  }
  2566  
  2567  // golang.org/issue/5283: don't release the Rows' connection in Close
  2568  // before calling Stmt.Close.
  2569  func TestRowsCloseOrder(t *testing.T) {
  2570  	db := newTestDB(t, "people")
  2571  	defer closeDB(t, db)
  2572  
  2573  	db.SetMaxIdleConns(0)
  2574  	setStrictFakeConnClose(t)
  2575  	defer setStrictFakeConnClose(nil)
  2576  
  2577  	rows, err := db.Query("SELECT|people|age,name|")
  2578  	if err != nil {
  2579  		t.Fatal(err)
  2580  	}
  2581  	err = rows.Close()
  2582  	if err != nil {
  2583  		t.Fatal(err)
  2584  	}
  2585  }
  2586  
  2587  func TestRowsImplicitClose(t *testing.T) {
  2588  	db := newTestDB(t, "people")
  2589  	defer closeDB(t, db)
  2590  
  2591  	rows, err := db.Query("SELECT|people|age,name|")
  2592  	if err != nil {
  2593  		t.Fatal(err)
  2594  	}
  2595  
  2596  	want, fail := 2, errors.New("fail")
  2597  	r := rows.rowsi.(*rowsCursor)
  2598  	r.errPos, r.err = want, fail
  2599  
  2600  	got := 0
  2601  	for rows.Next() {
  2602  		got++
  2603  	}
  2604  	if got != want {
  2605  		t.Errorf("got %d rows, want %d", got, want)
  2606  	}
  2607  	if err := rows.Err(); err != fail {
  2608  		t.Errorf("got error %v, want %v", err, fail)
  2609  	}
  2610  	if !r.closed {
  2611  		t.Errorf("r.closed is false, want true")
  2612  	}
  2613  }
  2614  
  2615  func TestStmtCloseOrder(t *testing.T) {
  2616  	db := newTestDB(t, "people")
  2617  	defer closeDB(t, db)
  2618  
  2619  	db.SetMaxIdleConns(0)
  2620  	setStrictFakeConnClose(t)
  2621  	defer setStrictFakeConnClose(nil)
  2622  
  2623  	_, err := db.Query("SELECT|non_existent|name|")
  2624  	if err == nil {
  2625  		t.Fatal("Querying non-existent table should fail")
  2626  	}
  2627  }
  2628  
  2629  // Test cases where there's more than maxBadConnRetries bad connections in the
  2630  // pool (issue 8834)
  2631  func TestManyErrBadConn(t *testing.T) {
  2632  	manyErrBadConnSetup := func(first ...func(db *DB)) *DB {
  2633  		db := newTestDB(t, "people")
  2634  
  2635  		for _, f := range first {
  2636  			f(db)
  2637  		}
  2638  
  2639  		nconn := maxBadConnRetries + 1
  2640  		db.SetMaxIdleConns(nconn)
  2641  		db.SetMaxOpenConns(nconn)
  2642  		// open enough connections
  2643  		func() {
  2644  			for i := 0; i < nconn; i++ {
  2645  				rows, err := db.Query("SELECT|people|age,name|")
  2646  				if err != nil {
  2647  					t.Fatal(err)
  2648  				}
  2649  				defer rows.Close()
  2650  			}
  2651  		}()
  2652  
  2653  		db.mu.Lock()
  2654  		defer db.mu.Unlock()
  2655  		if db.numOpen != nconn {
  2656  			t.Fatalf("unexpected numOpen %d (was expecting %d)", db.numOpen, nconn)
  2657  		} else if len(db.freeConn) != nconn {
  2658  			t.Fatalf("unexpected len(db.freeConn) %d (was expecting %d)", len(db.freeConn), nconn)
  2659  		}
  2660  		for _, conn := range db.freeConn {
  2661  			conn.Lock()
  2662  			conn.ci.(*fakeConn).stickyBad = true
  2663  			conn.Unlock()
  2664  		}
  2665  		return db
  2666  	}
  2667  
  2668  	// Query
  2669  	db := manyErrBadConnSetup()
  2670  	defer closeDB(t, db)
  2671  	rows, err := db.Query("SELECT|people|age,name|")
  2672  	if err != nil {
  2673  		t.Fatal(err)
  2674  	}
  2675  	if err = rows.Close(); err != nil {
  2676  		t.Fatal(err)
  2677  	}
  2678  
  2679  	// Exec
  2680  	db = manyErrBadConnSetup()
  2681  	defer closeDB(t, db)
  2682  	_, err = db.Exec("INSERT|people|name=Julia,age=19")
  2683  	if err != nil {
  2684  		t.Fatal(err)
  2685  	}
  2686  
  2687  	// Begin
  2688  	db = manyErrBadConnSetup()
  2689  	defer closeDB(t, db)
  2690  	tx, err := db.Begin()
  2691  	if err != nil {
  2692  		t.Fatal(err)
  2693  	}
  2694  	if err = tx.Rollback(); err != nil {
  2695  		t.Fatal(err)
  2696  	}
  2697  
  2698  	// Prepare
  2699  	db = manyErrBadConnSetup()
  2700  	defer closeDB(t, db)
  2701  	stmt, err := db.Prepare("SELECT|people|age,name|")
  2702  	if err != nil {
  2703  		t.Fatal(err)
  2704  	}
  2705  	if err = stmt.Close(); err != nil {
  2706  		t.Fatal(err)
  2707  	}
  2708  
  2709  	// Stmt.Exec
  2710  	db = manyErrBadConnSetup(func(db *DB) {
  2711  		stmt, err = db.Prepare("INSERT|people|name=Julia,age=19")
  2712  		if err != nil {
  2713  			t.Fatal(err)
  2714  		}
  2715  	})
  2716  	defer closeDB(t, db)
  2717  	_, err = stmt.Exec()
  2718  	if err != nil {
  2719  		t.Fatal(err)
  2720  	}
  2721  	if err = stmt.Close(); err != nil {
  2722  		t.Fatal(err)
  2723  	}
  2724  
  2725  	// Stmt.Query
  2726  	db = manyErrBadConnSetup(func(db *DB) {
  2727  		stmt, err = db.Prepare("SELECT|people|age,name|")
  2728  		if err != nil {
  2729  			t.Fatal(err)
  2730  		}
  2731  	})
  2732  	defer closeDB(t, db)
  2733  	rows, err = stmt.Query()
  2734  	if err != nil {
  2735  		t.Fatal(err)
  2736  	}
  2737  	if err = rows.Close(); err != nil {
  2738  		t.Fatal(err)
  2739  	}
  2740  	if err = stmt.Close(); err != nil {
  2741  		t.Fatal(err)
  2742  	}
  2743  
  2744  	// Conn
  2745  	db = manyErrBadConnSetup()
  2746  	defer closeDB(t, db)
  2747  	ctx, cancel := context.WithCancel(context.Background())
  2748  	defer cancel()
  2749  	conn, err := db.Conn(ctx)
  2750  	if err != nil {
  2751  		t.Fatal(err)
  2752  	}
  2753  	conn.dc.ci.(*fakeConn).skipDirtySession = true
  2754  	err = conn.Close()
  2755  	if err != nil {
  2756  		t.Fatal(err)
  2757  	}
  2758  
  2759  	// Ping
  2760  	db = manyErrBadConnSetup()
  2761  	defer closeDB(t, db)
  2762  	err = db.PingContext(ctx)
  2763  	if err != nil {
  2764  		t.Fatal(err)
  2765  	}
  2766  }
  2767  
  2768  // Issue 34775: Ensure that a Tx cannot commit after a rollback.
  2769  func TestTxCannotCommitAfterRollback(t *testing.T) {
  2770  	db := newTestDB(t, "tx_status")
  2771  	defer closeDB(t, db)
  2772  
  2773  	// First check query reporting is correct.
  2774  	var txStatus string
  2775  	err := db.QueryRow("SELECT|tx_status|tx_status|").Scan(&txStatus)
  2776  	if err != nil {
  2777  		t.Fatal(err)
  2778  	}
  2779  	if g, w := txStatus, "autocommit"; g != w {
  2780  		t.Fatalf("tx_status=%q, wanted %q", g, w)
  2781  	}
  2782  
  2783  	ctx, cancel := context.WithCancel(context.Background())
  2784  	defer cancel()
  2785  
  2786  	tx, err := db.BeginTx(ctx, nil)
  2787  	if err != nil {
  2788  		t.Fatal(err)
  2789  	}
  2790  
  2791  	// Ignore dirty session for this test.
  2792  	// A failing test should trigger the dirty session flag as well,
  2793  	// but that isn't exactly what this should test for.
  2794  	tx.txi.(*fakeTx).c.skipDirtySession = true
  2795  
  2796  	defer tx.Rollback()
  2797  
  2798  	err = tx.QueryRow("SELECT|tx_status|tx_status|").Scan(&txStatus)
  2799  	if err != nil {
  2800  		t.Fatal(err)
  2801  	}
  2802  	if g, w := txStatus, "transaction"; g != w {
  2803  		t.Fatalf("tx_status=%q, wanted %q", g, w)
  2804  	}
  2805  
  2806  	// 1. Begin a transaction.
  2807  	// 2. (A) Start a query, (B) begin Tx rollback through a ctx cancel.
  2808  	// 3. Check if 2.A has committed in Tx (pass) or outside of Tx (fail).
  2809  	sendQuery := make(chan struct{})
  2810  	// The Tx status is returned through the row results, ensure
  2811  	// that the rows results are not canceled.
  2812  	bypassRowsAwaitDone = true
  2813  	hookTxGrabConn = func() {
  2814  		cancel()
  2815  		<-sendQuery
  2816  	}
  2817  	rollbackHook = func() {
  2818  		close(sendQuery)
  2819  	}
  2820  	defer func() {
  2821  		hookTxGrabConn = nil
  2822  		rollbackHook = nil
  2823  		bypassRowsAwaitDone = false
  2824  	}()
  2825  
  2826  	err = tx.QueryRow("SELECT|tx_status|tx_status|").Scan(&txStatus)
  2827  	if err != nil {
  2828  		// A failure here would be expected if skipDirtySession was not set to true above.
  2829  		t.Fatal(err)
  2830  	}
  2831  	if g, w := txStatus, "transaction"; g != w {
  2832  		t.Fatalf("tx_status=%q, wanted %q", g, w)
  2833  	}
  2834  }
  2835  
  2836  // Issue 40985 transaction statement deadlock while context cancel.
  2837  func TestTxStmtDeadlock(t *testing.T) {
  2838  	db := newTestDB(t, "people")
  2839  	defer closeDB(t, db)
  2840  
  2841  	ctx, cancel := context.WithCancel(context.Background())
  2842  	defer cancel()
  2843  	tx, err := db.BeginTx(ctx, nil)
  2844  	if err != nil {
  2845  		t.Fatal(err)
  2846  	}
  2847  
  2848  	stmt, err := tx.Prepare("SELECT|people|name,age|age=?")
  2849  	if err != nil {
  2850  		t.Fatal(err)
  2851  	}
  2852  	cancel()
  2853  	// Run number of stmt queries to reproduce deadlock from context cancel
  2854  	for i := 0; i < 1e3; i++ {
  2855  		// Encounter any close related errors (e.g. ErrTxDone, stmt is closed)
  2856  		// is expected due to context cancel.
  2857  		_, err = stmt.Query(1)
  2858  		if err != nil {
  2859  			break
  2860  		}
  2861  	}
  2862  	_ = tx.Rollback()
  2863  }
  2864  
  2865  // Issue32530 encounters an issue where a connection may
  2866  // expire right after it comes out of a used connection pool
  2867  // even when a new connection is requested.
  2868  func TestConnExpiresFreshOutOfPool(t *testing.T) {
  2869  	execCases := []struct {
  2870  		expired  bool
  2871  		badReset bool
  2872  	}{
  2873  		{false, false},
  2874  		{true, false},
  2875  		{false, true},
  2876  	}
  2877  
  2878  	t0 := time.Unix(1000000, 0)
  2879  	offset := time.Duration(0)
  2880  	offsetMu := sync.RWMutex{}
  2881  
  2882  	nowFunc = func() time.Time {
  2883  		offsetMu.RLock()
  2884  		defer offsetMu.RUnlock()
  2885  		return t0.Add(offset)
  2886  	}
  2887  	defer func() { nowFunc = time.Now }()
  2888  
  2889  	ctx, cancel := context.WithCancel(context.Background())
  2890  	defer cancel()
  2891  
  2892  	db := newTestDB(t, "magicquery")
  2893  	defer closeDB(t, db)
  2894  
  2895  	db.SetMaxOpenConns(1)
  2896  
  2897  	for _, ec := range execCases {
  2898  		ec := ec
  2899  		name := fmt.Sprintf("expired=%t,badReset=%t", ec.expired, ec.badReset)
  2900  		t.Run(name, func(t *testing.T) {
  2901  			db.clearAllConns(t)
  2902  
  2903  			db.SetMaxIdleConns(1)
  2904  			db.SetConnMaxLifetime(10 * time.Second)
  2905  
  2906  			conn, err := db.conn(ctx, alwaysNewConn)
  2907  			if err != nil {
  2908  				t.Fatal(err)
  2909  			}
  2910  
  2911  			afterPutConn := make(chan struct{})
  2912  			waitingForConn := make(chan struct{})
  2913  
  2914  			go func() {
  2915  				defer close(afterPutConn)
  2916  
  2917  				conn, err := db.conn(ctx, alwaysNewConn)
  2918  				if err == nil {
  2919  					db.putConn(conn, err, false)
  2920  				} else {
  2921  					t.Errorf("db.conn: %v", err)
  2922  				}
  2923  			}()
  2924  			go func() {
  2925  				defer close(waitingForConn)
  2926  
  2927  				for {
  2928  					if t.Failed() {
  2929  						return
  2930  					}
  2931  					db.mu.Lock()
  2932  					ct := len(db.connRequests)
  2933  					db.mu.Unlock()
  2934  					if ct > 0 {
  2935  						return
  2936  					}
  2937  					time.Sleep(10 * time.Millisecond)
  2938  				}
  2939  			}()
  2940  
  2941  			<-waitingForConn
  2942  
  2943  			if t.Failed() {
  2944  				return
  2945  			}
  2946  
  2947  			offsetMu.Lock()
  2948  			if ec.expired {
  2949  				offset = 11 * time.Second
  2950  			} else {
  2951  				offset = time.Duration(0)
  2952  			}
  2953  			offsetMu.Unlock()
  2954  
  2955  			conn.ci.(*fakeConn).stickyBad = ec.badReset
  2956  
  2957  			db.putConn(conn, err, true)
  2958  
  2959  			<-afterPutConn
  2960  		})
  2961  	}
  2962  }
  2963  
  2964  // TestIssue20575 ensures the Rows from query does not block
  2965  // closing a transaction. Ensure Rows is closed while closing a trasaction.
  2966  func TestIssue20575(t *testing.T) {
  2967  	db := newTestDB(t, "people")
  2968  	defer closeDB(t, db)
  2969  
  2970  	tx, err := db.Begin()
  2971  	if err != nil {
  2972  		t.Fatal(err)
  2973  	}
  2974  	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
  2975  	defer cancel()
  2976  	_, err = tx.QueryContext(ctx, "SELECT|people|age,name|")
  2977  	if err != nil {
  2978  		t.Fatal(err)
  2979  	}
  2980  	// Do not close Rows from QueryContext.
  2981  	err = tx.Rollback()
  2982  	if err != nil {
  2983  		t.Fatal(err)
  2984  	}
  2985  	select {
  2986  	default:
  2987  	case <-ctx.Done():
  2988  		t.Fatal("timeout: failed to rollback query without closing rows:", ctx.Err())
  2989  	}
  2990  }
  2991  
  2992  // TestIssue20622 tests closing the transaction before rows is closed, requires
  2993  // the race detector to fail.
  2994  func TestIssue20622(t *testing.T) {
  2995  	db := newTestDB(t, "people")
  2996  	defer closeDB(t, db)
  2997  
  2998  	ctx, cancel := context.WithCancel(context.Background())
  2999  	defer cancel()
  3000  
  3001  	tx, err := db.BeginTx(ctx, nil)
  3002  	if err != nil {
  3003  		t.Fatal(err)
  3004  	}
  3005  
  3006  	rows, err := tx.Query("SELECT|people|age,name|")
  3007  	if err != nil {
  3008  		t.Fatal(err)
  3009  	}
  3010  
  3011  	count := 0
  3012  	for rows.Next() {
  3013  		count++
  3014  		var age int
  3015  		var name string
  3016  		if err := rows.Scan(&age, &name); err != nil {
  3017  			t.Fatal("scan failed", err)
  3018  		}
  3019  
  3020  		if count == 1 {
  3021  			cancel()
  3022  		}
  3023  		time.Sleep(100 * time.Millisecond)
  3024  	}
  3025  	rows.Close()
  3026  	tx.Commit()
  3027  }
  3028  
  3029  // golang.org/issue/5718
  3030  func TestErrBadConnReconnect(t *testing.T) {
  3031  	db := newTestDB(t, "foo")
  3032  	defer closeDB(t, db)
  3033  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  3034  
  3035  	simulateBadConn := func(name string, hook *func() bool, op func() error) {
  3036  		broken, retried := false, false
  3037  		numOpen := db.numOpen
  3038  
  3039  		// simulate a broken connection on the first try
  3040  		*hook = func() bool {
  3041  			if !broken {
  3042  				broken = true
  3043  				return true
  3044  			}
  3045  			retried = true
  3046  			return false
  3047  		}
  3048  
  3049  		if err := op(); err != nil {
  3050  			t.Errorf(name+": %v", err)
  3051  			return
  3052  		}
  3053  
  3054  		if !broken || !retried {
  3055  			t.Error(name + ": Failed to simulate broken connection")
  3056  		}
  3057  		*hook = nil
  3058  
  3059  		if numOpen != db.numOpen {
  3060  			t.Errorf(name+": leaked %d connection(s)!", db.numOpen-numOpen)
  3061  			numOpen = db.numOpen
  3062  		}
  3063  	}
  3064  
  3065  	// db.Exec
  3066  	dbExec := func() error {
  3067  		_, err := db.Exec("INSERT|t1|name=?,age=?,dead=?", "Gordon", 3, true)
  3068  		return err
  3069  	}
  3070  	simulateBadConn("db.Exec prepare", &hookPrepareBadConn, dbExec)
  3071  	simulateBadConn("db.Exec exec", &hookExecBadConn, dbExec)
  3072  
  3073  	// db.Query
  3074  	dbQuery := func() error {
  3075  		rows, err := db.Query("SELECT|t1|age,name|")
  3076  		if err == nil {
  3077  			err = rows.Close()
  3078  		}
  3079  		return err
  3080  	}
  3081  	simulateBadConn("db.Query prepare", &hookPrepareBadConn, dbQuery)
  3082  	simulateBadConn("db.Query query", &hookQueryBadConn, dbQuery)
  3083  
  3084  	// db.Prepare
  3085  	simulateBadConn("db.Prepare", &hookPrepareBadConn, func() error {
  3086  		stmt, err := db.Prepare("INSERT|t1|name=?,age=?,dead=?")
  3087  		if err != nil {
  3088  			return err
  3089  		}
  3090  		stmt.Close()
  3091  		return nil
  3092  	})
  3093  
  3094  	// Provide a way to force a re-prepare of a statement on next execution
  3095  	forcePrepare := func(stmt *Stmt) {
  3096  		stmt.css = nil
  3097  	}
  3098  
  3099  	// stmt.Exec
  3100  	stmt1, err := db.Prepare("INSERT|t1|name=?,age=?,dead=?")
  3101  	if err != nil {
  3102  		t.Fatalf("prepare: %v", err)
  3103  	}
  3104  	defer stmt1.Close()
  3105  	// make sure we must prepare the stmt first
  3106  	forcePrepare(stmt1)
  3107  
  3108  	stmtExec := func() error {
  3109  		_, err := stmt1.Exec("Gopher", 3, false)
  3110  		return err
  3111  	}
  3112  	simulateBadConn("stmt.Exec prepare", &hookPrepareBadConn, stmtExec)
  3113  	simulateBadConn("stmt.Exec exec", &hookExecBadConn, stmtExec)
  3114  
  3115  	// stmt.Query
  3116  	stmt2, err := db.Prepare("SELECT|t1|age,name|")
  3117  	if err != nil {
  3118  		t.Fatalf("prepare: %v", err)
  3119  	}
  3120  	defer stmt2.Close()
  3121  	// make sure we must prepare the stmt first
  3122  	forcePrepare(stmt2)
  3123  
  3124  	stmtQuery := func() error {
  3125  		rows, err := stmt2.Query()
  3126  		if err == nil {
  3127  			err = rows.Close()
  3128  		}
  3129  		return err
  3130  	}
  3131  	simulateBadConn("stmt.Query prepare", &hookPrepareBadConn, stmtQuery)
  3132  	simulateBadConn("stmt.Query exec", &hookQueryBadConn, stmtQuery)
  3133  }
  3134  
  3135  // golang.org/issue/11264
  3136  func TestTxEndBadConn(t *testing.T) {
  3137  	db := newTestDB(t, "foo")
  3138  	defer closeDB(t, db)
  3139  	db.SetMaxIdleConns(0)
  3140  	exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
  3141  	db.SetMaxIdleConns(1)
  3142  
  3143  	simulateBadConn := func(name string, hook *func() bool, op func() error) {
  3144  		broken := false
  3145  		numOpen := db.numOpen
  3146  
  3147  		*hook = func() bool {
  3148  			if !broken {
  3149  				broken = true
  3150  			}
  3151  			return broken
  3152  		}
  3153  
  3154  		if err := op(); err != driver.ErrBadConn {
  3155  			t.Errorf(name+": %v", err)
  3156  			return
  3157  		}
  3158  
  3159  		if !broken {
  3160  			t.Error(name + ": Failed to simulate broken connection")
  3161  		}
  3162  		*hook = nil
  3163  
  3164  		if numOpen != db.numOpen {
  3165  			t.Errorf(name+": leaked %d connection(s)!", db.numOpen-numOpen)
  3166  		}
  3167  	}
  3168  
  3169  	// db.Exec
  3170  	dbExec := func(endTx func(tx *Tx) error) func() error {
  3171  		return func() error {
  3172  			tx, err := db.Begin()
  3173  			if err != nil {
  3174  				return err
  3175  			}
  3176  			_, err = tx.Exec("INSERT|t1|name=?,age=?,dead=?", "Gordon", 3, true)
  3177  			if err != nil {
  3178  				return err
  3179  			}
  3180  			return endTx(tx)
  3181  		}
  3182  	}
  3183  	simulateBadConn("db.Tx.Exec commit", &hookCommitBadConn, dbExec((*Tx).Commit))
  3184  	simulateBadConn("db.Tx.Exec rollback", &hookRollbackBadConn, dbExec((*Tx).Rollback))
  3185  
  3186  	// db.Query
  3187  	dbQuery := func(endTx func(tx *Tx) error) func() error {
  3188  		return func() error {
  3189  			tx, err := db.Begin()
  3190  			if err != nil {
  3191  				return err
  3192  			}
  3193  			rows, err := tx.Query("SELECT|t1|age,name|")
  3194  			if err == nil {
  3195  				err = rows.Close()
  3196  			} else {
  3197  				return err
  3198  			}
  3199  			return endTx(tx)
  3200  		}
  3201  	}
  3202  	simulateBadConn("db.Tx.Query commit", &hookCommitBadConn, dbQuery((*Tx).Commit))
  3203  	simulateBadConn("db.Tx.Query rollback", &hookRollbackBadConn, dbQuery((*Tx).Rollback))
  3204  }
  3205  
  3206  type concurrentTest interface {
  3207  	init(t testing.TB, db *DB)
  3208  	finish(t testing.TB)
  3209  	test(t testing.TB) error
  3210  }
  3211  
  3212  type concurrentDBQueryTest struct {
  3213  	db *DB
  3214  }
  3215  
  3216  func (c *concurrentDBQueryTest) init(t testing.TB, db *DB) {
  3217  	c.db = db
  3218  }
  3219  
  3220  func (c *concurrentDBQueryTest) finish(t testing.TB) {
  3221  	c.db = nil
  3222  }
  3223  
  3224  func (c *concurrentDBQueryTest) test(t testing.TB) error {
  3225  	rows, err := c.db.Query("SELECT|people|name|")
  3226  	if err != nil {
  3227  		t.Error(err)
  3228  		return err
  3229  	}
  3230  	var name string
  3231  	for rows.Next() {
  3232  		rows.Scan(&name)
  3233  	}
  3234  	rows.Close()
  3235  	return nil
  3236  }
  3237  
  3238  type concurrentDBExecTest struct {
  3239  	db *DB
  3240  }
  3241  
  3242  func (c *concurrentDBExecTest) init(t testing.TB, db *DB) {
  3243  	c.db = db
  3244  }
  3245  
  3246  func (c *concurrentDBExecTest) finish(t testing.TB) {
  3247  	c.db = nil
  3248  }
  3249  
  3250  func (c *concurrentDBExecTest) test(t testing.TB) error {
  3251  	_, err := c.db.Exec("NOSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?", 3, chrisBirthday)
  3252  	if err != nil {
  3253  		t.Error(err)
  3254  		return err
  3255  	}
  3256  	return nil
  3257  }
  3258  
  3259  type concurrentStmtQueryTest struct {
  3260  	db   *DB
  3261  	stmt *Stmt
  3262  }
  3263  
  3264  func (c *concurrentStmtQueryTest) init(t testing.TB, db *DB) {
  3265  	c.db = db
  3266  	var err error
  3267  	c.stmt, err = db.Prepare("SELECT|people|name|")
  3268  	if err != nil {
  3269  		t.Fatal(err)
  3270  	}
  3271  }
  3272  
  3273  func (c *concurrentStmtQueryTest) finish(t testing.TB) {
  3274  	if c.stmt != nil {
  3275  		c.stmt.Close()
  3276  		c.stmt = nil
  3277  	}
  3278  	c.db = nil
  3279  }
  3280  
  3281  func (c *concurrentStmtQueryTest) test(t testing.TB) error {
  3282  	rows, err := c.stmt.Query()
  3283  	if err != nil {
  3284  		t.Errorf("error on query:  %v", err)
  3285  		return err
  3286  	}
  3287  
  3288  	var name string
  3289  	for rows.Next() {
  3290  		rows.Scan(&name)
  3291  	}
  3292  	rows.Close()
  3293  	return nil
  3294  }
  3295  
  3296  type concurrentStmtExecTest struct {
  3297  	db   *DB
  3298  	stmt *Stmt
  3299  }
  3300  
  3301  func (c *concurrentStmtExecTest) init(t testing.TB, db *DB) {
  3302  	c.db = db
  3303  	var err error
  3304  	c.stmt, err = db.Prepare("NOSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?")
  3305  	if err != nil {
  3306  		t.Fatal(err)
  3307  	}
  3308  }
  3309  
  3310  func (c *concurrentStmtExecTest) finish(t testing.TB) {
  3311  	if c.stmt != nil {
  3312  		c.stmt.Close()
  3313  		c.stmt = nil
  3314  	}
  3315  	c.db = nil
  3316  }
  3317  
  3318  func (c *concurrentStmtExecTest) test(t testing.TB) error {
  3319  	_, err := c.stmt.Exec(3, chrisBirthday)
  3320  	if err != nil {
  3321  		t.Errorf("error on exec:  %v", err)
  3322  		return err
  3323  	}
  3324  	return nil
  3325  }
  3326  
  3327  type concurrentTxQueryTest struct {
  3328  	db *DB
  3329  	tx *Tx
  3330  }
  3331  
  3332  func (c *concurrentTxQueryTest) init(t testing.TB, db *DB) {
  3333  	c.db = db
  3334  	var err error
  3335  	c.tx, err = c.db.Begin()
  3336  	if err != nil {
  3337  		t.Fatal(err)
  3338  	}
  3339  }
  3340  
  3341  func (c *concurrentTxQueryTest) finish(t testing.TB) {
  3342  	if c.tx != nil {
  3343  		c.tx.Rollback()
  3344  		c.tx = nil
  3345  	}
  3346  	c.db = nil
  3347  }
  3348  
  3349  func (c *concurrentTxQueryTest) test(t testing.TB) error {
  3350  	rows, err := c.db.Query("SELECT|people|name|")
  3351  	if err != nil {
  3352  		t.Error(err)
  3353  		return err
  3354  	}
  3355  	var name string
  3356  	for rows.Next() {
  3357  		rows.Scan(&name)
  3358  	}
  3359  	rows.Close()
  3360  	return nil
  3361  }
  3362  
  3363  type concurrentTxExecTest struct {
  3364  	db *DB
  3365  	tx *Tx
  3366  }
  3367  
  3368  func (c *concurrentTxExecTest) init(t testing.TB, db *DB) {
  3369  	c.db = db
  3370  	var err error
  3371  	c.tx, err = c.db.Begin()
  3372  	if err != nil {
  3373  		t.Fatal(err)
  3374  	}
  3375  }
  3376  
  3377  func (c *concurrentTxExecTest) finish(t testing.TB) {
  3378  	if c.tx != nil {
  3379  		c.tx.Rollback()
  3380  		c.tx = nil
  3381  	}
  3382  	c.db = nil
  3383  }
  3384  
  3385  func (c *concurrentTxExecTest) test(t testing.TB) error {
  3386  	_, err := c.tx.Exec("NOSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?", 3, chrisBirthday)
  3387  	if err != nil {
  3388  		t.Error(err)
  3389  		return err
  3390  	}
  3391  	return nil
  3392  }
  3393  
  3394  type concurrentTxStmtQueryTest struct {
  3395  	db   *DB
  3396  	tx   *Tx
  3397  	stmt *Stmt
  3398  }
  3399  
  3400  func (c *concurrentTxStmtQueryTest) init(t testing.TB, db *DB) {
  3401  	c.db = db
  3402  	var err error
  3403  	c.tx, err = c.db.Begin()
  3404  	if err != nil {
  3405  		t.Fatal(err)
  3406  	}
  3407  	c.stmt, err = c.tx.Prepare("SELECT|people|name|")
  3408  	if err != nil {
  3409  		t.Fatal(err)
  3410  	}
  3411  }
  3412  
  3413  func (c *concurrentTxStmtQueryTest) finish(t testing.TB) {
  3414  	if c.stmt != nil {
  3415  		c.stmt.Close()
  3416  		c.stmt = nil
  3417  	}
  3418  	if c.tx != nil {
  3419  		c.tx.Rollback()
  3420  		c.tx = nil
  3421  	}
  3422  	c.db = nil
  3423  }
  3424  
  3425  func (c *concurrentTxStmtQueryTest) test(t testing.TB) error {
  3426  	rows, err := c.stmt.Query()
  3427  	if err != nil {
  3428  		t.Errorf("error on query:  %v", err)
  3429  		return err
  3430  	}
  3431  
  3432  	var name string
  3433  	for rows.Next() {
  3434  		rows.Scan(&name)
  3435  	}
  3436  	rows.Close()
  3437  	return nil
  3438  }
  3439  
  3440  type concurrentTxStmtExecTest struct {
  3441  	db   *DB
  3442  	tx   *Tx
  3443  	stmt *Stmt
  3444  }
  3445  
  3446  func (c *concurrentTxStmtExecTest) init(t testing.TB, db *DB) {
  3447  	c.db = db
  3448  	var err error
  3449  	c.tx, err = c.db.Begin()
  3450  	if err != nil {
  3451  		t.Fatal(err)
  3452  	}
  3453  	c.stmt, err = c.tx.Prepare("NOSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?")
  3454  	if err != nil {
  3455  		t.Fatal(err)
  3456  	}
  3457  }
  3458  
  3459  func (c *concurrentTxStmtExecTest) finish(t testing.TB) {
  3460  	if c.stmt != nil {
  3461  		c.stmt.Close()
  3462  		c.stmt = nil
  3463  	}
  3464  	if c.tx != nil {
  3465  		c.tx.Rollback()
  3466  		c.tx = nil
  3467  	}
  3468  	c.db = nil
  3469  }
  3470  
  3471  func (c *concurrentTxStmtExecTest) test(t testing.TB) error {
  3472  	_, err := c.stmt.Exec(3, chrisBirthday)
  3473  	if err != nil {
  3474  		t.Errorf("error on exec:  %v", err)
  3475  		return err
  3476  	}
  3477  	return nil
  3478  }
  3479  
  3480  type concurrentRandomTest struct {
  3481  	tests []concurrentTest
  3482  }
  3483  
  3484  func (c *concurrentRandomTest) init(t testing.TB, db *DB) {
  3485  	c.tests = []concurrentTest{
  3486  		new(concurrentDBQueryTest),
  3487  		new(concurrentDBExecTest),
  3488  		new(concurrentStmtQueryTest),
  3489  		new(concurrentStmtExecTest),
  3490  		new(concurrentTxQueryTest),
  3491  		new(concurrentTxExecTest),
  3492  		new(concurrentTxStmtQueryTest),
  3493  		new(concurrentTxStmtExecTest),
  3494  	}
  3495  	for _, ct := range c.tests {
  3496  		ct.init(t, db)
  3497  	}
  3498  }
  3499  
  3500  func (c *concurrentRandomTest) finish(t testing.TB) {
  3501  	for _, ct := range c.tests {
  3502  		ct.finish(t)
  3503  	}
  3504  }
  3505  
  3506  func (c *concurrentRandomTest) test(t testing.TB) error {
  3507  	ct := c.tests[rand.Intn(len(c.tests))]
  3508  	return ct.test(t)
  3509  }
  3510  
  3511  func doConcurrentTest(t testing.TB, ct concurrentTest) {
  3512  	maxProcs, numReqs := 1, 500
  3513  	if testing.Short() {
  3514  		maxProcs, numReqs = 4, 50
  3515  	}
  3516  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(maxProcs))
  3517  
  3518  	db := newTestDB(t, "people")
  3519  	defer closeDB(t, db)
  3520  
  3521  	ct.init(t, db)
  3522  	defer ct.finish(t)
  3523  
  3524  	var wg sync.WaitGroup
  3525  	wg.Add(numReqs)
  3526  
  3527  	reqs := make(chan bool)
  3528  	defer close(reqs)
  3529  
  3530  	for i := 0; i < maxProcs*2; i++ {
  3531  		go func() {
  3532  			for range reqs {
  3533  				err := ct.test(t)
  3534  				if err != nil {
  3535  					wg.Done()
  3536  					continue
  3537  				}
  3538  				wg.Done()
  3539  			}
  3540  		}()
  3541  	}
  3542  
  3543  	for i := 0; i < numReqs; i++ {
  3544  		reqs <- true
  3545  	}
  3546  
  3547  	wg.Wait()
  3548  }
  3549  
  3550  func TestIssue6081(t *testing.T) {
  3551  	db := newTestDB(t, "people")
  3552  	defer closeDB(t, db)
  3553  
  3554  	drv := db.Driver().(*fakeDriver)
  3555  	drv.mu.Lock()
  3556  	opens0 := drv.openCount
  3557  	closes0 := drv.closeCount
  3558  	drv.mu.Unlock()
  3559  
  3560  	stmt, err := db.Prepare("SELECT|people|name|")
  3561  	if err != nil {
  3562  		t.Fatal(err)
  3563  	}
  3564  	setRowsCloseHook(func(rows *Rows, err *error) {
  3565  		*err = driver.ErrBadConn
  3566  	})
  3567  	defer setRowsCloseHook(nil)
  3568  	for i := 0; i < 10; i++ {
  3569  		rows, err := stmt.Query()
  3570  		if err != nil {
  3571  			t.Fatal(err)
  3572  		}
  3573  		rows.Close()
  3574  	}
  3575  	if n := len(stmt.css); n > 1 {
  3576  		t.Errorf("len(css slice) = %d; want <= 1", n)
  3577  	}
  3578  	stmt.Close()
  3579  	if n := len(stmt.css); n != 0 {
  3580  		t.Errorf("len(css slice) after Close = %d; want 0", n)
  3581  	}
  3582  
  3583  	drv.mu.Lock()
  3584  	opens := drv.openCount - opens0
  3585  	closes := drv.closeCount - closes0
  3586  	drv.mu.Unlock()
  3587  	if opens < 9 {
  3588  		t.Errorf("opens = %d; want >= 9", opens)
  3589  	}
  3590  	if closes < 9 {
  3591  		t.Errorf("closes = %d; want >= 9", closes)
  3592  	}
  3593  }
  3594  
  3595  // TestIssue18429 attempts to stress rolling back the transaction from a
  3596  // context cancel while simultaneously calling Tx.Rollback. Rolling back from a
  3597  // context happens concurrently so tx.rollback and tx.Commit must guard against
  3598  // double entry.
  3599  //
  3600  // In the test, a context is canceled while the query is in process so
  3601  // the internal rollback will run concurrently with the explicitly called
  3602  // Tx.Rollback.
  3603  //
  3604  // The addition of calling rows.Next also tests
  3605  // Issue 21117.
  3606  func TestIssue18429(t *testing.T) {
  3607  	db := newTestDB(t, "people")
  3608  	defer closeDB(t, db)
  3609  
  3610  	ctx := context.Background()
  3611  	sem := make(chan bool, 20)
  3612  	var wg sync.WaitGroup
  3613  
  3614  	const milliWait = 30
  3615  
  3616  	for i := 0; i < 100; i++ {
  3617  		sem <- true
  3618  		wg.Add(1)
  3619  		go func() {
  3620  			defer func() {
  3621  				<-sem
  3622  				wg.Done()
  3623  			}()
  3624  			qwait := (time.Duration(rand.Intn(milliWait)) * time.Millisecond).String()
  3625  
  3626  			ctx, cancel := context.WithTimeout(ctx, time.Duration(rand.Intn(milliWait))*time.Millisecond)
  3627  			defer cancel()
  3628  
  3629  			tx, err := db.BeginTx(ctx, nil)
  3630  			if err != nil {
  3631  				return
  3632  			}
  3633  			// This is expected to give a cancel error most, but not all the time.
  3634  			// Test failure will happen with a panic or other race condition being
  3635  			// reported.
  3636  			rows, _ := tx.QueryContext(ctx, "WAIT|"+qwait+"|SELECT|people|name|")
  3637  			if rows != nil {
  3638  				var name string
  3639  				// Call Next to test Issue 21117 and check for races.
  3640  				for rows.Next() {
  3641  					// Scan the buffer so it is read and checked for races.
  3642  					rows.Scan(&name)
  3643  				}
  3644  				rows.Close()
  3645  			}
  3646  			// This call will race with the context cancel rollback to complete
  3647  			// if the rollback itself isn't guarded.
  3648  			tx.Rollback()
  3649  		}()
  3650  	}
  3651  	wg.Wait()
  3652  }
  3653  
  3654  // TestIssue20160 attempts to test a short context life on a stmt Query.
  3655  func TestIssue20160(t *testing.T) {
  3656  	db := newTestDB(t, "people")
  3657  	defer closeDB(t, db)
  3658  
  3659  	ctx := context.Background()
  3660  	sem := make(chan bool, 20)
  3661  	var wg sync.WaitGroup
  3662  
  3663  	const milliWait = 30
  3664  
  3665  	stmt, err := db.PrepareContext(ctx, "SELECT|people|name|")
  3666  	if err != nil {
  3667  		t.Fatal(err)
  3668  	}
  3669  	defer stmt.Close()
  3670  
  3671  	for i := 0; i < 100; i++ {
  3672  		sem <- true
  3673  		wg.Add(1)
  3674  		go func() {
  3675  			defer func() {
  3676  				<-sem
  3677  				wg.Done()
  3678  			}()
  3679  			ctx, cancel := context.WithTimeout(ctx, time.Duration(rand.Intn(milliWait))*time.Millisecond)
  3680  			defer cancel()
  3681  
  3682  			// This is expected to give a cancel error most, but not all the time.
  3683  			// Test failure will happen with a panic or other race condition being
  3684  			// reported.
  3685  			rows, _ := stmt.QueryContext(ctx)
  3686  			if rows != nil {
  3687  				rows.Close()
  3688  			}
  3689  		}()
  3690  	}
  3691  	wg.Wait()
  3692  }
  3693  
  3694  // TestIssue18719 closes the context right before use. The sql.driverConn
  3695  // will nil out the ci on close in a lock, but if another process uses it right after
  3696  // it will panic with on the nil ref.
  3697  //
  3698  // See https://golang.org/cl/35550 .
  3699  func TestIssue18719(t *testing.T) {
  3700  	db := newTestDB(t, "people")
  3701  	defer closeDB(t, db)
  3702  
  3703  	ctx, cancel := context.WithCancel(context.Background())
  3704  	defer cancel()
  3705  
  3706  	tx, err := db.BeginTx(ctx, nil)
  3707  	if err != nil {
  3708  		t.Fatal(err)
  3709  	}
  3710  
  3711  	hookTxGrabConn = func() {
  3712  		cancel()
  3713  
  3714  		// Wait for the context to cancel and tx to rollback.
  3715  		for tx.isDone() == false {
  3716  			time.Sleep(3 * time.Millisecond)
  3717  		}
  3718  	}
  3719  	defer func() { hookTxGrabConn = nil }()
  3720  
  3721  	// This call will grab the connection and cancel the context
  3722  	// after it has done so. Code after must deal with the canceled state.
  3723  	_, err = tx.QueryContext(ctx, "SELECT|people|name|")
  3724  	if err != nil {
  3725  		t.Fatalf("expected error %v but got %v", nil, err)
  3726  	}
  3727  
  3728  	// Rows may be ignored because it will be closed when the context is canceled.
  3729  
  3730  	// Do not explicitly rollback. The rollback will happen from the
  3731  	// canceled context.
  3732  
  3733  	cancel()
  3734  }
  3735  
  3736  func TestIssue20647(t *testing.T) {
  3737  	db := newTestDB(t, "people")
  3738  	defer closeDB(t, db)
  3739  
  3740  	ctx, cancel := context.WithCancel(context.Background())
  3741  	defer cancel()
  3742  
  3743  	conn, err := db.Conn(ctx)
  3744  	if err != nil {
  3745  		t.Fatal(err)
  3746  	}
  3747  	conn.dc.ci.(*fakeConn).skipDirtySession = true
  3748  	defer conn.Close()
  3749  
  3750  	stmt, err := conn.PrepareContext(ctx, "SELECT|people|name|")
  3751  	if err != nil {
  3752  		t.Fatal(err)
  3753  	}
  3754  	defer stmt.Close()
  3755  
  3756  	rows1, err := stmt.QueryContext(ctx)
  3757  	if err != nil {
  3758  		t.Fatal("rows1", err)
  3759  	}
  3760  	defer rows1.Close()
  3761  
  3762  	rows2, err := stmt.QueryContext(ctx)
  3763  	if err != nil {
  3764  		t.Fatal("rows2", err)
  3765  	}
  3766  	defer rows2.Close()
  3767  
  3768  	if rows1.dc != rows2.dc {
  3769  		t.Fatal("stmt prepared on Conn does not use same connection")
  3770  	}
  3771  }
  3772  
  3773  func TestConcurrency(t *testing.T) {
  3774  	list := []struct {
  3775  		name string
  3776  		ct   concurrentTest
  3777  	}{
  3778  		{"Query", new(concurrentDBQueryTest)},
  3779  		{"Exec", new(concurrentDBExecTest)},
  3780  		{"StmtQuery", new(concurrentStmtQueryTest)},
  3781  		{"StmtExec", new(concurrentStmtExecTest)},
  3782  		{"TxQuery", new(concurrentTxQueryTest)},
  3783  		{"TxExec", new(concurrentTxExecTest)},
  3784  		{"TxStmtQuery", new(concurrentTxStmtQueryTest)},
  3785  		{"TxStmtExec", new(concurrentTxStmtExecTest)},
  3786  		{"Random", new(concurrentRandomTest)},
  3787  	}
  3788  	for _, item := range list {
  3789  		t.Run(item.name, func(t *testing.T) {
  3790  			doConcurrentTest(t, item.ct)
  3791  		})
  3792  	}
  3793  }
  3794  
  3795  func TestConnectionLeak(t *testing.T) {
  3796  	db := newTestDB(t, "people")
  3797  	defer closeDB(t, db)
  3798  	// Start by opening defaultMaxIdleConns
  3799  	rows := make([]*Rows, defaultMaxIdleConns)
  3800  	// We need to SetMaxOpenConns > MaxIdleConns, so the DB can open
  3801  	// a new connection and we can fill the idle queue with the released
  3802  	// connections.
  3803  	db.SetMaxOpenConns(len(rows) + 1)
  3804  	for ii := range rows {
  3805  		r, err := db.Query("SELECT|people|name|")
  3806  		if err != nil {
  3807  			t.Fatal(err)
  3808  		}
  3809  		r.Next()
  3810  		if err := r.Err(); err != nil {
  3811  			t.Fatal(err)
  3812  		}
  3813  		rows[ii] = r
  3814  	}
  3815  	// Now we have defaultMaxIdleConns busy connections. Open
  3816  	// a new one, but wait until the busy connections are released
  3817  	// before returning control to DB.
  3818  	drv := db.Driver().(*fakeDriver)
  3819  	drv.waitCh = make(chan struct{}, 1)
  3820  	drv.waitingCh = make(chan struct{}, 1)
  3821  	var wg sync.WaitGroup
  3822  	wg.Add(1)
  3823  	go func() {
  3824  		r, err := db.Query("SELECT|people|name|")
  3825  		if err != nil {
  3826  			t.Error(err)
  3827  			return
  3828  		}
  3829  		r.Close()
  3830  		wg.Done()
  3831  	}()
  3832  	// Wait until the goroutine we've just created has started waiting.
  3833  	<-drv.waitingCh
  3834  	// Now close the busy connections. This provides a connection for
  3835  	// the blocked goroutine and then fills up the idle queue.
  3836  	for _, v := range rows {
  3837  		v.Close()
  3838  	}
  3839  	// At this point we give the new connection to DB. This connection is
  3840  	// now useless, since the idle queue is full and there are no pending
  3841  	// requests. DB should deal with this situation without leaking the
  3842  	// connection.
  3843  	drv.waitCh <- struct{}{}
  3844  	wg.Wait()
  3845  }
  3846  
  3847  func TestStatsMaxIdleClosedZero(t *testing.T) {
  3848  	db := newTestDB(t, "people")
  3849  	defer closeDB(t, db)
  3850  
  3851  	db.SetMaxOpenConns(1)
  3852  	db.SetMaxIdleConns(1)
  3853  	db.SetConnMaxLifetime(0)
  3854  
  3855  	preMaxIdleClosed := db.Stats().MaxIdleClosed
  3856  
  3857  	for i := 0; i < 10; i++ {
  3858  		rows, err := db.Query("SELECT|people|name|")
  3859  		if err != nil {
  3860  			t.Fatal(err)
  3861  		}
  3862  		rows.Close()
  3863  	}
  3864  
  3865  	st := db.Stats()
  3866  	maxIdleClosed := st.MaxIdleClosed - preMaxIdleClosed
  3867  	t.Logf("MaxIdleClosed: %d", maxIdleClosed)
  3868  	if maxIdleClosed != 0 {
  3869  		t.Fatal("expected 0 max idle closed conns, got: ", maxIdleClosed)
  3870  	}
  3871  }
  3872  
  3873  func TestStatsMaxIdleClosedTen(t *testing.T) {
  3874  	db := newTestDB(t, "people")
  3875  	defer closeDB(t, db)
  3876  
  3877  	db.SetMaxOpenConns(1)
  3878  	db.SetMaxIdleConns(0)
  3879  	db.SetConnMaxLifetime(0)
  3880  
  3881  	preMaxIdleClosed := db.Stats().MaxIdleClosed
  3882  
  3883  	for i := 0; i < 10; i++ {
  3884  		rows, err := db.Query("SELECT|people|name|")
  3885  		if err != nil {
  3886  			t.Fatal(err)
  3887  		}
  3888  		rows.Close()
  3889  	}
  3890  
  3891  	st := db.Stats()
  3892  	maxIdleClosed := st.MaxIdleClosed - preMaxIdleClosed
  3893  	t.Logf("MaxIdleClosed: %d", maxIdleClosed)
  3894  	if maxIdleClosed != 10 {
  3895  		t.Fatal("expected 0 max idle closed conns, got: ", maxIdleClosed)
  3896  	}
  3897  }
  3898  
  3899  func TestMaxIdleTime(t *testing.T) {
  3900  	list := []struct {
  3901  		wantMaxIdleTime time.Duration
  3902  		wantIdleClosed  int64
  3903  		timeOffset      time.Duration
  3904  	}{
  3905  		{time.Nanosecond, 1, 10 * time.Millisecond},
  3906  		{time.Hour, 0, 10 * time.Millisecond},
  3907  	}
  3908  	baseTime := time.Unix(0, 0)
  3909  	defer func() {
  3910  		nowFunc = time.Now
  3911  	}()
  3912  	for _, item := range list {
  3913  		nowFunc = func() time.Time {
  3914  			return baseTime
  3915  		}
  3916  		t.Run(fmt.Sprintf("%v", item.wantMaxIdleTime), func(t *testing.T) {
  3917  			db := newTestDB(t, "people")
  3918  			defer closeDB(t, db)
  3919  
  3920  			db.SetMaxOpenConns(1)
  3921  			db.SetMaxIdleConns(1)
  3922  			db.SetConnMaxIdleTime(item.wantMaxIdleTime)
  3923  			db.SetConnMaxLifetime(0)
  3924  
  3925  			preMaxIdleClosed := db.Stats().MaxIdleTimeClosed
  3926  
  3927  			if err := db.Ping(); err != nil {
  3928  				t.Fatal(err)
  3929  			}
  3930  
  3931  			nowFunc = func() time.Time {
  3932  				return baseTime.Add(item.timeOffset)
  3933  			}
  3934  
  3935  			db.mu.Lock()
  3936  			closing := db.connectionCleanerRunLocked()
  3937  			db.mu.Unlock()
  3938  			for _, c := range closing {
  3939  				c.Close()
  3940  			}
  3941  			if g, w := int64(len(closing)), item.wantIdleClosed; g != w {
  3942  				t.Errorf("got: %d; want %d closed conns", g, w)
  3943  			}
  3944  
  3945  			st := db.Stats()
  3946  			maxIdleClosed := st.MaxIdleTimeClosed - preMaxIdleClosed
  3947  			if g, w := maxIdleClosed, item.wantIdleClosed; g != w {
  3948  				t.Errorf(" got: %d; want %d max idle closed conns", g, w)
  3949  			}
  3950  		})
  3951  	}
  3952  }
  3953  
  3954  type nvcDriver struct {
  3955  	fakeDriver
  3956  	skipNamedValueCheck bool
  3957  }
  3958  
  3959  func (d *nvcDriver) Open(dsn string) (driver.Conn, error) {
  3960  	c, err := d.fakeDriver.Open(dsn)
  3961  	fc := c.(*fakeConn)
  3962  	fc.db.allowAny = true
  3963  	return &nvcConn{fc, d.skipNamedValueCheck}, err
  3964  }
  3965  
  3966  type nvcConn struct {
  3967  	*fakeConn
  3968  	skipNamedValueCheck bool
  3969  }
  3970  
  3971  type decimalInt struct {
  3972  	value int
  3973  }
  3974  
  3975  type doNotInclude struct{}
  3976  
  3977  var _ driver.NamedValueChecker = &nvcConn{}
  3978  
  3979  func (c *nvcConn) CheckNamedValue(nv *driver.NamedValue) error {
  3980  	if c.skipNamedValueCheck {
  3981  		return driver.ErrSkip
  3982  	}
  3983  	switch v := nv.Value.(type) {
  3984  	default:
  3985  		return driver.ErrSkip
  3986  	case Out:
  3987  		switch ov := v.Dest.(type) {
  3988  		default:
  3989  			return errors.New("unknown NameValueCheck OUTPUT type")
  3990  		case *string:
  3991  			*ov = "from-server"
  3992  			nv.Value = "OUT:*string"
  3993  		}
  3994  		return nil
  3995  	case decimalInt, []int64:
  3996  		return nil
  3997  	case doNotInclude:
  3998  		return driver.ErrRemoveArgument
  3999  	}
  4000  }
  4001  
  4002  func TestNamedValueChecker(t *testing.T) {
  4003  	Register("NamedValueCheck", &nvcDriver{})
  4004  	db, err := Open("NamedValueCheck", "")
  4005  	if err != nil {
  4006  		t.Fatal(err)
  4007  	}
  4008  	defer db.Close()
  4009  
  4010  	ctx, cancel := context.WithCancel(context.Background())
  4011  	defer cancel()
  4012  
  4013  	_, err = db.ExecContext(ctx, "WIPE")
  4014  	if err != nil {
  4015  		t.Fatal("exec wipe", err)
  4016  	}
  4017  
  4018  	_, err = db.ExecContext(ctx, "CREATE|keys|dec1=any,str1=string,out1=string,array1=any")
  4019  	if err != nil {
  4020  		t.Fatal("exec create", err)
  4021  	}
  4022  
  4023  	o1 := ""
  4024  	_, err = db.ExecContext(ctx, "INSERT|keys|dec1=?A,str1=?,out1=?O1,array1=?", Named("A", decimalInt{123}), "hello", Named("O1", Out{Dest: &o1}), []int64{42, 128, 707}, doNotInclude{})
  4025  	if err != nil {
  4026  		t.Fatal("exec insert", err)
  4027  	}
  4028  	var (
  4029  		str1 string
  4030  		dec1 decimalInt
  4031  		arr1 []int64
  4032  	)
  4033  	err = db.QueryRowContext(ctx, "SELECT|keys|dec1,str1,array1|").Scan(&dec1, &str1, &arr1)
  4034  	if err != nil {
  4035  		t.Fatal("select", err)
  4036  	}
  4037  
  4038  	list := []struct{ got, want interface{} }{
  4039  		{o1, "from-server"},
  4040  		{dec1, decimalInt{123}},
  4041  		{str1, "hello"},
  4042  		{arr1, []int64{42, 128, 707}},
  4043  	}
  4044  
  4045  	for index, item := range list {
  4046  		if !reflect.DeepEqual(item.got, item.want) {
  4047  			t.Errorf("got %#v wanted %#v for index %d", item.got, item.want, index)
  4048  		}
  4049  	}
  4050  }
  4051  
  4052  func TestNamedValueCheckerSkip(t *testing.T) {
  4053  	Register("NamedValueCheckSkip", &nvcDriver{skipNamedValueCheck: true})
  4054  	db, err := Open("NamedValueCheckSkip", "")
  4055  	if err != nil {
  4056  		t.Fatal(err)
  4057  	}
  4058  	defer db.Close()
  4059  
  4060  	ctx, cancel := context.WithCancel(context.Background())
  4061  	defer cancel()
  4062  
  4063  	_, err = db.ExecContext(ctx, "WIPE")
  4064  	if err != nil {
  4065  		t.Fatal("exec wipe", err)
  4066  	}
  4067  
  4068  	_, err = db.ExecContext(ctx, "CREATE|keys|dec1=any")
  4069  	if err != nil {
  4070  		t.Fatal("exec create", err)
  4071  	}
  4072  
  4073  	_, err = db.ExecContext(ctx, "INSERT|keys|dec1=?A", Named("A", decimalInt{123}))
  4074  	if err == nil {
  4075  		t.Fatalf("expected error with bad argument, got %v", err)
  4076  	}
  4077  }
  4078  
  4079  func TestOpenConnector(t *testing.T) {
  4080  	Register("testctx", &fakeDriverCtx{})
  4081  	db, err := Open("testctx", "people")
  4082  	if err != nil {
  4083  		t.Fatal(err)
  4084  	}
  4085  	defer db.Close()
  4086  
  4087  	c, ok := db.connector.(*fakeConnector)
  4088  	if !ok {
  4089  		t.Fatal("not using *fakeConnector")
  4090  	}
  4091  
  4092  	if err := db.Close(); err != nil {
  4093  		t.Fatal(err)
  4094  	}
  4095  
  4096  	if !c.closed {
  4097  		t.Fatal("connector is not closed")
  4098  	}
  4099  }
  4100  
  4101  type ctxOnlyDriver struct {
  4102  	fakeDriver
  4103  }
  4104  
  4105  func (d *ctxOnlyDriver) Open(dsn string) (driver.Conn, error) {
  4106  	conn, err := d.fakeDriver.Open(dsn)
  4107  	if err != nil {
  4108  		return nil, err
  4109  	}
  4110  	return &ctxOnlyConn{fc: conn.(*fakeConn)}, nil
  4111  }
  4112  
  4113  var (
  4114  	_ driver.Conn           = &ctxOnlyConn{}
  4115  	_ driver.QueryerContext = &ctxOnlyConn{}
  4116  	_ driver.ExecerContext  = &ctxOnlyConn{}
  4117  )
  4118  
  4119  type ctxOnlyConn struct {
  4120  	fc *fakeConn
  4121  
  4122  	queryCtxCalled bool
  4123  	execCtxCalled  bool
  4124  }
  4125  
  4126  func (c *ctxOnlyConn) Begin() (driver.Tx, error) {
  4127  	return c.fc.Begin()
  4128  }
  4129  
  4130  func (c *ctxOnlyConn) Close() error {
  4131  	return c.fc.Close()
  4132  }
  4133  
  4134  // Prepare is still part of the Conn interface, so while it isn't used
  4135  // must be defined for compatibility.
  4136  func (c *ctxOnlyConn) Prepare(q string) (driver.Stmt, error) {
  4137  	panic("not used")
  4138  }
  4139  
  4140  func (c *ctxOnlyConn) PrepareContext(ctx context.Context, q string) (driver.Stmt, error) {
  4141  	return c.fc.PrepareContext(ctx, q)
  4142  }
  4143  
  4144  func (c *ctxOnlyConn) QueryContext(ctx context.Context, q string, args []driver.NamedValue) (driver.Rows, error) {
  4145  	c.queryCtxCalled = true
  4146  	return c.fc.QueryContext(ctx, q, args)
  4147  }
  4148  
  4149  func (c *ctxOnlyConn) ExecContext(ctx context.Context, q string, args []driver.NamedValue) (driver.Result, error) {
  4150  	c.execCtxCalled = true
  4151  	return c.fc.ExecContext(ctx, q, args)
  4152  }
  4153  
  4154  // TestQueryExecContextOnly ensures drivers only need to implement QueryContext
  4155  // and ExecContext methods.
  4156  func TestQueryExecContextOnly(t *testing.T) {
  4157  	// Ensure connection does not implement non-context interfaces.
  4158  	var connType driver.Conn = &ctxOnlyConn{}
  4159  	if _, ok := connType.(driver.Execer); ok {
  4160  		t.Fatalf("%T must not implement driver.Execer", connType)
  4161  	}
  4162  	if _, ok := connType.(driver.Queryer); ok {
  4163  		t.Fatalf("%T must not implement driver.Queryer", connType)
  4164  	}
  4165  
  4166  	Register("ContextOnly", &ctxOnlyDriver{})
  4167  	db, err := Open("ContextOnly", "")
  4168  	if err != nil {
  4169  		t.Fatal(err)
  4170  	}
  4171  	defer db.Close()
  4172  
  4173  	ctx, cancel := context.WithCancel(context.Background())
  4174  	defer cancel()
  4175  
  4176  	conn, err := db.Conn(ctx)
  4177  	if err != nil {
  4178  		t.Fatal("db.Conn", err)
  4179  	}
  4180  	defer conn.Close()
  4181  	coc := conn.dc.ci.(*ctxOnlyConn)
  4182  	coc.fc.skipDirtySession = true
  4183  
  4184  	_, err = conn.ExecContext(ctx, "WIPE")
  4185  	if err != nil {
  4186  		t.Fatal("exec wipe", err)
  4187  	}
  4188  
  4189  	_, err = conn.ExecContext(ctx, "CREATE|keys|v1=string")
  4190  	if err != nil {
  4191  		t.Fatal("exec create", err)
  4192  	}
  4193  	expectedValue := "value1"
  4194  	_, err = conn.ExecContext(ctx, "INSERT|keys|v1=?", expectedValue)
  4195  	if err != nil {
  4196  		t.Fatal("exec insert", err)
  4197  	}
  4198  	rows, err := conn.QueryContext(ctx, "SELECT|keys|v1|")
  4199  	if err != nil {
  4200  		t.Fatal("query select", err)
  4201  	}
  4202  	v1 := ""
  4203  	for rows.Next() {
  4204  		err = rows.Scan(&v1)
  4205  		if err != nil {
  4206  			t.Fatal("rows scan", err)
  4207  		}
  4208  	}
  4209  	rows.Close()
  4210  
  4211  	if v1 != expectedValue {
  4212  		t.Fatalf("expected %q, got %q", expectedValue, v1)
  4213  	}
  4214  
  4215  	if !coc.execCtxCalled {
  4216  		t.Error("ExecContext not called")
  4217  	}
  4218  	if !coc.queryCtxCalled {
  4219  		t.Error("QueryContext not called")
  4220  	}
  4221  }
  4222  
  4223  type alwaysErrScanner struct{}
  4224  
  4225  var errTestScanWrap = errors.New("errTestScanWrap")
  4226  
  4227  func (alwaysErrScanner) Scan(interface{}) error {
  4228  	return errTestScanWrap
  4229  }
  4230  
  4231  // Issue 38099: Ensure that Rows.Scan properly wraps underlying errors.
  4232  func TestRowsScanProperlyWrapsErrors(t *testing.T) {
  4233  	db := newTestDB(t, "people")
  4234  	defer closeDB(t, db)
  4235  
  4236  	rows, err := db.Query("SELECT|people|age|")
  4237  	if err != nil {
  4238  		t.Fatalf("Query: %v", err)
  4239  	}
  4240  
  4241  	var res alwaysErrScanner
  4242  
  4243  	for rows.Next() {
  4244  		err = rows.Scan(&res)
  4245  		if err == nil {
  4246  			t.Fatal("expecting back an error")
  4247  		}
  4248  		if !errors.Is(err, errTestScanWrap) {
  4249  			t.Fatalf("errors.Is mismatch\n%v\nWant: %v", err, errTestScanWrap)
  4250  		}
  4251  		// Ensure that error substring matching still correctly works.
  4252  		if !strings.Contains(err.Error(), errTestScanWrap.Error()) {
  4253  			t.Fatalf("Error %v does not contain %v", err, errTestScanWrap)
  4254  		}
  4255  	}
  4256  }
  4257  
  4258  // badConn implements a bad driver.Conn, for TestBadDriver.
  4259  // The Exec method panics.
  4260  type badConn struct{}
  4261  
  4262  func (bc badConn) Prepare(query string) (driver.Stmt, error) {
  4263  	return nil, errors.New("badConn Prepare")
  4264  }
  4265  
  4266  func (bc badConn) Close() error {
  4267  	return nil
  4268  }
  4269  
  4270  func (bc badConn) Begin() (driver.Tx, error) {
  4271  	return nil, errors.New("badConn Begin")
  4272  }
  4273  
  4274  func (bc badConn) Exec(query string, args []driver.Value) (driver.Result, error) {
  4275  	panic("badConn.Exec")
  4276  }
  4277  
  4278  // badDriver is a driver.Driver that uses badConn.
  4279  type badDriver struct{}
  4280  
  4281  func (bd badDriver) Open(name string) (driver.Conn, error) {
  4282  	return badConn{}, nil
  4283  }
  4284  
  4285  // Issue 15901.
  4286  func TestBadDriver(t *testing.T) {
  4287  	Register("bad", badDriver{})
  4288  	db, err := Open("bad", "ignored")
  4289  	if err != nil {
  4290  		t.Fatal(err)
  4291  	}
  4292  	defer func() {
  4293  		if r := recover(); r == nil {
  4294  			t.Error("expected panic")
  4295  		} else {
  4296  			if want := "badConn.Exec"; r.(string) != want {
  4297  				t.Errorf("panic was %v, expected %v", r, want)
  4298  			}
  4299  		}
  4300  	}()
  4301  	defer db.Close()
  4302  	db.Exec("ignored")
  4303  }
  4304  
  4305  type pingDriver struct {
  4306  	fails bool
  4307  }
  4308  
  4309  type pingConn struct {
  4310  	badConn
  4311  	driver *pingDriver
  4312  }
  4313  
  4314  var pingError = errors.New("Ping failed")
  4315  
  4316  func (pc pingConn) Ping(ctx context.Context) error {
  4317  	if pc.driver.fails {
  4318  		return pingError
  4319  	}
  4320  	return nil
  4321  }
  4322  
  4323  var _ driver.Pinger = pingConn{}
  4324  
  4325  func (pd *pingDriver) Open(name string) (driver.Conn, error) {
  4326  	return pingConn{driver: pd}, nil
  4327  }
  4328  
  4329  func TestPing(t *testing.T) {
  4330  	driver := &pingDriver{}
  4331  	Register("ping", driver)
  4332  
  4333  	db, err := Open("ping", "ignored")
  4334  	if err != nil {
  4335  		t.Fatal(err)
  4336  	}
  4337  
  4338  	if err := db.Ping(); err != nil {
  4339  		t.Errorf("err was %#v, expected nil", err)
  4340  		return
  4341  	}
  4342  
  4343  	driver.fails = true
  4344  	if err := db.Ping(); err != pingError {
  4345  		t.Errorf("err was %#v, expected pingError", err)
  4346  	}
  4347  }
  4348  
  4349  // Issue 18101.
  4350  func TestTypedString(t *testing.T) {
  4351  	db := newTestDB(t, "people")
  4352  	defer closeDB(t, db)
  4353  
  4354  	type Str string
  4355  	var scanned Str
  4356  
  4357  	err := db.QueryRow("SELECT|people|name|name=?", "Alice").Scan(&scanned)
  4358  	if err != nil {
  4359  		t.Fatal(err)
  4360  	}
  4361  	expected := Str("Alice")
  4362  	if scanned != expected {
  4363  		t.Errorf("expected %+v, got %+v", expected, scanned)
  4364  	}
  4365  }
  4366  
  4367  func BenchmarkConcurrentDBExec(b *testing.B) {
  4368  	b.ReportAllocs()
  4369  	ct := new(concurrentDBExecTest)
  4370  	for i := 0; i < b.N; i++ {
  4371  		doConcurrentTest(b, ct)
  4372  	}
  4373  }
  4374  
  4375  func BenchmarkConcurrentStmtQuery(b *testing.B) {
  4376  	b.ReportAllocs()
  4377  	ct := new(concurrentStmtQueryTest)
  4378  	for i := 0; i < b.N; i++ {
  4379  		doConcurrentTest(b, ct)
  4380  	}
  4381  }
  4382  
  4383  func BenchmarkConcurrentStmtExec(b *testing.B) {
  4384  	b.ReportAllocs()
  4385  	ct := new(concurrentStmtExecTest)
  4386  	for i := 0; i < b.N; i++ {
  4387  		doConcurrentTest(b, ct)
  4388  	}
  4389  }
  4390  
  4391  func BenchmarkConcurrentTxQuery(b *testing.B) {
  4392  	b.ReportAllocs()
  4393  	ct := new(concurrentTxQueryTest)
  4394  	for i := 0; i < b.N; i++ {
  4395  		doConcurrentTest(b, ct)
  4396  	}
  4397  }
  4398  
  4399  func BenchmarkConcurrentTxExec(b *testing.B) {
  4400  	b.ReportAllocs()
  4401  	ct := new(concurrentTxExecTest)
  4402  	for i := 0; i < b.N; i++ {
  4403  		doConcurrentTest(b, ct)
  4404  	}
  4405  }
  4406  
  4407  func BenchmarkConcurrentTxStmtQuery(b *testing.B) {
  4408  	b.ReportAllocs()
  4409  	ct := new(concurrentTxStmtQueryTest)
  4410  	for i := 0; i < b.N; i++ {
  4411  		doConcurrentTest(b, ct)
  4412  	}
  4413  }
  4414  
  4415  func BenchmarkConcurrentTxStmtExec(b *testing.B) {
  4416  	b.ReportAllocs()
  4417  	ct := new(concurrentTxStmtExecTest)
  4418  	for i := 0; i < b.N; i++ {
  4419  		doConcurrentTest(b, ct)
  4420  	}
  4421  }
  4422  
  4423  func BenchmarkConcurrentRandom(b *testing.B) {
  4424  	b.ReportAllocs()
  4425  	ct := new(concurrentRandomTest)
  4426  	for i := 0; i < b.N; i++ {
  4427  		doConcurrentTest(b, ct)
  4428  	}
  4429  }
  4430  
  4431  func BenchmarkManyConcurrentQueries(b *testing.B) {
  4432  	b.ReportAllocs()
  4433  	// To see lock contention in Go 1.4, 16~ cores and 128~ goroutines are required.
  4434  	const parallelism = 16
  4435  
  4436  	db := newTestDB(b, "magicquery")
  4437  	defer closeDB(b, db)
  4438  	db.SetMaxIdleConns(runtime.GOMAXPROCS(0) * parallelism)
  4439  
  4440  	stmt, err := db.Prepare("SELECT|magicquery|op|op=?,millis=?")
  4441  	if err != nil {
  4442  		b.Fatal(err)
  4443  	}
  4444  	defer stmt.Close()
  4445  
  4446  	b.SetParallelism(parallelism)
  4447  	b.RunParallel(func(pb *testing.PB) {
  4448  		for pb.Next() {
  4449  			rows, err := stmt.Query("sleep", 1)
  4450  			if err != nil {
  4451  				b.Error(err)
  4452  				return
  4453  			}
  4454  			rows.Close()
  4455  		}
  4456  	})
  4457  }
  4458  

View as plain text