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         "fmt"
   9         "reflect"
  10         "runtime"
  11         "strings"
  12         "sync"
  13         "testing"
  14         "time"
  15 )
  16
  17 func init() {
  18         type dbConn struct {
  19                 db *DB
  20                 c  *driverConn
  21         }
  22         freedFrom := make(map[dbConn]string)
  23         putConnHook = func(db *DB, c *driverConn) {
  24                 for _, oc := range db.freeConn {
  25                         if oc == c {
  26                                 // print before panic, as panic may get lost due to conflicting panic
  27                                 // (all goroutines asleep) elsewhere, since we might not unlock
  28                                 // the mutex in freeConn here.
  29                                 println("double free of conn. conflicts are:\nA) " + freedFrom[dbConn{db, c}] + "\n\nand\nB) " + stack())
  30                                 panic("double free of conn.")
  31                         }
  32                 }
  33                 freedFrom[dbConn{db, c}] = stack()
  34         }
  35 }
  36
  37 const fakeDBName = "foo"
  38
  39 var chrisBirthday = time.Unix(123456789, 0)
  40
  41 type testOrBench interface {
  42         Fatalf(string, ...interface{})
  43         Errorf(string, ...interface{})
  44         Fatal(...interface{})
  45         Error(...interface{})
  46         Logf(string, ...interface{})
  47 }
  48
  49 func newTestDB(t testOrBench, name string) *DB {
  50         db, err := Open("test", fakeDBName)
  51         if err != nil {
  52                 t.Fatalf("Open: %v", err)
  53         }
  54         if _, err := db.Exec("WIPE"); err != nil {
  55                 t.Fatalf("exec wipe: %v", err)
  56         }
  57         if name == "people" {
  58                 exec(t, db, "CREATE|people|name=string,age=int32,photo=blob,dead=bool,bdate=datetime")
  59                 exec(t, db, "INSERT|people|name=Alice,age=?,photo=APHOTO", 1)
  60                 exec(t, db, "INSERT|people|name=Bob,age=?,photo=BPHOTO", 2)
  61                 exec(t, db, "INSERT|people|name=Chris,age=?,photo=CPHOTO,bdate=?", 3, chrisBirthday)
  62         }
  63         if name == "magicquery" {
  64                 // Magic table name and column, known by fakedb_test.go.
  65                 exec(t, db, "CREATE|magicquery|op=string,millis=int32")
  66                 exec(t, db, "INSERT|magicquery|op=sleep,millis=10")
  67         }
  68         return db
  69 }
  70
  71 func exec(t testOrBench, db *DB, query string, args ...interface{}) {
  72         _, err := db.Exec(query, args...)
  73         if err != nil {
  74                 t.Fatalf("Exec of %q: %v", query, err)
  75         }
  76 }
  77
  78 func closeDB(t testOrBench, db *DB) {
  79         if e := recover(); e != nil {
  80                 fmt.Printf("Panic: %v\n", e)
  81                 panic(e)
  82         }
  83         defer setHookpostCloseConn(nil)
  84         setHookpostCloseConn(func(_ *fakeConn, err error) {
  85                 if err != nil {
  86                         t.Errorf("Error closing fakeConn: %v", err)
  87                 }
  88         })
  89         for i, dc := range db.freeConn {
  90                 if n := len(dc.openStmt); n > 0 {
  91                         // Just a sanity check. This is legal in
  92                         // general, but if we make the tests clean up
  93                         // their statements first, then we can safely
  94                         // verify this is always zero here, and any
  95                         // other value is a leak.
  96                         t.Errorf("while closing db, freeConn %d/%d had %d open stmts; want 0", i, len(db.freeConn), n)
  97                 }
  98         }
  99         err := db.Close()
 100         if err != nil {
 101                 t.Fatalf("error closing DB: %v", err)
 102         }
 103 }
 104
 105 // numPrepares assumes that db has exactly 1 idle conn and returns
 106 // its count of calls to Prepare
 107 func numPrepares(t *testing.T, db *DB) int {
 108         if n := len(db.freeConn); n != 1 {
 109                 t.Fatalf("free conns = %d; want 1", n)
 110         }
 111         return db.freeConn[0].ci.(*fakeConn).numPrepare
 112 }
 113
 114 func (db *DB) numDeps() int {
 115         db.mu.Lock()
 116         defer db.mu.Unlock()
 117         return len(db.dep)
 118 }
 119
 120 // Dependencies are closed via a goroutine, so this polls waiting for
 121 // numDeps to fall to want, waiting up to d.
 122 func (db *DB) numDepsPollUntil(want int, d time.Duration) int {
 123         deadline := time.Now().Add(d)
 124         for {
 125                 n := db.numDeps()
 126                 if n <= want || time.Now().After(deadline) {
 127                         return n
 128                 }
 129                 time.Sleep(50 * time.Millisecond)
 130         }
 131 }
 132
 133 func (db *DB) numFreeConns() int {
 134         db.mu.Lock()
 135         defer db.mu.Unlock()
 136         return len(db.freeConn)
 137 }
 138
 139 func (db *DB) dumpDeps(t *testing.T) {
 140         for fc := range db.dep {
 141                 db.dumpDep(t, 0, fc, map[finalCloser]bool{})
 142         }
 143 }
 144
 145 func (db *DB) dumpDep(t *testing.T, depth int, dep finalCloser, seen map[finalCloser]bool) {
 146         seen[dep] = true
 147         indent := strings.Repeat("  ", depth)
 148         ds := db.dep[dep]
 149         for k := range ds {
 150                 t.Logf("%s%T (%p) waiting for -> %T (%p)", indent, dep, dep, k, k)
 151                 if fc, ok := k.(finalCloser); ok {
 152                         if !seen[fc] {
 153                                 db.dumpDep(t, depth+1, fc, seen)
 154                         }
 155                 }
 156         }
 157 }
 158
 159 func TestQuery(t *testing.T) {
 160         db := newTestDB(t, "people")
 161         defer closeDB(t, db)
 162         prepares0 := numPrepares(t, db)
 163         rows, err := db.Query("SELECT|people|age,name|")
 164         if err != nil {
 165                 t.Fatalf("Query: %v", err)
 166         }
 167         type row struct {
 168                 age  int
 169                 name string
 170         }
 171         got := []row{}
 172         for rows.Next() {
 173                 var r row
 174                 err = rows.Scan(&r.age, &r.name)
 175                 if err != nil {
 176                         t.Fatalf("Scan: %v", err)
 177                 }
 178                 got = append(got, r)
 179         }
 180         err = rows.Err()
 181         if err != nil {
 182                 t.Fatalf("Err: %v", err)
 183         }
 184         want := []row{
 185                 {age: 1, name: "Alice"},
 186                 {age: 2, name: "Bob"},
 187                 {age: 3, name: "Chris"},
 188         }
 189         if !reflect.DeepEqual(got, want) {
 190                 t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)
 191         }
 192
 193         // And verify that the final rows.Next() call, which hit EOF,
 194         // also closed the rows connection.
 195         if n := db.numFreeConns(); n != 1 {
 196                 t.Fatalf("free conns after query hitting EOF = %d; want 1", n)
 197         }
 198         if prepares := numPrepares(t, db) - prepares0; prepares != 1 {
 199                 t.Errorf("executed %d Prepare statements; want 1", prepares)
 200         }
 201 }
 202
 203 func TestByteOwnership(t *testing.T) {
 204         db := newTestDB(t, "people")
 205         defer closeDB(t, db)
 206         rows, err := db.Query("SELECT|people|name,photo|")
 207         if err != nil {
 208                 t.Fatalf("Query: %v", err)
 209         }
 210         type row struct {
 211                 name  []byte
 212                 photo RawBytes
 213         }
 214         got := []row{}
 215         for rows.Next() {
 216                 var r row
 217                 err = rows.Scan(&r.name, &r.photo)
 218                 if err != nil {
 219                         t.Fatalf("Scan: %v", err)
 220                 }
 221                 got = append(got, r)
 222         }
 223         corruptMemory := []byte("\xffPHOTO")
 224         want := []row{
 225                 {name: []byte("Alice"), photo: corruptMemory},
 226                 {name: []byte("Bob"), photo: corruptMemory},
 227                 {name: []byte("Chris"), photo: corruptMemory},
 228         }
 229         if !reflect.DeepEqual(got, want) {
 230                 t.Errorf("mismatch.\n got: %#v\nwant: %#v", got, want)
 231         }
 232
 233         var photo RawBytes
 234         err = db.QueryRow("SELECT|people|photo|name=?", "Alice").Scan(&photo)
 235         if err == nil {
 236                 t.Error("want error scanning into RawBytes from QueryRow")
 237         }
 238 }
 239
 240 func TestRowsColumns(t *testing.T) {
 241         db := newTestDB(t, "people")
 242         defer closeDB(t, db)
 243         rows, err := db.Query("SELECT|people|age,name|")
 244         if err != nil {
 245                 t.Fatalf("Query: %v", err)
 246         }
 247         cols, err := rows.Columns()
 248         if err != nil {
 249                 t.Fatalf("Columns: %v", err)
 250         }
 251         want := []string{"age", "name"}
 252         if !reflect.DeepEqual(cols, want) {
 253                 t.Errorf("got %#v; want %#v", cols, want)
 254         }
 255 }
 256
 257 func TestQueryRow(t *testing.T) {
 258         db := newTestDB(t, "people")
 259         defer closeDB(t, db)
 260         var name string
 261         var age int
 262         var birthday time.Time
 263
 264         err := db.QueryRow("SELECT|people|age,name|age=?", 3).Scan(&age)
 265         if err == nil || !strings.Contains(err.Error(), "expected 2 destination arguments") {
 266                 t.Errorf("expected error from wrong number of arguments; actually got: %v", err)
 267         }
 268
 269         err = db.QueryRow("SELECT|people|bdate|age=?", 3).Scan(&birthday)
 270         if err != nil || !birthday.Equal(chrisBirthday) {
 271                 t.Errorf("chris birthday = %v, err = %v; want %v", birthday, err, chrisBirthday)
 272         }
 273
 274         err = db.QueryRow("SELECT|people|age,name|age=?", 2).Scan(&age, &name)
 275         if err != nil {
 276                 t.Fatalf("age QueryRow+Scan: %v", err)
 277         }
 278         if name != "Bob" {
 279                 t.Errorf("expected name Bob, got %q", name)
 280         }
 281         if age != 2 {
 282                 t.Errorf("expected age 2, got %d", age)
 283         }
 284
 285         err = db.QueryRow("SELECT|people|age,name|name=?", "Alice").Scan(&age, &name)
 286         if err != nil {
 287                 t.Fatalf("name QueryRow+Scan: %v", err)
 288         }
 289         if name != "Alice" {
 290                 t.Errorf("expected name Alice, got %q", name)
 291         }
 292         if age != 1 {
 293                 t.Errorf("expected age 1, got %d", age)
 294         }
 295
 296         var photo []byte
 297         err = db.QueryRow("SELECT|people|photo|name=?", "Alice").Scan(&photo)
 298         if err != nil {
 299                 t.Fatalf("photo QueryRow+Scan: %v", err)
 300         }
 301         want := []byte("APHOTO")
 302         if !reflect.DeepEqual(photo, want) {
 303                 t.Errorf("photo = %q; want %q", photo, want)
 304         }
 305 }
 306
 307 func TestStatementErrorAfterClose(t *testing.T) {
 308         db := newTestDB(t, "people")
 309         defer closeDB(t, db)
 310         stmt, err := db.Prepare("SELECT|people|age|name=?")
 311         if err != nil {
 312                 t.Fatalf("Prepare: %v", err)
 313         }
 314         err = stmt.Close()
 315         if err != nil {
 316                 t.Fatalf("Close: %v", err)
 317         }
 318         var name string
 319         err = stmt.QueryRow("foo").Scan(&name)
 320         if err == nil {
 321                 t.Errorf("expected error from QueryRow.Scan after Stmt.Close")
 322         }
 323 }
 324
 325 func TestStatementQueryRow(t *testing.T) {
 326         db := newTestDB(t, "people")
 327         defer closeDB(t, db)
 328         stmt, err := db.Prepare("SELECT|people|age|name=?")
 329         if err != nil {
 330                 t.Fatalf("Prepare: %v", err)
 331         }
 332         defer stmt.Close()
 333         var age int
 334         for n, tt := range []struct {
 335                 name string
 336                 want int
 337         }{
 338                 {"Alice", 1},
 339                 {"Bob", 2},
 340                 {"Chris", 3},
 341         } {
 342                 if err := stmt.QueryRow(tt.name).Scan(&age); err != nil {
 343                         t.Errorf("%d: on %q, QueryRow/Scan: %v", n, tt.name, err)
 344                 } else if age != tt.want {
 345                         t.Errorf("%d: age=%d, want %d", n, age, tt.want)
 346                 }
 347         }
 348
 349 }
 350
 351 // golang.org/issue/3734
 352 func TestStatementQueryRowConcurrent(t *testing.T) {
 353         db := newTestDB(t, "people")
 354         defer closeDB(t, db)
 355         stmt, err := db.Prepare("SELECT|people|age|name=?")
 356         if err != nil {
 357                 t.Fatalf("Prepare: %v", err)
 358         }
 359         defer stmt.Close()
 360
 361         const n = 10
 362         ch := make(chan error, n)
 363         for i := 0; i < n; i++ {
 364                 go func() {
 365                         var age int
 366                         err := stmt.QueryRow("Alice").Scan(&age)
 367                         if err == nil && age != 1 {
 368                                 err = fmt.Errorf("unexpected age %d", age)
 369                         }
 370                         ch <- err
 371                 }()
 372         }
 373         for i := 0; i < n; i++ {
 374                 if err := <-ch; err != nil {
 375                         t.Error(err)
 376                 }
 377         }
 378 }
 379
 380 // just a test of fakedb itself
 381 func TestBogusPreboundParameters(t *testing.T) {
 382         db := newTestDB(t, "foo")
 383         defer closeDB(t, db)
 384         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
 385         _, err := db.Prepare("INSERT|t1|name=?,age=bogusconversion")
 386         if err == nil {
 387                 t.Fatalf("expected error")
 388         }
 389         if err.Error() != `fakedb: invalid conversion to int32 from "bogusconversion"` {
 390                 t.Errorf("unexpected error: %v", err)
 391         }
 392 }
 393
 394 func TestExec(t *testing.T) {
 395         db := newTestDB(t, "foo")
 396         defer closeDB(t, db)
 397         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
 398         stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
 399         if err != nil {
 400                 t.Errorf("Stmt, err = %v, %v", stmt, err)
 401         }
 402         defer stmt.Close()
 403
 404         type execTest struct {
 405                 args    []interface{}
 406                 wantErr string
 407         }
 408         execTests := []execTest{
 409                 // Okay:
 410                 {[]interface{}{"Brad", 31}, ""},
 411                 {[]interface{}{"Brad", int64(31)}, ""},
 412                 {[]interface{}{"Bob", "32"}, ""},
 413                 {[]interface{}{7, 9}, ""},
 414
 415                 // Invalid conversions:
 416                 {[]interface{}{"Brad", int64(0xFFFFFFFF)}, "sql: converting argument #1's type: sql/driver: value 4294967295 overflows int32"},
 417                 {[]interface{}{"Brad", "strconv fail"}, "sql: converting argument #1's type: sql/driver: value \"strconv fail\" can't be converted to int32"},
 418
 419                 // Wrong number of args:
 420                 {[]interface{}{}, "sql: expected 2 arguments, got 0"},
 421                 {[]interface{}{1, 2, 3}, "sql: expected 2 arguments, got 3"},
 422         }
 423         for n, et := range execTests {
 424                 _, err := stmt.Exec(et.args...)
 425                 errStr := ""
 426                 if err != nil {
 427                         errStr = err.Error()
 428                 }
 429                 if errStr != et.wantErr {
 430                         t.Errorf("stmt.Execute #%d: for %v, got error %q, want error %q",
 431                                 n, et.args, errStr, et.wantErr)
 432                 }
 433         }
 434 }
 435
 436 func TestTxStmt(t *testing.T) {
 437         db := newTestDB(t, "")
 438         defer closeDB(t, db)
 439         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
 440         stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
 441         if err != nil {
 442                 t.Fatalf("Stmt, err = %v, %v", stmt, err)
 443         }
 444         defer stmt.Close()
 445         tx, err := db.Begin()
 446         if err != nil {
 447                 t.Fatalf("Begin = %v", err)
 448         }
 449         txs := tx.Stmt(stmt)
 450         defer txs.Close()
 451         _, err = txs.Exec("Bobby", 7)
 452         if err != nil {
 453                 t.Fatalf("Exec = %v", err)
 454         }
 455         err = tx.Commit()
 456         if err != nil {
 457                 t.Fatalf("Commit = %v", err)
 458         }
 459 }
 460
 461 // Issue: http://golang.org/issue/2784
 462 // This test didn't fail before because we got luckly with the fakedb driver.
 463 // It was failing, and now not, in github.com/bradfitz/go-sql-test
 464 func TestTxQuery(t *testing.T) {
 465         db := newTestDB(t, "")
 466         defer closeDB(t, db)
 467         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
 468         exec(t, db, "INSERT|t1|name=Alice")
 469
 470         tx, err := db.Begin()
 471         if err != nil {
 472                 t.Fatal(err)
 473         }
 474         defer tx.Rollback()
 475
 476         r, err := tx.Query("SELECT|t1|name|")
 477         if err != nil {
 478                 t.Fatal(err)
 479         }
 480         defer r.Close()
 481
 482         if !r.Next() {
 483                 if r.Err() != nil {
 484                         t.Fatal(r.Err())
 485                 }
 486                 t.Fatal("expected one row")
 487         }
 488
 489         var x string
 490         err = r.Scan(&x)
 491         if err != nil {
 492                 t.Fatal(err)
 493         }
 494 }
 495
 496 func TestTxQueryInvalid(t *testing.T) {
 497         db := newTestDB(t, "")
 498         defer closeDB(t, db)
 499
 500         tx, err := db.Begin()
 501         if err != nil {
 502                 t.Fatal(err)
 503         }
 504         defer tx.Rollback()
 505
 506         _, err = tx.Query("SELECT|t1|name|")
 507         if err == nil {
 508                 t.Fatal("Error expected")
 509         }
 510 }
 511
 512 // Tests fix for issue 4433, that retries in Begin happen when
 513 // conn.Begin() returns ErrBadConn
 514 func TestTxErrBadConn(t *testing.T) {
 515         db, err := Open("test", fakeDBName+";badConn")
 516         if err != nil {
 517                 t.Fatalf("Open: %v", err)
 518         }
 519         if _, err := db.Exec("WIPE"); err != nil {
 520                 t.Fatalf("exec wipe: %v", err)
 521         }
 522         defer closeDB(t, db)
 523         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
 524         stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
 525         if err != nil {
 526                 t.Fatalf("Stmt, err = %v, %v", stmt, err)
 527         }
 528         defer stmt.Close()
 529         tx, err := db.Begin()
 530         if err != nil {
 531                 t.Fatalf("Begin = %v", err)
 532         }
 533         txs := tx.Stmt(stmt)
 534         defer txs.Close()
 535         _, err = txs.Exec("Bobby", 7)
 536         if err != nil {
 537                 t.Fatalf("Exec = %v", err)
 538         }
 539         err = tx.Commit()
 540         if err != nil {
 541                 t.Fatalf("Commit = %v", err)
 542         }
 543 }
 544
 545 // Tests fix for issue 2542, that we release a lock when querying on
 546 // a closed connection.
 547 func TestIssue2542Deadlock(t *testing.T) {
 548         db := newTestDB(t, "people")
 549         closeDB(t, db)
 550         for i := 0; i < 2; i++ {
 551                 _, err := db.Query("SELECT|people|age,name|")
 552                 if err == nil {
 553                         t.Fatalf("expected error")
 554                 }
 555         }
 556 }
 557
 558 // From golang.org/issue/3865
 559 func TestCloseStmtBeforeRows(t *testing.T) {
 560         db := newTestDB(t, "people")
 561         defer closeDB(t, db)
 562
 563         s, err := db.Prepare("SELECT|people|name|")
 564         if err != nil {
 565                 t.Fatal(err)
 566         }
 567
 568         r, err := s.Query()
 569         if err != nil {
 570                 s.Close()
 571                 t.Fatal(err)
 572         }
 573
 574         err = s.Close()
 575         if err != nil {
 576                 t.Fatal(err)
 577         }
 578
 579         r.Close()
 580 }
 581
 582 // Tests fix for issue 2788, that we bind nil to a []byte if the
 583 // value in the column is sql null
 584 func TestNullByteSlice(t *testing.T) {
 585         db := newTestDB(t, "")
 586         defer closeDB(t, db)
 587         exec(t, db, "CREATE|t|id=int32,name=nullstring")
 588         exec(t, db, "INSERT|t|id=10,name=?", nil)
 589
 590         var name []byte
 591
 592         err := db.QueryRow("SELECT|t|name|id=?", 10).Scan(&name)
 593         if err != nil {
 594                 t.Fatal(err)
 595         }
 596         if name != nil {
 597                 t.Fatalf("name []byte should be nil for null column value, got: %#v", name)
 598         }
 599
 600         exec(t, db, "INSERT|t|id=11,name=?", "bob")
 601         err = db.QueryRow("SELECT|t|name|id=?", 11).Scan(&name)
 602         if err != nil {
 603                 t.Fatal(err)
 604         }
 605         if string(name) != "bob" {
 606                 t.Fatalf("name []byte should be bob, got: %q", string(name))
 607         }
 608 }
 609
 610 func TestPointerParamsAndScans(t *testing.T) {
 611         db := newTestDB(t, "")
 612         defer closeDB(t, db)
 613         exec(t, db, "CREATE|t|id=int32,name=nullstring")
 614
 615         bob := "bob"
 616         var name *string
 617
 618         name = &bob
 619         exec(t, db, "INSERT|t|id=10,name=?", name)
 620         name = nil
 621         exec(t, db, "INSERT|t|id=20,name=?", name)
 622
 623         err := db.QueryRow("SELECT|t|name|id=?", 10).Scan(&name)
 624         if err != nil {
 625                 t.Fatalf("querying id 10: %v", err)
 626         }
 627         if name == nil {
 628                 t.Errorf("id 10's name = nil; want bob")
 629         } else if *name != "bob" {
 630                 t.Errorf("id 10's name = %q; want bob", *name)
 631         }
 632
 633         err = db.QueryRow("SELECT|t|name|id=?", 20).Scan(&name)
 634         if err != nil {
 635                 t.Fatalf("querying id 20: %v", err)
 636         }
 637         if name != nil {
 638                 t.Errorf("id 20 = %q; want nil", *name)
 639         }
 640 }
 641
 642 func TestQueryRowClosingStmt(t *testing.T) {
 643         db := newTestDB(t, "people")
 644         defer closeDB(t, db)
 645         var name string
 646         var age int
 647         err := db.QueryRow("SELECT|people|age,name|age=?", 3).Scan(&age, &name)
 648         if err != nil {
 649                 t.Fatal(err)
 650         }
 651         if len(db.freeConn) != 1 {
 652                 t.Fatalf("expected 1 free conn")
 653         }
 654         fakeConn := db.freeConn[0].ci.(*fakeConn)
 655         if made, closed := fakeConn.stmtsMade, fakeConn.stmtsClosed; made != closed {
 656                 t.Errorf("statement close mismatch: made %d, closed %d", made, closed)
 657         }
 658 }
 659
 660 type nullTestRow struct {
 661         nullParam    interface{}
 662         notNullParam interface{}
 663         scanNullVal  interface{}
 664 }
 665
 666 type nullTestSpec struct {
 667         nullType    string
 668         notNullType string
 669         rows        [6]nullTestRow
 670 }
 671
 672 func TestNullStringParam(t *testing.T) {
 673         spec := nullTestSpec{"nullstring", "string", [6]nullTestRow{
 674                 {NullString{"aqua", true}, "", NullString{"aqua", true}},
 675                 {NullString{"brown", false}, "", NullString{"", false}},
 676                 {"chartreuse", "", NullString{"chartreuse", true}},
 677                 {NullString{"darkred", true}, "", NullString{"darkred", true}},
 678                 {NullString{"eel", false}, "", NullString{"", false}},
 679                 {"foo", NullString{"black", false}, nil},
 680         }}
 681         nullTestRun(t, spec)
 682 }
 683
 684 func TestNullInt64Param(t *testing.T) {
 685         spec := nullTestSpec{"nullint64", "int64", [6]nullTestRow{
 686                 {NullInt64{31, true}, 1, NullInt64{31, true}},
 687                 {NullInt64{-22, false}, 1, NullInt64{0, false}},
 688                 {22, 1, NullInt64{22, true}},
 689                 {NullInt64{33, true}, 1, NullInt64{33, true}},
 690                 {NullInt64{222, false}, 1, NullInt64{0, false}},
 691                 {0, NullInt64{31, false}, nil},
 692         }}
 693         nullTestRun(t, spec)
 694 }
 695
 696 func TestNullFloat64Param(t *testing.T) {
 697         spec := nullTestSpec{"nullfloat64", "float64", [6]nullTestRow{
 698                 {NullFloat64{31.2, true}, 1, NullFloat64{31.2, true}},
 699                 {NullFloat64{13.1, false}, 1, NullFloat64{0, false}},
 700                 {-22.9, 1, NullFloat64{-22.9, true}},
 701                 {NullFloat64{33.81, true}, 1, NullFloat64{33.81, true}},
 702                 {NullFloat64{222, false}, 1, NullFloat64{0, false}},
 703                 {10, NullFloat64{31.2, false}, nil},
 704         }}
 705         nullTestRun(t, spec)
 706 }
 707
 708 func TestNullBoolParam(t *testing.T) {
 709         spec := nullTestSpec{"nullbool", "bool", [6]nullTestRow{
 710                 {NullBool{false, true}, true, NullBool{false, true}},
 711                 {NullBool{true, false}, false, NullBool{false, false}},
 712                 {true, true, NullBool{true, true}},
 713                 {NullBool{true, true}, false, NullBool{true, true}},
 714                 {NullBool{true, false}, true, NullBool{false, false}},
 715                 {true, NullBool{true, false}, nil},
 716         }}
 717         nullTestRun(t, spec)
 718 }
 719
 720 func nullTestRun(t *testing.T, spec nullTestSpec) {
 721         db := newTestDB(t, "")
 722         defer closeDB(t, db)
 723         exec(t, db, fmt.Sprintf("CREATE|t|id=int32,name=string,nullf=%s,notnullf=%s", spec.nullType, spec.notNullType))
 724
 725         // Inserts with db.Exec:
 726         exec(t, db, "INSERT|t|id=?,name=?,nullf=?,notnullf=?", 1, "alice", spec.rows[0].nullParam, spec.rows[0].notNullParam)
 727         exec(t, db, "INSERT|t|id=?,name=?,nullf=?,notnullf=?", 2, "bob", spec.rows[1].nullParam, spec.rows[1].notNullParam)
 728
 729         // Inserts with a prepared statement:
 730         stmt, err := db.Prepare("INSERT|t|id=?,name=?,nullf=?,notnullf=?")
 731         if err != nil {
 732                 t.Fatalf("prepare: %v", err)
 733         }
 734         defer stmt.Close()
 735         if _, err := stmt.Exec(3, "chris", spec.rows[2].nullParam, spec.rows[2].notNullParam); err != nil {
 736                 t.Errorf("exec insert chris: %v", err)
 737         }
 738         if _, err := stmt.Exec(4, "dave", spec.rows[3].nullParam, spec.rows[3].notNullParam); err != nil {
 739                 t.Errorf("exec insert dave: %v", err)
 740         }
 741         if _, err := stmt.Exec(5, "eleanor", spec.rows[4].nullParam, spec.rows[4].notNullParam); err != nil {
 742                 t.Errorf("exec insert eleanor: %v", err)
 743         }
 744
 745         // Can't put null val into non-null col
 746         if _, err := stmt.Exec(6, "bob", spec.rows[5].nullParam, spec.rows[5].notNullParam); err == nil {
 747                 t.Errorf("expected error inserting nil val with prepared statement Exec")
 748         }
 749
 750         _, err = db.Exec("INSERT|t|id=?,name=?,nullf=?", 999, nil, nil)
 751         if err == nil {
 752                 // TODO: this test fails, but it's just because
 753                 // fakeConn implements the optional Execer interface,
 754                 // so arguably this is the correct behavior.  But
 755                 // maybe I should flesh out the fakeConn.Exec
 756                 // implementation so this properly fails.
 757                 // t.Errorf("expected error inserting nil name with Exec")
 758         }
 759
 760         paramtype := reflect.TypeOf(spec.rows[0].nullParam)
 761         bindVal := reflect.New(paramtype).Interface()
 762
 763         for i := 0; i < 5; i++ {
 764                 id := i + 1
 765                 if err := db.QueryRow("SELECT|t|nullf|id=?", id).Scan(bindVal); err != nil {
 766                         t.Errorf("id=%d Scan: %v", id, err)
 767                 }
 768                 bindValDeref := reflect.ValueOf(bindVal).Elem().Interface()
 769                 if !reflect.DeepEqual(bindValDeref, spec.rows[i].scanNullVal) {
 770                         t.Errorf("id=%d got %#v, want %#v", id, bindValDeref, spec.rows[i].scanNullVal)
 771                 }
 772         }
 773 }
 774
 775 // golang.org/issue/4859
 776 func TestQueryRowNilScanDest(t *testing.T) {
 777         db := newTestDB(t, "people")
 778         defer closeDB(t, db)
 779         var name *string // nil pointer
 780         err := db.QueryRow("SELECT|people|name|").Scan(name)
 781         want := "sql: Scan error on column index 0: destination pointer is nil"
 782         if err == nil || err.Error() != want {
 783                 t.Errorf("error = %q; want %q", err.Error(), want)
 784         }
 785 }
 786
 787 func TestIssue4902(t *testing.T) {
 788         db := newTestDB(t, "people")
 789         defer closeDB(t, db)
 790
 791         driver := db.driver.(*fakeDriver)
 792         opens0 := driver.openCount
 793
 794         var stmt *Stmt
 795         var err error
 796         for i := 0; i < 10; i++ {
 797                 stmt, err = db.Prepare("SELECT|people|name|")
 798                 if err != nil {
 799                         t.Fatal(err)
 800                 }
 801                 err = stmt.Close()
 802                 if err != nil {
 803                         t.Fatal(err)
 804                 }
 805         }
 806
 807         opens := driver.openCount - opens0
 808         if opens > 1 {
 809                 t.Errorf("opens = %d; want <= 1", opens)
 810                 t.Logf("db = %#v", db)
 811                 t.Logf("driver = %#v", driver)
 812                 t.Logf("stmt = %#v", stmt)
 813         }
 814 }
 815
 816 // Issue 3857
 817 // This used to deadlock.
 818 func TestSimultaneousQueries(t *testing.T) {
 819         db := newTestDB(t, "people")
 820         defer closeDB(t, db)
 821
 822         tx, err := db.Begin()
 823         if err != nil {
 824                 t.Fatal(err)
 825         }
 826         defer tx.Rollback()
 827
 828         r1, err := tx.Query("SELECT|people|name|")
 829         if err != nil {
 830                 t.Fatal(err)
 831         }
 832         defer r1.Close()
 833
 834         r2, err := tx.Query("SELECT|people|name|")
 835         if err != nil {
 836                 t.Fatal(err)
 837         }
 838         defer r2.Close()
 839 }
 840
 841 func TestMaxIdleConns(t *testing.T) {
 842         db := newTestDB(t, "people")
 843         defer closeDB(t, db)
 844
 845         tx, err := db.Begin()
 846         if err != nil {
 847                 t.Fatal(err)
 848         }
 849         tx.Commit()
 850         if got := len(db.freeConn); got != 1 {
 851                 t.Errorf("freeConns = %d; want 1", got)
 852         }
 853
 854         db.SetMaxIdleConns(0)
 855
 856         if got := len(db.freeConn); got != 0 {
 857                 t.Errorf("freeConns after set to zero = %d; want 0", got)
 858         }
 859
 860         tx, err = db.Begin()
 861         if err != nil {
 862                 t.Fatal(err)
 863         }
 864         tx.Commit()
 865         if got := len(db.freeConn); got != 0 {
 866                 t.Errorf("freeConns = %d; want 0", got)
 867         }
 868 }
 869
 870 // golang.org/issue/5323
 871 func TestStmtCloseDeps(t *testing.T) {
 872         if testing.Short() {
 873                 t.Skip("skipping in short mode")
 874         }
 875         defer setHookpostCloseConn(nil)
 876         setHookpostCloseConn(func(_ *fakeConn, err error) {
 877                 if err != nil {
 878                         t.Errorf("Error closing fakeConn: %v", err)
 879                 }
 880         })
 881
 882         db := newTestDB(t, "magicquery")
 883         defer closeDB(t, db)
 884
 885         driver := db.driver.(*fakeDriver)
 886
 887         driver.mu.Lock()
 888         opens0 := driver.openCount
 889         closes0 := driver.closeCount
 890         driver.mu.Unlock()
 891         openDelta0 := opens0 - closes0
 892
 893         stmt, err := db.Prepare("SELECT|magicquery|op|op=?,millis=?")
 894         if err != nil {
 895                 t.Fatal(err)
 896         }
 897
 898         // Start 50 parallel slow queries.
 899         const (
 900                 nquery      = 50
 901                 sleepMillis = 25
 902                 nbatch      = 2
 903         )
 904         var wg sync.WaitGroup
 905         for batch := 0; batch < nbatch; batch++ {
 906                 for i := 0; i < nquery; i++ {
 907                         wg.Add(1)
 908                         go func() {
 909                                 defer wg.Done()
 910                                 var op string
 911                                 if err := stmt.QueryRow("sleep", sleepMillis).Scan(&op); err != nil && err != ErrNoRows {
 912                                         t.Error(err)
 913                                 }
 914                         }()
 915                 }
 916                 // Sleep for twice the expected length of time for the
 917                 // batch of 50 queries above to finish before starting
 918                 // the next round.
 919                 time.Sleep(2 * sleepMillis * time.Millisecond)
 920         }
 921         wg.Wait()
 922
 923         if g, w := db.numFreeConns(), 2; g != w {
 924                 t.Errorf("free conns = %d; want %d", g, w)
 925         }
 926
 927         if n := db.numDepsPollUntil(4, time.Second); n > 4 {
 928                 t.Errorf("number of dependencies = %d; expected <= 4", n)
 929                 db.dumpDeps(t)
 930         }
 931
 932         driver.mu.Lock()
 933         opens := driver.openCount - opens0
 934         closes := driver.closeCount - closes0
 935         driver.mu.Unlock()
 936         openDelta := (driver.openCount - driver.closeCount) - openDelta0
 937
 938         if openDelta > 2 {
 939                 t.Logf("open calls = %d", opens)
 940                 t.Logf("close calls = %d", closes)
 941                 t.Logf("open delta = %d", openDelta)
 942                 t.Errorf("db connections opened = %d; want <= 2", openDelta)
 943                 db.dumpDeps(t)
 944         }
 945
 946         if len(stmt.css) > nquery {
 947                 t.Errorf("len(stmt.css) = %d; want <= %d", len(stmt.css), nquery)
 948         }
 949
 950         if err := stmt.Close(); err != nil {
 951                 t.Fatal(err)
 952         }
 953
 954         if g, w := db.numFreeConns(), 2; g != w {
 955                 t.Errorf("free conns = %d; want %d", g, w)
 956         }
 957
 958         if n := db.numDepsPollUntil(2, time.Second); n > 2 {
 959                 t.Errorf("number of dependencies = %d; expected <= 2", n)
 960                 db.dumpDeps(t)
 961         }
 962
 963         db.SetMaxIdleConns(0)
 964
 965         if g, w := db.numFreeConns(), 0; g != w {
 966                 t.Errorf("free conns = %d; want %d", g, w)
 967         }
 968
 969         if n := db.numDepsPollUntil(0, time.Second); n > 0 {
 970                 t.Errorf("number of dependencies = %d; expected 0", n)
 971                 db.dumpDeps(t)
 972         }
 973 }
 974
 975 // golang.org/issue/5046
 976 func TestCloseConnBeforeStmts(t *testing.T) {
 977         db := newTestDB(t, "people")
 978         defer closeDB(t, db)
 979
 980         defer setHookpostCloseConn(nil)
 981         setHookpostCloseConn(func(_ *fakeConn, err error) {
 982                 if err != nil {
 983                         t.Errorf("Error closing fakeConn: %v; from %s", err, stack())
 984                         db.dumpDeps(t)
 985                         t.Errorf("DB = %#v", db)
 986                 }
 987         })
 988
 989         stmt, err := db.Prepare("SELECT|people|name|")
 990         if err != nil {
 991                 t.Fatal(err)
 992         }
 993
 994         if len(db.freeConn) != 1 {
 995                 t.Fatalf("expected 1 freeConn; got %d", len(db.freeConn))
 996         }
 997         dc := db.freeConn[0]
 998         if dc.closed {
 999                 t.Errorf("conn shouldn't be closed")
1000         }
1001
1002         if n := len(dc.openStmt); n != 1 {
1003                 t.Errorf("driverConn num openStmt = %d; want 1", n)
1004         }
1005         err = db.Close()
1006         if err != nil {
1007                 t.Errorf("db Close = %v", err)
1008         }
1009         if !dc.closed {
1010                 t.Errorf("after db.Close, driverConn should be closed")
1011         }
1012         if n := len(dc.openStmt); n != 0 {
1013                 t.Errorf("driverConn num openStmt = %d; want 0", n)
1014         }
1015
1016         err = stmt.Close()
1017         if err != nil {
1018                 t.Errorf("Stmt close = %v", err)
1019         }
1020
1021         if !dc.closed {
1022                 t.Errorf("conn should be closed")
1023         }
1024         if dc.ci != nil {
1025                 t.Errorf("after Stmt Close, driverConn's Conn interface should be nil")
1026         }
1027 }
1028
1029 // golang.org/issue/5283: don't release the Rows' connection in Close
1030 // before calling Stmt.Close.
1031 func TestRowsCloseOrder(t *testing.T) {
1032         db := newTestDB(t, "people")
1033         defer closeDB(t, db)
1034
1035         db.SetMaxIdleConns(0)
1036         setStrictFakeConnClose(t)
1037         defer setStrictFakeConnClose(nil)
1038
1039         rows, err := db.Query("SELECT|people|age,name|")
1040         if err != nil {
1041                 t.Fatal(err)
1042         }
1043         err = rows.Close()
1044         if err != nil {
1045                 t.Fatal(err)
1046         }
1047 }
1048
1049 func manyConcurrentQueries(t testOrBench) {
1050         maxProcs, numReqs := 16, 500
1051         if testing.Short() {
1052                 maxProcs, numReqs = 4, 50
1053         }
1054         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(maxProcs))
1055
1056         db := newTestDB(t, "people")
1057         defer closeDB(t, db)
1058
1059         stmt, err := db.Prepare("SELECT|people|name|")
1060         if err != nil {
1061                 t.Fatal(err)
1062         }
1063         defer stmt.Close()
1064
1065         var wg sync.WaitGroup
1066         wg.Add(numReqs)
1067
1068         reqs := make(chan bool)
1069         defer close(reqs)
1070
1071         for i := 0; i < maxProcs*2; i++ {
1072                 go func() {
1073                         for _ = range reqs {
1074                                 rows, err := stmt.Query()
1075                                 if err != nil {
1076                                         t.Errorf("error on query:  %v", err)
1077                                         wg.Done()
1078                                         continue
1079                                 }
1080
1081                                 var name string
1082                                 for rows.Next() {
1083                                         rows.Scan(&name)
1084                                 }
1085                                 rows.Close()
1086
1087                                 wg.Done()
1088                         }
1089                 }()
1090         }
1091
1092         for i := 0; i < numReqs; i++ {
1093                 reqs <- true
1094         }
1095
1096         wg.Wait()
1097 }
1098
1099 func TestConcurrency(t *testing.T) {
1100         manyConcurrentQueries(t)
1101 }
1102
1103 func BenchmarkConcurrency(b *testing.B) {
1104         b.ReportAllocs()
1105         for i := 0; i < b.N; i++ {
1106                 manyConcurrentQueries(b)
1107         }
1108 }