code review 8836045: database/sql: fix driver Conn refcounting with prepared...

src/pkg/database/sql/fakedb_test.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package sql
 
 import (
         "database/sql/driver"
         "errors"
         "fmt"
@@ skipping 17 matching lines @@
 //
 //   WIPE
 //   CREATE|<tablename>|<col>=<type>,<col>=<type>,...
 //     where types are: "string", [u]int{8,16,32,64}, "bool"
 //   INSERT|<tablename>|col=val,col2=val2,col3=?
 //   SELECT|<tablename>|projectcol1,projectcol2|filtercol=?,filtercol2=?
 //
 // When opening a fakeDriver's database, it starts empty with no
 // tables.  All tables and data are stored in memory only.
 type fakeDriver struct {
-        mu        sync.Mutex
-        openCount int
-        dbs       map[string]*fakeDB
+        mu         sync.Mutex // guards all 4 fields
+        openCount  int        // conn opens
+        closeCount int        // conn closes
+        dbs        map[string]*fakeDB
 }
 
 type fakeDB struct {
         name string
 
         mu      sync.Mutex
         free    []*fakeConn
         tables  map[string]*table
         badConn bool
 }
@@ skipping 192 matching lines @@
 
 var testStrictClose *testing.T
 
 // setStrictFakeConnClose sets the t to Errorf on when fakeConn.Close
 // fails to close. If nil, the check is disabled.
 func setStrictFakeConnClose(t *testing.T) {
         testStrictClose = t
 }
 
 func (c *fakeConn) Close() (err error) {
+        drv := fdriver.(*fakeDriver)
         defer func() {
                 if err != nil && testStrictClose != nil {
                         testStrictClose.Errorf("failed to close a test fakeConn: %v", err)
                 }
                 hookPostCloseConn.Lock()
                 fn := hookPostCloseConn.fn
                 hookPostCloseConn.Unlock()
                 if fn != nil {
                         fn(c, err)
                 }
+                if err == nil {
+                        drv.mu.Lock()
+                        drv.closeCount++
+                        drv.mu.Unlock()
+                }
         }()
         if c.currTx != nil {
                 return errors.New("can't close fakeConn; in a Transaction")
         }
         if c.db == nil {
                 return errors.New("can't close fakeConn; already closed")
         }
         if c.stmtsMade > c.stmtsClosed {
                 return errors.New("can't close; dangling statement(s)")
         }
@@ skipping 179 matching lines @@
                 return driver.DefaultParameterConverter
         }
         return s.placeholderConverter[idx]
 }
 
 func (s *fakeStmt) Close() error {
         if s.c == nil {
                 panic("nil conn in fakeStmt.Close")
         }
         if s.c.db == nil {
-                panic("in fakeSmt.Close, conn's db is nil (already closed)")
+                panic("in fakeStmt.Close, conn's db is nil (already closed)")
         }
         if !s.closed {
                 s.c.incrStat(&s.c.stmtsClosed)
                 s.closed = true
         }
         return nil
 }
 
 var errClosed = errors.New("fakedb: statement has been closed")
 
@@ skipping 72 matching lines @@
         if len(args) != s.placeholders {
                 panic("error in pkg db; should only get here if size is correct")
         }
 
         db.mu.Lock()
         t, ok := db.table(s.table)
         db.mu.Unlock()
         if !ok {
                 return nil, fmt.Errorf("fakedb: table %q doesn't exist", s.table)
         }
+
+        if s.table == "magicquery" {
+                if len(s.whereCol) == 2 && s.whereCol[0] == "op" && s.whereCol[1] == "millis" {
+                        if args[0] == "sleep" {
+                                time.Sleep(time.Duration(args[1].(int64)) * time.Millisecond)
+                        }
+                }
+        }
+
         t.mu.Lock()
         defer t.mu.Unlock()
 
         colIdx := make(map[string]int) // select column name -> column index in table
         for _, name := range s.colName {
                 idx := t.columnIndex(name)
                 if idx == -1 {
                         return nil, fmt.Errorf("fakedb: unknown column name %q", name)
                 }
                 colIdx[name] = idx
@@ skipping 151 matching lines @@
                 // TODO(coopernurse): add type-specific converter
                 return driver.NotNull{Converter: driver.DefaultParameterConverter}
         case "nullfloat64":
                 // TODO(coopernurse): add type-specific converter
                 return driver.Null{Converter: driver.DefaultParameterConverter}
         case "datetime":
                 return driver.DefaultParameterConverter
         }
         panic("invalid fakedb column type of " + typ)
 }