code review 5759050: database/sql: ensure Stmts are correctly closed.

src/pkg/database/sql/sql_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"
         "fmt"
         "reflect"
@@ skipping 233 matching lines @@
         }
 }
 
 func TestStatementQueryRow(t *testing.T) {
         db := newTestDB(t, "people")
         defer closeDB(t, db)
         stmt, err := db.Prepare("SELECT|people|age|name=?")
         if err != nil {
                 t.Fatalf("Prepare: %v", err)
         }
+        defer stmt.Close()
         var age int
         for n, tt := range []struct {
                 name string
                 want int
         }{
                 {"Alice", 1},
                 {"Bob", 2},
                 {"Chris", 3},
         } {
                 if err := stmt.QueryRow(tt.name).Scan(&age); err != nil {
@@ skipping 20 matching lines @@
 }
 
 func TestExec(t *testing.T) {
         db := newTestDB(t, "foo")
         defer closeDB(t, db)
         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
         stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
         if err != nil {
                 t.Errorf("Stmt, err = %v, %v", stmt, err)
         }
+        defer stmt.Close()
 
         type execTest struct {
                 args    []interface{}
                 wantErr string
         }
         execTests := []execTest{
                 // Okay:
                 {[]interface{}{"Brad", 31}, ""},
                 {[]interface{}{"Brad", int64(31)}, ""},
                 {[]interface{}{"Bob", "32"}, ""},
@@ skipping 21 matching lines @@
 }
 
 func TestTxStmt(t *testing.T) {
         db := newTestDB(t, "")
         defer closeDB(t, db)
         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
         stmt, err := db.Prepare("INSERT|t1|name=?,age=?")
         if err != nil {
                 t.Fatalf("Stmt, err = %v, %v", stmt, err)
         }
+        defer stmt.Close()
         tx, err := db.Begin()
         if err != nil {
                 t.Fatalf("Begin = %v", err)
         }
-        _, err = tx.Stmt(stmt).Exec("Bobby", 7)
+        txs := tx.Stmt(stmt)
+        defer txs.Close()
+        _, err = txs.Exec("Bobby", 7)
         if err != nil {
                 t.Fatalf("Exec = %v", err)
         }
         err = tx.Commit()
         if err != nil {
                 t.Fatalf("Commit = %v", err)
         }
 }
 
 // Issue: http://golang.org/issue/2784
 // This test didn't fail before because we got luckly with the fakedb driver.
 // It was failing, and now not, in github.com/bradfitz/go-sql-test
 func TestTxQuery(t *testing.T) {
         db := newTestDB(t, "")
         defer closeDB(t, db)
         exec(t, db, "CREATE|t1|name=string,age=int32,dead=bool")
         exec(t, db, "INSERT|t1|name=Alice")
 
         tx, err := db.Begin()
         if err != nil {
                 t.Fatal(err)
         }
         defer tx.Rollback()
 
         r, err := tx.Query("SELECT|t1|name|")
         if err != nil {
                 t.Fatal(err)
         }
+        defer r.Close()
 
         if !r.Next() {
                 if r.Err() != nil {
                         t.Fatal(r.Err())
                 }
                 t.Fatal("expected one row")
         }
 
         var x string
         err = r.Scan(&x)
@@ skipping 176 matching lines @@
 
         // Inserts with db.Exec:
         exec(t, db, "INSERT|t|id=?,name=?,nullf=?,notnullf=?", 1, "alice", spec.rows[0].nullParam, spec.rows[0].notNullParam)
         exec(t, db, "INSERT|t|id=?,name=?,nullf=?,notnullf=?", 2, "bob", spec.rows[1].nullParam, spec.rows[1].notNullParam)
 
         // Inserts with a prepared statement:
         stmt, err := db.Prepare("INSERT|t|id=?,name=?,nullf=?,notnullf=?")
         if err != nil {
                 t.Fatalf("prepare: %v", err)
         }
+        defer stmt.Close()
         if _, err := stmt.Exec(3, "chris", spec.rows[2].nullParam, spec.rows[2].notNullParam); err != nil {
                 t.Errorf("exec insert chris: %v", err)
         }
         if _, err := stmt.Exec(4, "dave", spec.rows[3].nullParam, spec.rows[3].notNullParam); err != nil {
                 t.Errorf("exec insert dave: %v", err)
         }
         if _, err := stmt.Exec(5, "eleanor", spec.rows[4].nullParam, spec.rows[4].notNullParam); err != nil {
                 t.Errorf("exec insert eleanor: %v", err)
         }
 
@@ skipping 24 matching lines @@
                 if !reflect.DeepEqual(bindValDeref, spec.rows[i].scanNullVal) {
                         t.Errorf("id=%d got %#v, want %#v", id, bindValDeref, spec.rows[i].scanNullVal)
                 }
         }
 }
 
 func stack() string {
         buf := make([]byte, 1024)
         return string(buf[:runtime.Stack(buf, false)])
 }