libgo/go/database/sql/sql_test.go

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