Build with "go tool" and hackishly bundle code from same package into one file each

1 files changed, 5766 insertions, 0 deletions

diff --git a/tests/golite.go b/tests/golite.go
index 1988f6e..34ea5e4 100644
--- a/tests/golite.go
+++ b/tests/golite.go
@@ -1,8 +1,5774 @@
+// Copyright (C) 2019 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.
+
+// //go:build cgo // +build cgo
+
 package golite
 
 import (
+	"bytes"
+	"context"
+	"database/sql"
+	"database/sql/driver"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"math"
+	"math/rand"
+	"net/url"
+	"os"
+	"path"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+	"time"
 )
 
 
+
+// The number of rows of test data to create in the source database.
+// Can be used to control how many pages are available to be backed up.
+const testRowCount = 100
+
+// The maximum number of seconds after which the page-by-page backup is considered to have taken too long.
+const usePagePerStepsTimeoutSeconds = 30
+
+// Test the backup functionality.
+func testBackup(t *testing.T, testRowCount int, usePerPageSteps bool) {
+	// This function will be called multiple times.
+	// It uses sql.Register(), which requires the name parameter value to be unique.
+	// There does not currently appear to be a way to unregister a registered driver, however.
+	// So generate a database driver name that will likely be unique.
+	var driverName = fmt.Sprintf("sqlite3_testBackup_%v_%v_%v", testRowCount, usePerPageSteps, time.Now().UnixNano())
+
+	// The driver's connection will be needed in order to perform the backup.
+	driverConns := []*SQLiteConn{}
+	sql.Register(driverName, &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			driverConns = append(driverConns, conn)
+			return nil
+		},
+	})
+
+	// Connect to the source database.
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+	srcDb, err := sql.Open(driverName, srcTempFilename)
+	if err != nil {
+		t.Fatal("Failed to open the source database:", err)
+	}
+	defer srcDb.Close()
+	err = srcDb.Ping()
+	if err != nil {
+		t.Fatal("Failed to connect to the source database:", err)
+	}
+
+	// Connect to the destination database.
+	destTempFilename := TempFilename(t)
+	defer os.Remove(destTempFilename)
+	destDb, err := sql.Open(driverName, destTempFilename)
+	if err != nil {
+		t.Fatal("Failed to open the destination database:", err)
+	}
+	defer destDb.Close()
+	err = destDb.Ping()
+	if err != nil {
+		t.Fatal("Failed to connect to the destination database:", err)
+	}
+
+	// Check the driver connections.
+	if len(driverConns) != 2 {
+		t.Fatalf("Expected 2 driver connections, but found %v.", len(driverConns))
+	}
+	srcDbDriverConn := driverConns[0]
+	if srcDbDriverConn == nil {
+		t.Fatal("The source database driver connection is nil.")
+	}
+	destDbDriverConn := driverConns[1]
+	if destDbDriverConn == nil {
+		t.Fatal("The destination database driver connection is nil.")
+	}
+
+	// Generate some test data for the given ID.
+	var generateTestData = func(id int) string {
+		return fmt.Sprintf("test-%v", id)
+	}
+
+	// Populate the source database with a test table containing some test data.
+	tx, err := srcDb.Begin()
+	if err != nil {
+		t.Fatal("Failed to begin a transaction when populating the source database:", err)
+	}
+	_, err = srcDb.Exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)")
+	if err != nil {
+		tx.Rollback()
+		t.Fatal("Failed to create the source database \"test\" table:", err)
+	}
+	for id := 0; id < testRowCount; id++ {
+		_, err = srcDb.Exec("INSERT INTO test (id, value) VALUES (?, ?)", id, generateTestData(id))
+		if err != nil {
+			tx.Rollback()
+			t.Fatal("Failed to insert a row into the source database \"test\" table:", err)
+		}
+	}
+	err = tx.Commit()
+	if err != nil {
+		t.Fatal("Failed to populate the source database:", err)
+	}
+
+	// Confirm that the destination database is initially empty.
+	var destTableCount int
+	err = destDb.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type = 'table'").Scan(&destTableCount)
+	if err != nil {
+		t.Fatal("Failed to check the destination table count:", err)
+	}
+	if destTableCount != 0 {
+		t.Fatalf("The destination database is not empty; %v table(s) found.", destTableCount)
+	}
+
+	// Prepare to perform the backup.
+	backup, err := destDbDriverConn.Backup("main", srcDbDriverConn, "main")
+	if err != nil {
+		t.Fatal("Failed to initialize the backup:", err)
+	}
+
+	// Allow the initial page count and remaining values to be retrieved.
+	// According to <https://www.sqlite.org/c3ref/backup_finish.html>, the page count and remaining values are "... only updated by sqlite3_backup_step()."
+	isDone, err := backup.Step(0)
+	if err != nil {
+		t.Fatal("Unable to perform an initial 0-page backup step:", err)
+	}
+	if isDone {
+		t.Fatal("Backup is unexpectedly done.")
+	}
+
+	// Check that the page count and remaining values are reasonable.
+	initialPageCount := backup.PageCount()
+	if initialPageCount <= 0 {
+		t.Fatalf("Unexpected initial page count value: %v", initialPageCount)
+	}
+	initialRemaining := backup.Remaining()
+	if initialRemaining <= 0 {
+		t.Fatalf("Unexpected initial remaining value: %v", initialRemaining)
+	}
+	if initialRemaining != initialPageCount {
+		t.Fatalf("Initial remaining value differs from the initial page count value; remaining: %v; page count: %v", initialRemaining, initialPageCount)
+	}
+
+	// Perform the backup.
+	if usePerPageSteps {
+		var startTime = time.Now().Unix()
+
+		// Test backing-up using a page-by-page approach.
+		var latestRemaining = initialRemaining
+		for {
+			// Perform the backup step.
+			isDone, err = backup.Step(1)
+			if err != nil {
+				t.Fatal("Failed to perform a backup step:", err)
+			}
+
+			// The page count should remain unchanged from its initial value.
+			currentPageCount := backup.PageCount()
+			if currentPageCount != initialPageCount {
+				t.Fatalf("Current page count differs from the initial page count; initial page count: %v; current page count: %v", initialPageCount, currentPageCount)
+			}
+
+			// There should now be one less page remaining.
+			currentRemaining := backup.Remaining()
+			expectedRemaining := latestRemaining - 1
+			if currentRemaining != expectedRemaining {
+				t.Fatalf("Unexpected remaining value; expected remaining value: %v; actual remaining value: %v", expectedRemaining, currentRemaining)
+			}
+			latestRemaining = currentRemaining
+
+			if isDone {
+				break
+			}
+
+			// Limit the runtime of the backup attempt.
+			if (time.Now().Unix() - startTime) > usePagePerStepsTimeoutSeconds {
+				t.Fatal("Backup is taking longer than expected.")
+			}
+		}
+	} else {
+		// Test the copying of all remaining pages.
+		isDone, err = backup.Step(-1)
+		if err != nil {
+			t.Fatal("Failed to perform a backup step:", err)
+		}
+		if !isDone {
+			t.Fatal("Backup is unexpectedly not done.")
+		}
+	}
+
+	// Check that the page count and remaining values are reasonable.
+	finalPageCount := backup.PageCount()
+	if finalPageCount != initialPageCount {
+		t.Fatalf("Final page count differs from the initial page count; initial page count: %v; final page count: %v", initialPageCount, finalPageCount)
+	}
+	finalRemaining := backup.Remaining()
+	if finalRemaining != 0 {
+		t.Fatalf("Unexpected remaining value: %v", finalRemaining)
+	}
+
+	// Finish the backup.
+	err = backup.Finish()
+	if err != nil {
+		t.Fatal("Failed to finish backup:", err)
+	}
+
+	// Confirm that the "test" table now exists in the destination database.
+	var doesTestTableExist bool
+	err = destDb.QueryRow("SELECT EXISTS (SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'test' LIMIT 1) AS test_table_exists").Scan(&doesTestTableExist)
+	if err != nil {
+		t.Fatal("Failed to check if the \"test\" table exists in the destination database:", err)
+	}
+	if !doesTestTableExist {
+		t.Fatal("The \"test\" table could not be found in the destination database.")
+	}
+
+	// Confirm that the number of rows in the destination database's "test" table matches that of the source table.
+	var actualTestTableRowCount int
+	err = destDb.QueryRow("SELECT COUNT(*) FROM test").Scan(&actualTestTableRowCount)
+	if err != nil {
+		t.Fatal("Failed to determine the rowcount of the \"test\" table in the destination database:", err)
+	}
+	if testRowCount != actualTestTableRowCount {
+		t.Fatalf("Unexpected destination \"test\" table row count; expected: %v; found: %v", testRowCount, actualTestTableRowCount)
+	}
+
+	// Check each of the rows in the destination database.
+	for id := 0; id < testRowCount; id++ {
+		var checkedValue string
+		err = destDb.QueryRow("SELECT value FROM test WHERE id = ?", id).Scan(&checkedValue)
+		if err != nil {
+			t.Fatal("Failed to query the \"test\" table in the destination database:", err)
+		}
+
+		var expectedValue = generateTestData(id)
+		if checkedValue != expectedValue {
+			t.Fatalf("Unexpected value in the \"test\" table in the destination database; expected value: %v; actual value: %v", expectedValue, checkedValue)
+		}
+	}
+}
+
+func TestBackupStepByStep(t *testing.T) {
+	testBackup(t, testRowCount, true)
+}
+
+func TestBackupAllRemainingPages(t *testing.T) {
+	testBackup(t, testRowCount, false)
+}
+
+// Test the error reporting when preparing to perform a backup.
+func TestBackupError(t *testing.T) {
+	const driverName = "sqlite3_TestBackupError"
+
+	// The driver's connection will be needed in order to perform the backup.
+	var dbDriverConn *SQLiteConn
+	sql.Register(driverName, &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			dbDriverConn = conn
+			return nil
+		},
+	})
+
+	// Connect to the database.
+	dbTempFilename := TempFilename(t)
+	defer os.Remove(dbTempFilename)
+	db, err := sql.Open(driverName, dbTempFilename)
+	if err != nil {
+		t.Fatal("Failed to open the database:", err)
+	}
+	defer db.Close()
+	db.Ping()
+
+	// Need the driver connection in order to perform the backup.
+	if dbDriverConn == nil {
+		t.Fatal("Failed to get the driver connection.")
+	}
+
+	// Prepare to perform the backup.
+	// Intentionally using the same connection for both the source and destination databases, to trigger an error result.
+	backup, err := dbDriverConn.Backup("main", dbDriverConn, "main")
+	if err == nil {
+		t.Fatal("Failed to get the expected error result.")
+	}
+	const expectedError = "source and destination must be distinct"
+	if err.Error() != expectedError {
+		t.Fatalf("Unexpected error message; expected value: \"%v\"; actual value: \"%v\"", expectedError, err.Error())
+	}
+	if backup != nil {
+		t.Fatal("Failed to get the expected nil backup result.")
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build cgo // +build cgo
+
+func TestCallbackArgCast(t *testing.T) {
+	intConv := callbackSyntheticForTests(reflect.ValueOf(int64(math.MaxInt64)), nil)
+	floatConv := callbackSyntheticForTests(reflect.ValueOf(float64(math.MaxFloat64)), nil)
+	errConv := callbackSyntheticForTests(reflect.Value{}, errors.New("test"))
+
+	tests := []struct {
+		f callbackArgConverter
+		o reflect.Value
+	}{
+		{intConv, reflect.ValueOf(int8(-1))},
+		{intConv, reflect.ValueOf(int16(-1))},
+		{intConv, reflect.ValueOf(int32(-1))},
+		{intConv, reflect.ValueOf(uint8(math.MaxUint8))},
+		{intConv, reflect.ValueOf(uint16(math.MaxUint16))},
+		{intConv, reflect.ValueOf(uint32(math.MaxUint32))},
+		// Special case, int64->uint64 is only 1<<63 - 1, not 1<<64 - 1
+		{intConv, reflect.ValueOf(uint64(math.MaxInt64))},
+		{floatConv, reflect.ValueOf(float32(math.Inf(1)))},
+	}
+
+	for _, test := range tests {
+		conv := callbackArgCast{test.f, test.o.Type()}
+		val, err := conv.Run(nil)
+		if err != nil {
+			t.Errorf("Couldn't convert to %s: %s", test.o.Type(), err)
+		} else if !reflect.DeepEqual(val.Interface(), test.o.Interface()) {
+			t.Errorf("Unexpected result from converting to %s: got %v, want %v", test.o.Type(), val.Interface(), test.o.Interface())
+		}
+	}
+
+	conv := callbackArgCast{errConv, reflect.TypeOf(int8(0))}
+	_, err := conv.Run(nil)
+	if err == nil {
+		t.Errorf("Expected error during callbackArgCast, but got none")
+	}
+}
+
+func TestCallbackConverters(t *testing.T) {
+	tests := []struct {
+		v   any
+		err bool
+	}{
+		// Unfortunately, we can't tell which converter was returned,
+		// but we can at least check which types can be converted.
+		{[]byte{0}, false},
+		{"text", false},
+		{true, false},
+		{int8(0), false},
+		{int16(0), false},
+		{int32(0), false},
+		{int64(0), false},
+		{uint8(0), false},
+		{uint16(0), false},
+		{uint32(0), false},
+		{uint64(0), false},
+		{int(0), false},
+		{uint(0), false},
+		{float64(0), false},
+		{float32(0), false},
+
+		{func() {}, true},
+		{complex64(complex(0, 0)), true},
+		{complex128(complex(0, 0)), true},
+		{struct{}{}, true},
+		{map[string]string{}, true},
+		{[]string{}, true},
+		{(*int8)(nil), true},
+		{make(chan int), true},
+	}
+
+	for _, test := range tests {
+		_, err := callbackArg(reflect.TypeOf(test.v))
+		if test.err && err == nil {
+			t.Errorf("Expected an error when converting %s, got no error", reflect.TypeOf(test.v))
+		} else if !test.err && err != nil {
+			t.Errorf("Expected converter when converting %s, got error: %s", reflect.TypeOf(test.v), err)
+		}
+	}
+
+	for _, test := range tests {
+		_, err := callbackRet(reflect.TypeOf(test.v))
+		if test.err && err == nil {
+			t.Errorf("Expected an error when converting %s, got no error", reflect.TypeOf(test.v))
+		} else if !test.err && err != nil {
+			t.Errorf("Expected converter when converting %s, got error: %s", reflect.TypeOf(test.v), err)
+		}
+	}
+}
+
+func TestCallbackReturnAny(t *testing.T) {
+	udf := func() any {
+		return 1
+	}
+
+	typ := reflect.TypeOf(udf)
+	_, err := callbackRet(typ.Out(0))
+	if err != nil {
+		t.Errorf("Expected valid callback for any return type, got: %s", err)
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build cgo // +build cgo
+
+func TestSimpleError(t *testing.T) {
+	e := ErrError.Error()
+	if e != "SQL logic error or missing database" && e != "SQL logic error" {
+		t.Error("wrong error code: " + e)
+	}
+}
+
+func TestCorruptDbErrors(t *testing.T) {
+	dirName, err := ioutil.TempDir("", "sqlite3")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dirName)
+
+	dbFileName := path.Join(dirName, "test.db")
+	f, err := os.Create(dbFileName)
+	if err != nil {
+		t.Error(err)
+	}
+	f.Write([]byte{1, 2, 3, 4, 5})
+	f.Close()
+
+	db, err := sql.Open("sqlite3", dbFileName)
+	if err == nil {
+		_, err = db.Exec("drop table foo")
+	}
+
+	sqliteErr := err.(Error)
+	if sqliteErr.Code != ErrNotADB {
+		t.Error("wrong error code for corrupted DB")
+	}
+	if err.Error() == "" {
+		t.Error("wrong error string for corrupted DB")
+	}
+	db.Close()
+}
+
+func TestSqlLogicErrors(t *testing.T) {
+	dirName, err := ioutil.TempDir("", "sqlite3")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dirName)
+
+	dbFileName := path.Join(dirName, "test.db")
+	db, err := sql.Open("sqlite3", dbFileName)
+	if err != nil {
+		t.Error(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+	if err != nil {
+		t.Error(err)
+	}
+
+	const expectedErr = "table Foo already exists"
+	_, err = db.Exec("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+	if err.Error() != expectedErr {
+		t.Errorf("Unexpected error: %s, expected %s", err.Error(), expectedErr)
+	}
+
+}
+
+func TestExtendedErrorCodes_ForeignKey(t *testing.T) {
+	dirName, err := ioutil.TempDir("", "sqlite3-err")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dirName)
+
+	dbFileName := path.Join(dirName, "test.db")
+	db, err := sql.Open("sqlite3", dbFileName)
+	if err != nil {
+		t.Error(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("PRAGMA foreign_keys=ON;")
+	if err != nil {
+		t.Errorf("PRAGMA foreign_keys=ON: %v", err)
+	}
+
+	_, err = db.Exec(`CREATE TABLE Foo (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		value INTEGER NOT NULL,
+		ref INTEGER NULL REFERENCES Foo (id),
+		UNIQUE(value)
+	);`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = db.Exec("INSERT INTO Foo (ref, value) VALUES (100, 100);")
+	if err == nil {
+		t.Error("No error!")
+	} else {
+		sqliteErr := err.(Error)
+		if sqliteErr.Code != ErrConstraint {
+			t.Errorf("Wrong basic error code: %d != %d",
+				sqliteErr.Code, ErrConstraint)
+		}
+		if sqliteErr.ExtendedCode != ErrConstraintForeignKey {
+			t.Errorf("Wrong extended error code: %d != %d",
+				sqliteErr.ExtendedCode, ErrConstraintForeignKey)
+		}
+	}
+
+}
+
+func TestExtendedErrorCodes_NotNull(t *testing.T) {
+	dirName, err := ioutil.TempDir("", "sqlite3-err")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dirName)
+
+	dbFileName := path.Join(dirName, "test.db")
+	db, err := sql.Open("sqlite3", dbFileName)
+	if err != nil {
+		t.Error(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("PRAGMA foreign_keys=ON;")
+	if err != nil {
+		t.Errorf("PRAGMA foreign_keys=ON: %v", err)
+	}
+
+	_, err = db.Exec(`CREATE TABLE Foo (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		value INTEGER NOT NULL,
+		ref INTEGER NULL REFERENCES Foo (id),
+		UNIQUE(value)
+	);`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	res, err := db.Exec("INSERT INTO Foo (value) VALUES (100);")
+	if err != nil {
+		t.Fatalf("Creating first row: %v", err)
+	}
+
+	id, err := res.LastInsertId()
+	if err != nil {
+		t.Fatalf("Retrieving last insert id: %v", err)
+	}
+
+	_, err = db.Exec("INSERT INTO Foo (ref) VALUES (?);", id)
+	if err == nil {
+		t.Error("No error!")
+	} else {
+		sqliteErr := err.(Error)
+		if sqliteErr.Code != ErrConstraint {
+			t.Errorf("Wrong basic error code: %d != %d",
+				sqliteErr.Code, ErrConstraint)
+		}
+		if sqliteErr.ExtendedCode != ErrConstraintNotNull {
+			t.Errorf("Wrong extended error code: %d != %d",
+				sqliteErr.ExtendedCode, ErrConstraintNotNull)
+		}
+	}
+
+}
+
+func TestExtendedErrorCodes_Unique(t *testing.T) {
+	dirName, err := ioutil.TempDir("", "sqlite3-err")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dirName)
+
+	dbFileName := path.Join(dirName, "test.db")
+	db, err := sql.Open("sqlite3", dbFileName)
+	if err != nil {
+		t.Error(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("PRAGMA foreign_keys=ON;")
+	if err != nil {
+		t.Errorf("PRAGMA foreign_keys=ON: %v", err)
+	}
+
+	_, err = db.Exec(`CREATE TABLE Foo (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		value INTEGER NOT NULL,
+		ref INTEGER NULL REFERENCES Foo (id),
+		UNIQUE(value)
+	);`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	res, err := db.Exec("INSERT INTO Foo (value) VALUES (100);")
+	if err != nil {
+		t.Fatalf("Creating first row: %v", err)
+	}
+
+	id, err := res.LastInsertId()
+	if err != nil {
+		t.Fatalf("Retrieving last insert id: %v", err)
+	}
+
+	_, err = db.Exec("INSERT INTO Foo (ref, value) VALUES (?, 100);", id)
+	if err == nil {
+		t.Error("No error!")
+	} else {
+		sqliteErr := err.(Error)
+		if sqliteErr.Code != ErrConstraint {
+			t.Errorf("Wrong basic error code: %d != %d",
+				sqliteErr.Code, ErrConstraint)
+		}
+		if sqliteErr.ExtendedCode != ErrConstraintUnique {
+			t.Errorf("Wrong extended error code: %d != %d",
+				sqliteErr.ExtendedCode, ErrConstraintUnique)
+		}
+		extended := sqliteErr.Code.Extend(3).Error()
+		expected := "constraint failed"
+		if extended != expected {
+			t.Errorf("Wrong basic error code: %q != %q",
+				extended, expected)
+		}
+	}
+}
+
+func TestError_SystemErrno(t *testing.T) {
+	_, n, _ := Version()
+	if n < 3012000 {
+		t.Skip("sqlite3_system_errno requires sqlite3 >= 3.12.0")
+	}
+
+	// open a non-existent database in read-only mode so we get an IO error.
+	db, err := sql.Open("sqlite3", "file:nonexistent.db?mode=ro")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Ping()
+	if err == nil {
+		t.Fatal("expected error pinging read-only non-existent database, but got nil")
+	}
+
+	serr, ok := err.(Error)
+	if !ok {
+		t.Fatalf("expected error to be of type Error, but got %[1]T %[1]v", err)
+	}
+
+	if serr.SystemErrno == 0 {
+		t.Fatal("expected SystemErrno to be set")
+	}
+
+	if !os.IsNotExist(serr.SystemErrno) {
+		t.Errorf("expected SystemErrno to be a not exists error, but got %v", serr.SystemErrno)
+	}
+}
+// Copyright (C) 2018 G.J.R. Timmer <gjr.timmer@gmail.com>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+// TestCryptEncoders to increase coverage
+func TestCryptEncoders(t *testing.T) {
+	tests := []struct {
+		enc      string
+		salt     string
+		expected string
+	}{
+		{"sha1", "", "d033e22ae348aeb5660fc2140aec35850c4da997"},
+		{"sha256", "", "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918"},
+		{"sha384", "", "9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2ec9f10290cdc0782"},
+		{"sha512", "", "c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec"},
+		{"ssha1", "salt", "9bc7aa55f08fdad935c3f8362d3f48bcf70eb280"},
+		{"ssha256", "salt", "f9a81477552594c79f2abc3fc099daa896a6e3a3590a55ffa392b6000412e80b"},
+		{"ssha384", "salt", "9ed776b477fcfc1b5e584989e8d770f5e17d98a7643546a63c2b07d4ab00f1348f6b8e73103d3a23554f727136e8c215"},
+		{"ssha512", "salt", "3c4a79782143337be4492be072abcfe979dd703c00541a8c39a0f3df4bab2029c050cf46fddc47090b5b04ac537b3e78189e3de16e601e859f95c51ac9f6dafb"},
+	}
+
+	for _, e := range tests {
+		var fn func(pass []byte, hash any) []byte
+		switch e.enc {
+		case "sha1":
+			fn = CryptEncoderSHA1
+		case "ssha1":
+			fn = CryptEncoderSSHA1(e.salt)
+		case "sha256":
+			fn = CryptEncoderSHA256
+		case "ssha256":
+			fn = CryptEncoderSSHA256(e.salt)
+		case "sha384":
+			fn = CryptEncoderSHA384
+		case "ssha384":
+			fn = CryptEncoderSSHA384(e.salt)
+		case "sha512":
+			fn = CryptEncoderSHA512
+		case "ssha512":
+			fn = CryptEncoderSSHA512(e.salt)
+		}
+
+		h := fn([]byte("admin"), nil)
+		if strings.Compare(fmt.Sprintf("%x", h), e.expected) != 0 {
+			t.Fatalf("Invalid %s hash: expected: %s; got: %x", strings.ToUpper(e.enc), e.expected, h)
+		}
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build go1.13 && cgo // +build go1.13,cgo
+
+func TestBeginTxCancel(t *testing.T) {
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+
+	db, err := sql.Open("sqlite3", srcTempFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	db.SetMaxOpenConns(10)
+	db.SetMaxIdleConns(5)
+
+	defer db.Close()
+	initDatabase(t, db, 100)
+
+	// create several go-routines to expose racy issue
+	for i := 0; i < 1000; i++ {
+		func() {
+			ctx, cancel := context.WithCancel(context.Background())
+			conn, err := db.Conn(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := conn.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+
+			err = conn.Raw(func(driverConn any) error {
+				d, ok := driverConn.(driver.ConnBeginTx)
+				if !ok {
+					t.Fatal("unexpected: wrong type")
+				}
+				// checks that conn.Raw can be used to get *SQLiteConn
+				if _, ok = driverConn.(*SQLiteConn); !ok {
+					t.Fatalf("conn.Raw() driverConn type=%T, expected *SQLiteConn", driverConn)
+				}
+
+				go cancel() // make it cancel concurrently with exec("BEGIN");
+				tx, err := d.BeginTx(ctx, driver.TxOptions{})
+				switch err {
+				case nil:
+					switch err := tx.Rollback(); err {
+					case nil, sql.ErrTxDone:
+					default:
+						return err
+					}
+				case context.Canceled:
+				default:
+					// must not fail with "cannot start a transaction within a transaction"
+					return err
+				}
+				return nil
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+		}()
+	}
+}
+
+func TestStmtReadonly(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = db.Exec("CREATE TABLE t (count INT)")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	isRO := func(query string) bool {
+		c, err := db.Conn(context.Background())
+		if err != nil {
+			return false
+		}
+
+		var ro bool
+		c.Raw(func(dc any) error {
+			stmt, err := dc.(*SQLiteConn).Prepare(query)
+			if err != nil {
+				return err
+			}
+			if stmt == nil {
+				return errors.New("stmt is nil")
+			}
+			ro = stmt.(*SQLiteStmt).Readonly()
+			return nil
+		})
+		return ro // On errors ro will remain false.
+	}
+
+	if !isRO(`select * from t`) {
+		t.Error("select not seen as read-only")
+	}
+	if isRO(`insert into t values (1), (2)`) {
+		t.Error("insert seen as read-only")
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build go1.8 && cgo // +build go1.8,cgo
+
+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.Named("name", "foo"), sql.Named("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.Named("id", 1), sql.Named("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")
+	}
+}
+
+var (
+	testTableStatements = []string{
+		`DROP TABLE IF EXISTS test_table`,
+		`
+CREATE TABLE IF NOT EXISTS test_table (
+	key1      VARCHAR(64) PRIMARY KEY,
+	key_id    VARCHAR(64) NOT NULL,
+	key2      VARCHAR(64) NOT NULL,
+	key3      VARCHAR(64) NOT NULL,
+	key4      VARCHAR(64) NOT NULL,
+	key5      VARCHAR(64) NOT NULL,
+	key6      VARCHAR(64) NOT NULL,
+	data      BLOB        NOT NULL
+);`,
+	}
+	letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+)
+
+func randStringBytes(n int) string {
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = letterBytes[rand.Intn(len(letterBytes))]
+	}
+	return string(b)
+}
+
+func initDatabase(t *testing.T, db *sql.DB, rowCount int64) {
+	for _, query := range testTableStatements {
+		_, err := db.Exec(query)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	for i := int64(0); i < rowCount; i++ {
+		query := `INSERT INTO test_table
+			(key1, key_id, key2, key3, key4, key5, key6, data)
+			VALUES
+			(?, ?, ?, ?, ?, ?, ?, ?);`
+		args := []interface{}{
+			randStringBytes(50),
+			fmt.Sprint(i),
+			randStringBytes(50),
+			randStringBytes(50),
+			randStringBytes(50),
+			randStringBytes(50),
+			randStringBytes(50),
+			randStringBytes(50),
+			randStringBytes(2048),
+		}
+		_, err := db.Exec(query, args...)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestShortTimeout(t *testing.T) {
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+
+	db, err := sql.Open("sqlite3", srcTempFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	initDatabase(t, db, 100)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Microsecond)
+	defer cancel()
+	query := `SELECT key1, key_id, key2, key3, key4, key5, key6, data
+		FROM test_table
+		ORDER BY key2 ASC`
+	_, err = db.QueryContext(ctx, query)
+	if err != nil && err != context.DeadlineExceeded {
+		t.Fatal(err)
+	}
+	if ctx.Err() != nil && ctx.Err() != context.DeadlineExceeded {
+		t.Fatal(ctx.Err())
+	}
+}
+
+func TestExecContextCancel(t *testing.T) {
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+
+	db, err := sql.Open("sqlite3", srcTempFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	defer db.Close()
+
+	ts := time.Now()
+	initDatabase(t, db, 1000)
+	spent := time.Since(ts)
+	const minTestTime = 100 * time.Millisecond
+	if spent < minTestTime {
+		t.Skipf("test will be too racy (spent=%s < min=%s) as ExecContext below will be too fast.",
+			spent.String(), minTestTime.String(),
+		)
+	}
+
+	// expected to be extremely slow query
+	q := `
+INSERT INTO test_table (key1, key_id, key2, key3, key4, key5, key6, data)
+SELECT t1.key1 || t2.key1, t1.key_id || t2.key_id, t1.key2 || t2.key2, t1.key3 || t2.key3, t1.key4 || t2.key4, t1.key5 || t2.key5, t1.key6 || t2.key6, t1.data || t2.data
+FROM test_table t1 LEFT OUTER JOIN test_table t2`
+	// expect query above take ~ same time as setup above
+	// This is racy: the context must be valid so sql/db.ExecContext calls the sqlite3 driver.
+	// It starts the query, the context expires, then calls sqlite3_interrupt
+	ctx, cancel := context.WithTimeout(context.Background(), minTestTime/2)
+	defer cancel()
+	ts = time.Now()
+	r, err := db.ExecContext(ctx, q)
+	// racy check
+	if r != nil {
+		n, err := r.RowsAffected()
+		t.Logf("query should not have succeeded: rows=%d; err=%v; duration=%s",
+			n, err, time.Since(ts).String())
+	}
+	if err != context.DeadlineExceeded {
+		t.Fatal(err, ctx.Err())
+	}
+}
+
+func TestQueryRowContextCancel(t *testing.T) {
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+
+	db, err := sql.Open("sqlite3", srcTempFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	initDatabase(t, db, 100)
+
+	const query = `SELECT key_id FROM test_table ORDER BY key2 ASC`
+	var keyID string
+	unexpectedErrors := make(map[string]int)
+	for i := 0; i < 10000; i++ {
+		ctx, cancel := context.WithCancel(context.Background())
+		row := db.QueryRowContext(ctx, query)
+
+		cancel()
+		// it is fine to get "nil" as context cancellation can be handled with delay
+		if err := row.Scan(&keyID); err != nil && err != context.Canceled {
+			if err.Error() == "sql: Rows are closed" {
+				// see https://github.com/golang/go/issues/24431
+				// fixed in 1.11.1 to properly return context error
+				continue
+			}
+			unexpectedErrors[err.Error()]++
+		}
+	}
+	for errText, count := range unexpectedErrors {
+		t.Error(errText, count)
+	}
+}
+
+func TestQueryRowContextCancelParallel(t *testing.T) {
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+
+	db, err := sql.Open("sqlite3", srcTempFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	db.SetMaxOpenConns(10)
+	db.SetMaxIdleConns(5)
+
+	defer db.Close()
+	initDatabase(t, db, 100)
+
+	const query = `SELECT key_id FROM test_table ORDER BY key2 ASC`
+	wg := sync.WaitGroup{}
+	defer wg.Wait()
+
+	testCtx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			var keyID string
+			for {
+				select {
+				case <-testCtx.Done():
+					return
+				default:
+				}
+				ctx, cancel := context.WithCancel(context.Background())
+				row := db.QueryRowContext(ctx, query)
+
+				cancel()
+				_ = row.Scan(&keyID) // see TestQueryRowContextCancel
+			}
+		}()
+	}
+
+	var keyID string
+	for i := 0; i < 10000; i++ {
+		// note that testCtx is not cancelled during query execution
+		row := db.QueryRowContext(testCtx, query)
+
+		if err := row.Scan(&keyID); err != nil {
+			t.Fatal(i, err)
+		}
+	}
+}
+
+func TestExecCancel(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	if _, err = db.Exec("create table foo (id integer primary key)"); err != nil {
+		t.Fatal(err)
+	}
+
+	for n := 0; n < 100; n++ {
+		ctx, cancel := context.WithCancel(context.Background())
+		_, err = db.ExecContext(ctx, "insert into foo (id) values (?)", n)
+		cancel()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func doTestOpenContext(t *testing.T, option string) (string, error) {
+	tempFilename := TempFilename(t)
+	url := tempFilename + option
+
+	defer func() {
+		err := os.Remove(tempFilename)
+		if err != nil {
+			t.Error("temp file remove error:", err)
+		}
+	}()
+
+	db, err := sql.Open("sqlite3", url)
+	if err != nil {
+		return "Failed to open database:", err
+	}
+
+	defer func() {
+		err = db.Close()
+		if err != nil {
+			t.Error("db close error:", err)
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 55*time.Second)
+	err = db.PingContext(ctx)
+	cancel()
+	if err != nil {
+		return "ping error:", err
+	}
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "drop table foo")
+	cancel()
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "create table foo (id integer)")
+	cancel()
+	if err != nil {
+		return "Failed to create table:", err
+	}
+
+	if stat, err := os.Stat(tempFilename); err != nil || stat.IsDir() {
+		return "Failed to create ./foo.db", nil
+	}
+
+	return "", nil
+}
+
+func TestOpenContext(t *testing.T) {
+	cases := map[string]bool{
+		"":                   true,
+		"?_txlock=immediate": true,
+		"?_txlock=deferred":  true,
+		"?_txlock=exclusive": true,
+		"?_txlock=bogus":     false,
+	}
+	for option, expectedPass := range cases {
+		result, err := doTestOpenContext(t, option)
+		if result == "" {
+			if !expectedPass {
+				errmsg := fmt.Sprintf("_txlock error not caught at dbOpen with option: %s", option)
+				t.Fatal(errmsg)
+			}
+		} else if expectedPass {
+			if err == nil {
+				t.Fatal(result)
+			} else {
+				t.Fatal(result, err)
+			}
+		}
+	}
+}
+
+func TestFileCopyTruncate(t *testing.T) {
+	var err error
+	tempFilename := TempFilename(t)
+
+	defer func() {
+		err = os.Remove(tempFilename)
+		if err != nil {
+			t.Error("temp file remove error:", err)
+		}
+	}()
+
+	db, err := sql.Open("sqlite3", tempFilename)
+	if err != nil {
+		t.Fatal("open error:", err)
+	}
+
+	defer func() {
+		err = db.Close()
+		if err != nil {
+			t.Error("db close error:", err)
+		}
+	}()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 55*time.Second)
+	err = db.PingContext(ctx)
+	cancel()
+	if err != nil {
+		t.Fatal("ping error:", err)
+	}
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "drop table foo")
+	cancel()
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "create table foo (id integer)")
+	cancel()
+	if err != nil {
+		t.Fatal("create table error:", err)
+	}
+
+	// copy db to new file
+	var data []byte
+	data, err = ioutil.ReadFile(tempFilename)
+	if err != nil {
+		t.Fatal("read file error:", err)
+	}
+
+	var f *os.File
+	f, err = os.Create(tempFilename + "-db-copy")
+	if err != nil {
+		t.Fatal("create file error:", err)
+	}
+
+	defer func() {
+		err = os.Remove(tempFilename + "-db-copy")
+		if err != nil {
+			t.Error("temp file moved remove error:", err)
+		}
+	}()
+
+	_, err = f.Write(data)
+	if err != nil {
+		f.Close()
+		t.Fatal("write file error:", err)
+	}
+	err = f.Close()
+	if err != nil {
+		t.Fatal("close file error:", err)
+	}
+
+	// truncate current db file
+	f, err = os.OpenFile(tempFilename, os.O_WRONLY|os.O_TRUNC, 0666)
+	if err != nil {
+		t.Fatal("open file error:", err)
+	}
+	err = f.Close()
+	if err != nil {
+		t.Fatal("close file error:", err)
+	}
+
+	// test db after file truncate
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	err = db.PingContext(ctx)
+	cancel()
+	if err != nil {
+		t.Fatal("ping error:", err)
+	}
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "drop table foo")
+	cancel()
+	if err == nil {
+		t.Fatal("drop table no error")
+	}
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "create table foo (id integer)")
+	cancel()
+	if err != nil {
+		t.Fatal("create table error:", err)
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Error("db close error:", err)
+	}
+
+	// test copied file
+	db, err = sql.Open("sqlite3", tempFilename+"-db-copy")
+	if err != nil {
+		t.Fatal("open error:", err)
+	}
+
+	defer func() {
+		err = db.Close()
+		if err != nil {
+			t.Error("db close error:", err)
+		}
+	}()
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	err = db.PingContext(ctx)
+	cancel()
+	if err != nil {
+		t.Fatal("ping error:", err)
+	}
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "drop table foo")
+	cancel()
+	if err != nil {
+		t.Fatal("drop table error:", err)
+	}
+
+	ctx, cancel = context.WithTimeout(context.Background(), 55*time.Second)
+	_, err = db.ExecContext(ctx, "create table foo (id integer)")
+	cancel()
+	if err != nil {
+		t.Fatal("create table error:", err)
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build !sqlite_omit_load_extension // +build !sqlite_omit_load_extension
+
+func TestExtensionsError(t *testing.T) {
+	sql.Register("sqlite3_TestExtensionsError",
+		&SQLiteDriver{
+			Extensions: []string{
+				"foobar",
+			},
+		},
+	)
+
+	db, err := sql.Open("sqlite3_TestExtensionsError", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Ping()
+	if err == nil {
+		t.Fatal("expected error loading non-existent extension")
+	}
+
+	if err.Error() == "not an error" {
+		t.Fatal("expected error from sqlite3_enable_load_extension to be returned")
+	}
+}
+
+func TestLoadExtensionError(t *testing.T) {
+	sql.Register("sqlite3_TestLoadExtensionError",
+		&SQLiteDriver{
+			ConnectHook: func(c *SQLiteConn) error {
+				return c.LoadExtension("foobar", "")
+			},
+		},
+	)
+
+	db, err := sql.Open("sqlite3_TestLoadExtensionError", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Ping()
+	if err == nil {
+		t.Fatal("expected error loading non-existent extension")
+	}
+
+	if err.Error() == "not an error" {
+		t.Fatal("expected error from sqlite3_enable_load_extension to be returned")
+	}
+}
+// //go:build sqlite_column_metadata // +build sqlite_column_metadata
+
+func TestColumnTableName(t *testing.T) {
+	d := SQLiteDriver{}
+	conn, err := d.Open(":memory:")
+	if err != nil {
+		t.Fatal("failed to get database connection:", err)
+	}
+	defer conn.Close()
+	sqlite3conn := conn.(*SQLiteConn)
+
+	_, err = sqlite3conn.Exec(`CREATE TABLE foo (name string)`, nil)
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+	_, err = sqlite3conn.Exec(`CREATE TABLE bar (name string)`, nil)
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	stmt, err := sqlite3conn.Prepare(`SELECT * FROM foo JOIN bar ON foo.name = bar.name`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if exp, got := "foo", stmt.(*SQLiteStmt).ColumnTableName(0); exp != got {
+		t.Fatalf("Incorrect table name returned expected: %s, got: %s", exp, got)
+	}
+	if exp, got := "bar", stmt.(*SQLiteStmt).ColumnTableName(1); exp != got {
+		t.Fatalf("Incorrect table name returned expected: %s, got: %s", exp, got)
+	}
+	if exp, got := "", stmt.(*SQLiteStmt).ColumnTableName(2); exp != got {
+		t.Fatalf("Incorrect table name returned expected: %s, got: %s", exp, got)
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build cgo // +build cgo
+
+func TestFTS3(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("DROP TABLE foo")
+	_, err = db.Exec("CREATE VIRTUAL TABLE foo USING fts3(id INTEGER PRIMARY KEY, value TEXT)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(?, ?)", 1, `今日の 晩御飯は 天麩羅よ`)
+	if err != nil {
+		t.Fatal("Failed to insert value:", err)
+	}
+
+	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(?, ?)", 2, `今日は いい 天気だ`)
+	if err != nil {
+		t.Fatal("Failed to insert value:", err)
+	}
+
+	rows, err := db.Query("SELECT id, value FROM foo WHERE value MATCH '今日* 天*'")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id int
+		var value string
+
+		if err := rows.Scan(&id, &value); err != nil {
+			t.Error("Unable to scan results:", err)
+			continue
+		}
+
+		if id == 1 && value != `今日の 晩御飯は 天麩羅よ` {
+			t.Error("Value for id 1 should be `今日の 晩御飯は 天麩羅よ`, but:", value)
+		} else if id == 2 && value != `今日は いい 天気だ` {
+			t.Error("Value for id 2 should be `今日は いい 天気だ`, but:", value)
+		}
+	}
+
+	rows, err = db.Query("SELECT value FROM foo WHERE value MATCH '今日* 天麩羅*'")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+	defer rows.Close()
+
+	var value string
+	if !rows.Next() {
+		t.Fatal("Result should be only one")
+	}
+
+	if err := rows.Scan(&value); err != nil {
+		t.Fatal("Unable to scan results:", err)
+	}
+
+	if value != `今日の 晩御飯は 天麩羅よ` {
+		t.Fatal("Value should be `今日の 晩御飯は 天麩羅よ`, but:", value)
+	}
+
+	if rows.Next() {
+		t.Fatal("Result should be only one")
+	}
+}
+
+func TestFTS4(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("DROP TABLE foo")
+	_, err = db.Exec("CREATE VIRTUAL TABLE foo USING fts4(tokenize=unicode61, id INTEGER PRIMARY KEY, value TEXT)")
+	switch {
+	case err != nil && err.Error() == "unknown tokenizer: unicode61":
+		t.Skip("FTS4 not supported")
+	case err != nil:
+		t.Fatal("Failed to create table:", err)
+	}
+
+	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(?, ?)", 1, `février`)
+	if err != nil {
+		t.Fatal("Failed to insert value:", err)
+	}
+
+	rows, err := db.Query("SELECT value FROM foo WHERE value MATCH 'fevrier'")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+	defer rows.Close()
+
+	var value string
+	if !rows.Next() {
+		t.Fatal("Result should be only one")
+	}
+
+	if err := rows.Scan(&value); err != nil {
+		t.Fatal("Unable to scan results:", err)
+	}
+
+	if value != `février` {
+		t.Fatal("Value should be `février`, but:", value)
+	}
+
+	if rows.Next() {
+		t.Fatal("Result should be only one")
+	}
+}
+// //go:build sqlite_math_functions // +build sqlite_math_functions
+
+func TestMathFunctions(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	queries := []string{
+		`SELECT acos(1)`,
+		`SELECT log(10, 100)`,
+		`SELECT power(2, 2)`,
+	}
+
+	for _, query := range queries {
+		var result float64
+		if err := db.QueryRow(query).Scan(&result); err != nil {
+			t.Errorf("invoking math function query %q: %v", query, err)
+		}
+	}
+}
+// Copyright (C) 2019 G.J.R. Timmer <gjr.timmer@gmail.com>.
+// Copyright (C) 2018 segment.com <friends@segment.com>
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+// //go:build sqlite_preupdate_hook // +build sqlite_preupdate_hook
+
+type preUpdateHookDataForTest struct {
+	databaseName string
+	tableName    string
+	count        int
+	op           int
+	oldRow       []any
+	newRow       []any
+}
+
+/*
+func TestPreUpdateHook(t *testing.T) {
+	var events []preUpdateHookDataForTest
+
+	sql.Register("sqlite3_PreUpdateHook", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			conn.RegisterPreUpdateHook(func(data SQLitePreUpdateData) {
+				eval := -1
+				oldRow := []any{eval}
+				if data.Op != SQLITE_INSERT {
+					err := data.Old(oldRow...)
+					if err != nil {
+						t.Fatalf("Unexpected error calling SQLitePreUpdateData.Old: %v", err)
+					}
+				}
+
+				eval2 := -1
+				newRow := []any{eval2}
+				if data.Op != SQLITE_DELETE {
+					err := data.New(newRow...)
+					if err != nil {
+						t.Fatalf("Unexpected error calling SQLitePreUpdateData.New: %v", err)
+					}
+				}
+
+				// tests dest bound checks in loop
+				var tooSmallRow []any
+				if data.Op != SQLITE_INSERT {
+					err := data.Old(tooSmallRow...)
+					if err != nil {
+						t.Fatalf("Unexpected error calling SQLitePreUpdateData.Old: %v", err)
+					}
+					if len(tooSmallRow) != 0 {
+						t.Errorf("Expected tooSmallRow to be empty, got: %v", tooSmallRow)
+					}
+				}
+
+				events = append(events, preUpdateHookDataForTest{
+					databaseName: data.DatabaseName,
+					tableName:    data.TableName,
+					count:        data.Count(),
+					op:           data.Op,
+					oldRow:       oldRow,
+					newRow:       newRow,
+				})
+			})
+			return nil
+		},
+	})
+
+	db, err := sql.Open("sqlite3_PreUpdateHook", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	statements := []string{
+		"create table foo (id integer primary key)",
+		"insert into foo values (9)",
+		"update foo set id = 99 where id = 9",
+		"delete from foo where id = 99",
+	}
+	for _, statement := range statements {
+		_, err = db.Exec(statement)
+		if err != nil {
+			t.Fatalf("Unable to prepare test data [%v]: %v", statement, err)
+		}
+	}
+
+	if len(events) != 3 {
+		t.Errorf("Events should be 3 entries, got: %d", len(events))
+	}
+
+	if events[0].op != SQLITE_INSERT {
+		t.Errorf("Op isn't as expected: %v", events[0].op)
+	}
+
+	if events[1].op != SQLITE_UPDATE {
+		t.Errorf("Op isn't as expected: %v", events[1].op)
+	}
+
+	if events[1].count != 1 {
+		t.Errorf("Expected event row 1 to have 1 column, had: %v", events[1].count)
+	}
+
+	newRow_0_0 := events[0].newRow[0].(int64)
+	if newRow_0_0 != 9 {
+		t.Errorf("Expected event row 0 new column 0 to be == 9, got: %v", newRow_0_0)
+	}
+
+	oldRow_1_0 := events[1].oldRow[0].(int64)
+	if oldRow_1_0 != 9 {
+		t.Errorf("Expected event row 1 old column 0 to be == 9, got: %v", oldRow_1_0)
+	}
+
+	newRow_1_0 := events[1].newRow[0].(int64)
+	if newRow_1_0 != 99 {
+		t.Errorf("Expected event row 1 new column 0 to be == 99, got: %v", newRow_1_0)
+	}
+
+	oldRow_2_0 := events[2].oldRow[0].(int64)
+	if oldRow_2_0 != 99 {
+		t.Errorf("Expected event row 1 new column 0 to be == 99, got: %v", oldRow_2_0)
+	}
+}
+*/
+// //go:build !libsqlite3 || sqlite_serialize // +build !libsqlite3 sqlite_serialize
+
+func TestSerializeDeserialize(t *testing.T) {
+	// Connect to the source database.
+	srcTempFilename := TempFilename(t)
+	defer os.Remove(srcTempFilename)
+	srcDb, err := sql.Open(driverName, srcTempFilename)
+	if err != nil {
+		t.Fatal("Failed to open the source database:", err)
+	}
+	defer srcDb.Close()
+	err = srcDb.Ping()
+	if err != nil {
+		t.Fatal("Failed to connect to the source database:", err)
+	}
+
+	// Connect to the destination database.
+	destTempFilename := TempFilename(t)
+	defer os.Remove(destTempFilename)
+	destDb, err := sql.Open(driverName, destTempFilename)
+	if err != nil {
+		t.Fatal("Failed to open the destination database:", err)
+	}
+	defer destDb.Close()
+	err = destDb.Ping()
+	if err != nil {
+		t.Fatal("Failed to connect to the destination database:", err)
+	}
+
+	// Write data to source database.
+	_, err = srcDb.Exec(`CREATE TABLE foo (name string)`)
+	if err != nil {
+		t.Fatal("Failed to create table in source database:", err)
+	}
+	_, err = srcDb.Exec(`INSERT INTO foo(name) VALUES("alice")`)
+	if err != nil {
+		t.Fatal("Failed to insert data into source database", err)
+	}
+
+	// Serialize the source database
+	srcConn, err := srcDb.Conn(context.Background())
+	if err != nil {
+		t.Fatal("Failed to get connection to source database:", err)
+	}
+	defer srcConn.Close()
+
+	var serialized []byte
+	if err := srcConn.Raw(func(raw any) error {
+		var err error
+		serialized, err = raw.(*SQLiteConn).Serialize("")
+		return err
+	}); err != nil {
+		t.Fatal("Failed to serialize source database:", err)
+	}
+	srcConn.Close()
+
+	// Confirm that the destination database is initially empty.
+	var destTableCount int
+	err = destDb.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type = 'table'").Scan(&destTableCount)
+	if err != nil {
+		t.Fatal("Failed to check the destination table count:", err)
+	}
+	if destTableCount != 0 {
+		t.Fatalf("The destination database is not empty; %v table(s) found.", destTableCount)
+	}
+
+	// Deserialize to destination database
+	destConn, err := destDb.Conn(context.Background())
+	if err != nil {
+		t.Fatal("Failed to get connection to destination database:", err)
+	}
+	defer destConn.Close()
+
+	if err := destConn.Raw(func(raw any) error {
+		return raw.(*SQLiteConn).Deserialize(serialized, "")
+	}); err != nil {
+		t.Fatal("Failed to deserialize source database:", err)
+	}
+	destConn.Close()
+
+	// Confirm that destination database has been loaded correctly.
+	var destRowCount int
+	err = destDb.QueryRow(`SELECT COUNT(*) FROM foo`).Scan(&destRowCount)
+	if err != nil {
+		t.Fatal("Failed to count rows in destination database table", err)
+	}
+	if destRowCount != 1 {
+		t.Fatalf("Destination table does not have the expected records")
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build sqlite_unlock_notify // +build sqlite_unlock_notify
+
+func TestUnlockNotify(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	dsn := fmt.Sprintf("file:%s?cache=shared&mode=rwc&_busy_timeout=%d", tempFilename, 500)
+	db, err := sql.Open("sqlite3", dsn)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE foo(id INTEGER, status INTEGER)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal("Failed to begin transaction:", err)
+	}
+
+	_, err = tx.Exec("INSERT INTO foo(id, status) VALUES(1, 100)")
+	if err != nil {
+		t.Fatal("Failed to insert null:", err)
+	}
+
+	_, err = tx.Exec("UPDATE foo SET status = 200 WHERE id = 1")
+	if err != nil {
+		t.Fatal("Failed to update table:", err)
+	}
+
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	timer := time.NewTimer(500 * time.Millisecond)
+	go func() {
+		<-timer.C
+		err := tx.Commit()
+		if err != nil {
+			t.Fatal("Failed to commit transaction:", err)
+		}
+		wg.Done()
+	}()
+
+	rows, err := db.Query("SELECT count(*) from foo")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	if rows.Next() {
+		var count int
+		if err := rows.Scan(&count); err != nil {
+			t.Fatal("Failed to Scan rows", err)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal("Failed at the call to Next:", err)
+	}
+	wg.Wait()
+
+}
+
+func TestUnlockNotifyMany(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	dsn := fmt.Sprintf("file:%s?cache=shared&mode=rwc&_busy_timeout=%d", tempFilename, 500)
+	db, err := sql.Open("sqlite3", dsn)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE foo(id INTEGER, status INTEGER)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal("Failed to begin transaction:", err)
+	}
+
+	_, err = tx.Exec("INSERT INTO foo(id, status) VALUES(1, 100)")
+	if err != nil {
+		t.Fatal("Failed to insert null:", err)
+	}
+
+	_, err = tx.Exec("UPDATE foo SET status = 200 WHERE id = 1")
+	if err != nil {
+		t.Fatal("Failed to update table:", err)
+	}
+
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	timer := time.NewTimer(500 * time.Millisecond)
+	go func() {
+		<-timer.C
+		err := tx.Commit()
+		if err != nil {
+			t.Fatal("Failed to commit transaction:", err)
+		}
+		wg.Done()
+	}()
+
+	const concurrentQueries = 1000
+	wg.Add(concurrentQueries)
+	for i := 0; i < concurrentQueries; i++ {
+		go func() {
+			rows, err := db.Query("SELECT count(*) from foo")
+			if err != nil {
+				t.Fatal("Unable to query foo table:", err)
+			}
+
+			if rows.Next() {
+				var count int
+				if err := rows.Scan(&count); err != nil {
+					t.Fatal("Failed to Scan rows", err)
+				}
+			}
+			if err := rows.Err(); err != nil {
+				t.Fatal("Failed at the call to Next:", err)
+			}
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+}
+
+func TestUnlockNotifyDeadlock(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	dsn := fmt.Sprintf("file:%s?cache=shared&mode=rwc&_busy_timeout=%d", tempFilename, 500)
+	db, err := sql.Open("sqlite3", dsn)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE foo(id INTEGER, status INTEGER)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal("Failed to begin transaction:", err)
+	}
+
+	_, err = tx.Exec("INSERT INTO foo(id, status) VALUES(1, 100)")
+	if err != nil {
+		t.Fatal("Failed to insert null:", err)
+	}
+
+	_, err = tx.Exec("UPDATE foo SET status = 200 WHERE id = 1")
+	if err != nil {
+		t.Fatal("Failed to update table:", err)
+	}
+
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	timer := time.NewTimer(500 * time.Millisecond)
+	go func() {
+		<-timer.C
+		err := tx.Commit()
+		if err != nil {
+			t.Fatal("Failed to commit transaction:", err)
+		}
+		wg.Done()
+	}()
+
+	wg.Add(1)
+	go func() {
+		tx2, err := db.Begin()
+		if err != nil {
+			t.Fatal("Failed to begin transaction:", err)
+		}
+		defer tx2.Rollback()
+
+		_, err = tx2.Exec("DELETE FROM foo")
+		if err != nil {
+			t.Fatal("Failed to delete table:", err)
+		}
+		err = tx2.Commit()
+		if err != nil {
+			t.Fatal("Failed to commit transaction:", err)
+		}
+		wg.Done()
+	}()
+
+	rows, err := tx.Query("SELECT count(*) from foo")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	if rows.Next() {
+		var count int
+		if err := rows.Scan(&count); err != nil {
+			t.Fatal("Failed to Scan rows", err)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal("Failed at the call to Next:", err)
+	}
+
+	wg.Wait()
+}
+// Copyright (C) 2018 G.J.R. Timmer <gjr.timmer@gmail.com>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+// //go:build sqlite_userauth // +build sqlite_userauth
+
+var (
+	conn             *SQLiteConn
+	create           func(t *testing.T, username, password string) (file string, err error)
+	createWithCrypt  func(t *testing.T, username, password, crypt, salt string) (file string, err error)
+	connect          func(t *testing.T, f string, username, password string) (file string, db *sql.DB, c *SQLiteConn, err error)
+	connectWithCrypt func(t *testing.T, f string, username, password string, crypt string, salt string) (file string, db *sql.DB, c *SQLiteConn, err error)
+	authEnabled      func(db *sql.DB) (exists bool, err error)
+	addUser          func(db *sql.DB, username, password string, admin int) (rv int, err error)
+	userExists       func(db *sql.DB, username string) (rv int, err error)
+	isAdmin          func(db *sql.DB, username string) (rv bool, err error)
+	modifyUser       func(db *sql.DB, username, password string, admin int) (rv int, err error)
+	deleteUser       func(db *sql.DB, username string) (rv int, err error)
+)
+
+func init() {
+	// Create database connection
+	sql.Register("sqlite3_with_conn",
+		&SQLiteDriver{
+			ConnectHook: func(c *SQLiteConn) error {
+				conn = c
+				return nil
+			},
+		})
+
+	create = func(t *testing.T, username, password string) (file string, err error) {
+		var db *sql.DB
+		file, db, _, err = connect(t, "", username, password)
+		db.Close()
+		return
+	}
+
+	createWithCrypt = func(t *testing.T, username, password, crypt, salt string) (file string, err error) {
+		var db *sql.DB
+		file, db, _, err = connectWithCrypt(t, "", "admin", "admin", crypt, salt)
+		db.Close()
+		return
+	}
+
+	connect = func(t *testing.T, f string, username, password string) (file string, db *sql.DB, c *SQLiteConn, err error) {
+		conn = nil // Clear connection
+		file = f   // Copy provided file (f) => file
+		if file == "" {
+			// Create dummy file
+			file = TempFilename(t)
+		}
+
+		params := "?_auth"
+		if len(username) > 0 {
+			params = fmt.Sprintf("%s&_auth_user=%s", params, username)
+		}
+		if len(password) > 0 {
+			params = fmt.Sprintf("%s&_auth_pass=%s", params, password)
+		}
+		db, err = sql.Open("sqlite3_with_conn", "file:"+file+params)
+		if err != nil {
+			defer os.Remove(file)
+			return file, nil, nil, err
+		}
+
+		// Dummy query to force connection and database creation
+		// Will return ErrUnauthorized (SQLITE_AUTH) if user authentication fails
+		if _, err = db.Exec("SELECT 1;"); err != nil {
+			defer os.Remove(file)
+			defer db.Close()
+			return file, nil, nil, err
+		}
+		c = conn
+
+		return
+	}
+
+	connectWithCrypt = func(t *testing.T, f string, username, password string, crypt string, salt string) (file string, db *sql.DB, c *SQLiteConn, err error) {
+		conn = nil // Clear connection
+		file = f   // Copy provided file (f) => file
+		if file == "" {
+			// Create dummy file
+			file = TempFilename(t)
+		}
+
+		db, err = sql.Open("sqlite3_with_conn", "file:"+file+fmt.Sprintf("?_auth&_auth_user=%s&_auth_pass=%s&_auth_crypt=%s&_auth_salt=%s", username, password, crypt, salt))
+		if err != nil {
+			defer os.Remove(file)
+			return file, nil, nil, err
+		}
+
+		// Dummy query to force connection and database creation
+		// Will return ErrUnauthorized (SQLITE_AUTH) if user authentication fails
+		if _, err = db.Exec("SELECT 1;"); err != nil {
+			defer os.Remove(file)
+			defer db.Close()
+			return file, nil, nil, err
+		}
+		c = conn
+
+		return
+	}
+
+	authEnabled = func(db *sql.DB) (exists bool, err error) {
+		err = db.QueryRow("select count(type) from sqlite_master WHERE type='table' and name='sqlite_user';").Scan(&exists)
+		return
+	}
+
+	addUser = func(db *sql.DB, username, password string, admin int) (rv int, err error) {
+		err = db.QueryRow("select auth_user_add(?, ?, ?);", username, password, admin).Scan(&rv)
+		return
+	}
+
+	userExists = func(db *sql.DB, username string) (rv int, err error) {
+		err = db.QueryRow("select count(uname) from sqlite_user where uname=?", username).Scan(&rv)
+		return
+	}
+
+	isAdmin = func(db *sql.DB, username string) (rv bool, err error) {
+		err = db.QueryRow("select isAdmin from sqlite_user where uname=?", username).Scan(&rv)
+		return
+	}
+
+	modifyUser = func(db *sql.DB, username, password string, admin int) (rv int, err error) {
+		err = db.QueryRow("select auth_user_change(?, ?, ?);", username, password, admin).Scan(&rv)
+		return
+	}
+
+	deleteUser = func(db *sql.DB, username string) (rv int, err error) {
+		err = db.QueryRow("select auth_user_delete(?);", username).Scan(&rv)
+		return
+	}
+}
+
+func TestUserAuthCreateDatabase(t *testing.T) {
+	f, db, c, err := connect(t, "", "admin", "admin")
+	if err != nil && c == nil && db == nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	defer os.Remove(f)
+
+	enabled, err := authEnabled(db)
+	if err != nil || !enabled {
+		t.Fatalf("UserAuth not enabled: %s", err)
+	}
+
+	e, err := userExists(db, "admin")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if e != 1 {
+		t.Fatal("UserAuth: admin does not exists")
+	}
+	a, err := isAdmin(db, "admin")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !a {
+		t.Fatal("UserAuth: User is not administrator")
+	}
+}
+
+func TestUserAuthCreateDatabaseWithoutArgs(t *testing.T) {
+	_, db, c, err := connect(t, "", "", "")
+	if err == nil && c == nil && db == nil {
+		t.Fatal("Should have failed due to missing _auth_* parameters")
+	}
+
+	_, db, c, err = connect(t, "", "", "admin")
+	if err == nil && c == nil && db == nil {
+		t.Fatal("Should have failed due to missing _auth_user parameter")
+	}
+
+	_, db, c, err = connect(t, "", "admin", "")
+	if err == nil && c == nil && db == nil {
+		t.Fatal("Should have failed due to missing _auth_pass parameter")
+	}
+}
+
+/*
+func TestUserAuthLogin(t *testing.T) {
+	f1, err := create(t, "admin", "admin")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(f1)
+
+	f2, db2, c2, err := connect(t, f1, "admin", "admin")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db2.Close()
+	if f1 != f2 {
+		t.Fatal("UserAuth: Database file mismatch")
+	}
+
+	// Test lower level authentication
+	err = c2.Authenticate("admin", "admin")
+	if err != nil {
+		t.Fatalf("UserAuth: *SQLiteConn.Authenticate() Failed: %s", err)
+	}
+
+	// Test Login Failed
+	_, _, _, err = connect(t, f1, "admin", "invalid")
+	if err == nil {
+		t.Fatal("Login successful while expecting to fail")
+	}
+	if err != ErrUnauthorized {
+		t.Fatal(err)
+	}
+	err = c2.Authenticate("admin", "invalid")
+	if err == nil {
+		t.Fatal("Login successful while expecting to fail")
+	}
+	if err != ErrUnauthorized {
+		t.Fatal(err)
+	}
+}
+
+func TestUserAuthAddAdmin(t *testing.T) {
+	f, db, c, err := connect(t, "", "admin", "admin")
+	if err != nil && c == nil && db == nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	defer os.Remove(f)
+
+	// Add Admin User through SQL call
+	rv, err := addUser(db, "admin2", "admin2", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	// Check if user was created
+	exists, err := userExists(db, "admin2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 1 {
+		t.Fatal("UserAuth: 'admin2' does not exists")
+	}
+
+	// Check if user was created as an Administrator
+	admin, err := isAdmin(db, "admin2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !admin {
+		t.Fatal("UserAuth: 'admin2' is not administrator")
+	}
+
+	// Test *SQLiteConn
+	err = c.AuthUserAdd("admin3", "admin3", true)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check if user was created
+	exists, err = userExists(db, "admin2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 1 {
+		t.Fatal("UserAuth: 'admin3' does not exists")
+	}
+
+	// Check if the user was created as an Administrator
+	admin, err = isAdmin(db, "admin3")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !admin {
+		t.Fatal("UserAuth: 'admin3' is not administrator")
+	}
+}
+
+func TestUserAuthAddUser(t *testing.T) {
+	f1, db1, c, err := connect(t, "", "admin", "admin")
+	if err != nil && c == nil && db == nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(f1)
+
+	// Add user through SQL call
+	rv, err := addUser(db1, "user", "user", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	// Check if user was created
+	exists, err := userExists(db1, "user")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 1 {
+		t.Fatal("UserAuth: 'user' does not exists")
+	}
+
+	// Check if user was created as an Administrator
+	admin, err := isAdmin(db1, "user")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if admin {
+		t.Fatal("UserAuth: 'user' is administrator")
+	}
+
+	// Test *SQLiteConn
+	err = c.AuthUserAdd("user2", "user2", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check if user was created
+	exists, err = userExists(db1, "user2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 1 {
+		t.Fatal("UserAuth: 'user2' does not exists")
+	}
+
+	// Check if the user was created as an Administrator
+	admin, err = isAdmin(db1, "user2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if admin {
+		t.Fatal("UserAuth: 'user2' is administrator")
+	}
+
+	// Reconnect as normal user
+	db1.Close()
+	_, db2, c2, err := connect(t, f1, "user", "user")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db2.Close()
+
+	// Try to create admin user while logged in as normal user
+	rv, err = addUser(db2, "admin2", "admin2", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != SQLITE_AUTH {
+		t.Fatal("Created admin user while not allowed")
+	}
+
+	err = c2.AuthUserAdd("admin3", "admin3", true)
+	if err != ErrAdminRequired {
+		t.Fatal("Created admin user while not allowed")
+	}
+
+	// Try to create normal user while logged in as normal user
+	rv, err = addUser(db2, "user3", "user3", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != SQLITE_AUTH {
+		t.Fatal("Created user while not allowed")
+	}
+
+	err = c2.AuthUserAdd("user4", "user4", false)
+	if err != ErrAdminRequired {
+		t.Fatal("Created user while not allowed")
+	}
+}
+
+func TestUserAuthModifyUser(t *testing.T) {
+	f1, db1, c1, err := connect(t, "", "admin", "admin")
+	if err != nil && c1 == nil && db == nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(f1)
+
+	// Modify Password for current logged in admin
+	// through SQL
+	rv, err := modifyUser(db1, "admin", "admin2", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to modify password for admin")
+	}
+
+	// Modify password for current logged in admin
+	// through *SQLiteConn
+	err = c1.AuthUserChange("admin", "admin3", true)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Modify Administrator Flag
+	// Because we are current logged in as 'admin'
+	// Changing our own admin flag should fail.
+	rv, err = modifyUser(db1, "admin", "admin3", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != SQLITE_AUTH {
+		t.Fatal("Successfully changed admin flag while not allowed")
+	}
+
+	// Modify admin flag through (*SQLiteConn)
+	// Because we are current logged in as 'admin'
+	// Changing our own admin flag should fail.
+	err = c1.AuthUserChange("admin", "admin3", false)
+	if err != ErrAdminRequired {
+		t.Fatal("Successfully changed admin flag while not allowed")
+	}
+
+	// Add normal user
+	rv, err = addUser(db1, "user", "password", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	rv, err = addUser(db1, "user2", "user2", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	// Modify other user password and flag through SQL
+	rv, err = modifyUser(db1, "user", "pass", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to modify password for user")
+	}
+
+	// Modify other user password and flag through *SQLiteConn
+	err = c1.AuthUserChange("user", "newpass", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Disconnect database for reconnect
+	db1.Close()
+	_, db2, c2, err := connect(t, f1, "user", "newpass")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db2.Close()
+
+	// Modify other user password through SQL
+	rv, err = modifyUser(db2, "user2", "newpass", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != SQLITE_AUTH {
+		t.Fatal("Password change successful while not allowed")
+	}
+
+	// Modify other user password and flag through *SQLiteConn
+	err = c2.AuthUserChange("user2", "invalid", false)
+	if err != ErrAdminRequired {
+		t.Fatal("Password change successful while not allowed")
+	}
+}
+
+func TestUserAuthDeleteUser(t *testing.T) {
+	f1, db1, c, err := connect(t, "", "admin", "admin")
+	if err != nil && c == nil && db == nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(f1)
+
+	// Add Admin User 2
+	rv, err := addUser(db1, "admin2", "admin2", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	rv, err = addUser(db1, "admin3", "admin3", 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	// Check if user was created
+	exists, err := userExists(db1, "admin2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 1 {
+		t.Fatal("UserAuth: 'admin2' does not exists")
+	}
+
+	exists, err = userExists(db1, "admin3")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 1 {
+		t.Fatal("UserAuth: 'admin2' does not exists")
+	}
+
+	// Delete user through SQL
+	rv, err = deleteUser(db1, "admin2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to delete admin2")
+	}
+
+	// Verify user admin2 deleted
+	exists, err = userExists(db1, "admin2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 0 {
+		t.Fatal("UserAuth: 'admin2' still exists")
+	}
+
+	// Delete user through *SQLiteConn
+	rv, err = deleteUser(db1, "admin3")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to delete admin3")
+	}
+
+	// Verify user admin3 deleted
+	exists, err = userExists(db1, "admin3")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if exists != 0 {
+		t.Fatal("UserAuth: 'admin3' still exists")
+	}
+
+	// Add normal user for reconnect and privileges check
+	rv, err = addUser(db1, "reconnect", "reconnect", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	// Add normal user for deletion through SQL
+	rv, err = addUser(db1, "user", "user", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	rv, err = addUser(db1, "user2", "user2", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != 0 {
+		t.Fatal("Failed to add user")
+	}
+
+	// Close database for reconnect
+	db1.Close()
+
+	// Reconnect as normal user
+	_, db2, c2, err := connect(t, f1, "reconnect", "reconnect")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db2.Close()
+
+	// Delete user while logged in as normal user
+	// through SQL
+	rv, err = deleteUser(db2, "user")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rv != SQLITE_AUTH {
+		t.Fatal("Successfully deleted user wthout proper privileges")
+	}
+
+	// Delete user while logged in as normal user
+	// through *SQLiteConn
+	err = c2.AuthUserDelete("user2")
+	if err != ErrAdminRequired {
+		t.Fatal("Successfully deleted user wthout proper privileges")
+	}
+}
+*/
+
+func TestUserAuthEncoders(t *testing.T) {
+	cases := map[string]string{
+		"sha1":    "",
+		"ssha1":   "salted",
+		"sha256":  "",
+		"ssha256": "salted",
+		"sha384":  "",
+		"ssha384": "salted",
+		"sha512":  "",
+		"ssha512": "salted",
+	}
+
+	for enc, salt := range cases {
+		f, err := createWithCrypt(t, "admin", "admin", enc, salt)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer os.Remove(f)
+
+		_, db, _, err := connectWithCrypt(t, f, "admin", "admin", enc, salt)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer db.Close()
+		if e, err := authEnabled(db); err != nil && !e {
+			t.Fatalf("UserAuth (%s) not enabled %s", enc, err)
+		}
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build sqlite_vtable || vtable // +build sqlite_vtable vtable
+
+type testModule struct {
+	t        *testing.T
+	intarray []int
+}
+
+type testVTab struct {
+	intarray []int
+}
+
+type testVTabCursor struct {
+	vTab  *testVTab
+	index int
+}
+
+func (m testModule) Create(c *SQLiteConn, args []string) (VTab, error) {
+	if len(args) != 6 {
+		m.t.Fatal("six arguments expected")
+	}
+	if args[0] != "test" {
+		m.t.Fatal("module name")
+	}
+	if args[1] != "main" {
+		m.t.Fatal("db name")
+	}
+	if args[2] != "vtab" {
+		m.t.Fatal("table name")
+	}
+	if args[3] != "'1'" {
+		m.t.Fatal("first arg")
+	}
+	if args[4] != "2" {
+		m.t.Fatal("second arg")
+	}
+	if args[5] != "three" {
+		m.t.Fatal("third argsecond arg")
+	}
+	err := c.DeclareVTab("CREATE TABLE x(test TEXT)")
+	if err != nil {
+		return nil, err
+	}
+	return &testVTab{m.intarray}, nil
+}
+
+func (m testModule) Connect(c *SQLiteConn, args []string) (VTab, error) {
+	return m.Create(c, args)
+}
+
+func (m testModule) DestroyModule() {}
+
+func (v *testVTab) BestIndex(cst []InfoConstraint, ob []InfoOrderBy) (*IndexResult, error) {
+	used := make([]bool, 0, len(cst))
+	for range cst {
+		used = append(used, false)
+	}
+	return &IndexResult{
+		Used:           used,
+		IdxNum:         0,
+		IdxStr:         "test-index",
+		AlreadyOrdered: true,
+		EstimatedCost:  100,
+		EstimatedRows:  200,
+	}, nil
+}
+
+func (v *testVTab) Disconnect() error {
+	return nil
+}
+
+func (v *testVTab) Destroy() error {
+	return nil
+}
+
+func (v *testVTab) Open() (VTabCursor, error) {
+	return &testVTabCursor{v, 0}, nil
+}
+
+func (vc *testVTabCursor) Close() error {
+	return nil
+}
+
+func (vc *testVTabCursor) Filter(idxNum int, idxStr string, vals []any) error {
+	vc.index = 0
+	return nil
+}
+
+func (vc *testVTabCursor) Next() error {
+	vc.index++
+	return nil
+}
+
+func (vc *testVTabCursor) EOF() bool {
+	return vc.index >= len(vc.vTab.intarray)
+}
+
+func (vc *testVTabCursor) Column(c *SQLiteContext, col int) error {
+	if col != 0 {
+		return fmt.Errorf("column index out of bounds: %d", col)
+	}
+	c.ResultInt(vc.vTab.intarray[vc.index])
+	return nil
+}
+
+func (vc *testVTabCursor) Rowid() (int64, error) {
+	return int64(vc.index), nil
+}
+
+func TestCreateModule(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	intarray := []int{1, 2, 3}
+	sql.Register("sqlite3_TestCreateModule", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			return conn.CreateModule("test", testModule{t, intarray})
+		},
+	})
+	db, err := sql.Open("sqlite3_TestCreateModule", tempFilename)
+	if err != nil {
+		t.Fatalf("could not open db: %v", err)
+	}
+	_, err = db.Exec("CREATE VIRTUAL TABLE vtab USING test('1', 2, three)")
+	if err != nil {
+		t.Fatalf("could not create vtable: %v", err)
+	}
+
+	var i, value int
+	rows, err := db.Query("SELECT rowid, * FROM vtab WHERE test = '3'")
+	if err != nil {
+		t.Fatalf("couldn't select from virtual table: %v", err)
+	}
+	for rows.Next() {
+		rows.Scan(&i, &value)
+		if intarray[i] != value {
+			t.Fatalf("want %v but %v", intarray[i], value)
+		}
+	}
+
+	_, err = db.Exec("DROP TABLE vtab")
+	if err != nil {
+		t.Fatalf("couldn't drop virtual table: %v", err)
+	}
+}
+
+func TestVUpdate(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+
+	// create module
+	updateMod := &vtabUpdateModule{t, make(map[string]*vtabUpdateTable)}
+
+	// register module
+	sql.Register("sqlite3_TestVUpdate", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			return conn.CreateModule("updatetest", updateMod)
+		},
+	})
+
+	// connect
+	db, err := sql.Open("sqlite3_TestVUpdate", tempFilename)
+	if err != nil {
+		t.Fatalf("could not open db: %v", err)
+	}
+
+	// create test table
+	_, err = db.Exec(`CREATE VIRTUAL TABLE vt USING updatetest(f1 integer, f2 text, f3 text)`)
+	if err != nil {
+		t.Fatalf("could not create updatetest vtable vt, got: %v", err)
+	}
+
+	// check that table is defined properly
+	if len(updateMod.tables) != 1 {
+		t.Fatalf("expected exactly 1 table to exist, got: %d", len(updateMod.tables))
+	}
+	if _, ok := updateMod.tables["vt"]; !ok {
+		t.Fatalf("expected table `vt` to exist in tables")
+	}
+
+	// check nothing in updatetest
+	rows, err := db.Query(`select * from vt`)
+	if err != nil {
+		t.Fatalf("could not query vt, got: %v", err)
+	}
+	i, err := getRowCount(rows)
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	if i != 0 {
+		t.Fatalf("expected no rows in vt, got: %d", i)
+	}
+
+	_, err = db.Exec(`delete from vt where f1 = 'yes'`)
+	if err != nil {
+		t.Fatalf("expected error on delete, got nil")
+	}
+
+	// test bad column name
+	_, err = db.Exec(`insert into vt (f4) values('a')`)
+	if err == nil {
+		t.Fatalf("expected error on insert, got nil")
+	}
+
+	// insert to vt
+	res, err := db.Exec(`insert into vt (f1, f2, f3) values (115, 'b', 'c'), (116, 'd', 'e')`)
+	if err != nil {
+		t.Fatalf("expected no error on insert, got: %v", err)
+	}
+	n, err := res.RowsAffected()
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	if n != 2 {
+		t.Fatalf("expected 1 row affected, got: %d", n)
+	}
+
+	// check vt table
+	vt := updateMod.tables["vt"]
+	if len(vt.data) != 2 {
+		t.Fatalf("expected table vt to have exactly 2 rows, got: %d", len(vt.data))
+	}
+	if !reflect.DeepEqual(vt.data[0], []any{int64(115), "b", "c"}) {
+		t.Fatalf("expected table vt entry 0 to be [115 b c], instead: %v", vt.data[0])
+	}
+	if !reflect.DeepEqual(vt.data[1], []any{int64(116), "d", "e"}) {
+		t.Fatalf("expected table vt entry 1 to be [116 d e], instead: %v", vt.data[1])
+	}
+
+	// query vt
+	var f1 int
+	var f2, f3 string
+	err = db.QueryRow(`select * from vt where f1 = 115`).Scan(&f1, &f2, &f3)
+	if err != nil {
+		t.Fatalf("expected no error on vt query, got: %v", err)
+	}
+
+	// check column values
+	if f1 != 115 || f2 != "b" || f3 != "c" {
+		t.Errorf("expected f1==115, f2==b, f3==c, got: %d, %q, %q", f1, f2, f3)
+	}
+
+	// update vt
+	res, err = db.Exec(`update vt set f1=117, f2='f' where f3='e'`)
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	n, err = res.RowsAffected()
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	if n != 1 {
+		t.Fatalf("expected exactly one row updated, got: %d", n)
+	}
+
+	// check vt table
+	if len(vt.data) != 2 {
+		t.Fatalf("expected table vt to have exactly 2 rows, got: %d", len(vt.data))
+	}
+	if !reflect.DeepEqual(vt.data[0], []any{int64(115), "b", "c"}) {
+		t.Fatalf("expected table vt entry 0 to be [115 b c], instead: %v", vt.data[0])
+	}
+	if !reflect.DeepEqual(vt.data[1], []any{int64(117), "f", "e"}) {
+		t.Fatalf("expected table vt entry 1 to be [117 f e], instead: %v", vt.data[1])
+	}
+
+	// delete from vt
+	res, err = db.Exec(`delete from vt where f1 = 117`)
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	n, err = res.RowsAffected()
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	if n != 1 {
+		t.Fatalf("expected exactly one row deleted, got: %d", n)
+	}
+
+	// check vt table
+	if len(vt.data) != 1 {
+		t.Fatalf("expected table vt to have exactly 1 row, got: %d", len(vt.data))
+	}
+	if !reflect.DeepEqual(vt.data[0], []any{int64(115), "b", "c"}) {
+		t.Fatalf("expected table vt entry 0 to be [115 b c], instead: %v", vt.data[0])
+	}
+
+	// check updatetest has 1 result
+	rows, err = db.Query(`select * from vt`)
+	if err != nil {
+		t.Fatalf("could not query vt, got: %v", err)
+	}
+	i, err = getRowCount(rows)
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+	if i != 1 {
+		t.Fatalf("expected 1 row in vt, got: %d", i)
+	}
+}
+
+func getRowCount(rows *sql.Rows) (int, error) {
+	var i int
+	for rows.Next() {
+		i++
+	}
+	return i, nil
+}
+
+type vtabUpdateModule struct {
+	t      *testing.T
+	tables map[string]*vtabUpdateTable
+}
+
+func (m *vtabUpdateModule) Create(c *SQLiteConn, args []string) (VTab, error) {
+	if len(args) < 2 {
+		return nil, errors.New("must declare at least one column")
+	}
+
+	// get database name, table name, and column declarations ...
+	dbname, tname, decls := args[1], args[2], args[3:]
+
+	// extract column names + types from parameters declarations
+	cols, typs := make([]string, len(decls)), make([]string, len(decls))
+	for i := 0; i < len(decls); i++ {
+		n, typ := decls[i], ""
+		if j := strings.IndexAny(n, " \t\n"); j != -1 {
+			typ, n = strings.TrimSpace(n[j+1:]), n[:j]
+		}
+		cols[i], typs[i] = n, typ
+	}
+
+	// declare table
+	err := c.DeclareVTab(fmt.Sprintf(`CREATE TABLE "%s"."%s" (%s)`, dbname, tname, strings.Join(decls, ",")))
+	if err != nil {
+		return nil, err
+	}
+
+	// create table
+	vtab := &vtabUpdateTable{m.t, dbname, tname, cols, typs, make([][]any, 0)}
+	m.tables[tname] = vtab
+	return vtab, nil
+}
+
+func (m *vtabUpdateModule) Connect(c *SQLiteConn, args []string) (VTab, error) {
+	return m.Create(c, args)
+}
+
+func (m *vtabUpdateModule) DestroyModule() {}
+
+type vtabUpdateTable struct {
+	t    *testing.T
+	db   string
+	name string
+	cols []string
+	typs []string
+	data [][]any
+}
+
+func (t *vtabUpdateTable) Open() (VTabCursor, error) {
+	return &vtabUpdateCursor{t, 0}, nil
+}
+
+func (t *vtabUpdateTable) BestIndex(cst []InfoConstraint, ob []InfoOrderBy) (*IndexResult, error) {
+	return &IndexResult{Used: make([]bool, len(cst))}, nil
+}
+
+func (t *vtabUpdateTable) Disconnect() error {
+	return nil
+}
+
+func (t *vtabUpdateTable) Destroy() error {
+	return nil
+}
+
+func (t *vtabUpdateTable) Insert(id any, vals []any) (int64, error) {
+	var i int64
+	if id == nil {
+		i, t.data = int64(len(t.data)), append(t.data, vals)
+		return i, nil
+	}
+
+	var ok bool
+	i, ok = id.(int64)
+	if !ok {
+		return 0, fmt.Errorf("id is invalid type: %T", id)
+	}
+
+	t.data[i] = vals
+
+	return i, nil
+}
+
+func (t *vtabUpdateTable) Update(id any, vals []any) error {
+	i, ok := id.(int64)
+	if !ok {
+		return fmt.Errorf("id is invalid type: %T", id)
+	}
+
+	if int(i) >= len(t.data) || i < 0 {
+		return fmt.Errorf("invalid row id %d", i)
+	}
+
+	t.data[int(i)] = vals
+
+	return nil
+}
+
+func (t *vtabUpdateTable) Delete(id any) error {
+	i, ok := id.(int64)
+	if !ok {
+		return fmt.Errorf("id is invalid type: %T", id)
+	}
+
+	if int(i) >= len(t.data) || i < 0 {
+		return fmt.Errorf("invalid row id %d", i)
+	}
+
+	t.data = append(t.data[:i], t.data[i+1:]...)
+
+	return nil
+}
+
+type vtabUpdateCursor struct {
+	t *vtabUpdateTable
+	i int
+}
+
+func (c *vtabUpdateCursor) Column(ctxt *SQLiteContext, col int) error {
+	switch x := c.t.data[c.i][col].(type) {
+	case []byte:
+		ctxt.ResultBlob(x)
+	case bool:
+		ctxt.ResultBool(x)
+	case float64:
+		ctxt.ResultDouble(x)
+	case int:
+		ctxt.ResultInt(x)
+	case int64:
+		ctxt.ResultInt64(x)
+	case nil:
+		ctxt.ResultNull()
+	case string:
+		ctxt.ResultText(x)
+	default:
+		ctxt.ResultText(fmt.Sprintf("%v", x))
+	}
+
+	return nil
+}
+
+func (c *vtabUpdateCursor) Filter(ixNum int, ixName string, vals []any) error {
+	return nil
+}
+
+func (c *vtabUpdateCursor) Next() error {
+	c.i++
+	return nil
+}
+
+func (c *vtabUpdateCursor) EOF() bool {
+	return c.i >= len(c.t.data)
+}
+
+func (c *vtabUpdateCursor) Rowid() (int64, error) {
+	return int64(c.i), nil
+}
+
+func (c *vtabUpdateCursor) Close() error {
+	return nil
+}
+
+type testModuleEponymousOnly struct {
+	t        *testing.T
+	intarray []int
+}
+
+type testVTabEponymousOnly struct {
+	intarray []int
+}
+
+type testVTabCursorEponymousOnly struct {
+	vTab  *testVTabEponymousOnly
+	index int
+}
+
+func (m testModuleEponymousOnly) EponymousOnlyModule() {}
+
+func (m testModuleEponymousOnly) Create(c *SQLiteConn, args []string) (VTab, error) {
+	err := c.DeclareVTab("CREATE TABLE x(test INT)")
+	if err != nil {
+		return nil, err
+	}
+	return &testVTabEponymousOnly{m.intarray}, nil
+}
+
+func (m testModuleEponymousOnly) Connect(c *SQLiteConn, args []string) (VTab, error) {
+	return m.Create(c, args)
+}
+
+func (m testModuleEponymousOnly) DestroyModule() {}
+
+func (v *testVTabEponymousOnly) BestIndex(cst []InfoConstraint, ob []InfoOrderBy) (*IndexResult, error) {
+	used := make([]bool, 0, len(cst))
+	for range cst {
+		used = append(used, false)
+	}
+	return &IndexResult{
+		Used:           used,
+		IdxNum:         0,
+		IdxStr:         "test-index",
+		AlreadyOrdered: true,
+		EstimatedCost:  100,
+		EstimatedRows:  200,
+	}, nil
+}
+
+func (v *testVTabEponymousOnly) Disconnect() error {
+	return nil
+}
+
+func (v *testVTabEponymousOnly) Destroy() error {
+	return nil
+}
+
+func (v *testVTabEponymousOnly) Open() (VTabCursor, error) {
+	return &testVTabCursorEponymousOnly{v, 0}, nil
+}
+
+func (vc *testVTabCursorEponymousOnly) Close() error {
+	return nil
+}
+
+func (vc *testVTabCursorEponymousOnly) Filter(idxNum int, idxStr string, vals []any) error {
+	vc.index = 0
+	return nil
+}
+
+func (vc *testVTabCursorEponymousOnly) Next() error {
+	vc.index++
+	return nil
+}
+
+func (vc *testVTabCursorEponymousOnly) EOF() bool {
+	return vc.index >= len(vc.vTab.intarray)
+}
+
+func (vc *testVTabCursorEponymousOnly) Column(c *SQLiteContext, col int) error {
+	if col != 0 {
+		return fmt.Errorf("column index out of bounds: %d", col)
+	}
+	c.ResultInt(vc.vTab.intarray[vc.index])
+	return nil
+}
+
+func (vc *testVTabCursorEponymousOnly) Rowid() (int64, error) {
+	return int64(vc.index), nil
+}
+
+func TestCreateModuleEponymousOnly(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	intarray := []int{1, 2, 3}
+	sql.Register("sqlite3_TestCreateModuleEponymousOnly", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			return conn.CreateModule("test", testModuleEponymousOnly{t, intarray})
+		},
+	})
+	db, err := sql.Open("sqlite3_TestCreateModuleEponymousOnly", tempFilename)
+	if err != nil {
+		t.Fatalf("could not open db: %v", err)
+	}
+
+	var i, value int
+	rows, err := db.Query("SELECT rowid, * FROM test")
+	if err != nil {
+		t.Fatalf("couldn't select from virtual table: %v", err)
+	}
+	for rows.Next() {
+		err := rows.Scan(&i, &value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if intarray[i] != value {
+			t.Fatalf("want %v but %v", intarray[i], value)
+		}
+	}
+
+	_, err = db.Exec("DROP TABLE test")
+	if err != nil {
+		t.Logf("couldn't drop virtual table: %v", err)
+	}
+}
+// Copyright (C) 2019 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.
+
+// //go:build cgo // +build cgo
+
+func TempFilename(t testing.TB) string {
+	f, err := ioutil.TempFile("", "go-sqlite3-test-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	return f.Name()
+}
+
+func doTestOpen(t *testing.T, option string) (string, error) {
+	tempFilename := TempFilename(t)
+	url := tempFilename + option
+
+	defer func() {
+		err := os.Remove(tempFilename)
+		if err != nil {
+			t.Error("temp file remove error:", err)
+		}
+	}()
+
+	db, err := sql.Open("sqlite3", url)
+	if err != nil {
+		return "Failed to open database:", err
+	}
+
+	defer func() {
+		err = db.Close()
+		if err != nil {
+			t.Error("db close error:", err)
+		}
+	}()
+
+	err = db.Ping()
+	if err != nil {
+		return "ping error:", err
+	}
+
+	_, err = db.Exec("drop table foo")
+	_, err = db.Exec("create table foo (id integer)")
+	if err != nil {
+		return "Failed to create table:", err
+	}
+
+	if stat, err := os.Stat(tempFilename); err != nil || stat.IsDir() {
+		return "Failed to create ./foo.db", nil
+	}
+
+	return "", nil
+}
+
+func TestOpen(t *testing.T) {
+	cases := map[string]bool{
+		"":                   true,
+		"?_txlock=immediate": true,
+		"?_txlock=deferred":  true,
+		"?_txlock=exclusive": true,
+		"?_txlock=bogus":     false,
+	}
+	for option, expectedPass := range cases {
+		result, err := doTestOpen(t, option)
+		if result == "" {
+			if !expectedPass {
+				errmsg := fmt.Sprintf("_txlock error not caught at dbOpen with option: %s", option)
+				t.Fatal(errmsg)
+			}
+		} else if expectedPass {
+			if err == nil {
+				t.Fatal(result)
+			} else {
+				t.Fatal(result, err)
+			}
+		}
+	}
+}
+
+func TestOpenWithVFS(t *testing.T) {
+	filename := t.Name() + ".sqlite"
+
+	if err := os.Remove(filename); err != nil && !os.IsNotExist(err) {
+		t.Fatal(err)
+	}
+	defer os.Remove(filename)
+
+	db, err := sql.Open("sqlite3", fmt.Sprintf("file:%s?vfs=hello", filename))
+	if err != nil {
+		t.Fatal("Failed to open", err)
+	}
+	err = db.Ping()
+	if err == nil {
+		t.Fatal("Failed to open", err)
+	}
+	db.Close()
+
+	defer os.Remove(filename)
+
+	var vfs string
+	if runtime.GOOS == "windows" {
+		vfs = "win32-none"
+	} else {
+		vfs = "unix-none"
+	}
+	db, err = sql.Open("sqlite3", fmt.Sprintf("file:%s?vfs=%s", filename, vfs))
+	if err != nil {
+		t.Fatal("Failed to open", err)
+	}
+	err = db.Ping()
+	if err != nil {
+		t.Fatal("Failed to ping", err)
+	}
+	db.Close()
+}
+
+func TestOpenNoCreate(t *testing.T) {
+	filename := t.Name() + ".sqlite"
+
+	if err := os.Remove(filename); err != nil && !os.IsNotExist(err) {
+		t.Fatal(err)
+	}
+	defer os.Remove(filename)
+
+	// https://golang.org/pkg/database/sql/#Open
+	// "Open may just validate its arguments without creating a connection
+	// to the database. To verify that the data source name is valid, call Ping."
+	db, err := sql.Open("sqlite3", fmt.Sprintf("file:%s?mode=rw", filename))
+	if err == nil {
+		defer db.Close()
+
+		err = db.Ping()
+		if err == nil {
+			t.Fatal("expected error from Open or Ping")
+		}
+	}
+
+	sqlErr, ok := err.(Error)
+	if !ok {
+		t.Fatalf("expected sqlite3.Error, but got %T", err)
+	}
+
+	if sqlErr.Code != ErrCantOpen {
+		t.Fatalf("expected SQLITE_CANTOPEN, but got %v", sqlErr)
+	}
+
+	// make sure database file truly was not created
+	if _, err := os.Stat(filename); !os.IsNotExist(err) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Fatal("expected database file to not exist")
+	}
+
+	// verify that it works if the mode is "rwc" instead
+	db, err = sql.Open("sqlite3", fmt.Sprintf("file:%s?mode=rwc", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	if err := db.Ping(); err != nil {
+		t.Fatal(err)
+	}
+
+	// make sure database file truly was created
+	if _, err := os.Stat(filename); err != nil {
+		if !os.IsNotExist(err) {
+			t.Fatal(err)
+		}
+		t.Fatal("expected database file to exist")
+	}
+}
+
+func TestReadonly(t *testing.T) {
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+
+	db1, err := sql.Open("sqlite3", "file:"+tempFilename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	db1.Exec("CREATE TABLE test (x int, y float)")
+
+	db2, err := sql.Open("sqlite3", "file:"+tempFilename+"?mode=ro")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = db2
+	_, err = db2.Exec("INSERT INTO test VALUES (1, 3.14)")
+	if err == nil {
+		t.Fatal("didn't expect INSERT into read-only database to work")
+	}
+}
+
+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 TestDeferredForeignKey(t *testing.T) {
+	fname := TempFilename(t)
+	uri := "file:" + fname + "?_foreign_keys=1"
+	db, err := sql.Open("sqlite3", uri)
+	if err != nil {
+		os.Remove(fname)
+		t.Errorf("sql.Open(\"sqlite3\", %q): %v", uri, err)
+	}
+	_, err = db.Exec("CREATE TABLE bar (id INTEGER PRIMARY KEY)")
+	if err != nil {
+		t.Errorf("failed creating tables: %v", err)
+	}
+	_, err = db.Exec("CREATE TABLE foo (bar_id INTEGER, FOREIGN KEY(bar_id) REFERENCES bar(id) DEFERRABLE INITIALLY DEFERRED)")
+	if err != nil {
+		t.Errorf("failed creating tables: %v", err)
+	}
+	tx, err := db.Begin()
+	if err != nil {
+		t.Errorf("Failed to begin transaction: %v", err)
+	}
+	_, err = tx.Exec("INSERT INTO foo (bar_id) VALUES (123)")
+	if err != nil {
+		t.Errorf("Failed to insert row: %v", err)
+	}
+	err = tx.Commit()
+	if err == nil {
+		t.Errorf("Expected an error: %v", err)
+	}
+	_, err = db.Begin()
+	if err != nil {
+		t.Errorf("Failed to begin transaction: %v", err)
+	}
+
+	db.Close()
+	os.Remove(fname)
+}
+
+func TestRecursiveTriggers(t *testing.T) {
+	cases := map[string]bool{
+		"?_recursive_triggers=1": true,
+		"?_recursive_triggers=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 recursive_triggers;").Scan(&enabled)
+		db.Close()
+		os.Remove(fname)
+		if err != nil {
+			t.Errorf("query recursive_triggers for %s: %v", uri, err)
+			continue
+		}
+		if enabled != want {
+			t.Errorf("\"PRAGMA recursive_triggers;\" for %q = %t; want %t", uri, enabled, want)
+			continue
+		}
+	}
+}
+
+func TestClose(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)
+	}
+
+	_, err = db.Exec("drop table foo")
+	_, err = db.Exec("create table foo (id integer)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	stmt, err := db.Prepare("select id from foo where id = ?")
+	if err != nil {
+		t.Fatal("Failed to select records:", err)
+	}
+
+	db.Close()
+	_, err = stmt.Exec(1)
+	if err == nil {
+		t.Fatal("Failed to operate closed statement")
+	}
+}
+
+func TestInsert(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("drop table foo")
+	_, err = db.Exec("create table foo (id integer)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	res, err := db.Exec("insert into foo(id) values(123)")
+	if err != nil {
+		t.Fatal("Failed to insert record:", err)
+	}
+	affected, _ := res.RowsAffected()
+	if affected != 1 {
+		t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
+	}
+
+	rows, err := db.Query("select id from foo")
+	if err != nil {
+		t.Fatal("Failed to select records:", err)
+	}
+	defer rows.Close()
+
+	rows.Next()
+
+	var result int
+	rows.Scan(&result)
+	if result != 123 {
+		t.Errorf("Expected %d for fetched result, but %d:", 123, result)
+	}
+}
+
+func TestUpsert(t *testing.T) {
+	_, n, _ := Version()
+	if n < 3024000 {
+		t.Skip("UPSERT requires sqlite3 >= 3.24.0")
+	}
+	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("drop table foo")
+	_, err = db.Exec("create table foo (name string primary key, counter integer)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	for i := 0; i < 10; i++ {
+		res, err := db.Exec("insert into foo(name, counter) values('key', 1) on conflict (name) do update set counter=counter+1")
+		if err != nil {
+			t.Fatal("Failed to upsert record:", err)
+		}
+		affected, _ := res.RowsAffected()
+		if affected != 1 {
+			t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
+		}
+	}
+	rows, err := db.Query("select name, counter from foo")
+	if err != nil {
+		t.Fatal("Failed to select records:", err)
+	}
+	defer rows.Close()
+
+	rows.Next()
+
+	var resultName string
+	var resultCounter int
+	rows.Scan(&resultName, &resultCounter)
+	if resultName != "key" {
+		t.Errorf("Expected %s for fetched result, but %s:", "key", resultName)
+	}
+	if resultCounter != 10 {
+		t.Errorf("Expected %d for fetched result, but %d:", 10, resultCounter)
+	}
+
+}
+
+func TestUpdate(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("drop table foo")
+	_, err = db.Exec("create table foo (id integer)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	res, err := db.Exec("insert into foo(id) values(123)")
+	if err != nil {
+		t.Fatal("Failed to insert record:", err)
+	}
+	expected, err := res.LastInsertId()
+	if err != nil {
+		t.Fatal("Failed to get LastInsertId:", err)
+	}
+	affected, _ := res.RowsAffected()
+	if err != nil {
+		t.Fatal("Failed to get RowsAffected:", err)
+	}
+	if affected != 1 {
+		t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
+	}
+
+	res, err = db.Exec("update foo set id = 234")
+	if err != nil {
+		t.Fatal("Failed to update record:", err)
+	}
+	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)
+	}
+	affected, _ = res.RowsAffected()
+	if err != nil {
+		t.Fatal("Failed to get RowsAffected:", err)
+	}
+	if affected != 1 {
+		t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
+	}
+
+	rows, err := db.Query("select id from foo")
+	if err != nil {
+		t.Fatal("Failed to select records:", err)
+	}
+	defer rows.Close()
+
+	rows.Next()
+
+	var result int
+	rows.Scan(&result)
+	if result != 234 {
+		t.Errorf("Expected %d for fetched result, but %d:", 234, result)
+	}
+}
+
+func TestDelete(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("drop table foo")
+	_, err = db.Exec("create table foo (id integer)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	res, err := db.Exec("insert into foo(id) values(123)")
+	if err != nil {
+		t.Fatal("Failed to insert record:", err)
+	}
+	expected, err := res.LastInsertId()
+	if err != nil {
+		t.Fatal("Failed to get LastInsertId:", err)
+	}
+	affected, err := res.RowsAffected()
+	if err != nil {
+		t.Fatal("Failed to get RowsAffected:", err)
+	}
+	if affected != 1 {
+		t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected)
+	}
+
+	res, err = db.Exec("delete from foo where id = 123")
+	if err != nil {
+		t.Fatal("Failed to delete record:", err)
+	}
+	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)
+	}
+	affected, err = res.RowsAffected()
+	if err != nil {
+		t.Fatal("Failed to get RowsAffected:", err)
+	}
+	if affected != 1 {
+		t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected)
+	}
+
+	rows, err := db.Query("select id from foo")
+	if err != nil {
+		t.Fatal("Failed to select records:", err)
+	}
+	defer rows.Close()
+
+	if rows.Next() {
+		t.Error("Fetched row but expected not rows")
+	}
+}
+
+func TestBooleanRoundtrip(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("DROP TABLE foo")
+	_, err = db.Exec("CREATE TABLE foo(id INTEGER, value BOOL)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(1, ?)", true)
+	if err != nil {
+		t.Fatal("Failed to insert true value:", err)
+	}
+
+	_, err = db.Exec("INSERT INTO foo(id, value) VALUES(2, ?)", false)
+	if err != nil {
+		t.Fatal("Failed to insert false value:", err)
+	}
+
+	rows, err := db.Query("SELECT id, value FROM foo")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id int
+		var value bool
+
+		if err := rows.Scan(&id, &value); err != nil {
+			t.Error("Unable to scan results:", err)
+			continue
+		}
+
+		if id == 1 && !value {
+			t.Error("Value for id 1 should be true, not false")
+
+		} else if id == 2 && value {
+			t.Error("Value for id 2 should be false, not true")
+		}
+	}
+}
+
+func timezone(t time.Time) string { return t.Format("-07:00") }
+
+func TestTimestamp(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("DROP TABLE foo")
+	_, err = db.Exec("CREATE TABLE foo(id INTEGER, ts timeSTAMP, dt DATETIME)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
+	timestamp2 := time.Date(2006, time.January, 2, 15, 4, 5, 123456789, time.UTC)
+	timestamp3 := time.Date(2012, time.November, 4, 0, 0, 0, 0, time.UTC)
+	tzTest := time.FixedZone("TEST", -9*3600-13*60)
+	tests := []struct {
+		value    any
+		expected time.Time
+	}{
+		{"nonsense", time.Time{}},
+		{"0000-00-00 00:00:00", time.Time{}},
+		{time.Time{}.Unix(), time.Time{}},
+		{timestamp1, timestamp1},
+		{timestamp2.Unix(), timestamp2.Truncate(time.Second)},
+		{timestamp2.UnixNano() / int64(time.Millisecond), timestamp2.Truncate(time.Millisecond)},
+		{timestamp1.In(tzTest), timestamp1.In(tzTest)},
+		{timestamp1.Format("2006-01-02 15:04:05.000"), timestamp1},
+		{timestamp1.Format("2006-01-02T15:04:05.000"), timestamp1},
+		{timestamp1.Format("2006-01-02 15:04:05"), timestamp1},
+		{timestamp1.Format("2006-01-02T15:04:05"), timestamp1},
+		{timestamp2, timestamp2},
+		{"2006-01-02 15:04:05.123456789", timestamp2},
+		{"2006-01-02T15:04:05.123456789", timestamp2},
+		{"2006-01-02T05:51:05.123456789-09:13", timestamp2.In(tzTest)},
+		{"2012-11-04", timestamp3},
+		{"2012-11-04 00:00", timestamp3},
+		{"2012-11-04 00:00:00", timestamp3},
+		{"2012-11-04 00:00:00.000", timestamp3},
+		{"2012-11-04T00:00", timestamp3},
+		{"2012-11-04T00:00:00", timestamp3},
+		{"2012-11-04T00:00:00.000", timestamp3},
+		{"2006-01-02T15:04:05.123456789Z", timestamp2},
+		{"2012-11-04Z", timestamp3},
+		{"2012-11-04 00:00Z", timestamp3},
+		{"2012-11-04 00:00:00Z", timestamp3},
+		{"2012-11-04 00:00:00.000Z", timestamp3},
+		{"2012-11-04T00:00Z", timestamp3},
+		{"2012-11-04T00:00:00Z", timestamp3},
+		{"2012-11-04T00:00:00.000Z", timestamp3},
+	}
+	for i := range tests {
+		_, err = db.Exec("INSERT INTO foo(id, ts, dt) VALUES(?, ?, ?)", i, tests[i].value, tests[i].value)
+		if err != nil {
+			t.Fatal("Failed to insert timestamp:", err)
+		}
+	}
+
+	rows, err := db.Query("SELECT id, ts, dt FROM foo ORDER BY id ASC")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+	defer rows.Close()
+
+	seen := 0
+	for rows.Next() {
+		var id int
+		var ts, dt time.Time
+
+		if err := rows.Scan(&id, &ts, &dt); err != nil {
+			t.Error("Unable to scan results:", err)
+			continue
+		}
+		if id < 0 || id >= len(tests) {
+			t.Error("Bad row id: ", id)
+			continue
+		}
+		seen++
+		if !tests[id].expected.Equal(ts) {
+			t.Errorf("Timestamp value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
+		}
+		if !tests[id].expected.Equal(dt) {
+			t.Errorf("Datetime value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
+		}
+		if timezone(tests[id].expected) != timezone(ts) {
+			t.Errorf("Timezone for id %v (%v) should be %v, not %v", id, tests[id].value,
+				timezone(tests[id].expected), timezone(ts))
+		}
+		if timezone(tests[id].expected) != timezone(dt) {
+			t.Errorf("Timezone for id %v (%v) should be %v, not %v", id, tests[id].value,
+				timezone(tests[id].expected), timezone(dt))
+		}
+	}
+
+	if seen != len(tests) {
+		t.Errorf("Expected to see %d rows", len(tests))
+	}
+}
+
+func TestBoolean(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, fbool BOOLEAN)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	bool1 := true
+	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(1, ?)", bool1)
+	if err != nil {
+		t.Fatal("Failed to insert boolean:", err)
+	}
+
+	bool2 := false
+	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(2, ?)", bool2)
+	if err != nil {
+		t.Fatal("Failed to insert boolean:", err)
+	}
+
+	bool3 := "nonsense"
+	_, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(3, ?)", bool3)
+	if err != nil {
+		t.Fatal("Failed to insert nonsense:", err)
+	}
+
+	rows, err := db.Query("SELECT id, fbool FROM foo where fbool = ?", bool1)
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+	counter := 0
+
+	var id int
+	var fbool bool
+
+	for rows.Next() {
+		if err := rows.Scan(&id, &fbool); err != nil {
+			t.Fatal("Unable to scan results:", err)
+		}
+		counter++
+	}
+
+	if counter != 1 {
+		t.Fatalf("Expected 1 row but %v", counter)
+	}
+
+	if id != 1 && !fbool {
+		t.Fatalf("Value for id 1 should be %v, not %v", bool1, fbool)
+	}
+
+	rows, err = db.Query("SELECT id, fbool FROM foo where fbool = ?", bool2)
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	counter = 0
+
+	for rows.Next() {
+		if err := rows.Scan(&id, &fbool); err != nil {
+			t.Fatal("Unable to scan results:", err)
+		}
+		counter++
+	}
+
+	if counter != 1 {
+		t.Fatalf("Expected 1 row but %v", counter)
+	}
+
+	if id != 2 && fbool {
+		t.Fatalf("Value for id 2 should be %v, not %v", bool2, fbool)
+	}
+
+	// make sure "nonsense" triggered an error
+	rows, err = db.Query("SELECT id, fbool FROM foo where id=?;", 3)
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	rows.Next()
+	err = rows.Scan(&id, &fbool)
+	if err == nil {
+		t.Error("Expected error from \"nonsense\" bool")
+	}
+}
+
+func TestFloat32(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)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	_, err = db.Exec("INSERT INTO foo(id) VALUES(null)")
+	if err != nil {
+		t.Fatal("Failed to insert null:", err)
+	}
+
+	rows, err := db.Query("SELECT id FROM foo")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	if !rows.Next() {
+		t.Fatal("Unable to query results:", err)
+	}
+
+	var id any
+	if err := rows.Scan(&id); err != nil {
+		t.Fatal("Unable to scan results:", err)
+	}
+	if id != nil {
+		t.Error("Expected nil but not")
+	}
+}
+
+func TestNull(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()
+
+	rows, err := db.Query("SELECT 3.141592")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	if !rows.Next() {
+		t.Fatal("Unable to query results:", err)
+	}
+
+	var v any
+	if err := rows.Scan(&v); err != nil {
+		t.Fatal("Unable to scan results:", err)
+	}
+	f, ok := v.(float64)
+	if !ok {
+		t.Error("Expected float but not")
+	}
+	if f != 3.141592 {
+		t.Error("Expected 3.141592 but not")
+	}
+}
+
+func TestTransaction(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)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal("Failed to begin transaction:", err)
+	}
+
+	_, err = tx.Exec("INSERT INTO foo(id) VALUES(1)")
+	if err != nil {
+		t.Fatal("Failed to insert null:", err)
+	}
+
+	rows, err := tx.Query("SELECT id from foo")
+	if err != nil {
+		t.Fatal("Unable to query foo table:", err)
+	}
+
+	err = tx.Rollback()
+	if err != nil {
+		t.Fatal("Failed to rollback transaction:", err)
+	}
+
+	if rows.Next() {
+		t.Fatal("Unable to query results:", err)
+	}
+
+	tx, err = db.Begin()
+	if err != nil {
+		t.Fatal("Failed to begin transaction:", err)
+	}
+
+	_, err = tx.Exec("INSERT INTO foo(id) VALUES(1)")
+	if err != nil {
+		t.Fatal("Failed to insert null:", err)
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		t.Fatal("Failed to commit transaction:", err)
+	}
+
+	rows, err = tx.Query("SELECT id from foo")
+	if err == nil {
+		t.Fatal("Expected failure to query")
+	}
+}
+
+func TestWAL(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()
+
+	if _, err = db.Exec("PRAGMA journal_mode=WAL;"); err != nil {
+		t.Fatal("Failed to Exec PRAGMA journal_mode:", err)
+	}
+	if _, err = db.Exec("PRAGMA locking_mode=EXCLUSIVE;"); err != nil {
+		t.Fatal("Failed to Exec PRAGMA locking_mode:", err)
+	}
+	if _, err = db.Exec("CREATE TABLE test (id SERIAL, user TEXT NOT NULL, name TEXT NOT NULL);"); err != nil {
+		t.Fatal("Failed to Exec CREATE TABLE:", err)
+	}
+	if _, err = db.Exec("INSERT INTO test (user, name) VALUES ('user','name');"); err != nil {
+		t.Fatal("Failed to Exec INSERT:", err)
+	}
+
+	trans, err := db.Begin()
+	if err != nil {
+		t.Fatal("Failed to Begin:", err)
+	}
+	s, err := trans.Prepare("INSERT INTO test (user, name) VALUES (?, ?);")
+	if err != nil {
+		t.Fatal("Failed to Prepare:", err)
+	}
+
+	var count int
+	if err = trans.QueryRow("SELECT count(user) FROM test;").Scan(&count); err != nil {
+		t.Fatal("Failed to QueryRow:", err)
+	}
+	if _, err = s.Exec("bbbb", "aaaa"); err != nil {
+		t.Fatal("Failed to Exec prepared statement:", err)
+	}
+	if err = s.Close(); err != nil {
+		t.Fatal("Failed to Close prepared statement:", err)
+	}
+	if err = trans.Commit(); err != nil {
+		t.Fatal("Failed to Commit:", err)
+	}
+}
+
+func TestTimezoneConversion(t *testing.T) {
+	zones := []string{"UTC", "US/Central", "US/Pacific", "Local"}
+	for _, tz := range zones {
+		tempFilename := TempFilename(t)
+		defer os.Remove(tempFilename)
+		db, err := sql.Open("sqlite3", tempFilename+"?_loc="+url.QueryEscape(tz))
+		if err != nil {
+			t.Fatal("Failed to open database:", err)
+		}
+		defer db.Close()
+
+		_, err = db.Exec("DROP TABLE foo")
+		_, err = db.Exec("CREATE TABLE foo(id INTEGER, ts TIMESTAMP, dt DATETIME)")
+		if err != nil {
+			t.Fatal("Failed to create table:", err)
+		}
+
+		loc, err := time.LoadLocation(tz)
+		if err != nil {
+			t.Fatal("Failed to load location:", err)
+		}
+
+		timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
+		timestamp2 := time.Date(2006, time.January, 2, 15, 4, 5, 123456789, time.UTC)
+		timestamp3 := time.Date(2012, time.November, 4, 0, 0, 0, 0, time.UTC)
+		tests := []struct {
+			value    any
+			expected time.Time
+		}{
+			{"nonsense", time.Time{}.In(loc)},
+			{"0000-00-00 00:00:00", time.Time{}.In(loc)},
+			{timestamp1, timestamp1.In(loc)},
+			{timestamp1.Unix(), timestamp1.In(loc)},
+			{timestamp1.In(time.FixedZone("TEST", -7*3600)), timestamp1.In(loc)},
+			{timestamp1.Format("2006-01-02 15:04:05.000"), timestamp1.In(loc)},
+			{timestamp1.Format("2006-01-02T15:04:05.000"), timestamp1.In(loc)},
+			{timestamp1.Format("2006-01-02 15:04:05"), timestamp1.In(loc)},
+			{timestamp1.Format("2006-01-02T15:04:05"), timestamp1.In(loc)},
+			{timestamp2, timestamp2.In(loc)},
+			{"2006-01-02 15:04:05.123456789", timestamp2.In(loc)},
+			{"2006-01-02T15:04:05.123456789", timestamp2.In(loc)},
+			{"2012-11-04", timestamp3.In(loc)},
+			{"2012-11-04 00:00", timestamp3.In(loc)},
+			{"2012-11-04 00:00:00", timestamp3.In(loc)},
+			{"2012-11-04 00:00:00.000", timestamp3.In(loc)},
+			{"2012-11-04T00:00", timestamp3.In(loc)},
+			{"2012-11-04T00:00:00", timestamp3.In(loc)},
+			{"2012-11-04T00:00:00.000", timestamp3.In(loc)},
+		}
+		for i := range tests {
+			_, err = db.Exec("INSERT INTO foo(id, ts, dt) VALUES(?, ?, ?)", i, tests[i].value, tests[i].value)
+			if err != nil {
+				t.Fatal("Failed to insert timestamp:", err)
+			}
+		}
+
+		rows, err := db.Query("SELECT id, ts, dt FROM foo ORDER BY id ASC")
+		if err != nil {
+			t.Fatal("Unable to query foo table:", err)
+		}
+		defer rows.Close()
+
+		seen := 0
+		for rows.Next() {
+			var id int
+			var ts, dt time.Time
+
+			if err := rows.Scan(&id, &ts, &dt); err != nil {
+				t.Error("Unable to scan results:", err)
+				continue
+			}
+			if id < 0 || id >= len(tests) {
+				t.Error("Bad row id: ", id)
+				continue
+			}
+			seen++
+			if !tests[id].expected.Equal(ts) {
+				t.Errorf("Timestamp value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, ts)
+			}
+			if !tests[id].expected.Equal(dt) {
+				t.Errorf("Datetime value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
+			}
+			if tests[id].expected.Location().String() != ts.Location().String() {
+				t.Errorf("Location for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected.Location().String(), ts.Location().String())
+			}
+			if tests[id].expected.Location().String() != dt.Location().String() {
+				t.Errorf("Location for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected.Location().String(), dt.Location().String())
+			}
+		}
+
+		if seen != len(tests) {
+			t.Errorf("Expected to see %d rows", len(tests))
+		}
+	}
+}
+
+// TODO: Execer & Queryer currently disabled
+// https://github.com/mattn/go-sqlite3/issues/82
+func TestExecer(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); -- one comment
+       insert into foo(id) values(?);
+       insert into foo(id) values(?);
+       insert into foo(id) values(?); -- another comment
+       `, 1, 2, 3)
+	if err != nil {
+		t.Error("Failed to call db.Exec:", err)
+	}
+}
+
+func TestQueryer(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);
+	`)
+	if err != nil {
+		t.Error("Failed to call db.Query:", err)
+	}
+
+	_, err = db.Exec(`
+		insert into foo(id) values(?);
+		insert into foo(id) values(?);
+		insert into foo(id) values(?);
+	`, 3, 2, 1)
+	if err != nil {
+		t.Error("Failed to call db.Exec:", err)
+	}
+	rows, err := db.Query(`
+		select id from foo order by id;
+	`)
+	if err != nil {
+		t.Error("Failed to call db.Query:", err)
+	}
+	defer rows.Close()
+	n := 0
+	for rows.Next() {
+		var id int
+		err = rows.Scan(&id)
+		if err != nil {
+			t.Error("Failed to db.Query:", err)
+		}
+		if id != n+1 {
+			t.Error("Failed to db.Query: not matched results")
+		}
+		n = n + 1
+	}
+	if err := rows.Err(); err != nil {
+		t.Errorf("Post-scan failed: %v\n", err)
+	}
+	if n != 3 {
+		t.Errorf("Expected 3 rows but retrieved %v", n)
+	}
+}
+
+func TestStress(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)
+	}
+	db.Exec("CREATE TABLE foo (id int);")
+	db.Exec("INSERT INTO foo VALUES(1);")
+	db.Exec("INSERT INTO foo VALUES(2);")
+	db.Close()
+
+	for i := 0; i < 10000; i++ {
+		db, err := sql.Open("sqlite3", tempFilename)
+		if err != nil {
+			t.Fatal("Failed to open database:", err)
+		}
+
+		for j := 0; j < 3; j++ {
+			rows, err := db.Query("select * from foo where id=1;")
+			if err != nil {
+				t.Error("Failed to call db.Query:", err)
+			}
+			for rows.Next() {
+				var i int
+				if err := rows.Scan(&i); err != nil {
+					t.Errorf("Scan failed: %v\n", err)
+				}
+			}
+			if err := rows.Err(); err != nil {
+				t.Errorf("Post-scan failed: %v\n", err)
+			}
+			rows.Close()
+		}
+		db.Close()
+	}
+}
+
+func TestDateTimeLocal(t *testing.T) {
+	zone := "Asia/Tokyo"
+	tempFilename := TempFilename(t)
+	defer os.Remove(tempFilename)
+	db, err := sql.Open("sqlite3", tempFilename+"?_loc="+zone)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	db.Exec("CREATE TABLE foo (dt datetime);")
+	db.Exec("INSERT INTO foo VALUES('2015-03-05 15:16:17');")
+
+	row := db.QueryRow("select * from foo")
+	var d time.Time
+	err = row.Scan(&d)
+	if err != nil {
+		t.Fatal("Failed to scan datetime:", err)
+	}
+	if d.Hour() == 15 || !strings.Contains(d.String(), "JST") {
+		t.Fatal("Result should have timezone", d)
+	}
+	db.Close()
+
+	db, err = sql.Open("sqlite3", tempFilename)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+
+	row = db.QueryRow("select * from foo")
+	err = row.Scan(&d)
+	if err != nil {
+		t.Fatal("Failed to scan datetime:", err)
+	}
+	if d.UTC().Hour() != 15 || !strings.Contains(d.String(), "UTC") {
+		t.Fatalf("Result should not have timezone %v %v", zone, d.String())
+	}
+
+	_, err = db.Exec("DELETE FROM foo")
+	if err != nil {
+		t.Fatal("Failed to delete table:", err)
+	}
+	dt, err := time.Parse("2006/1/2 15/4/5 -0700 MST", "2015/3/5 15/16/17 +0900 JST")
+	if err != nil {
+		t.Fatal("Failed to parse datetime:", err)
+	}
+	db.Exec("INSERT INTO foo VALUES(?);", dt)
+
+	db.Close()
+	db, err = sql.Open("sqlite3", tempFilename+"?_loc="+zone)
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+
+	row = db.QueryRow("select * from foo")
+	err = row.Scan(&d)
+	if err != nil {
+		t.Fatal("Failed to scan datetime:", err)
+	}
+	if d.Hour() != 15 || !strings.Contains(d.String(), "JST") {
+		t.Fatalf("Result should have timezone %v %v", zone, d.String())
+	}
+}
+
+func TestVersion(t *testing.T) {
+	s, n, id := Version()
+	if s == "" || n == 0 || id == "" {
+		t.Errorf("Version failed %q, %d, %q\n", s, n, id)
+	}
+}
+
+func TestStringContainingZero(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, extra text);
+	`)
+	if err != nil {
+		t.Error("Failed to call db.Query:", err)
+	}
+
+	const text = "foo\x00bar"
+
+	_, err = db.Exec(`insert into foo(id, name, extra) values($1, $2, $2)`, 1, text)
+	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, text)
+	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 != text {
+		t.Error("Failed to db.QueryRow: not matched results")
+	}
+}
+
+const CurrentTimeStamp = "2006-01-02 15:04:05"
+
+type TimeStamp struct{ *time.Time }
+
+func (t TimeStamp) Scan(value any) error {
+	var err error
+	switch v := value.(type) {
+	case string:
+		*t.Time, err = time.Parse(CurrentTimeStamp, v)
+	case []byte:
+		*t.Time, err = time.Parse(CurrentTimeStamp, string(v))
+	default:
+		err = errors.New("invalid type for current_timestamp")
+	}
+	return err
+}
+
+func (t TimeStamp) Value() (driver.Value, error) {
+	return t.Time.Format(CurrentTimeStamp), nil
+}
+
+func TestDateTimeNow(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()
+
+	var d time.Time
+	err = db.QueryRow("SELECT datetime('now')").Scan(TimeStamp{&d})
+	if err != nil {
+		t.Fatal("Failed to scan datetime:", err)
+	}
+}
+
+func TestFunctionRegistration(t *testing.T) {
+	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) }
+	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)
+	}
+	generic := func(a any) int64 {
+		switch a.(type) {
+		case int64:
+			return 1
+		case float64:
+			return 2
+		case []byte:
+			return 3
+		case string:
+			return 4
+		default:
+			panic("unreachable")
+		}
+	}
+	variadic := func(a, b int64, c ...int64) int64 {
+		ret := a + b
+		for _, d := range c {
+			ret += d
+		}
+		return ret
+	}
+	variadicGeneric := func(a ...any) int64 {
+		return int64(len(a))
+	}
+
+	sql.Register("sqlite3_FunctionRegistration", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			if err := conn.RegisterFunc("addi8_16_32", addi8_16_32, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("addi64", addi64, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("addu8_16_32", addu8_16_32, true); err != nil {
+				return err
+			}
+			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("addf32_64", addf32_64, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("not", not, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("regex", regex, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("generic", generic, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("variadic", variadic, true); err != nil {
+				return err
+			}
+			if err := conn.RegisterFunc("variadicGeneric", variadicGeneric, true); err != nil {
+				return err
+			}
+			return nil
+		},
+	})
+	db, err := sql.Open("sqlite3_FunctionRegistration", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	ops := []struct {
+		query    string
+		expected any
+	}{
+		{"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 addf32_64(1.5,1.5)", float64(3)},
+		{"SELECT not(1)", false},
+		{"SELECT not(0)", true},
+		{`SELECT regex('^foo.*', 'foobar')`, true},
+		{`SELECT regex('^foo.*', 'barfoobar')`, false},
+		{"SELECT generic(1)", int64(1)},
+		{"SELECT generic(1.1)", int64(2)},
+		{`SELECT generic(NULL)`, int64(3)},
+		{`SELECT generic('foo')`, int64(4)},
+		{"SELECT variadic(1,2)", int64(3)},
+		{"SELECT variadic(1,2,3,4)", int64(10)},
+		{"SELECT variadic(1,1,1,1,1,1,1,1,1,1)", int64(10)},
+		{`SELECT variadicGeneric(1,'foo',2.3, NULL)`, int64(4)},
+	}
+
+	for _, op := range ops {
+		ret := reflect.New(reflect.TypeOf(op.expected))
+		err = db.QueryRow(op.query).Scan(ret.Interface())
+		if err != nil {
+			t.Errorf("Query %q failed: %s", op.query, err)
+		} else if !reflect.DeepEqual(ret.Elem().Interface(), op.expected) {
+			t.Errorf("Query %q returned wrong value: got %v (%T), want %v (%T)", op.query, ret.Elem().Interface(), ret.Elem().Interface(), op.expected, op.expected)
+		}
+	}
+}
+
+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 {
+			return conn.RegisterAggregator("customSum", customSum, true)
+		},
+	})
+	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)
+		}
+	}
+}
+
+type mode struct {
+	counts   map[any]int
+	top      any
+	topCount int
+}
+
+func newMode() *mode {
+	return &mode{
+		counts: map[any]int{},
+	}
+}
+
+func (m *mode) Step(x any) {
+	m.counts[x]++
+	c := m.counts[x]
+	if c > m.topCount {
+		m.top = x
+		m.topCount = c
+	}
+}
+
+func (m *mode) Done() any {
+	return m.top
+}
+
+func TestAggregatorRegistration_GenericReturn(t *testing.T) {
+	sql.Register("sqlite3_AggregatorRegistration_GenericReturn", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			return conn.RegisterAggregator("mode", newMode, true)
+		},
+	})
+	db, err := sql.Open("sqlite3_AggregatorRegistration_GenericReturn", ":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 {
+		t.Fatal("Failed to create table:", err)
+	}
+	_, err = db.Exec("insert into foo values (1, 10), (1, 20), (1, 45), (2, 42), (2, 115), (2, 20)")
+	if err != nil {
+		t.Fatal("Failed to insert records:", err)
+	}
+
+	var mode int
+	err = db.QueryRow("select mode(profits) from foo").Scan(&mode)
+	if err != nil {
+		t.Fatal("MODE query error:", err)
+	}
+
+	if mode != 20 {
+		t.Fatal("Got incorrect mode. Wanted 20, got: ", mode)
+	}
+}
+
+func rot13(r rune) rune {
+	switch {
+	case r >= 'A' && r <= 'Z':
+		return 'A' + (r-'A'+13)%26
+	case r >= 'a' && r <= 'z':
+		return 'a' + (r-'a'+13)%26
+	}
+	return r
+}
+
+func TestCollationRegistration(t *testing.T) {
+	collateRot13 := func(a, b string) int {
+		ra, rb := strings.Map(rot13, a), strings.Map(rot13, b)
+		return strings.Compare(ra, rb)
+	}
+	collateRot13Reverse := func(a, b string) int {
+		return collateRot13(b, a)
+	}
+
+	sql.Register("sqlite3_CollationRegistration", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			if err := conn.RegisterCollation("rot13", collateRot13); err != nil {
+				return err
+			}
+			if err := conn.RegisterCollation("rot13reverse", collateRot13Reverse); err != nil {
+				return err
+			}
+			return nil
+		},
+	})
+
+	db, err := sql.Open("sqlite3_CollationRegistration", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	populate := []string{
+		`CREATE TABLE test (s TEXT)`,
+		`INSERT INTO test VALUES ('aaaa')`,
+		`INSERT INTO test VALUES ('ffff')`,
+		`INSERT INTO test VALUES ('qqqq')`,
+		`INSERT INTO test VALUES ('tttt')`,
+		`INSERT INTO test VALUES ('zzzz')`,
+	}
+	for _, stmt := range populate {
+		if _, err := db.Exec(stmt); err != nil {
+			t.Fatal("Failed to populate test DB:", err)
+		}
+	}
+
+	ops := []struct {
+		query string
+		want  []string
+	}{
+		{
+			"SELECT * FROM test ORDER BY s COLLATE rot13 ASC",
+			[]string{
+				"qqqq",
+				"tttt",
+				"zzzz",
+				"aaaa",
+				"ffff",
+			},
+		},
+		{
+			"SELECT * FROM test ORDER BY s COLLATE rot13 DESC",
+			[]string{
+				"ffff",
+				"aaaa",
+				"zzzz",
+				"tttt",
+				"qqqq",
+			},
+		},
+		{
+			"SELECT * FROM test ORDER BY s COLLATE rot13reverse ASC",
+			[]string{
+				"ffff",
+				"aaaa",
+				"zzzz",
+				"tttt",
+				"qqqq",
+			},
+		},
+		{
+			"SELECT * FROM test ORDER BY s COLLATE rot13reverse DESC",
+			[]string{
+				"qqqq",
+				"tttt",
+				"zzzz",
+				"aaaa",
+				"ffff",
+			},
+		},
+	}
+
+	for _, op := range ops {
+		rows, err := db.Query(op.query)
+		if err != nil {
+			t.Fatalf("Query %q failed: %s", op.query, err)
+		}
+		got := []string{}
+		defer rows.Close()
+		for rows.Next() {
+			var s string
+			if err = rows.Scan(&s); err != nil {
+				t.Fatalf("Reading row for %q: %s", op.query, err)
+			}
+			got = append(got, s)
+		}
+		if err = rows.Err(); err != nil {
+			t.Fatalf("Reading rows for %q: %s", op.query, err)
+		}
+
+		if !reflect.DeepEqual(got, op.want) {
+			t.Fatalf("Unexpected output from %q\ngot:\n%s\n\nwant:\n%s", op.query, strings.Join(got, "\n"), strings.Join(op.want, "\n"))
+		}
+	}
+}
+
+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)
+	}
+}
+
+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")
+	}
+}
+
+func TestUpdateAndTransactionHooks(t *testing.T) {
+	var events []string
+	var commitHookReturn = 0
+
+	sql.Register("sqlite3_UpdateHook", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			conn.RegisterCommitHook(func() int {
+				events = append(events, "commit")
+				return commitHookReturn
+			})
+			conn.RegisterRollbackHook(func() {
+				events = append(events, "rollback")
+			})
+			conn.RegisterUpdateHook(func(op int, db string, table string, rowid int64) {
+				events = append(events, fmt.Sprintf("update(op=%v db=%v table=%v rowid=%v)", op, db, table, rowid))
+			})
+			return nil
+		},
+	})
+	db, err := sql.Open("sqlite3_UpdateHook", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	statements := []string{
+		"create table foo (id integer primary key)",
+		"insert into foo values (9)",
+		"update foo set id = 99 where id = 9",
+		"delete from foo where id = 99",
+	}
+	for _, statement := range statements {
+		_, err = db.Exec(statement)
+		if err != nil {
+			t.Fatalf("Unable to prepare test data [%v]: %v", statement, err)
+		}
+	}
+
+	commitHookReturn = 1
+	_, err = db.Exec("insert into foo values (5)")
+	if err == nil {
+		t.Error("Commit hook failed to rollback transaction")
+	}
+
+	var expected = []string{
+		"commit",
+		fmt.Sprintf("update(op=%v db=main table=foo rowid=9)", SQLITE_INSERT),
+		"commit",
+		fmt.Sprintf("update(op=%v db=main table=foo rowid=99)", SQLITE_UPDATE),
+		"commit",
+		fmt.Sprintf("update(op=%v db=main table=foo rowid=99)", SQLITE_DELETE),
+		"commit",
+		fmt.Sprintf("update(op=%v db=main table=foo rowid=5)", SQLITE_INSERT),
+		"commit",
+		"rollback",
+	}
+	if !reflect.DeepEqual(events, expected) {
+		t.Errorf("Expected notifications %v but got %v", expected, events)
+	}
+}
+
+func TestAuthorizer(t *testing.T) {
+	var authorizerReturn = 0
+
+	sql.Register("sqlite3_Authorizer", &SQLiteDriver{
+		ConnectHook: func(conn *SQLiteConn) error {
+			conn.RegisterAuthorizer(func(op int, arg1, arg2, arg3 string) int {
+				return authorizerReturn
+			})
+			return nil
+		},
+	})
+	db, err := sql.Open("sqlite3_Authorizer", ":memory:")
+	if err != nil {
+		t.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	statements := []string{
+		"create table foo (id integer primary key, name varchar)",
+		"insert into foo values (9, 'test9')",
+		"update foo set name = 'test99' where id = 9",
+		"select * from foo",
+	}
+
+	authorizerReturn = SQLITE_OK
+	for _, statement := range statements {
+		_, err = db.Exec(statement)
+		if err != nil {
+			t.Fatalf("No error expected [%v]: %v", statement, err)
+		}
+	}
+
+	authorizerReturn = SQLITE_DENY
+	for _, statement := range statements {
+		_, err = db.Exec(statement)
+		if err == nil {
+			t.Fatalf("Authorizer didn't worked - nil received, but error expected: [%v]", statement)
+		}
+	}
+}
+
+func TestSetFileControlInt(t *testing.T) {
+	t.Run("PERSIST_WAL", func(t *testing.T) {
+		tempFilename := TempFilename(t)
+		defer os.Remove(tempFilename)
+
+		sql.Register("sqlite3_FCNTL_PERSIST_WAL", &SQLiteDriver{
+			ConnectHook: func(conn *SQLiteConn) error {
+				if err := conn.SetFileControlInt("", SQLITE_FCNTL_PERSIST_WAL, 1); err != nil {
+					return fmt.Errorf("Unexpected error from SetFileControlInt(): %w", err)
+				}
+				return nil
+			},
+		})
+
+		db, err := sql.Open("sqlite3_FCNTL_PERSIST_WAL", tempFilename)
+		if err != nil {
+			t.Fatal("Failed to open database:", err)
+		}
+		defer db.Close()
+
+		// Set to WAL mode & write a page.
+		if _, err := db.Exec(`PRAGMA journal_mode = wal`); err != nil {
+			t.Fatal("Failed to set journal mode:", err)
+		} else if _, err := db.Exec(`CREATE TABLE t (x)`); err != nil {
+			t.Fatal("Failed to create table:", err)
+		}
+		if err := db.Close(); err != nil {
+			t.Fatal("Failed to close database", err)
+		}
+
+		// Ensure WAL file persists after close.
+		if _, err := os.Stat(tempFilename + "-wal"); err != nil {
+			t.Fatal("Expected WAL file to be persisted after close", err)
+		}
+	})
+}
+
+func TestNonColumnString(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var x any
+	if err := db.QueryRow("SELECT 'hello'").Scan(&x); err != nil {
+		t.Fatal(err)
+	}
+	s, ok := x.(string)
+	if !ok {
+		t.Fatalf("non-column string must return string but got %T", x)
+	}
+	if s != "hello" {
+		t.Fatalf("non-column string must return %q but got %q", "hello", s)
+	}
+}
+
+func TestNilAndEmptyBytes(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	actualNil := []byte("use this to use an actual nil not a reference to nil")
+	emptyBytes := []byte{}
+	for tsti, tst := range []struct {
+		name          string
+		columnType    string
+		insertBytes   []byte
+		expectedBytes []byte
+	}{
+		{"actual nil blob", "blob", actualNil, nil},
+		{"referenced nil blob", "blob", nil, nil},
+		{"empty blob", "blob", emptyBytes, emptyBytes},
+		{"actual nil text", "text", actualNil, nil},
+		{"referenced nil text", "text", nil, nil},
+		{"empty text", "text", emptyBytes, emptyBytes},
+	} {
+		if _, err = db.Exec(fmt.Sprintf("create table tbl%d (txt %s)", tsti, tst.columnType)); err != nil {
+			t.Fatal(tst.name, err)
+		}
+		if bytes.Equal(tst.insertBytes, actualNil) {
+			if _, err = db.Exec(fmt.Sprintf("insert into tbl%d (txt) values (?)", tsti), nil); err != nil {
+				t.Fatal(tst.name, err)
+			}
+		} else {
+			if _, err = db.Exec(fmt.Sprintf("insert into tbl%d (txt) values (?)", tsti), &tst.insertBytes); err != nil {
+				t.Fatal(tst.name, err)
+			}
+		}
+		rows, err := db.Query(fmt.Sprintf("select txt from tbl%d", tsti))
+		if err != nil {
+			t.Fatal(tst.name, err)
+		}
+		if !rows.Next() {
+			t.Fatal(tst.name, "no rows")
+		}
+		var scanBytes []byte
+		if err = rows.Scan(&scanBytes); err != nil {
+			t.Fatal(tst.name, err)
+		}
+		if err = rows.Err(); err != nil {
+			t.Fatal(tst.name, err)
+		}
+		if tst.expectedBytes == nil && scanBytes != nil {
+			t.Errorf("%s: %#v != %#v", tst.name, scanBytes, tst.expectedBytes)
+		} else if !bytes.Equal(scanBytes, tst.expectedBytes) {
+			t.Errorf("%s: %#v != %#v", tst.name, scanBytes, tst.expectedBytes)
+		}
+	}
+}
+
+func TestInsertNilByteSlice(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if _, err := db.Exec("create table blob_not_null (b blob not null)"); err != nil {
+		t.Fatal(err)
+	}
+	var nilSlice []byte
+	if _, err := db.Exec("insert into blob_not_null (b) values (?)", nilSlice); err == nil {
+		t.Fatal("didn't expect INSERT to 'not null' column with a nil []byte slice to work")
+	}
+	zeroLenSlice := []byte{}
+	if _, err := db.Exec("insert into blob_not_null (b) values (?)", zeroLenSlice); err != nil {
+		t.Fatal("failed to insert zero-length slice")
+	}
+}
+
+func TestNamedParam(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("drop table foo")
+	_, err = db.Exec("create table foo (id integer, name text, amount integer)")
+	if err != nil {
+		t.Fatal("Failed to create table:", err)
+	}
+
+	_, err = db.Exec("insert into foo(id, name, amount) values(:id, @name, $amount)",
+		sql.Named("bar", 42), sql.Named("baz", "quux"),
+		sql.Named("amount", 123), sql.Named("corge", "waldo"),
+		sql.Named("id", 2), sql.Named("name", "grault"))
+	if err != nil {
+		t.Fatal("Failed to insert record with named parameters:", err)
+	}
+
+	rows, err := db.Query("select id, name, amount from foo")
+	if err != nil {
+		t.Fatal("Failed to select records:", err)
+	}
+	defer rows.Close()
+
+	rows.Next()
+
+	var id, amount int
+	var name string
+	rows.Scan(&id, &name, &amount)
+	if id != 2 || name != "grault" || amount != 123 {
+		t.Errorf("Expected %d, %q, %d for fetched result, but got %d, %q, %d:", 2, "grault", 123, id, name, amount)
+	}
+}
+
+var customFunctionOnce sync.Once
+
+func BenchmarkCustomFunctions(b *testing.B) {
+	customFunctionOnce.Do(func() {
+		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.
+				return conn.RegisterFunc("custom_add", customAdd, false)
+			},
+		})
+	})
+
+	db, err := sql.Open("sqlite3_BenchmarkCustomFunctions", ":memory:")
+	if err != nil {
+		b.Fatal("Failed to open database:", err)
+	}
+	defer db.Close()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var i int64
+		err = db.QueryRow("SELECT custom_add(1,2)").Scan(&i)
+		if err != nil {
+			b.Fatal("Failed to run custom add:", err)
+		}
+	}
+}
+
+func TestSuite(t *testing.T) {
+	initializeTestDB(t)
+	defer freeTestDB()
+
+	for _, test := range tests {
+		t.Run(test.Name, test.F)
+	}
+}
+
+func BenchmarkSuite(b *testing.B) {
+	initializeTestDB(b)
+	defer freeTestDB()
+
+	for _, benchmark := range benchmarks {
+		b.Run(benchmark.Name, benchmark.F)
+	}
+}
+
+// Dialect is a type of dialect of databases.
+type Dialect int
+
+// Dialects for databases.
+const (
+	SQLITE     Dialect = iota // SQLITE mean SQLite3 dialect
+	POSTGRESQL                // POSTGRESQL mean PostgreSQL dialect
+	MYSQL                     // MYSQL mean MySQL dialect
+)
+
+// DB provide context for the tests
+type TestDB struct {
+	testing.TB
+	*sql.DB
+	dialect      Dialect
+	once         sync.Once
+	tempFilename string
+}
+
+var db *TestDB
+
+func initializeTestDB(t testing.TB) {
+	tempFilename := TempFilename(t)
+	d, err := sql.Open("sqlite3", tempFilename+"?_busy_timeout=99999")
+	if err != nil {
+		os.Remove(tempFilename)
+		t.Fatal(err)
+	}
+
+	db = &TestDB{t, d, SQLITE, sync.Once{}, tempFilename}
+}
+
+func freeTestDB() {
+	err := db.DB.Close()
+	if err != nil {
+		panic(err)
+	}
+	err = os.Remove(db.tempFilename)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// the following tables will be created and dropped during the test
+var testTables = []string{"foo", "bar", "t", "bench"}
+
+var tests = []testing.InternalTest{
+	{Name: "TestResult", F: testResult},
+	{Name: "TestBlobs", F: testBlobs},
+	{Name: "TestMultiBlobs", F: testMultiBlobs},
+	{Name: "TestNullZeroLengthBlobs", F: testNullZeroLengthBlobs},
+	{Name: "TestManyQueryRow", F: testManyQueryRow},
+	{Name: "TestTxQuery", F: testTxQuery},
+	{Name: "TestPreparedStmt", F: testPreparedStmt},
+	{Name: "TestExecEmptyQuery", F: testExecEmptyQuery},
+}
+
+var benchmarks = []testing.InternalBenchmark{
+	{Name: "BenchmarkExec", F: benchmarkExec},
+	{Name: "BenchmarkQuery", F: benchmarkQuery},
+	{Name: "BenchmarkParams", F: benchmarkParams},
+	{Name: "BenchmarkStmt", F: benchmarkStmt},
+	{Name: "BenchmarkRows", F: benchmarkRows},
+	{Name: "BenchmarkStmtRows", F: benchmarkStmtRows},
+}
+
+func (db *TestDB) mustExec(sql string, args ...any) sql.Result {
+	res, err := db.Exec(sql, args...)
+	if err != nil {
+		db.Fatalf("Error running %q: %v", sql, err)
+	}
+	return res
+}
+
+func (db *TestDB) tearDown() {
+	for _, tbl := range testTables {
+		switch db.dialect {
+		case SQLITE:
+			db.mustExec("drop table if exists " + tbl)
+		case MYSQL, POSTGRESQL:
+			db.mustExec("drop table if exists " + tbl)
+		default:
+			db.Fatal("unknown dialect")
+		}
+	}
+}
+
+// q replaces ? parameters if needed
+func (db *TestDB) q(sql string) string {
+	switch db.dialect {
+	case POSTGRESQL: // replace with $1, $2, ..
+		qrx := regexp.MustCompile(`\?`)
+		n := 0
+		return qrx.ReplaceAllStringFunc(sql, func(string) string {
+			n++
+			return "$" + strconv.Itoa(n)
+		})
+	}
+	return sql
+}
+
+func (db *TestDB) blobType(size int) string {
+	switch db.dialect {
+	case SQLITE:
+		return fmt.Sprintf("blob[%d]", size)
+	case POSTGRESQL:
+		return "bytea"
+	case MYSQL:
+		return fmt.Sprintf("VARBINARY(%d)", size)
+	}
+	panic("unknown dialect")
+}
+
+func (db *TestDB) serialPK() string {
+	switch db.dialect {
+	case SQLITE:
+		return "integer primary key autoincrement"
+	case POSTGRESQL:
+		return "serial primary key"
+	case MYSQL:
+		return "integer primary key auto_increment"
+	}
+	panic("unknown dialect")
+}
+
+func (db *TestDB) now() string {
+	switch db.dialect {
+	case SQLITE:
+		return "datetime('now')"
+	case POSTGRESQL:
+		return "now()"
+	case MYSQL:
+		return "now()"
+	}
+	panic("unknown dialect")
+}
+
+func makeBench() {
+	if _, err := db.Exec("create table bench (n varchar(32), i integer, d double, s varchar(32), t datetime)"); err != nil {
+		panic(err)
+	}
+	st, err := db.Prepare("insert into bench values (?, ?, ?, ?, ?)")
+	if err != nil {
+		panic(err)
+	}
+	defer st.Close()
+	for i := 0; i < 100; i++ {
+		if _, err = st.Exec(nil, i, float64(i), fmt.Sprintf("%d", i), time.Now()); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// testResult is test for result
+func testResult(t *testing.T) {
+	db.tearDown()
+	db.mustExec("create temporary table test (id " + db.serialPK() + ", name varchar(10))")
+
+	for i := 1; i < 3; i++ {
+		r := db.mustExec(db.q("insert into test (name) values (?)"), fmt.Sprintf("row %d", i))
+		n, err := r.RowsAffected()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if n != 1 {
+			t.Errorf("got %v, want %v", n, 1)
+		}
+		n, err = r.LastInsertId()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if n != int64(i) {
+			t.Errorf("got %v, want %v", n, i)
+		}
+	}
+	if _, err := db.Exec("error!"); err == nil {
+		t.Fatalf("expected error")
+	}
+}
+
+// testBlobs is test for blobs
+func testBlobs(t *testing.T) {
+	db.tearDown()
+	var blob = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	db.mustExec("create table foo (id integer primary key, bar " + db.blobType(16) + ")")
+	db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 0, blob)
+
+	want := fmt.Sprintf("%x", blob)
+
+	b := make([]byte, 16)
+	err := db.QueryRow(db.q("select bar from foo where id = ?"), 0).Scan(&b)
+	got := fmt.Sprintf("%x", b)
+	if err != nil {
+		t.Errorf("[]byte scan: %v", err)
+	} else if got != want {
+		t.Errorf("for []byte, got %q; want %q", got, want)
+	}
+
+	err = db.QueryRow(db.q("select bar from foo where id = ?"), 0).Scan(&got)
+	want = string(blob)
+	if err != nil {
+		t.Errorf("string scan: %v", err)
+	} else if got != want {
+		t.Errorf("for string, got %q; want %q", got, want)
+	}
+}
+
+func testMultiBlobs(t *testing.T) {
+	db.tearDown()
+	db.mustExec("create table foo (id integer primary key, bar " + db.blobType(16) + ")")
+	var blob0 = []byte{0, 1, 2, 3, 4, 5, 6, 7}
+	db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 0, blob0)
+	var blob1 = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 1, blob1)
+
+	r, err := db.Query(db.q("select bar from foo order by id"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer r.Close()
+	if !r.Next() {
+		if r.Err() != nil {
+			t.Fatal(err)
+		}
+		t.Fatal("expected one rows")
+	}
+
+	want0 := fmt.Sprintf("%x", blob0)
+	b0 := make([]byte, 8)
+	err = r.Scan(&b0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got0 := fmt.Sprintf("%x", b0)
+
+	if !r.Next() {
+		if r.Err() != nil {
+			t.Fatal(err)
+		}
+		t.Fatal("expected one rows")
+	}
+
+	want1 := fmt.Sprintf("%x", blob1)
+	b1 := make([]byte, 16)
+	err = r.Scan(&b1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got1 := fmt.Sprintf("%x", b1)
+	if got0 != want0 {
+		t.Errorf("for []byte, got %q; want %q", got0, want0)
+	}
+	if got1 != want1 {
+		t.Errorf("for []byte, got %q; want %q", got1, want1)
+	}
+}
+
+// testBlobs tests that we distinguish between null and zero-length blobs
+func testNullZeroLengthBlobs(t *testing.T) {
+	db.tearDown()
+	db.mustExec("create table foo (id integer primary key, bar " + db.blobType(16) + ")")
+	db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 0, nil)
+	db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 1, []byte{})
+
+	r0 := db.QueryRow(db.q("select bar from foo where id=0"))
+	var b0 []byte
+	err := r0.Scan(&b0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b0 != nil {
+		t.Errorf("for id=0, got %x; want nil", b0)
+	}
+
+	r1 := db.QueryRow(db.q("select bar from foo where id=1"))
+	var b1 []byte
+	err = r1.Scan(&b1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if b1 == nil {
+		t.Error("for id=1, got nil; want zero-length slice")
+	} else if len(b1) > 0 {
+		t.Errorf("for id=1, got %x; want zero-length slice", b1)
+	}
+}
+
+// testManyQueryRow is test for many query row
+func testManyQueryRow(t *testing.T) {
+	if testing.Short() {
+		t.Log("skipping in short mode")
+		return
+	}
+	db.tearDown()
+	db.mustExec("create table foo (id integer primary key, name varchar(50))")
+	db.mustExec(db.q("insert into foo (id, name) values(?,?)"), 1, "bob")
+	var name string
+	for i := 0; i < 10000; i++ {
+		err := db.QueryRow(db.q("select name from foo where id = ?"), 1).Scan(&name)
+		if err != nil || name != "bob" {
+			t.Fatalf("on query %d: err=%v, name=%q", i, err, name)
+		}
+	}
+}
+
+// testTxQuery is test for transactional query
+func testTxQuery(t *testing.T) {
+	db.tearDown()
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tx.Rollback()
+
+	_, err = tx.Exec("create table foo (id integer primary key, name varchar(50))")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = tx.Exec(db.q("insert into foo (id, name) values(?,?)"), 1, "bob")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	r, err := tx.Query(db.q("select name from foo where id = ?"), 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer r.Close()
+
+	if !r.Next() {
+		if r.Err() != nil {
+			t.Fatal(err)
+		}
+		t.Fatal("expected one rows")
+	}
+
+	var name string
+	err = r.Scan(&name)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+// testPreparedStmt is test for prepared statement
+func testPreparedStmt(t *testing.T) {
+	db.tearDown()
+	db.mustExec("CREATE TABLE t (count INT)")
+	sel, err := db.Prepare("SELECT count FROM t ORDER BY count DESC")
+	if err != nil {
+		t.Fatalf("prepare 1: %v", err)
+	}
+	ins, err := db.Prepare(db.q("INSERT INTO t (count) VALUES (?)"))
+	if err != nil {
+		t.Fatalf("prepare 2: %v", err)
+	}
+
+	for n := 1; n <= 3; n++ {
+		if _, err := ins.Exec(n); err != nil {
+			t.Fatalf("insert(%d) = %v", n, err)
+		}
+	}
+
+	const nRuns = 10
+	var wg sync.WaitGroup
+	for i := 0; i < nRuns; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 10; j++ {
+				count := 0
+				if err := sel.QueryRow().Scan(&count); err != nil && err != sql.ErrNoRows {
+					t.Errorf("Query: %v", err)
+					return
+				}
+				if _, err := ins.Exec(rand.Intn(100)); err != nil {
+					t.Errorf("Insert: %v", err)
+					return
+				}
+			}
+		}()
+	}
+	wg.Wait()
+}
+
+// testEmptyQuery is test for validating the API in case of empty query
+func testExecEmptyQuery(t *testing.T) {
+	db.tearDown()
+	res, err := db.Exec(" -- this is just a comment ")
+	if err != nil {
+		t.Fatalf("empty query err: %v", err)
+	}
+
+	_, err = res.LastInsertId()
+	if err != nil {
+		t.Fatalf("LastInsertId returned an error: %v", err)
+	}
+
+	_, err = res.RowsAffected()
+	if err != nil {
+		t.Fatalf("RowsAffected returned an error: %v", err)
+	}
+}
+
+// Benchmarks need to use panic() since b.Error errors are lost when
+// running via testing.Benchmark() I would like to run these via go
+// test -bench but calling Benchmark() from a benchmark test
+// currently hangs go.
+
+// benchmarkExec is benchmark for exec
+func benchmarkExec(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		if _, err := db.Exec("select 1"); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// benchmarkQuery is benchmark for query
+func benchmarkQuery(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var n sql.NullString
+		var i int
+		var f float64
+		var s string
+		//		var t time.Time
+		if err := db.QueryRow("select null, 1, 1.1, 'foo'").Scan(&n, &i, &f, &s); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// benchmarkParams is benchmark for params
+func benchmarkParams(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var n sql.NullString
+		var i int
+		var f float64
+		var s string
+		//		var t time.Time
+		if err := db.QueryRow("select ?, ?, ?, ?", nil, 1, 1.1, "foo").Scan(&n, &i, &f, &s); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// benchmarkStmt is benchmark for statement
+func benchmarkStmt(b *testing.B) {
+	st, err := db.Prepare("select ?, ?, ?, ?")
+	if err != nil {
+		panic(err)
+	}
+	defer st.Close()
+
+	for n := 0; n < b.N; n++ {
+		var n sql.NullString
+		var i int
+		var f float64
+		var s string
+		//		var t time.Time
+		if err := st.QueryRow(nil, 1, 1.1, "foo").Scan(&n, &i, &f, &s); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// benchmarkRows is benchmark for rows
+func benchmarkRows(b *testing.B) {
+	db.once.Do(makeBench)
+
+	for n := 0; n < b.N; n++ {
+		var n sql.NullString
+		var i int
+		var f float64
+		var s string
+		var t time.Time
+		r, err := db.Query("select * from bench")
+		if err != nil {
+			panic(err)
+		}
+		for r.Next() {
+			if err = r.Scan(&n, &i, &f, &s, &t); err != nil {
+				panic(err)
+			}
+		}
+		if err = r.Err(); err != nil {
+			panic(err)
+		}
+	}
+}
+
+// benchmarkStmtRows is benchmark for statement rows
+func benchmarkStmtRows(b *testing.B) {
+	db.once.Do(makeBench)
+
+	st, err := db.Prepare("select * from bench")
+	if err != nil {
+		panic(err)
+	}
+	defer st.Close()
+
+	for n := 0; n < b.N; n++ {
+		var n sql.NullString
+		var i int
+		var f float64
+		var s string
+		var t time.Time
+		r, err := st.Query()
+		if err != nil {
+			panic(err)
+		}
+		for r.Next() {
+			if err = r.Scan(&n, &i, &f, &s, &t); err != nil {
+				panic(err)
+			}
+		}
+		if err = r.Err(); err != nil {
+			panic(err)
+		}
+	}
+}
+
+
 func MainTest() {
+	fmt.Println("working binary")
 }