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: [PATCH 01/14] implement go18 Pinger

---
 sqlite3_context.go | 14 ++++++++++++++
 sqlite3_test.go    | 16 ++++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 sqlite3_context.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) {

From d0e4959926020dc1ef3b001d8677ac94a6ada192 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 00:03:16 +0900
Subject: [PATCH 02/14] add go18 new feature

---
 sqlite3_type.go | 54 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 sqlite3_type.go

diff --git a/sqlite3_type.go b/sqlite3_type.go
new file mode 100644
index 0000000..748bc42
--- /dev/null
+++ b/sqlite3_type.go
@@ -0,0 +1,54 @@
+package sqlite3
+
+/*
+#ifndef USE_LIBSQLITE3
+#include <sqlite3-binding.h>
+#else
+#include <sqlite3.h>
+#endif
+*/
+import "C"
+import (
+	"reflect"
+	"time"
+)
+
+func (rc *SQLiteRows) ColumnTypeDatabaseTypeName(i int) string {
+	return C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i)))
+}
+
+/*
+func (rc *SQLiteRows) ColumnTypeLength(index int) (length int64, ok bool) {
+	return 0, false
+}
+
+func (rc *SQLiteRows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) {
+	return 0, 0, false
+}
+*/
+
+func (rc *SQLiteRows) ColumnTypeNullable(i int) (nullable, ok bool) {
+	return true, true
+}
+
+func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type {
+	switch C.sqlite3_column_type(rc.s.s, C.int(i)) {
+	case C.SQLITE_INTEGER:
+		switch C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))) {
+		case "timestamp", "datetime", "date":
+			return reflect.TypeOf(time.Time{})
+		case "boolean":
+			return reflect.TypeOf(false)
+		}
+		return reflect.TypeOf(int64(0))
+	case C.SQLITE_FLOAT:
+		return reflect.TypeOf(float64(0))
+	case C.SQLITE_BLOB:
+		return reflect.SliceOf(reflect.TypeOf(byte(0)))
+	case C.SQLITE_NULL:
+		return reflect.TypeOf(nil)
+	case C.SQLITE_TEXT:
+		return reflect.TypeOf("")
+	}
+	return reflect.SliceOf(reflect.TypeOf(byte(0)))
+}

From c95a77965c55783416165ca638dec12c0f0a9fdb Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 14:24:22 +0900
Subject: [PATCH 03/14] context features

---
 sqlite3.go         | 74 +++++++++++++++++++++++++++++++++++++++-------
 sqlite3_context.go | 14 ---------
 sqlite3_go18.go    | 32 ++++++++++++++++++++
 3 files changed, 95 insertions(+), 25 deletions(-)
 delete mode 100644 sqlite3_context.go
 create mode 100644 sqlite3_go18.go

diff --git a/sqlite3.go b/sqlite3.go
index de9d7d2..5087fad 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -114,6 +114,8 @@ import (
 	"strings"
 	"time"
 	"unsafe"
+
+	"golang.org/x/net/context"
 )
 
 // Timestamp formats understood by both this module and SQLite.
@@ -295,19 +297,19 @@ func (ai *aggInfo) Done(ctx *C.sqlite3_context) {
 
 // Commit transaction.
 func (tx *SQLiteTx) Commit() error {
-	_, err := tx.c.exec("COMMIT")
+	_, err := tx.c.execQuery("COMMIT")
 	if err != nil && err.(Error).Code == C.SQLITE_BUSY {
 		// sqlite3 will leave the transaction open in this scenario.
 		// However, database/sql considers the transaction complete once we
 		// return from Commit() - we must clean up to honour its semantics.
-		tx.c.exec("ROLLBACK")
+		tx.c.execQuery("ROLLBACK")
 	}
 	return err
 }
 
 // Rollback transaction.
 func (tx *SQLiteTx) Rollback() error {
-	_, err := tx.c.exec("ROLLBACK")
+	_, err := tx.c.execQuery("ROLLBACK")
 	return err
 }
 
@@ -404,9 +406,20 @@ func (c *SQLiteConn) lastError() Error {
 // Implements Execer
 func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error) {
 	if len(args) == 0 {
-		return c.exec(query)
+		return c.execQuery(query)
 	}
 
+	list := make([]namedValue, len(args))
+	for i, v := range args {
+		list[i] = namedValue{
+			Ordinal: i + 1,
+			Value:   v,
+		}
+	}
+	return c.exec(context.Background(), query, list)
+}
+
+func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue) (driver.Result, error) {
 	for {
 		s, err := c.Prepare(query)
 		if err != nil {
@@ -418,7 +431,7 @@ func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, err
 			if len(args) < na {
 				return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args))
 			}
-			res, err = s.Exec(args[:na])
+			res, err = s.(*SQLiteStmt).exec(ctx, args[:na])
 			if err != nil && err != driver.ErrSkip {
 				s.Close()
 				return nil, err
@@ -434,8 +447,25 @@ func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, err
 	}
 }
 
+type namedValue struct {
+	Name    string
+	Ordinal int
+	Value   driver.Value
+}
+
 // Implements Queryer
 func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error) {
+	list := make([]namedValue, len(args))
+	for i, v := range args {
+		list[i] = namedValue{
+			Ordinal: i + 1,
+			Value:   v,
+		}
+	}
+	return c.query(context.Background(), query, list)
+}
+
+func (c *SQLiteConn) query(ctx context.Context, query string, args []namedValue) (driver.Rows, error) {
 	for {
 		s, err := c.Prepare(query)
 		if err != nil {
@@ -446,7 +476,7 @@ func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, erro
 		if len(args) < na {
 			return nil, fmt.Errorf("Not enough args to execute query. Expected %d, got %d.", na, len(args))
 		}
-		rows, err := s.Query(args[:na])
+		rows, err := s.(*SQLiteStmt).query(ctx, args[:na])
 		if err != nil && err != driver.ErrSkip {
 			s.Close()
 			return nil, err
@@ -462,7 +492,7 @@ func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, erro
 	}
 }
 
-func (c *SQLiteConn) exec(cmd string) (driver.Result, error) {
+func (c *SQLiteConn) execQuery(cmd string) (driver.Result, error) {
 	pcmd := C.CString(cmd)
 	defer C.free(unsafe.Pointer(pcmd))
 
@@ -476,7 +506,7 @@ func (c *SQLiteConn) exec(cmd string) (driver.Result, error) {
 
 // Begin transaction.
 func (c *SQLiteConn) Begin() (driver.Tx, error) {
-	if _, err := c.exec(c.txlock); err != nil {
+	if _, err := c.execQuery(c.txlock); err != nil {
 		return nil, err
 	}
 	return &SQLiteTx{c}, nil
@@ -658,7 +688,7 @@ type bindArg struct {
 	v driver.Value
 }
 
-func (s *SQLiteStmt) bind(args []driver.Value) error {
+func (s *SQLiteStmt) bind(args []namedValue) error {
 	rv := C.sqlite3_reset(s.s)
 	if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE {
 		return s.c.lastError()
@@ -670,12 +700,12 @@ func (s *SQLiteStmt) bind(args []driver.Value) error {
 	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]}
+				vargs[i] = bindArg{pi, args[i].Value}
 			}
 		}
 	} else {
 		for i, v := range args {
-			vargs[i] = bindArg{i + 1, v}
+			vargs[i] = bindArg{i + 1, v.Value}
 		}
 	}
 
@@ -722,6 +752,17 @@ func (s *SQLiteStmt) bind(args []driver.Value) error {
 
 // Query the statement with arguments. Return records.
 func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error) {
+	list := make([]namedValue, len(args))
+	for i, v := range args {
+		list[i] = namedValue{
+			Ordinal: i + 1,
+			Value:   v,
+		}
+	}
+	return s.query(context.Background(), list)
+}
+
+func (s *SQLiteStmt) query(ctx context.Context, args []namedValue) (driver.Rows, error) {
 	if err := s.bind(args); err != nil {
 		return nil, err
 	}
@@ -740,6 +781,17 @@ func (r *SQLiteResult) RowsAffected() (int64, error) {
 
 // Execute the statement with arguments. Return result object.
 func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error) {
+	list := make([]namedValue, len(args))
+	for i, v := range args {
+		list[i] = namedValue{
+			Ordinal: i + 1,
+			Value:   v,
+		}
+	}
+	return s.exec(context.Background(), list)
+}
+
+func (s *SQLiteStmt) exec(ctx context.Context, args []namedValue) (driver.Result, error) {
 	if err := s.bind(args); err != nil {
 		C.sqlite3_reset(s.s)
 		C.sqlite3_clear_bindings(s.s)
diff --git a/sqlite3_context.go b/sqlite3_context.go
deleted file mode 100644
index 26e4998..0000000
--- a/sqlite3_context.go
+++ /dev/null
@@ -1,14 +0,0 @@
-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_go18.go b/sqlite3_go18.go
new file mode 100644
index 0000000..1ee4c6a
--- /dev/null
+++ b/sqlite3_go18.go
@@ -0,0 +1,32 @@
+package sqlite3
+
+import (
+	"database/sql/driver"
+	"errors"
+
+	"golang.org/x/net/context"
+)
+
+// Ping implement Pinger.
+func (c *SQLiteConn) Ping(ctx context.Context) error {
+	if c.db == nil {
+		return errors.New("Connection was closed")
+	}
+	return nil
+}
+
+func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
+	list := make([]namedValue, len(args))
+	for i, nv := range args {
+		list[i] = namedValue(nv)
+	}
+	return c.query(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 {
+		list[i] = namedValue(nv)
+	}
+	return s.query(ctx, list)
+}

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: [PATCH 04/14] support named params

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

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")
 	}

From 29b191f2068cf75cdb2f9e75274de95a3106b9a2 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 15:07:51 +0900
Subject: [PATCH 05/14] build tag

---
 sqlite3_go18.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sqlite3_go18.go b/sqlite3_go18.go
index 3993490..28a1bbf 100644
--- a/sqlite3_go18.go
+++ b/sqlite3_go18.go
@@ -1,3 +1,5 @@
+// +build go1.8
+
 package sqlite3
 
 import (

From 025b917610cf628e9be1dcf9386525d0dbc22659 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 15:11:24 +0900
Subject: [PATCH 06/14] add PrepareContext

---
 sqlite3.go      | 4 ++++
 sqlite3_go18.go | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/sqlite3.go b/sqlite3.go
index 3b80eeb..bef5627 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -644,6 +644,10 @@ func (c *SQLiteConn) Close() error {
 
 // Prepare the query string. Return a new statement.
 func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
+	return c.prepare(context.Background(), query)
+}
+
+func (c *SQLiteConn) prepare(ctx context.Context, query string) (driver.Stmt, error) {
 	pquery := C.CString(query)
 	defer C.free(unsafe.Pointer(pquery))
 	var s *C.sqlite3_stmt
diff --git a/sqlite3_go18.go b/sqlite3_go18.go
index 28a1bbf..5832a92 100644
--- a/sqlite3_go18.go
+++ b/sqlite3_go18.go
@@ -33,6 +33,10 @@ func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []drive
 	return c.exec(ctx, query, list)
 }
 
+func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
+	return c.prepare(ctx, query)
+}
+
 func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
 	list := make([]namedValue, len(args))
 	for i, nv := range args {

From 755d5be32c971580a8ae5ed32a6bd5ff774d722d Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Fri, 4 Nov 2016 15:15:16 +0900
Subject: [PATCH 07/14] add BeginContext

---
 sqlite3.go      | 4 ++++
 sqlite3_go18.go | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/sqlite3.go b/sqlite3.go
index bef5627..cf5e99a 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -514,6 +514,10 @@ func (c *SQLiteConn) execQuery(cmd string) (driver.Result, error) {
 
 // Begin transaction.
 func (c *SQLiteConn) Begin() (driver.Tx, error) {
+	return c.begin(context.Background())
+}
+
+func (c *SQLiteConn) begin(ctx context.Context) (driver.Tx, error) {
 	if _, err := c.execQuery(c.txlock); err != nil {
 		return nil, err
 	}
diff --git a/sqlite3_go18.go b/sqlite3_go18.go
index 5832a92..7109d58 100644
--- a/sqlite3_go18.go
+++ b/sqlite3_go18.go
@@ -37,6 +37,10 @@ func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.S
 	return c.prepare(ctx, query)
 }
 
+func (c *SQLiteConn) BeginContext(ctx context.Context) (driver.Tx, error) {
+	return c.begin(ctx)
+}
+
 func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
 	list := make([]namedValue, len(args))
 	for i, nv := range args {

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: [PATCH 08/14] 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

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)

From a9ad8a09c97c7ba4f4dbc7a6dd787fe7cdbefdbb Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sat, 5 Nov 2016 00:28:43 +0900
Subject: [PATCH 09/14] remove trailing space

---
 sqlite3_icu.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sqlite3_icu.go b/sqlite3_icu.go
index 4c5492b..e960626 100644
--- a/sqlite3_icu.go
+++ b/sqlite3_icu.go
@@ -2,7 +2,7 @@
 //
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
-// +build icu 
+// +build icu
 
 package sqlite3
 

From 0d1d1a644e704714e7ccf5e28dc53601c4e9cf37 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sat, 5 Nov 2016 00:40:06 +0900
Subject: [PATCH 10/14] go vet && golint

---
 backup.go                 | 14 +++++++----
 error.go                  |  1 +
 sqlite3.go                | 50 +++++++++++++++++++--------------------
 sqlite3_go18.go           |  6 +++++
 sqlite3_load_extension.go |  1 +
 tracecallback_noimpl.go   |  1 +
 6 files changed, 44 insertions(+), 29 deletions(-)

diff --git a/backup.go b/backup.go
index 05f8038..5ab3a54 100644
--- a/backup.go
+++ b/backup.go
@@ -19,10 +19,12 @@ import (
 	"unsafe"
 )
 
+// SQLiteBackup implement interface of Backup.
 type SQLiteBackup struct {
 	b *C.sqlite3_backup
 }
 
+// Backup make backup from src to dest.
 func (c *SQLiteConn) Backup(dest string, conn *SQLiteConn, src string) (*SQLiteBackup, error) {
 	destptr := C.CString(dest)
 	defer C.free(unsafe.Pointer(destptr))
@@ -37,10 +39,10 @@ func (c *SQLiteConn) Backup(dest string, conn *SQLiteConn, src string) (*SQLiteB
 	return nil, c.lastError()
 }
 
-// Backs up for one step. Calls the underlying `sqlite3_backup_step` function.
-// This function returns a boolean indicating if the backup is done and
-// an error signalling any other error. Done is returned if the underlying C
-// function returns SQLITE_DONE (Code 101)
+// Step to backs up for one step. Calls the underlying `sqlite3_backup_step`
+// function.  This function returns a boolean indicating if the backup is done
+// and an error signalling any other error. Done is returned if the underlying
+// C function returns SQLITE_DONE (Code 101)
 func (b *SQLiteBackup) Step(p int) (bool, error) {
 	ret := C.sqlite3_backup_step(b.b, C.int(p))
 	if ret == C.SQLITE_DONE {
@@ -51,18 +53,22 @@ func (b *SQLiteBackup) Step(p int) (bool, error) {
 	return false, nil
 }
 
+// Remaining return whether have the rest for backup.
 func (b *SQLiteBackup) Remaining() int {
 	return int(C.sqlite3_backup_remaining(b.b))
 }
 
+// PageCount return count of pages.
 func (b *SQLiteBackup) PageCount() int {
 	return int(C.sqlite3_backup_pagecount(b.b))
 }
 
+// Finish close backup.
 func (b *SQLiteBackup) Finish() error {
 	return b.Close()
 }
 
+// Close close backup.
 func (b *SQLiteBackup) Close() error {
 	ret := C.sqlite3_backup_finish(b.b)
 
diff --git a/error.go b/error.go
index b910108..474f8e6 100644
--- a/error.go
+++ b/error.go
@@ -7,6 +7,7 @@ package sqlite3
 
 import "C"
 
+// ErrNo inherit errno.
 type ErrNo int
 
 const ErrNoMask C.int = 0xff
diff --git a/sqlite3.go b/sqlite3.go
index cf5e99a..b018918 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -118,10 +118,10 @@ import (
 	"golang.org/x/net/context"
 )
 
-// Timestamp formats understood by both this module and SQLite.
-// The first format in the slice will be used when saving time values
-// into the database. When parsing a string from a timestamp or
-// datetime column, the formats are tried in order.
+// SQLiteTimestampFormats is timestamp formats understood by both this module
+// and SQLite.  The first format in the slice will be used when saving time
+// values into the database. When parsing a string from a timestamp or datetime
+// column, the formats are tried in order.
 var SQLiteTimestampFormats = []string{
 	// By default, store timestamps with whatever timezone they come with.
 	// When parsed, they will be returned with the same timezone.
@@ -141,20 +141,20 @@ func init() {
 }
 
 // Version returns SQLite library version information.
-func Version() (libVersion string, libVersionNumber int, sourceId string) {
+func Version() (libVersion string, libVersionNumber int, sourceID string) {
 	libVersion = C.GoString(C.sqlite3_libversion())
 	libVersionNumber = int(C.sqlite3_libversion_number())
-	sourceId = C.GoString(C.sqlite3_sourceid())
-	return libVersion, libVersionNumber, sourceId
+	sourceID = C.GoString(C.sqlite3_sourceid())
+	return libVersion, libVersionNumber, sourceID
 }
 
-// Driver struct.
+// SQLiteDriver implement sql.Driver.
 type SQLiteDriver struct {
 	Extensions  []string
 	ConnectHook func(*SQLiteConn) error
 }
 
-// Conn struct.
+// SQLiteConn implement sql.Conn.
 type SQLiteConn struct {
 	db          *C.sqlite3
 	loc         *time.Location
@@ -163,12 +163,12 @@ type SQLiteConn struct {
 	aggregators []*aggInfo
 }
 
-// Tx struct.
+// SQLiteTx implemen sql.Tx.
 type SQLiteTx struct {
 	c *SQLiteConn
 }
 
-// Stmt struct.
+// SQLiteStmt implement sql.Stmt.
 type SQLiteStmt struct {
 	c      *SQLiteConn
 	s      *C.sqlite3_stmt
@@ -177,13 +177,13 @@ type SQLiteStmt struct {
 	cls    bool
 }
 
-// Result struct.
+// SQLiteResult implement sql.Result.
 type SQLiteResult struct {
 	id      int64
 	changes int64
 }
 
-// Rows struct.
+// SQLiteRows implement sql.Rows.
 type SQLiteRows struct {
 	s        *SQLiteStmt
 	nc       int
@@ -401,7 +401,7 @@ func (c *SQLiteConn) lastError() Error {
 	}
 }
 
-// Implements Execer
+// Exec implements Execer.
 func (c *SQLiteConn) Exec(query string, args []driver.Value) (driver.Result, error) {
 	if len(args) == 0 {
 		return c.execQuery(query)
@@ -456,7 +456,7 @@ type namedValue struct {
 	Value   driver.Value
 }
 
-// Implements Queryer
+// Query implements Queryer.
 func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error) {
 	list := make([]namedValue, len(args))
 	for i, v := range args {
@@ -549,7 +549,7 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 
 	var loc *time.Location
 	txlock := "BEGIN"
-	busy_timeout := 5000
+	busyTimeout := 5000
 	pos := strings.IndexRune(dsn, '?')
 	if pos >= 1 {
 		params, err := url.ParseQuery(dsn[pos+1:])
@@ -575,7 +575,7 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 			if err != nil {
 				return nil, fmt.Errorf("Invalid _busy_timeout: %v: %v", val, err)
 			}
-			busy_timeout = int(iv)
+			busyTimeout = int(iv)
 		}
 
 		// _txlock
@@ -612,7 +612,7 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 		return nil, errors.New("sqlite succeeded without returning a database")
 	}
 
-	rv = C.sqlite3_busy_timeout(db, C.int(busy_timeout))
+	rv = C.sqlite3_busy_timeout(db, C.int(busyTimeout))
 	if rv != C.SQLITE_OK {
 		return nil, Error{Code: ErrNo(rv)}
 	}
@@ -686,7 +686,7 @@ func (s *SQLiteStmt) Close() error {
 	return nil
 }
 
-// Return a number of parameters.
+// NumInput return a number of parameters.
 func (s *SQLiteStmt) NumInput() int {
 	return int(C.sqlite3_bind_parameter_count(s.s))
 }
@@ -769,17 +769,17 @@ func (s *SQLiteStmt) query(ctx context.Context, args []namedValue) (driver.Rows,
 	return &SQLiteRows{s, int(C.sqlite3_column_count(s.s)), nil, nil, s.cls}, nil
 }
 
-// Return last inserted ID.
+// LastInsertId teturn last inserted ID.
 func (r *SQLiteResult) LastInsertId() (int64, error) {
 	return r.id, nil
 }
 
-// Return how many rows affected.
+// RowsAffected return how many rows affected.
 func (r *SQLiteResult) RowsAffected() (int64, error) {
 	return r.changes, nil
 }
 
-// Execute the statement with arguments. Return result object.
+// Exec execute the statement with arguments. Return result object.
 func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error) {
 	list := make([]namedValue, len(args))
 	for i, v := range args {
@@ -823,7 +823,7 @@ func (rc *SQLiteRows) Close() error {
 	return nil
 }
 
-// Return column names.
+// Columns return column names.
 func (rc *SQLiteRows) Columns() []string {
 	if rc.nc != len(rc.cols) {
 		rc.cols = make([]string, rc.nc)
@@ -834,7 +834,7 @@ func (rc *SQLiteRows) Columns() []string {
 	return rc.cols
 }
 
-// Return column types.
+// DeclTypes return column types.
 func (rc *SQLiteRows) DeclTypes() []string {
 	if rc.decltype == nil {
 		rc.decltype = make([]string, rc.nc)
@@ -845,7 +845,7 @@ func (rc *SQLiteRows) DeclTypes() []string {
 	return rc.decltype
 }
 
-// Move cursor to next.
+// Next move cursor to next.
 func (rc *SQLiteRows) Next(dest []driver.Value) error {
 	rv := C.sqlite3_step(rc.s.s)
 	if rv == C.SQLITE_DONE {
diff --git a/sqlite3_go18.go b/sqlite3_go18.go
index 7109d58..9ad7baf 100644
--- a/sqlite3_go18.go
+++ b/sqlite3_go18.go
@@ -17,6 +17,7 @@ func (c *SQLiteConn) Ping(ctx context.Context) error {
 	return nil
 }
 
+// QueryContext implement QueryerContext.
 func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
 	list := make([]namedValue, len(args))
 	for i, nv := range args {
@@ -25,6 +26,7 @@ func (c *SQLiteConn) QueryContext(ctx context.Context, query string, args []driv
 	return c.query(ctx, query, list)
 }
 
+// ExecContext implement ExecerContext.
 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 {
@@ -33,14 +35,17 @@ func (c *SQLiteConn) ExecContext(ctx context.Context, query string, args []drive
 	return c.exec(ctx, query, list)
 }
 
+// PrepareContext implement ConnPrepareContext.
 func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
 	return c.prepare(ctx, query)
 }
 
+// BeginContext implement ConnBeginContext.
 func (c *SQLiteConn) BeginContext(ctx context.Context) (driver.Tx, error) {
 	return c.begin(ctx)
 }
 
+// QueryContext implement QueryerContext.
 func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
 	list := make([]namedValue, len(args))
 	for i, nv := range args {
@@ -49,6 +54,7 @@ func (s *SQLiteStmt) QueryContext(ctx context.Context, args []driver.NamedValue)
 	return s.query(ctx, list)
 }
 
+// ExecContext implement ExecerContext.
 func (s *SQLiteStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
 	list := make([]namedValue, len(args))
 	for i, nv := range args {
diff --git a/sqlite3_load_extension.go b/sqlite3_load_extension.go
index e6e0801..b5bccb1 100644
--- a/sqlite3_load_extension.go
+++ b/sqlite3_load_extension.go
@@ -42,6 +42,7 @@ func (c *SQLiteConn) loadExtensions(extensions []string) error {
 	return nil
 }
 
+// LoadExtension load the sqlite3 extension.
 func (c *SQLiteConn) LoadExtension(lib string, entry string) error {
 	rv := C.sqlite3_enable_load_extension(c.db, 1)
 	if rv != C.SQLITE_OK {
diff --git a/tracecallback_noimpl.go b/tracecallback_noimpl.go
index c0a49e9..f270415 100644
--- a/tracecallback_noimpl.go
+++ b/tracecallback_noimpl.go
@@ -4,6 +4,7 @@ package sqlite3
 
 import "errors"
 
+// RegisterAggregator register the aggregator.
 func (c *SQLiteConn) RegisterAggregator(name string, impl interface{}, pure bool) error {
 	return errors.New("This feature is not implemented")
 }

From cde7293c72308f3cc5b57bfa65e162fb868470d8 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sat, 5 Nov 2016 00:46:04 +0900
Subject: [PATCH 11/14] go vet && golint

---
 error.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/error.go b/error.go
index 474f8e6..1f14aba 100644
--- a/error.go
+++ b/error.go
@@ -10,10 +10,13 @@ import "C"
 // ErrNo inherit errno.
 type ErrNo int
 
+// ErrNoMask is mask code.
 const ErrNoMask C.int = 0xff
 
+// ErrNoExtended is extended errno.
 type ErrNoExtended int
 
+// Error implement sqlite error code.
 type Error struct {
 	Code         ErrNo         /* The error code returned by SQLite */
 	ExtendedCode ErrNoExtended /* The extended error code returned by SQLite */
@@ -53,18 +56,22 @@ var (
 	ErrWarning    = ErrNo(28) /* Warnings from sqlite3_log() */
 )
 
+// Error return error message from errno.
 func (err ErrNo) Error() string {
 	return Error{Code: err}.Error()
 }
 
+// Extend return extended errno.
 func (err ErrNo) Extend(by int) ErrNoExtended {
 	return ErrNoExtended(int(err) | (by << 8))
 }
 
+// Error return error message that is extended code.
 func (err ErrNoExtended) Error() string {
 	return Error{Code: ErrNo(C.int(err) & ErrNoMask), ExtendedCode: err}.Error()
 }
 
+// Error return error message.
 func (err Error) Error() string {
 	if err.err != "" {
 		return err.err
@@ -122,7 +129,7 @@ var (
 	ErrConstraintTrigger      = ErrConstraint.Extend(7)
 	ErrConstraintUnique       = ErrConstraint.Extend(8)
 	ErrConstraintVTab         = ErrConstraint.Extend(9)
-	ErrConstraintRowId        = ErrConstraint.Extend(10)
+	ErrConstraintRowID        = ErrConstraint.Extend(10)
 	ErrNoticeRecoverWAL       = ErrNotice.Extend(1)
 	ErrNoticeRecoverRollback  = ErrNotice.Extend(2)
 	ErrWarningAutoIndex       = ErrWarning.Extend(1)

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: [PATCH 12/14] 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(-)

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:

From 605d9d08513fd3936c3d4a8631abd1db14136074 Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sun, 6 Nov 2016 20:43:53 +0900
Subject: [PATCH 13/14] cancel

---
 sqlite3.go | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/sqlite3.go b/sqlite3.go
index b018918..c1c42f0 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -190,6 +190,7 @@ type SQLiteRows struct {
 	cols     []string
 	decltype []string
 	cls      bool
+	done     chan struct{}
 }
 
 type functionInfo struct {
@@ -766,7 +767,26 @@ func (s *SQLiteStmt) query(ctx context.Context, args []namedValue) (driver.Rows,
 	if err := s.bind(args); err != nil {
 		return nil, err
 	}
-	return &SQLiteRows{s, int(C.sqlite3_column_count(s.s)), nil, nil, s.cls}, nil
+
+	rows := &SQLiteRows{
+		s:        s,
+		nc:       int(C.sqlite3_column_count(s.s)),
+		cols:     nil,
+		decltype: nil,
+		cls:      s.cls,
+		done:     make(chan struct{}),
+	}
+
+	go func() {
+		select {
+		case <-ctx.Done():
+			C.sqlite3_interrupt(s.c.db)
+			rows.Close()
+		case <-rows.done:
+		}
+	}()
+
+	return rows, nil
 }
 
 // LastInsertId teturn last inserted ID.
@@ -813,6 +833,10 @@ func (rc *SQLiteRows) Close() error {
 	if rc.s.closed {
 		return nil
 	}
+	if rc.done != nil {
+		close(rc.done)
+		rc.done = nil
+	}
 	if rc.cls {
 		return rc.s.Close()
 	}

From deed33aec73ebdd869ff5fc6dcb9a3bd5a039a7f Mon Sep 17 00:00:00 2001
From: Yasuhiro Matsumoto <mattn.jp@gmail.com>
Date: Sun, 6 Nov 2016 20:46:27 +0900
Subject: [PATCH 14/14] cancel

---
 sqlite3.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/sqlite3.go b/sqlite3.go
index c1c42f0..ac069e3 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -817,6 +817,17 @@ func (s *SQLiteStmt) exec(ctx context.Context, args []namedValue) (driver.Result
 		C.sqlite3_clear_bindings(s.s)
 		return nil, err
 	}
+
+	done := make(chan struct{})
+	defer close(done)
+	go func() {
+		select {
+		case <-ctx.Done():
+			C.sqlite3_interrupt(s.c.db)
+		case <-done:
+		}
+	}()
+
 	var rowid, changes C.longlong
 	rv := C._sqlite3_step(s.s, &rowid, &changes)
 	if rv != C.SQLITE_ROW && rv != C.SQLITE_OK && rv != C.SQLITE_DONE {
@@ -825,6 +836,7 @@ func (s *SQLiteStmt) exec(ctx context.Context, args []namedValue) (driver.Result
 		C.sqlite3_clear_bindings(s.s)
 		return nil, err
 	}
+
 	return &SQLiteResult{int64(rowid), int64(changes)}, nil
 }