From 4f5821ada67fa024a5d417664e0d6c47a71c5c6c Mon Sep 17 00:00:00 2001
From: Zac Medico <zmedico@gmail.com>
Date: Mon, 7 Mar 2016 01:15:24 -0800
Subject: Test SQLiteRows.DeclTypes()

---
 sqlite3_test.go | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_test.go b/sqlite3_test.go
index 9efd313..c7996c6 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -1279,6 +1279,41 @@ func TestAggregatorRegistration(t *testing.T) {
 	}
 }
 
+func TestDeclTypes(t *testing.T) {
+
+	d := SQLiteDriver{}
+
+	conn, err := d.Open(":memory:")
+	if err != nil {
+		t.Fatal("Failed to begin transaction:", err)
+	}
+	defer conn.Close()
+
+	sqlite3conn := conn.(*SQLiteConn)
+
+	_, err = sqlite3conn.Exec("create table foo (id integer not null primary key, name text)", nil)
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	_, err = sqlite3conn.Exec("insert into foo(name) values(\"bar\")", nil)
+	if err != nil {
+		t.Fatal("Failed to insert:", err)
+	}
+
+	rs, err := sqlite3conn.Query("select * from foo", nil)
+	if err != nil {
+		t.Fatal("Failed to select:", err)
+	}
+	defer rs.Close()
+
+	declTypes := rs.(*SQLiteRows).DeclTypes()
+
+	if !reflect.DeepEqual(declTypes, []string{"integer", "text"}) {
+		t.Fatal("Unexpected declTypes:", declTypes)
+	}
+}
+
 var customFunctionOnce sync.Once
 
 func BenchmarkCustomFunctions(b *testing.B) {
-- 
cgit v1.2.3


From caab59fb664ce62b14ce12203cf8da715e3fc46e Mon Sep 17 00:00:00 2001
From: yoza <yoza.is12s@gmail.com>
Date: Mon, 14 Mar 2016 20:54:10 +0900
Subject: Fix testing message at TestInsert and TestUpdate

---
 sqlite3_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_test.go b/sqlite3_test.go
index c7996c6..44ec640 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -168,7 +168,7 @@ func TestInsert(t *testing.T) {
 	var result int
 	rows.Scan(&result)
 	if result != 123 {
-		t.Errorf("Fetched %q; expected %q", 123, result)
+		t.Errorf("Expected %d for fetched result, but %d:", 123, result)
 	}
 }
 
@@ -233,7 +233,7 @@ func TestUpdate(t *testing.T) {
 	var result int
 	rows.Scan(&result)
 	if result != 234 {
-		t.Errorf("Fetched %q; expected %q", 234, result)
+		t.Errorf("Expected %d for fetched result, but %d:", 234, result)
 	}
 }
 
-- 
cgit v1.2.3


From 3fb7a0e792edd47bf0cf1e919dfc14e2be412e15 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Thu, 8 Sep 2016 01:20:43 +0900
Subject: TestAggregatorRegistration may fail if trace feature is not
 implemented

---
 sqlite3_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_test.go b/sqlite3_test.go
index 44ec640..cf826dd 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -1252,7 +1252,8 @@ func TestAggregatorRegistration(t *testing.T) {
 
 	_, err = db.Exec("create table foo (department integer, profits integer)")
 	if err != nil {
-		t.Fatal("Failed to create table:", err)
+		// trace feature is not implemented
+		t.Skip("Failed to create table:", err)
 	}
 
 	_, err = db.Exec("insert into foo values (1, 10), (1, 20), (2, 42)")
-- 
cgit v1.2.3


From 6796d46c3a2736edc88418f6de515c76e29f4aa9 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Thu, 3 Nov 2016 23:05:34 +0900
Subject: implement go18 Pinger

---
 sqlite3_context.go | 14 ++++++++++++++
 sqlite3_test.go    | 16 ++++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 sqlite3_context.go

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_context.go b/sqlite3_context.go
new file mode 100644
index 0000000..26e4998
--- /dev/null
+++ b/sqlite3_context.go
@@ -0,0 +1,14 @@
+package sqlite3
+
+import (
+	"context"
+	"errors"
+)
+
+// Ping implement Pinger.
+func (c *SQLiteConn) Ping(ctx context.Context) error {
+	if c.db == nil {
+		return errors.New("Connection was closed")
+	}
+	return nil
+}
diff --git a/sqlite3_test.go b/sqlite3_test.go
index cf826dd..fc5c99c 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -1315,6 +1315,22 @@ func TestDeclTypes(t *testing.T) {
 	}
 }
 
+func TestPinger(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = db.Ping()
+	if err != nil {
+		t.Fatal(err)
+	}
+	db.Close()
+	err = db.Ping()
+	if err == nil {
+		t.Fatal("Should be closed")
+	}
+}
+
 var customFunctionOnce sync.Once
 
 func BenchmarkCustomFunctions(b *testing.B) {
-- 
cgit v1.2.3


From b23526fb3ce3365cb83fcb1f46ac278d70d8f934 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 15:00:29 +0900
Subject: support named params

---
 sqlite3.go      | 48 ++++++++++++++++++++----------------------------
 sqlite3_go18.go | 16 ++++++++++++++++
 sqlite3_test.go |  6 +++---
 3 files changed, 39 insertions(+), 31 deletions(-)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3.go b/sqlite3.go
index 5087fad..3b80eeb 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -172,8 +172,6 @@ type SQLiteTx struct {
 type SQLiteStmt struct {
 	c      *SQLiteConn
 	s      *C.sqlite3_stmt
-	nv     int
-	nn     []string
 	t      string
 	closed bool
 	cls    bool
@@ -420,6 +418,7 @@ func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, err
 }
 
 func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue) (driver.Result, error) {
+	start := 0
 	for {
 		s, err := c.Prepare(query)
 		if err != nil {
@@ -431,12 +430,16 @@ func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue)
 			if len(args) < na {
 				return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args))
 			}
+			for i := 0; i < na; i++ {
+				args[i].Ordinal -= start
+			}
 			res, err = s.(*SQLiteStmt).exec(ctx, args[:na])
 			if err != nil && err != driver.ErrSkip {
 				s.Close()
 				return nil, err
 			}
 			args = args[na:]
+			start += na
 		}
 		tail := s.(*SQLiteStmt).t
 		s.Close()
@@ -466,6 +469,7 @@ func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, erro
 }
 
 func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) (driver.Rows, error) {
+	start := 0
 	for {
 		s, err := c.Prepare(query)
 		if err != nil {
@@ -476,12 +480,16 @@ func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue)
 		if len(args) < na {
 			return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args))
 		}
+		for i := 0; i < na; i++ {
+			args[i].Ordinal -= start
+		}
 		rows, err := s.(*SQLiteStmt).query(ctx, args[:na])
 		if err != nil && err != driver.ErrSkip {
 			s.Close()
 			return nil, err
 		}
 		args = args[na:]
+		start += na
 		tail := s.(*SQLiteStmt).t
 		if tail == "" {
 			return rows, nil
@@ -648,15 +656,7 @@ func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
 	if tail != nil && *tail != '\000' {
 		t = strings.TrimSpace(C.GoString(tail))
 	}
-	nv := int(C.sqlite3_bind_parameter_count(s))
-	var nn []string
-	for i := 0; i < nv; i++ {
-		pn := C.GoString(C.sqlite3_bind_parameter_name(s, C.int(i+1)))
-		if len(pn) > 1 && pn[0] == '$' && 48 <= pn[1] && pn[1] <= 57 {
-			nn = append(nn, C.GoString(C.sqlite3_bind_parameter_name(s, C.int(i+1))))
-		}
-	}
-	ss := &SQLiteStmt{c: c, s: s, nv: nv, nn: nn, t: t}
+	ss := &SQLiteStmt{c: c, s: s, t: t}
 	runtime.SetFinalizer(ss, (*SQLiteStmt).Close)
 	return ss, nil
 }
@@ -680,7 +680,7 @@ func (s *SQLiteStmt) Close() error {
 
 // Return a number of parameters.
 func (s *SQLiteStmt) NumInput() int {
-	return s.nv
+	return int(C.sqlite3_bind_parameter_count(s.s))
 }
 
 type bindArg struct {
@@ -694,25 +694,17 @@ func (s *SQLiteStmt) bind(args []namedValue) error {
 		return s.c.lastError()
 	}
 
-	var vargs []bindArg
-	narg := len(args)
-	vargs = make([]bindArg, narg)
-	if len(s.nn) > 0 {
-		for i, v := range s.nn {
-			if pi, err := strconv.Atoi(v[1:]); err == nil {
-				vargs[i] = bindArg{pi, args[i].Value}
-			}
-		}
-	} else {
-		for i, v := range args {
-			vargs[i] = bindArg{i + 1, v.Value}
+	for i, v := range args {
+		if v.Name != "" {
+			cname := C.CString(v.Name)
+			args[i].Ordinal = int(C.sqlite3_bind_parameter_index(s.s, cname))
+			C.free(unsafe.Pointer(cname))
 		}
 	}
 
-	for _, varg := range vargs {
-		n := C.int(varg.n)
-		v := varg.v
-		switch v := v.(type) {
+	for _, arg := range args {
+		n := C.int(arg.Ordinal)
+		switch v := arg.Value.(type) {
 		case nil:
 			rv = C.sqlite3_bind_null(s.s, n)
 		case string:
diff --git a/sqlite3_go18.go b/sqlite3_go18.go
index 1ee4c6a..3993490 100644
--- a/sqlite3_go18.go
+++ b/sqlite3_go18.go
@@ -23,6 +23,14 @@ func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driv
 	return c.query(ctx, query, list)
 }
 
+func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
+	list := make([]namedValue, len(args))
+	for i, nv := range args {
+		list[i] = namedValue(nv)
+	}
+	return c.exec(ctx, query, list)
+}
+
 func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
 	list := make([]namedValue, len(args))
 	for i, nv := range args {
@@ -30,3 +38,11 @@ func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue)
 	}
 	return s.query(ctx, list)
 }
+
+func (s *SQLiteStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
+	list := make([]namedValue, len(args))
+	for i, nv := range args {
+		list[i] = namedValue(nv)
+	}
+	return s.exec(ctx, list)
+}
diff --git a/sqlite3_test.go b/sqlite3_test.go
index fc5c99c..b126bbd 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -993,7 +993,7 @@ func TestVersion(t *testing.T) {
 	}
 }
 
-func TestNumberNamedParams(t *testing.T) {
+func TestNamedParams(t *testing.T) {
 	tempFilename := TempFilename(t)
 	defer os.Remove(tempFilename)
 	db, err := sql.Open("sqlite3", tempFilename)
@@ -1009,12 +1009,12 @@ func TestNumberNamedParams(t *testing.T) {
 		t.Error("Failed to call db.Query:", err)
 	}
 
-	_, err = db.Exec(`insert into foo(id, name, extra) values($1, $2, $2)`, 1, "foo")
+	_, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Param(":name", "foo"), sql.Param(":id", 1))
 	if err != nil {
 		t.Error("Failed to call db.Exec:", err)
 	}
 
-	row := db.QueryRow(`select id, extra from foo where id = $1 and extra = $2`, 1, "foo")
+	row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Param(":id", 1), sql.Param(":extra", "foo"))
 	if row == nil {
 		t.Error("Failed to call db.QueryRow")
 	}
-- 
cgit v1.2.3


From 57eaf4c0709539478ef65348d27518327283c840 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 15:17:21 +0900
Subject: separate test

---
 sqlite3_go18_test.go | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 sqlite3_test.go      | 36 ------------------------------------
 2 files changed, 49 insertions(+), 36 deletions(-)
 create mode 100644 sqlite3_go18_test.go

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go
new file mode 100644
index 0000000..bc8aa4e
--- /dev/null
+++ b/sqlite3_go18_test.go
@@ -0,0 +1,49 @@
+// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+// +build go1.8
+
+package sqlite3
+
+import (
+	"database/sql"
+	"os"
+	"testing"
+)
+
+func TestNamedParams(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	db, err := sql.Open("sqlite3", tempFilename)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+	create table foo (id integer, name text, extra text);
+	`)
+	if err != nil {
+		t.Error("Failed to call db.Query:", err)
+	}
+
+	_, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Param(":name", "foo"), sql.Param(":id", 1))
+	if err != nil {
+		t.Error("Failed to call db.Exec:", err)
+	}
+
+	row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Param(":id", 1), sql.Param(":extra", "foo"))
+	if row == nil {
+		t.Error("Failed to call db.QueryRow")
+	}
+	var id int
+	var extra string
+	err = row.Scan(&id, &extra)
+	if err != nil {
+		t.Error("Failed to db.Scan:", err)
+	}
+	if id != 1 || extra != "foo" {
+		t.Error("Failed to db.QueryRow: not matched results")
+	}
+}
diff --git a/sqlite3_test.go b/sqlite3_test.go
index b126bbd..e578404 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -993,42 +993,6 @@ func TestVersion(t *testing.T) {
 	}
 }
 
-func TestNamedParams(t *testing.T) {
-	tempFilename := TempFilename(t)
-	defer os.Remove(tempFilename)
-	db, err := sql.Open("sqlite3", tempFilename)
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec(`
-	create table foo (id integer, name text, extra text);
-	`)
-	if err != nil {
-		t.Error("Failed to call db.Query:", err)
-	}
-
-	_, err = db.Exec(`insert into foo(id, name, extra) values(:id, :name, :name)`, sql.Param(":name", "foo"), sql.Param(":id", 1))
-	if err != nil {
-		t.Error("Failed to call db.Exec:", err)
-	}
-
-	row := db.QueryRow(`select id, extra from foo where id = :id and extra = :extra`, sql.Param(":id", 1), sql.Param(":extra", "foo"))
-	if row == nil {
-		t.Error("Failed to call db.QueryRow")
-	}
-	var id int
-	var extra string
-	err = row.Scan(&id, &extra)
-	if err != nil {
-		t.Error("Failed to db.Scan:", err)
-	}
-	if id != 1 || extra != "foo" {
-		t.Error("Failed to db.QueryRow: not matched results")
-	}
-}
-
 func TestStringContainingZero(t *testing.T) {
 	tempFilename := TempFilename(t)
 	defer os.Remove(tempFilename)
-- 
cgit v1.2.3


From 15491aeb9ce9ce0ec580011e1bbc3d83c6be4953 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sun, 6 Nov 2016 13:16:38 +0900
Subject: go vet && golint

---
 sqlite3_go18.go      |  7 ++++++-
 sqlite3_go18_test.go |  1 +
 sqlite3_test.go      | 42 +++++++++++++++++++++---------------------
 sqlite3_type.go      |  3 +++
 4 files changed, 31 insertions(+), 22 deletions(-)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_go18.go b/sqlite3_go18.go
index 9ad7baf..ec2c3a8 100644
--- a/sqlite3_go18.go
+++ b/sqlite3_go18.go
@@ -1,3 +1,8 @@
+// Copyright (C) 2014 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
 // +build go1.8
 
 package sqlite3
@@ -6,7 +11,7 @@ import (
 	"database/sql/driver"
 	"errors"
 
-	"golang.org/x/net/context"
+	"context"
 )
 
 // Ping implement Pinger.
diff --git a/sqlite3_go18_test.go b/sqlite3_go18_test.go
index bc8aa4e..54e6604 100644
--- a/sqlite3_go18_test.go
+++ b/sqlite3_go18_test.go
@@ -2,6 +2,7 @@
 //
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
+
 // +build go1.8
 
 package sqlite3
diff --git a/sqlite3_test.go b/sqlite3_test.go
index e578404..eb9d18e 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -207,12 +207,12 @@ func TestUpdate(t *testing.T) {
 	if err != nil {
 		t.Fatal("Failed to update record:", err)
 	}
-	lastId, err := res.LastInsertId()
+	lastID, err := res.LastInsertId()
 	if err != nil {
 		t.Fatal("Failed to get LastInsertId:", err)
 	}
-	if expected != lastId {
-		t.Errorf("Expected %q for last Id, but %q:", expected, lastId)
+	if expected != lastID {
+		t.Errorf("Expected %q for last Id, but %q:", expected, lastID)
 	}
 	affected, _ = res.RowsAffected()
 	if err != nil {
@@ -272,12 +272,12 @@ func TestDelete(t *testing.T) {
 	if err != nil {
 		t.Fatal("Failed to delete record:", err)
 	}
-	lastId, err := res.LastInsertId()
+	lastID, err := res.LastInsertId()
 	if err != nil {
 		t.Fatal("Failed to get LastInsertId:", err)
 	}
-	if expected != lastId {
-		t.Errorf("Expected %q for last Id, but %q:", expected, lastId)
+	if expected != lastID {
+		t.Errorf("Expected %q for last Id, but %q:", expected, lastID)
 	}
 	affected, err = res.RowsAffected()
 	if err != nil {
@@ -1070,12 +1070,12 @@ func TestDateTimeNow(t *testing.T) {
 }
 
 func TestFunctionRegistration(t *testing.T) {
-	addi_8_16_32 := func(a int8, b int16) int32 { return int32(a) + int32(b) }
-	addi_64 := func(a, b int64) int64 { return a + b }
-	addu_8_16_32 := func(a uint8, b uint16) uint32 { return uint32(a) + uint32(b) }
-	addu_64 := func(a, b uint64) uint64 { return a + b }
+	addi8_16_32 := func(a int8, b int16) int32 { return int32(a) + int32(b) }
+	addi64 := func(a, b int64) int64 { return a + b }
+	addu8_16_32 := func(a uint8, b uint16) uint32 { return uint32(a) + uint32(b) }
+	addu64 := func(a, b uint64) uint64 { return a + b }
 	addiu := func(a int, b uint) int64 { return int64(a) + int64(b) }
-	addf_32_64 := func(a float32, b float64) float64 { return float64(a) + b }
+	addf32_64 := func(a float32, b float64) float64 { return float64(a) + b }
 	not := func(a bool) bool { return !a }
 	regex := func(re, s string) (bool, error) {
 		return regexp.MatchString(re, s)
@@ -1107,22 +1107,22 @@ func TestFunctionRegistration(t *testing.T) {
 
 	sql.Register("sqlite3_FunctionRegistration", &SQLiteDriver{
 		ConnectHook: func(conn *SQLiteConn) error {
-			if err := conn.RegisterFunc("addi_8_16_32", addi_8_16_32, true); err != nil {
+			if err := conn.RegisterFunc("addi8_16_32", addi8_16_32, true); err != nil {
 				return err
 			}
-			if err := conn.RegisterFunc("addi_64", addi_64, true); err != nil {
+			if err := conn.RegisterFunc("addi64", addi64, true); err != nil {
 				return err
 			}
-			if err := conn.RegisterFunc("addu_8_16_32", addu_8_16_32, true); err != nil {
+			if err := conn.RegisterFunc("addu8_16_32", addu8_16_32, true); err != nil {
 				return err
 			}
-			if err := conn.RegisterFunc("addu_64", addu_64, true); err != nil {
+			if err := conn.RegisterFunc("addu64", addu64, true); err != nil {
 				return err
 			}
 			if err := conn.RegisterFunc("addiu", addiu, true); err != nil {
 				return err
 			}
-			if err := conn.RegisterFunc("addf_32_64", addf_32_64, true); err != nil {
+			if err := conn.RegisterFunc("addf32_64", addf32_64, true); err != nil {
 				return err
 			}
 			if err := conn.RegisterFunc("not", not, true); err != nil {
@@ -1153,12 +1153,12 @@ func TestFunctionRegistration(t *testing.T) {
 		query    string
 		expected interface{}
 	}{
-		{"SELECT addi_8_16_32(1,2)", int32(3)},
-		{"SELECT addi_64(1,2)", int64(3)},
-		{"SELECT addu_8_16_32(1,2)", uint32(3)},
-		{"SELECT addu_64(1,2)", uint64(3)},
+		{"SELECT addi8_16_32(1,2)", int32(3)},
+		{"SELECT addi64(1,2)", int64(3)},
+		{"SELECT addu8_16_32(1,2)", uint32(3)},
+		{"SELECT addu64(1,2)", uint64(3)},
 		{"SELECT addiu(1,2)", int64(3)},
-		{"SELECT addf_32_64(1.5,1.5)", float64(3)},
+		{"SELECT addf32_64(1.5,1.5)", float64(3)},
 		{"SELECT not(1)", false},
 		{"SELECT not(0)", true},
 		{`SELECT regex("^foo.*", "foobar")`, true},
diff --git a/sqlite3_type.go b/sqlite3_type.go
index 748bc42..200d071 100644
--- a/sqlite3_type.go
+++ b/sqlite3_type.go
@@ -13,6 +13,7 @@ import (
 	"time"
 )
 
+// ColumnTypeDatabaseTypeName implement RowsColumnTypeDatabaseTypeName.
 func (rc *SQLiteRows) ColumnTypeDatabaseTypeName(i int) string {
 	return C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i)))
 }
@@ -27,10 +28,12 @@ func (rc *SQLiteRows) ColumnTypePrecisionScale(index int) (precision, scale int6
 }
 */
 
+// ColumnTypeNullable implement RowsColumnTypeNullable.
 func (rc *SQLiteRows) ColumnTypeNullable(i int) (nullable, ok bool) {
 	return true, true
 }
 
+// ColumnTypeScanType implement RowsColumnTypeScanType.
 func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type {
 	switch C.sqlite3_column_type(rc.s.s, C.int(i)) {
 	case C.SQLITE_INTEGER:
-- 
cgit v1.2.3


From 7ed900a7c4cc22315a007cc49821cce3baa7be0f Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Thu, 19 Jan 2017 02:20:24 +0900
Subject: fix test

---
 sqlite3_test.go       | 60 ------------------------------------------
 sqlite3_trace_test.go | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++
 tracecallback.go      |  1 -
 3 files changed, 72 insertions(+), 61 deletions(-)
 create mode 100644 sqlite3_trace_test.go

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_test.go b/sqlite3_test.go
index eb9d18e..8efb409 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -1184,66 +1184,6 @@ func TestFunctionRegistration(t *testing.T) {
 	}
 }
 
-type sumAggregator int64
-
-func (s *sumAggregator) Step(x int64) {
-	*s += sumAggregator(x)
-}
-
-func (s *sumAggregator) Done() int64 {
-	return int64(*s)
-}
-
-func TestAggregatorRegistration(t *testing.T) {
-	customSum := func() *sumAggregator {
-		var ret sumAggregator
-		return &ret
-	}
-
-	sql.Register("sqlite3_AggregatorRegistration", &SQLiteDriver{
-		ConnectHook: func(conn *SQLiteConn) error {
-			if err := conn.RegisterAggregator("customSum", customSum, true); err != nil {
-				return err
-			}
-			return nil
-		},
-	})
-	db, err := sql.Open("sqlite3_AggregatorRegistration", ":memory:")
-	if err != nil {
-		t.Fatal("Failed to open database:", err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec("create table foo (department integer, profits integer)")
-	if err != nil {
-		// trace feature is not implemented
-		t.Skip("Failed to create table:", err)
-	}
-
-	_, err = db.Exec("insert into foo values (1, 10), (1, 20), (2, 42)")
-	if err != nil {
-		t.Fatal("Failed to insert records:", err)
-	}
-
-	tests := []struct {
-		dept, sum int64
-	}{
-		{1, 30},
-		{2, 42},
-	}
-
-	for _, test := range tests {
-		var ret int64
-		err = db.QueryRow("select customSum(profits) from foo where department = $1 group by department", test.dept).Scan(&ret)
-		if err != nil {
-			t.Fatal("Query failed:", err)
-		}
-		if ret != test.sum {
-			t.Fatalf("Custom sum returned wrong value, got %d, want %d", ret, test.sum)
-		}
-	}
-}
-
 func TestDeclTypes(t *testing.T) {
 
 	d := SQLiteDriver{}
diff --git a/sqlite3_trace_test.go b/sqlite3_trace_test.go
new file mode 100644
index 0000000..57a6757
--- /dev/null
+++ b/sqlite3_trace_test.go
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+// +build trace
+
+package sqlite3
+
+import (
+	"database/sql"
+	"testing"
+)
+
+type sumAggregator int64
+
+func (s *sumAggregator) Step(x int64) {
+	*s += sumAggregator(x)
+}
+
+func (s *sumAggregator) Done() int64 {
+	return int64(*s)
+}
+
+func TestAggregatorRegistration(t *testing.T) {
+	customSum := func() *sumAggregator {
+		var ret sumAggregator
+		return &ret
+	}
+
+	sql.Register("sqlite3_AggregatorRegistration", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			if err := conn.RegisterAggregator("customSum", customSum, true); err != nil {
+				return err
+			}
+			return nil
+		},
+	})
+	db, err := sql.Open("sqlite3_AggregatorRegistration", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("create table foo (department integer, profits integer)")
+	if err != nil {
+		// trace feature is not implemented
+		t.Skip("Failed to create table:", err)
+	}
+
+	_, err = db.Exec("insert into foo values (1, 10), (1, 20), (2, 42)")
+	if err != nil {
+		t.Fatal("Failed to insert records:", err)
+	}
+
+	tests := []struct {
+		dept, sum int64
+	}{
+		{1, 30},
+		{2, 42},
+	}
+
+	for _, test := range tests {
+		var ret int64
+		err = db.QueryRow("select customSum(profits) from foo where department = $1 group by department", test.dept).Scan(&ret)
+		if err != nil {
+			t.Fatal("Query failed:", err)
+		}
+		if ret != test.sum {
+			t.Fatalf("Custom sum returned wrong value, got %d, want %d", ret, test.sum)
+		}
+	}
+}
diff --git a/tracecallback.go b/tracecallback.go
index 93688d4..de1d504 100644
--- a/tracecallback.go
+++ b/tracecallback.go
@@ -1,5 +1,4 @@
 // Copyright (C) 2016 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-// TODO: add "Gimpl do foo" team?
 //
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
-- 
cgit v1.2.3


From 5b1175ef066f9fe80eee84c0ba5d0dbea72d09a6 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sun, 5 Mar 2017 00:46:52 +0900
Subject: not use underscore

---
 sqlite3_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3_test.go b/sqlite3_test.go
index 8efb409..e844f82 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -1239,14 +1239,14 @@ var customFunctionOnce sync.Once
 
 func BenchmarkCustomFunctions(b *testing.B) {
 	customFunctionOnce.Do(func() {
-		custom_add := func(a, b int64) int64 {
+		customAdd := func(a, b int64) int64 {
 			return a + b
 		}
 
 		sql.Register("sqlite3_BenchmarkCustomFunctions", &SQLiteDriver{
 			ConnectHook: func(conn *SQLiteConn) error {
 				// Impure function to force sqlite to reexecute it each time.
-				if err := conn.RegisterFunc("custom_add", custom_add, false); err != nil {
+				if err := conn.RegisterFunc("custom_add", customAdd, false); err != nil {
 					return err
 				}
 				return nil
-- 
cgit v1.2.3


From c6d43c40e663785489630d0f9086bbae5f490394 Mon Sep 17 00:00:00 2001
From: Ross Light <light@google.com>
Date: Sat, 1 Apr 2017 09:12:21 -0700
Subject: Add _foreign_keys connection parameter

Fixes #377
Updates #255
---
 sqlite3.go      | 46 +++++++++++++++++++++++++++++++++++++++++++---
 sqlite3_test.go | 29 +++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 3 deletions(-)

(limited to 'sqlite3_test.go')

diff --git a/sqlite3.go b/sqlite3.go
index cbde900..161eb22 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -400,14 +400,18 @@ func (c *SQLiteConn) AutoCommit() bool {
 }
 
 func (c *SQLiteConn) lastError() error {
-	rv := C.sqlite3_errcode(c.db)
+	return lastError(c.db)
+}
+
+func lastError(db *C.sqlite3) error {
+	rv := C.sqlite3_errcode(db)
 	if rv == C.SQLITE_OK {
 		return nil
 	}
 	return Error{
 		Code:         ErrNo(rv),
-		ExtendedCode: ErrNoExtended(C.sqlite3_extended_errcode(c.db)),
-		err:          C.GoString(C.sqlite3_errmsg(c.db)),
+		ExtendedCode: ErrNoExtended(C.sqlite3_extended_errcode(db)),
+		err:          C.GoString(C.sqlite3_errmsg(db)),
 	}
 }
 
@@ -537,6 +541,8 @@ func errorString(err Error) string {
 //   _txlock=XXX
 //     Specify locking behavior for transactions.  XXX can be "immediate",
 //     "deferred", "exclusive".
+//   _foreign_keys=X
+//     Enable or disable enforcement of foreign keys.  X can be 1 or 0.
 func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 	if C.sqlite3_threadsafe() == 0 {
 		return nil, errors.New("sqlite library was not compiled for thread-safe operation")
@@ -545,6 +551,7 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 	var loc *time.Location
 	txlock := "BEGIN"
 	busyTimeout := 5000
+	foreignKeys := -1
 	pos := strings.IndexRune(dsn, '?')
 	if pos >= 1 {
 		params, err := url.ParseQuery(dsn[pos+1:])
@@ -587,6 +594,18 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 			}
 		}
 
+		// _foreign_keys
+		if val := params.Get("_foreign_keys"); val != "" {
+			switch val {
+			case "1":
+				foreignKeys = 1
+			case "0":
+				foreignKeys = 0
+			default:
+				return nil, fmt.Errorf("Invalid _foreign_keys: %v", val)
+			}
+		}
+
 		if !strings.HasPrefix(dsn, "file:") {
 			dsn = dsn[:pos]
 		}
@@ -612,6 +631,27 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 		return nil, Error{Code: ErrNo(rv)}
 	}
 
+	exec := func(s string) error {
+		cs := C.CString(s)
+		rv := C.sqlite3_exec(db, cs, nil, nil, nil)
+		C.free(unsafe.Pointer(cs))
+		if rv != C.SQLITE_OK {
+			return lastError(db)
+		}
+		return nil
+	}
+	if foreignKeys == 0 {
+		if err := exec("PRAGMA foreign_keys = OFF;"); err != nil {
+			C.sqlite3_close_v2(db)
+			return nil, err
+		}
+	} else if foreignKeys == 1 {
+		if err := exec("PRAGMA foreign_keys = ON;"); err != nil {
+			C.sqlite3_close_v2(db)
+			return nil, err
+		}
+	}
+
 	conn := &SQLiteConn{db: db, loc: loc, txlock: txlock}
 
 	if len(d.Extensions) > 0 {
diff --git a/sqlite3_test.go b/sqlite3_test.go
index e844f82..03b678d 100644
--- a/sqlite3_test.go
+++ b/sqlite3_test.go
@@ -107,6 +107,35 @@ func TestReadonly(t *testing.T) {
 	}
 }
 
+func TestForeignKeys(t *testing.T) {
+	cases := map[string]bool{
+		"?_foreign_keys=1": true,
+		"?_foreign_keys=0": false,
+	}
+	for option, want := range cases {
+		fname := TempFilename(t)
+		uri := "file:" + fname + option
+		db, err := sql.Open("sqlite3", uri)
+		if err != nil {
+			os.Remove(fname)
+			t.Errorf("sql.Open(\"sqlite3\", %q): %v", uri, err)
+			continue
+		}
+		var enabled bool
+		err = db.QueryRow("PRAGMA foreign_keys;").Scan(&enabled)
+		db.Close()
+		os.Remove(fname)
+		if err != nil {
+			t.Errorf("query foreign_keys for %s: %v", uri, err)
+			continue
+		}
+		if enabled != want {
+			t.Errorf("\"PRAGMA foreign_keys;\" for %q = %t; want %t", uri, enabled, want)
+			continue
+		}
+	}
+}
+
 func TestClose(t *testing.T) {
 	tempFilename := TempFilename(t)
 	defer os.Remove(tempFilename)
-- 
cgit v1.2.3